Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/*! This file is auto-generated */ +var twemoji=function(){"use strict";var h={base:"https://cdn.jsdelivr.net/gh/jdecked/twemoji@15.0.3/assets/",ext:".png",size:"72x72",className:"emoji",convert:{fromCodePoint:function(d){d="string"==typeof d?parseInt(d,16):d;if(d<65536)return e(d);return e(55296+((d-=65536)>>10),56320+(1023&d))},toCodePoint:o},onerror:function(){this.parentNode&&this.parentNode.replaceChild(x(this.alt,!1),this)},parse:function(d,u){u&&"function"!=typeof u||(u={callback:u});return h.doNotParse=u.doNotParse,("string"==typeof d?function(d,a){return n(d,function(d){var u,f,c=d,e=N(d),b=a.callback(e,a);if(e&&b){for(f in c="
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define('underscore', factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () { + var current = global._; + var exports = global._ = factory(); + exports.noConflict = function () { global._ = current; return exports; }; + }())); +}(this, (function () { + // Underscore.js 1.13.6 + // https://underscorejs.org + // (c) 2009-2022 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors + // Underscore may be freely distributed under the MIT license. + + // Current version. + var VERSION = '1.13.6'; + + // Establish the root object, `window` (`self`) in the browser, `global` + // on the server, or `this` in some virtual machines. We use `self` + // instead of `window` for `WebWorker` support. + var root = (typeof self == 'object' && self.self === self && self) || + (typeof global == 'object' && global.global === global && global) || + Function('return this')() || + {}; + + // Save bytes in the minified (but not gzipped) version: + var ArrayProto = Array.prototype, ObjProto = Object.prototype; + var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null; + + // Create quick reference variables for speed access to core prototypes. + var push = ArrayProto.push, + slice = ArrayProto.slice, + toString = ObjProto.toString, + hasOwnProperty = ObjProto.hasOwnProperty; + + // Modern feature detection. + var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined', + supportsDataView = typeof DataView !== 'undefined'; + + // All **ECMAScript 5+** native function implementations that we hope to use + // are declared here. + var nativeIsArray = Array.isArray, + nativeKeys = Object.keys, + nativeCreate = Object.create, + nativeIsView = supportsArrayBuffer && ArrayBuffer.isView; + + // Create references to these builtin functions because we override them. + var _isNaN = isNaN, + _isFinite = isFinite; + + // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed. + var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString'); + var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', + 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; + + // The largest integer that can be represented exactly. + var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1; + + // Some functions take a variable number of arguments, or a few expected + // arguments at the beginning and then a variable number of values to operate + // on. This helper accumulates all remaining arguments past the function’s + // argument length (or an explicit `startIndex`), into an array that becomes + // the last argument. Similar to ES6’s "rest parameter". + function restArguments(func, startIndex) { + startIndex = startIndex == null ? func.length - 1 : +startIndex; + return function() { + var length = Math.max(arguments.length - startIndex, 0), + rest = Array(length), + index = 0; + for (; index < length; index++) { + rest[index] = arguments[index + startIndex]; + } + switch (startIndex) { + case 0: return func.call(this, rest); + case 1: return func.call(this, arguments[0], rest); + case 2: return func.call(this, arguments[0], arguments[1], rest); + } + var args = Array(startIndex + 1); + for (index = 0; index < startIndex; index++) { + args[index] = arguments[index]; + } + args[startIndex] = rest; + return func.apply(this, args); + }; + } + + // Is a given variable an object? + function isObject(obj) { + var type = typeof obj; + return type === 'function' || (type === 'object' && !!obj); + } + + // Is a given value equal to null? + function isNull(obj) { + return obj === null; + } + + // Is a given variable undefined? + function isUndefined(obj) { + return obj === void 0; + } + + // Is a given value a boolean? + function isBoolean(obj) { + return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; + } + + // Is a given value a DOM element? + function isElement(obj) { + return !!(obj && obj.nodeType === 1); + } + + // Internal function for creating a `toString`-based type tester. + function tagTester(name) { + var tag = '[object ' + name + ']'; + return function(obj) { + return toString.call(obj) === tag; + }; + } + + var isString = tagTester('String'); + + var isNumber = tagTester('Number'); + + var isDate = tagTester('Date'); + + var isRegExp = tagTester('RegExp'); + + var isError = tagTester('Error'); + + var isSymbol = tagTester('Symbol'); + + var isArrayBuffer = tagTester('ArrayBuffer'); + + var isFunction = tagTester('Function'); + + // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old + // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236). + var nodelist = root.document && root.document.childNodes; + if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') { + isFunction = function(obj) { + return typeof obj == 'function' || false; + }; + } + + var isFunction$1 = isFunction; + + var hasObjectTag = tagTester('Object'); + + // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`. + // In IE 11, the most common among them, this problem also applies to + // `Map`, `WeakMap` and `Set`. + var hasStringTagBug = ( + supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8))) + ), + isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map)); + + var isDataView = tagTester('DataView'); + + // In IE 10 - Edge 13, we need a different heuristic + // to determine whether an object is a `DataView`. + function ie10IsDataView(obj) { + return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer); + } + + var isDataView$1 = (hasStringTagBug ? ie10IsDataView : isDataView); + + // Is a given value an array? + // Delegates to ECMA5's native `Array.isArray`. + var isArray = nativeIsArray || tagTester('Array'); + + // Internal function to check whether `key` is an own property name of `obj`. + function has$1(obj, key) { + return obj != null && hasOwnProperty.call(obj, key); + } + + var isArguments = tagTester('Arguments'); + + // Define a fallback version of the method in browsers (ahem, IE < 9), where + // there isn't any inspectable "Arguments" type. + (function() { + if (!isArguments(arguments)) { + isArguments = function(obj) { + return has$1(obj, 'callee'); + }; + } + }()); + + var isArguments$1 = isArguments; + + // Is a given object a finite number? + function isFinite$1(obj) { + return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj)); + } + + // Is the given value `NaN`? + function isNaN$1(obj) { + return isNumber(obj) && _isNaN(obj); + } + + // Predicate-generating function. Often useful outside of Underscore. + function constant(value) { + return function() { + return value; + }; + } + + // Common internal logic for `isArrayLike` and `isBufferLike`. + function createSizePropertyCheck(getSizeProperty) { + return function(collection) { + var sizeProperty = getSizeProperty(collection); + return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX; + } + } + + // Internal helper to generate a function to obtain property `key` from `obj`. + function shallowProperty(key) { + return function(obj) { + return obj == null ? void 0 : obj[key]; + }; + } + + // Internal helper to obtain the `byteLength` property of an object. + var getByteLength = shallowProperty('byteLength'); + + // Internal helper to determine whether we should spend extensive checks against + // `ArrayBuffer` et al. + var isBufferLike = createSizePropertyCheck(getByteLength); + + // Is a given value a typed array? + var typedArrayPattern = /\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/; + function isTypedArray(obj) { + // `ArrayBuffer.isView` is the most future-proof, so use it when available. + // Otherwise, fall back on the above regular expression. + return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) : + isBufferLike(obj) && typedArrayPattern.test(toString.call(obj)); + } + + var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false); + + // Internal helper to obtain the `length` property of an object. + var getLength = shallowProperty('length'); + + // Internal helper to create a simple lookup structure. + // `collectNonEnumProps` used to depend on `_.contains`, but this led to + // circular imports. `emulatedSet` is a one-off solution that only works for + // arrays of strings. + function emulatedSet(keys) { + var hash = {}; + for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true; + return { + contains: function(key) { return hash[key] === true; }, + push: function(key) { + hash[key] = true; + return keys.push(key); + } + }; + } + + // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't + // be iterated by `for key in ...` and thus missed. Extends `keys` in place if + // needed. + function collectNonEnumProps(obj, keys) { + keys = emulatedSet(keys); + var nonEnumIdx = nonEnumerableProps.length; + var constructor = obj.constructor; + var proto = (isFunction$1(constructor) && constructor.prototype) || ObjProto; + + // Constructor is a special case. + var prop = 'constructor'; + if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop); + + while (nonEnumIdx--) { + prop = nonEnumerableProps[nonEnumIdx]; + if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) { + keys.push(prop); + } + } + } + + // Retrieve the names of an object's own properties. + // Delegates to **ECMAScript 5**'s native `Object.keys`. + function keys(obj) { + if (!isObject(obj)) return []; + if (nativeKeys) return nativeKeys(obj); + var keys = []; + for (var key in obj) if (has$1(obj, key)) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + } + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + function isEmpty(obj) { + if (obj == null) return true; + // Skip the more expensive `toString`-based type checks if `obj` has no + // `.length`. + var length = getLength(obj); + if (typeof length == 'number' && ( + isArray(obj) || isString(obj) || isArguments$1(obj) + )) return length === 0; + return getLength(keys(obj)) === 0; + } + + // Returns whether an object has a given set of `key:value` pairs. + function isMatch(object, attrs) { + var _keys = keys(attrs), length = _keys.length; + if (object == null) return !length; + var obj = Object(object); + for (var i = 0; i < length; i++) { + var key = _keys[i]; + if (attrs[key] !== obj[key] || !(key in obj)) return false; + } + return true; + } + + // If Underscore is called as a function, it returns a wrapped object that can + // be used OO-style. This wrapper holds altered versions of all functions added + // through `_.mixin`. Wrapped objects may be chained. + function _$1(obj) { + if (obj instanceof _$1) return obj; + if (!(this instanceof _$1)) return new _$1(obj); + this._wrapped = obj; + } + + _$1.VERSION = VERSION; + + // Extracts the result from a wrapped and chained object. + _$1.prototype.value = function() { + return this._wrapped; + }; + + // Provide unwrapping proxies for some methods used in engine operations + // such as arithmetic and JSON stringification. + _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value; + + _$1.prototype.toString = function() { + return String(this._wrapped); + }; + + // Internal function to wrap or shallow-copy an ArrayBuffer, + // typed array or DataView to a new view, reusing the buffer. + function toBufferView(bufferSource) { + return new Uint8Array( + bufferSource.buffer || bufferSource, + bufferSource.byteOffset || 0, + getByteLength(bufferSource) + ); + } + + // We use this string twice, so give it a name for minification. + var tagDataView = '[object DataView]'; + + // Internal recursive comparison function for `_.isEqual`. + function eq(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal). + if (a === b) return a !== 0 || 1 / a === 1 / b; + // `null` or `undefined` only equal to itself (strict comparison). + if (a == null || b == null) return false; + // `NaN`s are equivalent, but non-reflexive. + if (a !== a) return b !== b; + // Exhaust primitive checks + var type = typeof a; + if (type !== 'function' && type !== 'object' && typeof b != 'object') return false; + return deepEq(a, b, aStack, bStack); + } + + // Internal recursive comparison function for `_.isEqual`. + function deepEq(a, b, aStack, bStack) { + // Unwrap any wrapped objects. + if (a instanceof _$1) a = a._wrapped; + if (b instanceof _$1) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className !== toString.call(b)) return false; + // Work around a bug in IE 10 - Edge 13. + if (hasStringTagBug && className == '[object Object]' && isDataView$1(a)) { + if (!isDataView$1(b)) return false; + className = tagDataView; + } + switch (className) { + // These types are compared by value. + case '[object RegExp]': + // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return '' + a === '' + b; + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. + // Object(NaN) is equivalent to NaN. + if (+a !== +a) return +b !== +b; + // An `egal` comparison is performed for other numeric values. + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a === +b; + case '[object Symbol]': + return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b); + case '[object ArrayBuffer]': + case tagDataView: + // Coerce to typed array so we can fall through. + return deepEq(toBufferView(a), toBufferView(b), aStack, bStack); + } + + var areArrays = className === '[object Array]'; + if (!areArrays && isTypedArray$1(a)) { + var byteLength = getByteLength(a); + if (byteLength !== getByteLength(b)) return false; + if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true; + areArrays = true; + } + if (!areArrays) { + if (typeof a != 'object' || typeof b != 'object') return false; + + // Objects with different constructors are not equivalent, but `Object`s or `Array`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor && + isFunction$1(bCtor) && bCtor instanceof bCtor) + && ('constructor' in a && 'constructor' in b)) { + return false; + } + } + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + + // Initializing stack of traversed objects. + // It's done here since we only need them for objects and arrays comparison. + aStack = aStack || []; + bStack = bStack || []; + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] === a) return bStack[length] === b; + } + + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + + // Recursively compare objects and arrays. + if (areArrays) { + // Compare array lengths to determine if a deep comparison is necessary. + length = a.length; + if (length !== b.length) return false; + // Deep compare the contents, ignoring non-numeric properties. + while (length--) { + if (!eq(a[length], b[length], aStack, bStack)) return false; + } + } else { + // Deep compare objects. + var _keys = keys(a), key; + length = _keys.length; + // Ensure that both objects contain the same number of properties before comparing deep equality. + if (keys(b).length !== length) return false; + while (length--) { + // Deep compare each member + key = _keys[length]; + if (!(has$1(b, key) && eq(a[key], b[key], aStack, bStack))) return false; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return true; + } + + // Perform a deep comparison to check if two objects are equal. + function isEqual(a, b) { + return eq(a, b); + } + + // Retrieve all the enumerable property names of an object. + function allKeys(obj) { + if (!isObject(obj)) return []; + var keys = []; + for (var key in obj) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + } + + // Since the regular `Object.prototype.toString` type tests don't work for + // some types in IE 11, we use a fingerprinting heuristic instead, based + // on the methods. It's not great, but it's the best we got. + // The fingerprint method lists are defined below. + function ie11fingerprint(methods) { + var length = getLength(methods); + return function(obj) { + if (obj == null) return false; + // `Map`, `WeakMap` and `Set` have no enumerable keys. + var keys = allKeys(obj); + if (getLength(keys)) return false; + for (var i = 0; i < length; i++) { + if (!isFunction$1(obj[methods[i]])) return false; + } + // If we are testing against `WeakMap`, we need to ensure that + // `obj` doesn't have a `forEach` method in order to distinguish + // it from a regular `Map`. + return methods !== weakMapMethods || !isFunction$1(obj[forEachName]); + }; + } + + // In the interest of compact minification, we write + // each string in the fingerprints only once. + var forEachName = 'forEach', + hasName = 'has', + commonInit = ['clear', 'delete'], + mapTail = ['get', hasName, 'set']; + + // `Map`, `WeakMap` and `Set` each have slightly different + // combinations of the above sublists. + var mapMethods = commonInit.concat(forEachName, mapTail), + weakMapMethods = commonInit.concat(mapTail), + setMethods = ['add'].concat(commonInit, forEachName, hasName); + + var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map'); + + var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap'); + + var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set'); + + var isWeakSet = tagTester('WeakSet'); + + // Retrieve the values of an object's properties. + function values(obj) { + var _keys = keys(obj); + var length = _keys.length; + var values = Array(length); + for (var i = 0; i < length; i++) { + values[i] = obj[_keys[i]]; + } + return values; + } + + // Convert an object into a list of `[key, value]` pairs. + // The opposite of `_.object` with one argument. + function pairs(obj) { + var _keys = keys(obj); + var length = _keys.length; + var pairs = Array(length); + for (var i = 0; i < length; i++) { + pairs[i] = [_keys[i], obj[_keys[i]]]; + } + return pairs; + } + + // Invert the keys and values of an object. The values must be serializable. + function invert(obj) { + var result = {}; + var _keys = keys(obj); + for (var i = 0, length = _keys.length; i < length; i++) { + result[obj[_keys[i]]] = _keys[i]; + } + return result; + } + + // Return a sorted list of the function names available on the object. + function functions(obj) { + var names = []; + for (var key in obj) { + if (isFunction$1(obj[key])) names.push(key); + } + return names.sort(); + } + + // An internal function for creating assigner functions. + function createAssigner(keysFunc, defaults) { + return function(obj) { + var length = arguments.length; + if (defaults) obj = Object(obj); + if (length < 2 || obj == null) return obj; + for (var index = 1; index < length; index++) { + var source = arguments[index], + keys = keysFunc(source), + l = keys.length; + for (var i = 0; i < l; i++) { + var key = keys[i]; + if (!defaults || obj[key] === void 0) obj[key] = source[key]; + } + } + return obj; + }; + } + + // Extend a given object with all the properties in passed-in object(s). + var extend = createAssigner(allKeys); + + // Assigns a given object with all the own properties in the passed-in + // object(s). + // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) + var extendOwn = createAssigner(keys); + + // Fill in a given object with default properties. + var defaults = createAssigner(allKeys, true); + + // Create a naked function reference for surrogate-prototype-swapping. + function ctor() { + return function(){}; + } + + // An internal function for creating a new object that inherits from another. + function baseCreate(prototype) { + if (!isObject(prototype)) return {}; + if (nativeCreate) return nativeCreate(prototype); + var Ctor = ctor(); + Ctor.prototype = prototype; + var result = new Ctor; + Ctor.prototype = null; + return result; + } + + // Creates an object that inherits from the given prototype object. + // If additional properties are provided then they will be added to the + // created object. + function create(prototype, props) { + var result = baseCreate(prototype); + if (props) extendOwn(result, props); + return result; + } + + // Create a (shallow-cloned) duplicate of an object. + function clone(obj) { + if (!isObject(obj)) return obj; + return isArray(obj) ? obj.slice() : extend({}, obj); + } + + // Invokes `interceptor` with the `obj` and then returns `obj`. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + function tap(obj, interceptor) { + interceptor(obj); + return obj; + } + + // Normalize a (deep) property `path` to array. + // Like `_.iteratee`, this function can be customized. + function toPath$1(path) { + return isArray(path) ? path : [path]; + } + _$1.toPath = toPath$1; + + // Internal wrapper for `_.toPath` to enable minification. + // Similar to `cb` for `_.iteratee`. + function toPath(path) { + return _$1.toPath(path); + } + + // Internal function to obtain a nested property in `obj` along `path`. + function deepGet(obj, path) { + var length = path.length; + for (var i = 0; i < length; i++) { + if (obj == null) return void 0; + obj = obj[path[i]]; + } + return length ? obj : void 0; + } + + // Get the value of the (deep) property on `path` from `object`. + // If any property in `path` does not exist or if the value is + // `undefined`, return `defaultValue` instead. + // The `path` is normalized through `_.toPath`. + function get(object, path, defaultValue) { + var value = deepGet(object, toPath(path)); + return isUndefined(value) ? defaultValue : value; + } + + // Shortcut function for checking if an object has a given property directly on + // itself (in other words, not on a prototype). Unlike the internal `has` + // function, this public version can also traverse nested properties. + function has(obj, path) { + path = toPath(path); + var length = path.length; + for (var i = 0; i < length; i++) { + var key = path[i]; + if (!has$1(obj, key)) return false; + obj = obj[key]; + } + return !!length; + } + + // Keep the identity function around for default iteratees. + function identity(value) { + return value; + } + + // Returns a predicate for checking whether an object has a given set of + // `key:value` pairs. + function matcher(attrs) { + attrs = extendOwn({}, attrs); + return function(obj) { + return isMatch(obj, attrs); + }; + } + + // Creates a function that, when passed an object, will traverse that object’s + // properties down the given `path`, specified as an array of keys or indices. + function property(path) { + path = toPath(path); + return function(obj) { + return deepGet(obj, path); + }; + } + + // Internal function that returns an efficient (for current engines) version + // of the passed-in callback, to be repeatedly applied in other Underscore + // functions. + function optimizeCb(func, context, argCount) { + if (context === void 0) return func; + switch (argCount == null ? 3 : argCount) { + case 1: return function(value) { + return func.call(context, value); + }; + // The 2-argument case is omitted because we’re not using it. + case 3: return function(value, index, collection) { + return func.call(context, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(context, accumulator, value, index, collection); + }; + } + return function() { + return func.apply(context, arguments); + }; + } + + // An internal function to generate callbacks that can be applied to each + // element in a collection, returning the desired result — either `_.identity`, + // an arbitrary callback, a property matcher, or a property accessor. + function baseIteratee(value, context, argCount) { + if (value == null) return identity; + if (isFunction$1(value)) return optimizeCb(value, context, argCount); + if (isObject(value) && !isArray(value)) return matcher(value); + return property(value); + } + + // External wrapper for our callback generator. Users may customize + // `_.iteratee` if they want additional predicate/iteratee shorthand styles. + // This abstraction hides the internal-only `argCount` argument. + function iteratee(value, context) { + return baseIteratee(value, context, Infinity); + } + _$1.iteratee = iteratee; + + // The function we call internally to generate a callback. It invokes + // `_.iteratee` if overridden, otherwise `baseIteratee`. + function cb(value, context, argCount) { + if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context); + return baseIteratee(value, context, argCount); + } + + // Returns the results of applying the `iteratee` to each element of `obj`. + // In contrast to `_.map` it returns an object. + function mapObject(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var _keys = keys(obj), + length = _keys.length, + results = {}; + for (var index = 0; index < length; index++) { + var currentKey = _keys[index]; + results[currentKey] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + } + + // Predicate-generating function. Often useful outside of Underscore. + function noop(){} + + // Generates a function for a given object that returns a given property. + function propertyOf(obj) { + if (obj == null) return noop; + return function(path) { + return get(obj, path); + }; + } + + // Run a function **n** times. + function times(n, iteratee, context) { + var accum = Array(Math.max(0, n)); + iteratee = optimizeCb(iteratee, context, 1); + for (var i = 0; i < n; i++) accum[i] = iteratee(i); + return accum; + } + + // Return a random integer between `min` and `max` (inclusive). + function random(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + } + + // A (possibly faster) way to get the current timestamp as an integer. + var now = Date.now || function() { + return new Date().getTime(); + }; + + // Internal helper to generate functions for escaping and unescaping strings + // to/from HTML interpolation. + function createEscaper(map) { + var escaper = function(match) { + return map[match]; + }; + // Regexes for identifying a key that needs to be escaped. + var source = '(?:' + keys(map).join('|') + ')'; + var testRegexp = RegExp(source); + var replaceRegexp = RegExp(source, 'g'); + return function(string) { + string = string == null ? '' : '' + string; + return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string; + }; + } + + // Internal list of HTML entities for escaping. + var escapeMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`' + }; + + // Function for escaping strings to HTML interpolation. + var _escape = createEscaper(escapeMap); + + // Internal list of HTML entities for unescaping. + var unescapeMap = invert(escapeMap); + + // Function for unescaping strings from HTML interpolation. + var _unescape = createEscaper(unescapeMap); + + // By default, Underscore uses ERB-style template delimiters. Change the + // following template settings to use alternative delimiters. + var templateSettings = _$1.templateSettings = { + evaluate: /<%([\s\S]+?)%>/g, + interpolate: /<%=([\s\S]+?)%>/g, + escape: /<%-([\s\S]+?)%>/g + }; + + // When customizing `_.templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g; + + function escapeChar(match) { + return '\\' + escapes[match]; + } + + // In order to prevent third-party code injection through + // `_.templateSettings.variable`, we test it against the following regular + // expression. It is intentionally a bit more liberal than just matching valid + // identifiers, but still prevents possible loopholes through defaults or + // destructuring assignment. + var bareIdentifier = /^\s*(\w|\$)+\s*$/; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + // NB: `oldSettings` only exists for backwards compatibility. + function template(text, settings, oldSettings) { + if (!settings && oldSettings) settings = oldSettings; + settings = defaults({}, settings, _$1.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset).replace(escapeRegExp, escapeChar); + index = offset + match.length; + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } else if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } else if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + + // Adobe VMs need the match returned to produce the correct offset. + return match; + }); + source += "';\n"; + + var argument = settings.variable; + if (argument) { + // Insure against third-party code injection. (CVE-2021-23358) + if (!bareIdentifier.test(argument)) throw new Error( + 'variable is not a bare identifier: ' + argument + ); + } else { + // If a variable is not specified, place data values in local scope. + source = 'with(obj||{}){\n' + source + '}\n'; + argument = 'obj'; + } + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + 'return __p;\n'; + + var render; + try { + render = new Function(argument, '_', source); + } catch (e) { + e.source = source; + throw e; + } + + var template = function(data) { + return render.call(this, data, _$1); + }; + + // Provide the compiled source as a convenience for precompilation. + template.source = 'function(' + argument + '){\n' + source + '}'; + + return template; + } + + // Traverses the children of `obj` along `path`. If a child is a function, it + // is invoked with its parent as context. Returns the value of the final + // child, or `fallback` if any child is undefined. + function result(obj, path, fallback) { + path = toPath(path); + var length = path.length; + if (!length) { + return isFunction$1(fallback) ? fallback.call(obj) : fallback; + } + for (var i = 0; i < length; i++) { + var prop = obj == null ? void 0 : obj[path[i]]; + if (prop === void 0) { + prop = fallback; + i = length; // Ensure we don't continue iterating. + } + obj = isFunction$1(prop) ? prop.call(obj) : prop; + } + return obj; + } + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + function uniqueId(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + } + + // Start chaining a wrapped Underscore object. + function chain(obj) { + var instance = _$1(obj); + instance._chain = true; + return instance; + } + + // Internal function to execute `sourceFunc` bound to `context` with optional + // `args`. Determines whether to execute a function as a constructor or as a + // normal function. + function executeBound(sourceFunc, boundFunc, context, callingContext, args) { + if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args); + var self = baseCreate(sourceFunc.prototype); + var result = sourceFunc.apply(self, args); + if (isObject(result)) return result; + return self; + } + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. `_` acts + // as a placeholder by default, allowing any combination of arguments to be + // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument. + var partial = restArguments(function(func, boundArgs) { + var placeholder = partial.placeholder; + var bound = function() { + var position = 0, length = boundArgs.length; + var args = Array(length); + for (var i = 0; i < length; i++) { + args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i]; + } + while (position < arguments.length) args.push(arguments[position++]); + return executeBound(func, bound, this, this, args); + }; + return bound; + }); + + partial.placeholder = _$1; + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). + var bind = restArguments(function(func, context, args) { + if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function'); + var bound = restArguments(function(callArgs) { + return executeBound(func, bound, context, this, args.concat(callArgs)); + }); + return bound; + }); + + // Internal helper for collection methods to determine whether a collection + // should be iterated as an array or as an object. + // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength + // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094 + var isArrayLike = createSizePropertyCheck(getLength); + + // Internal implementation of a recursive `flatten` function. + function flatten$1(input, depth, strict, output) { + output = output || []; + if (!depth && depth !== 0) { + depth = Infinity; + } else if (depth <= 0) { + return output.concat(input); + } + var idx = output.length; + for (var i = 0, length = getLength(input); i < length; i++) { + var value = input[i]; + if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) { + // Flatten current level of array or arguments object. + if (depth > 1) { + flatten$1(value, depth - 1, strict, output); + idx = output.length; + } else { + var j = 0, len = value.length; + while (j < len) output[idx++] = value[j++]; + } + } else if (!strict) { + output[idx++] = value; + } + } + return output; + } + + // Bind a number of an object's methods to that object. Remaining arguments + // are the method names to be bound. Useful for ensuring that all callbacks + // defined on an object belong to it. + var bindAll = restArguments(function(obj, keys) { + keys = flatten$1(keys, false, false); + var index = keys.length; + if (index < 1) throw new Error('bindAll must be passed function names'); + while (index--) { + var key = keys[index]; + obj[key] = bind(obj[key], obj); + } + return obj; + }); + + // Memoize an expensive function by storing its results. + function memoize(func, hasher) { + var memoize = function(key) { + var cache = memoize.cache; + var address = '' + (hasher ? hasher.apply(this, arguments) : key); + if (!has$1(cache, address)) cache[address] = func.apply(this, arguments); + return cache[address]; + }; + memoize.cache = {}; + return memoize; + } + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + var delay = restArguments(function(func, wait, args) { + return setTimeout(function() { + return func.apply(null, args); + }, wait); + }); + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + var defer = partial(delay, _$1, 1); + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. Normally, the throttled function will run + // as much as it can, without ever going more than once per `wait` duration; + // but if you'd like to disable the execution on the leading edge, pass + // `{leading: false}`. To disable execution on the trailing edge, ditto. + function throttle(func, wait, options) { + var timeout, context, args, result; + var previous = 0; + if (!options) options = {}; + + var later = function() { + previous = options.leading === false ? 0 : now(); + timeout = null; + result = func.apply(context, args); + if (!timeout) context = args = null; + }; + + var throttled = function() { + var _now = now(); + if (!previous && options.leading === false) previous = _now; + var remaining = wait - (_now - previous); + context = this; + args = arguments; + if (remaining <= 0 || remaining > wait) { + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + previous = _now; + result = func.apply(context, args); + if (!timeout) context = args = null; + } else if (!timeout && options.trailing !== false) { + timeout = setTimeout(later, remaining); + } + return result; + }; + + throttled.cancel = function() { + clearTimeout(timeout); + previous = 0; + timeout = context = args = null; + }; + + return throttled; + } + + // When a sequence of calls of the returned function ends, the argument + // function is triggered. The end of a sequence is defined by the `wait` + // parameter. If `immediate` is passed, the argument function will be + // triggered at the beginning of the sequence instead of at the end. + function debounce(func, wait, immediate) { + var timeout, previous, args, result, context; + + var later = function() { + var passed = now() - previous; + if (wait > passed) { + timeout = setTimeout(later, wait - passed); + } else { + timeout = null; + if (!immediate) result = func.apply(context, args); + // This check is needed because `func` can recursively invoke `debounced`. + if (!timeout) args = context = null; + } + }; + + var debounced = restArguments(function(_args) { + context = this; + args = _args; + previous = now(); + if (!timeout) { + timeout = setTimeout(later, wait); + if (immediate) result = func.apply(context, args); + } + return result; + }); + + debounced.cancel = function() { + clearTimeout(timeout); + timeout = args = context = null; + }; + + return debounced; + } + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + function wrap(func, wrapper) { + return partial(wrapper, func); + } + + // Returns a negated version of the passed-in predicate. + function negate(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; + } + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + function compose() { + var args = arguments; + var start = args.length - 1; + return function() { + var i = start; + var result = args[start].apply(this, arguments); + while (i--) result = args[i].call(this, result); + return result; + }; + } + + // Returns a function that will only be executed on and after the Nth call. + function after(times, func) { + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + } + + // Returns a function that will only be executed up to (but not including) the + // Nth call. + function before(times, func) { + var memo; + return function() { + if (--times > 0) { + memo = func.apply(this, arguments); + } + if (times <= 1) func = null; + return memo; + }; + } + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + var once = partial(before, 2); + + // Returns the first key on an object that passes a truth test. + function findKey(obj, predicate, context) { + predicate = cb(predicate, context); + var _keys = keys(obj), key; + for (var i = 0, length = _keys.length; i < length; i++) { + key = _keys[i]; + if (predicate(obj[key], key, obj)) return key; + } + } + + // Internal function to generate `_.findIndex` and `_.findLastIndex`. + function createPredicateIndexFinder(dir) { + return function(array, predicate, context) { + predicate = cb(predicate, context); + var length = getLength(array); + var index = dir > 0 ? 0 : length - 1; + for (; index >= 0 && index < length; index += dir) { + if (predicate(array[index], index, array)) return index; + } + return -1; + }; + } + + // Returns the first index on an array-like that passes a truth test. + var findIndex = createPredicateIndexFinder(1); + + // Returns the last index on an array-like that passes a truth test. + var findLastIndex = createPredicateIndexFinder(-1); + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + function sortedIndex(array, obj, iteratee, context) { + iteratee = cb(iteratee, context, 1); + var value = iteratee(obj); + var low = 0, high = getLength(array); + while (low < high) { + var mid = Math.floor((low + high) / 2); + if (iteratee(array[mid]) < value) low = mid + 1; else high = mid; + } + return low; + } + + // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions. + function createIndexFinder(dir, predicateFind, sortedIndex) { + return function(array, item, idx) { + var i = 0, length = getLength(array); + if (typeof idx == 'number') { + if (dir > 0) { + i = idx >= 0 ? idx : Math.max(idx + length, i); + } else { + length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1; + } + } else if (sortedIndex && idx && length) { + idx = sortedIndex(array, item); + return array[idx] === item ? idx : -1; + } + if (item !== item) { + idx = predicateFind(slice.call(array, i, length), isNaN$1); + return idx >= 0 ? idx + i : -1; + } + for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) { + if (array[idx] === item) return idx; + } + return -1; + }; + } + + // Return the position of the first occurrence of an item in an array, + // or -1 if the item is not included in the array. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + var indexOf = createIndexFinder(1, findIndex, sortedIndex); + + // Return the position of the last occurrence of an item in an array, + // or -1 if the item is not included in the array. + var lastIndexOf = createIndexFinder(-1, findLastIndex); + + // Return the first value which passes a truth test. + function find(obj, predicate, context) { + var keyFinder = isArrayLike(obj) ? findIndex : findKey; + var key = keyFinder(obj, predicate, context); + if (key !== void 0 && key !== -1) return obj[key]; + } + + // Convenience version of a common use case of `_.find`: getting the first + // object containing specific `key:value` pairs. + function findWhere(obj, attrs) { + return find(obj, matcher(attrs)); + } + + // The cornerstone for collection functions, an `each` + // implementation, aka `forEach`. + // Handles raw objects in addition to array-likes. Treats all + // sparse array-likes as if they were dense. + function each(obj, iteratee, context) { + iteratee = optimizeCb(iteratee, context); + var i, length; + if (isArrayLike(obj)) { + for (i = 0, length = obj.length; i < length; i++) { + iteratee(obj[i], i, obj); + } + } else { + var _keys = keys(obj); + for (i = 0, length = _keys.length; i < length; i++) { + iteratee(obj[_keys[i]], _keys[i], obj); + } + } + return obj; + } + + // Return the results of applying the iteratee to each element. + function map(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var _keys = !isArrayLike(obj) && keys(obj), + length = (_keys || obj).length, + results = Array(length); + for (var index = 0; index < length; index++) { + var currentKey = _keys ? _keys[index] : index; + results[index] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + } + + // Internal helper to create a reducing function, iterating left or right. + function createReduce(dir) { + // Wrap code that reassigns argument variables in a separate function than + // the one that accesses `arguments.length` to avoid a perf hit. (#1991) + var reducer = function(obj, iteratee, memo, initial) { + var _keys = !isArrayLike(obj) && keys(obj), + length = (_keys || obj).length, + index = dir > 0 ? 0 : length - 1; + if (!initial) { + memo = obj[_keys ? _keys[index] : index]; + index += dir; + } + for (; index >= 0 && index < length; index += dir) { + var currentKey = _keys ? _keys[index] : index; + memo = iteratee(memo, obj[currentKey], currentKey, obj); + } + return memo; + }; + + return function(obj, iteratee, memo, context) { + var initial = arguments.length >= 3; + return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial); + }; + } + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. + var reduce = createReduce(1); + + // The right-associative version of reduce, also known as `foldr`. + var reduceRight = createReduce(-1); + + // Return all the elements that pass a truth test. + function filter(obj, predicate, context) { + var results = []; + predicate = cb(predicate, context); + each(obj, function(value, index, list) { + if (predicate(value, index, list)) results.push(value); + }); + return results; + } + + // Return all the elements for which a truth test fails. + function reject(obj, predicate, context) { + return filter(obj, negate(cb(predicate)), context); + } + + // Determine whether all of the elements pass a truth test. + function every(obj, predicate, context) { + predicate = cb(predicate, context); + var _keys = !isArrayLike(obj) && keys(obj), + length = (_keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = _keys ? _keys[index] : index; + if (!predicate(obj[currentKey], currentKey, obj)) return false; + } + return true; + } + + // Determine if at least one element in the object passes a truth test. + function some(obj, predicate, context) { + predicate = cb(predicate, context); + var _keys = !isArrayLike(obj) && keys(obj), + length = (_keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = _keys ? _keys[index] : index; + if (predicate(obj[currentKey], currentKey, obj)) return true; + } + return false; + } + + // Determine if the array or object contains a given item (using `===`). + function contains(obj, item, fromIndex, guard) { + if (!isArrayLike(obj)) obj = values(obj); + if (typeof fromIndex != 'number' || guard) fromIndex = 0; + return indexOf(obj, item, fromIndex) >= 0; + } + + // Invoke a method (with arguments) on every item in a collection. + var invoke = restArguments(function(obj, path, args) { + var contextPath, func; + if (isFunction$1(path)) { + func = path; + } else { + path = toPath(path); + contextPath = path.slice(0, -1); + path = path[path.length - 1]; + } + return map(obj, function(context) { + var method = func; + if (!method) { + if (contextPath && contextPath.length) { + context = deepGet(context, contextPath); + } + if (context == null) return void 0; + method = context[path]; + } + return method == null ? method : method.apply(context, args); + }); + }); + + // Convenience version of a common use case of `_.map`: fetching a property. + function pluck(obj, key) { + return map(obj, property(key)); + } + + // Convenience version of a common use case of `_.filter`: selecting only + // objects containing specific `key:value` pairs. + function where(obj, attrs) { + return filter(obj, matcher(attrs)); + } + + // Return the maximum element (or element-based computation). + function max(obj, iteratee, context) { + var result = -Infinity, lastComputed = -Infinity, + value, computed; + if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) { + obj = isArrayLike(obj) ? obj : values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value != null && value > result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + each(obj, function(v, index, list) { + computed = iteratee(v, index, list); + if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) { + result = v; + lastComputed = computed; + } + }); + } + return result; + } + + // Return the minimum element (or element-based computation). + function min(obj, iteratee, context) { + var result = Infinity, lastComputed = Infinity, + value, computed; + if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) { + obj = isArrayLike(obj) ? obj : values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value != null && value < result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + each(obj, function(v, index, list) { + computed = iteratee(v, index, list); + if (computed < lastComputed || (computed === Infinity && result === Infinity)) { + result = v; + lastComputed = computed; + } + }); + } + return result; + } + + // Safely create a real, live array from anything iterable. + var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g; + function toArray(obj) { + if (!obj) return []; + if (isArray(obj)) return slice.call(obj); + if (isString(obj)) { + // Keep surrogate pair characters together. + return obj.match(reStrSymbol); + } + if (isArrayLike(obj)) return map(obj, identity); + return values(obj); + } + + // Sample **n** random values from a collection using the modern version of the + // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle). + // If **n** is not specified, returns a single random element. + // The internal `guard` argument allows it to work with `_.map`. + function sample(obj, n, guard) { + if (n == null || guard) { + if (!isArrayLike(obj)) obj = values(obj); + return obj[random(obj.length - 1)]; + } + var sample = toArray(obj); + var length = getLength(sample); + n = Math.max(Math.min(n, length), 0); + var last = length - 1; + for (var index = 0; index < n; index++) { + var rand = random(index, last); + var temp = sample[index]; + sample[index] = sample[rand]; + sample[rand] = temp; + } + return sample.slice(0, n); + } + + // Shuffle a collection. + function shuffle(obj) { + return sample(obj, Infinity); + } + + // Sort the object's values by a criterion produced by an iteratee. + function sortBy(obj, iteratee, context) { + var index = 0; + iteratee = cb(iteratee, context); + return pluck(map(obj, function(value, key, list) { + return { + value: value, + index: index++, + criteria: iteratee(value, key, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index - right.index; + }), 'value'); + } + + // An internal function used for aggregate "group by" operations. + function group(behavior, partition) { + return function(obj, iteratee, context) { + var result = partition ? [[], []] : {}; + iteratee = cb(iteratee, context); + each(obj, function(value, index) { + var key = iteratee(value, index, obj); + behavior(result, value, key); + }); + return result; + }; + } + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + var groupBy = group(function(result, value, key) { + if (has$1(result, key)) result[key].push(value); else result[key] = [value]; + }); + + // Indexes the object's values by a criterion, similar to `_.groupBy`, but for + // when you know that your index values will be unique. + var indexBy = group(function(result, value, key) { + result[key] = value; + }); + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + var countBy = group(function(result, value, key) { + if (has$1(result, key)) result[key]++; else result[key] = 1; + }); + + // Split a collection into two arrays: one whose elements all pass the given + // truth test, and one whose elements all do not pass the truth test. + var partition = group(function(result, value, pass) { + result[pass ? 0 : 1].push(value); + }, true); + + // Return the number of elements in a collection. + function size(obj) { + if (obj == null) return 0; + return isArrayLike(obj) ? obj.length : keys(obj).length; + } + + // Internal `_.pick` helper function to determine whether `key` is an enumerable + // property name of `obj`. + function keyInObj(value, key, obj) { + return key in obj; + } + + // Return a copy of the object only containing the allowed properties. + var pick = restArguments(function(obj, keys) { + var result = {}, iteratee = keys[0]; + if (obj == null) return result; + if (isFunction$1(iteratee)) { + if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]); + keys = allKeys(obj); + } else { + iteratee = keyInObj; + keys = flatten$1(keys, false, false); + obj = Object(obj); + } + for (var i = 0, length = keys.length; i < length; i++) { + var key = keys[i]; + var value = obj[key]; + if (iteratee(value, key, obj)) result[key] = value; + } + return result; + }); + + // Return a copy of the object without the disallowed properties. + var omit = restArguments(function(obj, keys) { + var iteratee = keys[0], context; + if (isFunction$1(iteratee)) { + iteratee = negate(iteratee); + if (keys.length > 1) context = keys[1]; + } else { + keys = map(flatten$1(keys, false, false), String); + iteratee = function(value, key) { + return !contains(keys, key); + }; + } + return pick(obj, iteratee, context); + }); + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. + function initial(array, n, guard) { + return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n))); + } + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. The **guard** check allows it to work with `_.map`. + function first(array, n, guard) { + if (array == null || array.length < 1) return n == null || guard ? void 0 : []; + if (n == null || guard) return array[0]; + return initial(array, array.length - n); + } + + // Returns everything but the first entry of the `array`. Especially useful on + // the `arguments` object. Passing an **n** will return the rest N values in the + // `array`. + function rest(array, n, guard) { + return slice.call(array, n == null || guard ? 1 : n); + } + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. + function last(array, n, guard) { + if (array == null || array.length < 1) return n == null || guard ? void 0 : []; + if (n == null || guard) return array[array.length - 1]; + return rest(array, Math.max(0, array.length - n)); + } + + // Trim out all falsy values from an array. + function compact(array) { + return filter(array, Boolean); + } + + // Flatten out an array, either recursively (by default), or up to `depth`. + // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively. + function flatten(array, depth) { + return flatten$1(array, depth, false); + } + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + var difference = restArguments(function(array, rest) { + rest = flatten$1(rest, true, true); + return filter(array, function(value){ + return !contains(rest, value); + }); + }); + + // Return a version of the array that does not contain the specified value(s). + var without = restArguments(function(array, otherArrays) { + return difference(array, otherArrays); + }); + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // The faster algorithm will not work with an iteratee if the iteratee + // is not a one-to-one function, so providing an iteratee will disable + // the faster algorithm. + function uniq(array, isSorted, iteratee, context) { + if (!isBoolean(isSorted)) { + context = iteratee; + iteratee = isSorted; + isSorted = false; + } + if (iteratee != null) iteratee = cb(iteratee, context); + var result = []; + var seen = []; + for (var i = 0, length = getLength(array); i < length; i++) { + var value = array[i], + computed = iteratee ? iteratee(value, i, array) : value; + if (isSorted && !iteratee) { + if (!i || seen !== computed) result.push(value); + seen = computed; + } else if (iteratee) { + if (!contains(seen, computed)) { + seen.push(computed); + result.push(value); + } + } else if (!contains(result, value)) { + result.push(value); + } + } + return result; + } + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + var union = restArguments(function(arrays) { + return uniq(flatten$1(arrays, true, true)); + }); + + // Produce an array that contains every item shared between all the + // passed-in arrays. + function intersection(array) { + var result = []; + var argsLength = arguments.length; + for (var i = 0, length = getLength(array); i < length; i++) { + var item = array[i]; + if (contains(result, item)) continue; + var j; + for (j = 1; j < argsLength; j++) { + if (!contains(arguments[j], item)) break; + } + if (j === argsLength) result.push(item); + } + return result; + } + + // Complement of zip. Unzip accepts an array of arrays and groups + // each array's elements on shared indices. + function unzip(array) { + var length = (array && max(array, getLength).length) || 0; + var result = Array(length); + + for (var index = 0; index < length; index++) { + result[index] = pluck(array, index); + } + return result; + } + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + var zip = restArguments(unzip); + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. Passing by pairs is the reverse of `_.pairs`. + function object(list, values) { + var result = {}; + for (var i = 0, length = getLength(list); i < length; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + } + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](https://docs.python.org/library/functions.html#range). + function range(start, stop, step) { + if (stop == null) { + stop = start || 0; + start = 0; + } + if (!step) { + step = stop < start ? -1 : 1; + } + + var length = Math.max(Math.ceil((stop - start) / step), 0); + var range = Array(length); + + for (var idx = 0; idx < length; idx++, start += step) { + range[idx] = start; + } + + return range; + } + + // Chunk a single array into multiple arrays, each containing `count` or fewer + // items. + function chunk(array, count) { + if (count == null || count < 1) return []; + var result = []; + var i = 0, length = array.length; + while (i < length) { + result.push(slice.call(array, i, i += count)); + } + return result; + } + + // Helper function to continue chaining intermediate results. + function chainResult(instance, obj) { + return instance._chain ? _$1(obj).chain() : obj; + } + + // Add your own custom functions to the Underscore object. + function mixin(obj) { + each(functions(obj), function(name) { + var func = _$1[name] = obj[name]; + _$1.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return chainResult(this, func.apply(_$1, args)); + }; + }); + return _$1; + } + + // Add all mutator `Array` functions to the wrapper. + each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _$1.prototype[name] = function() { + var obj = this._wrapped; + if (obj != null) { + method.apply(obj, arguments); + if ((name === 'shift' || name === 'splice') && obj.length === 0) { + delete obj[0]; + } + } + return chainResult(this, obj); + }; + }); + + // Add all accessor `Array` functions to the wrapper. + each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _$1.prototype[name] = function() { + var obj = this._wrapped; + if (obj != null) obj = method.apply(obj, arguments); + return chainResult(this, obj); + }; + }); + + // Named Exports + + var allExports = { + __proto__: null, + VERSION: VERSION, + restArguments: restArguments, + isObject: isObject, + isNull: isNull, + isUndefined: isUndefined, + isBoolean: isBoolean, + isElement: isElement, + isString: isString, + isNumber: isNumber, + isDate: isDate, + isRegExp: isRegExp, + isError: isError, + isSymbol: isSymbol, + isArrayBuffer: isArrayBuffer, + isDataView: isDataView$1, + isArray: isArray, + isFunction: isFunction$1, + isArguments: isArguments$1, + isFinite: isFinite$1, + isNaN: isNaN$1, + isTypedArray: isTypedArray$1, + isEmpty: isEmpty, + isMatch: isMatch, + isEqual: isEqual, + isMap: isMap, + isWeakMap: isWeakMap, + isSet: isSet, + isWeakSet: isWeakSet, + keys: keys, + allKeys: allKeys, + values: values, + pairs: pairs, + invert: invert, + functions: functions, + methods: functions, + extend: extend, + extendOwn: extendOwn, + assign: extendOwn, + defaults: defaults, + create: create, + clone: clone, + tap: tap, + get: get, + has: has, + mapObject: mapObject, + identity: identity, + constant: constant, + noop: noop, + toPath: toPath$1, + property: property, + propertyOf: propertyOf, + matcher: matcher, + matches: matcher, + times: times, + random: random, + now: now, + escape: _escape, + unescape: _unescape, + templateSettings: templateSettings, + template: template, + result: result, + uniqueId: uniqueId, + chain: chain, + iteratee: iteratee, + partial: partial, + bind: bind, + bindAll: bindAll, + memoize: memoize, + delay: delay, + defer: defer, + throttle: throttle, + debounce: debounce, + wrap: wrap, + negate: negate, + compose: compose, + after: after, + before: before, + once: once, + findKey: findKey, + findIndex: findIndex, + findLastIndex: findLastIndex, + sortedIndex: sortedIndex, + indexOf: indexOf, + lastIndexOf: lastIndexOf, + find: find, + detect: find, + findWhere: findWhere, + each: each, + forEach: each, + map: map, + collect: map, + reduce: reduce, + foldl: reduce, + inject: reduce, + reduceRight: reduceRight, + foldr: reduceRight, + filter: filter, + select: filter, + reject: reject, + every: every, + all: every, + some: some, + any: some, + contains: contains, + includes: contains, + include: contains, + invoke: invoke, + pluck: pluck, + where: where, + max: max, + min: min, + shuffle: shuffle, + sample: sample, + sortBy: sortBy, + groupBy: groupBy, + indexBy: indexBy, + countBy: countBy, + partition: partition, + toArray: toArray, + size: size, + pick: pick, + omit: omit, + first: first, + head: first, + take: first, + initial: initial, + last: last, + rest: rest, + tail: rest, + drop: rest, + compact: compact, + flatten: flatten, + without: without, + uniq: uniq, + unique: uniq, + union: union, + intersection: intersection, + difference: difference, + unzip: unzip, + transpose: unzip, + zip: zip, + object: object, + range: range, + chunk: chunk, + mixin: mixin, + 'default': _$1 + }; + + // Default Export + + // Add all of the Underscore functions to the wrapper object. + var _ = mixin(allExports); + // Legacy Node.js API. + _._ = _; + + return _; + +}))); diff --git a/wp-includes/js/underscore.min.js b/wp-includes/js/underscore.min.js index f0125be..97debd0 100644 --- a/wp-includes/js/underscore.min.js +++ b/wp-includes/js/underscore.min.js @@ -1,10 +1,2 @@ - - -
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/*! This file is auto-generated */ +!function(n,r){var t,e;"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define("underscore",r):(n="undefined"!=typeof globalThis?globalThis:n||self,t=n._,(e=n._=r()).noConflict=function(){return n._=t,e})}(this,function(){var n="1.13.6",r="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},e=Array.prototype,F=Object.prototype,V="undefined"!=typeof Symbol?Symbol.prototype:null,P=e.push,f=e.slice,s=F.toString,q=F.hasOwnProperty,t="undefined"!=typeof ArrayBuffer,u="undefined"!=typeof DataView,U=Array.isArray,W=Object.keys,z=Object.create,L=t&&ArrayBuffer.isView,$=isNaN,C=isFinite,K=!{toString:null}.propertyIsEnumerable("toString"),J=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],G=Math.pow(2,53)-1;function l(u,o){return o=null==o?u.length-1:+o,function(){for(var n=Math.max(arguments.length-o,0),r=Array(n),t=0;t
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/** + * Cookie functions. + * + * @output wp-includes/js/utils.js + */ + +/* global userSettings, getAllUserSettings, wpCookies, setUserSetting */ +/* exported getUserSetting, setUserSetting, deleteUserSetting */ + +window.wpCookies = { +// The following functions are from Cookie.js class in TinyMCE 3, Moxiecode, used under LGPL. + + each: function( obj, cb, scope ) { + var n, l; + + if ( ! obj ) { + return 0; + } + + scope = scope || obj; + + if ( typeof( obj.length ) !== 'undefined' ) { + for ( n = 0, l = obj.length; n < l; n++ ) { + if ( cb.call( scope, obj[n], n, obj ) === false ) { + return 0; + } + } + } else { + for ( n in obj ) { + if ( obj.hasOwnProperty(n) ) { + if ( cb.call( scope, obj[n], n, obj ) === false ) { + return 0; + } + } + } + } + return 1; + }, + + /** + * Get a multi-values cookie. + * Returns a JS object with the name: 'value' pairs. + */ + getHash: function( name ) { + var cookie = this.get( name ), values; + + if ( cookie ) { + this.each( cookie.split('&'), function( pair ) { + pair = pair.split('='); + values = values || {}; + values[pair[0]] = pair[1]; + }); + } + + return values; + }, + + /** + * Set a multi-values cookie. + * + * 'values_obj' is the JS object that is stored. It is encoded as URI in wpCookies.set(). + */ + setHash: function( name, values_obj, expires, path, domain, secure ) { + var str = ''; + + this.each( values_obj, function( val, key ) { + str += ( ! str ? '' : '&' ) + key + '=' + val; + }); + + this.set( name, str, expires, path, domain, secure ); + }, + + /** + * Get a cookie. + */ + get: function( name ) { + var e, b, + cookie = document.cookie, + p = name + '='; + + if ( ! cookie ) { + return; + } + + b = cookie.indexOf( '; ' + p ); + + if ( b === -1 ) { + b = cookie.indexOf(p); + + if ( b !== 0 ) { + return null; + } + } else { + b += 2; + } + + e = cookie.indexOf( ';', b ); + + if ( e === -1 ) { + e = cookie.length; + } + + return decodeURIComponent( cookie.substring( b + p.length, e ) ); + }, + + /** + * Set a cookie. + * + * The 'expires' arg can be either a JS Date() object set to the expiration date (back-compat) + * or the number of seconds until expiration + */ + set: function( name, value, expires, path, domain, secure ) { + var d = new Date(); + + if ( typeof( expires ) === 'object' && expires.toGMTString ) { + expires = expires.toGMTString(); + } else if ( parseInt( expires, 10 ) ) { + d.setTime( d.getTime() + ( parseInt( expires, 10 ) * 1000 ) ); // Time must be in milliseconds. + expires = d.toGMTString(); + } else { + expires = ''; + } + + document.cookie = name + '=' + encodeURIComponent( value ) + + ( expires ? '; expires=' + expires : '' ) + + ( path ? '; path=' + path : '' ) + + ( domain ? '; domain=' + domain : '' ) + + ( secure ? '; secure' : '' ); + }, + + /** + * Remove a cookie. + * + * This is done by setting it to an empty value and setting the expiration time in the past. + */ + remove: function( name, path, domain, secure ) { + this.set( name, '', -1000, path, domain, secure ); + } +}; + +// Returns the value as string. Second arg or empty string is returned when value is not set. +window.getUserSetting = function( name, def ) { + var settings = getAllUserSettings(); + + if ( settings.hasOwnProperty( name ) ) { + return settings[name]; + } + + if ( typeof def !== 'undefined' ) { + return def; + } + + return ''; +}; + +/* + * Both name and value must be only ASCII letters, numbers or underscore + * and the shorter, the better (cookies can store maximum 4KB). Not suitable to store text. + * The value is converted and stored as string. + */ +window.setUserSetting = function( name, value, _del ) { + if ( 'object' !== typeof userSettings ) { + return false; + } + + var uid = userSettings.uid, + settings = wpCookies.getHash( 'wp-settings-' + uid ), + path = userSettings.url, + secure = !! userSettings.secure; + + name = name.toString().replace( /[^A-Za-z0-9_-]/g, '' ); + + if ( typeof value === 'number' ) { + value = parseInt( value, 10 ); + } else { + value = value.toString().replace( /[^A-Za-z0-9_-]/g, '' ); + } + + settings = settings || {}; + + if ( _del ) { + delete settings[name]; + } else { + settings[name] = value; + } + + wpCookies.setHash( 'wp-settings-' + uid, settings, 31536000, path, '', secure ); + wpCookies.set( 'wp-settings-time-' + uid, userSettings.time, 31536000, path, '', secure ); + + return name; +}; + +window.deleteUserSetting = function( name ) { + return setUserSetting( name, '', 1 ); +}; + +// Returns all settings as JS object. +window.getAllUserSettings = function() { + if ( 'object' !== typeof userSettings ) { + return {}; + } + + return wpCookies.getHash( 'wp-settings-' + userSettings.uid ) || {}; +}; diff --git a/wp-includes/js/utils.min.js b/wp-includes/js/utils.min.js index f0125be..424656e 100644 --- a/wp-includes/js/utils.min.js +++ b/wp-includes/js/utils.min.js @@ -1,10 +1,2 @@ - - -
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/*! This file is auto-generated */ +window.wpCookies={each:function(e,t,n){var i,s;if(!e)return 0;if(n=n||e,void 0!==e.length){for(i=0,s=e.length;i
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/** + * @output wp-includes/js/wp-ajax-response.js + */ + + /* global wpAjax */ + +window.wpAjax = jQuery.extend( { + unserialize: function( s ) { + var r = {}, q, pp, i, p; + if ( !s ) { return r; } + q = s.split('?'); if ( q[1] ) { s = q[1]; } + pp = s.split('&'); + for ( i in pp ) { + if ( typeof pp.hasOwnProperty === 'function' && !pp.hasOwnProperty(i) ) { continue; } + p = pp[i].split('='); + r[p[0]] = p[1]; + } + return r; + }, + parseAjaxResponse: function( x, r, e ) { // 1 = good, 0 = strange (bad data?), -1 = you lack permission. + var parsed = {}, re = jQuery('#' + r).empty(), err = '', noticeMessage = ''; + + if ( x && typeof x === 'object' && x.getElementsByTagName('wp_ajax') ) { + parsed.responses = []; + parsed.errors = false; + jQuery('response', x).each( function() { + var th = jQuery(this), child = jQuery(this.firstChild), response; + response = { action: th.attr('action'), what: child.get(0).nodeName, id: child.attr('id'), oldId: child.attr('old_id'), position: child.attr('position') }; + response.data = jQuery( 'response_data', child ).text(); + response.supplemental = {}; + if ( !jQuery( 'supplemental', child ).children().each( function() { + + if ( this.nodeName === 'notice' ) { + noticeMessage += jQuery(this).text(); + return; + } + + response.supplemental[this.nodeName] = jQuery(this).text(); + } ).length ) { response.supplemental = false; } + response.errors = []; + if ( !jQuery('wp_error', child).each( function() { + var code = jQuery(this).attr('code'), anError, errorData, formField; + anError = { code: code, message: this.firstChild.nodeValue, data: false }; + errorData = jQuery('wp_error_data[code="' + code + '"]', x); + if ( errorData ) { anError.data = errorData.get(); } + formField = jQuery( 'form-field', errorData ).text(); + if ( formField ) { code = formField; } + if ( e ) { wpAjax.invalidateForm( jQuery('#' + e + ' :input[name="' + code + '"]' ).parents('.form-field:first') ); } + err += '
' + anError.message + '
'; + response.errors.push( anError ); + parsed.errors = true; + } ).length ) { response.errors = false; } + parsed.responses.push( response ); + } ); + if ( err.length ) { + re.html( '' + err + '
' );
+ wp.a11y.speak( err );
+ } else if ( noticeMessage.length ) {
+ re.html( '' + noticeMessage + '
' + x + '
' + wpAjax.noPerm + '
' + wpAjax.broken + '
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/*! This file is auto-generated */ +window.wpAjax=jQuery.extend({unserialize:function(e){var r,t,i,a,n={};if(e)for(i in t=(e=(r=e.split("?"))[1]?r[1]:e).split("&"))"function"==typeof t.hasOwnProperty&&!t.hasOwnProperty(i)||(n[(a=t[i].split("="))[0]]=a[1]);return n},parseAjaxResponse:function(a,e,n){var o={},e=jQuery("#"+e).empty(),s="",t="";return a&&"object"==typeof a&&a.getElementsByTagName("wp_ajax")?(o.responses=[],o.errors=!1,jQuery("response",a).each(function(){var e=jQuery(this),r=jQuery(this.firstChild),i={action:e.attr("action"),what:r.get(0).nodeName,id:r.attr("id"),oldId:r.attr("old_id"),position:r.attr("position")};i.data=jQuery("response_data",r).text(),i.supplemental={},jQuery("supplemental",r).children().each(function(){"notice"===this.nodeName?t+=jQuery(this).text():i.supplemental[this.nodeName]=jQuery(this).text()}).length||(i.supplemental=!1),i.errors=[],jQuery("wp_error",r).each(function(){var e=jQuery(this).attr("code"),r={code:e,message:this.firstChild.nodeValue,data:!1},t=jQuery('wp_error_data[code="'+e+'"]',a);t&&(r.data=t.get()),(t=jQuery("form-field",t).text())&&(e=t),n&&wpAjax.invalidateForm(jQuery("#"+n+' :input[name="'+e+'"]').parents(".form-field:first")),s+="
"+r.message+"
",i.errors.push(r),o.errors=!0}).length||(i.errors=!1),o.responses.push(i)}),s.length?(e.html(''+s+"
"),wp.a11y.speak(s)):t.length&&(e.html(''+t+"
'+a+"
'+wpAjax.noPerm+"
'+wpAjax.broken+"
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/** + * @output wp-includes/js/wp-api.js + */ + +(function( window, undefined ) { + + 'use strict'; + + /** + * Initialize the WP_API. + */ + function WP_API() { + /** @namespace wp.api.models */ + this.models = {}; + /** @namespace wp.api.collections */ + this.collections = {}; + /** @namespace wp.api.views */ + this.views = {}; + } + + /** @namespace wp */ + window.wp = window.wp || {}; + /** @namespace wp.api */ + wp.api = wp.api || new WP_API(); + wp.api.versionString = wp.api.versionString || 'wp/v2/'; + + // Alias _includes to _.contains, ensuring it is available if lodash is used. + if ( ! _.isFunction( _.includes ) && _.isFunction( _.contains ) ) { + _.includes = _.contains; + } + +})( window ); + +(function( window, undefined ) { + + 'use strict'; + + var pad, r; + + /** @namespace wp */ + window.wp = window.wp || {}; + /** @namespace wp.api */ + wp.api = wp.api || {}; + /** @namespace wp.api.utils */ + wp.api.utils = wp.api.utils || {}; + + /** + * Determine model based on API route. + * + * @param {string} route The API route. + * + * @return {Backbone Model} The model found at given route. Undefined if not found. + */ + wp.api.getModelByRoute = function( route ) { + return _.find( wp.api.models, function( model ) { + return model.prototype.route && route === model.prototype.route.index; + } ); + }; + + /** + * Determine collection based on API route. + * + * @param {string} route The API route. + * + * @return {Backbone Model} The collection found at given route. Undefined if not found. + */ + wp.api.getCollectionByRoute = function( route ) { + return _.find( wp.api.collections, function( collection ) { + return collection.prototype.route && route === collection.prototype.route.index; + } ); + }; + + + /** + * ECMAScript 5 shim, adapted from MDN. + * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString + */ + if ( ! Date.prototype.toISOString ) { + pad = function( number ) { + r = String( number ); + if ( 1 === r.length ) { + r = '0' + r; + } + + return r; + }; + + Date.prototype.toISOString = function() { + return this.getUTCFullYear() + + '-' + pad( this.getUTCMonth() + 1 ) + + '-' + pad( this.getUTCDate() ) + + 'T' + pad( this.getUTCHours() ) + + ':' + pad( this.getUTCMinutes() ) + + ':' + pad( this.getUTCSeconds() ) + + '.' + String( ( this.getUTCMilliseconds() / 1000 ).toFixed( 3 ) ).slice( 2, 5 ) + + 'Z'; + }; + } + + /** + * Parse date into ISO8601 format. + * + * @param {Date} date. + */ + wp.api.utils.parseISO8601 = function( date ) { + var timestamp, struct, i, k, + minutesOffset = 0, + numericKeys = [ 1, 4, 5, 6, 7, 10, 11 ]; + + /* + * ES5 §15.9.4.2 states that the string should attempt to be parsed as a Date Time String Format string + * before falling back to any implementation-specific date parsing, so that’s what we do, even if native + * implementations could be faster. + */ + // 1 YYYY 2 MM 3 DD 4 HH 5 mm 6 ss 7 msec 8 Z 9 ± 10 tzHH 11 tzmm + if ( ( struct = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec( date ) ) ) { + + // Avoid NaN timestamps caused by “undefined” values being passed to Date.UTC. + for ( i = 0; ( k = numericKeys[i] ); ++i ) { + struct[k] = +struct[k] || 0; + } + + // Allow undefined days and months. + struct[2] = ( +struct[2] || 1 ) - 1; + struct[3] = +struct[3] || 1; + + if ( 'Z' !== struct[8] && undefined !== struct[9] ) { + minutesOffset = struct[10] * 60 + struct[11]; + + if ( '+' === struct[9] ) { + minutesOffset = 0 - minutesOffset; + } + } + + timestamp = Date.UTC( struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7] ); + } else { + timestamp = Date.parse ? Date.parse( date ) : NaN; + } + + return timestamp; + }; + + /** + * Helper function for getting the root URL. + * @return {[type]} [description] + */ + wp.api.utils.getRootUrl = function() { + return window.location.origin ? + window.location.origin + '/' : + window.location.protocol + '//' + window.location.host + '/'; + }; + + /** + * Helper for capitalizing strings. + */ + wp.api.utils.capitalize = function( str ) { + if ( _.isUndefined( str ) ) { + return str; + } + return str.charAt( 0 ).toUpperCase() + str.slice( 1 ); + }; + + /** + * Helper function that capitalizes the first word and camel cases any words starting + * after dashes, removing the dashes. + */ + wp.api.utils.capitalizeAndCamelCaseDashes = function( str ) { + if ( _.isUndefined( str ) ) { + return str; + } + str = wp.api.utils.capitalize( str ); + + return wp.api.utils.camelCaseDashes( str ); + }; + + /** + * Helper function to camel case the letter after dashes, removing the dashes. + */ + wp.api.utils.camelCaseDashes = function( str ) { + return str.replace( /-([a-z])/g, function( g ) { + return g[ 1 ].toUpperCase(); + } ); + }; + + /** + * Extract a route part based on negative index. + * + * @param {string} route The endpoint route. + * @param {number} part The number of parts from the end of the route to retrieve. Default 1. + * Example route `/a/b/c`: part 1 is `c`, part 2 is `b`, part 3 is `a`. + * @param {string} [versionString] Version string, defaults to `wp.api.versionString`. + * @param {boolean} [reverse] Whether to reverse the order when extracting the route part. Optional, default false. + */ + wp.api.utils.extractRoutePart = function( route, part, versionString, reverse ) { + var routeParts; + + part = part || 1; + versionString = versionString || wp.api.versionString; + + // Remove versions string from route to avoid returning it. + if ( 0 === route.indexOf( '/' + versionString ) ) { + route = route.substr( versionString.length + 1 ); + } + + routeParts = route.split( '/' ); + if ( reverse ) { + routeParts = routeParts.reverse(); + } + if ( _.isUndefined( routeParts[ --part ] ) ) { + return ''; + } + return routeParts[ part ]; + }; + + /** + * Extract a parent name from a passed route. + * + * @param {string} route The route to extract a name from. + */ + wp.api.utils.extractParentName = function( route ) { + var name, + lastSlash = route.lastIndexOf( '_id>[\\d]+)/' ); + + if ( lastSlash < 0 ) { + return ''; + } + name = route.substr( 0, lastSlash - 1 ); + name = name.split( '/' ); + name.pop(); + name = name.pop(); + return name; + }; + + /** + * Add args and options to a model prototype from a route's endpoints. + * + * @param {Array} routeEndpoints Array of route endpoints. + * @param {Object} modelInstance An instance of the model (or collection) + * to add the args to. + */ + wp.api.utils.decorateFromRoute = function( routeEndpoints, modelInstance ) { + + /** + * Build the args based on route endpoint data. + */ + _.each( routeEndpoints, function( routeEndpoint ) { + + // Add post and edit endpoints as model args. + if ( _.includes( routeEndpoint.methods, 'POST' ) || _.includes( routeEndpoint.methods, 'PUT' ) ) { + + // Add any non-empty args, merging them into the args object. + if ( ! _.isEmpty( routeEndpoint.args ) ) { + + // Set as default if no args yet. + if ( _.isEmpty( modelInstance.prototype.args ) ) { + modelInstance.prototype.args = routeEndpoint.args; + } else { + + // We already have args, merge these new args in. + modelInstance.prototype.args = _.extend( modelInstance.prototype.args, routeEndpoint.args ); + } + } + } else { + + // Add GET method as model options. + if ( _.includes( routeEndpoint.methods, 'GET' ) ) { + + // Add any non-empty args, merging them into the defaults object. + if ( ! _.isEmpty( routeEndpoint.args ) ) { + + // Set as default if no defaults yet. + if ( _.isEmpty( modelInstance.prototype.options ) ) { + modelInstance.prototype.options = routeEndpoint.args; + } else { + + // We already have options, merge these new args in. + modelInstance.prototype.options = _.extend( modelInstance.prototype.options, routeEndpoint.args ); + } + } + + } + } + + } ); + + }; + + /** + * Add mixins and helpers to models depending on their defaults. + * + * @param {Backbone Model} model The model to attach helpers and mixins to. + * @param {string} modelClassName The classname of the constructed model. + * @param {Object} loadingObjects An object containing the models and collections we are building. + */ + wp.api.utils.addMixinsAndHelpers = function( model, modelClassName, loadingObjects ) { + + var hasDate = false, + + /** + * Array of parseable dates. + * + * @type {string[]}. + */ + parseableDates = [ 'date', 'modified', 'date_gmt', 'modified_gmt' ], + + /** + * Mixin for all content that is time stamped. + * + * This mixin converts between mysql timestamps and JavaScript Dates when syncing a model + * to or from the server. For example, a date stored as `2015-12-27T21:22:24` on the server + * gets expanded to `Sun Dec 27 2015 14:22:24 GMT-0700 (MST)` when the model is fetched. + * + * @type {{toJSON: toJSON, parse: parse}}. + */ + TimeStampedMixin = { + + /** + * Prepare a JavaScript Date for transmitting to the server. + * + * This helper function accepts a field and Date object. It converts the passed Date + * to an ISO string and sets that on the model field. + * + * @param {Date} date A JavaScript date object. WordPress expects dates in UTC. + * @param {string} field The date field to set. One of 'date', 'date_gmt', 'date_modified' + * or 'date_modified_gmt'. Optional, defaults to 'date'. + */ + setDate: function( date, field ) { + var theField = field || 'date'; + + // Don't alter non-parsable date fields. + if ( _.indexOf( parseableDates, theField ) < 0 ) { + return false; + } + + this.set( theField, date.toISOString() ); + }, + + /** + * Get a JavaScript Date from the passed field. + * + * WordPress returns 'date' and 'date_modified' in the timezone of the server as well as + * UTC dates as 'date_gmt' and 'date_modified_gmt'. Draft posts do not include UTC dates. + * + * @param {string} field The date field to set. One of 'date', 'date_gmt', 'date_modified' + * or 'date_modified_gmt'. Optional, defaults to 'date'. + */ + getDate: function( field ) { + var theField = field || 'date', + theISODate = this.get( theField ); + + // Only get date fields and non-null values. + if ( _.indexOf( parseableDates, theField ) < 0 || _.isNull( theISODate ) ) { + return false; + } + + return new Date( wp.api.utils.parseISO8601( theISODate ) ); + } + }, + + /** + * Build a helper function to retrieve related model. + * + * @param {string} parentModel The parent model. + * @param {number} modelId The model ID if the object to request + * @param {string} modelName The model name to use when constructing the model. + * @param {string} embedSourcePoint Where to check the embedded object for _embed data. + * @param {string} embedCheckField Which model field to check to see if the model has data. + * + * @return {Deferred.promise} A promise which resolves to the constructed model. + */ + buildModelGetter = function( parentModel, modelId, modelName, embedSourcePoint, embedCheckField ) { + var getModel, embeddedObjects, attributes, deferred; + + deferred = jQuery.Deferred(); + embeddedObjects = parentModel.get( '_embedded' ) || {}; + + // Verify that we have a valid object id. + if ( ! _.isNumber( modelId ) || 0 === modelId ) { + deferred.reject(); + return deferred; + } + + // If we have embedded object data, use that when constructing the getModel. + if ( embeddedObjects[ embedSourcePoint ] ) { + attributes = _.findWhere( embeddedObjects[ embedSourcePoint ], { id: modelId } ); + } + + // Otherwise use the modelId. + if ( ! attributes ) { + attributes = { id: modelId }; + } + + // Create the new getModel model. + getModel = new wp.api.models[ modelName ]( attributes ); + + if ( ! getModel.get( embedCheckField ) ) { + getModel.fetch( { + success: function( getModel ) { + deferred.resolve( getModel ); + }, + error: function( getModel, response ) { + deferred.reject( response ); + } + } ); + } else { + // Resolve with the embedded model. + deferred.resolve( getModel ); + } + + // Return a promise. + return deferred.promise(); + }, + + /** + * Build a helper to retrieve a collection. + * + * @param {string} parentModel The parent model. + * @param {string} collectionName The name to use when constructing the collection. + * @param {string} embedSourcePoint Where to check the embedded object for _embed data. + * @param {string} embedIndex An additional optional index for the _embed data. + * + * @return {Deferred.promise} A promise which resolves to the constructed collection. + */ + buildCollectionGetter = function( parentModel, collectionName, embedSourcePoint, embedIndex ) { + /** + * Returns a promise that resolves to the requested collection + * + * Uses the embedded data if available, otherwise fetches the + * data from the server. + * + * @return {Deferred.promise} promise Resolves to a wp.api.collections[ collectionName ] + * collection. + */ + var postId, embeddedObjects, getObjects, + classProperties = '', + properties = '', + deferred = jQuery.Deferred(); + + postId = parentModel.get( 'id' ); + embeddedObjects = parentModel.get( '_embedded' ) || {}; + + // Verify that we have a valid post ID. + if ( ! _.isNumber( postId ) || 0 === postId ) { + deferred.reject(); + return deferred; + } + + // If we have embedded getObjects data, use that when constructing the getObjects. + if ( ! _.isUndefined( embedSourcePoint ) && ! _.isUndefined( embeddedObjects[ embedSourcePoint ] ) ) { + + // Some embeds also include an index offset, check for that. + if ( _.isUndefined( embedIndex ) ) { + + // Use the embed source point directly. + properties = embeddedObjects[ embedSourcePoint ]; + } else { + + // Add the index to the embed source point. + properties = embeddedObjects[ embedSourcePoint ][ embedIndex ]; + } + } else { + + // Otherwise use the postId. + classProperties = { parent: postId }; + } + + // Create the new getObjects collection. + getObjects = new wp.api.collections[ collectionName ]( properties, classProperties ); + + // If we didn’t have embedded getObjects, fetch the getObjects data. + if ( _.isUndefined( getObjects.models[0] ) ) { + getObjects.fetch( { + success: function( getObjects ) { + + // Add a helper 'parent_post' attribute onto the model. + setHelperParentPost( getObjects, postId ); + deferred.resolve( getObjects ); + }, + error: function( getModel, response ) { + deferred.reject( response ); + } + } ); + } else { + + // Add a helper 'parent_post' attribute onto the model. + setHelperParentPost( getObjects, postId ); + deferred.resolve( getObjects ); + } + + // Return a promise. + return deferred.promise(); + + }, + + /** + * Set the model post parent. + */ + setHelperParentPost = function( collection, postId ) { + + // Attach post_parent id to the collection. + _.each( collection.models, function( model ) { + model.set( 'parent_post', postId ); + } ); + }, + + /** + * Add a helper function to handle post Meta. + */ + MetaMixin = { + + /** + * Get meta by key for a post. + * + * @param {string} key The meta key. + * + * @return {Object} The post meta value. + */ + getMeta: function( key ) { + var metas = this.get( 'meta' ); + return metas[ key ]; + }, + + /** + * Get all meta key/values for a post. + * + * @return {Object} The post metas, as a key value pair object. + */ + getMetas: function() { + return this.get( 'meta' ); + }, + + /** + * Set a group of meta key/values for a post. + * + * @param {Object} meta The post meta to set, as key/value pairs. + */ + setMetas: function( meta ) { + var metas = this.get( 'meta' ); + _.extend( metas, meta ); + this.set( 'meta', metas ); + }, + + /** + * Set a single meta value for a post, by key. + * + * @param {string} key The meta key. + * @param {Object} value The meta value. + */ + setMeta: function( key, value ) { + var metas = this.get( 'meta' ); + metas[ key ] = value; + this.set( 'meta', metas ); + } + }, + + /** + * Add a helper function to handle post Revisions. + */ + RevisionsMixin = { + getRevisions: function() { + return buildCollectionGetter( this, 'PostRevisions' ); + } + }, + + /** + * Add a helper function to handle post Tags. + */ + TagsMixin = { + + /** + * Get the tags for a post. + * + * @return {Deferred.promise} promise Resolves to an array of tags. + */ + getTags: function() { + var tagIds = this.get( 'tags' ), + tags = new wp.api.collections.Tags(); + + // Resolve with an empty array if no tags. + if ( _.isEmpty( tagIds ) ) { + return jQuery.Deferred().resolve( [] ); + } + + return tags.fetch( { data: { include: tagIds } } ); + }, + + /** + * Set the tags for a post. + * + * Accepts an array of tag slugs, or a Tags collection. + * + * @param {Array|Backbone.Collection} tags The tags to set on the post. + * + */ + setTags: function( tags ) { + var allTags, newTag, + self = this, + newTags = []; + + if ( _.isString( tags ) ) { + return false; + } + + // If this is an array of slugs, build a collection. + if ( _.isArray( tags ) ) { + + // Get all the tags. + allTags = new wp.api.collections.Tags(); + allTags.fetch( { + data: { per_page: 100 }, + success: function( alltags ) { + + // Find the passed tags and set them up. + _.each( tags, function( tag ) { + newTag = new wp.api.models.Tag( alltags.findWhere( { slug: tag } ) ); + + // Tie the new tag to the post. + newTag.set( 'parent_post', self.get( 'id' ) ); + + // Add the new tag to the collection. + newTags.push( newTag ); + } ); + tags = new wp.api.collections.Tags( newTags ); + self.setTagsWithCollection( tags ); + } + } ); + + } else { + this.setTagsWithCollection( tags ); + } + }, + + /** + * Set the tags for a post. + * + * Accepts a Tags collection. + * + * @param {Array|Backbone.Collection} tags The tags to set on the post. + * + */ + setTagsWithCollection: function( tags ) { + + // Pluck out the category IDs. + this.set( 'tags', tags.pluck( 'id' ) ); + return this.save(); + } + }, + + /** + * Add a helper function to handle post Categories. + */ + CategoriesMixin = { + + /** + * Get a the categories for a post. + * + * @return {Deferred.promise} promise Resolves to an array of categories. + */ + getCategories: function() { + var categoryIds = this.get( 'categories' ), + categories = new wp.api.collections.Categories(); + + // Resolve with an empty array if no categories. + if ( _.isEmpty( categoryIds ) ) { + return jQuery.Deferred().resolve( [] ); + } + + return categories.fetch( { data: { include: categoryIds } } ); + }, + + /** + * Set the categories for a post. + * + * Accepts an array of category slugs, or a Categories collection. + * + * @param {Array|Backbone.Collection} categories The categories to set on the post. + * + */ + setCategories: function( categories ) { + var allCategories, newCategory, + self = this, + newCategories = []; + + if ( _.isString( categories ) ) { + return false; + } + + // If this is an array of slugs, build a collection. + if ( _.isArray( categories ) ) { + + // Get all the categories. + allCategories = new wp.api.collections.Categories(); + allCategories.fetch( { + data: { per_page: 100 }, + success: function( allcats ) { + + // Find the passed categories and set them up. + _.each( categories, function( category ) { + newCategory = new wp.api.models.Category( allcats.findWhere( { slug: category } ) ); + + // Tie the new category to the post. + newCategory.set( 'parent_post', self.get( 'id' ) ); + + // Add the new category to the collection. + newCategories.push( newCategory ); + } ); + categories = new wp.api.collections.Categories( newCategories ); + self.setCategoriesWithCollection( categories ); + } + } ); + + } else { + this.setCategoriesWithCollection( categories ); + } + + }, + + /** + * Set the categories for a post. + * + * Accepts Categories collection. + * + * @param {Array|Backbone.Collection} categories The categories to set on the post. + * + */ + setCategoriesWithCollection: function( categories ) { + + // Pluck out the category IDs. + this.set( 'categories', categories.pluck( 'id' ) ); + return this.save(); + } + }, + + /** + * Add a helper function to retrieve the author user model. + */ + AuthorMixin = { + getAuthorUser: function() { + return buildModelGetter( this, this.get( 'author' ), 'User', 'author', 'name' ); + } + }, + + /** + * Add a helper function to retrieve the featured media. + */ + FeaturedMediaMixin = { + getFeaturedMedia: function() { + return buildModelGetter( this, this.get( 'featured_media' ), 'Media', 'wp:featuredmedia', 'source_url' ); + } + }; + + // Exit if we don't have valid model defaults. + if ( _.isUndefined( model.prototype.args ) ) { + return model; + } + + // Go thru the parsable date fields, if our model contains any of them it gets the TimeStampedMixin. + _.each( parseableDates, function( theDateKey ) { + if ( ! _.isUndefined( model.prototype.args[ theDateKey ] ) ) { + hasDate = true; + } + } ); + + // Add the TimeStampedMixin for models that contain a date field. + if ( hasDate ) { + model = model.extend( TimeStampedMixin ); + } + + // Add the AuthorMixin for models that contain an author. + if ( ! _.isUndefined( model.prototype.args.author ) ) { + model = model.extend( AuthorMixin ); + } + + // Add the FeaturedMediaMixin for models that contain a featured_media. + if ( ! _.isUndefined( model.prototype.args.featured_media ) ) { + model = model.extend( FeaturedMediaMixin ); + } + + // Add the CategoriesMixin for models that support categories collections. + if ( ! _.isUndefined( model.prototype.args.categories ) ) { + model = model.extend( CategoriesMixin ); + } + + // Add the MetaMixin for models that support meta. + if ( ! _.isUndefined( model.prototype.args.meta ) ) { + model = model.extend( MetaMixin ); + } + + // Add the TagsMixin for models that support tags collections. + if ( ! _.isUndefined( model.prototype.args.tags ) ) { + model = model.extend( TagsMixin ); + } + + // Add the RevisionsMixin for models that support revisions collections. + if ( ! _.isUndefined( loadingObjects.collections[ modelClassName + 'Revisions' ] ) ) { + model = model.extend( RevisionsMixin ); + } + + return model; + }; + +})( window ); + +/* global wpApiSettings:false */ + +// Suppress warning about parse function's unused "options" argument: +/* jshint unused:false */ +(function() { + + 'use strict'; + + var wpApiSettings = window.wpApiSettings || {}, + trashableTypes = [ 'Comment', 'Media', 'Comment', 'Post', 'Page', 'Status', 'Taxonomy', 'Type' ]; + + /** + * Backbone base model for all models. + */ + wp.api.WPApiBaseModel = Backbone.Model.extend( + /** @lends WPApiBaseModel.prototype */ + { + + // Initialize the model. + initialize: function() { + + /** + * Types that don't support trashing require passing ?force=true to delete. + * + */ + if ( -1 === _.indexOf( trashableTypes, this.name ) ) { + this.requireForceForDelete = true; + } + }, + + /** + * Set nonce header before every Backbone sync. + * + * @param {string} method. + * @param {Backbone.Model} model. + * @param {{beforeSend}, *} options. + * @return {*}. + */ + sync: function( method, model, options ) { + var beforeSend; + + options = options || {}; + + // Remove date_gmt if null. + if ( _.isNull( model.get( 'date_gmt' ) ) ) { + model.unset( 'date_gmt' ); + } + + // Remove slug if empty. + if ( _.isEmpty( model.get( 'slug' ) ) ) { + model.unset( 'slug' ); + } + + if ( _.isFunction( model.nonce ) && ! _.isEmpty( model.nonce() ) ) { + beforeSend = options.beforeSend; + + // @todo Enable option for jsonp endpoints. + // options.dataType = 'jsonp'; + + // Include the nonce with requests. + options.beforeSend = function( xhr ) { + xhr.setRequestHeader( 'X-WP-Nonce', model.nonce() ); + + if ( beforeSend ) { + return beforeSend.apply( this, arguments ); + } + }; + + // Update the nonce when a new nonce is returned with the response. + options.complete = function( xhr ) { + var returnedNonce = xhr.getResponseHeader( 'X-WP-Nonce' ); + + if ( returnedNonce && _.isFunction( model.nonce ) && model.nonce() !== returnedNonce ) { + model.endpointModel.set( 'nonce', returnedNonce ); + } + }; + } + + // Add '?force=true' to use delete method when required. + if ( this.requireForceForDelete && 'delete' === method ) { + model.url = model.url() + '?force=true'; + } + return Backbone.sync( method, model, options ); + }, + + /** + * Save is only allowed when the PUT OR POST methods are available for the endpoint. + */ + save: function( attrs, options ) { + + // Do we have the put method, then execute the save. + if ( _.includes( this.methods, 'PUT' ) || _.includes( this.methods, 'POST' ) ) { + + // Proxy the call to the original save function. + return Backbone.Model.prototype.save.call( this, attrs, options ); + } else { + + // Otherwise bail, disallowing action. + return false; + } + }, + + /** + * Delete is only allowed when the DELETE method is available for the endpoint. + */ + destroy: function( options ) { + + // Do we have the DELETE method, then execute the destroy. + if ( _.includes( this.methods, 'DELETE' ) ) { + + // Proxy the call to the original save function. + return Backbone.Model.prototype.destroy.call( this, options ); + } else { + + // Otherwise bail, disallowing action. + return false; + } + } + + } + ); + + /** + * API Schema model. Contains meta information about the API. + */ + wp.api.models.Schema = wp.api.WPApiBaseModel.extend( + /** @lends Schema.prototype */ + { + defaults: { + _links: {}, + namespace: null, + routes: {} + }, + + initialize: function( attributes, options ) { + var model = this; + options = options || {}; + + wp.api.WPApiBaseModel.prototype.initialize.call( model, attributes, options ); + + model.apiRoot = options.apiRoot || wpApiSettings.root; + model.versionString = options.versionString || wpApiSettings.versionString; + }, + + url: function() { + return this.apiRoot + this.versionString; + } + } + ); +})(); + +( function() { + + 'use strict'; + + var wpApiSettings = window.wpApiSettings || {}; + + /** + * Contains basic collection functionality such as pagination. + */ + wp.api.WPApiBaseCollection = Backbone.Collection.extend( + /** @lends BaseCollection.prototype */ + { + + /** + * Setup default state. + */ + initialize: function( models, options ) { + this.state = { + data: {}, + currentPage: null, + totalPages: null, + totalObjects: null + }; + if ( _.isUndefined( options ) ) { + this.parent = ''; + } else { + this.parent = options.parent; + } + }, + + /** + * Extend Backbone.Collection.sync to add nince and pagination support. + * + * Set nonce header before every Backbone sync. + * + * @param {string} method. + * @param {Backbone.Model} model. + * @param {{success}, *} options. + * @return {*}. + */ + sync: function( method, model, options ) { + var beforeSend, success, + self = this; + + options = options || {}; + + if ( _.isFunction( model.nonce ) && ! _.isEmpty( model.nonce() ) ) { + beforeSend = options.beforeSend; + + // Include the nonce with requests. + options.beforeSend = function( xhr ) { + xhr.setRequestHeader( 'X-WP-Nonce', model.nonce() ); + + if ( beforeSend ) { + return beforeSend.apply( self, arguments ); + } + }; + + // Update the nonce when a new nonce is returned with the response. + options.complete = function( xhr ) { + var returnedNonce = xhr.getResponseHeader( 'X-WP-Nonce' ); + + if ( returnedNonce && _.isFunction( model.nonce ) && model.nonce() !== returnedNonce ) { + model.endpointModel.set( 'nonce', returnedNonce ); + } + }; + } + + // When reading, add pagination data. + if ( 'read' === method ) { + if ( options.data ) { + self.state.data = _.clone( options.data ); + + delete self.state.data.page; + } else { + self.state.data = options.data = {}; + } + + if ( 'undefined' === typeof options.data.page ) { + self.state.currentPage = null; + self.state.totalPages = null; + self.state.totalObjects = null; + } else { + self.state.currentPage = options.data.page - 1; + } + + success = options.success; + options.success = function( data, textStatus, request ) { + if ( ! _.isUndefined( request ) ) { + self.state.totalPages = parseInt( request.getResponseHeader( 'x-wp-totalpages' ), 10 ); + self.state.totalObjects = parseInt( request.getResponseHeader( 'x-wp-total' ), 10 ); + } + + if ( null === self.state.currentPage ) { + self.state.currentPage = 1; + } else { + self.state.currentPage++; + } + + if ( success ) { + return success.apply( this, arguments ); + } + }; + } + + // Continue by calling Backbone's sync. + return Backbone.sync( method, model, options ); + }, + + /** + * Fetches the next page of objects if a new page exists. + * + * @param {data: {page}} options. + * @return {*}. + */ + more: function( options ) { + options = options || {}; + options.data = options.data || {}; + + _.extend( options.data, this.state.data ); + + if ( 'undefined' === typeof options.data.page ) { + if ( ! this.hasMore() ) { + return false; + } + + if ( null === this.state.currentPage || this.state.currentPage <= 1 ) { + options.data.page = 2; + } else { + options.data.page = this.state.currentPage + 1; + } + } + + return this.fetch( options ); + }, + + /** + * Returns true if there are more pages of objects available. + * + * @return {null|boolean} + */ + hasMore: function() { + if ( null === this.state.totalPages || + null === this.state.totalObjects || + null === this.state.currentPage ) { + return null; + } else { + return ( this.state.currentPage < this.state.totalPages ); + } + } + } + ); + +} )(); + +( function() { + + 'use strict'; + + var Endpoint, initializedDeferreds = {}, + wpApiSettings = window.wpApiSettings || {}; + + /** @namespace wp */ + window.wp = window.wp || {}; + + /** @namespace wp.api */ + wp.api = wp.api || {}; + + // If wpApiSettings is unavailable, try the default. + if ( _.isEmpty( wpApiSettings ) ) { + wpApiSettings.root = window.location.origin + '/wp-json/'; + } + + Endpoint = Backbone.Model.extend(/** @lends Endpoint.prototype */{ + defaults: { + apiRoot: wpApiSettings.root, + versionString: wp.api.versionString, + nonce: null, + schema: null, + models: {}, + collections: {} + }, + + /** + * Initialize the Endpoint model. + */ + initialize: function() { + var model = this, deferred; + + Backbone.Model.prototype.initialize.apply( model, arguments ); + + deferred = jQuery.Deferred(); + model.schemaConstructed = deferred.promise(); + + model.schemaModel = new wp.api.models.Schema( null, { + apiRoot: model.get( 'apiRoot' ), + versionString: model.get( 'versionString' ), + nonce: model.get( 'nonce' ) + } ); + + // When the model loads, resolve the promise. + model.schemaModel.once( 'change', function() { + model.constructFromSchema(); + deferred.resolve( model ); + } ); + + if ( model.get( 'schema' ) ) { + + // Use schema supplied as model attribute. + model.schemaModel.set( model.schemaModel.parse( model.get( 'schema' ) ) ); + } else if ( + ! _.isUndefined( sessionStorage ) && + ( _.isUndefined( wpApiSettings.cacheSchema ) || wpApiSettings.cacheSchema ) && + sessionStorage.getItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ) ) + ) { + + // Used a cached copy of the schema model if available. + model.schemaModel.set( model.schemaModel.parse( JSON.parse( sessionStorage.getItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ) ) ) ) ); + } else { + model.schemaModel.fetch( { + /** + * When the server returns the schema model data, store the data in a sessionCache so we don't + * have to retrieve it again for this session. Then, construct the models and collections based + * on the schema model data. + * + * @ignore + */ + success: function( newSchemaModel ) { + + // Store a copy of the schema model in the session cache if available. + if ( ! _.isUndefined( sessionStorage ) && ( _.isUndefined( wpApiSettings.cacheSchema ) || wpApiSettings.cacheSchema ) ) { + try { + sessionStorage.setItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ), JSON.stringify( newSchemaModel ) ); + } catch ( error ) { + + // Fail silently, fixes errors in safari private mode. + } + } + }, + + // Log the error condition. + error: function( err ) { + window.console.log( err ); + } + } ); + } + }, + + constructFromSchema: function() { + var routeModel = this, modelRoutes, collectionRoutes, schemaRoot, loadingObjects, + + /** + * Set up the model and collection name mapping options. As the schema is built, the + * model and collection names will be adjusted if they are found in the mapping object. + * + * Localizing a variable wpApiSettings.mapping will over-ride the default mapping options. + * + */ + mapping = wpApiSettings.mapping || { + models: { + 'Categories': 'Category', + 'Comments': 'Comment', + 'Pages': 'Page', + 'PagesMeta': 'PageMeta', + 'PagesRevisions': 'PageRevision', + 'Posts': 'Post', + 'PostsCategories': 'PostCategory', + 'PostsRevisions': 'PostRevision', + 'PostsTags': 'PostTag', + 'Schema': 'Schema', + 'Statuses': 'Status', + 'Tags': 'Tag', + 'Taxonomies': 'Taxonomy', + 'Types': 'Type', + 'Users': 'User' + }, + collections: { + 'PagesMeta': 'PageMeta', + 'PagesRevisions': 'PageRevisions', + 'PostsCategories': 'PostCategories', + 'PostsMeta': 'PostMeta', + 'PostsRevisions': 'PostRevisions', + 'PostsTags': 'PostTags' + } + }, + + modelEndpoints = routeModel.get( 'modelEndpoints' ), + modelRegex = new RegExp( '(?:.*[+)]|\/(' + modelEndpoints.join( '|' ) + '))$' ); + + /** + * Iterate thru the routes, picking up models and collections to build. Builds two arrays, + * one for models and one for collections. + */ + modelRoutes = []; + collectionRoutes = []; + schemaRoot = routeModel.get( 'apiRoot' ).replace( wp.api.utils.getRootUrl(), '' ); + loadingObjects = {}; + + /** + * Tracking objects for models and collections. + */ + loadingObjects.models = {}; + loadingObjects.collections = {}; + + _.each( routeModel.schemaModel.get( 'routes' ), function( route, index ) { + + // Skip the schema root if included in the schema. + if ( index !== routeModel.get( ' versionString' ) && + index !== schemaRoot && + index !== ( '/' + routeModel.get( 'versionString' ).slice( 0, -1 ) ) + ) { + + // Single items end with a regex, or a special case word. + if ( modelRegex.test( index ) ) { + modelRoutes.push( { index: index, route: route } ); + } else { + + // Collections end in a name. + collectionRoutes.push( { index: index, route: route } ); + } + } + } ); + + /** + * Construct the models. + * + * Base the class name on the route endpoint. + */ + _.each( modelRoutes, function( modelRoute ) { + + // Extract the name and any parent from the route. + var modelClassName, + routeName = wp.api.utils.extractRoutePart( modelRoute.index, 2, routeModel.get( 'versionString' ), true ), + parentName = wp.api.utils.extractRoutePart( modelRoute.index, 1, routeModel.get( 'versionString' ), false ), + routeEnd = wp.api.utils.extractRoutePart( modelRoute.index, 1, routeModel.get( 'versionString' ), true ); + + // Clear the parent part of the rouite if its actually the version string. + if ( parentName === routeModel.get( 'versionString' ) ) { + parentName = ''; + } + + // Handle the special case of the 'me' route. + if ( 'me' === routeEnd ) { + routeName = 'me'; + } + + // If the model has a parent in its route, add that to its class name. + if ( '' !== parentName && parentName !== routeName ) { + modelClassName = wp.api.utils.capitalizeAndCamelCaseDashes( parentName ) + wp.api.utils.capitalizeAndCamelCaseDashes( routeName ); + modelClassName = mapping.models[ modelClassName ] || modelClassName; + loadingObjects.models[ modelClassName ] = wp.api.WPApiBaseModel.extend( { + + // Return a constructed url based on the parent and id. + url: function() { + var url = + routeModel.get( 'apiRoot' ) + + routeModel.get( 'versionString' ) + + parentName + '/' + + ( ( _.isUndefined( this.get( 'parent' ) ) || 0 === this.get( 'parent' ) ) ? + ( _.isUndefined( this.get( 'parent_post' ) ) ? '' : this.get( 'parent_post' ) + '/' ) : + this.get( 'parent' ) + '/' ) + + routeName; + + if ( ! _.isUndefined( this.get( 'id' ) ) ) { + url += '/' + this.get( 'id' ); + } + return url; + }, + + // Track nonces on the Endpoint 'routeModel'. + nonce: function() { + return routeModel.get( 'nonce' ); + }, + + endpointModel: routeModel, + + // Include a reference to the original route object. + route: modelRoute, + + // Include a reference to the original class name. + name: modelClassName, + + // Include the array of route methods for easy reference. + methods: modelRoute.route.methods, + + // Include the array of route endpoints for easy reference. + endpoints: modelRoute.route.endpoints + } ); + } else { + + // This is a model without a parent in its route. + modelClassName = wp.api.utils.capitalizeAndCamelCaseDashes( routeName ); + modelClassName = mapping.models[ modelClassName ] || modelClassName; + loadingObjects.models[ modelClassName ] = wp.api.WPApiBaseModel.extend( { + + // Function that returns a constructed url based on the ID. + url: function() { + var url = routeModel.get( 'apiRoot' ) + + routeModel.get( 'versionString' ) + + ( ( 'me' === routeName ) ? 'users/me' : routeName ); + + if ( ! _.isUndefined( this.get( 'id' ) ) ) { + url += '/' + this.get( 'id' ); + } + return url; + }, + + // Track nonces at the Endpoint level. + nonce: function() { + return routeModel.get( 'nonce' ); + }, + + endpointModel: routeModel, + + // Include a reference to the original route object. + route: modelRoute, + + // Include a reference to the original class name. + name: modelClassName, + + // Include the array of route methods for easy reference. + methods: modelRoute.route.methods, + + // Include the array of route endpoints for easy reference. + endpoints: modelRoute.route.endpoints + } ); + } + + // Add defaults to the new model, pulled form the endpoint. + wp.api.utils.decorateFromRoute( + modelRoute.route.endpoints, + loadingObjects.models[ modelClassName ], + routeModel.get( 'versionString' ) + ); + + } ); + + /** + * Construct the collections. + * + * Base the class name on the route endpoint. + */ + _.each( collectionRoutes, function( collectionRoute ) { + + // Extract the name and any parent from the route. + var collectionClassName, modelClassName, + routeName = collectionRoute.index.slice( collectionRoute.index.lastIndexOf( '/' ) + 1 ), + parentName = wp.api.utils.extractRoutePart( collectionRoute.index, 1, routeModel.get( 'versionString' ), false ); + + // If the collection has a parent in its route, add that to its class name. + if ( '' !== parentName && parentName !== routeName && routeModel.get( 'versionString' ) !== parentName ) { + + collectionClassName = wp.api.utils.capitalizeAndCamelCaseDashes( parentName ) + wp.api.utils.capitalizeAndCamelCaseDashes( routeName ); + modelClassName = mapping.models[ collectionClassName ] || collectionClassName; + collectionClassName = mapping.collections[ collectionClassName ] || collectionClassName; + loadingObjects.collections[ collectionClassName ] = wp.api.WPApiBaseCollection.extend( { + + // Function that returns a constructed url passed on the parent. + url: function() { + return routeModel.get( 'apiRoot' ) + routeModel.get( 'versionString' ) + + parentName + '/' + + ( ( _.isUndefined( this.parent ) || '' === this.parent ) ? + ( _.isUndefined( this.get( 'parent_post' ) ) ? '' : this.get( 'parent_post' ) + '/' ) : + this.parent + '/' ) + + routeName; + }, + + // Specify the model that this collection contains. + model: function( attrs, options ) { + return new loadingObjects.models[ modelClassName ]( attrs, options ); + }, + + // Track nonces at the Endpoint level. + nonce: function() { + return routeModel.get( 'nonce' ); + }, + + endpointModel: routeModel, + + // Include a reference to the original class name. + name: collectionClassName, + + // Include a reference to the original route object. + route: collectionRoute, + + // Include the array of route methods for easy reference. + methods: collectionRoute.route.methods + } ); + } else { + + // This is a collection without a parent in its route. + collectionClassName = wp.api.utils.capitalizeAndCamelCaseDashes( routeName ); + modelClassName = mapping.models[ collectionClassName ] || collectionClassName; + collectionClassName = mapping.collections[ collectionClassName ] || collectionClassName; + loadingObjects.collections[ collectionClassName ] = wp.api.WPApiBaseCollection.extend( { + + // For the url of a root level collection, use a string. + url: function() { + return routeModel.get( 'apiRoot' ) + routeModel.get( 'versionString' ) + routeName; + }, + + // Specify the model that this collection contains. + model: function( attrs, options ) { + return new loadingObjects.models[ modelClassName ]( attrs, options ); + }, + + // Track nonces at the Endpoint level. + nonce: function() { + return routeModel.get( 'nonce' ); + }, + + endpointModel: routeModel, + + // Include a reference to the original class name. + name: collectionClassName, + + // Include a reference to the original route object. + route: collectionRoute, + + // Include the array of route methods for easy reference. + methods: collectionRoute.route.methods + } ); + } + + // Add defaults to the new model, pulled form the endpoint. + wp.api.utils.decorateFromRoute( collectionRoute.route.endpoints, loadingObjects.collections[ collectionClassName ] ); + } ); + + // Add mixins and helpers for each of the models. + _.each( loadingObjects.models, function( model, index ) { + loadingObjects.models[ index ] = wp.api.utils.addMixinsAndHelpers( model, index, loadingObjects ); + } ); + + // Set the routeModel models and collections. + routeModel.set( 'models', loadingObjects.models ); + routeModel.set( 'collections', loadingObjects.collections ); + + } + + } ); + + wp.api.endpoints = new Backbone.Collection(); + + /** + * Initialize the wp-api, optionally passing the API root. + * + * @param {Object} [args] + * @param {string} [args.nonce] The nonce. Optional, defaults to wpApiSettings.nonce. + * @param {string} [args.apiRoot] The api root. Optional, defaults to wpApiSettings.root. + * @param {string} [args.versionString] The version string. Optional, defaults to wpApiSettings.root. + * @param {Object} [args.schema] The schema. Optional, will be fetched from API if not provided. + */ + wp.api.init = function( args ) { + var endpoint, attributes = {}, deferred, promise; + + args = args || {}; + attributes.nonce = _.isString( args.nonce ) ? args.nonce : ( wpApiSettings.nonce || '' ); + attributes.apiRoot = args.apiRoot || wpApiSettings.root || '/wp-json'; + attributes.versionString = args.versionString || wpApiSettings.versionString || 'wp/v2/'; + attributes.schema = args.schema || null; + attributes.modelEndpoints = args.modelEndpoints || [ 'me', 'settings' ]; + if ( ! attributes.schema && attributes.apiRoot === wpApiSettings.root && attributes.versionString === wpApiSettings.versionString ) { + attributes.schema = wpApiSettings.schema; + } + + if ( ! initializedDeferreds[ attributes.apiRoot + attributes.versionString ] ) { + + // Look for an existing copy of this endpoint. + endpoint = wp.api.endpoints.findWhere( { 'apiRoot': attributes.apiRoot, 'versionString': attributes.versionString } ); + if ( ! endpoint ) { + endpoint = new Endpoint( attributes ); + } + deferred = jQuery.Deferred(); + promise = deferred.promise(); + + endpoint.schemaConstructed.done( function( resolvedEndpoint ) { + wp.api.endpoints.add( resolvedEndpoint ); + + // Map the default endpoints, extending any already present items (including Schema model). + wp.api.models = _.extend( wp.api.models, resolvedEndpoint.get( 'models' ) ); + wp.api.collections = _.extend( wp.api.collections, resolvedEndpoint.get( 'collections' ) ); + deferred.resolve( resolvedEndpoint ); + } ); + initializedDeferreds[ attributes.apiRoot + attributes.versionString ] = promise; + } + return initializedDeferreds[ attributes.apiRoot + attributes.versionString ]; + }; + + /** + * Construct the default endpoints and add to an endpoints collection. + */ + + // The wp.api.init function returns a promise that will resolve with the endpoint once it is ready. + wp.api.loadPromise = wp.api.init(); + +} )(); diff --git a/wp-includes/js/wp-api.min.js b/wp-includes/js/wp-api.min.js index f0125be..0107864 100644 --- a/wp-includes/js/wp-api.min.js +++ b/wp-includes/js/wp-api.min.js @@ -1,10 +1,2 @@ - - -
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/*! This file is auto-generated */ +!function(e){"use strict";e.wp=e.wp||{},wp.api=wp.api||new function(){this.models={},this.collections={},this.views={}},wp.api.versionString=wp.api.versionString||"wp/v2/",!_.isFunction(_.includes)&&_.isFunction(_.contains)&&(_.includes=_.contains)}(window),function(e){"use strict";var t,i;e.wp=e.wp||{},wp.api=wp.api||{},wp.api.utils=wp.api.utils||{},wp.api.getModelByRoute=function(t){return _.find(wp.api.models,function(e){return e.prototype.route&&t===e.prototype.route.index})},wp.api.getCollectionByRoute=function(t){return _.find(wp.api.collections,function(e){return e.prototype.route&&t===e.prototype.route.index})},Date.prototype.toISOString||(t=function(e){return i=1===(i=String(e)).length?"0"+i:i},Date.prototype.toISOString=function(){return this.getUTCFullYear()+"-"+t(this.getUTCMonth()+1)+"-"+t(this.getUTCDate())+"T"+t(this.getUTCHours())+":"+t(this.getUTCMinutes())+":"+t(this.getUTCSeconds())+"."+String((this.getUTCMilliseconds()/1e3).toFixed(3)).slice(2,5)+"Z"}),wp.api.utils.parseISO8601=function(e){var t,i,n,o,s=0,a=[1,4,5,6,7,10,11];if(i=/^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(e)){for(n=0;o=a[n];++n)i[o]=+i[o]||0;i[2]=(+i[2]||1)-1,i[3]=+i[3]||1,"Z"!==i[8]&&void 0!==i[9]&&(s=60*i[10]+i[11],"+"===i[9])&&(s=0-s),t=Date.UTC(i[1],i[2],i[3],i[4],i[5]+s,i[6],i[7])}else t=Date.parse?Date.parse(e):NaN;return t},wp.api.utils.getRootUrl=function(){return e.location.origin?e.location.origin+"/":e.location.protocol+"//"+e.location.host+"/"},wp.api.utils.capitalize=function(e){return _.isUndefined(e)?e:e.charAt(0).toUpperCase()+e.slice(1)},wp.api.utils.capitalizeAndCamelCaseDashes=function(e){return _.isUndefined(e)?e:(e=wp.api.utils.capitalize(e),wp.api.utils.camelCaseDashes(e))},wp.api.utils.camelCaseDashes=function(e){return e.replace(/-([a-z])/g,function(e){return e[1].toUpperCase()})},wp.api.utils.extractRoutePart=function(e,t,i,n){return t=t||1,i=i||wp.api.versionString,i=(e=0===e.indexOf("/"+i)?e.substr(i.length+1):e).split("/"),n&&(i=i.reverse()),_.isUndefined(i[--t])?"":i[t]},wp.api.utils.extractParentName=function(e){var t=e.lastIndexOf("_id>[\\d]+)/");return t<0?"":((e=(e=e.substr(0,t-1)).split("/")).pop(),e.pop())},wp.api.utils.decorateFromRoute=function(e,t){_.each(e,function(e){_.includes(e.methods,"POST")||_.includes(e.methods,"PUT")?_.isEmpty(e.args)||(_.isEmpty(t.prototype.args)?t.prototype.args=e.args:t.prototype.args=_.extend(t.prototype.args,e.args)):_.includes(e.methods,"GET")&&!_.isEmpty(e.args)&&(_.isEmpty(t.prototype.options)?t.prototype.options=e.args:t.prototype.options=_.extend(t.prototype.options,e.args))})},wp.api.utils.addMixinsAndHelpers=function(t,e,i){function n(e,t,i,n,o){var s,a=jQuery.Deferred(),e=e.get("_embedded")||{};return _.isNumber(t)&&0!==t?(s=(s=e[n]?_.findWhere(e[n],{id:t}):s)||{id:t},(e=new wp.api.models[i](s)).get(o)?a.resolve(e):e.fetch({success:function(e){a.resolve(e)},error:function(e,t){a.reject(t)}}),a.promise()):(a.reject(),a)}function p(e,t){_.each(e.models,function(e){e.set("parent_post",t)})}var o=!1,s=["date","modified","date_gmt","modified_gmt"],a={setDate:function(e,t){t=t||"date";if(_.indexOf(s,t)<0)return!1;this.set(t,e.toISOString())},getDate:function(e){var e=e||"date",t=this.get(e);return!(_.indexOf(s,e)<0||_.isNull(t))&&new Date(wp.api.utils.parseISO8601(t))}},r={getMeta:function(e){return this.get("meta")[e]},getMetas:function(){return this.get("meta")},setMetas:function(e){var t=this.get("meta");_.extend(t,e),this.set("meta",t)},setMeta:function(e,t){var i=this.get("meta");i[e]=t,this.set("meta",i)}},c={getRevisions:function(){return e=this,t="PostRevisions",s=o="",a=jQuery.Deferred(),r=e.get("id"),e=e.get("_embedded")||{},_.isNumber(r)&&0!==r?(_.isUndefined(i)||_.isUndefined(e[i])?o={parent:r}:s=_.isUndefined(n)?e[i]:e[i][n],e=new wp.api.collections[t](s,o),_.isUndefined(e.models[0])?e.fetch({success:function(e){p(e,r),a.resolve(e)},error:function(e,t){a.reject(t)}}):(p(e,r),a.resolve(e)),a.promise()):(a.reject(),a);var e,t,i,n,o,s,a,r}},d={getTags:function(){var e=this.get("tags"),t=new wp.api.collections.Tags;return _.isEmpty(e)?jQuery.Deferred().resolve([]):t.fetch({data:{include:e}})},setTags:function(e){var i,n=this,o=[];if(_.isString(e))return!1;_.isArray(e)?(new wp.api.collections.Tags).fetch({data:{per_page:100},success:function(t){_.each(e,function(e){(i=new wp.api.models.Tag(t.findWhere({slug:e}))).set("parent_post",n.get("id")),o.push(i)}),e=new wp.api.collections.Tags(o),n.setTagsWithCollection(e)}}):this.setTagsWithCollection(e)},setTagsWithCollection:function(e){return this.set("tags",e.pluck("id")),this.save()}},l={getCategories:function(){var e=this.get("categories"),t=new wp.api.collections.Categories;return _.isEmpty(e)?jQuery.Deferred().resolve([]):t.fetch({data:{include:e}})},setCategories:function(e){var i,n=this,o=[];if(_.isString(e))return!1;_.isArray(e)?(new wp.api.collections.Categories).fetch({data:{per_page:100},success:function(t){_.each(e,function(e){(i=new wp.api.models.Category(t.findWhere({slug:e}))).set("parent_post",n.get("id")),o.push(i)}),e=new wp.api.collections.Categories(o),n.setCategoriesWithCollection(e)}}):this.setCategoriesWithCollection(e)},setCategoriesWithCollection:function(e){return this.set("categories",e.pluck("id")),this.save()}},u={getAuthorUser:function(){return n(this,this.get("author"),"User","author","name")}},g={getFeaturedMedia:function(){return n(this,this.get("featured_media"),"Media","wp:featuredmedia","source_url")}};return t=_.isUndefined(t.prototype.args)||(_.each(s,function(e){_.isUndefined(t.prototype.args[e])||(o=!0)}),o&&(t=t.extend(a)),_.isUndefined(t.prototype.args.author)||(t=t.extend(u)),_.isUndefined(t.prototype.args.featured_media)||(t=t.extend(g)),_.isUndefined(t.prototype.args.categories)||(t=t.extend(l)),_.isUndefined(t.prototype.args.meta)||(t=t.extend(r)),_.isUndefined(t.prototype.args.tags)||(t=t.extend(d)),_.isUndefined(i.collections[e+"Revisions"]))?t:t.extend(c)}}(window),function(){"use strict";var i=window.wpApiSettings||{},e=["Comment","Media","Comment","Post","Page","Status","Taxonomy","Type"];wp.api.WPApiBaseModel=Backbone.Model.extend({initialize:function(){-1===_.indexOf(e,this.name)&&(this.requireForceForDelete=!0)},sync:function(e,t,i){var n;return i=i||{},_.isNull(t.get("date_gmt"))&&t.unset("date_gmt"),_.isEmpty(t.get("slug"))&&t.unset("slug"),_.isFunction(t.nonce)&&!_.isEmpty(t.nonce())&&(n=i.beforeSend,i.beforeSend=function(e){if(e.setRequestHeader("X-WP-Nonce",t.nonce()),n)return n.apply(this,arguments)},i.complete=function(e){e=e.getResponseHeader("X-WP-Nonce");e&&_.isFunction(t.nonce)&&t.nonce()!==e&&t.endpointModel.set("nonce",e)}),this.requireForceForDelete&&"delete"===e&&(t.url=t.url()+"?force=true"),Backbone.sync(e,t,i)},save:function(e,t){return!(!_.includes(this.methods,"PUT")&&!_.includes(this.methods,"POST"))&&Backbone.Model.prototype.save.call(this,e,t)},destroy:function(e){return!!_.includes(this.methods,"DELETE")&&Backbone.Model.prototype.destroy.call(this,e)}}),wp.api.models.Schema=wp.api.WPApiBaseModel.extend({defaults:{_links:{},namespace:null,routes:{}},initialize:function(e,t){t=t||{},wp.api.WPApiBaseModel.prototype.initialize.call(this,e,t),this.apiRoot=t.apiRoot||i.root,this.versionString=t.versionString||i.versionString},url:function(){return this.apiRoot+this.versionString}})}(),function(){"use strict";window.wpApiSettings;wp.api.WPApiBaseCollection=Backbone.Collection.extend({initialize:function(e,t){this.state={data:{},currentPage:null,totalPages:null,totalObjects:null},_.isUndefined(t)?this.parent="":this.parent=t.parent},sync:function(e,t,i){var n,o,s=this;return i=i||{},_.isFunction(t.nonce)&&!_.isEmpty(t.nonce())&&(n=i.beforeSend,i.beforeSend=function(e){if(e.setRequestHeader("X-WP-Nonce",t.nonce()),n)return n.apply(s,arguments)},i.complete=function(e){e=e.getResponseHeader("X-WP-Nonce");e&&_.isFunction(t.nonce)&&t.nonce()!==e&&t.endpointModel.set("nonce",e)}),"read"===e&&(i.data?(s.state.data=_.clone(i.data),delete s.state.data.page):s.state.data=i.data={},void 0===i.data.page?(s.state.currentPage=null,s.state.totalPages=null,s.state.totalObjects=null):s.state.currentPage=i.data.page-1,o=i.success,i.success=function(e,t,i){if(_.isUndefined(i)||(s.state.totalPages=parseInt(i.getResponseHeader("x-wp-totalpages"),10),s.state.totalObjects=parseInt(i.getResponseHeader("x-wp-total"),10)),null===s.state.currentPage?s.state.currentPage=1:s.state.currentPage++,o)return o.apply(this,arguments)}),Backbone.sync(e,t,i)},more:function(e){if((e=e||{}).data=e.data||{},_.extend(e.data,this.state.data),void 0===e.data.page){if(!this.hasMore())return!1;null===this.state.currentPage||this.state.currentPage<=1?e.data.page=2:e.data.page=this.state.currentPage+1}return this.fetch(e)},hasMore:function(){return null===this.state.totalPages||null===this.state.totalObjects||null===this.state.currentPage?null:this.state.currentPage
Too Many Requests
-The user has sent too many requests -in a given amount of time.
--Apache/2.4.41 (Ubuntu) Server at 2008.stateofthemap.org Port 443 - +/** + * Interim login dialog. + * + * @output wp-includes/js/wp-auth-check.js + */ + +( function( $ ) { + var wrap, + tempHidden, + tempHiddenTimeout; + + /** + * Shows the authentication form popup. + * + * @since 3.6.0 + * @private + */ + function show() { + var parent = $( '#wp-auth-check' ), + form = $( '#wp-auth-check-form' ), + noframe = wrap.find( '.wp-auth-fallback-expired' ), + frame, loaded = false; + + if ( form.length ) { + // Add unload confirmation to counter (frame-busting) JS redirects. + $( window ).on( 'beforeunload.wp-auth-check', function( event ) { + event.originalEvent.returnValue = window.wp.i18n.__( 'Your session has expired. You can log in again from this page or go to the login page.' ); + }); + + frame = $( '