X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/59e7d7e4864c09a02499c310b17c91cbf050efa2..028399bd2cc1bdd206602eac9b51eb6715826a1c:/vendor/assets/iD/iD.js diff --git a/vendor/assets/iD/iD.js b/vendor/assets/iD/iD.js index 346fdbd66..088e252a2 100644 --- a/vendor/assets/iD/iD.js +++ b/vendor/assets/iD/iD.js @@ -2,17 +2,12 @@ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; - function createCommonjsModule(fn) { - var module = { exports: {} }; - return fn(module, module.exports), module.exports; - } - var check = function (it) { return it && it.Math == Math && it; }; // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 - var global$2 = + var global$1o = // eslint-disable-next-line es/no-global-this -- safe check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || @@ -22,7 +17,9 @@ // eslint-disable-next-line no-new-func -- fallback (function () { return this; })() || Function('return this')(); - var fails = function (exec) { + var objectGetOwnPropertyDescriptor = {}; + + var fails$V = function (exec) { try { return !!exec(); } catch (error) { @@ -30,31 +27,47 @@ } }; + var fails$U = fails$V; + // Detect IE8's incomplete defineProperty implementation - var descriptors = !fails(function () { + var descriptors = !fails$U(function () { // eslint-disable-next-line es/no-object-defineproperty -- required for testing return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; }); - var $propertyIsEnumerable$1 = {}.propertyIsEnumerable; + var fails$T = fails$V; + + var functionBindNative = !fails$T(function () { + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$4 = functionBindNative; + + var call$q = Function.prototype.call; + + var functionCall = NATIVE_BIND$4 ? call$q.bind(call$q) : function () { + return call$q.apply(call$q, arguments); + }; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable$2 = {}.propertyIsEnumerable; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe var getOwnPropertyDescriptor$5 = Object.getOwnPropertyDescriptor; // Nashorn ~ JDK8 bug - var NASHORN_BUG = getOwnPropertyDescriptor$5 && !$propertyIsEnumerable$1.call({ 1: 2 }, 1); + var NASHORN_BUG = getOwnPropertyDescriptor$5 && !$propertyIsEnumerable$2.call({ 1: 2 }, 1); // `Object.prototype.propertyIsEnumerable` method implementation // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable - var f$7 = NASHORN_BUG ? function propertyIsEnumerable(V) { + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { var descriptor = getOwnPropertyDescriptor$5(this, V); return !!descriptor && descriptor.enumerable; - } : $propertyIsEnumerable$1; + } : $propertyIsEnumerable$2; - var objectPropertyIsEnumerable = { - f: f$7 - }; - - var createPropertyDescriptor = function (bitmap, value) { + var createPropertyDescriptor$7 = function (bitmap, value) { return { enumerable: !(bitmap & 1), configurable: !(bitmap & 2), @@ -63,192 +76,522 @@ }; }; - var toString$1 = {}.toString; + var NATIVE_BIND$3 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var bind$g = FunctionPrototype$3.bind; + var call$p = FunctionPrototype$3.call; + var uncurryThis$Y = NATIVE_BIND$3 && bind$g.bind(call$p, call$p); + + var functionUncurryThis = NATIVE_BIND$3 ? function (fn) { + return fn && uncurryThis$Y(fn); + } : function (fn) { + return fn && function () { + return call$p.apply(fn, arguments); + }; + }; + + var uncurryThis$X = functionUncurryThis; - var classofRaw = function (it) { - return toString$1.call(it).slice(8, -1); + var toString$n = uncurryThis$X({}.toString); + var stringSlice$c = uncurryThis$X(''.slice); + + var classofRaw$1 = function (it) { + return stringSlice$c(toString$n(it), 8, -1); }; - var split$1 = ''.split; + var global$1n = global$1o; + var uncurryThis$W = functionUncurryThis; + var fails$S = fails$V; + var classof$e = classofRaw$1; + + var Object$5 = global$1n.Object; + var split$4 = uncurryThis$W(''.split); // fallback for non-array-like ES3 and non-enumerable old V8 strings - var indexedObject = fails(function () { + var indexedObject = fails$S(function () { // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 // eslint-disable-next-line no-prototype-builtins -- safe - return !Object('z').propertyIsEnumerable(0); + return !Object$5('z').propertyIsEnumerable(0); }) ? function (it) { - return classofRaw(it) == 'String' ? split$1.call(it, '') : Object(it); - } : Object; + return classof$e(it) == 'String' ? split$4(it, '') : Object$5(it); + } : Object$5; + + var global$1m = global$1o; + + var TypeError$p = global$1m.TypeError; // `RequireObjectCoercible` abstract operation // https://tc39.es/ecma262/#sec-requireobjectcoercible - var requireObjectCoercible = function (it) { - if (it == undefined) throw TypeError("Can't call method on " + it); + var requireObjectCoercible$e = function (it) { + if (it == undefined) throw TypeError$p("Can't call method on " + it); return it; }; // toObject with fallback for non-array-like ES3 strings + var IndexedObject$4 = indexedObject; + var requireObjectCoercible$d = requireObjectCoercible$e; + var toIndexedObject$d = function (it) { + return IndexedObject$4(requireObjectCoercible$d(it)); + }; + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$r = function (argument) { + return typeof argument == 'function'; + }; - var toIndexedObject = function (it) { - return indexedObject(requireObjectCoercible(it)); + var isCallable$q = isCallable$r; + + var isObject$s = function (it) { + return typeof it == 'object' ? it !== null : isCallable$q(it); }; - var isObject$4 = function (it) { - return typeof it === 'object' ? it !== null : typeof it === 'function'; + var global$1l = global$1o; + var isCallable$p = isCallable$r; + + var aFunction = function (argument) { + return isCallable$p(argument) ? argument : undefined; }; - // `ToPrimitive` abstract operation - // https://tc39.es/ecma262/#sec-toprimitive - // instead of the ES6 spec version, we didn't implement @@toPrimitive case - // and the second argument - flag - preferred type is a string - var toPrimitive = function (input, PREFERRED_STRING) { - if (!isObject$4(input)) return input; + var getBuiltIn$b = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$1l[namespace]) : global$1l[namespace] && global$1l[namespace][method]; + }; + + var uncurryThis$V = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$V({}.isPrototypeOf); + + var getBuiltIn$a = getBuiltIn$b; + + var engineUserAgent = getBuiltIn$a('navigator', 'userAgent') || ''; + + var global$1k = global$1o; + var userAgent$7 = engineUserAgent; + + var process$4 = global$1k.process; + var Deno = global$1k.Deno; + var versions = process$4 && process$4.versions || Deno && Deno.version; + var v8 = versions && versions.v8; + var match, version$1; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version$1 = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version$1 && userAgent$7) { + match = userAgent$7.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$7.match(/Chrome\/(\d+)/); + if (match) version$1 = +match[1]; + } + } + + var engineV8Version = version$1; + + /* eslint-disable es/no-symbol -- required for testing */ + + var V8_VERSION$3 = engineV8Version; + var fails$R = fails$V; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$R(function () { + var symbol = Symbol(); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + return !String(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + + var NATIVE_SYMBOL$3 = nativeSymbol; + + var useSymbolAsUid = NATIVE_SYMBOL$3 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var global$1j = global$1o; + var getBuiltIn$9 = getBuiltIn$b; + var isCallable$o = isCallable$r; + var isPrototypeOf$9 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var Object$4 = global$1j.Object; + + var isSymbol$6 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$9('Symbol'); + return isCallable$o($Symbol) && isPrototypeOf$9($Symbol.prototype, Object$4(it)); + }; + + var global$1i = global$1o; + + var String$6 = global$1i.String; + + var tryToString$5 = function (argument) { + try { + return String$6(argument); + } catch (error) { + return 'Object'; + } + }; + + var global$1h = global$1o; + var isCallable$n = isCallable$r; + var tryToString$4 = tryToString$5; + + var TypeError$o = global$1h.TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$a = function (argument) { + if (isCallable$n(argument)) return argument; + throw TypeError$o(tryToString$4(argument) + ' is not a function'); + }; + + var aCallable$9 = aCallable$a; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$7 = function (V, P) { + var func = V[P]; + return func == null ? undefined : aCallable$9(func); + }; + + var global$1g = global$1o; + var call$o = functionCall; + var isCallable$m = isCallable$r; + var isObject$r = isObject$s; + + var TypeError$n = global$1g.TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { var fn, val; - if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$4(val = fn.call(input))) return val; - if (typeof (fn = input.valueOf) == 'function' && !isObject$4(val = fn.call(input))) return val; - if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$4(val = fn.call(input))) return val; - throw TypeError("Can't convert object to primitive value"); + if (pref === 'string' && isCallable$m(fn = input.toString) && !isObject$r(val = call$o(fn, input))) return val; + if (isCallable$m(fn = input.valueOf) && !isObject$r(val = call$o(fn, input))) return val; + if (pref !== 'string' && isCallable$m(fn = input.toString) && !isObject$r(val = call$o(fn, input))) return val; + throw TypeError$n("Can't convert object to primitive value"); + }; + + var shared$5 = {exports: {}}; + + var isPure = false; + + var global$1f = global$1o; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$d = Object.defineProperty; + + var setGlobal$3 = function (key, value) { + try { + defineProperty$d(global$1f, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$1f[key] = value; + } return value; }; + var global$1e = global$1o; + var setGlobal$2 = setGlobal$3; + + var SHARED = '__core-js_shared__'; + var store$4 = global$1e[SHARED] || setGlobal$2(SHARED, {}); + + var sharedStore = store$4; + + var store$3 = sharedStore; + + (shared$5.exports = function (key, value) { + return store$3[key] || (store$3[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.21.0', + mode: 'global', + copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.21.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var global$1d = global$1o; + var requireObjectCoercible$c = requireObjectCoercible$e; + + var Object$3 = global$1d.Object; + // `ToObject` abstract operation // https://tc39.es/ecma262/#sec-toobject - var toObject = function (argument) { - return Object(requireObjectCoercible(argument)); + var toObject$i = function (argument) { + return Object$3(requireObjectCoercible$c(argument)); + }; + + var uncurryThis$U = functionUncurryThis; + var toObject$h = toObject$i; + + var hasOwnProperty$3 = uncurryThis$U({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty$3(toObject$h(it), key); }; - var hasOwnProperty$3 = {}.hasOwnProperty; + var uncurryThis$T = functionUncurryThis; + + var id$2 = 0; + var postfix = Math.random(); + var toString$m = uncurryThis$T(1.0.toString); - var has$1 = Object.hasOwn || function hasOwn(it, key) { - return hasOwnProperty$3.call(toObject(it), key); + var uid$5 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$m(++id$2 + postfix, 36); }; - var document$3 = global$2.document; + var global$1c = global$1o; + var shared$4 = shared$5.exports; + var hasOwn$l = hasOwnProperty_1; + var uid$4 = uid$5; + var NATIVE_SYMBOL$2 = nativeSymbol; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var WellKnownSymbolsStore$1 = shared$4('wks'); + var Symbol$3 = global$1c.Symbol; + var symbolFor = Symbol$3 && Symbol$3['for']; + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$3 : Symbol$3 && Symbol$3.withoutSetter || uid$4; + + var wellKnownSymbol$t = function (name) { + if (!hasOwn$l(WellKnownSymbolsStore$1, name) || !(NATIVE_SYMBOL$2 || typeof WellKnownSymbolsStore$1[name] == 'string')) { + var description = 'Symbol.' + name; + if (NATIVE_SYMBOL$2 && hasOwn$l(Symbol$3, name)) { + WellKnownSymbolsStore$1[name] = Symbol$3[name]; + } else if (USE_SYMBOL_AS_UID && symbolFor) { + WellKnownSymbolsStore$1[name] = symbolFor(description); + } else { + WellKnownSymbolsStore$1[name] = createWellKnownSymbol(description); + } + } return WellKnownSymbolsStore$1[name]; + }; + + var global$1b = global$1o; + var call$n = functionCall; + var isObject$q = isObject$s; + var isSymbol$5 = isSymbol$6; + var getMethod$6 = getMethod$7; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$s = wellKnownSymbol$t; + + var TypeError$m = global$1b.TypeError; + var TO_PRIMITIVE$1 = wellKnownSymbol$s('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$3 = function (input, pref) { + if (!isObject$q(input) || isSymbol$5(input)) return input; + var exoticToPrim = getMethod$6(input, TO_PRIMITIVE$1); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$n(exoticToPrim, input, pref); + if (!isObject$q(result) || isSymbol$5(result)) return result; + throw TypeError$m("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive$2 = toPrimitive$3; + var isSymbol$4 = isSymbol$6; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$5 = function (argument) { + var key = toPrimitive$2(argument, 'string'); + return isSymbol$4(key) ? key : key + ''; + }; + + var global$1a = global$1o; + var isObject$p = isObject$s; + + var document$3 = global$1a.document; // typeof document.createElement is 'object' in old IE - var EXISTS = isObject$4(document$3) && isObject$4(document$3.createElement); + var EXISTS$1 = isObject$p(document$3) && isObject$p(document$3.createElement); - var documentCreateElement = function (it) { - return EXISTS ? document$3.createElement(it) : {}; + var documentCreateElement$2 = function (it) { + return EXISTS$1 ? document$3.createElement(it) : {}; }; - // Thank's IE8 for his funny defineProperty - var ie8DomDefine = !descriptors && !fails(function () { - // eslint-disable-next-line es/no-object-defineproperty -- requied for testing - return Object.defineProperty(documentCreateElement('div'), 'a', { + var DESCRIPTORS$p = descriptors; + var fails$Q = fails$V; + var createElement$1 = documentCreateElement$2; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$p && !fails$Q(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { get: function () { return 7; } }).a != 7; }); + var DESCRIPTORS$o = descriptors; + var call$m = functionCall; + var propertyIsEnumerableModule$2 = objectPropertyIsEnumerable; + var createPropertyDescriptor$6 = createPropertyDescriptor$7; + var toIndexedObject$c = toIndexedObject$d; + var toPropertyKey$4 = toPropertyKey$5; + var hasOwn$k = hasOwnProperty_1; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe - var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var $getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; // `Object.getOwnPropertyDescriptor` method // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor - var f$6 = descriptors ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) { - O = toIndexedObject(O); - P = toPrimitive(P, true); - if (ie8DomDefine) try { - return $getOwnPropertyDescriptor$1(O, P); + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$o ? $getOwnPropertyDescriptor$2 : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$c(O); + P = toPropertyKey$4(P); + if (IE8_DOM_DEFINE$1) try { + return $getOwnPropertyDescriptor$2(O, P); } catch (error) { /* empty */ } - if (has$1(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]); + if (hasOwn$k(O, P)) return createPropertyDescriptor$6(!call$m(propertyIsEnumerableModule$2.f, O, P), O[P]); }; - var objectGetOwnPropertyDescriptor = { - f: f$6 - }; + var objectDefineProperty = {}; - var anObject = function (it) { - if (!isObject$4(it)) { - throw TypeError(String(it) + ' is not an object'); - } return it; + var DESCRIPTORS$n = descriptors; + var fails$P = fails$V; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$n && fails$P(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype != 42; + }); + + var global$19 = global$1o; + var isObject$o = isObject$s; + + var String$5 = global$19.String; + var TypeError$l = global$19.TypeError; + + // `Assert: Type(argument) is Object` + var anObject$n = function (argument) { + if (isObject$o(argument)) return argument; + throw TypeError$l(String$5(argument) + ' is not an object'); }; + var global$18 = global$1o; + var DESCRIPTORS$m = descriptors; + var IE8_DOM_DEFINE = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; + var anObject$m = anObject$n; + var toPropertyKey$3 = toPropertyKey$5; + + var TypeError$k = global$18.TypeError; // eslint-disable-next-line es/no-object-defineproperty -- safe var $defineProperty$1 = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE$1 = 'configurable'; + var WRITABLE = 'writable'; // `Object.defineProperty` method // https://tc39.es/ecma262/#sec-object.defineproperty - var f$5 = descriptors ? $defineProperty$1 : function defineProperty(O, P, Attributes) { - anObject(O); - P = toPrimitive(P, true); - anObject(Attributes); - if (ie8DomDefine) try { + objectDefineProperty.f = DESCRIPTORS$m ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$m(O); + P = toPropertyKey$3(P); + anObject$m(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty$1(O, P, Attributes); + } : $defineProperty$1 : function defineProperty(O, P, Attributes) { + anObject$m(O); + P = toPropertyKey$3(P); + anObject$m(Attributes); + if (IE8_DOM_DEFINE) try { return $defineProperty$1(O, P, Attributes); } catch (error) { /* empty */ } - if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); + if ('get' in Attributes || 'set' in Attributes) throw TypeError$k('Accessors not supported'); if ('value' in Attributes) O[P] = Attributes.value; return O; }; - var objectDefineProperty = { - f: f$5 - }; + var DESCRIPTORS$l = descriptors; + var definePropertyModule$7 = objectDefineProperty; + var createPropertyDescriptor$5 = createPropertyDescriptor$7; - var createNonEnumerableProperty = descriptors ? function (object, key, value) { - return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value)); + var createNonEnumerableProperty$b = DESCRIPTORS$l ? function (object, key, value) { + return definePropertyModule$7.f(object, key, createPropertyDescriptor$5(1, value)); } : function (object, key, value) { object[key] = value; return object; }; - var setGlobal = function (key, value) { - try { - createNonEnumerableProperty(global$2, key, value); - } catch (error) { - global$2[key] = value; - } return value; - }; + var redefine$h = {exports: {}}; - var SHARED = '__core-js_shared__'; - var store$1 = global$2[SHARED] || setGlobal(SHARED, {}); - - var sharedStore = store$1; + var uncurryThis$S = functionUncurryThis; + var isCallable$l = isCallable$r; + var store$2 = sharedStore; - var functionToString = Function.toString; + var functionToString$1 = uncurryThis$S(Function.toString); // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper - if (typeof sharedStore.inspectSource != 'function') { - sharedStore.inspectSource = function (it) { - return functionToString.call(it); + if (!isCallable$l(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); }; } - var inspectSource = sharedStore.inspectSource; + var inspectSource$4 = store$2.inspectSource; - var WeakMap$1 = global$2.WeakMap; + var global$17 = global$1o; + var isCallable$k = isCallable$r; + var inspectSource$3 = inspectSource$4; - var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(inspectSource(WeakMap$1)); + var WeakMap$1 = global$17.WeakMap; - var isPure = false; + var nativeWeakMap = isCallable$k(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1)); - var shared = createCommonjsModule(function (module) { - (module.exports = function (key, value) { - return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {}); - })('versions', []).push({ - version: '3.15.0', - mode: 'global', - copyright: '© 2021 Denis Pushkarev (zloirock.ru)' - }); - }); + var shared$3 = shared$5.exports; + var uid$3 = uid$5; - var id$1 = 0; - var postfix = Math.random(); + var keys$3 = shared$3('keys'); - var uid = function (key) { - return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id$1 + postfix).toString(36); + var sharedKey$4 = function (key) { + return keys$3[key] || (keys$3[key] = uid$3(key)); }; - var keys$3 = shared('keys'); - - var sharedKey = function (key) { - return keys$3[key] || (keys$3[key] = uid(key)); - }; + var hiddenKeys$6 = {}; - var hiddenKeys$1 = {}; + var NATIVE_WEAK_MAP = nativeWeakMap; + var global$16 = global$1o; + var uncurryThis$R = functionUncurryThis; + var isObject$n = isObject$s; + var createNonEnumerableProperty$a = createNonEnumerableProperty$b; + var hasOwn$j = hasOwnProperty_1; + var shared$2 = sharedStore; + var sharedKey$3 = sharedKey$4; + var hiddenKeys$5 = hiddenKeys$6; var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; - var WeakMap = global$2.WeakMap; + var TypeError$j = global$16.TypeError; + var WeakMap = global$16.WeakMap; var set$4, get$5, has; var enforce = function (it) { @@ -258,43 +601,43 @@ var getterFor = function (TYPE) { return function (it) { var state; - if (!isObject$4(it) || (state = get$5(it)).type !== TYPE) { - throw TypeError('Incompatible receiver, ' + TYPE + ' required'); + if (!isObject$n(it) || (state = get$5(it)).type !== TYPE) { + throw TypeError$j('Incompatible receiver, ' + TYPE + ' required'); } return state; }; }; - if (nativeWeakMap || sharedStore.state) { - var store = sharedStore.state || (sharedStore.state = new WeakMap()); - var wmget = store.get; - var wmhas = store.has; - var wmset = store.set; + if (NATIVE_WEAK_MAP || shared$2.state) { + var store$1 = shared$2.state || (shared$2.state = new WeakMap()); + var wmget = uncurryThis$R(store$1.get); + var wmhas = uncurryThis$R(store$1.has); + var wmset = uncurryThis$R(store$1.set); set$4 = function (it, metadata) { - if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + if (wmhas(store$1, it)) throw new TypeError$j(OBJECT_ALREADY_INITIALIZED); metadata.facade = it; - wmset.call(store, it, metadata); + wmset(store$1, it, metadata); return metadata; }; get$5 = function (it) { - return wmget.call(store, it) || {}; + return wmget(store$1, it) || {}; }; has = function (it) { - return wmhas.call(store, it); + return wmhas(store$1, it); }; } else { - var STATE = sharedKey('state'); - hiddenKeys$1[STATE] = true; + var STATE = sharedKey$3('state'); + hiddenKeys$5[STATE] = true; set$4 = function (it, metadata) { - if (has$1(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + if (hasOwn$j(it, STATE)) throw new TypeError$j(OBJECT_ALREADY_INITIALIZED); metadata.facade = it; - createNonEnumerableProperty(it, STATE, metadata); + createNonEnumerableProperty$a(it, STATE, metadata); return metadata; }; get$5 = function (it) { - return has$1(it, STATE) ? it[STATE] : {}; + return hasOwn$j(it, STATE) ? it[STATE] : {}; }; has = function (it) { - return has$1(it, STATE); + return hasOwn$j(it, STATE); }; } @@ -306,28 +649,58 @@ getterFor: getterFor }; - var redefine = createCommonjsModule(function (module) { - var getInternalState = internalState.get; - var enforceInternalState = internalState.enforce; + var DESCRIPTORS$k = descriptors; + var hasOwn$i = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$k && Object.getOwnPropertyDescriptor; + + var EXISTS = hasOwn$i(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE = EXISTS && (!DESCRIPTORS$k || (DESCRIPTORS$k && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE + }; + + var global$15 = global$1o; + var isCallable$j = isCallable$r; + var hasOwn$h = hasOwnProperty_1; + var createNonEnumerableProperty$9 = createNonEnumerableProperty$b; + var setGlobal$1 = setGlobal$3; + var inspectSource$2 = inspectSource$4; + var InternalStateModule$9 = internalState; + var CONFIGURABLE_FUNCTION_NAME$2 = functionName.CONFIGURABLE; + + var getInternalState$7 = InternalStateModule$9.get; + var enforceInternalState$1 = InternalStateModule$9.enforce; var TEMPLATE = String(String).split('String'); - (module.exports = function (O, key, value, options) { + (redefine$h.exports = function (O, key, value, options) { var unsafe = options ? !!options.unsafe : false; var simple = options ? !!options.enumerable : false; var noTargetGet = options ? !!options.noTargetGet : false; + var name = options && options.name !== undefined ? options.name : key; var state; - if (typeof value == 'function') { - if (typeof key == 'string' && !has$1(value, 'name')) { - createNonEnumerableProperty(value, 'name', key); + if (isCallable$j(value)) { + if (String(name).slice(0, 7) === 'Symbol(') { + name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (!hasOwn$h(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$2 && value.name !== name)) { + createNonEnumerableProperty$9(value, 'name', name); } - state = enforceInternalState(value); + state = enforceInternalState$1(value); if (!state.source) { - state.source = TEMPLATE.join(typeof key == 'string' ? key : ''); + state.source = TEMPLATE.join(typeof name == 'string' ? name : ''); } } - if (O === global$2) { + if (O === global$15) { if (simple) O[key] = value; - else setGlobal(key, value); + else setGlobal$1(key, value); return; } else if (!unsafe) { delete O[key]; @@ -335,58 +708,66 @@ simple = true; } if (simple) O[key] = value; - else createNonEnumerableProperty(O, key, value); + else createNonEnumerableProperty$9(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative })(Function.prototype, 'toString', function toString() { - return typeof this == 'function' && getInternalState(this).source || inspectSource(this); - }); + return isCallable$j(this) && getInternalState$7(this).source || inspectSource$2(this); }); - var path = global$2; + var objectGetOwnPropertyNames = {}; - var aFunction$1 = function (variable) { - return typeof variable == 'function' ? variable : undefined; + var ceil$1 = Math.ceil; + var floor$8 = Math.floor; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$b = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- safe + return number !== number || number === 0 ? 0 : (number > 0 ? floor$8 : ceil$1)(number); }; - var getBuiltIn = function (namespace, method) { - return arguments.length < 2 ? aFunction$1(path[namespace]) || aFunction$1(global$2[namespace]) - : path[namespace] && path[namespace][method] || global$2[namespace] && global$2[namespace][method]; - }; + var toIntegerOrInfinity$a = toIntegerOrInfinity$b; - var ceil$1 = Math.ceil; - var floor$7 = Math.floor; + var max$5 = Math.max; + var min$9 = Math.min; - // `ToInteger` abstract operation - // https://tc39.es/ecma262/#sec-tointeger - var toInteger = function (argument) { - return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor$7 : ceil$1)(argument); + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$9 = function (index, length) { + var integer = toIntegerOrInfinity$a(index); + return integer < 0 ? max$5(integer + length, 0) : min$9(integer, length); }; - var min$9 = Math.min; + var toIntegerOrInfinity$9 = toIntegerOrInfinity$b; + + var min$8 = Math.min; // `ToLength` abstract operation // https://tc39.es/ecma262/#sec-tolength - var toLength = function (argument) { - return argument > 0 ? min$9(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + var toLength$c = function (argument) { + return argument > 0 ? min$8(toIntegerOrInfinity$9(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 }; - var max$4 = Math.max; - var min$8 = Math.min; + var toLength$b = toLength$c; - // Helper for a popular repeating case of the spec: - // Let integer be ? ToInteger(index). - // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). - var toAbsoluteIndex = function (index, length) { - var integer = toInteger(index); - return integer < 0 ? max$4(integer + length, 0) : min$8(integer, length); + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$i = function (obj) { + return toLength$b(obj.length); }; + var toIndexedObject$b = toIndexedObject$d; + var toAbsoluteIndex$8 = toAbsoluteIndex$9; + var lengthOfArrayLike$h = lengthOfArrayLike$i; + // `Array.prototype.{ indexOf, includes }` methods implementation var createMethod$6 = function (IS_INCLUDES) { return function ($this, el, fromIndex) { - var O = toIndexedObject($this); - var length = toLength(O.length); - var index = toAbsoluteIndex(fromIndex, length); + var O = toIndexedObject$b($this); + var length = lengthOfArrayLike$h(O); + var index = toAbsoluteIndex$8(fromIndex, length); var value; // Array#includes uses SameValueZero equality algorithm // eslint-disable-next-line no-self-compare -- NaN check @@ -410,24 +791,29 @@ indexOf: createMethod$6(false) }; - var indexOf = arrayIncludes.indexOf; + var uncurryThis$Q = functionUncurryThis; + var hasOwn$g = hasOwnProperty_1; + var toIndexedObject$a = toIndexedObject$d; + var indexOf$1 = arrayIncludes.indexOf; + var hiddenKeys$4 = hiddenKeys$6; + var push$a = uncurryThis$Q([].push); var objectKeysInternal = function (object, names) { - var O = toIndexedObject(object); + var O = toIndexedObject$a(object); var i = 0; var result = []; var key; - for (key in O) !has$1(hiddenKeys$1, key) && has$1(O, key) && result.push(key); + for (key in O) !hasOwn$g(hiddenKeys$4, key) && hasOwn$g(O, key) && push$a(result, key); // Don't enum bug & hidden keys - while (names.length > i) if (has$1(O, key = names[i++])) { - ~indexOf(result, key) || result.push(key); + while (names.length > i) if (hasOwn$g(O, key = names[i++])) { + ~indexOf$1(result, key) || push$a(result, key); } return result; }; // IE8- don't enum bug keys - var enumBugKeys = [ + var enumBugKeys$3 = [ 'constructor', 'hasOwnProperty', 'isPrototypeOf', @@ -437,69 +823,85 @@ 'valueOf' ]; - var hiddenKeys = enumBugKeys.concat('length', 'prototype'); + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$2 = enumBugKeys$3; + + var hiddenKeys$3 = enumBugKeys$2.concat('length', 'prototype'); // `Object.getOwnPropertyNames` method // https://tc39.es/ecma262/#sec-object.getownpropertynames // eslint-disable-next-line es/no-object-getownpropertynames -- safe - var f$4 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { - return objectKeysInternal(O, hiddenKeys); + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$3); }; - var objectGetOwnPropertyNames = { - f: f$4 - }; + var objectGetOwnPropertySymbols = {}; // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe - var f$3 = Object.getOwnPropertySymbols; + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; - var objectGetOwnPropertySymbols = { - f: f$3 - }; + var getBuiltIn$8 = getBuiltIn$b; + var uncurryThis$P = functionUncurryThis; + var getOwnPropertyNamesModule$2 = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$2 = objectGetOwnPropertySymbols; + var anObject$l = anObject$n; + + var concat$3 = uncurryThis$P([].concat); // all object keys, includes non-enumerable and symbols - var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { - var keys = objectGetOwnPropertyNames.f(anObject(it)); - var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; - return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; + var ownKeys$1 = getBuiltIn$8('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$2.f(anObject$l(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$2.f; + return getOwnPropertySymbols ? concat$3(keys, getOwnPropertySymbols(it)) : keys; }; - var copyConstructorProperties = function (target, source) { + var hasOwn$f = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule$3 = objectGetOwnPropertyDescriptor; + var definePropertyModule$6 = objectDefineProperty; + + var copyConstructorProperties$2 = function (target, source, exceptions) { var keys = ownKeys(source); - var defineProperty = objectDefineProperty.f; - var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var defineProperty = definePropertyModule$6.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule$3.f; for (var i = 0; i < keys.length; i++) { var key = keys[i]; - if (!has$1(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + if (!hasOwn$f(target, key) && !(exceptions && hasOwn$f(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } } }; + var fails$O = fails$V; + var isCallable$i = isCallable$r; + var replacement = /#|\.prototype\./; - var isForced = function (feature, detection) { + var isForced$5 = function (feature, detection) { var value = data[normalize$1(feature)]; return value == POLYFILL ? true : value == NATIVE ? false - : typeof detection == 'function' ? fails(detection) + : isCallable$i(detection) ? fails$O(detection) : !!detection; }; - var normalize$1 = isForced.normalize = function (string) { + var normalize$1 = isForced$5.normalize = function (string) { return String(string).replace(replacement, '.').toLowerCase(); }; - var data = isForced.data = {}; - var NATIVE = isForced.NATIVE = 'N'; - var POLYFILL = isForced.POLYFILL = 'P'; + var data = isForced$5.data = {}; + var NATIVE = isForced$5.NATIVE = 'N'; + var POLYFILL = isForced$5.POLYFILL = 'P'; - var isForced_1 = isForced; + var isForced_1 = isForced$5; + var global$14 = global$1o; var getOwnPropertyDescriptor$4 = objectGetOwnPropertyDescriptor.f; - - - - - + var createNonEnumerableProperty$8 = createNonEnumerableProperty$b; + var redefine$g = redefine$h.exports; + var setGlobal = setGlobal$3; + var copyConstructorProperties$1 = copyConstructorProperties$2; + var isForced$4 = isForced_1; /* options.target - name of the target object @@ -514,6 +916,7 @@ options.sham - add a flag to not completely full polyfills options.enumerable - export as enumerable property options.noTargetGet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key */ var _export = function (options, source) { var TARGET = options.target; @@ -521,11 +924,11 @@ var STATIC = options.stat; var FORCED, target, key, targetProperty, sourceProperty, descriptor; if (GLOBAL) { - target = global$2; + target = global$14; } else if (STATIC) { - target = global$2[TARGET] || setGlobal(TARGET, {}); + target = global$14[TARGET] || setGlobal(TARGET, {}); } else { - target = (global$2[TARGET] || {}).prototype; + target = (global$14[TARGET] || {}).prototype; } if (target) for (key in source) { sourceProperty = source[key]; @@ -533,59 +936,63 @@ descriptor = getOwnPropertyDescriptor$4(target, key); targetProperty = descriptor && descriptor.value; } else targetProperty = target[key]; - FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + FORCED = isForced$4(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target if (!FORCED && targetProperty !== undefined) { - if (typeof sourceProperty === typeof targetProperty) continue; - copyConstructorProperties(sourceProperty, targetProperty); + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties$1(sourceProperty, targetProperty); } // add a flag to not completely full polyfills if (options.sham || (targetProperty && targetProperty.sham)) { - createNonEnumerableProperty(sourceProperty, 'sham', true); + createNonEnumerableProperty$8(sourceProperty, 'sham', true); } // extend global - redefine(target, key, sourceProperty, options); + redefine$g(target, key, sourceProperty, options); } }; + var $$1e = _export; + var global$13 = global$1o; + var uncurryThis$O = functionUncurryThis; + + var Date$1 = global$13.Date; + var getTime$2 = uncurryThis$O(Date$1.prototype.getTime); + // `Date.now` method // https://tc39.es/ecma262/#sec-date.now - _export({ target: 'Date', stat: true }, { + $$1e({ target: 'Date', stat: true }, { now: function now() { - return new Date().getTime(); + return getTime$2(new Date$1()); } }); + var uncurryThis$N = functionUncurryThis; + var redefine$f = redefine$h.exports; + var DatePrototype$1 = Date.prototype; var INVALID_DATE = 'Invalid Date'; var TO_STRING$1 = 'toString'; - var nativeDateToString = DatePrototype$1[TO_STRING$1]; - var getTime$1 = DatePrototype$1.getTime; + var un$DateToString = uncurryThis$N(DatePrototype$1[TO_STRING$1]); + var getTime$1 = uncurryThis$N(DatePrototype$1.getTime); // `Date.prototype.toString` method // https://tc39.es/ecma262/#sec-date.prototype.tostring - if (new Date(NaN) + '' != INVALID_DATE) { - redefine(DatePrototype$1, TO_STRING$1, function toString() { - var value = getTime$1.call(this); + if (String(new Date(NaN)) != INVALID_DATE) { + redefine$f(DatePrototype$1, TO_STRING$1, function toString() { + var value = getTime$1(this); // eslint-disable-next-line no-self-compare -- NaN check - return value === value ? nativeDateToString.call(this) : INVALID_DATE; + return value === value ? un$DateToString(this) : INVALID_DATE; }); } function _typeof(obj) { "@babel/helpers - typeof"; - if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { - _typeof = function (obj) { - return typeof obj; - }; - } else { - _typeof = function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; - }; - } - - return _typeof(obj); + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }, _typeof(obj); } function _classCallCheck$1(instance, Constructor) { @@ -607,6 +1014,9 @@ function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); return Constructor; } @@ -757,104 +1167,95 @@ }; } - var engineUserAgent = getBuiltIn('navigator', 'userAgent') || ''; + var $$1d = _export; + var global$12 = global$1o; - var process$4 = global$2.process; - var versions = process$4 && process$4.versions; - var v8 = versions && versions.v8; - var match, version$1; - - if (v8) { - match = v8.split('.'); - version$1 = match[0] < 4 ? 1 : match[0] + match[1]; - } else if (engineUserAgent) { - match = engineUserAgent.match(/Edge\/(\d+)/); - if (!match || match[1] >= 74) { - match = engineUserAgent.match(/Chrome\/(\d+)/); - if (match) version$1 = match[1]; - } - } - - var engineV8Version = version$1 && +version$1; - - /* eslint-disable es/no-symbol -- required for testing */ - - // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing - var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () { - var symbol = Symbol(); - // Chrome 38 Symbol has incorrect toString conversion - // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances - return !String(symbol) || !(Object(symbol) instanceof Symbol) || - // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances - !Symbol.sham && engineV8Version && engineV8Version < 41; + // `globalThis` object + // https://tc39.es/ecma262/#sec-globalthis + $$1d({ global: true }, { + globalThis: global$12 }); - /* eslint-disable es/no-symbol -- required for testing */ - - var useSymbolAsUid = nativeSymbol - && !Symbol.sham - && typeof Symbol.iterator == 'symbol'; + var global$11 = global$1o; - var WellKnownSymbolsStore$1 = shared('wks'); - var Symbol$1 = global$2.Symbol; - var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid; + var path$1 = global$11; - var wellKnownSymbol = function (name) { - if (!has$1(WellKnownSymbolsStore$1, name) || !(nativeSymbol || typeof WellKnownSymbolsStore$1[name] == 'string')) { - if (nativeSymbol && has$1(Symbol$1, name)) { - WellKnownSymbolsStore$1[name] = Symbol$1[name]; - } else { - WellKnownSymbolsStore$1[name] = createWellKnownSymbol('Symbol.' + name); - } - } return WellKnownSymbolsStore$1[name]; - }; + var wellKnownSymbolWrapped = {}; - var f$2 = wellKnownSymbol; + var wellKnownSymbol$r = wellKnownSymbol$t; - var wellKnownSymbolWrapped = { - f: f$2 - }; + wellKnownSymbolWrapped.f = wellKnownSymbol$r; - var defineProperty$9 = objectDefineProperty.f; + var path = path$1; + var hasOwn$e = hasOwnProperty_1; + var wrappedWellKnownSymbolModule$1 = wellKnownSymbolWrapped; + var defineProperty$c = objectDefineProperty.f; - var defineWellKnownSymbol = function (NAME) { + var defineWellKnownSymbol$4 = function (NAME) { var Symbol = path.Symbol || (path.Symbol = {}); - if (!has$1(Symbol, NAME)) defineProperty$9(Symbol, NAME, { - value: wellKnownSymbolWrapped.f(NAME) + if (!hasOwn$e(Symbol, NAME)) defineProperty$c(Symbol, NAME, { + value: wrappedWellKnownSymbolModule$1.f(NAME) }); }; + var defineWellKnownSymbol$3 = defineWellKnownSymbol$4; + // `Symbol.iterator` well-known symbol // https://tc39.es/ecma262/#sec-symbol.iterator - defineWellKnownSymbol('iterator'); + defineWellKnownSymbol$3('iterator'); + + var objectDefineProperties = {}; + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$3; // `Object.keys` method // https://tc39.es/ecma262/#sec-object.keys // eslint-disable-next-line es/no-object-keys -- safe - var objectKeys = Object.keys || function keys(O) { - return objectKeysInternal(O, enumBugKeys); + var objectKeys$4 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); }; + var DESCRIPTORS$j = descriptors; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var definePropertyModule$5 = objectDefineProperty; + var anObject$k = anObject$n; + var toIndexedObject$9 = toIndexedObject$d; + var objectKeys$3 = objectKeys$4; + // `Object.defineProperties` method // https://tc39.es/ecma262/#sec-object.defineproperties // eslint-disable-next-line es/no-object-defineproperties -- safe - var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) { - anObject(O); - var keys = objectKeys(Properties); + objectDefineProperties.f = DESCRIPTORS$j && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$k(O); + var props = toIndexedObject$9(Properties); + var keys = objectKeys$3(Properties); var length = keys.length; var index = 0; var key; - while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]); + while (length > index) definePropertyModule$5.f(O, key = keys[index++], props[key]); return O; }; - var html = getBuiltIn('document', 'documentElement'); + var getBuiltIn$7 = getBuiltIn$b; + + var html$2 = getBuiltIn$7('document', 'documentElement'); + + /* global ActiveXObject -- old IE, WSH */ + + var anObject$j = anObject$n; + var definePropertiesModule$1 = objectDefineProperties; + var enumBugKeys = enumBugKeys$3; + var hiddenKeys$2 = hiddenKeys$6; + var html$1 = html$2; + var documentCreateElement$1 = documentCreateElement$2; + var sharedKey$2 = sharedKey$4; var GT = '>'; var LT = '<'; var PROTOTYPE$2 = 'prototype'; var SCRIPT = 'script'; - var IE_PROTO$1 = sharedKey('IE_PROTO'); + var IE_PROTO$1 = sharedKey$2('IE_PROTO'); var EmptyConstructor = function () { /* empty */ }; @@ -874,11 +1275,11 @@ // Create object with fake `null` prototype: use iframe Object with cleared prototype var NullProtoObjectViaIFrame = function () { // Thrash, waste and sodomy: IE GC bug - var iframe = documentCreateElement('iframe'); + var iframe = documentCreateElement$1('iframe'); var JS = 'java' + SCRIPT + ':'; var iframeDocument; iframe.style.display = 'none'; - html.appendChild(iframe); + html$1.appendChild(iframe); // https://github.com/zloirock/core-js/issues/475 iframe.src = String(JS); iframeDocument = iframe.contentWindow.document; @@ -896,75 +1297,96 @@ var activeXDocument; var NullProtoObject = function () { try { - /* global ActiveXObject -- old IE */ - activeXDocument = document.domain && new ActiveXObject('htmlfile'); + activeXDocument = new ActiveXObject('htmlfile'); } catch (error) { /* ignore */ } - NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH var length = enumBugKeys.length; while (length--) delete NullProtoObject[PROTOTYPE$2][enumBugKeys[length]]; return NullProtoObject(); }; - hiddenKeys$1[IE_PROTO$1] = true; + hiddenKeys$2[IE_PROTO$1] = true; // `Object.create` method // https://tc39.es/ecma262/#sec-object.create var objectCreate = Object.create || function create(O, Properties) { var result; if (O !== null) { - EmptyConstructor[PROTOTYPE$2] = anObject(O); + EmptyConstructor[PROTOTYPE$2] = anObject$j(O); result = new EmptyConstructor(); EmptyConstructor[PROTOTYPE$2] = null; // add "__proto__" for Object.getPrototypeOf polyfill result[IE_PROTO$1] = O; } else result = NullProtoObject(); - return Properties === undefined ? result : objectDefineProperties(result, Properties); + return Properties === undefined ? result : definePropertiesModule$1.f(result, Properties); }; - var UNSCOPABLES = wellKnownSymbol('unscopables'); + var wellKnownSymbol$q = wellKnownSymbol$t; + var create$a = objectCreate; + var definePropertyModule$4 = objectDefineProperty; + + var UNSCOPABLES = wellKnownSymbol$q('unscopables'); var ArrayPrototype$1 = Array.prototype; // Array.prototype[@@unscopables] // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables if (ArrayPrototype$1[UNSCOPABLES] == undefined) { - objectDefineProperty.f(ArrayPrototype$1, UNSCOPABLES, { + definePropertyModule$4.f(ArrayPrototype$1, UNSCOPABLES, { configurable: true, - value: objectCreate(null) + value: create$a(null) }); } // add a key to Array.prototype[@@unscopables] - var addToUnscopables = function (key) { + var addToUnscopables$6 = function (key) { ArrayPrototype$1[UNSCOPABLES][key] = true; }; var iterators = {}; - var correctPrototypeGetter = !fails(function () { + var fails$N = fails$V; + + var correctPrototypeGetter = !fails$N(function () { function F() { /* empty */ } F.prototype.constructor = null; // eslint-disable-next-line es/no-object-getprototypeof -- required for testing return Object.getPrototypeOf(new F()) !== F.prototype; }); - var IE_PROTO = sharedKey('IE_PROTO'); - var ObjectPrototype$3 = Object.prototype; + var global$10 = global$1o; + var hasOwn$d = hasOwnProperty_1; + var isCallable$h = isCallable$r; + var toObject$g = toObject$i; + var sharedKey$1 = sharedKey$4; + var CORRECT_PROTOTYPE_GETTER$1 = correctPrototypeGetter; + + var IE_PROTO = sharedKey$1('IE_PROTO'); + var Object$2 = global$10.Object; + var ObjectPrototype$4 = Object$2.prototype; // `Object.getPrototypeOf` method // https://tc39.es/ecma262/#sec-object.getprototypeof - // eslint-disable-next-line es/no-object-getprototypeof -- safe - var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) { - O = toObject(O); - if (has$1(O, IE_PROTO)) return O[IE_PROTO]; - if (typeof O.constructor == 'function' && O instanceof O.constructor) { - return O.constructor.prototype; - } return O instanceof Object ? ObjectPrototype$3 : null; + var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER$1 ? Object$2.getPrototypeOf : function (O) { + var object = toObject$g(O); + if (hasOwn$d(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$h(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof Object$2 ? ObjectPrototype$4 : null; }; - var ITERATOR$8 = wellKnownSymbol('iterator'); - var BUGGY_SAFARI_ITERATORS$1 = false; + var fails$M = fails$V; + var isCallable$g = isCallable$r; + var getPrototypeOf$4 = objectGetPrototypeOf; + var redefine$e = redefine$h.exports; + var wellKnownSymbol$p = wellKnownSymbol$t; - var returnThis$2 = function () { return this; }; + var ITERATOR$a = wellKnownSymbol$p('iterator'); + var BUGGY_SAFARI_ITERATORS$1 = false; // `%IteratorPrototype%` object // https://tc39.es/ecma262/#sec-%iteratorprototype%-object @@ -976,23 +1398,25 @@ // Safari 8 has buggy iterators w/o `next` if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; else { - PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator)); + PrototypeOfArrayIteratorPrototype = getPrototypeOf$4(getPrototypeOf$4(arrayIterator)); if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; } } - var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails(function () { + var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$M(function () { var test = {}; // FF44- legacy iterators case - return IteratorPrototype$2[ITERATOR$8].call(test) !== test; + return IteratorPrototype$2[ITERATOR$a].call(test) !== test; }); if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; // `%IteratorPrototype%[@@iterator]()` method // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator - if (!has$1(IteratorPrototype$2, ITERATOR$8)) { - createNonEnumerableProperty(IteratorPrototype$2, ITERATOR$8, returnThis$2); + if (!isCallable$g(IteratorPrototype$2[ITERATOR$a])) { + redefine$e(IteratorPrototype$2, ITERATOR$a, function () { + return this; + }); } var iteratorsCore = { @@ -1000,42 +1424,52 @@ BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 }; - var defineProperty$8 = objectDefineProperty.f; - - + var defineProperty$b = objectDefineProperty.f; + var hasOwn$c = hasOwnProperty_1; + var wellKnownSymbol$o = wellKnownSymbol$t; - var TO_STRING_TAG$4 = wellKnownSymbol('toStringTag'); + var TO_STRING_TAG$4 = wellKnownSymbol$o('toStringTag'); - var setToStringTag = function (it, TAG, STATIC) { - if (it && !has$1(it = STATIC ? it : it.prototype, TO_STRING_TAG$4)) { - defineProperty$8(it, TO_STRING_TAG$4, { configurable: true, value: TAG }); + var setToStringTag$a = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$c(target, TO_STRING_TAG$4)) { + defineProperty$b(target, TO_STRING_TAG$4, { configurable: true, value: TAG }); } }; var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; - - - - + var create$9 = objectCreate; + var createPropertyDescriptor$4 = createPropertyDescriptor$7; + var setToStringTag$9 = setToStringTag$a; + var Iterators$4 = iterators; var returnThis$1 = function () { return this; }; - var createIteratorConstructor = function (IteratorConstructor, NAME, next) { + var createIteratorConstructor$2 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { var TO_STRING_TAG = NAME + ' Iterator'; - IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) }); - setToStringTag(IteratorConstructor, TO_STRING_TAG, false); - iterators[TO_STRING_TAG] = returnThis$1; + IteratorConstructor.prototype = create$9(IteratorPrototype$1, { next: createPropertyDescriptor$4(+!ENUMERABLE_NEXT, next) }); + setToStringTag$9(IteratorConstructor, TO_STRING_TAG, false); + Iterators$4[TO_STRING_TAG] = returnThis$1; return IteratorConstructor; }; - var aPossiblePrototype = function (it) { - if (!isObject$4(it) && it !== null) { - throw TypeError("Can't set " + String(it) + ' as a prototype'); - } return it; + var global$$ = global$1o; + var isCallable$f = isCallable$r; + + var String$4 = global$$.String; + var TypeError$i = global$$.TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$f(argument)) return argument; + throw TypeError$i("Can't set " + String$4(argument) + ' as a prototype'); }; /* eslint-disable no-proto -- safe */ + var uncurryThis$M = functionUncurryThis; + var anObject$i = anObject$n; + var aPossiblePrototype = aPossiblePrototype$1; + // `Object.setPrototypeOf` method // https://tc39.es/ecma262/#sec-object.setprototypeof // Works with __proto__ only. Old v8 can't work with null proto objects. @@ -1046,30 +1480,46 @@ var setter; try { // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe - setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; - setter.call(test, []); + setter = uncurryThis$M(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set); + setter(test, []); CORRECT_SETTER = test instanceof Array; } catch (error) { /* empty */ } return function setPrototypeOf(O, proto) { - anObject(O); + anObject$i(O); aPossiblePrototype(proto); - if (CORRECT_SETTER) setter.call(O, proto); + if (CORRECT_SETTER) setter(O, proto); else O.__proto__ = proto; return O; }; }() : undefined); - var IteratorPrototype = iteratorsCore.IteratorPrototype; - var BUGGY_SAFARI_ITERATORS = iteratorsCore.BUGGY_SAFARI_ITERATORS; - var ITERATOR$7 = wellKnownSymbol('iterator'); + var $$1c = _export; + var call$l = functionCall; + var FunctionName$1 = functionName; + var isCallable$e = isCallable$r; + var createIteratorConstructor$1 = createIteratorConstructor$2; + var getPrototypeOf$3 = objectGetPrototypeOf; + var setPrototypeOf$6 = objectSetPrototypeOf; + var setToStringTag$8 = setToStringTag$a; + var createNonEnumerableProperty$7 = createNonEnumerableProperty$b; + var redefine$d = redefine$h.exports; + var wellKnownSymbol$n = wellKnownSymbol$t; + var Iterators$3 = iterators; + var IteratorsCore = iteratorsCore; + + var PROPER_FUNCTION_NAME$3 = FunctionName$1.PROPER; + var CONFIGURABLE_FUNCTION_NAME$1 = FunctionName$1.CONFIGURABLE; + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR$9 = wellKnownSymbol$n('iterator'); var KEYS = 'keys'; var VALUES = 'values'; var ENTRIES = 'entries'; var returnThis = function () { return this; }; - var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { - createIteratorConstructor(IteratorConstructor, NAME, next); + var defineIterator$3 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor$1(IteratorConstructor, NAME, next); var getIterationMethod = function (KIND) { if (KIND === DEFAULT && defaultIterator) return defaultIterator; @@ -1084,7 +1534,7 @@ var TO_STRING_TAG = NAME + ' Iterator'; var INCORRECT_VALUES_NAME = false; var IterablePrototype = Iterable.prototype; - var nativeIterator = IterablePrototype[ITERATOR$7] + var nativeIterator = IterablePrototype[ITERATOR$9] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT]; var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); @@ -1093,31 +1543,29 @@ // fix native if (anyNativeIterator) { - CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable())); - if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { - if (objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { - if (objectSetPrototypeOf) { - objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); - } else if (typeof CurrentIteratorPrototype[ITERATOR$7] != 'function') { - createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR$7, returnThis); + CurrentIteratorPrototype = getPrototypeOf$3(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf$3(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$6) { + setPrototypeOf$6(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$e(CurrentIteratorPrototype[ITERATOR$9])) { + redefine$d(CurrentIteratorPrototype, ITERATOR$9, returnThis); } } // Set @@toStringTag to native iterators - setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true); + setToStringTag$8(CurrentIteratorPrototype, TO_STRING_TAG, true); } } // fix Array.prototype.{ values, @@iterator }.name in V8 / FF - if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { - INCORRECT_VALUES_NAME = true; - defaultIterator = function values() { return nativeIterator.call(this); }; - } - - // define iterator - if (IterablePrototype[ITERATOR$7] !== defaultIterator) { - createNonEnumerableProperty(IterablePrototype, ITERATOR$7, defaultIterator); + if (PROPER_FUNCTION_NAME$3 && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME$1) { + createNonEnumerableProperty$7(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call$l(nativeIterator, this); }; + } } - iterators[NAME] = defaultIterator; // export additional methods if (DEFAULT) { @@ -1128,17 +1576,31 @@ }; if (FORCED) for (KEY in methods) { if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { - redefine(IterablePrototype, KEY, methods[KEY]); + redefine$d(IterablePrototype, KEY, methods[KEY]); } - } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } else $$1c({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); } + // define iterator + if (IterablePrototype[ITERATOR$9] !== defaultIterator) { + redefine$d(IterablePrototype, ITERATOR$9, defaultIterator, { name: DEFAULT }); + } + Iterators$3[NAME] = defaultIterator; + return methods; }; + var toIndexedObject$8 = toIndexedObject$d; + var addToUnscopables$5 = addToUnscopables$6; + var Iterators$2 = iterators; + var InternalStateModule$8 = internalState; + var defineProperty$a = objectDefineProperty.f; + var defineIterator$2 = defineIterator$3; + var DESCRIPTORS$i = descriptors; + var ARRAY_ITERATOR = 'Array Iterator'; - var setInternalState$7 = internalState.set; - var getInternalState$5 = internalState.getterFor(ARRAY_ITERATOR); + var setInternalState$8 = InternalStateModule$8.set; + var getInternalState$6 = InternalStateModule$8.getterFor(ARRAY_ITERATOR); // `Array.prototype.entries` method // https://tc39.es/ecma262/#sec-array.prototype.entries @@ -1150,17 +1612,17 @@ // https://tc39.es/ecma262/#sec-array.prototype-@@iterator // `CreateArrayIterator` internal method // https://tc39.es/ecma262/#sec-createarrayiterator - var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) { - setInternalState$7(this, { + var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) { + setInternalState$8(this, { type: ARRAY_ITERATOR, - target: toIndexedObject(iterated), // target + target: toIndexedObject$8(iterated), // target index: 0, // next index kind: kind // kind }); // `%ArrayIteratorPrototype%.next` method // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next }, function () { - var state = getInternalState$5(this); + var state = getInternalState$6(this); var target = state.target; var kind = state.kind; var index = state.index++; @@ -1176,21 +1638,36 @@ // argumentsList[@@iterator] is %ArrayProto_values% // https://tc39.es/ecma262/#sec-createunmappedargumentsobject // https://tc39.es/ecma262/#sec-createmappedargumentsobject - iterators.Arguments = iterators.Array; + var values = Iterators$2.Arguments = Iterators$2.Array; // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables - addToUnscopables('keys'); - addToUnscopables('values'); - addToUnscopables('entries'); + addToUnscopables$5('keys'); + addToUnscopables$5('values'); + addToUnscopables$5('entries'); + + // V8 ~ Chrome 45- bug + if (DESCRIPTORS$i && values.name !== 'values') try { + defineProperty$a(values, 'name', { value: 'values' }); + } catch (error) { /* empty */ } - var TO_STRING_TAG$3 = wellKnownSymbol('toStringTag'); + var wellKnownSymbol$m = wellKnownSymbol$t; + + var TO_STRING_TAG$3 = wellKnownSymbol$m('toStringTag'); var test$2 = {}; test$2[TO_STRING_TAG$3] = 'z'; var toStringTagSupport = String(test$2) === '[object z]'; - var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag'); + var global$_ = global$1o; + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$d = isCallable$r; + var classofRaw = classofRaw$1; + var wellKnownSymbol$l = wellKnownSymbol$t; + + var TO_STRING_TAG$2 = wellKnownSymbol$l('toStringTag'); + var Object$1 = global$_.Object; + // ES3 wrong here var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; @@ -1202,42 +1679,71 @@ }; // getting tag from ES6+ `Object.prototype.toString` - var classof = toStringTagSupport ? classofRaw : function (it) { + var classof$d = TO_STRING_TAG_SUPPORT$2 ? classofRaw : function (it) { var O, tag, result; return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case - : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$2)) == 'string' ? tag + : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG$2)) == 'string' ? tag // builtinTag case : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback - : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; + : (result = classofRaw(O)) == 'Object' && isCallable$d(O.callee) ? 'Arguments' : result; }; + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$c = classof$d; + // `Object.prototype.toString` method implementation // https://tc39.es/ecma262/#sec-object.prototype.tostring - var objectToString$1 = toStringTagSupport ? {}.toString : function toString() { - return '[object ' + classof(this) + ']'; + var objectToString$1 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$c(this) + ']'; }; + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var redefine$c = redefine$h.exports; + var toString$l = objectToString$1; + // `Object.prototype.toString` method // https://tc39.es/ecma262/#sec-object.prototype.tostring - if (!toStringTagSupport) { - redefine(Object.prototype, 'toString', objectToString$1, { unsafe: true }); + if (!TO_STRING_TAG_SUPPORT) { + redefine$c(Object.prototype, 'toString', toString$l, { unsafe: true }); } - // `String.prototype.{ codePointAt, at }` methods implementation + var global$Z = global$1o; + var classof$b = classof$d; + + var String$3 = global$Z.String; + + var toString$k = function (argument) { + if (classof$b(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string'); + return String$3(argument); + }; + + var uncurryThis$L = functionUncurryThis; + var toIntegerOrInfinity$8 = toIntegerOrInfinity$b; + var toString$j = toString$k; + var requireObjectCoercible$b = requireObjectCoercible$e; + + var charAt$8 = uncurryThis$L(''.charAt); + var charCodeAt$2 = uncurryThis$L(''.charCodeAt); + var stringSlice$b = uncurryThis$L(''.slice); + var createMethod$5 = function (CONVERT_TO_STRING) { return function ($this, pos) { - var S = String(requireObjectCoercible($this)); - var position = toInteger(pos); + var S = toString$j(requireObjectCoercible$b($this)); + var position = toIntegerOrInfinity$8(pos); var size = S.length; var first, second; if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; - first = S.charCodeAt(position); + first = charCodeAt$2(S, position); return first < 0xD800 || first > 0xDBFF || position + 1 === size - || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF - ? CONVERT_TO_STRING ? S.charAt(position) : first - : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + || (second = charCodeAt$2(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$8(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice$b(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; }; }; @@ -1250,31 +1756,32 @@ charAt: createMethod$5(true) }; - var charAt$1 = stringMultibyte.charAt; - - + var charAt$7 = stringMultibyte.charAt; + var toString$i = toString$k; + var InternalStateModule$7 = internalState; + var defineIterator$1 = defineIterator$3; var STRING_ITERATOR = 'String Iterator'; - var setInternalState$6 = internalState.set; - var getInternalState$4 = internalState.getterFor(STRING_ITERATOR); + var setInternalState$7 = InternalStateModule$7.set; + var getInternalState$5 = InternalStateModule$7.getterFor(STRING_ITERATOR); // `String.prototype[@@iterator]` method // https://tc39.es/ecma262/#sec-string.prototype-@@iterator - defineIterator(String, 'String', function (iterated) { - setInternalState$6(this, { + defineIterator$1(String, 'String', function (iterated) { + setInternalState$7(this, { type: STRING_ITERATOR, - string: String(iterated), + string: toString$i(iterated), index: 0 }); // `%StringIteratorPrototype%.next` method // https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next }, function next() { - var state = getInternalState$4(this); + var state = getInternalState$5(this); var string = state.string; var index = state.index; var point; if (index >= string.length) return { value: undefined, done: true }; - point = charAt$1(string, index); + point = charAt$7(string, index); state.index += point.length; return { value: point, done: false }; }); @@ -1315,46 +1822,109 @@ TouchList: 0 }; - var ITERATOR$6 = wellKnownSymbol('iterator'); - var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag'); - var ArrayValues = es_array_iterator.values; + // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` + var documentCreateElement = documentCreateElement$2; + + var classList$1 = documentCreateElement('span').classList; + var DOMTokenListPrototype$2 = classList$1 && classList$1.constructor && classList$1.constructor.prototype; + + var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; - for (var COLLECTION_NAME$1 in domIterables) { - var Collection$1 = global$2[COLLECTION_NAME$1]; - var CollectionPrototype$1 = Collection$1 && Collection$1.prototype; - if (CollectionPrototype$1) { + var global$Y = global$1o; + var DOMIterables$1 = domIterables; + var DOMTokenListPrototype$1 = domTokenListPrototype; + var ArrayIteratorMethods = es_array_iterator; + var createNonEnumerableProperty$6 = createNonEnumerableProperty$b; + var wellKnownSymbol$k = wellKnownSymbol$t; + + var ITERATOR$8 = wellKnownSymbol$k('iterator'); + var TO_STRING_TAG$1 = wellKnownSymbol$k('toStringTag'); + var ArrayValues = ArrayIteratorMethods.values; + + var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype$1[ITERATOR$6] !== ArrayValues) try { - createNonEnumerableProperty(CollectionPrototype$1, ITERATOR$6, ArrayValues); + if (CollectionPrototype[ITERATOR$8] !== ArrayValues) try { + createNonEnumerableProperty$6(CollectionPrototype, ITERATOR$8, ArrayValues); } catch (error) { - CollectionPrototype$1[ITERATOR$6] = ArrayValues; + CollectionPrototype[ITERATOR$8] = ArrayValues; } - if (!CollectionPrototype$1[TO_STRING_TAG$1]) { - createNonEnumerableProperty(CollectionPrototype$1, TO_STRING_TAG$1, COLLECTION_NAME$1); + if (!CollectionPrototype[TO_STRING_TAG$1]) { + createNonEnumerableProperty$6(CollectionPrototype, TO_STRING_TAG$1, COLLECTION_NAME); } - if (domIterables[COLLECTION_NAME$1]) for (var METHOD_NAME in es_array_iterator) { + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype$1[METHOD_NAME] !== es_array_iterator[METHOD_NAME]) try { - createNonEnumerableProperty(CollectionPrototype$1, METHOD_NAME, es_array_iterator[METHOD_NAME]); + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$6(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); } catch (error) { - CollectionPrototype$1[METHOD_NAME] = es_array_iterator[METHOD_NAME]; + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; } } } + }; + + for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$Y[COLLECTION_NAME$1] && global$Y[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); } + handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + + var NATIVE_BIND$2 = functionBindNative; + + var FunctionPrototype$1 = Function.prototype; + var apply$9 = FunctionPrototype$1.apply; + var call$k = FunctionPrototype$1.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$2 ? call$k.bind(apply$9) : function () { + return call$k.apply(apply$9, arguments); + }); + + var classof$a = classofRaw$1; + // `IsArray` abstract operation // https://tc39.es/ecma262/#sec-isarray // eslint-disable-next-line es/no-array-isarray -- safe - var isArray = Array.isArray || function isArray(arg) { - return classofRaw(arg) == 'Array'; + var isArray$8 = Array.isArray || function isArray(argument) { + return classof$a(argument) == 'Array'; + }; + + var objectGetOwnPropertyNamesExternal = {}; + + var toPropertyKey$2 = toPropertyKey$5; + var definePropertyModule$3 = objectDefineProperty; + var createPropertyDescriptor$3 = createPropertyDescriptor$7; + + var createProperty$5 = function (object, key, value) { + var propertyKey = toPropertyKey$2(key); + if (propertyKey in object) definePropertyModule$3.f(object, propertyKey, createPropertyDescriptor$3(0, value)); + else object[propertyKey] = value; + }; + + var global$X = global$1o; + var toAbsoluteIndex$7 = toAbsoluteIndex$9; + var lengthOfArrayLike$g = lengthOfArrayLike$i; + var createProperty$4 = createProperty$5; + + var Array$7 = global$X.Array; + var max$4 = Math.max; + + var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$g(O); + var k = toAbsoluteIndex$7(start, length); + var fin = toAbsoluteIndex$7(end === undefined ? length : end, length); + var result = Array$7(max$4(fin - k, 0)); + for (var n = 0; k < fin; k++, n++) createProperty$4(result, n, O[k]); + result.length = n; + return result; }; /* eslint-disable es/no-object-getownpropertynames -- safe */ + var classof$9 = classofRaw$1; + var toIndexedObject$7 = toIndexedObject$d; var $getOwnPropertyNames$1 = objectGetOwnPropertyNames.f; - - var toString = {}.toString; + var arraySlice$c = arraySliceSimple; var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : []; @@ -1363,86 +1933,146 @@ try { return $getOwnPropertyNames$1(it); } catch (error) { - return windowNames.slice(); + return arraySlice$c(windowNames); } }; // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window - var f$1 = function getOwnPropertyNames(it) { - return windowNames && toString.call(it) == '[object Window]' + objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$9(it) == 'Window' ? getWindowNames(it) - : $getOwnPropertyNames$1(toIndexedObject(it)); + : $getOwnPropertyNames$1(toIndexedObject$7(it)); }; - var objectGetOwnPropertyNamesExternal = { - f: f$1 - }; + var uncurryThis$K = functionUncurryThis; - var aFunction = function (it) { - if (typeof it != 'function') { - throw TypeError(String(it) + ' is not a function'); - } return it; - }; + var arraySlice$b = uncurryThis$K([].slice); + + var uncurryThis$J = functionUncurryThis; + var aCallable$8 = aCallable$a; + var NATIVE_BIND$1 = functionBindNative; + + var bind$f = uncurryThis$J(uncurryThis$J.bind); // optional / simple context binding - var functionBindContext = function (fn, that, length) { - aFunction(fn); - if (that === undefined) return fn; - switch (length) { - case 0: return function () { - return fn.call(that); - }; - case 1: return function (a) { - return fn.call(that, a); - }; - case 2: return function (a, b) { - return fn.call(that, a, b); - }; - case 3: return function (a, b, c) { - return fn.call(that, a, b, c); - }; - } - return function (/* ...args */) { + var functionBindContext = function (fn, that) { + aCallable$8(fn); + return that === undefined ? fn : NATIVE_BIND$1 ? bind$f(fn, that) : function (/* ...args */) { return fn.apply(that, arguments); }; }; - var SPECIES$6 = wellKnownSymbol('species'); + var uncurryThis$I = functionUncurryThis; + var fails$L = fails$V; + var isCallable$c = isCallable$r; + var classof$8 = classof$d; + var getBuiltIn$6 = getBuiltIn$b; + var inspectSource$1 = inspectSource$4; + + var noop$2 = function () { /* empty */ }; + var empty$1 = []; + var construct$1 = getBuiltIn$6('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec$6 = uncurryThis$I(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.exec(noop$2); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$c(argument)) return false; + try { + construct$1(noop$2, empty$1, argument); + return true; + } catch (error) { + return false; + } + }; - // `ArraySpeciesCreate` abstract operation + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$c(argument)) return false; + switch (classof$8(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec$6(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$4 = !construct$1 || fails$L(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var global$W = global$1o; + var isArray$7 = isArray$8; + var isConstructor$3 = isConstructor$4; + var isObject$m = isObject$s; + var wellKnownSymbol$j = wellKnownSymbol$t; + + var SPECIES$6 = wellKnownSymbol$j('species'); + var Array$6 = global$W.Array; + + // a part of `ArraySpeciesCreate` abstract operation // https://tc39.es/ecma262/#sec-arrayspeciescreate - var arraySpeciesCreate = function (originalArray, length) { + var arraySpeciesConstructor$1 = function (originalArray) { var C; - if (isArray(originalArray)) { + if (isArray$7(originalArray)) { C = originalArray.constructor; // cross-realm fallback - if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; - else if (isObject$4(C)) { + if (isConstructor$3(C) && (C === Array$6 || isArray$7(C.prototype))) C = undefined; + else if (isObject$m(C)) { C = C[SPECIES$6]; if (C === null) C = undefined; } - } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); + } return C === undefined ? Array$6 : C; + }; + + var arraySpeciesConstructor = arraySpeciesConstructor$1; + + // `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesCreate$4 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); }; - var push = [].push; + var bind$e = functionBindContext; + var uncurryThis$H = functionUncurryThis; + var IndexedObject$3 = indexedObject; + var toObject$f = toObject$i; + var lengthOfArrayLike$f = lengthOfArrayLike$i; + var arraySpeciesCreate$3 = arraySpeciesCreate$4; + + var push$9 = uncurryThis$H([].push); - // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterOut }` methods implementation + // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation var createMethod$4 = function (TYPE) { var IS_MAP = TYPE == 1; var IS_FILTER = TYPE == 2; var IS_SOME = TYPE == 3; var IS_EVERY = TYPE == 4; var IS_FIND_INDEX = TYPE == 6; - var IS_FILTER_OUT = TYPE == 7; + var IS_FILTER_REJECT = TYPE == 7; var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; return function ($this, callbackfn, that, specificCreate) { - var O = toObject($this); - var self = indexedObject(O); - var boundFunction = functionBindContext(callbackfn, that, 3); - var length = toLength(self.length); + var O = toObject$f($this); + var self = IndexedObject$3(O); + var boundFunction = bind$e(callbackfn, that); + var length = lengthOfArrayLike$f(self); var index = 0; - var create = specificCreate || arraySpeciesCreate; - var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_OUT ? create($this, 0) : undefined; + var create = specificCreate || arraySpeciesCreate$3; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; var value, result; for (;length > index; index++) if (NO_HOLES || index in self) { value = self[index]; @@ -1453,10 +2083,10 @@ case 3: return true; // some case 5: return value; // find case 6: return index; // findIndex - case 2: push.call(target, value); // filter + case 2: push$9(target, value); // filter } else switch (TYPE) { case 4: return false; // every - case 7: push.call(target, value); // filterOut + case 7: push$9(target, value); // filterReject } } } @@ -1486,130 +2116,173 @@ // `Array.prototype.findIndex` method // https://tc39.es/ecma262/#sec-array.prototype.findIndex findIndex: createMethod$4(6), - // `Array.prototype.filterOut` method + // `Array.prototype.filterReject` method // https://github.com/tc39/proposal-array-filtering - filterOut: createMethod$4(7) + filterReject: createMethod$4(7) }; + var $$1b = _export; + var global$V = global$1o; + var getBuiltIn$5 = getBuiltIn$b; + var apply$8 = functionApply; + var call$j = functionCall; + var uncurryThis$G = functionUncurryThis; + var DESCRIPTORS$h = descriptors; + var NATIVE_SYMBOL$1 = nativeSymbol; + var fails$K = fails$V; + var hasOwn$b = hasOwnProperty_1; + var isArray$6 = isArray$8; + var isCallable$b = isCallable$r; + var isObject$l = isObject$s; + var isPrototypeOf$8 = objectIsPrototypeOf; + var isSymbol$3 = isSymbol$6; + var anObject$h = anObject$n; + var toObject$e = toObject$i; + var toIndexedObject$6 = toIndexedObject$d; + var toPropertyKey$1 = toPropertyKey$5; + var $toString$3 = toString$k; + var createPropertyDescriptor$2 = createPropertyDescriptor$7; + var nativeObjectCreate = objectCreate; + var objectKeys$2 = objectKeys$4; + var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternal = objectGetOwnPropertyNamesExternal; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var getOwnPropertyDescriptorModule$2 = objectGetOwnPropertyDescriptor; + var definePropertyModule$2 = objectDefineProperty; + var definePropertiesModule = objectDefineProperties; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var arraySlice$a = arraySlice$b; + var redefine$b = redefine$h.exports; + var shared$1 = shared$5.exports; + var sharedKey = sharedKey$4; + var hiddenKeys$1 = hiddenKeys$6; + var uid$2 = uid$5; + var wellKnownSymbol$i = wellKnownSymbol$t; + var wrappedWellKnownSymbolModule = wellKnownSymbolWrapped; + var defineWellKnownSymbol$2 = defineWellKnownSymbol$4; + var setToStringTag$7 = setToStringTag$a; + var InternalStateModule$6 = internalState; var $forEach$2 = arrayIteration.forEach; var HIDDEN = sharedKey('hidden'); var SYMBOL = 'Symbol'; var PROTOTYPE$1 = 'prototype'; - var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); - var setInternalState$5 = internalState.set; - var getInternalState$3 = internalState.getterFor(SYMBOL); - var ObjectPrototype$2 = Object[PROTOTYPE$1]; - var $Symbol = global$2.Symbol; - var $stringify = getBuiltIn('JSON', 'stringify'); - var nativeGetOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; - var nativeDefineProperty = objectDefineProperty.f; - var nativeGetOwnPropertyNames = objectGetOwnPropertyNamesExternal.f; - var nativePropertyIsEnumerable = objectPropertyIsEnumerable.f; - var AllSymbols = shared('symbols'); - var ObjectPrototypeSymbols = shared('op-symbols'); - var StringToSymbolRegistry = shared('string-to-symbol-registry'); - var SymbolToStringRegistry = shared('symbol-to-string-registry'); - var WellKnownSymbolsStore = shared('wks'); - var QObject = global$2.QObject; + var TO_PRIMITIVE = wellKnownSymbol$i('toPrimitive'); + + var setInternalState$6 = InternalStateModule$6.set; + var getInternalState$4 = InternalStateModule$6.getterFor(SYMBOL); + + var ObjectPrototype$3 = Object[PROTOTYPE$1]; + var $Symbol = global$V.Symbol; + var SymbolPrototype$1 = $Symbol && $Symbol[PROTOTYPE$1]; + var TypeError$h = global$V.TypeError; + var QObject = global$V.QObject; + var $stringify = getBuiltIn$5('JSON', 'stringify'); + var nativeGetOwnPropertyDescriptor$2 = getOwnPropertyDescriptorModule$2.f; + var nativeDefineProperty$1 = definePropertyModule$2.f; + var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f; + var nativePropertyIsEnumerable = propertyIsEnumerableModule$1.f; + var push$8 = uncurryThis$G([].push); + + var AllSymbols = shared$1('symbols'); + var ObjectPrototypeSymbols = shared$1('op-symbols'); + var StringToSymbolRegistry = shared$1('string-to-symbol-registry'); + var SymbolToStringRegistry = shared$1('symbol-to-string-registry'); + var WellKnownSymbolsStore = shared$1('wks'); + // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 var USE_SETTER = !QObject || !QObject[PROTOTYPE$1] || !QObject[PROTOTYPE$1].findChild; // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 - var setSymbolDescriptor = descriptors && fails(function () { - return objectCreate(nativeDefineProperty({}, 'a', { - get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; } + var setSymbolDescriptor = DESCRIPTORS$h && fails$K(function () { + return nativeObjectCreate(nativeDefineProperty$1({}, 'a', { + get: function () { return nativeDefineProperty$1(this, 'a', { value: 7 }).a; } })).a != 7; }) ? function (O, P, Attributes) { - var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$1(ObjectPrototype$2, P); - if (ObjectPrototypeDescriptor) delete ObjectPrototype$2[P]; - nativeDefineProperty(O, P, Attributes); - if (ObjectPrototypeDescriptor && O !== ObjectPrototype$2) { - nativeDefineProperty(ObjectPrototype$2, P, ObjectPrototypeDescriptor); + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$2(ObjectPrototype$3, P); + if (ObjectPrototypeDescriptor) delete ObjectPrototype$3[P]; + nativeDefineProperty$1(O, P, Attributes); + if (ObjectPrototypeDescriptor && O !== ObjectPrototype$3) { + nativeDefineProperty$1(ObjectPrototype$3, P, ObjectPrototypeDescriptor); } - } : nativeDefineProperty; + } : nativeDefineProperty$1; var wrap$2 = function (tag, description) { - var symbol = AllSymbols[tag] = objectCreate($Symbol[PROTOTYPE$1]); - setInternalState$5(symbol, { + var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype$1); + setInternalState$6(symbol, { type: SYMBOL, tag: tag, description: description }); - if (!descriptors) symbol.description = description; + if (!DESCRIPTORS$h) symbol.description = description; return symbol; }; - var isSymbol$1 = useSymbolAsUid ? function (it) { - return typeof it == 'symbol'; - } : function (it) { - return Object(it) instanceof $Symbol; - }; - var $defineProperty = function defineProperty(O, P, Attributes) { - if (O === ObjectPrototype$2) $defineProperty(ObjectPrototypeSymbols, P, Attributes); - anObject(O); - var key = toPrimitive(P, true); - anObject(Attributes); - if (has$1(AllSymbols, key)) { + if (O === ObjectPrototype$3) $defineProperty(ObjectPrototypeSymbols, P, Attributes); + anObject$h(O); + var key = toPropertyKey$1(P); + anObject$h(Attributes); + if (hasOwn$b(AllSymbols, key)) { if (!Attributes.enumerable) { - if (!has$1(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {})); + if (!hasOwn$b(O, HIDDEN)) nativeDefineProperty$1(O, HIDDEN, createPropertyDescriptor$2(1, {})); O[HIDDEN][key] = true; } else { - if (has$1(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; - Attributes = objectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); + if (hasOwn$b(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; + Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor$2(0, false) }); } return setSymbolDescriptor(O, key, Attributes); - } return nativeDefineProperty(O, key, Attributes); + } return nativeDefineProperty$1(O, key, Attributes); }; var $defineProperties = function defineProperties(O, Properties) { - anObject(O); - var properties = toIndexedObject(Properties); - var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); + anObject$h(O); + var properties = toIndexedObject$6(Properties); + var keys = objectKeys$2(properties).concat($getOwnPropertySymbols(properties)); $forEach$2(keys, function (key) { - if (!descriptors || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]); + if (!DESCRIPTORS$h || call$j($propertyIsEnumerable$1, properties, key)) $defineProperty(O, key, properties[key]); }); return O; }; var $create = function create(O, Properties) { - return Properties === undefined ? objectCreate(O) : $defineProperties(objectCreate(O), Properties); + return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties); }; - var $propertyIsEnumerable = function propertyIsEnumerable(V) { - var P = toPrimitive(V, true); - var enumerable = nativePropertyIsEnumerable.call(this, P); - if (this === ObjectPrototype$2 && has$1(AllSymbols, P) && !has$1(ObjectPrototypeSymbols, P)) return false; - return enumerable || !has$1(this, P) || !has$1(AllSymbols, P) || has$1(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true; + var $propertyIsEnumerable$1 = function propertyIsEnumerable(V) { + var P = toPropertyKey$1(V); + var enumerable = call$j(nativePropertyIsEnumerable, this, P); + if (this === ObjectPrototype$3 && hasOwn$b(AllSymbols, P) && !hasOwn$b(ObjectPrototypeSymbols, P)) return false; + return enumerable || !hasOwn$b(this, P) || !hasOwn$b(AllSymbols, P) || hasOwn$b(this, HIDDEN) && this[HIDDEN][P] + ? enumerable : true; }; var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { - var it = toIndexedObject(O); - var key = toPrimitive(P, true); - if (it === ObjectPrototype$2 && has$1(AllSymbols, key) && !has$1(ObjectPrototypeSymbols, key)) return; - var descriptor = nativeGetOwnPropertyDescriptor$1(it, key); - if (descriptor && has$1(AllSymbols, key) && !(has$1(it, HIDDEN) && it[HIDDEN][key])) { + var it = toIndexedObject$6(O); + var key = toPropertyKey$1(P); + if (it === ObjectPrototype$3 && hasOwn$b(AllSymbols, key) && !hasOwn$b(ObjectPrototypeSymbols, key)) return; + var descriptor = nativeGetOwnPropertyDescriptor$2(it, key); + if (descriptor && hasOwn$b(AllSymbols, key) && !(hasOwn$b(it, HIDDEN) && it[HIDDEN][key])) { descriptor.enumerable = true; } return descriptor; }; var $getOwnPropertyNames = function getOwnPropertyNames(O) { - var names = nativeGetOwnPropertyNames(toIndexedObject(O)); + var names = nativeGetOwnPropertyNames(toIndexedObject$6(O)); var result = []; $forEach$2(names, function (key) { - if (!has$1(AllSymbols, key) && !has$1(hiddenKeys$1, key)) result.push(key); + if (!hasOwn$b(AllSymbols, key) && !hasOwn$b(hiddenKeys$1, key)) push$8(result, key); }); return result; }; var $getOwnPropertySymbols = function getOwnPropertySymbols(O) { - var IS_OBJECT_PROTOTYPE = O === ObjectPrototype$2; - var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); + var IS_OBJECT_PROTOTYPE = O === ObjectPrototype$3; + var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject$6(O)); var result = []; $forEach$2(names, function (key) { - if (has$1(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has$1(ObjectPrototype$2, key))) { - result.push(AllSymbols[key]); + if (hasOwn$b(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn$b(ObjectPrototype$3, key))) { + push$8(result, AllSymbols[key]); } }); return result; @@ -1617,66 +2290,69 @@ // `Symbol` constructor // https://tc39.es/ecma262/#sec-symbol-constructor - if (!nativeSymbol) { + if (!NATIVE_SYMBOL$1) { $Symbol = function Symbol() { - if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor'); - var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]); - var tag = uid(description); + if (isPrototypeOf$8(SymbolPrototype$1, this)) throw TypeError$h('Symbol is not a constructor'); + var description = !arguments.length || arguments[0] === undefined ? undefined : $toString$3(arguments[0]); + var tag = uid$2(description); var setter = function (value) { - if (this === ObjectPrototype$2) setter.call(ObjectPrototypeSymbols, value); - if (has$1(this, HIDDEN) && has$1(this[HIDDEN], tag)) this[HIDDEN][tag] = false; - setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); + if (this === ObjectPrototype$3) call$j(setter, ObjectPrototypeSymbols, value); + if (hasOwn$b(this, HIDDEN) && hasOwn$b(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDescriptor(this, tag, createPropertyDescriptor$2(1, value)); }; - if (descriptors && USE_SETTER) setSymbolDescriptor(ObjectPrototype$2, tag, { configurable: true, set: setter }); + if (DESCRIPTORS$h && USE_SETTER) setSymbolDescriptor(ObjectPrototype$3, tag, { configurable: true, set: setter }); return wrap$2(tag, description); }; - redefine($Symbol[PROTOTYPE$1], 'toString', function toString() { - return getInternalState$3(this).tag; + SymbolPrototype$1 = $Symbol[PROTOTYPE$1]; + + redefine$b(SymbolPrototype$1, 'toString', function toString() { + return getInternalState$4(this).tag; }); - redefine($Symbol, 'withoutSetter', function (description) { - return wrap$2(uid(description), description); + redefine$b($Symbol, 'withoutSetter', function (description) { + return wrap$2(uid$2(description), description); }); - objectPropertyIsEnumerable.f = $propertyIsEnumerable; - objectDefineProperty.f = $defineProperty; - objectGetOwnPropertyDescriptor.f = $getOwnPropertyDescriptor; - objectGetOwnPropertyNames.f = objectGetOwnPropertyNamesExternal.f = $getOwnPropertyNames; - objectGetOwnPropertySymbols.f = $getOwnPropertySymbols; + propertyIsEnumerableModule$1.f = $propertyIsEnumerable$1; + definePropertyModule$2.f = $defineProperty; + definePropertiesModule.f = $defineProperties; + getOwnPropertyDescriptorModule$2.f = $getOwnPropertyDescriptor; + getOwnPropertyNamesModule$1.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames; + getOwnPropertySymbolsModule$1.f = $getOwnPropertySymbols; - wellKnownSymbolWrapped.f = function (name) { - return wrap$2(wellKnownSymbol(name), name); + wrappedWellKnownSymbolModule.f = function (name) { + return wrap$2(wellKnownSymbol$i(name), name); }; - if (descriptors) { + if (DESCRIPTORS$h) { // https://github.com/tc39/proposal-Symbol-description - nativeDefineProperty($Symbol[PROTOTYPE$1], 'description', { + nativeDefineProperty$1(SymbolPrototype$1, 'description', { configurable: true, get: function description() { - return getInternalState$3(this).description; + return getInternalState$4(this).description; } }); { - redefine(ObjectPrototype$2, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + redefine$b(ObjectPrototype$3, 'propertyIsEnumerable', $propertyIsEnumerable$1, { unsafe: true }); } } } - _export({ global: true, wrap: true, forced: !nativeSymbol, sham: !nativeSymbol }, { + $$1b({ global: true, wrap: true, forced: !NATIVE_SYMBOL$1, sham: !NATIVE_SYMBOL$1 }, { Symbol: $Symbol }); - $forEach$2(objectKeys(WellKnownSymbolsStore), function (name) { - defineWellKnownSymbol(name); + $forEach$2(objectKeys$2(WellKnownSymbolsStore), function (name) { + defineWellKnownSymbol$2(name); }); - _export({ target: SYMBOL, stat: true, forced: !nativeSymbol }, { + $$1b({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL$1 }, { // `Symbol.for` method // https://tc39.es/ecma262/#sec-symbol.for 'for': function (key) { - var string = String(key); - if (has$1(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; + var string = $toString$3(key); + if (hasOwn$b(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; var symbol = $Symbol(string); StringToSymbolRegistry[string] = symbol; SymbolToStringRegistry[symbol] = string; @@ -1685,14 +2361,14 @@ // `Symbol.keyFor` method // https://tc39.es/ecma262/#sec-symbol.keyfor keyFor: function keyFor(sym) { - if (!isSymbol$1(sym)) throw TypeError(sym + ' is not a symbol'); - if (has$1(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; + if (!isSymbol$3(sym)) throw TypeError$h(sym + ' is not a symbol'); + if (hasOwn$b(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; }, useSetter: function () { USE_SETTER = true; }, useSimple: function () { USE_SETTER = false; } }); - _export({ target: 'Object', stat: true, forced: !nativeSymbol, sham: !descriptors }, { + $$1b({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL$1, sham: !DESCRIPTORS$h }, { // `Object.create` method // https://tc39.es/ecma262/#sec-object.create create: $create, @@ -1707,7 +2383,7 @@ getOwnPropertyDescriptor: $getOwnPropertyDescriptor }); - _export({ target: 'Object', stat: true, forced: !nativeSymbol }, { + $$1b({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL$1 }, { // `Object.getOwnPropertyNames` method // https://tc39.es/ecma262/#sec-object.getownpropertynames getOwnPropertyNames: $getOwnPropertyNames, @@ -1718,16 +2394,16 @@ // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives // https://bugs.chromium.org/p/v8/issues/detail?id=3443 - _export({ target: 'Object', stat: true, forced: fails(function () { objectGetOwnPropertySymbols.f(1); }) }, { + $$1b({ target: 'Object', stat: true, forced: fails$K(function () { getOwnPropertySymbolsModule$1.f(1); }) }, { getOwnPropertySymbols: function getOwnPropertySymbols(it) { - return objectGetOwnPropertySymbols.f(toObject(it)); + return getOwnPropertySymbolsModule$1.f(toObject$e(it)); } }); // `JSON.stringify` method behavior with symbols // https://tc39.es/ecma262/#sec-json.stringify if ($stringify) { - var FORCED_JSON_STRINGIFY = !nativeSymbol || fails(function () { + var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL$1 || fails$K(function () { var symbol = $Symbol(); // MS Edge converts symbol values to JSON as {} return $stringify([symbol]) != '[null]' @@ -1737,112 +2413,143 @@ || $stringify(Object(symbol)) != '{}'; }); - _export({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, { + $$1b({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, { // eslint-disable-next-line no-unused-vars -- required for `.length` stringify: function stringify(it, replacer, space) { - var args = [it]; - var index = 1; - var $replacer; - while (arguments.length > index) args.push(arguments[index++]); - $replacer = replacer; - if (!isObject$4(replacer) && it === undefined || isSymbol$1(it)) return; // IE8 returns string on undefined - if (!isArray(replacer)) replacer = function (key, value) { - if (typeof $replacer == 'function') value = $replacer.call(this, key, value); - if (!isSymbol$1(value)) return value; + var args = arraySlice$a(arguments); + var $replacer = replacer; + if (!isObject$l(replacer) && it === undefined || isSymbol$3(it)) return; // IE8 returns string on undefined + if (!isArray$6(replacer)) replacer = function (key, value) { + if (isCallable$b($replacer)) value = call$j($replacer, this, key, value); + if (!isSymbol$3(value)) return value; }; args[1] = replacer; - return $stringify.apply(null, args); + return apply$8($stringify, null, args); } }); } // `Symbol.prototype[@@toPrimitive]` method // https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive - if (!$Symbol[PROTOTYPE$1][TO_PRIMITIVE]) { - createNonEnumerableProperty($Symbol[PROTOTYPE$1], TO_PRIMITIVE, $Symbol[PROTOTYPE$1].valueOf); + if (!SymbolPrototype$1[TO_PRIMITIVE]) { + var valueOf = SymbolPrototype$1.valueOf; + // eslint-disable-next-line no-unused-vars -- required for .length + redefine$b(SymbolPrototype$1, TO_PRIMITIVE, function (hint) { + // TODO: improve hint logic + return call$j(valueOf, this); + }); } // `Symbol.prototype[@@toStringTag]` property // https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag - setToStringTag($Symbol, SYMBOL); + setToStringTag$7($Symbol, SYMBOL); hiddenKeys$1[HIDDEN] = true; - var defineProperty$7 = objectDefineProperty.f; - + var $$1a = _export; + var DESCRIPTORS$g = descriptors; + var global$U = global$1o; + var uncurryThis$F = functionUncurryThis; + var hasOwn$a = hasOwnProperty_1; + var isCallable$a = isCallable$r; + var isPrototypeOf$7 = objectIsPrototypeOf; + var toString$h = toString$k; + var defineProperty$9 = objectDefineProperty.f; + var copyConstructorProperties = copyConstructorProperties$2; - var NativeSymbol = global$2.Symbol; + var NativeSymbol = global$U.Symbol; + var SymbolPrototype = NativeSymbol && NativeSymbol.prototype; - if (descriptors && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || + if (DESCRIPTORS$g && isCallable$a(NativeSymbol) && (!('description' in SymbolPrototype) || // Safari 12 bug NativeSymbol().description !== undefined )) { var EmptyStringDescriptionStore = {}; // wrap Symbol constructor for correct work with undefined description var SymbolWrapper = function Symbol() { - var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); - var result = this instanceof SymbolWrapper + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$h(arguments[0]); + var result = isPrototypeOf$7(SymbolPrototype, this) ? new NativeSymbol(description) // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' : description === undefined ? NativeSymbol() : NativeSymbol(description); if (description === '') EmptyStringDescriptionStore[result] = true; return result; }; + copyConstructorProperties(SymbolWrapper, NativeSymbol); - var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; - symbolPrototype.constructor = SymbolWrapper; + SymbolWrapper.prototype = SymbolPrototype; + SymbolPrototype.constructor = SymbolWrapper; - var symbolToString = symbolPrototype.toString; - var native = String(NativeSymbol('test')) == 'Symbol(test)'; + var NATIVE_SYMBOL = String(NativeSymbol('test')) == 'Symbol(test)'; + var symbolToString$1 = uncurryThis$F(SymbolPrototype.toString); + var symbolValueOf = uncurryThis$F(SymbolPrototype.valueOf); var regexp = /^Symbol\((.*)\)[^)]+$/; - defineProperty$7(symbolPrototype, 'description', { + var replace$8 = uncurryThis$F(''.replace); + var stringSlice$a = uncurryThis$F(''.slice); + + defineProperty$9(SymbolPrototype, 'description', { configurable: true, get: function description() { - var symbol = isObject$4(this) ? this.valueOf() : this; - var string = symbolToString.call(symbol); - if (has$1(EmptyStringDescriptionStore, symbol)) return ''; - var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); + var symbol = symbolValueOf(this); + var string = symbolToString$1(symbol); + if (hasOwn$a(EmptyStringDescriptionStore, symbol)) return ''; + var desc = NATIVE_SYMBOL ? stringSlice$a(string, 7, -1) : replace$8(string, regexp, '$1'); return desc === '' ? undefined : desc; } }); - _export({ global: true, forced: true }, { + $$1a({ global: true, forced: true }, { Symbol: SymbolWrapper }); } // eslint-disable-next-line es/no-typed-arrays -- safe - var arrayBufferNative = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined'; + var arrayBufferNative = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined'; + + var redefine$a = redefine$h.exports; - var redefineAll = function (target, src, options) { - for (var key in src) redefine(target, key, src[key], options); + var redefineAll$4 = function (target, src, options) { + for (var key in src) redefine$a(target, key, src[key], options); return target; }; - var anInstance = function (it, Constructor, name) { - if (!(it instanceof Constructor)) { - throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); - } return it; + var global$T = global$1o; + var isPrototypeOf$6 = objectIsPrototypeOf; + + var TypeError$g = global$T.TypeError; + + var anInstance$7 = function (it, Prototype) { + if (isPrototypeOf$6(Prototype, it)) return it; + throw TypeError$g('Incorrect invocation'); }; + var global$S = global$1o; + var toIntegerOrInfinity$7 = toIntegerOrInfinity$b; + var toLength$a = toLength$c; + + var RangeError$b = global$S.RangeError; + // `ToIndex` abstract operation // https://tc39.es/ecma262/#sec-toindex - var toIndex = function (it) { + var toIndex$2 = function (it) { if (it === undefined) return 0; - var number = toInteger(it); - var length = toLength(number); - if (number !== length) throw RangeError('Wrong length or index'); + var number = toIntegerOrInfinity$7(it); + var length = toLength$a(number); + if (number !== length) throw RangeError$b('Wrong length or index'); return length; }; // IEEE754 conversions based on https://github.com/feross/ieee754 + var global$R = global$1o; + + var Array$5 = global$R.Array; var abs$4 = Math.abs; var pow$2 = Math.pow; - var floor$6 = Math.floor; + var floor$7 = Math.floor; var log$2 = Math.log; var LN2 = Math.LN2; var pack = function (number, mantissaLength, bytes) { - var buffer = new Array(bytes); + var buffer = Array$5(bytes); var exponentLength = bytes * 8 - mantissaLength - 1; var eMax = (1 << exponentLength) - 1; var eBias = eMax >> 1; @@ -1857,8 +2564,9 @@ mantissa = number != number ? 1 : 0; exponent = eMax; } else { - exponent = floor$6(log$2(number) / LN2); - if (number * (c = pow$2(2, -exponent)) < 1) { + exponent = floor$7(log$2(number) / LN2); + c = pow$2(2, -exponent); + if (number * c < 1) { exponent--; c *= 2; } @@ -1882,10 +2590,18 @@ exponent = 0; } } - for (; mantissaLength >= 8; buffer[index++] = mantissa & 255, mantissa /= 256, mantissaLength -= 8); + while (mantissaLength >= 8) { + buffer[index++] = mantissa & 255; + mantissa /= 256; + mantissaLength -= 8; + } exponent = exponent << mantissaLength | mantissa; exponentLength += mantissaLength; - for (; exponentLength > 0; buffer[index++] = exponent & 255, exponent /= 256, exponentLength -= 8); + while (exponentLength > 0) { + buffer[index++] = exponent & 255; + exponent /= 256; + exponentLength -= 8; + } buffer[--index] |= sign * 128; return buffer; }; @@ -1901,11 +2617,17 @@ var exponent = sign & 127; var mantissa; sign >>= 7; - for (; nBits > 0; exponent = exponent * 256 + buffer[index], index--, nBits -= 8); + while (nBits > 0) { + exponent = exponent * 256 + buffer[index--]; + nBits -= 8; + } mantissa = exponent & (1 << -nBits) - 1; exponent >>= -nBits; nBits += mantissaLength; - for (; nBits > 0; mantissa = mantissa * 256 + buffer[index], index--, nBits -= 8); + while (nBits > 0) { + mantissa = mantissa * 256 + buffer[index--]; + nBits -= 8; + } if (exponent === 0) { exponent = 1 - eBias; } else if (exponent === eMax) { @@ -1916,46 +2638,72 @@ } return (sign ? -1 : 1) * mantissa * pow$2(2, exponent - mantissaLength); }; - var ieee754$1 = { + var ieee754$2 = { pack: pack, unpack: unpack }; + var toObject$d = toObject$i; + var toAbsoluteIndex$6 = toAbsoluteIndex$9; + var lengthOfArrayLike$e = lengthOfArrayLike$i; + // `Array.prototype.fill` method implementation // https://tc39.es/ecma262/#sec-array.prototype.fill - var arrayFill = function fill(value /* , start = 0, end = @length */) { - var O = toObject(this); - var length = toLength(O.length); + var arrayFill$1 = function fill(value /* , start = 0, end = @length */) { + var O = toObject$d(this); + var length = lengthOfArrayLike$e(O); var argumentsLength = arguments.length; - var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var index = toAbsoluteIndex$6(argumentsLength > 1 ? arguments[1] : undefined, length); var end = argumentsLength > 2 ? arguments[2] : undefined; - var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + var endPos = end === undefined ? length : toAbsoluteIndex$6(end, length); while (endPos > index) O[index++] = value; return O; }; - var getOwnPropertyNames$3 = objectGetOwnPropertyNames.f; - var defineProperty$6 = objectDefineProperty.f; - - - - - var getInternalState$2 = internalState.get; - var setInternalState$4 = internalState.set; + var global$Q = global$1o; + var uncurryThis$E = functionUncurryThis; + var DESCRIPTORS$f = descriptors; + var NATIVE_ARRAY_BUFFER$2 = arrayBufferNative; + var FunctionName = functionName; + var createNonEnumerableProperty$5 = createNonEnumerableProperty$b; + var redefineAll$3 = redefineAll$4; + var fails$J = fails$V; + var anInstance$6 = anInstance$7; + var toIntegerOrInfinity$6 = toIntegerOrInfinity$b; + var toLength$9 = toLength$c; + var toIndex$1 = toIndex$2; + var IEEE754 = ieee754$2; + var getPrototypeOf$2 = objectGetPrototypeOf; + var setPrototypeOf$5 = objectSetPrototypeOf; + var getOwnPropertyNames$4 = objectGetOwnPropertyNames.f; + var defineProperty$8 = objectDefineProperty.f; + var arrayFill = arrayFill$1; + var arraySlice$9 = arraySliceSimple; + var setToStringTag$6 = setToStringTag$a; + var InternalStateModule$5 = internalState; + + var PROPER_FUNCTION_NAME$2 = FunctionName.PROPER; + var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; + var getInternalState$3 = InternalStateModule$5.get; + var setInternalState$5 = InternalStateModule$5.set; var ARRAY_BUFFER$1 = 'ArrayBuffer'; var DATA_VIEW = 'DataView'; var PROTOTYPE = 'prototype'; - var WRONG_LENGTH = 'Wrong length'; + var WRONG_LENGTH$1 = 'Wrong length'; var WRONG_INDEX = 'Wrong index'; - var NativeArrayBuffer$1 = global$2[ARRAY_BUFFER$1]; + var NativeArrayBuffer$1 = global$Q[ARRAY_BUFFER$1]; var $ArrayBuffer = NativeArrayBuffer$1; - var $DataView = global$2[DATA_VIEW]; - var $DataViewPrototype = $DataView && $DataView[PROTOTYPE]; - var ObjectPrototype$1 = Object.prototype; - var RangeError$1 = global$2.RangeError; - - var packIEEE754 = ieee754$1.pack; - var unpackIEEE754 = ieee754$1.unpack; + var ArrayBufferPrototype$1 = $ArrayBuffer && $ArrayBuffer[PROTOTYPE]; + var $DataView = global$Q[DATA_VIEW]; + var DataViewPrototype$1 = $DataView && $DataView[PROTOTYPE]; + var ObjectPrototype$2 = Object.prototype; + var Array$4 = global$Q.Array; + var RangeError$a = global$Q.RangeError; + var fill$1 = uncurryThis$E(arrayFill); + var reverse = uncurryThis$E([].reverse); + + var packIEEE754 = IEEE754.pack; + var unpackIEEE754 = IEEE754.unpack; var packInt8 = function (number) { return [number & 0xFF]; @@ -1981,69 +2729,73 @@ return packIEEE754(number, 52, 8); }; - var addGetter = function (Constructor, key) { - defineProperty$6(Constructor[PROTOTYPE], key, { get: function () { return getInternalState$2(this)[key]; } }); + var addGetter$1 = function (Constructor, key) { + defineProperty$8(Constructor[PROTOTYPE], key, { get: function () { return getInternalState$3(this)[key]; } }); }; var get$4 = function (view, count, index, isLittleEndian) { - var intIndex = toIndex(index); - var store = getInternalState$2(view); - if (intIndex + count > store.byteLength) throw RangeError$1(WRONG_INDEX); - var bytes = getInternalState$2(store.buffer).bytes; + var intIndex = toIndex$1(index); + var store = getInternalState$3(view); + if (intIndex + count > store.byteLength) throw RangeError$a(WRONG_INDEX); + var bytes = getInternalState$3(store.buffer).bytes; var start = intIndex + store.byteOffset; - var pack = bytes.slice(start, start + count); - return isLittleEndian ? pack : pack.reverse(); + var pack = arraySlice$9(bytes, start, start + count); + return isLittleEndian ? pack : reverse(pack); }; var set$3 = function (view, count, index, conversion, value, isLittleEndian) { - var intIndex = toIndex(index); - var store = getInternalState$2(view); - if (intIndex + count > store.byteLength) throw RangeError$1(WRONG_INDEX); - var bytes = getInternalState$2(store.buffer).bytes; + var intIndex = toIndex$1(index); + var store = getInternalState$3(view); + if (intIndex + count > store.byteLength) throw RangeError$a(WRONG_INDEX); + var bytes = getInternalState$3(store.buffer).bytes; var start = intIndex + store.byteOffset; var pack = conversion(+value); for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1]; }; - if (!arrayBufferNative) { + if (!NATIVE_ARRAY_BUFFER$2) { $ArrayBuffer = function ArrayBuffer(length) { - anInstance(this, $ArrayBuffer, ARRAY_BUFFER$1); - var byteLength = toIndex(length); - setInternalState$4(this, { - bytes: arrayFill.call(new Array(byteLength), 0), + anInstance$6(this, ArrayBufferPrototype$1); + var byteLength = toIndex$1(length); + setInternalState$5(this, { + bytes: fill$1(Array$4(byteLength), 0), byteLength: byteLength }); - if (!descriptors) this.byteLength = byteLength; + if (!DESCRIPTORS$f) this.byteLength = byteLength; }; + ArrayBufferPrototype$1 = $ArrayBuffer[PROTOTYPE]; + $DataView = function DataView(buffer, byteOffset, byteLength) { - anInstance(this, $DataView, DATA_VIEW); - anInstance(buffer, $ArrayBuffer, DATA_VIEW); - var bufferLength = getInternalState$2(buffer).byteLength; - var offset = toInteger(byteOffset); - if (offset < 0 || offset > bufferLength) throw RangeError$1('Wrong offset'); - byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength); - if (offset + byteLength > bufferLength) throw RangeError$1(WRONG_LENGTH); - setInternalState$4(this, { + anInstance$6(this, DataViewPrototype$1); + anInstance$6(buffer, ArrayBufferPrototype$1); + var bufferLength = getInternalState$3(buffer).byteLength; + var offset = toIntegerOrInfinity$6(byteOffset); + if (offset < 0 || offset > bufferLength) throw RangeError$a('Wrong offset'); + byteLength = byteLength === undefined ? bufferLength - offset : toLength$9(byteLength); + if (offset + byteLength > bufferLength) throw RangeError$a(WRONG_LENGTH$1); + setInternalState$5(this, { buffer: buffer, byteLength: byteLength, byteOffset: offset }); - if (!descriptors) { + if (!DESCRIPTORS$f) { this.buffer = buffer; this.byteLength = byteLength; this.byteOffset = offset; } }; - if (descriptors) { - addGetter($ArrayBuffer, 'byteLength'); - addGetter($DataView, 'buffer'); - addGetter($DataView, 'byteLength'); - addGetter($DataView, 'byteOffset'); + DataViewPrototype$1 = $DataView[PROTOTYPE]; + + if (DESCRIPTORS$f) { + addGetter$1($ArrayBuffer, 'byteLength'); + addGetter$1($DataView, 'buffer'); + addGetter$1($DataView, 'byteLength'); + addGetter$1($DataView, 'byteOffset'); } - redefineAll($DataView[PROTOTYPE], { + redefineAll$3(DataViewPrototype$1, { getInt8: function getInt8(byteOffset) { return get$4(this, 1, byteOffset)[0] << 24 >> 24; }, @@ -2096,124 +2848,174 @@ } }); } else { + var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME$2 && NativeArrayBuffer$1.name !== ARRAY_BUFFER$1; /* eslint-disable no-new -- required for testing */ - if (!fails(function () { + if (!fails$J(function () { NativeArrayBuffer$1(1); - }) || !fails(function () { + }) || !fails$J(function () { new NativeArrayBuffer$1(-1); - }) || fails(function () { + }) || fails$J(function () { new NativeArrayBuffer$1(); new NativeArrayBuffer$1(1.5); new NativeArrayBuffer$1(NaN); - return NativeArrayBuffer$1.name != ARRAY_BUFFER$1; + return INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME; })) { /* eslint-enable no-new -- required for testing */ $ArrayBuffer = function ArrayBuffer(length) { - anInstance(this, $ArrayBuffer); - return new NativeArrayBuffer$1(toIndex(length)); + anInstance$6(this, ArrayBufferPrototype$1); + return new NativeArrayBuffer$1(toIndex$1(length)); }; - var ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE] = NativeArrayBuffer$1[PROTOTYPE]; - for (var keys$2 = getOwnPropertyNames$3(NativeArrayBuffer$1), j$2 = 0, key$1; keys$2.length > j$2;) { + + $ArrayBuffer[PROTOTYPE] = ArrayBufferPrototype$1; + + for (var keys$2 = getOwnPropertyNames$4(NativeArrayBuffer$1), j$2 = 0, key$1; keys$2.length > j$2;) { if (!((key$1 = keys$2[j$2++]) in $ArrayBuffer)) { - createNonEnumerableProperty($ArrayBuffer, key$1, NativeArrayBuffer$1[key$1]); + createNonEnumerableProperty$5($ArrayBuffer, key$1, NativeArrayBuffer$1[key$1]); } } - ArrayBufferPrototype.constructor = $ArrayBuffer; + + ArrayBufferPrototype$1.constructor = $ArrayBuffer; + } else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$5(NativeArrayBuffer$1, 'name', ARRAY_BUFFER$1); } // WebKit bug - the same parent prototype for typed arrays and data view - if (objectSetPrototypeOf && objectGetPrototypeOf($DataViewPrototype) !== ObjectPrototype$1) { - objectSetPrototypeOf($DataViewPrototype, ObjectPrototype$1); + if (setPrototypeOf$5 && getPrototypeOf$2(DataViewPrototype$1) !== ObjectPrototype$2) { + setPrototypeOf$5(DataViewPrototype$1, ObjectPrototype$2); } // iOS Safari 7.x bug var testView = new $DataView(new $ArrayBuffer(2)); - var $setInt8 = $DataViewPrototype.setInt8; + var $setInt8 = uncurryThis$E(DataViewPrototype$1.setInt8); testView.setInt8(0, 2147483648); testView.setInt8(1, 2147483649); - if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll($DataViewPrototype, { + if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll$3(DataViewPrototype$1, { setInt8: function setInt8(byteOffset, value) { - $setInt8.call(this, byteOffset, value << 24 >> 24); + $setInt8(this, byteOffset, value << 24 >> 24); }, setUint8: function setUint8(byteOffset, value) { - $setInt8.call(this, byteOffset, value << 24 >> 24); + $setInt8(this, byteOffset, value << 24 >> 24); } }, { unsafe: true }); } - setToStringTag($ArrayBuffer, ARRAY_BUFFER$1); - setToStringTag($DataView, DATA_VIEW); + setToStringTag$6($ArrayBuffer, ARRAY_BUFFER$1); + setToStringTag$6($DataView, DATA_VIEW); var arrayBuffer = { ArrayBuffer: $ArrayBuffer, DataView: $DataView }; - var SPECIES$5 = wellKnownSymbol('species'); + var global$P = global$1o; + var isConstructor$2 = isConstructor$4; + var tryToString$3 = tryToString$5; + + var TypeError$f = global$P.TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$3 = function (argument) { + if (isConstructor$2(argument)) return argument; + throw TypeError$f(tryToString$3(argument) + ' is not a constructor'); + }; + + var anObject$g = anObject$n; + var aConstructor$2 = aConstructor$3; + var wellKnownSymbol$h = wellKnownSymbol$t; + + var SPECIES$5 = wellKnownSymbol$h('species'); // `SpeciesConstructor` abstract operation // https://tc39.es/ecma262/#sec-speciesconstructor - var speciesConstructor = function (O, defaultConstructor) { - var C = anObject(O).constructor; + var speciesConstructor$5 = function (O, defaultConstructor) { + var C = anObject$g(O).constructor; var S; - return C === undefined || (S = anObject(C)[SPECIES$5]) == undefined ? defaultConstructor : aFunction(S); + return C === undefined || (S = anObject$g(C)[SPECIES$5]) == undefined ? defaultConstructor : aConstructor$2(S); }; - var ArrayBuffer$3 = arrayBuffer.ArrayBuffer; - var DataView$1 = arrayBuffer.DataView; - var nativeArrayBufferSlice = ArrayBuffer$3.prototype.slice; - - var INCORRECT_SLICE = fails(function () { - return !new ArrayBuffer$3(2).slice(1, undefined).byteLength; + var $$19 = _export; + var uncurryThis$D = functionUncurryThis; + var fails$I = fails$V; + var ArrayBufferModule$2 = arrayBuffer; + var anObject$f = anObject$n; + var toAbsoluteIndex$5 = toAbsoluteIndex$9; + var toLength$8 = toLength$c; + var speciesConstructor$4 = speciesConstructor$5; + + var ArrayBuffer$4 = ArrayBufferModule$2.ArrayBuffer; + var DataView$2 = ArrayBufferModule$2.DataView; + var DataViewPrototype = DataView$2.prototype; + var un$ArrayBufferSlice = uncurryThis$D(ArrayBuffer$4.prototype.slice); + var getUint8 = uncurryThis$D(DataViewPrototype.getUint8); + var setUint8 = uncurryThis$D(DataViewPrototype.setUint8); + + var INCORRECT_SLICE = fails$I(function () { + return !new ArrayBuffer$4(2).slice(1, undefined).byteLength; }); // `ArrayBuffer.prototype.slice` method // https://tc39.es/ecma262/#sec-arraybuffer.prototype.slice - _export({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { + $$19({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { slice: function slice(start, end) { - if (nativeArrayBufferSlice !== undefined && end === undefined) { - return nativeArrayBufferSlice.call(anObject(this), start); // FF fix - } - var length = anObject(this).byteLength; - var first = toAbsoluteIndex(start, length); - var fin = toAbsoluteIndex(end === undefined ? length : end, length); - var result = new (speciesConstructor(this, ArrayBuffer$3))(toLength(fin - first)); - var viewSource = new DataView$1(this); - var viewTarget = new DataView$1(result); + if (un$ArrayBufferSlice && end === undefined) { + return un$ArrayBufferSlice(anObject$f(this), start); // FF fix + } + var length = anObject$f(this).byteLength; + var first = toAbsoluteIndex$5(start, length); + var fin = toAbsoluteIndex$5(end === undefined ? length : end, length); + var result = new (speciesConstructor$4(this, ArrayBuffer$4))(toLength$8(fin - first)); + var viewSource = new DataView$2(this); + var viewTarget = new DataView$2(result); var index = 0; while (first < fin) { - viewTarget.setUint8(index++, viewSource.getUint8(first++)); + setUint8(viewTarget, index++, getUint8(viewSource, first++)); } return result; } }); + var $$18 = _export; + var ArrayBufferModule$1 = arrayBuffer; + var NATIVE_ARRAY_BUFFER$1 = arrayBufferNative; + // `DataView` constructor // https://tc39.es/ecma262/#sec-dataview-constructor - _export({ global: true, forced: !arrayBufferNative }, { - DataView: arrayBuffer.DataView + $$18({ global: true, forced: !NATIVE_ARRAY_BUFFER$1 }, { + DataView: ArrayBufferModule$1.DataView }); - var defineProperty$5 = objectDefineProperty.f; - - - - - - var Int8Array$3 = global$2.Int8Array; - var Int8ArrayPrototype = Int8Array$3 && Int8Array$3.prototype; - var Uint8ClampedArray = global$2.Uint8ClampedArray; - var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; - var TypedArray = Int8Array$3 && objectGetPrototypeOf(Int8Array$3); - var TypedArrayPrototype = Int8ArrayPrototype && objectGetPrototypeOf(Int8ArrayPrototype); - var ObjectPrototype = Object.prototype; - var isPrototypeOf = ObjectPrototype.isPrototypeOf; + var NATIVE_ARRAY_BUFFER = arrayBufferNative; + var DESCRIPTORS$e = descriptors; + var global$O = global$1o; + var isCallable$9 = isCallable$r; + var isObject$k = isObject$s; + var hasOwn$9 = hasOwnProperty_1; + var classof$7 = classof$d; + var tryToString$2 = tryToString$5; + var createNonEnumerableProperty$4 = createNonEnumerableProperty$b; + var redefine$9 = redefine$h.exports; + var defineProperty$7 = objectDefineProperty.f; + var isPrototypeOf$5 = objectIsPrototypeOf; + var getPrototypeOf$1 = objectGetPrototypeOf; + var setPrototypeOf$4 = objectSetPrototypeOf; + var wellKnownSymbol$g = wellKnownSymbol$t; + var uid$1 = uid$5; + + var Int8Array$4 = global$O.Int8Array; + var Int8ArrayPrototype$1 = Int8Array$4 && Int8Array$4.prototype; + var Uint8ClampedArray$1 = global$O.Uint8ClampedArray; + var Uint8ClampedArrayPrototype = Uint8ClampedArray$1 && Uint8ClampedArray$1.prototype; + var TypedArray$1 = Int8Array$4 && getPrototypeOf$1(Int8Array$4); + var TypedArrayPrototype$2 = Int8ArrayPrototype$1 && getPrototypeOf$1(Int8ArrayPrototype$1); + var ObjectPrototype$1 = Object.prototype; + var TypeError$e = global$O.TypeError; - var TO_STRING_TAG = wellKnownSymbol('toStringTag'); - var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); + var TO_STRING_TAG = wellKnownSymbol$g('toStringTag'); + var TYPED_ARRAY_TAG$1 = uid$1('TYPED_ARRAY_TAG'); + var TYPED_ARRAY_CONSTRUCTOR$2 = uid$1('TYPED_ARRAY_CONSTRUCTOR'); // Fixing native typed arrays in Opera Presto crashes the browser, see #595 - var NATIVE_ARRAY_BUFFER_VIEWS$2 = arrayBufferNative && !!objectSetPrototypeOf && classof(global$2.opera) !== 'Opera'; - var TYPED_ARRAY_TAG_REQIRED = false; - var NAME$1; + var NATIVE_ARRAY_BUFFER_VIEWS$3 = NATIVE_ARRAY_BUFFER && !!setPrototypeOf$4 && classof$7(global$O.opera) !== 'Opera'; + var TYPED_ARRAY_TAG_REQUIRED = false; + var NAME$1, Constructor, Prototype; var TypedArrayConstructorsList = { Int8Array: 1, @@ -2233,140 +3035,157 @@ }; var isView = function isView(it) { - if (!isObject$4(it)) return false; - var klass = classof(it); + if (!isObject$k(it)) return false; + var klass = classof$7(it); return klass === 'DataView' - || has$1(TypedArrayConstructorsList, klass) - || has$1(BigIntArrayConstructorsList, klass); + || hasOwn$9(TypedArrayConstructorsList, klass) + || hasOwn$9(BigIntArrayConstructorsList, klass); }; - var isTypedArray = function (it) { - if (!isObject$4(it)) return false; - var klass = classof(it); - return has$1(TypedArrayConstructorsList, klass) - || has$1(BigIntArrayConstructorsList, klass); + var isTypedArray$1 = function (it) { + if (!isObject$k(it)) return false; + var klass = classof$7(it); + return hasOwn$9(TypedArrayConstructorsList, klass) + || hasOwn$9(BigIntArrayConstructorsList, klass); }; var aTypedArray$m = function (it) { - if (isTypedArray(it)) return it; - throw TypeError('Target is not a typed array'); + if (isTypedArray$1(it)) return it; + throw TypeError$e('Target is not a typed array'); }; - var aTypedArrayConstructor$4 = function (C) { - if (objectSetPrototypeOf) { - if (isPrototypeOf.call(TypedArray, C)) return C; - } else for (var ARRAY in TypedArrayConstructorsList) if (has$1(TypedArrayConstructorsList, NAME$1)) { - var TypedArrayConstructor = global$2[ARRAY]; - if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) { - return C; - } - } throw TypeError('Target is not a typed array constructor'); + var aTypedArrayConstructor$3 = function (C) { + if (isCallable$9(C) && (!setPrototypeOf$4 || isPrototypeOf$5(TypedArray$1, C))) return C; + throw TypeError$e(tryToString$2(C) + ' is not a typed array constructor'); }; - var exportTypedArrayMethod$n = function (KEY, property, forced) { - if (!descriptors) return; + var exportTypedArrayMethod$n = function (KEY, property, forced, options) { + if (!DESCRIPTORS$e) return; if (forced) for (var ARRAY in TypedArrayConstructorsList) { - var TypedArrayConstructor = global$2[ARRAY]; - if (TypedArrayConstructor && has$1(TypedArrayConstructor.prototype, KEY)) try { + var TypedArrayConstructor = global$O[ARRAY]; + if (TypedArrayConstructor && hasOwn$9(TypedArrayConstructor.prototype, KEY)) try { delete TypedArrayConstructor.prototype[KEY]; - } catch (error) { /* empty */ } + } catch (error) { + // old WebKit bug - some methods are non-configurable + try { + TypedArrayConstructor.prototype[KEY] = property; + } catch (error2) { /* empty */ } + } } - if (!TypedArrayPrototype[KEY] || forced) { - redefine(TypedArrayPrototype, KEY, forced ? property - : NATIVE_ARRAY_BUFFER_VIEWS$2 && Int8ArrayPrototype[KEY] || property); + if (!TypedArrayPrototype$2[KEY] || forced) { + redefine$9(TypedArrayPrototype$2, KEY, forced ? property + : NATIVE_ARRAY_BUFFER_VIEWS$3 && Int8ArrayPrototype$1[KEY] || property, options); } }; var exportTypedArrayStaticMethod$1 = function (KEY, property, forced) { var ARRAY, TypedArrayConstructor; - if (!descriptors) return; - if (objectSetPrototypeOf) { + if (!DESCRIPTORS$e) return; + if (setPrototypeOf$4) { if (forced) for (ARRAY in TypedArrayConstructorsList) { - TypedArrayConstructor = global$2[ARRAY]; - if (TypedArrayConstructor && has$1(TypedArrayConstructor, KEY)) try { + TypedArrayConstructor = global$O[ARRAY]; + if (TypedArrayConstructor && hasOwn$9(TypedArrayConstructor, KEY)) try { delete TypedArrayConstructor[KEY]; } catch (error) { /* empty */ } } - if (!TypedArray[KEY] || forced) { + if (!TypedArray$1[KEY] || forced) { // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable try { - return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS$2 && TypedArray[KEY] || property); + return redefine$9(TypedArray$1, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS$3 && TypedArray$1[KEY] || property); } catch (error) { /* empty */ } } else return; } for (ARRAY in TypedArrayConstructorsList) { - TypedArrayConstructor = global$2[ARRAY]; + TypedArrayConstructor = global$O[ARRAY]; if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { - redefine(TypedArrayConstructor, KEY, property); + redefine$9(TypedArrayConstructor, KEY, property); } } }; for (NAME$1 in TypedArrayConstructorsList) { - if (!global$2[NAME$1]) NATIVE_ARRAY_BUFFER_VIEWS$2 = false; + Constructor = global$O[NAME$1]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) createNonEnumerableProperty$4(Prototype, TYPED_ARRAY_CONSTRUCTOR$2, Constructor); + else NATIVE_ARRAY_BUFFER_VIEWS$3 = false; + } + + for (NAME$1 in BigIntArrayConstructorsList) { + Constructor = global$O[NAME$1]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) createNonEnumerableProperty$4(Prototype, TYPED_ARRAY_CONSTRUCTOR$2, Constructor); } // WebKit bug - typed arrays constructors prototype is Object.prototype - if (!NATIVE_ARRAY_BUFFER_VIEWS$2 || typeof TypedArray != 'function' || TypedArray === Function.prototype) { + if (!NATIVE_ARRAY_BUFFER_VIEWS$3 || !isCallable$9(TypedArray$1) || TypedArray$1 === Function.prototype) { // eslint-disable-next-line no-shadow -- safe - TypedArray = function TypedArray() { - throw TypeError('Incorrect invocation'); + TypedArray$1 = function TypedArray() { + throw TypeError$e('Incorrect invocation'); }; - if (NATIVE_ARRAY_BUFFER_VIEWS$2) for (NAME$1 in TypedArrayConstructorsList) { - if (global$2[NAME$1]) objectSetPrototypeOf(global$2[NAME$1], TypedArray); + if (NATIVE_ARRAY_BUFFER_VIEWS$3) for (NAME$1 in TypedArrayConstructorsList) { + if (global$O[NAME$1]) setPrototypeOf$4(global$O[NAME$1], TypedArray$1); } } - if (!NATIVE_ARRAY_BUFFER_VIEWS$2 || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { - TypedArrayPrototype = TypedArray.prototype; - if (NATIVE_ARRAY_BUFFER_VIEWS$2) for (NAME$1 in TypedArrayConstructorsList) { - if (global$2[NAME$1]) objectSetPrototypeOf(global$2[NAME$1].prototype, TypedArrayPrototype); + if (!NATIVE_ARRAY_BUFFER_VIEWS$3 || !TypedArrayPrototype$2 || TypedArrayPrototype$2 === ObjectPrototype$1) { + TypedArrayPrototype$2 = TypedArray$1.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS$3) for (NAME$1 in TypedArrayConstructorsList) { + if (global$O[NAME$1]) setPrototypeOf$4(global$O[NAME$1].prototype, TypedArrayPrototype$2); } } // WebKit bug - one more object in Uint8ClampedArray prototype chain - if (NATIVE_ARRAY_BUFFER_VIEWS$2 && objectGetPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { - objectSetPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); + if (NATIVE_ARRAY_BUFFER_VIEWS$3 && getPrototypeOf$1(Uint8ClampedArrayPrototype) !== TypedArrayPrototype$2) { + setPrototypeOf$4(Uint8ClampedArrayPrototype, TypedArrayPrototype$2); } - if (descriptors && !has$1(TypedArrayPrototype, TO_STRING_TAG)) { - TYPED_ARRAY_TAG_REQIRED = true; - defineProperty$5(TypedArrayPrototype, TO_STRING_TAG, { get: function () { - return isObject$4(this) ? this[TYPED_ARRAY_TAG] : undefined; + if (DESCRIPTORS$e && !hasOwn$9(TypedArrayPrototype$2, TO_STRING_TAG)) { + TYPED_ARRAY_TAG_REQUIRED = true; + defineProperty$7(TypedArrayPrototype$2, TO_STRING_TAG, { get: function () { + return isObject$k(this) ? this[TYPED_ARRAY_TAG$1] : undefined; } }); - for (NAME$1 in TypedArrayConstructorsList) if (global$2[NAME$1]) { - createNonEnumerableProperty(global$2[NAME$1], TYPED_ARRAY_TAG, NAME$1); + for (NAME$1 in TypedArrayConstructorsList) if (global$O[NAME$1]) { + createNonEnumerableProperty$4(global$O[NAME$1], TYPED_ARRAY_TAG$1, NAME$1); } } var arrayBufferViewCore = { - NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS$2, - TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG, + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS$3, + TYPED_ARRAY_CONSTRUCTOR: TYPED_ARRAY_CONSTRUCTOR$2, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG$1, aTypedArray: aTypedArray$m, - aTypedArrayConstructor: aTypedArrayConstructor$4, + aTypedArrayConstructor: aTypedArrayConstructor$3, exportTypedArrayMethod: exportTypedArrayMethod$n, exportTypedArrayStaticMethod: exportTypedArrayStaticMethod$1, isView: isView, - isTypedArray: isTypedArray, - TypedArray: TypedArray, - TypedArrayPrototype: TypedArrayPrototype + isTypedArray: isTypedArray$1, + TypedArray: TypedArray$1, + TypedArrayPrototype: TypedArrayPrototype$2 }; - var NATIVE_ARRAY_BUFFER_VIEWS$1 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; + var $$17 = _export; + var ArrayBufferViewCore$o = arrayBufferViewCore; + + var NATIVE_ARRAY_BUFFER_VIEWS$2 = ArrayBufferViewCore$o.NATIVE_ARRAY_BUFFER_VIEWS; // `ArrayBuffer.isView` method // https://tc39.es/ecma262/#sec-arraybuffer.isview - _export({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS$1 }, { - isView: arrayBufferViewCore.isView + $$17({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS$2 }, { + isView: ArrayBufferViewCore$o.isView }); - var SPECIES$4 = wellKnownSymbol('species'); + var getBuiltIn$4 = getBuiltIn$b; + var definePropertyModule$1 = objectDefineProperty; + var wellKnownSymbol$f = wellKnownSymbol$t; + var DESCRIPTORS$d = descriptors; + + var SPECIES$4 = wellKnownSymbol$f('species'); - var setSpecies = function (CONSTRUCTOR_NAME) { - var Constructor = getBuiltIn(CONSTRUCTOR_NAME); - var defineProperty = objectDefineProperty.f; + var setSpecies$5 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + var defineProperty = definePropertyModule$1.f; - if (descriptors && Constructor && !Constructor[SPECIES$4]) { + if (DESCRIPTORS$d && Constructor && !Constructor[SPECIES$4]) { defineProperty(Constructor, SPECIES$4, { configurable: true, get: function () { return this; } @@ -2374,54 +3193,263 @@ } }; + var $$16 = _export; + var global$N = global$1o; + var arrayBufferModule = arrayBuffer; + var setSpecies$4 = setSpecies$5; + var ARRAY_BUFFER = 'ArrayBuffer'; - var ArrayBuffer$2 = arrayBuffer[ARRAY_BUFFER]; - var NativeArrayBuffer = global$2[ARRAY_BUFFER]; + var ArrayBuffer$3 = arrayBufferModule[ARRAY_BUFFER]; + var NativeArrayBuffer = global$N[ARRAY_BUFFER]; // `ArrayBuffer` constructor // https://tc39.es/ecma262/#sec-arraybuffer-constructor - _export({ global: true, forced: NativeArrayBuffer !== ArrayBuffer$2 }, { - ArrayBuffer: ArrayBuffer$2 + $$16({ global: true, forced: NativeArrayBuffer !== ArrayBuffer$3 }, { + ArrayBuffer: ArrayBuffer$3 }); - setSpecies(ARRAY_BUFFER); + setSpecies$4(ARRAY_BUFFER); + + var fails$H = fails$V; - var arrayMethodIsStrict = function (METHOD_NAME, argument) { + var arrayMethodIsStrict$9 = function (METHOD_NAME, argument) { var method = [][METHOD_NAME]; - return !!method && fails(function () { + return !!method && fails$H(function () { // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing method.call(null, argument || function () { throw 1; }, 1); }); }; /* eslint-disable es/no-array-prototype-indexof -- required for testing */ + var $$15 = _export; + var uncurryThis$C = functionUncurryThis; + var $IndexOf = arrayIncludes.indexOf; + var arrayMethodIsStrict$8 = arrayMethodIsStrict$9; - var $indexOf$1 = arrayIncludes.indexOf; + var un$IndexOf = uncurryThis$C([].indexOf); - - var nativeIndexOf = [].indexOf; - - var NEGATIVE_ZERO$1 = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0; - var STRICT_METHOD$7 = arrayMethodIsStrict('indexOf'); + var NEGATIVE_ZERO$1 = !!un$IndexOf && 1 / un$IndexOf([1], 1, -0) < 0; + var STRICT_METHOD$8 = arrayMethodIsStrict$8('indexOf'); // `Array.prototype.indexOf` method // https://tc39.es/ecma262/#sec-array.prototype.indexof - _export({ target: 'Array', proto: true, forced: NEGATIVE_ZERO$1 || !STRICT_METHOD$7 }, { + $$15({ target: 'Array', proto: true, forced: NEGATIVE_ZERO$1 || !STRICT_METHOD$8 }, { indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { + var fromIndex = arguments.length > 1 ? arguments[1] : undefined; return NEGATIVE_ZERO$1 // convert -0 to +0 - ? nativeIndexOf.apply(this, arguments) || 0 - : $indexOf$1(this, searchElement, arguments.length > 1 ? arguments[1] : undefined); + ? un$IndexOf(this, searchElement, fromIndex) || 0 + : $IndexOf(this, searchElement, fromIndex); } }); - var SPECIES$3 = wellKnownSymbol('species'); + var anObject$e = anObject$n; + + // `RegExp.prototype.flags` getter implementation + // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags + var regexpFlags$1 = function () { + var that = anObject$e(this); + var result = ''; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.dotAll) result += 's'; + if (that.unicode) result += 'u'; + if (that.sticky) result += 'y'; + return result; + }; + + var fails$G = fails$V; + var global$M = global$1o; + + // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError + var $RegExp$2 = global$M.RegExp; + + var UNSUPPORTED_Y$3 = fails$G(function () { + var re = $RegExp$2('a', 'y'); + re.lastIndex = 2; + return re.exec('abcd') != null; + }); + + // UC Browser bug + // https://github.com/zloirock/core-js/issues/1008 + var MISSED_STICKY$1 = UNSUPPORTED_Y$3 || fails$G(function () { + return !$RegExp$2('a', 'y').sticky; + }); + + var BROKEN_CARET = UNSUPPORTED_Y$3 || fails$G(function () { + // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 + var re = $RegExp$2('^r', 'gy'); + re.lastIndex = 2; + return re.exec('str') != null; + }); + + var regexpStickyHelpers = { + BROKEN_CARET: BROKEN_CARET, + MISSED_STICKY: MISSED_STICKY$1, + UNSUPPORTED_Y: UNSUPPORTED_Y$3 + }; + + var fails$F = fails$V; + var global$L = global$1o; + + // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError + var $RegExp$1 = global$L.RegExp; + + var regexpUnsupportedDotAll = fails$F(function () { + var re = $RegExp$1('.', 's'); + return !(re.dotAll && re.exec('\n') && re.flags === 's'); + }); + + var fails$E = fails$V; + var global$K = global$1o; + + // babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError + var $RegExp = global$K.RegExp; - var arrayMethodHasSpeciesSupport = function (METHOD_NAME) { + var regexpUnsupportedNcg = fails$E(function () { + var re = $RegExp('(?b)', 'g'); + return re.exec('b').groups.a !== 'b' || + 'b'.replace(re, '$c') !== 'bc'; + }); + + /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ + /* eslint-disable regexp/no-useless-quantifier -- testing */ + var call$i = functionCall; + var uncurryThis$B = functionUncurryThis; + var toString$g = toString$k; + var regexpFlags = regexpFlags$1; + var stickyHelpers$2 = regexpStickyHelpers; + var shared = shared$5.exports; + var create$8 = objectCreate; + var getInternalState$2 = internalState.get; + var UNSUPPORTED_DOT_ALL$1 = regexpUnsupportedDotAll; + var UNSUPPORTED_NCG$1 = regexpUnsupportedNcg; + + var nativeReplace = shared('native-string-replace', String.prototype.replace); + var nativeExec = RegExp.prototype.exec; + var patchedExec = nativeExec; + var charAt$6 = uncurryThis$B(''.charAt); + var indexOf = uncurryThis$B(''.indexOf); + var replace$7 = uncurryThis$B(''.replace); + var stringSlice$9 = uncurryThis$B(''.slice); + + var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + call$i(nativeExec, re1, 'a'); + call$i(nativeExec, re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; + })(); + + var UNSUPPORTED_Y$2 = stickyHelpers$2.BROKEN_CARET; + + // nonparticipating capturing group, copied from es5-shim's String#split patch. + var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + + var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$2 || UNSUPPORTED_DOT_ALL$1 || UNSUPPORTED_NCG$1; + + if (PATCH) { + patchedExec = function exec(string) { + var re = this; + var state = getInternalState$2(re); + var str = toString$g(string); + var raw = state.raw; + var result, reCopy, lastIndex, match, i, object, group; + + if (raw) { + raw.lastIndex = re.lastIndex; + result = call$i(patchedExec, raw, str); + re.lastIndex = raw.lastIndex; + return result; + } + + var groups = state.groups; + var sticky = UNSUPPORTED_Y$2 && re.sticky; + var flags = call$i(regexpFlags, re); + var source = re.source; + var charsAdded = 0; + var strCopy = str; + + if (sticky) { + flags = replace$7(flags, 'y', ''); + if (indexOf(flags, 'g') === -1) { + flags += 'g'; + } + + strCopy = stringSlice$9(str, re.lastIndex); + // Support anchored sticky behavior. + if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$6(str, re.lastIndex - 1) !== '\n')) { + source = '(?: ' + source + ')'; + strCopy = ' ' + strCopy; + charsAdded++; + } + // ^(? + rx + ) is needed, in combination with some str slicing, to + // simulate the 'y' flag. + reCopy = new RegExp('^(?:' + source + ')', flags); + } + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + source + '$(?!\\s)', flags); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + match = call$i(nativeExec, sticky ? reCopy : re, strCopy); + + if (sticky) { + if (match) { + match.input = stringSlice$9(match.input, charsAdded); + match[0] = stringSlice$9(match[0], charsAdded); + match.index = re.lastIndex; + re.lastIndex += match[0].length; + } else re.lastIndex = 0; + } else if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ + call$i(nativeReplace, match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + if (match && groups) { + match.groups = object = create$8(null); + for (i = 0; i < groups.length; i++) { + group = groups[i]; + object[group[0]] = match[group[1]]; + } + } + + return match; + }; + } + + var regexpExec$3 = patchedExec; + + var $$14 = _export; + var exec$5 = regexpExec$3; + + // `RegExp.prototype.exec` method + // https://tc39.es/ecma262/#sec-regexp.prototype.exec + $$14({ target: 'RegExp', proto: true, forced: /./.exec !== exec$5 }, { + exec: exec$5 + }); + + var fails$D = fails$V; + var wellKnownSymbol$e = wellKnownSymbol$t; + var V8_VERSION$2 = engineV8Version; + + var SPECIES$3 = wellKnownSymbol$e('species'); + + var arrayMethodHasSpeciesSupport$5 = function (METHOD_NAME) { // We can't use this feature detection in V8 since it causes // deoptimization and serious performance degradation // https://github.com/zloirock/core-js/issues/677 - return engineV8Version >= 51 || !fails(function () { + return V8_VERSION$2 >= 51 || !fails$D(function () { var array = []; var constructor = array.constructor = {}; constructor[SPECIES$3] = function () { @@ -2431,113 +3459,192 @@ }); }; + var $$13 = _export; var $map$1 = arrayIteration.map; + var arrayMethodHasSpeciesSupport$4 = arrayMethodHasSpeciesSupport$5; - - var HAS_SPECIES_SUPPORT$3 = arrayMethodHasSpeciesSupport('map'); + var HAS_SPECIES_SUPPORT$3 = arrayMethodHasSpeciesSupport$4('map'); // `Array.prototype.map` method // https://tc39.es/ecma262/#sec-array.prototype.map // with adding support of @@species - _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$3 }, { + $$13({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$3 }, { map: function map(callbackfn /* , thisArg */) { return $map$1(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); var $forEach$1 = arrayIteration.forEach; + var arrayMethodIsStrict$7 = arrayMethodIsStrict$9; - - var STRICT_METHOD$6 = arrayMethodIsStrict('forEach'); + var STRICT_METHOD$7 = arrayMethodIsStrict$7('forEach'); // `Array.prototype.forEach` method implementation // https://tc39.es/ecma262/#sec-array.prototype.foreach - var arrayForEach = !STRICT_METHOD$6 ? function forEach(callbackfn /* , thisArg */) { + var arrayForEach = !STRICT_METHOD$7 ? function forEach(callbackfn /* , thisArg */) { return $forEach$1(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); // eslint-disable-next-line es/no-array-prototype-foreach -- safe } : [].forEach; + var $$12 = _export; + var forEach$3 = arrayForEach; + // `Array.prototype.forEach` method // https://tc39.es/ecma262/#sec-array.prototype.foreach // eslint-disable-next-line es/no-array-prototype-foreach -- safe - _export({ target: 'Array', proto: true, forced: [].forEach != arrayForEach }, { - forEach: arrayForEach + $$12({ target: 'Array', proto: true, forced: [].forEach != forEach$3 }, { + forEach: forEach$3 }); - for (var COLLECTION_NAME in domIterables) { - var Collection = global$2[COLLECTION_NAME]; - var CollectionPrototype = Collection && Collection.prototype; + var global$J = global$1o; + var DOMIterables = domIterables; + var DOMTokenListPrototype = domTokenListPrototype; + var forEach$2 = arrayForEach; + var createNonEnumerableProperty$3 = createNonEnumerableProperty$b; + + var handlePrototype = function (CollectionPrototype) { // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try { - createNonEnumerableProperty(CollectionPrototype, 'forEach', arrayForEach); + if (CollectionPrototype && CollectionPrototype.forEach !== forEach$2) try { + createNonEnumerableProperty$3(CollectionPrototype, 'forEach', forEach$2); } catch (error) { - CollectionPrototype.forEach = arrayForEach; + CollectionPrototype.forEach = forEach$2; + } + }; + + for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$J[COLLECTION_NAME] && global$J[COLLECTION_NAME].prototype); } } + handlePrototype(DOMTokenListPrototype); + + var $$11 = _export; + var isArray$5 = isArray$8; + // `Array.isArray` method // https://tc39.es/ecma262/#sec-array.isarray - _export({ target: 'Array', stat: true }, { - isArray: isArray + $$11({ target: 'Array', stat: true }, { + isArray: isArray$5 }); - var getOwnPropertyNames$2 = objectGetOwnPropertyNamesExternal.f; + var $$10 = _export; + var fails$C = fails$V; + var getOwnPropertyNames$3 = objectGetOwnPropertyNamesExternal.f; // eslint-disable-next-line es/no-object-getownpropertynames -- required for testing - var FAILS_ON_PRIMITIVES$4 = fails(function () { return !Object.getOwnPropertyNames(1); }); + var FAILS_ON_PRIMITIVES$5 = fails$C(function () { return !Object.getOwnPropertyNames(1); }); // `Object.getOwnPropertyNames` method // https://tc39.es/ecma262/#sec-object.getownpropertynames - _export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$4 }, { - getOwnPropertyNames: getOwnPropertyNames$2 + $$10({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$5 }, { + getOwnPropertyNames: getOwnPropertyNames$3 }); - var nativePromiseConstructor = global$2.Promise; + var global$I = global$1o; + + var nativePromiseConstructor = global$I.Promise; + + var wellKnownSymbol$d = wellKnownSymbol$t; + var Iterators$1 = iterators; - var ITERATOR$5 = wellKnownSymbol('iterator'); + var ITERATOR$7 = wellKnownSymbol$d('iterator'); var ArrayPrototype = Array.prototype; // check on default Array iterator - var isArrayIteratorMethod = function (it) { - return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR$5] === it); + var isArrayIteratorMethod$3 = function (it) { + return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$7] === it); }; - var ITERATOR$4 = wellKnownSymbol('iterator'); + var classof$6 = classof$d; + var getMethod$5 = getMethod$7; + var Iterators = iterators; + var wellKnownSymbol$c = wellKnownSymbol$t; + + var ITERATOR$6 = wellKnownSymbol$c('iterator'); + + var getIteratorMethod$5 = function (it) { + if (it != undefined) return getMethod$5(it, ITERATOR$6) + || getMethod$5(it, '@@iterator') + || Iterators[classof$6(it)]; + }; + + var global$H = global$1o; + var call$h = functionCall; + var aCallable$7 = aCallable$a; + var anObject$d = anObject$n; + var tryToString$1 = tryToString$5; + var getIteratorMethod$4 = getIteratorMethod$5; + + var TypeError$d = global$H.TypeError; - var getIteratorMethod = function (it) { - if (it != undefined) return it[ITERATOR$4] - || it['@@iterator'] - || iterators[classof(it)]; + var getIterator$4 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$4(argument) : usingIterator; + if (aCallable$7(iteratorMethod)) return anObject$d(call$h(iteratorMethod, argument)); + throw TypeError$d(tryToString$1(argument) + ' is not iterable'); }; - var iteratorClose = function (iterator) { - var returnMethod = iterator['return']; - if (returnMethod !== undefined) { - return anObject(returnMethod.call(iterator)).value; + var call$g = functionCall; + var anObject$c = anObject$n; + var getMethod$4 = getMethod$7; + + var iteratorClose$2 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$c(iterator); + try { + innerResult = getMethod$4(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$g(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$c(innerResult); + return value; }; + var global$G = global$1o; + var bind$d = functionBindContext; + var call$f = functionCall; + var anObject$b = anObject$n; + var tryToString = tryToString$5; + var isArrayIteratorMethod$2 = isArrayIteratorMethod$3; + var lengthOfArrayLike$d = lengthOfArrayLike$i; + var isPrototypeOf$4 = objectIsPrototypeOf; + var getIterator$3 = getIterator$4; + var getIteratorMethod$3 = getIteratorMethod$5; + var iteratorClose$1 = iteratorClose$2; + + var TypeError$c = global$G.TypeError; + var Result = function (stopped, result) { this.stopped = stopped; this.result = result; }; - var iterate = function (iterable, unboundFunction, options) { + var ResultPrototype = Result.prototype; + + var iterate$3 = function (iterable, unboundFunction, options) { var that = options && options.that; var AS_ENTRIES = !!(options && options.AS_ENTRIES); var IS_ITERATOR = !!(options && options.IS_ITERATOR); var INTERRUPTED = !!(options && options.INTERRUPTED); - var fn = functionBindContext(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED); + var fn = bind$d(unboundFunction, that); var iterator, iterFn, index, length, result, next, step; var stop = function (condition) { - if (iterator) iteratorClose(iterator); + if (iterator) iteratorClose$1(iterator, 'normal', condition); return new Result(true, condition); }; var callFn = function (value) { if (AS_ENTRIES) { - anObject(value); + anObject$b(value); return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); } return INTERRUPTED ? fn(value, stop) : fn(value); }; @@ -2545,31 +3652,32 @@ if (IS_ITERATOR) { iterator = iterable; } else { - iterFn = getIteratorMethod(iterable); - if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); + iterFn = getIteratorMethod$3(iterable); + if (!iterFn) throw TypeError$c(tryToString(iterable) + ' is not iterable'); // optimisation for array iterators - if (isArrayIteratorMethod(iterFn)) { - for (index = 0, length = toLength(iterable.length); length > index; index++) { + if (isArrayIteratorMethod$2(iterFn)) { + for (index = 0, length = lengthOfArrayLike$d(iterable); length > index; index++) { result = callFn(iterable[index]); - if (result && result instanceof Result) return result; + if (result && isPrototypeOf$4(ResultPrototype, result)) return result; } return new Result(false); } - iterator = iterFn.call(iterable); + iterator = getIterator$3(iterable, iterFn); } next = iterator.next; - while (!(step = next.call(iterator)).done) { + while (!(step = call$f(next, iterator)).done) { try { result = callFn(step.value); } catch (error) { - iteratorClose(iterator); - throw error; + iteratorClose$1(iterator, 'throw', error); } - if (typeof result == 'object' && result && result instanceof Result) return result; + if (typeof result == 'object' && result && isPrototypeOf$4(ResultPrototype, result)) return result; } return new Result(false); }; - var ITERATOR$3 = wellKnownSymbol('iterator'); + var wellKnownSymbol$b = wellKnownSymbol$t; + + var ITERATOR$5 = wellKnownSymbol$b('iterator'); var SAFE_CLOSING = false; try { @@ -2582,19 +3690,19 @@ SAFE_CLOSING = true; } }; - iteratorWithReturn[ITERATOR$3] = function () { + iteratorWithReturn[ITERATOR$5] = function () { return this; }; // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing Array.from(iteratorWithReturn, function () { throw 2; }); } catch (error) { /* empty */ } - var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) { + var checkCorrectnessOfIteration$4 = function (exec, SKIP_CLOSING) { if (!SKIP_CLOSING && !SAFE_CLOSING) return false; var ITERATION_SUPPORT = false; try { var object = {}; - object[ITERATOR$3] = function () { + object[ITERATOR$5] = function () { return { next: function () { return { done: ITERATION_SUPPORT = true }; @@ -2606,26 +3714,58 @@ return ITERATION_SUPPORT; }; - var engineIsIos = /(?:iphone|ipod|ipad).*applewebkit/i.test(engineUserAgent); + var global$F = global$1o; + + var TypeError$b = global$F.TypeError; - var engineIsNode = classofRaw(global$2.process) == 'process'; + var validateArgumentsLength$4 = function (passed, required) { + if (passed < required) throw TypeError$b('Not enough arguments'); + return passed; + }; - var location$1 = global$2.location; - var set$2 = global$2.setImmediate; - var clear = global$2.clearImmediate; - var process$3 = global$2.process; - var MessageChannel = global$2.MessageChannel; - var Dispatch$1 = global$2.Dispatch; + var userAgent$6 = engineUserAgent; + + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$6); + + var classof$5 = classofRaw$1; + var global$E = global$1o; + + var engineIsNode = classof$5(global$E.process) == 'process'; + + var global$D = global$1o; + var apply$7 = functionApply; + var bind$c = functionBindContext; + var isCallable$8 = isCallable$r; + var hasOwn$8 = hasOwnProperty_1; + var fails$B = fails$V; + var html = html$2; + var arraySlice$8 = arraySlice$b; + var createElement = documentCreateElement$2; + var validateArgumentsLength$3 = validateArgumentsLength$4; + var IS_IOS$1 = engineIsIos; + var IS_NODE$4 = engineIsNode; + + var set$2 = global$D.setImmediate; + var clear = global$D.clearImmediate; + var process$3 = global$D.process; + var Dispatch$1 = global$D.Dispatch; + var Function$3 = global$D.Function; + var MessageChannel = global$D.MessageChannel; + var String$2 = global$D.String; var counter = 0; - var queue = {}; + var queue$1 = {}; var ONREADYSTATECHANGE = 'onreadystatechange'; - var defer, channel, port; + var location$1, defer, channel, port; + + try { + // Deno throws a ReferenceError on `location` access without `--location` flag + location$1 = global$D.location; + } catch (error) { /* empty */ } var run = function (id) { - // eslint-disable-next-line no-prototype-builtins -- safe - if (queue.hasOwnProperty(id)) { - var fn = queue[id]; - delete queue[id]; + if (hasOwn$8(queue$1, id)) { + var fn = queue$1[id]; + delete queue$1[id]; fn(); } }; @@ -2642,27 +3782,26 @@ var post = function (id) { // old engines have not location.origin - global$2.postMessage(id + '', location$1.protocol + '//' + location$1.host); + global$D.postMessage(String$2(id), location$1.protocol + '//' + location$1.host); }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise: if (!set$2 || !clear) { - set$2 = function setImmediate(fn) { - var args = []; - var i = 1; - while (arguments.length > i) args.push(arguments[i++]); - queue[++counter] = function () { - // eslint-disable-next-line no-new-func -- spec requirement - (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args); + set$2 = function setImmediate(handler) { + validateArgumentsLength$3(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$3(handler); + var args = arraySlice$8(arguments, 1); + queue$1[++counter] = function () { + apply$7(fn, undefined, args); }; defer(counter); return counter; }; clear = function clearImmediate(id) { - delete queue[id]; + delete queue$1[id]; }; // Node.js 0.8- - if (engineIsNode) { + if (IS_NODE$4) { defer = function (id) { process$3.nextTick(runner(id)); }; @@ -2673,26 +3812,26 @@ }; // Browsers with MessageChannel, includes WebWorkers // except iOS - https://github.com/zloirock/core-js/issues/624 - } else if (MessageChannel && !engineIsIos) { + } else if (MessageChannel && !IS_IOS$1) { channel = new MessageChannel(); port = channel.port2; channel.port1.onmessage = listener; - defer = functionBindContext(port.postMessage, port, 1); + defer = bind$c(port.postMessage, port); // Browsers with postMessage, skip WebWorkers // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' } else if ( - global$2.addEventListener && - typeof postMessage == 'function' && - !global$2.importScripts && + global$D.addEventListener && + isCallable$8(global$D.postMessage) && + !global$D.importScripts && location$1 && location$1.protocol !== 'file:' && - !fails(post) + !fails$B(post) ) { defer = post; - global$2.addEventListener('message', listener, false); + global$D.addEventListener('message', listener, false); // IE8- - } else if (ONREADYSTATECHANGE in documentCreateElement('script')) { + } else if (ONREADYSTATECHANGE in createElement('script')) { defer = function (id) { - html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { html.removeChild(this); run(id); }; @@ -2710,20 +3849,30 @@ clear: clear }; - var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(engineUserAgent); - - var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f; - var macrotask = task$1.set; + var userAgent$5 = engineUserAgent; + var global$C = global$1o; + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$5) && global$C.Pebble !== undefined; + var userAgent$4 = engineUserAgent; + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$4); - var MutationObserver = global$2.MutationObserver || global$2.WebKitMutationObserver; - var document$2 = global$2.document; - var process$2 = global$2.process; - var Promise$1 = global$2.Promise; + var global$B = global$1o; + var bind$b = functionBindContext; + var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$3 = engineIsNode; + + var MutationObserver = global$B.MutationObserver || global$B.WebKitMutationObserver; + var document$2 = global$B.document; + var process$2 = global$B.process; + var Promise$1 = global$B.Promise; // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` - var queueMicrotaskDescriptor = getOwnPropertyDescriptor$3(global$2, 'queueMicrotask'); + var queueMicrotaskDescriptor = getOwnPropertyDescriptor$3(global$B, 'queueMicrotask'); var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; var flush, head, last, notify$1, toggle, node, promise, then; @@ -2732,7 +3881,7 @@ if (!queueMicrotask) { flush = function () { var parent, fn; - if (engineIsNode && (parent = process$2.domain)) parent.exit(); + if (IS_NODE$3 && (parent = process$2.domain)) parent.exit(); while (head) { fn = head.fn; head = head.next; @@ -2749,7 +3898,7 @@ // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 - if (!engineIsIos && !engineIsNode && !engineIsWebosWebkit && MutationObserver && document$2) { + if (!IS_IOS && !IS_NODE$3 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { toggle = true; node = document$2.createTextNode(''); new MutationObserver(flush).observe(node, { characterData: true }); @@ -2757,17 +3906,17 @@ node.data = toggle = !toggle; }; // environments with maybe non-completely correct, but existent Promise - } else if (Promise$1 && Promise$1.resolve) { + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { // Promise.resolve without an argument throws an error in LG WebOS 2 promise = Promise$1.resolve(undefined); // workaround of WebKit ~ iOS Safari 10.1 bug promise.constructor = Promise$1; - then = promise.then; + then = bind$b(promise.then, promise); notify$1 = function () { - then.call(promise, flush); + then(flush); }; // Node.js without promises - } else if (engineIsNode) { + } else if (IS_NODE$3) { notify$1 = function () { process$2.nextTick(flush); }; @@ -2778,14 +3927,15 @@ // - onreadystatechange // - setTimeout } else { + // strange IE + webpack dev server bug - use .bind(global) + macrotask = bind$b(macrotask, global$B); notify$1 = function () { - // strange IE + webpack dev server bug - use .call(global) - macrotask.call(global$2, flush); + macrotask(flush); }; } } - var microtask = queueMicrotask || function (fn) { + var microtask$1 = queueMicrotask || function (fn) { var task = { fn: fn, next: undefined }; if (last) last.next = task; if (!head) { @@ -2794,6 +3944,10 @@ } last = task; }; + var newPromiseCapability$2 = {}; + + var aCallable$6 = aCallable$a; + var PromiseCapability = function (C) { var resolve, reject; this.promise = new C(function ($$resolve, $$reject) { @@ -2801,37 +3955,39 @@ resolve = $$resolve; reject = $$reject; }); - this.resolve = aFunction(resolve); - this.reject = aFunction(reject); + this.resolve = aCallable$6(resolve); + this.reject = aCallable$6(reject); }; // `NewPromiseCapability` abstract operation // https://tc39.es/ecma262/#sec-newpromisecapability - var f = function (C) { + newPromiseCapability$2.f = function (C) { return new PromiseCapability(C); }; - var newPromiseCapability$1 = { - f: f - }; + var anObject$a = anObject$n; + var isObject$j = isObject$s; + var newPromiseCapability$1 = newPromiseCapability$2; - var promiseResolve = function (C, x) { - anObject(C); - if (isObject$4(x) && x.constructor === C) return x; + var promiseResolve$2 = function (C, x) { + anObject$a(C); + if (isObject$j(x) && x.constructor === C) return x; var promiseCapability = newPromiseCapability$1.f(C); var resolve = promiseCapability.resolve; resolve(x); return promiseCapability.promise; }; - var hostReportErrors = function (a, b) { - var console = global$2.console; + var global$A = global$1o; + + var hostReportErrors$1 = function (a, b) { + var console = global$A.console; if (console && console.error) { - arguments.length === 1 ? console.error(a) : console.error(a, b); + arguments.length == 1 ? console.error(a) : console.error(a, b); } }; - var perform = function (exec) { + var perform$1 = function (exec) { try { return { error: false, value: exec() }; } catch (error) { @@ -2839,36 +3995,81 @@ } }; - var engineIsBrowser = typeof window == 'object'; - - var task = task$1.set; - - - - - - - - + var Queue$1 = function () { + this.head = null; + this.tail = null; + }; + Queue$1.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + if (this.head) this.tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + this.head = entry.next; + if (this.tail === entry) this.tail = null; + return entry.item; + } + } + }; + var queue = Queue$1; + var engineIsBrowser = typeof window == 'object'; - var SPECIES$2 = wellKnownSymbol('species'); + var $$$ = _export; + var global$z = global$1o; + var getBuiltIn$3 = getBuiltIn$b; + var call$e = functionCall; + var NativePromise$1 = nativePromiseConstructor; + var redefine$8 = redefine$h.exports; + var redefineAll$2 = redefineAll$4; + var setPrototypeOf$3 = objectSetPrototypeOf; + var setToStringTag$5 = setToStringTag$a; + var setSpecies$3 = setSpecies$5; + var aCallable$5 = aCallable$a; + var isCallable$7 = isCallable$r; + var isObject$i = isObject$s; + var anInstance$5 = anInstance$7; + var inspectSource = inspectSource$4; + var iterate$2 = iterate$3; + var checkCorrectnessOfIteration$3 = checkCorrectnessOfIteration$4; + var speciesConstructor$3 = speciesConstructor$5; + var task = task$1.set; + var microtask = microtask$1; + var promiseResolve$1 = promiseResolve$2; + var hostReportErrors = hostReportErrors$1; + var newPromiseCapabilityModule = newPromiseCapability$2; + var perform = perform$1; + var Queue = queue; + var InternalStateModule$4 = internalState; + var isForced$3 = isForced_1; + var wellKnownSymbol$a = wellKnownSymbol$t; + var IS_BROWSER = engineIsBrowser; + var IS_NODE$2 = engineIsNode; + var V8_VERSION$1 = engineV8Version; + + var SPECIES$2 = wellKnownSymbol$a('species'); var PROMISE = 'Promise'; - var getInternalState$1 = internalState.get; - var setInternalState$3 = internalState.set; - var getInternalPromiseState = internalState.getterFor(PROMISE); - var NativePromisePrototype = nativePromiseConstructor && nativePromiseConstructor.prototype; - var PromiseConstructor = nativePromiseConstructor; - var PromiseConstructorPrototype = NativePromisePrototype; - var TypeError$1 = global$2.TypeError; - var document$1 = global$2.document; - var process$1 = global$2.process; - var newPromiseCapability = newPromiseCapability$1.f; + + var getInternalState$1 = InternalStateModule$4.getterFor(PROMISE); + var setInternalState$4 = InternalStateModule$4.set; + var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE); + var NativePromisePrototype = NativePromise$1 && NativePromise$1.prototype; + var PromiseConstructor = NativePromise$1; + var PromisePrototype = NativePromisePrototype; + var TypeError$a = global$z.TypeError; + var document$1 = global$z.document; + var process$1 = global$z.process; + var newPromiseCapability = newPromiseCapabilityModule.f; var newGenericPromiseCapability = newPromiseCapability; - var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$2.dispatchEvent); - var NATIVE_REJECTION_EVENT = typeof PromiseRejectionEvent == 'function'; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$z.dispatchEvent); + var NATIVE_REJECTION_EVENT = isCallable$7(global$z.PromiseRejectionEvent); var UNHANDLED_REJECTION = 'unhandledrejection'; var REJECTION_HANDLED = 'rejectionhandled'; var PENDING = 0; @@ -2877,18 +4078,20 @@ var HANDLED = 1; var UNHANDLED = 2; var SUBCLASSING = false; + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; - var FORCED$f = isForced_1(PROMISE, function () { - var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor); + var FORCED$g = isForced$3(PROMISE, function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor); // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 // We can't detect it synchronously, so just check versions - if (!GLOBAL_CORE_JS_PROMISE && engineV8Version === 66) return true; + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION$1 === 66) return true; // We can't use @@species feature detection in V8 since it causes // deoptimization and performance degradation // https://github.com/zloirock/core-js/issues/679 - if (engineV8Version >= 51 && /native code/.test(PromiseConstructor)) return false; + if (V8_VERSION$1 >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false; // Detect correctness of subclassing with @@species support var promise = new PromiseConstructor(function (resolve) { resolve(1); }); var FakePromise = function (exec) { @@ -2899,62 +4102,63 @@ SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; if (!SUBCLASSING) return true; // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test - return !GLOBAL_CORE_JS_PROMISE && engineIsBrowser && !NATIVE_REJECTION_EVENT; + return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT; }); - var INCORRECT_ITERATION$1 = FORCED$f || !checkCorrectnessOfIteration(function (iterable) { + var INCORRECT_ITERATION$1 = FORCED$g || !checkCorrectnessOfIteration$3(function (iterable) { PromiseConstructor.all(iterable)['catch'](function () { /* empty */ }); }); // helpers var isThenable = function (it) { var then; - return isObject$4(it) && typeof (then = it.then) == 'function' ? then : false; + return isObject$i(it) && isCallable$7(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state == FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(TypeError$a('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$e(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } }; var notify = function (state, isReject) { if (state.notified) return; state.notified = true; - var chain = state.reactions; microtask(function () { - var value = state.value; - var ok = state.state == FULFILLED; - var index = 0; - // variable length - can't use forEach - while (chain.length > index) { - var reaction = chain[index++]; - var handler = ok ? reaction.ok : reaction.fail; - var resolve = reaction.resolve; - var reject = reaction.reject; - var domain = reaction.domain; - var result, then, exited; - try { - if (handler) { - if (!ok) { - if (state.rejection === UNHANDLED) onHandleUnhandled(state); - state.rejection = HANDLED; - } - if (handler === true) result = value; - else { - if (domain) domain.enter(); - result = handler(value); // can throw - if (domain) { - domain.exit(); - exited = true; - } - } - if (result === reaction.promise) { - reject(TypeError$1('Promise-chain cycle')); - } else if (then = isThenable(result)) { - then.call(result, resolve, reject); - } else resolve(result); - } else reject(value); - } catch (error) { - if (domain && !exited) domain.exit(); - reject(error); - } + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); } - state.reactions = []; state.notified = false; if (isReject && !state.rejection) onUnhandled(state); }); @@ -2967,26 +4171,26 @@ event.promise = promise; event.reason = reason; event.initEvent(name, false, true); - global$2.dispatchEvent(event); + global$z.dispatchEvent(event); } else event = { promise: promise, reason: reason }; - if (!NATIVE_REJECTION_EVENT && (handler = global$2['on' + name])) handler(event); + if (!NATIVE_REJECTION_EVENT && (handler = global$z['on' + name])) handler(event); else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); }; var onUnhandled = function (state) { - task.call(global$2, function () { + call$e(task, global$z, function () { var promise = state.facade; var value = state.value; var IS_UNHANDLED = isUnhandled(state); var result; if (IS_UNHANDLED) { result = perform(function () { - if (engineIsNode) { + if (IS_NODE$2) { process$1.emit('unhandledRejection', value, promise); } else dispatchEvent$1(UNHANDLED_REJECTION, promise, value); }); // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should - state.rejection = engineIsNode || isUnhandled(state) ? UNHANDLED : HANDLED; + state.rejection = IS_NODE$2 || isUnhandled(state) ? UNHANDLED : HANDLED; if (result.error) throw result.value; } }); @@ -2997,15 +4201,15 @@ }; var onHandleUnhandled = function (state) { - task.call(global$2, function () { + call$e(task, global$z, function () { var promise = state.facade; - if (engineIsNode) { + if (IS_NODE$2) { process$1.emit('rejectionHandled', promise); } else dispatchEvent$1(REJECTION_HANDLED, promise, state.value); }); }; - var bind$2 = function (fn, state, unwrap) { + var bind$a = function (fn, state, unwrap) { return function (value) { fn(state, value, unwrap); }; @@ -3025,15 +4229,15 @@ state.done = true; if (unwrap) state = unwrap; try { - if (state.facade === value) throw TypeError$1("Promise can't be resolved itself"); + if (state.facade === value) throw TypeError$a("Promise can't be resolved itself"); var then = isThenable(value); if (then) { microtask(function () { var wrapper = { done: false }; try { - then.call(value, - bind$2(internalResolve, wrapper, state), - bind$2(internalReject, wrapper, state) + call$e(then, value, + bind$a(internalResolve, wrapper, state), + bind$a(internalReject, wrapper, state) ); } catch (error) { internalReject(wrapper, error, state); @@ -3050,45 +4254,48 @@ }; // constructor polyfill - if (FORCED$f) { + if (FORCED$g) { // 25.4.3.1 Promise(executor) PromiseConstructor = function Promise(executor) { - anInstance(this, PromiseConstructor, PROMISE); - aFunction(executor); - Internal.call(this); + anInstance$5(this, PromisePrototype); + aCallable$5(executor); + call$e(Internal, this); var state = getInternalState$1(this); try { - executor(bind$2(internalResolve, state), bind$2(internalReject, state)); + executor(bind$a(internalResolve, state), bind$a(internalReject, state)); } catch (error) { internalReject(state, error); } }; - PromiseConstructorPrototype = PromiseConstructor.prototype; + PromisePrototype = PromiseConstructor.prototype; // eslint-disable-next-line no-unused-vars -- required for `.length` Internal = function Promise(executor) { - setInternalState$3(this, { + setInternalState$4(this, { type: PROMISE, done: false, notified: false, parent: false, - reactions: [], + reactions: new Queue(), rejection: false, state: PENDING, value: undefined }); }; - Internal.prototype = redefineAll(PromiseConstructorPrototype, { + Internal.prototype = redefineAll$2(PromisePrototype, { // `Promise.prototype.then` method // https://tc39.es/ecma262/#sec-promise.prototype.then + // eslint-disable-next-line unicorn/no-thenable -- safe then: function then(onFulfilled, onRejected) { var state = getInternalPromiseState(this); - var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor)); - reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; - reaction.fail = typeof onRejected == 'function' && onRejected; - reaction.domain = engineIsNode ? process$1.domain : undefined; + var reaction = newPromiseCapability(speciesConstructor$3(this, PromiseConstructor)); state.parent = true; - state.reactions.push(reaction); - if (state.state != PENDING) notify(state, false); + reaction.ok = isCallable$7(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$7(onRejected) && onRejected; + reaction.domain = IS_NODE$2 ? process$1.domain : undefined; + if (state.state == PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); return reaction.promise; }, // `Promise.prototype.catch` method @@ -3101,30 +4308,30 @@ var promise = new Internal(); var state = getInternalState$1(promise); this.promise = promise; - this.resolve = bind$2(internalResolve, state); - this.reject = bind$2(internalReject, state); + this.resolve = bind$a(internalResolve, state); + this.reject = bind$a(internalReject, state); }; - newPromiseCapability$1.f = newPromiseCapability = function (C) { + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C); }; - if (typeof nativePromiseConstructor == 'function' && NativePromisePrototype !== Object.prototype) { + if (isCallable$7(NativePromise$1) && NativePromisePrototype !== Object.prototype) { nativeThen = NativePromisePrototype.then; if (!SUBCLASSING) { // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs - redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) { + redefine$8(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) { var that = this; return new PromiseConstructor(function (resolve, reject) { - nativeThen.call(that, resolve, reject); + call$e(nativeThen, that, resolve, reject); }).then(onFulfilled, onRejected); // https://github.com/zloirock/core-js/issues/640 }, { unsafe: true }); // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` - redefine(NativePromisePrototype, 'catch', PromiseConstructorPrototype['catch'], { unsafe: true }); + redefine$8(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true }); } // make `.constructor === Promise` work for native promise-based APIs @@ -3133,41 +4340,41 @@ } catch (error) { /* empty */ } // make `instanceof Promise` work for native promise-based APIs - if (objectSetPrototypeOf) { - objectSetPrototypeOf(NativePromisePrototype, PromiseConstructorPrototype); + if (setPrototypeOf$3) { + setPrototypeOf$3(NativePromisePrototype, PromisePrototype); } } } - _export({ global: true, wrap: true, forced: FORCED$f }, { + $$$({ global: true, wrap: true, forced: FORCED$g }, { Promise: PromiseConstructor }); - setToStringTag(PromiseConstructor, PROMISE, false); - setSpecies(PROMISE); + setToStringTag$5(PromiseConstructor, PROMISE, false); + setSpecies$3(PROMISE); - PromiseWrapper = getBuiltIn(PROMISE); + PromiseWrapper = getBuiltIn$3(PROMISE); // statics - _export({ target: PROMISE, stat: true, forced: FORCED$f }, { + $$$({ target: PROMISE, stat: true, forced: FORCED$g }, { // `Promise.reject` method // https://tc39.es/ecma262/#sec-promise.reject reject: function reject(r) { var capability = newPromiseCapability(this); - capability.reject.call(undefined, r); + call$e(capability.reject, undefined, r); return capability.promise; } }); - _export({ target: PROMISE, stat: true, forced: FORCED$f }, { + $$$({ target: PROMISE, stat: true, forced: FORCED$g }, { // `Promise.resolve` method // https://tc39.es/ecma262/#sec-promise.resolve resolve: function resolve(x) { - return promiseResolve(this, x); + return promiseResolve$1(this, x); } }); - _export({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION$1 }, { + $$$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION$1 }, { // `Promise.all` method // https://tc39.es/ecma262/#sec-promise.all all: function all(iterable) { @@ -3176,16 +4383,15 @@ var resolve = capability.resolve; var reject = capability.reject; var result = perform(function () { - var $promiseResolve = aFunction(C.resolve); + var $promiseResolve = aCallable$5(C.resolve); var values = []; var counter = 0; var remaining = 1; - iterate(iterable, function (promise) { + iterate$2(iterable, function (promise) { var index = counter++; var alreadyCalled = false; - values.push(undefined); remaining++; - $promiseResolve.call(C, promise).then(function (value) { + call$e($promiseResolve, C, promise).then(function (value) { if (alreadyCalled) return; alreadyCalled = true; values[index] = value; @@ -3204,9 +4410,9 @@ var capability = newPromiseCapability(C); var reject = capability.reject; var result = perform(function () { - var $promiseResolve = aFunction(C.resolve); - iterate(iterable, function (promise) { - $promiseResolve.call(C, promise).then(capability.resolve, reject); + var $promiseResolve = aCallable$5(C.resolve); + iterate$2(iterable, function (promise) { + call$e($promiseResolve, C, promise).then(capability.resolve, reject); }); }); if (result.error) reject(result.value); @@ -3214,131 +4420,176 @@ } }); + var typedArrayConstructor = {exports: {}}; + /* eslint-disable no-new -- required for testing */ - var NATIVE_ARRAY_BUFFER_VIEWS = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; - - var ArrayBuffer$1 = global$2.ArrayBuffer; - var Int8Array$2 = global$2.Int8Array; - - var typedArrayConstructorsRequireWrappers = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () { - Int8Array$2(1); - }) || !fails(function () { - new Int8Array$2(-1); - }) || !checkCorrectnessOfIteration(function (iterable) { - new Int8Array$2(); - new Int8Array$2(null); - new Int8Array$2(1.5); - new Int8Array$2(iterable); - }, true) || fails(function () { + var global$y = global$1o; + var fails$A = fails$V; + var checkCorrectnessOfIteration$2 = checkCorrectnessOfIteration$4; + var NATIVE_ARRAY_BUFFER_VIEWS$1 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; + + var ArrayBuffer$2 = global$y.ArrayBuffer; + var Int8Array$3 = global$y.Int8Array; + + var typedArrayConstructorsRequireWrappers = !NATIVE_ARRAY_BUFFER_VIEWS$1 || !fails$A(function () { + Int8Array$3(1); + }) || !fails$A(function () { + new Int8Array$3(-1); + }) || !checkCorrectnessOfIteration$2(function (iterable) { + new Int8Array$3(); + new Int8Array$3(null); + new Int8Array$3(1.5); + new Int8Array$3(iterable); + }, true) || fails$A(function () { // Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill - return new Int8Array$2(new ArrayBuffer$1(2), 1, undefined).length !== 1; + return new Int8Array$3(new ArrayBuffer$2(2), 1, undefined).length !== 1; }); - var toPositiveInteger = function (it) { - var result = toInteger(it); - if (result < 0) throw RangeError("The argument can't be less than 0"); + var isObject$h = isObject$s; + + var floor$6 = Math.floor; + + // `IsIntegralNumber` abstract operation + // https://tc39.es/ecma262/#sec-isintegralnumber + // eslint-disable-next-line es/no-number-isinteger -- safe + var isIntegralNumber$1 = Number.isInteger || function isInteger(it) { + return !isObject$h(it) && isFinite(it) && floor$6(it) === it; + }; + + var global$x = global$1o; + var toIntegerOrInfinity$5 = toIntegerOrInfinity$b; + + var RangeError$9 = global$x.RangeError; + + var toPositiveInteger$1 = function (it) { + var result = toIntegerOrInfinity$5(it); + if (result < 0) throw RangeError$9("The argument can't be less than 0"); return result; }; - var toOffset = function (it, BYTES) { + var global$w = global$1o; + var toPositiveInteger = toPositiveInteger$1; + + var RangeError$8 = global$w.RangeError; + + var toOffset$2 = function (it, BYTES) { var offset = toPositiveInteger(it); - if (offset % BYTES) throw RangeError('Wrong offset'); + if (offset % BYTES) throw RangeError$8('Wrong offset'); return offset; }; - var aTypedArrayConstructor$3 = arrayBufferViewCore.aTypedArrayConstructor; + var bind$9 = functionBindContext; + var call$d = functionCall; + var aConstructor$1 = aConstructor$3; + var toObject$c = toObject$i; + var lengthOfArrayLike$c = lengthOfArrayLike$i; + var getIterator$2 = getIterator$4; + var getIteratorMethod$2 = getIteratorMethod$5; + var isArrayIteratorMethod$1 = isArrayIteratorMethod$3; + var aTypedArrayConstructor$2 = arrayBufferViewCore.aTypedArrayConstructor; - var typedArrayFrom = function from(source /* , mapfn, thisArg */) { - var O = toObject(source); + var typedArrayFrom$2 = function from(source /* , mapfn, thisArg */) { + var C = aConstructor$1(this); + var O = toObject$c(source); var argumentsLength = arguments.length; var mapfn = argumentsLength > 1 ? arguments[1] : undefined; var mapping = mapfn !== undefined; - var iteratorMethod = getIteratorMethod(O); + var iteratorMethod = getIteratorMethod$2(O); var i, length, result, step, iterator, next; - if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) { - iterator = iteratorMethod.call(O); + if (iteratorMethod && !isArrayIteratorMethod$1(iteratorMethod)) { + iterator = getIterator$2(O, iteratorMethod); next = iterator.next; O = []; - while (!(step = next.call(iterator)).done) { + while (!(step = call$d(next, iterator)).done) { O.push(step.value); } } if (mapping && argumentsLength > 2) { - mapfn = functionBindContext(mapfn, arguments[2], 2); + mapfn = bind$9(mapfn, arguments[2]); } - length = toLength(O.length); - result = new (aTypedArrayConstructor$3(this))(length); + length = lengthOfArrayLike$c(O); + result = new (aTypedArrayConstructor$2(C))(length); for (i = 0; length > i; i++) { result[i] = mapping ? mapfn(O[i], i) : O[i]; } return result; }; + var isCallable$6 = isCallable$r; + var isObject$g = isObject$s; + var setPrototypeOf$2 = objectSetPrototypeOf; + // makes subclassing work correct for wrapped built-ins - var inheritIfRequired = function ($this, dummy, Wrapper) { + var inheritIfRequired$4 = function ($this, dummy, Wrapper) { var NewTarget, NewTargetPrototype; if ( // it can work only with native `setPrototypeOf` - objectSetPrototypeOf && + setPrototypeOf$2 && // we haven't completely correct pre-ES6 way for getting `new.target`, so use this - typeof (NewTarget = dummy.constructor) == 'function' && + isCallable$6(NewTarget = dummy.constructor) && NewTarget !== Wrapper && - isObject$4(NewTargetPrototype = NewTarget.prototype) && + isObject$g(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype - ) objectSetPrototypeOf($this, NewTargetPrototype); + ) setPrototypeOf$2($this, NewTargetPrototype); return $this; }; - var typedArrayConstructor = createCommonjsModule(function (module) { - - - - - - - - - - - - - - - - - - - var getOwnPropertyNames = objectGetOwnPropertyNames.f; - - var forEach = arrayIteration.forEach; - - - - - - - var getInternalState = internalState.get; - var setInternalState = internalState.set; - var nativeDefineProperty = objectDefineProperty.f; - var nativeGetOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var $$_ = _export; + var global$v = global$1o; + var call$c = functionCall; + var DESCRIPTORS$c = descriptors; + var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS$1 = typedArrayConstructorsRequireWrappers; + var ArrayBufferViewCore$n = arrayBufferViewCore; + var ArrayBufferModule = arrayBuffer; + var anInstance$4 = anInstance$7; + var createPropertyDescriptor$1 = createPropertyDescriptor$7; + var createNonEnumerableProperty$2 = createNonEnumerableProperty$b; + var isIntegralNumber = isIntegralNumber$1; + var toLength$7 = toLength$c; + var toIndex = toIndex$2; + var toOffset$1 = toOffset$2; + var toPropertyKey = toPropertyKey$5; + var hasOwn$7 = hasOwnProperty_1; + var classof$4 = classof$d; + var isObject$f = isObject$s; + var isSymbol$2 = isSymbol$6; + var create$7 = objectCreate; + var isPrototypeOf$3 = objectIsPrototypeOf; + var setPrototypeOf$1 = objectSetPrototypeOf; + var getOwnPropertyNames$2 = objectGetOwnPropertyNames.f; + var typedArrayFrom$1 = typedArrayFrom$2; + var forEach$1 = arrayIteration.forEach; + var setSpecies$2 = setSpecies$5; + var definePropertyModule = objectDefineProperty; + var getOwnPropertyDescriptorModule$1 = objectGetOwnPropertyDescriptor; + var InternalStateModule$3 = internalState; + var inheritIfRequired$3 = inheritIfRequired$4; + + var getInternalState = InternalStateModule$3.get; + var setInternalState$3 = InternalStateModule$3.set; + var nativeDefineProperty = definePropertyModule.f; + var nativeGetOwnPropertyDescriptor$1 = getOwnPropertyDescriptorModule$1.f; var round = Math.round; - var RangeError = global$2.RangeError; - var ArrayBuffer = arrayBuffer.ArrayBuffer; - var DataView = arrayBuffer.DataView; - var NATIVE_ARRAY_BUFFER_VIEWS = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; - var TYPED_ARRAY_TAG = arrayBufferViewCore.TYPED_ARRAY_TAG; - var TypedArray = arrayBufferViewCore.TypedArray; - var TypedArrayPrototype = arrayBufferViewCore.TypedArrayPrototype; - var aTypedArrayConstructor = arrayBufferViewCore.aTypedArrayConstructor; - var isTypedArray = arrayBufferViewCore.isTypedArray; + var RangeError$7 = global$v.RangeError; + var ArrayBuffer$1 = ArrayBufferModule.ArrayBuffer; + var ArrayBufferPrototype = ArrayBuffer$1.prototype; + var DataView$1 = ArrayBufferModule.DataView; + var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore$n.NATIVE_ARRAY_BUFFER_VIEWS; + var TYPED_ARRAY_CONSTRUCTOR$1 = ArrayBufferViewCore$n.TYPED_ARRAY_CONSTRUCTOR; + var TYPED_ARRAY_TAG = ArrayBufferViewCore$n.TYPED_ARRAY_TAG; + var TypedArray = ArrayBufferViewCore$n.TypedArray; + var TypedArrayPrototype$1 = ArrayBufferViewCore$n.TypedArrayPrototype; + var aTypedArrayConstructor$1 = ArrayBufferViewCore$n.aTypedArrayConstructor; + var isTypedArray = ArrayBufferViewCore$n.isTypedArray; var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; var WRONG_LENGTH = 'Wrong length'; var fromList = function (C, list) { + aTypedArrayConstructor$1(C); var index = 0; var length = list.length; - var result = new (aTypedArrayConstructor(C))(length); + var result = new C(length); while (length > index) result[index] = list[index++]; return result; }; @@ -3351,59 +4602,62 @@ var isArrayBuffer = function (it) { var klass; - return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer'; + return isPrototypeOf$3(ArrayBufferPrototype, it) || (klass = classof$4(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer'; }; var isTypedArrayIndex = function (target, key) { return isTypedArray(target) - && typeof key != 'symbol' + && !isSymbol$2(key) && key in target - && String(+key) == String(key); + && isIntegralNumber(+key) + && key >= 0; }; var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) { - return isTypedArrayIndex(target, key = toPrimitive(key, true)) - ? createPropertyDescriptor(2, target[key]) - : nativeGetOwnPropertyDescriptor(target, key); + key = toPropertyKey(key); + return isTypedArrayIndex(target, key) + ? createPropertyDescriptor$1(2, target[key]) + : nativeGetOwnPropertyDescriptor$1(target, key); }; var wrappedDefineProperty = function defineProperty(target, key, descriptor) { - if (isTypedArrayIndex(target, key = toPrimitive(key, true)) - && isObject$4(descriptor) - && has$1(descriptor, 'value') - && !has$1(descriptor, 'get') - && !has$1(descriptor, 'set') + key = toPropertyKey(key); + if (isTypedArrayIndex(target, key) + && isObject$f(descriptor) + && hasOwn$7(descriptor, 'value') + && !hasOwn$7(descriptor, 'get') + && !hasOwn$7(descriptor, 'set') // TODO: add validation descriptor w/o calling accessors && !descriptor.configurable - && (!has$1(descriptor, 'writable') || descriptor.writable) - && (!has$1(descriptor, 'enumerable') || descriptor.enumerable) + && (!hasOwn$7(descriptor, 'writable') || descriptor.writable) + && (!hasOwn$7(descriptor, 'enumerable') || descriptor.enumerable) ) { target[key] = descriptor.value; return target; } return nativeDefineProperty(target, key, descriptor); }; - if (descriptors) { + if (DESCRIPTORS$c) { if (!NATIVE_ARRAY_BUFFER_VIEWS) { - objectGetOwnPropertyDescriptor.f = wrappedGetOwnPropertyDescriptor; - objectDefineProperty.f = wrappedDefineProperty; - addGetter(TypedArrayPrototype, 'buffer'); - addGetter(TypedArrayPrototype, 'byteOffset'); - addGetter(TypedArrayPrototype, 'byteLength'); - addGetter(TypedArrayPrototype, 'length'); + getOwnPropertyDescriptorModule$1.f = wrappedGetOwnPropertyDescriptor; + definePropertyModule.f = wrappedDefineProperty; + addGetter(TypedArrayPrototype$1, 'buffer'); + addGetter(TypedArrayPrototype$1, 'byteOffset'); + addGetter(TypedArrayPrototype$1, 'byteLength'); + addGetter(TypedArrayPrototype$1, 'length'); } - _export({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { + $$_({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor, defineProperty: wrappedDefineProperty }); - module.exports = function (TYPE, wrapper, CLAMPED) { + typedArrayConstructor.exports = function (TYPE, wrapper, CLAMPED) { var BYTES = TYPE.match(/\d+$/)[0] / 8; var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array'; var GETTER = 'get' + TYPE; var SETTER = 'set' + TYPE; - var NativeTypedArrayConstructor = global$2[CONSTRUCTOR_NAME]; + var NativeTypedArrayConstructor = global$v[CONSTRUCTOR_NAME]; var TypedArrayConstructor = NativeTypedArrayConstructor; var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype; var exported = {}; @@ -3433,115 +4687,122 @@ if (!NATIVE_ARRAY_BUFFER_VIEWS) { TypedArrayConstructor = wrapper(function (that, data, offset, $length) { - anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME); + anInstance$4(that, TypedArrayConstructorPrototype); var index = 0; var byteOffset = 0; var buffer, byteLength, length; - if (!isObject$4(data)) { + if (!isObject$f(data)) { length = toIndex(data); byteLength = length * BYTES; - buffer = new ArrayBuffer(byteLength); + buffer = new ArrayBuffer$1(byteLength); } else if (isArrayBuffer(data)) { buffer = data; - byteOffset = toOffset(offset, BYTES); + byteOffset = toOffset$1(offset, BYTES); var $len = data.byteLength; if ($length === undefined) { - if ($len % BYTES) throw RangeError(WRONG_LENGTH); + if ($len % BYTES) throw RangeError$7(WRONG_LENGTH); byteLength = $len - byteOffset; - if (byteLength < 0) throw RangeError(WRONG_LENGTH); + if (byteLength < 0) throw RangeError$7(WRONG_LENGTH); } else { - byteLength = toLength($length) * BYTES; - if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH); + byteLength = toLength$7($length) * BYTES; + if (byteLength + byteOffset > $len) throw RangeError$7(WRONG_LENGTH); } length = byteLength / BYTES; } else if (isTypedArray(data)) { return fromList(TypedArrayConstructor, data); } else { - return typedArrayFrom.call(TypedArrayConstructor, data); + return call$c(typedArrayFrom$1, TypedArrayConstructor, data); } - setInternalState(that, { + setInternalState$3(that, { buffer: buffer, byteOffset: byteOffset, byteLength: byteLength, length: length, - view: new DataView(buffer) + view: new DataView$1(buffer) }); while (index < length) addElement(that, index++); }); - if (objectSetPrototypeOf) objectSetPrototypeOf(TypedArrayConstructor, TypedArray); - TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = objectCreate(TypedArrayPrototype); - } else if (typedArrayConstructorsRequireWrappers) { + if (setPrototypeOf$1) setPrototypeOf$1(TypedArrayConstructor, TypedArray); + TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create$7(TypedArrayPrototype$1); + } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS$1) { TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) { - anInstance(dummy, TypedArrayConstructor, CONSTRUCTOR_NAME); - return inheritIfRequired(function () { - if (!isObject$4(data)) return new NativeTypedArrayConstructor(toIndex(data)); + anInstance$4(dummy, TypedArrayConstructorPrototype); + return inheritIfRequired$3(function () { + if (!isObject$f(data)) return new NativeTypedArrayConstructor(toIndex(data)); if (isArrayBuffer(data)) return $length !== undefined - ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length) + ? new NativeTypedArrayConstructor(data, toOffset$1(typedArrayOffset, BYTES), $length) : typedArrayOffset !== undefined - ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES)) + ? new NativeTypedArrayConstructor(data, toOffset$1(typedArrayOffset, BYTES)) : new NativeTypedArrayConstructor(data); if (isTypedArray(data)) return fromList(TypedArrayConstructor, data); - return typedArrayFrom.call(TypedArrayConstructor, data); + return call$c(typedArrayFrom$1, TypedArrayConstructor, data); }(), dummy, TypedArrayConstructor); }); - if (objectSetPrototypeOf) objectSetPrototypeOf(TypedArrayConstructor, TypedArray); - forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) { + if (setPrototypeOf$1) setPrototypeOf$1(TypedArrayConstructor, TypedArray); + forEach$1(getOwnPropertyNames$2(NativeTypedArrayConstructor), function (key) { if (!(key in TypedArrayConstructor)) { - createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); + createNonEnumerableProperty$2(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); } }); TypedArrayConstructor.prototype = TypedArrayConstructorPrototype; } if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) { - createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); + createNonEnumerableProperty$2(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); } + createNonEnumerableProperty$2(TypedArrayConstructorPrototype, TYPED_ARRAY_CONSTRUCTOR$1, TypedArrayConstructor); + if (TYPED_ARRAY_TAG) { - createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); + createNonEnumerableProperty$2(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); } exported[CONSTRUCTOR_NAME] = TypedArrayConstructor; - _export({ + $$_({ global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS }, exported); if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) { - createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); + createNonEnumerableProperty$2(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); } if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) { - createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); + createNonEnumerableProperty$2(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); } - setSpecies(CONSTRUCTOR_NAME); + setSpecies$2(CONSTRUCTOR_NAME); }; - } else module.exports = function () { /* empty */ }; - }); + } else typedArrayConstructor.exports = function () { /* empty */ }; + + var createTypedArrayConstructor$1 = typedArrayConstructor.exports; // `Uint8Array` constructor // https://tc39.es/ecma262/#sec-typedarray-objects - typedArrayConstructor('Uint8', function (init) { + createTypedArrayConstructor$1('Uint8', function (init) { return function Uint8Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); + var toObject$b = toObject$i; + var toAbsoluteIndex$4 = toAbsoluteIndex$9; + var lengthOfArrayLike$b = lengthOfArrayLike$i; + var min$7 = Math.min; // `Array.prototype.copyWithin` method implementation // https://tc39.es/ecma262/#sec-array.prototype.copywithin // eslint-disable-next-line es/no-array-prototype-copywithin -- safe var arrayCopyWithin = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { - var O = toObject(this); - var len = toLength(O.length); - var to = toAbsoluteIndex(target, len); - var from = toAbsoluteIndex(start, len); + var O = toObject$b(this); + var len = lengthOfArrayLike$b(O); + var to = toAbsoluteIndex$4(target, len); + var from = toAbsoluteIndex$4(start, len); var end = arguments.length > 2 ? arguments[2] : undefined; - var count = min$7((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); + var count = min$7((end === undefined ? len : toAbsoluteIndex$4(end, len)) - from, len - to); var inc = 1; if (from < to && to < from + count) { inc = -1; @@ -3556,19 +4817,25 @@ } return O; }; - var aTypedArray$l = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$m = arrayBufferViewCore.exportTypedArrayMethod; + var uncurryThis$A = functionUncurryThis; + var ArrayBufferViewCore$m = arrayBufferViewCore; + var $ArrayCopyWithin = arrayCopyWithin; + + var u$ArrayCopyWithin = uncurryThis$A($ArrayCopyWithin); + var aTypedArray$l = ArrayBufferViewCore$m.aTypedArray; + var exportTypedArrayMethod$m = ArrayBufferViewCore$m.exportTypedArrayMethod; // `%TypedArray%.prototype.copyWithin` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin exportTypedArrayMethod$m('copyWithin', function copyWithin(target, start /* , end */) { - return arrayCopyWithin.call(aTypedArray$l(this), target, start, arguments.length > 2 ? arguments[2] : undefined); + return u$ArrayCopyWithin(aTypedArray$l(this), target, start, arguments.length > 2 ? arguments[2] : undefined); }); + var ArrayBufferViewCore$l = arrayBufferViewCore; var $every$1 = arrayIteration.every; - var aTypedArray$k = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$l = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$k = ArrayBufferViewCore$l.aTypedArray; + var exportTypedArrayMethod$l = ArrayBufferViewCore$l.exportTypedArrayMethod; // `%TypedArray%.prototype.every` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.every @@ -3576,45 +4843,74 @@ return $every$1(aTypedArray$k(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); }); - var aTypedArray$j = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$k = arrayBufferViewCore.exportTypedArrayMethod; + var ArrayBufferViewCore$k = arrayBufferViewCore; + var call$b = functionCall; + var $fill = arrayFill$1; + + var aTypedArray$j = ArrayBufferViewCore$k.aTypedArray; + var exportTypedArrayMethod$k = ArrayBufferViewCore$k.exportTypedArrayMethod; // `%TypedArray%.prototype.fill` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill - // eslint-disable-next-line no-unused-vars -- required for `.length` exportTypedArrayMethod$k('fill', function fill(value /* , start, end */) { - return arrayFill.apply(aTypedArray$j(this), arguments); + var length = arguments.length; + return call$b( + $fill, + aTypedArray$j(this), + value, + length > 1 ? arguments[1] : undefined, + length > 2 ? arguments[2] : undefined + ); }); - var aTypedArrayConstructor$2 = arrayBufferViewCore.aTypedArrayConstructor; - + var lengthOfArrayLike$a = lengthOfArrayLike$i; - var typedArrayFromSpeciesAndList = function (instance, list) { - var C = speciesConstructor(instance, instance.constructor); + var arrayFromConstructorAndList$1 = function (Constructor, list) { var index = 0; - var length = list.length; - var result = new (aTypedArrayConstructor$2(C))(length); + var length = lengthOfArrayLike$a(list); + var result = new Constructor(length); while (length > index) result[index] = list[index++]; return result; }; - var $filter$1 = arrayIteration.filter; + var ArrayBufferViewCore$j = arrayBufferViewCore; + var speciesConstructor$2 = speciesConstructor$5; + + var TYPED_ARRAY_CONSTRUCTOR = ArrayBufferViewCore$j.TYPED_ARRAY_CONSTRUCTOR; + var aTypedArrayConstructor = ArrayBufferViewCore$j.aTypedArrayConstructor; + // a part of `TypedArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#typedarray-species-create + var typedArraySpeciesConstructor$4 = function (originalArray) { + return aTypedArrayConstructor(speciesConstructor$2(originalArray, originalArray[TYPED_ARRAY_CONSTRUCTOR])); + }; - var aTypedArray$i = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$j = arrayBufferViewCore.exportTypedArrayMethod; + var arrayFromConstructorAndList = arrayFromConstructorAndList$1; + var typedArraySpeciesConstructor$3 = typedArraySpeciesConstructor$4; + + var typedArrayFromSpeciesAndList = function (instance, list) { + return arrayFromConstructorAndList(typedArraySpeciesConstructor$3(instance), list); + }; + + var ArrayBufferViewCore$i = arrayBufferViewCore; + var $filter$1 = arrayIteration.filter; + var fromSpeciesAndList = typedArrayFromSpeciesAndList; + + var aTypedArray$i = ArrayBufferViewCore$i.aTypedArray; + var exportTypedArrayMethod$j = ArrayBufferViewCore$i.exportTypedArrayMethod; // `%TypedArray%.prototype.filter` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter exportTypedArrayMethod$j('filter', function filter(callbackfn /* , thisArg */) { var list = $filter$1(aTypedArray$i(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); - return typedArrayFromSpeciesAndList(this, list); + return fromSpeciesAndList(this, list); }); + var ArrayBufferViewCore$h = arrayBufferViewCore; var $find$1 = arrayIteration.find; - var aTypedArray$h = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$i = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$h = ArrayBufferViewCore$h.aTypedArray; + var exportTypedArrayMethod$i = ArrayBufferViewCore$h.exportTypedArrayMethod; // `%TypedArray%.prototype.find` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.find @@ -3622,10 +4918,11 @@ return $find$1(aTypedArray$h(this), predicate, arguments.length > 1 ? arguments[1] : undefined); }); + var ArrayBufferViewCore$g = arrayBufferViewCore; var $findIndex$1 = arrayIteration.findIndex; - var aTypedArray$g = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$h = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$g = ArrayBufferViewCore$g.aTypedArray; + var exportTypedArrayMethod$h = ArrayBufferViewCore$g.exportTypedArrayMethod; // `%TypedArray%.prototype.findIndex` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex @@ -3633,10 +4930,11 @@ return $findIndex$1(aTypedArray$g(this), predicate, arguments.length > 1 ? arguments[1] : undefined); }); + var ArrayBufferViewCore$f = arrayBufferViewCore; var $forEach = arrayIteration.forEach; - var aTypedArray$f = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$g = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$f = ArrayBufferViewCore$f.aTypedArray; + var exportTypedArrayMethod$g = ArrayBufferViewCore$f.exportTypedArrayMethod; // `%TypedArray%.prototype.forEach` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach @@ -3644,10 +4942,11 @@ $forEach(aTypedArray$f(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); }); + var ArrayBufferViewCore$e = arrayBufferViewCore; var $includes$1 = arrayIncludes.includes; - var aTypedArray$e = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$f = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$e = ArrayBufferViewCore$e.aTypedArray; + var exportTypedArrayMethod$f = ArrayBufferViewCore$e.exportTypedArrayMethod; // `%TypedArray%.prototype.includes` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes @@ -3655,10 +4954,11 @@ return $includes$1(aTypedArray$e(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); }); + var ArrayBufferViewCore$d = arrayBufferViewCore; var $indexOf = arrayIncludes.indexOf; - var aTypedArray$d = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$e = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$d = ArrayBufferViewCore$d.aTypedArray; + var exportTypedArrayMethod$e = ArrayBufferViewCore$d.exportTypedArrayMethod; // `%TypedArray%.prototype.indexOf` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof @@ -3666,108 +4966,136 @@ return $indexOf(aTypedArray$d(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); }); - var ITERATOR$2 = wellKnownSymbol('iterator'); - var Uint8Array$2 = global$2.Uint8Array; - var arrayValues = es_array_iterator.values; - var arrayKeys = es_array_iterator.keys; - var arrayEntries = es_array_iterator.entries; - var aTypedArray$c = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$d = arrayBufferViewCore.exportTypedArrayMethod; - var nativeTypedArrayIterator = Uint8Array$2 && Uint8Array$2.prototype[ITERATOR$2]; + var global$u = global$1o; + var fails$z = fails$V; + var uncurryThis$z = functionUncurryThis; + var ArrayBufferViewCore$c = arrayBufferViewCore; + var ArrayIterators = es_array_iterator; + var wellKnownSymbol$9 = wellKnownSymbol$t; + + var ITERATOR$4 = wellKnownSymbol$9('iterator'); + var Uint8Array$2 = global$u.Uint8Array; + var arrayValues = uncurryThis$z(ArrayIterators.values); + var arrayKeys = uncurryThis$z(ArrayIterators.keys); + var arrayEntries = uncurryThis$z(ArrayIterators.entries); + var aTypedArray$c = ArrayBufferViewCore$c.aTypedArray; + var exportTypedArrayMethod$d = ArrayBufferViewCore$c.exportTypedArrayMethod; + var TypedArrayPrototype = Uint8Array$2 && Uint8Array$2.prototype; + + var GENERIC = !fails$z(function () { + TypedArrayPrototype[ITERATOR$4].call([1]); + }); - var CORRECT_ITER_NAME = !!nativeTypedArrayIterator - && (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined); + var ITERATOR_IS_VALUES = !!TypedArrayPrototype + && TypedArrayPrototype.values + && TypedArrayPrototype[ITERATOR$4] === TypedArrayPrototype.values + && TypedArrayPrototype.values.name === 'values'; var typedArrayValues = function values() { - return arrayValues.call(aTypedArray$c(this)); + return arrayValues(aTypedArray$c(this)); }; // `%TypedArray%.prototype.entries` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries exportTypedArrayMethod$d('entries', function entries() { - return arrayEntries.call(aTypedArray$c(this)); - }); + return arrayEntries(aTypedArray$c(this)); + }, GENERIC); // `%TypedArray%.prototype.keys` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys exportTypedArrayMethod$d('keys', function keys() { - return arrayKeys.call(aTypedArray$c(this)); - }); + return arrayKeys(aTypedArray$c(this)); + }, GENERIC); // `%TypedArray%.prototype.values` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.values - exportTypedArrayMethod$d('values', typedArrayValues, !CORRECT_ITER_NAME); + exportTypedArrayMethod$d('values', typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' }); // `%TypedArray%.prototype[@@iterator]` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator - exportTypedArrayMethod$d(ITERATOR$2, typedArrayValues, !CORRECT_ITER_NAME); + exportTypedArrayMethod$d(ITERATOR$4, typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' }); + + var ArrayBufferViewCore$b = arrayBufferViewCore; + var uncurryThis$y = functionUncurryThis; - var aTypedArray$b = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$c = arrayBufferViewCore.exportTypedArrayMethod; - var $join = [].join; + var aTypedArray$b = ArrayBufferViewCore$b.aTypedArray; + var exportTypedArrayMethod$c = ArrayBufferViewCore$b.exportTypedArrayMethod; + var $join = uncurryThis$y([].join); // `%TypedArray%.prototype.join` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.join - // eslint-disable-next-line no-unused-vars -- required for `.length` exportTypedArrayMethod$c('join', function join(separator) { - return $join.apply(aTypedArray$b(this), arguments); + return $join(aTypedArray$b(this), separator); }); /* eslint-disable es/no-array-prototype-lastindexof -- safe */ - - - - + var apply$6 = functionApply; + var toIndexedObject$5 = toIndexedObject$d; + var toIntegerOrInfinity$4 = toIntegerOrInfinity$b; + var lengthOfArrayLike$9 = lengthOfArrayLike$i; + var arrayMethodIsStrict$6 = arrayMethodIsStrict$9; var min$6 = Math.min; - var $lastIndexOf = [].lastIndexOf; - var NEGATIVE_ZERO = !!$lastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; - var STRICT_METHOD$5 = arrayMethodIsStrict('lastIndexOf'); - var FORCED$e = NEGATIVE_ZERO || !STRICT_METHOD$5; + var $lastIndexOf$1 = [].lastIndexOf; + var NEGATIVE_ZERO = !!$lastIndexOf$1 && 1 / [1].lastIndexOf(1, -0) < 0; + var STRICT_METHOD$6 = arrayMethodIsStrict$6('lastIndexOf'); + var FORCED$f = NEGATIVE_ZERO || !STRICT_METHOD$6; // `Array.prototype.lastIndexOf` method implementation // https://tc39.es/ecma262/#sec-array.prototype.lastindexof - var arrayLastIndexOf = FORCED$e ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + var arrayLastIndexOf = FORCED$f ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { // convert -0 to +0 - if (NEGATIVE_ZERO) return $lastIndexOf.apply(this, arguments) || 0; - var O = toIndexedObject(this); - var length = toLength(O.length); + if (NEGATIVE_ZERO) return apply$6($lastIndexOf$1, this, arguments) || 0; + var O = toIndexedObject$5(this); + var length = lengthOfArrayLike$9(O); var index = length - 1; - if (arguments.length > 1) index = min$6(index, toInteger(arguments[1])); + if (arguments.length > 1) index = min$6(index, toIntegerOrInfinity$4(arguments[1])); if (index < 0) index = length + index; for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0; return -1; - } : $lastIndexOf; + } : $lastIndexOf$1; - var aTypedArray$a = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$b = arrayBufferViewCore.exportTypedArrayMethod; + var ArrayBufferViewCore$a = arrayBufferViewCore; + var apply$5 = functionApply; + var $lastIndexOf = arrayLastIndexOf; + + var aTypedArray$a = ArrayBufferViewCore$a.aTypedArray; + var exportTypedArrayMethod$b = ArrayBufferViewCore$a.exportTypedArrayMethod; // `%TypedArray%.prototype.lastIndexOf` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof - // eslint-disable-next-line no-unused-vars -- required for `.length` exportTypedArrayMethod$b('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) { - return arrayLastIndexOf.apply(aTypedArray$a(this), arguments); + var length = arguments.length; + return apply$5($lastIndexOf, aTypedArray$a(this), length > 1 ? [searchElement, arguments[1]] : [searchElement]); }); + var ArrayBufferViewCore$9 = arrayBufferViewCore; var $map = arrayIteration.map; + var typedArraySpeciesConstructor$2 = typedArraySpeciesConstructor$4; - - var aTypedArray$9 = arrayBufferViewCore.aTypedArray; - var aTypedArrayConstructor$1 = arrayBufferViewCore.aTypedArrayConstructor; - var exportTypedArrayMethod$a = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$9 = ArrayBufferViewCore$9.aTypedArray; + var exportTypedArrayMethod$a = ArrayBufferViewCore$9.exportTypedArrayMethod; // `%TypedArray%.prototype.map` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.map exportTypedArrayMethod$a('map', function map(mapfn /* , thisArg */) { return $map(aTypedArray$9(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) { - return new (aTypedArrayConstructor$1(speciesConstructor(O, O.constructor)))(length); + return new (typedArraySpeciesConstructor$2(O))(length); }); }); + var global$t = global$1o; + var aCallable$4 = aCallable$a; + var toObject$a = toObject$i; + var IndexedObject$2 = indexedObject; + var lengthOfArrayLike$8 = lengthOfArrayLike$i; + + var TypeError$9 = global$t.TypeError; + // `Array.prototype.{ reduce, reduceRight }` methods implementation var createMethod$3 = function (IS_RIGHT) { return function (that, callbackfn, argumentsLength, memo) { - aFunction(callbackfn); - var O = toObject(that); - var self = indexedObject(O); - var length = toLength(O.length); + aCallable$4(callbackfn); + var O = toObject$a(that); + var self = IndexedObject$2(O); + var length = lengthOfArrayLike$8(O); var index = IS_RIGHT ? length - 1 : 0; var i = IS_RIGHT ? -1 : 1; if (argumentsLength < 2) while (true) { @@ -3778,7 +5106,7 @@ } index += i; if (IS_RIGHT ? index < 0 : length <= index) { - throw TypeError('Reduce of empty array with no initial value'); + throw TypeError$9('Reduce of empty array with no initial value'); } } for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) { @@ -3797,30 +5125,36 @@ right: createMethod$3(true) }; + var ArrayBufferViewCore$8 = arrayBufferViewCore; var $reduce$1 = arrayReduce.left; - var aTypedArray$8 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$9 = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$8 = ArrayBufferViewCore$8.aTypedArray; + var exportTypedArrayMethod$9 = ArrayBufferViewCore$8.exportTypedArrayMethod; // `%TypedArray%.prototype.reduce` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce exportTypedArrayMethod$9('reduce', function reduce(callbackfn /* , initialValue */) { - return $reduce$1(aTypedArray$8(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + var length = arguments.length; + return $reduce$1(aTypedArray$8(this), callbackfn, length, length > 1 ? arguments[1] : undefined); }); - var $reduceRight = arrayReduce.right; + var ArrayBufferViewCore$7 = arrayBufferViewCore; + var $reduceRight$1 = arrayReduce.right; - var aTypedArray$7 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$8 = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$7 = ArrayBufferViewCore$7.aTypedArray; + var exportTypedArrayMethod$8 = ArrayBufferViewCore$7.exportTypedArrayMethod; // `%TypedArray%.prototype.reduceRicht` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright exportTypedArrayMethod$8('reduceRight', function reduceRight(callbackfn /* , initialValue */) { - return $reduceRight(aTypedArray$7(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + var length = arguments.length; + return $reduceRight$1(aTypedArray$7(this), callbackfn, length, length > 1 ? arguments[1] : undefined); }); - var aTypedArray$6 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$7 = arrayBufferViewCore.exportTypedArrayMethod; + var ArrayBufferViewCore$6 = arrayBufferViewCore; + + var aTypedArray$6 = ArrayBufferViewCore$6.aTypedArray; + var exportTypedArrayMethod$7 = ArrayBufferViewCore$6.exportTypedArrayMethod; var floor$5 = Math.floor; // `%TypedArray%.prototype.reverse` method @@ -3838,12 +5172,34 @@ } return that; }); - var aTypedArray$5 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$6 = arrayBufferViewCore.exportTypedArrayMethod; - - var FORCED$d = fails(function () { + var global$s = global$1o; + var call$a = functionCall; + var ArrayBufferViewCore$5 = arrayBufferViewCore; + var lengthOfArrayLike$7 = lengthOfArrayLike$i; + var toOffset = toOffset$2; + var toIndexedObject$4 = toObject$i; + var fails$y = fails$V; + + var RangeError$6 = global$s.RangeError; + var Int8Array$2 = global$s.Int8Array; + var Int8ArrayPrototype = Int8Array$2 && Int8Array$2.prototype; + var $set = Int8ArrayPrototype && Int8ArrayPrototype.set; + var aTypedArray$5 = ArrayBufferViewCore$5.aTypedArray; + var exportTypedArrayMethod$6 = ArrayBufferViewCore$5.exportTypedArrayMethod; + + var WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS = !fails$y(function () { // eslint-disable-next-line es/no-typed-arrays -- required for testing - new Int8Array(1).set({}); + var array = new Uint8ClampedArray(2); + call$a($set, array, { length: 1, 0: 3 }, 1); + return array[1] !== 3; + }); + + // https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other + var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore$5.NATIVE_ARRAY_BUFFER_VIEWS && fails$y(function () { + var array = new Int8Array$2(2); + array.set(1); + array.set('2', 1); + return array[0] !== 0 || array[1] !== 2; }); // `%TypedArray%.prototype.set` method @@ -3851,20 +5207,24 @@ exportTypedArrayMethod$6('set', function set(arrayLike /* , offset */) { aTypedArray$5(this); var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1); + var src = toIndexedObject$4(arrayLike); + if (WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS) return call$a($set, this, src, offset); var length = this.length; - var src = toObject(arrayLike); - var len = toLength(src.length); + var len = lengthOfArrayLike$7(src); var index = 0; - if (len + offset > length) throw RangeError('Wrong length'); + if (len + offset > length) throw RangeError$6('Wrong length'); while (index < len) this[offset + index] = src[index++]; - }, FORCED$d); + }, !WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG); + + var ArrayBufferViewCore$4 = arrayBufferViewCore; + var typedArraySpeciesConstructor$1 = typedArraySpeciesConstructor$4; + var fails$x = fails$V; + var arraySlice$7 = arraySlice$b; - var aTypedArray$4 = arrayBufferViewCore.aTypedArray; - var aTypedArrayConstructor = arrayBufferViewCore.aTypedArrayConstructor; - var exportTypedArrayMethod$5 = arrayBufferViewCore.exportTypedArrayMethod; - var $slice$1 = [].slice; + var aTypedArray$4 = ArrayBufferViewCore$4.aTypedArray; + var exportTypedArrayMethod$5 = ArrayBufferViewCore$4.exportTypedArrayMethod; - var FORCED$c = fails(function () { + var FORCED$e = fails$x(function () { // eslint-disable-next-line es/no-typed-arrays -- required for testing new Int8Array(1).slice(); }); @@ -3872,19 +5232,20 @@ // `%TypedArray%.prototype.slice` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice exportTypedArrayMethod$5('slice', function slice(start, end) { - var list = $slice$1.call(aTypedArray$4(this), start, end); - var C = speciesConstructor(this, this.constructor); + var list = arraySlice$7(aTypedArray$4(this), start, end); + var C = typedArraySpeciesConstructor$1(this); var index = 0; var length = list.length; - var result = new (aTypedArrayConstructor(C))(length); + var result = new C(length); while (length > index) result[index] = list[index++]; return result; - }, FORCED$c); + }, FORCED$e); + var ArrayBufferViewCore$3 = arrayBufferViewCore; var $some$1 = arrayIteration.some; - var aTypedArray$3 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$4 = arrayBufferViewCore.exportTypedArrayMethod; + var aTypedArray$3 = ArrayBufferViewCore$3.aTypedArray; + var exportTypedArrayMethod$4 = ArrayBufferViewCore$3.exportTypedArrayMethod; // `%TypedArray%.prototype.some` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.some @@ -3892,15 +5253,17 @@ return $some$1(aTypedArray$3(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); }); - // TODO: use something more complex like timsort? + var arraySlice$6 = arraySliceSimple; + var floor$4 = Math.floor; var mergeSort = function (array, comparefn) { var length = array.length; var middle = floor$4(length / 2); return length < 8 ? insertionSort(array, comparefn) : merge$5( - mergeSort(array.slice(0, middle), comparefn), - mergeSort(array.slice(middle), comparefn), + array, + mergeSort(arraySlice$6(array, 0, middle), comparefn), + mergeSort(arraySlice$6(array, middle), comparefn), comparefn ); }; @@ -3920,55 +5283,70 @@ } return array; }; - var merge$5 = function (left, right, comparefn) { + var merge$5 = function (array, left, right, comparefn) { var llength = left.length; var rlength = right.length; var lindex = 0; var rindex = 0; - var result = []; while (lindex < llength || rindex < rlength) { - if (lindex < llength && rindex < rlength) { - result.push(comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]); - } else { - result.push(lindex < llength ? left[lindex++] : right[rindex++]); - } - } return result; + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } return array; }; - var arraySort = mergeSort; + var arraySort$1 = mergeSort; + + var userAgent$3 = engineUserAgent; - var firefox = engineUserAgent.match(/firefox\/(\d+)/i); + var firefox = userAgent$3.match(/firefox\/(\d+)/i); var engineFfVersion = !!firefox && +firefox[1]; - var engineIsIeOrEdge = /MSIE|Trident/.test(engineUserAgent); + var UA = engineUserAgent; - var webkit = engineUserAgent.match(/AppleWebKit\/(\d+)\./); + var engineIsIeOrEdge = /MSIE|Trident/.test(UA); + + var userAgent$2 = engineUserAgent; + + var webkit = userAgent$2.match(/AppleWebKit\/(\d+)\./); var engineWebkitVersion = !!webkit && +webkit[1]; - var aTypedArray$2 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$3 = arrayBufferViewCore.exportTypedArrayMethod; - var Uint16Array = global$2.Uint16Array; - var nativeSort$1 = Uint16Array && Uint16Array.prototype.sort; + var global$r = global$1o; + var uncurryThis$x = functionUncurryThis; + var fails$w = fails$V; + var aCallable$3 = aCallable$a; + var internalSort$1 = arraySort$1; + var ArrayBufferViewCore$2 = arrayBufferViewCore; + var FF$1 = engineFfVersion; + var IE_OR_EDGE$1 = engineIsIeOrEdge; + var V8$1 = engineV8Version; + var WEBKIT$1 = engineWebkitVersion; + + var Array$3 = global$r.Array; + var aTypedArray$2 = ArrayBufferViewCore$2.aTypedArray; + var exportTypedArrayMethod$3 = ArrayBufferViewCore$2.exportTypedArrayMethod; + var Uint16Array = global$r.Uint16Array; + var un$Sort$1 = Uint16Array && uncurryThis$x(Uint16Array.prototype.sort); // WebKit - var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort$1 && !fails(function () { - var array = new Uint16Array(2); - array.sort(null); - array.sort({}); - }); + var ACCEPT_INCORRECT_ARGUMENTS = !!un$Sort$1 && !(fails$w(function () { + un$Sort$1(new Uint16Array(2), null); + }) && fails$w(function () { + un$Sort$1(new Uint16Array(2), {}); + })); - var STABLE_SORT$1 = !!nativeSort$1 && !fails(function () { + var STABLE_SORT$1 = !!un$Sort$1 && !fails$w(function () { // feature detection can be too slow, so check engines versions - if (engineV8Version) return engineV8Version < 74; - if (engineFfVersion) return engineFfVersion < 67; - if (engineIsIeOrEdge) return true; - if (engineWebkitVersion) return engineWebkitVersion < 602; + if (V8$1) return V8$1 < 74; + if (FF$1) return FF$1 < 67; + if (IE_OR_EDGE$1) return true; + if (WEBKIT$1) return WEBKIT$1 < 602; var array = new Uint16Array(516); - var expected = Array(516); + var expected = Array$3(516); var index, mod; for (index = 0; index < 516; index++) { @@ -3977,7 +5355,7 @@ expected[index] = index - 2 * mod + 3; } - array.sort(function (a, b) { + un$Sort$1(array, function (a, b) { return (a / 4 | 0) - (b / 4 | 0); }); @@ -4001,79 +5379,79 @@ // `%TypedArray%.prototype.sort` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort exportTypedArrayMethod$3('sort', function sort(comparefn) { - var array = this; - if (comparefn !== undefined) aFunction(comparefn); - if (STABLE_SORT$1) return nativeSort$1.call(array, comparefn); - - aTypedArray$2(array); - var arrayLength = toLength(array.length); - var items = Array(arrayLength); - var index; - - for (index = 0; index < arrayLength; index++) { - items[index] = array[index]; - } - - items = arraySort(array, getSortCompare$1(comparefn)); - - for (index = 0; index < arrayLength; index++) { - array[index] = items[index]; - } + if (comparefn !== undefined) aCallable$3(comparefn); + if (STABLE_SORT$1) return un$Sort$1(this, comparefn); - return array; + return internalSort$1(aTypedArray$2(this), getSortCompare$1(comparefn)); }, !STABLE_SORT$1 || ACCEPT_INCORRECT_ARGUMENTS); - var aTypedArray$1 = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$2 = arrayBufferViewCore.exportTypedArrayMethod; + var ArrayBufferViewCore$1 = arrayBufferViewCore; + var toLength$6 = toLength$c; + var toAbsoluteIndex$3 = toAbsoluteIndex$9; + var typedArraySpeciesConstructor = typedArraySpeciesConstructor$4; + + var aTypedArray$1 = ArrayBufferViewCore$1.aTypedArray; + var exportTypedArrayMethod$2 = ArrayBufferViewCore$1.exportTypedArrayMethod; // `%TypedArray%.prototype.subarray` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray exportTypedArrayMethod$2('subarray', function subarray(begin, end) { var O = aTypedArray$1(this); var length = O.length; - var beginIndex = toAbsoluteIndex(begin, length); - return new (speciesConstructor(O, O.constructor))( + var beginIndex = toAbsoluteIndex$3(begin, length); + var C = typedArraySpeciesConstructor(O); + return new C( O.buffer, O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, - toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) + toLength$6((end === undefined ? length : toAbsoluteIndex$3(end, length)) - beginIndex) ); }); - var Int8Array$1 = global$2.Int8Array; - var aTypedArray = arrayBufferViewCore.aTypedArray; - var exportTypedArrayMethod$1 = arrayBufferViewCore.exportTypedArrayMethod; + var global$q = global$1o; + var apply$4 = functionApply; + var ArrayBufferViewCore = arrayBufferViewCore; + var fails$v = fails$V; + var arraySlice$5 = arraySlice$b; + + var Int8Array$1 = global$q.Int8Array; + var aTypedArray = ArrayBufferViewCore.aTypedArray; + var exportTypedArrayMethod$1 = ArrayBufferViewCore.exportTypedArrayMethod; var $toLocaleString = [].toLocaleString; - var $slice = [].slice; // iOS Safari 6.x fails here - var TO_LOCALE_STRING_BUG = !!Int8Array$1 && fails(function () { + var TO_LOCALE_STRING_BUG = !!Int8Array$1 && fails$v(function () { $toLocaleString.call(new Int8Array$1(1)); }); - var FORCED$b = fails(function () { + var FORCED$d = fails$v(function () { return [1, 2].toLocaleString() != new Int8Array$1([1, 2]).toLocaleString(); - }) || !fails(function () { + }) || !fails$v(function () { Int8Array$1.prototype.toLocaleString.call([1, 2]); }); // `%TypedArray%.prototype.toLocaleString` method // https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring exportTypedArrayMethod$1('toLocaleString', function toLocaleString() { - return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments); - }, FORCED$b); + return apply$4( + $toLocaleString, + TO_LOCALE_STRING_BUG ? arraySlice$5(aTypedArray(this)) : aTypedArray(this), + arraySlice$5(arguments) + ); + }, FORCED$d); var exportTypedArrayMethod = arrayBufferViewCore.exportTypedArrayMethod; + var fails$u = fails$V; + var global$p = global$1o; + var uncurryThis$w = functionUncurryThis; - - - var Uint8Array$1 = global$2.Uint8Array; + var Uint8Array$1 = global$p.Uint8Array; var Uint8ArrayPrototype = Uint8Array$1 && Uint8Array$1.prototype || {}; var arrayToString = [].toString; - var arrayJoin = [].join; + var join$5 = uncurryThis$w([].join); - if (fails(function () { arrayToString.call({}); })) { + if (fails$u(function () { arrayToString.call({}); })) { arrayToString = function toString() { - return arrayJoin.call(this); + return join$5(this); }; } @@ -4083,65 +5461,83 @@ // https://tc39.es/ecma262/#sec-%typedarray%.prototype.tostring exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD); - var nativeJoin = [].join; + var $$Z = _export; + var uncurryThis$v = functionUncurryThis; + var IndexedObject$1 = indexedObject; + var toIndexedObject$3 = toIndexedObject$d; + var arrayMethodIsStrict$5 = arrayMethodIsStrict$9; + + var un$Join = uncurryThis$v([].join); - var ES3_STRINGS = indexedObject != Object; - var STRICT_METHOD$4 = arrayMethodIsStrict('join', ','); + var ES3_STRINGS = IndexedObject$1 != Object; + var STRICT_METHOD$5 = arrayMethodIsStrict$5('join', ','); // `Array.prototype.join` method // https://tc39.es/ecma262/#sec-array.prototype.join - _export({ target: 'Array', proto: true, forced: ES3_STRINGS || !STRICT_METHOD$4 }, { + $$Z({ target: 'Array', proto: true, forced: ES3_STRINGS || !STRICT_METHOD$5 }, { join: function join(separator) { - return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator); + return un$Join(toIndexedObject$3(this), separator === undefined ? ',' : separator); } }); - var createProperty = function (object, key, value) { - var propertyKey = toPrimitive(key); - if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value)); - else object[propertyKey] = value; - }; - - var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport('slice'); - - var SPECIES$1 = wellKnownSymbol('species'); - var nativeSlice = [].slice; + var $$Y = _export; + var global$o = global$1o; + var isArray$4 = isArray$8; + var isConstructor$1 = isConstructor$4; + var isObject$e = isObject$s; + var toAbsoluteIndex$2 = toAbsoluteIndex$9; + var lengthOfArrayLike$6 = lengthOfArrayLike$i; + var toIndexedObject$2 = toIndexedObject$d; + var createProperty$3 = createProperty$5; + var wellKnownSymbol$8 = wellKnownSymbol$t; + var arrayMethodHasSpeciesSupport$3 = arrayMethodHasSpeciesSupport$5; + var un$Slice = arraySlice$b; + + var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport$3('slice'); + + var SPECIES$1 = wellKnownSymbol$8('species'); + var Array$2 = global$o.Array; var max$3 = Math.max; // `Array.prototype.slice` method // https://tc39.es/ecma262/#sec-array.prototype.slice // fallback for not array-like ES3 strings and DOM objects - _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + $$Y({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { slice: function slice(start, end) { - var O = toIndexedObject(this); - var length = toLength(O.length); - var k = toAbsoluteIndex(start, length); - var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var O = toIndexedObject$2(this); + var length = lengthOfArrayLike$6(O); + var k = toAbsoluteIndex$2(start, length); + var fin = toAbsoluteIndex$2(end === undefined ? length : end, length); // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible var Constructor, result, n; - if (isArray(O)) { + if (isArray$4(O)) { Constructor = O.constructor; // cross-realm fallback - if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { + if (isConstructor$1(Constructor) && (Constructor === Array$2 || isArray$4(Constructor.prototype))) { Constructor = undefined; - } else if (isObject$4(Constructor)) { + } else if (isObject$e(Constructor)) { Constructor = Constructor[SPECIES$1]; if (Constructor === null) Constructor = undefined; } - if (Constructor === Array || Constructor === undefined) { - return nativeSlice.call(O, k, fin); + if (Constructor === Array$2 || Constructor === undefined) { + return un$Slice(O, k, fin); } } - result = new (Constructor === undefined ? Array : Constructor)(max$3(fin - k, 0)); - for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + result = new (Constructor === undefined ? Array$2 : Constructor)(max$3(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty$3(result, n, O[k]); result.length = n; return result; } }); - var ITERATOR$1 = wellKnownSymbol('iterator'); + var fails$t = fails$V; + var wellKnownSymbol$7 = wellKnownSymbol$t; + var IS_PURE = isPure; - var nativeUrl = !fails(function () { + var ITERATOR$3 = wellKnownSymbol$7('iterator'); + + var nativeUrl = !fails$t(function () { + // eslint-disable-next-line unicorn/relative-url-style -- required for testing var url = new URL('b?a=1&b=2&c=3', 'http://a'); var searchParams = url.searchParams; var result = ''; @@ -4150,12 +5546,12 @@ searchParams['delete']('b'); result += key + value; }); - return (isPure && !url.toJSON) + return (IS_PURE && !url.toJSON) || !searchParams.sort || url.href !== 'http://a/c%20d?a=1&c=3' || searchParams.get('c') !== '3' || String(new URLSearchParams('?a=1')) !== 'a=1' - || !searchParams[ITERATOR$1] + || !searchParams[ITERATOR$3] // throws in Edge || new URL('https://a@b').username !== 'a' || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' @@ -4169,324 +5565,83 @@ || new URL('http://x', undefined).host !== 'x'; }); - // eslint-disable-next-line es/no-object-assign -- safe - var $assign = Object.assign; - // eslint-disable-next-line es/no-object-defineproperty -- required for testing - var defineProperty$4 = Object.defineProperty; - - // `Object.assign` method - // https://tc39.es/ecma262/#sec-object.assign - var objectAssign = !$assign || fails(function () { - // should have correct order of operations (Edge bug) - if (descriptors && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { - enumerable: true, - get: function () { - defineProperty$4(this, 'b', { - value: 3, - enumerable: false - }); - } - }), { b: 2 })).b !== 1) return true; - // should work with symbols and should have deterministic property order (V8 bug) - var A = {}; - var B = {}; - // eslint-disable-next-line es/no-symbol -- safe - var symbol = Symbol(); - var alphabet = 'abcdefghijklmnopqrst'; - A[symbol] = 7; - alphabet.split('').forEach(function (chr) { B[chr] = chr; }); - return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet; - }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` - var T = toObject(target); - var argumentsLength = arguments.length; - var index = 1; - var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; - var propertyIsEnumerable = objectPropertyIsEnumerable.f; - while (argumentsLength > index) { - var S = indexedObject(arguments[index++]); - var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); - var length = keys.length; - var j = 0; - var key; - while (length > j) { - key = keys[j++]; - if (!descriptors || propertyIsEnumerable.call(S, key)) T[key] = S[key]; - } - } return T; - } : $assign; - - // call something on iterator step with safe closing on error - var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) { - try { - return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); - } catch (error) { - iteratorClose(iterator); - throw error; - } - }; - - // `Array.from` method implementation - // https://tc39.es/ecma262/#sec-array.from - var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { - var O = toObject(arrayLike); - var C = typeof this == 'function' ? this : Array; - var argumentsLength = arguments.length; - var mapfn = argumentsLength > 1 ? arguments[1] : undefined; - var mapping = mapfn !== undefined; - var iteratorMethod = getIteratorMethod(O); - var index = 0; - var length, result, step, iterator, next, value; - if (mapping) mapfn = functionBindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2); - // if the target is not iterable or it's an array with the default iterator - use a simple case - if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { - iterator = iteratorMethod.call(O); - next = iterator.next; - result = new C(); - for (;!(step = next.call(iterator)).done; index++) { - value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; - createProperty(result, index, value); - } - } else { - length = toLength(O.length); - result = new C(length); - for (;length > index; index++) { - value = mapping ? mapfn(O[index], index) : O[index]; - createProperty(result, index, value); - } - } - result.length = index; - return result; - }; - - // based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js - var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1 - var base = 36; - var tMin = 1; - var tMax = 26; - var skew = 38; - var damp = 700; - var initialBias = 72; - var initialN = 128; // 0x80 - var delimiter = '-'; // '\x2D' - var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars - var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators - var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process'; - var baseMinusTMin = base - tMin; - var floor$3 = Math.floor; - var stringFromCharCode = String.fromCharCode; - - /** - * Creates an array containing the numeric code points of each Unicode - * character in the string. While JavaScript uses UCS-2 internally, - * this function will convert a pair of surrogate halves (each of which - * UCS-2 exposes as separate characters) into a single code point, - * matching UTF-16. - */ - var ucs2decode = function (string) { - var output = []; - var counter = 0; - var length = string.length; - while (counter < length) { - var value = string.charCodeAt(counter++); - if (value >= 0xD800 && value <= 0xDBFF && counter < length) { - // It's a high surrogate, and there is a next character. - var extra = string.charCodeAt(counter++); - if ((extra & 0xFC00) == 0xDC00) { // Low surrogate. - output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); - } else { - // It's an unmatched surrogate; only append this code unit, in case the - // next code unit is the high surrogate of a surrogate pair. - output.push(value); - counter--; - } - } else { - output.push(value); - } - } - return output; - }; - - /** - * Converts a digit/integer into a basic code point. - */ - var digitToBasic = function (digit) { - // 0..25 map to ASCII a..z or A..Z - // 26..35 map to ASCII 0..9 - return digit + 22 + 75 * (digit < 26); - }; - - /** - * Bias adaptation function as per section 3.4 of RFC 3492. - * https://tools.ietf.org/html/rfc3492#section-3.4 - */ - var adapt = function (delta, numPoints, firstTime) { - var k = 0; - delta = firstTime ? floor$3(delta / damp) : delta >> 1; - delta += floor$3(delta / numPoints); - for (; delta > baseMinusTMin * tMax >> 1; k += base) { - delta = floor$3(delta / baseMinusTMin); - } - return floor$3(k + (baseMinusTMin + 1) * delta / (delta + skew)); - }; - - /** - * Converts a string of Unicode symbols (e.g. a domain name label) to a - * Punycode string of ASCII-only symbols. - */ - // eslint-disable-next-line max-statements -- TODO - var encode = function (input) { - var output = []; - - // Convert the input in UCS-2 to an array of Unicode code points. - input = ucs2decode(input); - - // Cache the length. - var inputLength = input.length; - - // Initialize the state. - var n = initialN; - var delta = 0; - var bias = initialBias; - var i, currentValue; - - // Handle the basic code points. - for (i = 0; i < input.length; i++) { - currentValue = input[i]; - if (currentValue < 0x80) { - output.push(stringFromCharCode(currentValue)); - } - } - - var basicLength = output.length; // number of basic code points. - var handledCPCount = basicLength; // number of code points that have been handled; - - // Finish the basic string with a delimiter unless it's empty. - if (basicLength) { - output.push(delimiter); - } - - // Main encoding loop: - while (handledCPCount < inputLength) { - // All non-basic code points < n have been handled already. Find the next larger one: - var m = maxInt; - for (i = 0; i < input.length; i++) { - currentValue = input[i]; - if (currentValue >= n && currentValue < m) { - m = currentValue; - } - } - - // Increase `delta` enough to advance the decoder's state to , but guard against overflow. - var handledCPCountPlusOne = handledCPCount + 1; - if (m - n > floor$3((maxInt - delta) / handledCPCountPlusOne)) { - throw RangeError(OVERFLOW_ERROR); - } - - delta += (m - n) * handledCPCountPlusOne; - n = m; - - for (i = 0; i < input.length; i++) { - currentValue = input[i]; - if (currentValue < n && ++delta > maxInt) { - throw RangeError(OVERFLOW_ERROR); - } - if (currentValue == n) { - // Represent delta as a generalized variable-length integer. - var q = delta; - for (var k = base; /* no condition */; k += base) { - var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); - if (q < t) break; - var qMinusT = q - t; - var baseMinusT = base - t; - output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT))); - q = floor$3(qMinusT / baseMinusT); - } - - output.push(stringFromCharCode(digitToBasic(q))); - bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); - delta = 0; - ++handledCPCount; - } - } - - ++delta; - ++n; - } - return output.join(''); - }; - - var stringPunycodeToAscii = function (input) { - var encoded = []; - var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.'); - var i, label; - for (i = 0; i < labels.length; i++) { - label = labels[i]; - encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label); - } - return encoded.join('.'); - }; - - var getIterator = function (it) { - var iteratorMethod = getIteratorMethod(it); - if (typeof iteratorMethod != 'function') { - throw TypeError(String(it) + ' is not iterable'); - } return anObject(iteratorMethod.call(it)); - }; - // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` - - - - - - - - - - - - - - - - - - - - - var $fetch = getBuiltIn('fetch'); - var Headers$1 = getBuiltIn('Headers'); - var ITERATOR = wellKnownSymbol('iterator'); + var $$X = _export; + var global$n = global$1o; + var getBuiltIn$2 = getBuiltIn$b; + var call$9 = functionCall; + var uncurryThis$u = functionUncurryThis; + var USE_NATIVE_URL$1 = nativeUrl; + var redefine$7 = redefine$h.exports; + var redefineAll$1 = redefineAll$4; + var setToStringTag$4 = setToStringTag$a; + var createIteratorConstructor = createIteratorConstructor$2; + var InternalStateModule$2 = internalState; + var anInstance$3 = anInstance$7; + var isCallable$5 = isCallable$r; + var hasOwn$6 = hasOwnProperty_1; + var bind$8 = functionBindContext; + var classof$3 = classof$d; + var anObject$9 = anObject$n; + var isObject$d = isObject$s; + var $toString$2 = toString$k; + var create$6 = objectCreate; + var createPropertyDescriptor = createPropertyDescriptor$7; + var getIterator$1 = getIterator$4; + var getIteratorMethod$1 = getIteratorMethod$5; + var validateArgumentsLength$2 = validateArgumentsLength$4; + var wellKnownSymbol$6 = wellKnownSymbol$t; + var arraySort = arraySort$1; + + var ITERATOR$2 = wellKnownSymbol$6('iterator'); var URL_SEARCH_PARAMS = 'URLSearchParams'; var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator'; - var setInternalState$2 = internalState.set; - var getInternalParamsState = internalState.getterFor(URL_SEARCH_PARAMS); - var getInternalIteratorState = internalState.getterFor(URL_SEARCH_PARAMS_ITERATOR); + var setInternalState$2 = InternalStateModule$2.set; + var getInternalParamsState = InternalStateModule$2.getterFor(URL_SEARCH_PARAMS); + var getInternalIteratorState = InternalStateModule$2.getterFor(URL_SEARCH_PARAMS_ITERATOR); + + var n$Fetch = getBuiltIn$2('fetch'); + var N$Request = getBuiltIn$2('Request'); + var Headers$1 = getBuiltIn$2('Headers'); + var RequestPrototype = N$Request && N$Request.prototype; + var HeadersPrototype = Headers$1 && Headers$1.prototype; + var RegExp$1 = global$n.RegExp; + var TypeError$8 = global$n.TypeError; + var decodeURIComponent$1 = global$n.decodeURIComponent; + var encodeURIComponent$1 = global$n.encodeURIComponent; + var charAt$5 = uncurryThis$u(''.charAt); + var join$4 = uncurryThis$u([].join); + var push$7 = uncurryThis$u([].push); + var replace$6 = uncurryThis$u(''.replace); + var shift$1 = uncurryThis$u([].shift); + var splice = uncurryThis$u([].splice); + var split$3 = uncurryThis$u(''.split); + var stringSlice$8 = uncurryThis$u(''.slice); var plus = /\+/g; var sequences = Array(4); var percentSequence = function (bytes) { - return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi')); + return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp$1('((?:%[\\da-f]{2}){' + bytes + '})', 'gi')); }; var percentDecode = function (sequence) { try { - return decodeURIComponent(sequence); + return decodeURIComponent$1(sequence); } catch (error) { return sequence; } }; var deserialize = function (it) { - var result = it.replace(plus, ' '); + var result = replace$6(it, plus, ' '); var bytes = 4; try { - return decodeURIComponent(result); + return decodeURIComponent$1(result); } catch (error) { while (bytes) { - result = result.replace(percentSequence(bytes--), percentDecode); + result = replace$6(result, percentSequence(bytes--), percentDecode); } return result; } @@ -4494,7 +5649,7 @@ var find$1 = /[!'()~]|%20/g; - var replace$1 = { + var replacements = { '!': '%21', "'": '%27', '(': '%28', @@ -4504,44 +5659,17 @@ }; var replacer = function (match) { - return replace$1[match]; + return replacements[match]; }; var serialize = function (it) { - return encodeURIComponent(it).replace(find$1, replacer); - }; - - var parseSearchParams = function (result, query) { - if (query) { - var attributes = query.split('&'); - var index = 0; - var attribute, entry; - while (index < attributes.length) { - attribute = attributes[index++]; - if (attribute.length) { - entry = attribute.split('='); - result.push({ - key: deserialize(entry.shift()), - value: deserialize(entry.join('=')) - }); - } - } - } - }; - - var updateSearchParams = function (query) { - this.entries.length = 0; - parseSearchParams(this.entries, query); - }; - - var validateArgumentsLength = function (passed, required) { - if (passed < required) throw TypeError('Not enough arguments'); + return replace$6(encodeURIComponent$1(it), find$1, replacer); }; var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) { setInternalState$2(this, { type: URL_SEARCH_PARAMS_ITERATOR, - iterator: getIterator(getInternalParamsState(params).entries), + iterator: getIterator$1(getInternalParamsState(params).entries), kind: kind }); }, 'Iterator', function next() { @@ -4552,68 +5680,110 @@ if (!step.done) { step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value]; } return step; - }); + }, true); - // `URLSearchParams` constructor - // https://url.spec.whatwg.org/#interface-urlsearchparams - var URLSearchParamsConstructor = function URLSearchParams(/* init */) { - anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS); - var init = arguments.length > 0 ? arguments[0] : undefined; - var that = this; - var entries = []; - var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key; - - setInternalState$2(that, { - type: URL_SEARCH_PARAMS, - entries: entries, - updateURL: function () { /* empty */ }, - updateSearchParams: updateSearchParams - }); + var URLSearchParamsState = function (init) { + this.entries = []; + this.url = null; if (init !== undefined) { - if (isObject$4(init)) { - iteratorMethod = getIteratorMethod(init); - if (typeof iteratorMethod === 'function') { - iterator = iteratorMethod.call(init); - next = iterator.next; - while (!(step = next.call(iterator)).done) { - entryIterator = getIterator(anObject(step.value)); - entryNext = entryIterator.next; - if ( - (first = entryNext.call(entryIterator)).done || - (second = entryNext.call(entryIterator)).done || - !entryNext.call(entryIterator).done - ) throw TypeError('Expected sequence with length 2'); - entries.push({ key: first.value + '', value: second.value + '' }); + if (isObject$d(init)) this.parseObject(init); + else this.parseQuery(typeof init == 'string' ? charAt$5(init, 0) === '?' ? stringSlice$8(init, 1) : init : $toString$2(init)); + } + }; + + URLSearchParamsState.prototype = { + type: URL_SEARCH_PARAMS, + bindURL: function (url) { + this.url = url; + this.update(); + }, + parseObject: function (object) { + var iteratorMethod = getIteratorMethod$1(object); + var iterator, next, step, entryIterator, entryNext, first, second; + + if (iteratorMethod) { + iterator = getIterator$1(object, iteratorMethod); + next = iterator.next; + while (!(step = call$9(next, iterator)).done) { + entryIterator = getIterator$1(anObject$9(step.value)); + entryNext = entryIterator.next; + if ( + (first = call$9(entryNext, entryIterator)).done || + (second = call$9(entryNext, entryIterator)).done || + !call$9(entryNext, entryIterator).done + ) throw TypeError$8('Expected sequence with length 2'); + push$7(this.entries, { key: $toString$2(first.value), value: $toString$2(second.value) }); + } + } else for (var key in object) if (hasOwn$6(object, key)) { + push$7(this.entries, { key: key, value: $toString$2(object[key]) }); + } + }, + parseQuery: function (query) { + if (query) { + var attributes = split$3(query, '&'); + var index = 0; + var attribute, entry; + while (index < attributes.length) { + attribute = attributes[index++]; + if (attribute.length) { + entry = split$3(attribute, '='); + push$7(this.entries, { + key: deserialize(shift$1(entry)), + value: deserialize(join$4(entry, '=')) + }); } - } else for (key in init) if (has$1(init, key)) entries.push({ key: key, value: init[key] + '' }); - } else { - parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + ''); + } } + }, + serialize: function () { + var entries = this.entries; + var result = []; + var index = 0; + var entry; + while (index < entries.length) { + entry = entries[index++]; + push$7(result, serialize(entry.key) + '=' + serialize(entry.value)); + } return join$4(result, '&'); + }, + update: function () { + this.entries.length = 0; + this.parseQuery(this.url.query); + }, + updateURL: function () { + if (this.url) this.url.update(); } }; + // `URLSearchParams` constructor + // https://url.spec.whatwg.org/#interface-urlsearchparams + var URLSearchParamsConstructor = function URLSearchParams(/* init */) { + anInstance$3(this, URLSearchParamsPrototype); + var init = arguments.length > 0 ? arguments[0] : undefined; + setInternalState$2(this, new URLSearchParamsState(init)); + }; + var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype; - redefineAll(URLSearchParamsPrototype, { + redefineAll$1(URLSearchParamsPrototype, { // `URLSearchParams.prototype.append` method // https://url.spec.whatwg.org/#dom-urlsearchparams-append append: function append(name, value) { - validateArgumentsLength(arguments.length, 2); + validateArgumentsLength$2(arguments.length, 2); var state = getInternalParamsState(this); - state.entries.push({ key: name + '', value: value + '' }); + push$7(state.entries, { key: $toString$2(name), value: $toString$2(value) }); state.updateURL(); }, // `URLSearchParams.prototype.delete` method // https://url.spec.whatwg.org/#dom-urlsearchparams-delete 'delete': function (name) { - validateArgumentsLength(arguments.length, 1); + validateArgumentsLength$2(arguments.length, 1); var state = getInternalParamsState(this); var entries = state.entries; - var key = name + ''; + var key = $toString$2(name); var index = 0; while (index < entries.length) { - if (entries[index].key === key) entries.splice(index, 1); + if (entries[index].key === key) splice(entries, index, 1); else index++; } state.updateURL(); @@ -4621,9 +5791,9 @@ // `URLSearchParams.prototype.get` method // https://url.spec.whatwg.org/#dom-urlsearchparams-get get: function get(name) { - validateArgumentsLength(arguments.length, 1); + validateArgumentsLength$2(arguments.length, 1); var entries = getInternalParamsState(this).entries; - var key = name + ''; + var key = $toString$2(name); var index = 0; for (; index < entries.length; index++) { if (entries[index].key === key) return entries[index].value; @@ -4633,22 +5803,22 @@ // `URLSearchParams.prototype.getAll` method // https://url.spec.whatwg.org/#dom-urlsearchparams-getall getAll: function getAll(name) { - validateArgumentsLength(arguments.length, 1); + validateArgumentsLength$2(arguments.length, 1); var entries = getInternalParamsState(this).entries; - var key = name + ''; + var key = $toString$2(name); var result = []; var index = 0; for (; index < entries.length; index++) { - if (entries[index].key === key) result.push(entries[index].value); + if (entries[index].key === key) push$7(result, entries[index].value); } return result; }, // `URLSearchParams.prototype.has` method // https://url.spec.whatwg.org/#dom-urlsearchparams-has has: function has(name) { - validateArgumentsLength(arguments.length, 1); + validateArgumentsLength$2(arguments.length, 1); var entries = getInternalParamsState(this).entries; - var key = name + ''; + var key = $toString$2(name); var index = 0; while (index < entries.length) { if (entries[index++].key === key) return true; @@ -4658,52 +5828,40 @@ // `URLSearchParams.prototype.set` method // https://url.spec.whatwg.org/#dom-urlsearchparams-set set: function set(name, value) { - validateArgumentsLength(arguments.length, 1); + validateArgumentsLength$2(arguments.length, 1); var state = getInternalParamsState(this); var entries = state.entries; var found = false; - var key = name + ''; - var val = value + ''; + var key = $toString$2(name); + var val = $toString$2(value); var index = 0; var entry; for (; index < entries.length; index++) { entry = entries[index]; if (entry.key === key) { - if (found) entries.splice(index--, 1); + if (found) splice(entries, index--, 1); else { found = true; entry.value = val; } } } - if (!found) entries.push({ key: key, value: val }); + if (!found) push$7(entries, { key: key, value: val }); state.updateURL(); }, // `URLSearchParams.prototype.sort` method // https://url.spec.whatwg.org/#dom-urlsearchparams-sort sort: function sort() { var state = getInternalParamsState(this); - var entries = state.entries; - // Array#sort is not stable in some engines - var slice = entries.slice(); - var entry, entriesIndex, sliceIndex; - entries.length = 0; - for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) { - entry = slice[sliceIndex]; - for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) { - if (entries[entriesIndex].key > entry.key) { - entries.splice(entriesIndex, 0, entry); - break; - } - } - if (entriesIndex === sliceIndex) entries.push(entry); - } + arraySort(state.entries, function (a, b) { + return a.key > b.key ? 1 : -1; + }); state.updateURL(); }, // `URLSearchParams.prototype.forEach` method forEach: function forEach(callback /* , thisArg */) { var entries = getInternalParamsState(this).entries; - var boundFunction = functionBindContext(callback, arguments.length > 1 ? arguments[1] : undefined, 3); + var boundFunction = bind$8(callback, arguments.length > 1 ? arguments[1] : undefined); var index = 0; var entry; while (index < entries.length) { @@ -4726,53 +5884,63 @@ }, { enumerable: true }); // `URLSearchParams.prototype[@@iterator]` method - redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries); + redefine$7(URLSearchParamsPrototype, ITERATOR$2, URLSearchParamsPrototype.entries, { name: 'entries' }); // `URLSearchParams.prototype.toString` method // https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior - redefine(URLSearchParamsPrototype, 'toString', function toString() { - var entries = getInternalParamsState(this).entries; - var result = []; - var index = 0; - var entry; - while (index < entries.length) { - entry = entries[index++]; - result.push(serialize(entry.key) + '=' + serialize(entry.value)); - } return result.join('&'); + redefine$7(URLSearchParamsPrototype, 'toString', function toString() { + return getInternalParamsState(this).serialize(); }, { enumerable: true }); - setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS); + setToStringTag$4(URLSearchParamsConstructor, URL_SEARCH_PARAMS); - _export({ global: true, forced: !nativeUrl }, { + $$X({ global: true, forced: !USE_NATIVE_URL$1 }, { URLSearchParams: URLSearchParamsConstructor }); - // Wrap `fetch` for correct work with polyfilled `URLSearchParams` - // https://github.com/zloirock/core-js/issues/674 - if (!nativeUrl && typeof $fetch == 'function' && typeof Headers$1 == 'function') { - _export({ global: true, enumerable: true, forced: true }, { - fetch: function fetch(input /* , init */) { - var args = [input]; - var init, body, headers; - if (arguments.length > 1) { - init = arguments[1]; - if (isObject$4(init)) { - body = init.body; - if (classof(body) === URL_SEARCH_PARAMS) { - headers = init.headers ? new Headers$1(init.headers) : new Headers$1(); - if (!headers.has('content-type')) { - headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8'); - } - init = objectCreate(init, { - body: createPropertyDescriptor(0, String(body)), - headers: createPropertyDescriptor(0, headers) - }); - } - } - args.push(init); - } return $fetch.apply(this, args); - } - }); + // Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams` + if (!USE_NATIVE_URL$1 && isCallable$5(Headers$1)) { + var headersHas = uncurryThis$u(HeadersPrototype.has); + var headersSet = uncurryThis$u(HeadersPrototype.set); + + var wrapRequestOptions = function (init) { + if (isObject$d(init)) { + var body = init.body; + var headers; + if (classof$3(body) === URL_SEARCH_PARAMS) { + headers = init.headers ? new Headers$1(init.headers) : new Headers$1(); + if (!headersHas(headers, 'content-type')) { + headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8'); + } + return create$6(init, { + body: createPropertyDescriptor(0, $toString$2(body)), + headers: createPropertyDescriptor(0, headers) + }); + } + } return init; + }; + + if (isCallable$5(n$Fetch)) { + $$X({ global: true, enumerable: true, forced: true }, { + fetch: function fetch(input /* , init */) { + return n$Fetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {}); + } + }); + } + + if (isCallable$5(N$Request)) { + var RequestConstructor = function Request(input /* , init */) { + anInstance$3(this, RequestPrototype); + return new N$Request(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {}); + }; + + RequestPrototype.constructor = RequestConstructor; + RequestConstructor.prototype = RequestPrototype; + + $$X({ global: true, forced: true }, { + Request: RequestConstructor + }); + } } var web_urlSearchParams = { @@ -4780,1469 +5948,363 @@ getState: getInternalParamsState }; - // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` - - - + var uncurryThis$t = functionUncurryThis; + var PROPER_FUNCTION_NAME$1 = functionName.PROPER; + var redefine$6 = redefine$h.exports; + var anObject$8 = anObject$n; + var isPrototypeOf$2 = objectIsPrototypeOf; + var $toString$1 = toString$k; + var fails$s = fails$V; + var regExpFlags$2 = regexpFlags$1; + var TO_STRING = 'toString'; + var RegExpPrototype$3 = RegExp.prototype; + var n$ToString = RegExpPrototype$3[TO_STRING]; + var getFlags$1 = uncurryThis$t(regExpFlags$2); + var NOT_GENERIC = fails$s(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); + // FF44- RegExp#toString has a wrong name + var INCORRECT_NAME = PROPER_FUNCTION_NAME$1 && n$ToString.name != TO_STRING; + // `RegExp.prototype.toString` method + // https://tc39.es/ecma262/#sec-regexp.prototype.tostring + if (NOT_GENERIC || INCORRECT_NAME) { + redefine$6(RegExp.prototype, TO_STRING, function toString() { + var R = anObject$8(this); + var p = $toString$1(R.source); + var rf = R.flags; + var f = $toString$1(rf === undefined && isPrototypeOf$2(RegExpPrototype$3, R) && !('flags' in RegExpPrototype$3) ? getFlags$1(R) : rf); + return '/' + p + '/' + f; + }, { unsafe: true }); + } + // TODO: Remove from `core-js@4` since it's moved to entry points + var uncurryThis$s = functionUncurryThis; + var redefine$5 = redefine$h.exports; + var regexpExec$2 = regexpExec$3; + var fails$r = fails$V; + var wellKnownSymbol$5 = wellKnownSymbol$t; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$b; + var SPECIES = wellKnownSymbol$5('species'); + var RegExpPrototype$2 = RegExp.prototype; + var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) { + var SYMBOL = wellKnownSymbol$5(KEY); - var codeAt = stringMultibyte.codeAt; - - - - - - var NativeURL = global$2.URL; - var URLSearchParams$1 = web_urlSearchParams.URLSearchParams; - var getInternalSearchParamsState = web_urlSearchParams.getState; - var setInternalState$1 = internalState.set; - var getInternalURLState = internalState.getterFor('URL'); - var floor$2 = Math.floor; - var pow$1 = Math.pow; - - var INVALID_AUTHORITY = 'Invalid authority'; - var INVALID_SCHEME = 'Invalid scheme'; - var INVALID_HOST = 'Invalid host'; - var INVALID_PORT = 'Invalid port'; - - var ALPHA = /[A-Za-z]/; - // eslint-disable-next-line regexp/no-obscure-range -- safe - var ALPHANUMERIC = /[\d+-.A-Za-z]/; - var DIGIT = /\d/; - var HEX_START = /^0x/i; - var OCT = /^[0-7]+$/; - var DEC = /^\d+$/; - var HEX = /^[\dA-Fa-f]+$/; - /* eslint-disable no-control-regex -- safe */ - var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:<>?@[\\\]^|]/; - var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:<>?@[\\\]^|]/; - var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g; - var TAB_AND_NEW_LINE = /[\t\n\r]/g; - /* eslint-enable no-control-regex -- safe */ - var EOF; + var DELEGATES_TO_SYMBOL = !fails$r(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) != 7; + }); - var parseHost = function (url, input) { - var result, codePoints, index; - if (input.charAt(0) == '[') { - if (input.charAt(input.length - 1) != ']') return INVALID_HOST; - result = parseIPv6(input.slice(1, -1)); - if (!result) return INVALID_HOST; - url.host = result; - // opaque host - } else if (!isSpecial(url)) { - if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST; - result = ''; - codePoints = arrayFrom(input); - for (index = 0; index < codePoints.length; index++) { - result += percentEncode(codePoints[index], C0ControlPercentEncodeSet); - } - url.host = result; - } else { - input = stringPunycodeToAscii(input); - if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST; - result = parseIPv4(input); - if (result === null) return INVALID_HOST; - url.host = result; - } - }; + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$r(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; - var parseIPv4 = function (input) { - var parts = input.split('.'); - var partsLength, numbers, index, part, radix, number, ipv4; - if (parts.length && parts[parts.length - 1] == '') { - parts.pop(); - } - partsLength = parts.length; - if (partsLength > 4) return input; - numbers = []; - for (index = 0; index < partsLength; index++) { - part = parts[index]; - if (part == '') return input; - radix = 10; - if (part.length > 1 && part.charAt(0) == '0') { - radix = HEX_START.test(part) ? 16 : 8; - part = part.slice(radix == 8 ? 1 : 2); - } - if (part === '') { - number = 0; - } else { - if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input; - number = parseInt(part, radix); + if (KEY === 'split') { + // We can't use real regex here since it causes deoptimization + // and serious performance degradation in V8 + // https://github.com/zloirock/core-js/issues/306 + re = {}; + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES] = function () { return re; }; + re.flags = ''; + re[SYMBOL] = /./[SYMBOL]; } - numbers.push(number); - } - for (index = 0; index < partsLength; index++) { - number = numbers[index]; - if (index == partsLength - 1) { - if (number >= pow$1(256, 5 - partsLength)) return null; - } else if (number > 255) return null; - } - ipv4 = numbers.pop(); - for (index = 0; index < numbers.length; index++) { - ipv4 += numbers[index] * pow$1(256, 3 - index); - } - return ipv4; - }; - // eslint-disable-next-line max-statements -- TODO - var parseIPv6 = function (input) { - var address = [0, 0, 0, 0, 0, 0, 0, 0]; - var pieceIndex = 0; - var compress = null; - var pointer = 0; - var value, length, numbersSeen, ipv4Piece, number, swaps, swap; + re.exec = function () { execCalled = true; return null; }; - var char = function () { - return input.charAt(pointer); - }; + re[SYMBOL](''); + return !execCalled; + }); - if (char() == ':') { - if (input.charAt(1) != ':') return; - pointer += 2; - pieceIndex++; - compress = pieceIndex; - } - while (char()) { - if (pieceIndex == 8) return; - if (char() == ':') { - if (compress !== null) return; - pointer++; - pieceIndex++; - compress = pieceIndex; - continue; - } - value = length = 0; - while (length < 4 && HEX.test(char())) { - value = value * 16 + parseInt(char(), 16); - pointer++; - length++; - } - if (char() == '.') { - if (length == 0) return; - pointer -= length; - if (pieceIndex > 6) return; - numbersSeen = 0; - while (char()) { - ipv4Piece = null; - if (numbersSeen > 0) { - if (char() == '.' && numbersSeen < 4) pointer++; - else return; - } - if (!DIGIT.test(char())) return; - while (DIGIT.test(char())) { - number = parseInt(char(), 10); - if (ipv4Piece === null) ipv4Piece = number; - else if (ipv4Piece == 0) return; - else ipv4Piece = ipv4Piece * 10 + number; - if (ipv4Piece > 255) return; - pointer++; + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + FORCED + ) { + var uncurriedNativeRegExpMethod = uncurryThis$s(/./[SYMBOL]); + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + var uncurriedNativeMethod = uncurryThis$s(nativeMethod); + var $exec = regexp.exec; + if ($exec === regexpExec$2 || $exec === RegExpPrototype$2.exec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) }; } - address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; - numbersSeen++; - if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++; + return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) }; } - if (numbersSeen != 4) return; - break; - } else if (char() == ':') { - pointer++; - if (!char()) return; - } else if (char()) return; - address[pieceIndex++] = value; - } - if (compress !== null) { - swaps = pieceIndex - compress; - pieceIndex = 7; - while (pieceIndex != 0 && swaps > 0) { - swap = address[pieceIndex]; - address[pieceIndex--] = address[compress + swaps - 1]; - address[compress + --swaps] = swap; - } - } else if (pieceIndex != 8) return; - return address; - }; + return { done: false }; + }); - var findLongestZeroSequence = function (ipv6) { - var maxIndex = null; - var maxLength = 1; - var currStart = null; - var currLength = 0; - var index = 0; - for (; index < 8; index++) { - if (ipv6[index] !== 0) { - if (currLength > maxLength) { - maxIndex = currStart; - maxLength = currLength; - } - currStart = null; - currLength = 0; - } else { - if (currStart === null) currStart = index; - ++currLength; - } - } - if (currLength > maxLength) { - maxIndex = currStart; - maxLength = currLength; + redefine$5(String.prototype, KEY, methods[0]); + redefine$5(RegExpPrototype$2, SYMBOL, methods[1]); } - return maxIndex; - }; - var serializeHost = function (host) { - var result, index, compress, ignore0; - // ipv4 - if (typeof host == 'number') { - result = []; - for (index = 0; index < 4; index++) { - result.unshift(host % 256); - host = floor$2(host / 256); - } return result.join('.'); - // ipv6 - } else if (typeof host == 'object') { - result = ''; - compress = findLongestZeroSequence(host); - for (index = 0; index < 8; index++) { - if (ignore0 && host[index] === 0) continue; - if (ignore0) ignore0 = false; - if (compress === index) { - result += index ? ':' : '::'; - ignore0 = true; - } else { - result += host[index].toString(16); - if (index < 7) result += ':'; - } - } - return '[' + result + ']'; - } return host; + if (SHAM) createNonEnumerableProperty$1(RegExpPrototype$2[SYMBOL], 'sham', true); }; - var C0ControlPercentEncodeSet = {}; - var fragmentPercentEncodeSet = objectAssign({}, C0ControlPercentEncodeSet, { - ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1 - }); - var pathPercentEncodeSet = objectAssign({}, fragmentPercentEncodeSet, { - '#': 1, '?': 1, '{': 1, '}': 1 - }); - var userinfoPercentEncodeSet = objectAssign({}, pathPercentEncodeSet, { - '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1 - }); - - var percentEncode = function (char, set) { - var code = codeAt(char, 0); - return code > 0x20 && code < 0x7F && !has$1(set, char) ? char : encodeURIComponent(char); - }; + var charAt$4 = stringMultibyte.charAt; - var specialSchemes = { - ftp: 21, - file: null, - http: 80, - https: 443, - ws: 80, - wss: 443 + // `AdvanceStringIndex` abstract operation + // https://tc39.es/ecma262/#sec-advancestringindex + var advanceStringIndex$3 = function (S, index, unicode) { + return index + (unicode ? charAt$4(S, index).length : 1); }; - var isSpecial = function (url) { - return has$1(specialSchemes, url.scheme); - }; + var uncurryThis$r = functionUncurryThis; + var toObject$9 = toObject$i; - var includesCredentials = function (url) { - return url.username != '' || url.password != ''; - }; + var floor$3 = Math.floor; + var charAt$3 = uncurryThis$r(''.charAt); + var replace$5 = uncurryThis$r(''.replace); + var stringSlice$7 = uncurryThis$r(''.slice); + var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g; + var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g; - var cannotHaveUsernamePasswordPort = function (url) { - return !url.host || url.cannotBeABaseURL || url.scheme == 'file'; + // `GetSubstitution` abstract operation + // https://tc39.es/ecma262/#sec-getsubstitution + var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject$9(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return replace$5(replacement, symbols, function (match, ch) { + var capture; + switch (charAt$3(ch, 0)) { + case '$': return '$'; + case '&': return matched; + case '`': return stringSlice$7(str, 0, position); + case "'": return stringSlice$7(str, tailPos); + case '<': + capture = namedCaptures[stringSlice$7(ch, 1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor$3(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? charAt$3(ch, 1) : captures[f - 1] + charAt$3(ch, 1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); }; - var isWindowsDriveLetter = function (string, normalized) { - var second; - return string.length == 2 && ALPHA.test(string.charAt(0)) - && ((second = string.charAt(1)) == ':' || (!normalized && second == '|')); - }; + var global$m = global$1o; + var call$8 = functionCall; + var anObject$7 = anObject$n; + var isCallable$4 = isCallable$r; + var classof$2 = classofRaw$1; + var regexpExec$1 = regexpExec$3; - var startsWithWindowsDriveLetter = function (string) { - var third; - return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && ( - string.length == 2 || - ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#') - ); - }; + var TypeError$7 = global$m.TypeError; - var shortenURLsPath = function (url) { - var path = url.path; - var pathSize = path.length; - if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) { - path.pop(); + // `RegExpExec` abstract operation + // https://tc39.es/ecma262/#sec-regexpexec + var regexpExecAbstract = function (R, S) { + var exec = R.exec; + if (isCallable$4(exec)) { + var result = call$8(exec, R, S); + if (result !== null) anObject$7(result); + return result; } + if (classof$2(R) === 'RegExp') return call$8(regexpExec$1, R, S); + throw TypeError$7('RegExp#exec called on incompatible receiver'); }; - var isSingleDot = function (segment) { - return segment === '.' || segment.toLowerCase() === '%2e'; - }; + var apply$3 = functionApply; + var call$7 = functionCall; + var uncurryThis$q = functionUncurryThis; + var fixRegExpWellKnownSymbolLogic$3 = fixRegexpWellKnownSymbolLogic; + var fails$q = fails$V; + var anObject$6 = anObject$n; + var isCallable$3 = isCallable$r; + var toIntegerOrInfinity$3 = toIntegerOrInfinity$b; + var toLength$5 = toLength$c; + var toString$f = toString$k; + var requireObjectCoercible$a = requireObjectCoercible$e; + var advanceStringIndex$2 = advanceStringIndex$3; + var getMethod$3 = getMethod$7; + var getSubstitution = getSubstitution$1; + var regExpExec$3 = regexpExecAbstract; + var wellKnownSymbol$4 = wellKnownSymbol$t; + + var REPLACE = wellKnownSymbol$4('replace'); + var max$2 = Math.max; + var min$5 = Math.min; + var concat$2 = uncurryThis$q([].concat); + var push$6 = uncurryThis$q([].push); + var stringIndexOf$2 = uncurryThis$q(''.indexOf); + var stringSlice$6 = uncurryThis$q(''.slice); - var isDoubleDot = function (segment) { - segment = segment.toLowerCase(); - return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e'; + var maybeToString = function (it) { + return it === undefined ? it : String(it); }; - // States: - var SCHEME_START = {}; - var SCHEME = {}; - var NO_SCHEME = {}; - var SPECIAL_RELATIVE_OR_AUTHORITY = {}; - var PATH_OR_AUTHORITY = {}; - var RELATIVE = {}; - var RELATIVE_SLASH = {}; - var SPECIAL_AUTHORITY_SLASHES = {}; - var SPECIAL_AUTHORITY_IGNORE_SLASHES = {}; - var AUTHORITY = {}; - var HOST = {}; - var HOSTNAME = {}; - var PORT = {}; - var FILE = {}; - var FILE_SLASH = {}; - var FILE_HOST = {}; - var PATH_START = {}; - var PATH = {}; - var CANNOT_BE_A_BASE_URL_PATH = {}; - var QUERY = {}; - var FRAGMENT = {}; + // IE <= 11 replaces $0 with the whole match, as if it was $& + // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 + var REPLACE_KEEPS_$0 = (function () { + // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing + return 'a'.replace(/./, '$0') === '$0'; + })(); - // eslint-disable-next-line max-statements -- TODO - var parseURL = function (url, input, stateOverride, base) { - var state = stateOverride || SCHEME_START; - var pointer = 0; - var buffer = ''; - var seenAt = false; - var seenBracket = false; - var seenPasswordToken = false; - var codePoints, char, bufferCodePoints, failure; - - if (!stateOverride) { - url.scheme = ''; - url.username = ''; - url.password = ''; - url.host = null; - url.port = null; - url.path = []; - url.query = null; - url.fragment = null; - url.cannotBeABaseURL = false; - input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, ''); - } - - input = input.replace(TAB_AND_NEW_LINE, ''); - - codePoints = arrayFrom(input); - - while (pointer <= codePoints.length) { - char = codePoints[pointer]; - switch (state) { - case SCHEME_START: - if (char && ALPHA.test(char)) { - buffer += char.toLowerCase(); - state = SCHEME; - } else if (!stateOverride) { - state = NO_SCHEME; - continue; - } else return INVALID_SCHEME; - break; + // Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string + var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { + if (/./[REPLACE]) { + return /./[REPLACE]('a', '$0') === ''; + } + return false; + })(); - case SCHEME: - if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) { - buffer += char.toLowerCase(); - } else if (char == ':') { - if (stateOverride && ( - (isSpecial(url) != has$1(specialSchemes, buffer)) || - (buffer == 'file' && (includesCredentials(url) || url.port !== null)) || - (url.scheme == 'file' && !url.host) - )) return; - url.scheme = buffer; - if (stateOverride) { - if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null; - return; - } - buffer = ''; - if (url.scheme == 'file') { - state = FILE; - } else if (isSpecial(url) && base && base.scheme == url.scheme) { - state = SPECIAL_RELATIVE_OR_AUTHORITY; - } else if (isSpecial(url)) { - state = SPECIAL_AUTHORITY_SLASHES; - } else if (codePoints[pointer + 1] == '/') { - state = PATH_OR_AUTHORITY; - pointer++; - } else { - url.cannotBeABaseURL = true; - url.path.push(''); - state = CANNOT_BE_A_BASE_URL_PATH; - } - } else if (!stateOverride) { - buffer = ''; - state = NO_SCHEME; - pointer = 0; - continue; - } else return INVALID_SCHEME; - break; + var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$q(function () { + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive + return ''.replace(re, '$') !== '7'; + }); - case NO_SCHEME: - if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME; - if (base.cannotBeABaseURL && char == '#') { - url.scheme = base.scheme; - url.path = base.path.slice(); - url.query = base.query; - url.fragment = ''; - url.cannotBeABaseURL = true; - state = FRAGMENT; - break; - } - state = base.scheme == 'file' ? FILE : RELATIVE; - continue; + // @@replace logic + fixRegExpWellKnownSymbolLogic$3('replace', function (_, nativeReplace, maybeCallNative) { + var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; - case SPECIAL_RELATIVE_OR_AUTHORITY: - if (char == '/' && codePoints[pointer + 1] == '/') { - state = SPECIAL_AUTHORITY_IGNORE_SLASHES; - pointer++; - } else { - state = RELATIVE; - continue; - } break; + return [ + // `String.prototype.replace` method + // https://tc39.es/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible$a(this); + var replacer = searchValue == undefined ? undefined : getMethod$3(searchValue, REPLACE); + return replacer + ? call$7(replacer, searchValue, O, replaceValue) + : call$7(nativeReplace, toString$f(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace + function (string, replaceValue) { + var rx = anObject$6(this); + var S = toString$f(string); - case PATH_OR_AUTHORITY: - if (char == '/') { - state = AUTHORITY; - break; - } else { - state = PATH; - continue; - } + if ( + typeof replaceValue == 'string' && + stringIndexOf$2(replaceValue, UNSAFE_SUBSTITUTE) === -1 && + stringIndexOf$2(replaceValue, '$<') === -1 + ) { + var res = maybeCallNative(nativeReplace, rx, S, replaceValue); + if (res.done) return res.value; + } - case RELATIVE: - url.scheme = base.scheme; - if (char == EOF) { - url.username = base.username; - url.password = base.password; - url.host = base.host; - url.port = base.port; - url.path = base.path.slice(); - url.query = base.query; - } else if (char == '/' || (char == '\\' && isSpecial(url))) { - state = RELATIVE_SLASH; - } else if (char == '?') { - url.username = base.username; - url.password = base.password; - url.host = base.host; - url.port = base.port; - url.path = base.path.slice(); - url.query = ''; - state = QUERY; - } else if (char == '#') { - url.username = base.username; - url.password = base.password; - url.host = base.host; - url.port = base.port; - url.path = base.path.slice(); - url.query = base.query; - url.fragment = ''; - state = FRAGMENT; - } else { - url.username = base.username; - url.password = base.password; - url.host = base.host; - url.port = base.port; - url.path = base.path.slice(); - url.path.pop(); - state = PATH; - continue; - } break; + var functionalReplace = isCallable$3(replaceValue); + if (!functionalReplace) replaceValue = toString$f(replaceValue); - case RELATIVE_SLASH: - if (isSpecial(url) && (char == '/' || char == '\\')) { - state = SPECIAL_AUTHORITY_IGNORE_SLASHES; - } else if (char == '/') { - state = AUTHORITY; - } else { - url.username = base.username; - url.password = base.password; - url.host = base.host; - url.port = base.port; - state = PATH; - continue; - } break; + var global = rx.global; + if (global) { + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + var results = []; + while (true) { + var result = regExpExec$3(rx, S); + if (result === null) break; - case SPECIAL_AUTHORITY_SLASHES: - state = SPECIAL_AUTHORITY_IGNORE_SLASHES; - if (char != '/' || buffer.charAt(pointer + 1) != '/') continue; - pointer++; - break; + push$6(results, result); + if (!global) break; - case SPECIAL_AUTHORITY_IGNORE_SLASHES: - if (char != '/' && char != '\\') { - state = AUTHORITY; - continue; - } break; - - case AUTHORITY: - if (char == '@') { - if (seenAt) buffer = '%40' + buffer; - seenAt = true; - bufferCodePoints = arrayFrom(buffer); - for (var i = 0; i < bufferCodePoints.length; i++) { - var codePoint = bufferCodePoints[i]; - if (codePoint == ':' && !seenPasswordToken) { - seenPasswordToken = true; - continue; - } - var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet); - if (seenPasswordToken) url.password += encodedCodePoints; - else url.username += encodedCodePoints; - } - buffer = ''; - } else if ( - char == EOF || char == '/' || char == '?' || char == '#' || - (char == '\\' && isSpecial(url)) - ) { - if (seenAt && buffer == '') return INVALID_AUTHORITY; - pointer -= arrayFrom(buffer).length + 1; - buffer = ''; - state = HOST; - } else buffer += char; - break; + var matchStr = toString$f(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex$2(S, toLength$5(rx.lastIndex), fullUnicode); + } - case HOST: - case HOSTNAME: - if (stateOverride && url.scheme == 'file') { - state = FILE_HOST; - continue; - } else if (char == ':' && !seenBracket) { - if (buffer == '') return INVALID_HOST; - failure = parseHost(url, buffer); - if (failure) return failure; - buffer = ''; - state = PORT; - if (stateOverride == HOSTNAME) return; - } else if ( - char == EOF || char == '/' || char == '?' || char == '#' || - (char == '\\' && isSpecial(url)) - ) { - if (isSpecial(url) && buffer == '') return INVALID_HOST; - if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return; - failure = parseHost(url, buffer); - if (failure) return failure; - buffer = ''; - state = PATH_START; - if (stateOverride) return; - continue; - } else { - if (char == '[') seenBracket = true; - else if (char == ']') seenBracket = false; - buffer += char; - } break; - - case PORT: - if (DIGIT.test(char)) { - buffer += char; - } else if ( - char == EOF || char == '/' || char == '?' || char == '#' || - (char == '\\' && isSpecial(url)) || - stateOverride - ) { - if (buffer != '') { - var port = parseInt(buffer, 10); - if (port > 0xFFFF) return INVALID_PORT; - url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port; - buffer = ''; - } - if (stateOverride) return; - state = PATH_START; - continue; - } else return INVALID_PORT; - break; + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; - case FILE: - url.scheme = 'file'; - if (char == '/' || char == '\\') state = FILE_SLASH; - else if (base && base.scheme == 'file') { - if (char == EOF) { - url.host = base.host; - url.path = base.path.slice(); - url.query = base.query; - } else if (char == '?') { - url.host = base.host; - url.path = base.path.slice(); - url.query = ''; - state = QUERY; - } else if (char == '#') { - url.host = base.host; - url.path = base.path.slice(); - url.query = base.query; - url.fragment = ''; - state = FRAGMENT; - } else { - if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { - url.host = base.host; - url.path = base.path.slice(); - shortenURLsPath(url); - } - state = PATH; - continue; - } + var matched = toString$f(result[0]); + var position = max$2(min$5(toIntegerOrInfinity$3(result.index), S.length), 0); + var captures = []; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) push$6(captures, maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = concat$2([matched], captures, position, S); + if (namedCaptures !== undefined) push$6(replacerArgs, namedCaptures); + var replacement = toString$f(apply$3(replaceValue, undefined, replacerArgs)); } else { - state = PATH; - continue; - } break; - - case FILE_SLASH: - if (char == '/' || char == '\\') { - state = FILE_HOST; - break; + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); } - if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { - if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]); - else url.host = base.host; + if (position >= nextSourcePosition) { + accumulatedResult += stringSlice$6(S, nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; } - state = PATH; - continue; + } + return accumulatedResult + stringSlice$6(S, nextSourcePosition); + } + ]; + }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE); - case FILE_HOST: - if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') { - if (!stateOverride && isWindowsDriveLetter(buffer)) { - state = PATH; - } else if (buffer == '') { - url.host = ''; - if (stateOverride) return; - state = PATH_START; - } else { - failure = parseHost(url, buffer); - if (failure) return failure; - if (url.host == 'localhost') url.host = ''; - if (stateOverride) return; - buffer = ''; - state = PATH_START; - } continue; - } else buffer += char; - break; + var isObject$c = isObject$s; + var classof$1 = classofRaw$1; + var wellKnownSymbol$3 = wellKnownSymbol$t; - case PATH_START: - if (isSpecial(url)) { - state = PATH; - if (char != '/' && char != '\\') continue; - } else if (!stateOverride && char == '?') { - url.query = ''; - state = QUERY; - } else if (!stateOverride && char == '#') { - url.fragment = ''; - state = FRAGMENT; - } else if (char != EOF) { - state = PATH; - if (char != '/') continue; - } break; - - case PATH: - if ( - char == EOF || char == '/' || - (char == '\\' && isSpecial(url)) || - (!stateOverride && (char == '?' || char == '#')) - ) { - if (isDoubleDot(buffer)) { - shortenURLsPath(url); - if (char != '/' && !(char == '\\' && isSpecial(url))) { - url.path.push(''); - } - } else if (isSingleDot(buffer)) { - if (char != '/' && !(char == '\\' && isSpecial(url))) { - url.path.push(''); - } - } else { - if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) { - if (url.host) url.host = ''; - buffer = buffer.charAt(0) + ':'; // normalize windows drive letter - } - url.path.push(buffer); - } - buffer = ''; - if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) { - while (url.path.length > 1 && url.path[0] === '') { - url.path.shift(); - } - } - if (char == '?') { - url.query = ''; - state = QUERY; - } else if (char == '#') { - url.fragment = ''; - state = FRAGMENT; - } - } else { - buffer += percentEncode(char, pathPercentEncodeSet); - } break; - - case CANNOT_BE_A_BASE_URL_PATH: - if (char == '?') { - url.query = ''; - state = QUERY; - } else if (char == '#') { - url.fragment = ''; - state = FRAGMENT; - } else if (char != EOF) { - url.path[0] += percentEncode(char, C0ControlPercentEncodeSet); - } break; - - case QUERY: - if (!stateOverride && char == '#') { - url.fragment = ''; - state = FRAGMENT; - } else if (char != EOF) { - if (char == "'" && isSpecial(url)) url.query += '%27'; - else if (char == '#') url.query += '%23'; - else url.query += percentEncode(char, C0ControlPercentEncodeSet); - } break; - - case FRAGMENT: - if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet); - break; - } - - pointer++; - } - }; - - // `URL` constructor - // https://url.spec.whatwg.org/#url-class - var URLConstructor = function URL(url /* , base */) { - var that = anInstance(this, URLConstructor, 'URL'); - var base = arguments.length > 1 ? arguments[1] : undefined; - var urlString = String(url); - var state = setInternalState$1(that, { type: 'URL' }); - var baseState, failure; - if (base !== undefined) { - if (base instanceof URLConstructor) baseState = getInternalURLState(base); - else { - failure = parseURL(baseState = {}, String(base)); - if (failure) throw TypeError(failure); - } - } - failure = parseURL(state, urlString, null, baseState); - if (failure) throw TypeError(failure); - var searchParams = state.searchParams = new URLSearchParams$1(); - var searchParamsState = getInternalSearchParamsState(searchParams); - searchParamsState.updateSearchParams(state.query); - searchParamsState.updateURL = function () { - state.query = String(searchParams) || null; - }; - if (!descriptors) { - that.href = serializeURL.call(that); - that.origin = getOrigin.call(that); - that.protocol = getProtocol.call(that); - that.username = getUsername.call(that); - that.password = getPassword.call(that); - that.host = getHost.call(that); - that.hostname = getHostname.call(that); - that.port = getPort.call(that); - that.pathname = getPathname.call(that); - that.search = getSearch.call(that); - that.searchParams = getSearchParams.call(that); - that.hash = getHash.call(that); - } - }; - - var URLPrototype = URLConstructor.prototype; - - var serializeURL = function () { - var url = getInternalURLState(this); - var scheme = url.scheme; - var username = url.username; - var password = url.password; - var host = url.host; - var port = url.port; - var path = url.path; - var query = url.query; - var fragment = url.fragment; - var output = scheme + ':'; - if (host !== null) { - output += '//'; - if (includesCredentials(url)) { - output += username + (password ? ':' + password : '') + '@'; - } - output += serializeHost(host); - if (port !== null) output += ':' + port; - } else if (scheme == 'file') output += '//'; - output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; - if (query !== null) output += '?' + query; - if (fragment !== null) output += '#' + fragment; - return output; - }; - - var getOrigin = function () { - var url = getInternalURLState(this); - var scheme = url.scheme; - var port = url.port; - if (scheme == 'blob') try { - return new URLConstructor(scheme.path[0]).origin; - } catch (error) { - return 'null'; - } - if (scheme == 'file' || !isSpecial(url)) return 'null'; - return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : ''); - }; - - var getProtocol = function () { - return getInternalURLState(this).scheme + ':'; - }; - - var getUsername = function () { - return getInternalURLState(this).username; - }; - - var getPassword = function () { - return getInternalURLState(this).password; - }; - - var getHost = function () { - var url = getInternalURLState(this); - var host = url.host; - var port = url.port; - return host === null ? '' - : port === null ? serializeHost(host) - : serializeHost(host) + ':' + port; - }; - - var getHostname = function () { - var host = getInternalURLState(this).host; - return host === null ? '' : serializeHost(host); - }; - - var getPort = function () { - var port = getInternalURLState(this).port; - return port === null ? '' : String(port); - }; - - var getPathname = function () { - var url = getInternalURLState(this); - var path = url.path; - return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; - }; - - var getSearch = function () { - var query = getInternalURLState(this).query; - return query ? '?' + query : ''; - }; - - var getSearchParams = function () { - return getInternalURLState(this).searchParams; - }; - - var getHash = function () { - var fragment = getInternalURLState(this).fragment; - return fragment ? '#' + fragment : ''; - }; - - var accessorDescriptor = function (getter, setter) { - return { get: getter, set: setter, configurable: true, enumerable: true }; - }; - - if (descriptors) { - objectDefineProperties(URLPrototype, { - // `URL.prototype.href` accessors pair - // https://url.spec.whatwg.org/#dom-url-href - href: accessorDescriptor(serializeURL, function (href) { - var url = getInternalURLState(this); - var urlString = String(href); - var failure = parseURL(url, urlString); - if (failure) throw TypeError(failure); - getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); - }), - // `URL.prototype.origin` getter - // https://url.spec.whatwg.org/#dom-url-origin - origin: accessorDescriptor(getOrigin), - // `URL.prototype.protocol` accessors pair - // https://url.spec.whatwg.org/#dom-url-protocol - protocol: accessorDescriptor(getProtocol, function (protocol) { - var url = getInternalURLState(this); - parseURL(url, String(protocol) + ':', SCHEME_START); - }), - // `URL.prototype.username` accessors pair - // https://url.spec.whatwg.org/#dom-url-username - username: accessorDescriptor(getUsername, function (username) { - var url = getInternalURLState(this); - var codePoints = arrayFrom(String(username)); - if (cannotHaveUsernamePasswordPort(url)) return; - url.username = ''; - for (var i = 0; i < codePoints.length; i++) { - url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet); - } - }), - // `URL.prototype.password` accessors pair - // https://url.spec.whatwg.org/#dom-url-password - password: accessorDescriptor(getPassword, function (password) { - var url = getInternalURLState(this); - var codePoints = arrayFrom(String(password)); - if (cannotHaveUsernamePasswordPort(url)) return; - url.password = ''; - for (var i = 0; i < codePoints.length; i++) { - url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet); - } - }), - // `URL.prototype.host` accessors pair - // https://url.spec.whatwg.org/#dom-url-host - host: accessorDescriptor(getHost, function (host) { - var url = getInternalURLState(this); - if (url.cannotBeABaseURL) return; - parseURL(url, String(host), HOST); - }), - // `URL.prototype.hostname` accessors pair - // https://url.spec.whatwg.org/#dom-url-hostname - hostname: accessorDescriptor(getHostname, function (hostname) { - var url = getInternalURLState(this); - if (url.cannotBeABaseURL) return; - parseURL(url, String(hostname), HOSTNAME); - }), - // `URL.prototype.port` accessors pair - // https://url.spec.whatwg.org/#dom-url-port - port: accessorDescriptor(getPort, function (port) { - var url = getInternalURLState(this); - if (cannotHaveUsernamePasswordPort(url)) return; - port = String(port); - if (port == '') url.port = null; - else parseURL(url, port, PORT); - }), - // `URL.prototype.pathname` accessors pair - // https://url.spec.whatwg.org/#dom-url-pathname - pathname: accessorDescriptor(getPathname, function (pathname) { - var url = getInternalURLState(this); - if (url.cannotBeABaseURL) return; - url.path = []; - parseURL(url, pathname + '', PATH_START); - }), - // `URL.prototype.search` accessors pair - // https://url.spec.whatwg.org/#dom-url-search - search: accessorDescriptor(getSearch, function (search) { - var url = getInternalURLState(this); - search = String(search); - if (search == '') { - url.query = null; - } else { - if ('?' == search.charAt(0)) search = search.slice(1); - url.query = ''; - parseURL(url, search, QUERY); - } - getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); - }), - // `URL.prototype.searchParams` getter - // https://url.spec.whatwg.org/#dom-url-searchparams - searchParams: accessorDescriptor(getSearchParams), - // `URL.prototype.hash` accessors pair - // https://url.spec.whatwg.org/#dom-url-hash - hash: accessorDescriptor(getHash, function (hash) { - var url = getInternalURLState(this); - hash = String(hash); - if (hash == '') { - url.fragment = null; - return; - } - if ('#' == hash.charAt(0)) hash = hash.slice(1); - url.fragment = ''; - parseURL(url, hash, FRAGMENT); - }) - }); - } - - // `URL.prototype.toJSON` method - // https://url.spec.whatwg.org/#dom-url-tojson - redefine(URLPrototype, 'toJSON', function toJSON() { - return serializeURL.call(this); - }, { enumerable: true }); - - // `URL.prototype.toString` method - // https://url.spec.whatwg.org/#URL-stringification-behavior - redefine(URLPrototype, 'toString', function toString() { - return serializeURL.call(this); - }, { enumerable: true }); - - if (NativeURL) { - var nativeCreateObjectURL = NativeURL.createObjectURL; - var nativeRevokeObjectURL = NativeURL.revokeObjectURL; - // `URL.createObjectURL` method - // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL - // eslint-disable-next-line no-unused-vars -- required for `.length` - if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) { - return nativeCreateObjectURL.apply(NativeURL, arguments); - }); - // `URL.revokeObjectURL` method - // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL - // eslint-disable-next-line no-unused-vars -- required for `.length` - if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) { - return nativeRevokeObjectURL.apply(NativeURL, arguments); - }); - } - - setToStringTag(URLConstructor, 'URL'); - - _export({ global: true, forced: !nativeUrl, sham: !descriptors }, { - URL: URLConstructor - }); - - // `RegExp.prototype.flags` getter implementation - // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags - var regexpFlags = function () { - var that = anObject(this); - var result = ''; - if (that.global) result += 'g'; - if (that.ignoreCase) result += 'i'; - if (that.multiline) result += 'm'; - if (that.dotAll) result += 's'; - if (that.unicode) result += 'u'; - if (that.sticky) result += 'y'; - return result; - }; - - var TO_STRING = 'toString'; - var RegExpPrototype$2 = RegExp.prototype; - var nativeToString = RegExpPrototype$2[TO_STRING]; - - var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); - // FF44- RegExp#toString has a wrong name - var INCORRECT_NAME = nativeToString.name != TO_STRING; - - // `RegExp.prototype.toString` method - // https://tc39.es/ecma262/#sec-regexp.prototype.tostring - if (NOT_GENERIC || INCORRECT_NAME) { - redefine(RegExp.prototype, TO_STRING, function toString() { - var R = anObject(this); - var p = String(R.source); - var rf = R.flags; - var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype$2) ? regexpFlags.call(R) : rf); - return '/' + p + '/' + f; - }, { unsafe: true }); - } - - // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError, - var RE = function (s, f) { - return RegExp(s, f); - }; - - var UNSUPPORTED_Y$3 = fails(function () { - var re = RE('a', 'y'); - re.lastIndex = 2; - return re.exec('abcd') != null; - }); - - var BROKEN_CARET = fails(function () { - // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 - var re = RE('^r', 'gy'); - re.lastIndex = 2; - return re.exec('str') != null; - }); - - var regexpStickyHelpers = { - UNSUPPORTED_Y: UNSUPPORTED_Y$3, - BROKEN_CARET: BROKEN_CARET - }; - - var regexpUnsupportedDotAll = fails(function () { - // babel-minify transpiles RegExp('.', 's') -> /./s and it causes SyntaxError - var re = RegExp('.', (typeof '').charAt(0)); - return !(re.dotAll && re.exec('\n') && re.flags === 's'); - }); - - var regexpUnsupportedNcg = fails(function () { - // babel-minify transpiles RegExp('.', 'g') -> /./g and it causes SyntaxError - var re = RegExp('(?b)', (typeof '').charAt(5)); - return re.exec('b').groups.a !== 'b' || - 'b'.replace(re, '$c') !== 'bc'; - }); - - /* eslint-disable regexp/no-assertion-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ - /* eslint-disable regexp/no-useless-quantifier -- testing */ - - - - - var getInternalState = internalState.get; - - - - var nativeExec = RegExp.prototype.exec; - var nativeReplace = shared('native-string-replace', String.prototype.replace); - - var patchedExec = nativeExec; - - var UPDATES_LAST_INDEX_WRONG = (function () { - var re1 = /a/; - var re2 = /b*/g; - nativeExec.call(re1, 'a'); - nativeExec.call(re2, 'a'); - return re1.lastIndex !== 0 || re2.lastIndex !== 0; - })(); - - var UNSUPPORTED_Y$2 = regexpStickyHelpers.UNSUPPORTED_Y || regexpStickyHelpers.BROKEN_CARET; - - // nonparticipating capturing group, copied from es5-shim's String#split patch. - var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; - - var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$2 || regexpUnsupportedDotAll || regexpUnsupportedNcg; - - if (PATCH) { - // eslint-disable-next-line max-statements -- TODO - patchedExec = function exec(str) { - var re = this; - var state = getInternalState(re); - var raw = state.raw; - var result, reCopy, lastIndex, match, i, object, group; - - if (raw) { - raw.lastIndex = re.lastIndex; - result = patchedExec.call(raw, str); - re.lastIndex = raw.lastIndex; - return result; - } - - var groups = state.groups; - var sticky = UNSUPPORTED_Y$2 && re.sticky; - var flags = regexpFlags.call(re); - var source = re.source; - var charsAdded = 0; - var strCopy = str; - - if (sticky) { - flags = flags.replace('y', ''); - if (flags.indexOf('g') === -1) { - flags += 'g'; - } - - strCopy = String(str).slice(re.lastIndex); - // Support anchored sticky behavior. - if (re.lastIndex > 0 && (!re.multiline || re.multiline && str[re.lastIndex - 1] !== '\n')) { - source = '(?: ' + source + ')'; - strCopy = ' ' + strCopy; - charsAdded++; - } - // ^(? + rx + ) is needed, in combination with some str slicing, to - // simulate the 'y' flag. - reCopy = new RegExp('^(?:' + source + ')', flags); - } - - if (NPCG_INCLUDED) { - reCopy = new RegExp('^' + source + '$(?!\\s)', flags); - } - if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; - - match = nativeExec.call(sticky ? reCopy : re, strCopy); - - if (sticky) { - if (match) { - match.input = match.input.slice(charsAdded); - match[0] = match[0].slice(charsAdded); - match.index = re.lastIndex; - re.lastIndex += match[0].length; - } else re.lastIndex = 0; - } else if (UPDATES_LAST_INDEX_WRONG && match) { - re.lastIndex = re.global ? match.index + match[0].length : lastIndex; - } - if (NPCG_INCLUDED && match && match.length > 1) { - // Fix browsers whose `exec` methods don't consistently return `undefined` - // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ - nativeReplace.call(match[0], reCopy, function () { - for (i = 1; i < arguments.length - 2; i++) { - if (arguments[i] === undefined) match[i] = undefined; - } - }); - } - - if (match && groups) { - match.groups = object = objectCreate(null); - for (i = 0; i < groups.length; i++) { - group = groups[i]; - object[group[0]] = match[group[1]]; - } - } - - return match; - }; - } - - var regexpExec = patchedExec; - - // `RegExp.prototype.exec` method - // https://tc39.es/ecma262/#sec-regexp.prototype.exec - _export({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, { - exec: regexpExec - }); - - // TODO: Remove from `core-js@4` since it's moved to entry points - - - - - - - - var SPECIES = wellKnownSymbol('species'); - var RegExpPrototype$1 = RegExp.prototype; - - var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) { - var SYMBOL = wellKnownSymbol(KEY); - - var DELEGATES_TO_SYMBOL = !fails(function () { - // String methods call symbol-named RegEp methods - var O = {}; - O[SYMBOL] = function () { return 7; }; - return ''[KEY](O) != 7; - }); - - var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { - // Symbol-named RegExp methods call .exec - var execCalled = false; - var re = /a/; - - if (KEY === 'split') { - // We can't use real regex here since it causes deoptimization - // and serious performance degradation in V8 - // https://github.com/zloirock/core-js/issues/306 - re = {}; - // RegExp[@@split] doesn't call the regex's exec method, but first creates - // a new one. We need to return the patched regex when creating the new one. - re.constructor = {}; - re.constructor[SPECIES] = function () { return re; }; - re.flags = ''; - re[SYMBOL] = /./[SYMBOL]; - } - - re.exec = function () { execCalled = true; return null; }; - - re[SYMBOL](''); - return !execCalled; - }); - - if ( - !DELEGATES_TO_SYMBOL || - !DELEGATES_TO_EXEC || - FORCED - ) { - var nativeRegExpMethod = /./[SYMBOL]; - var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { - var $exec = regexp.exec; - if ($exec === regexpExec || $exec === RegExpPrototype$1.exec) { - if (DELEGATES_TO_SYMBOL && !forceStringMethod) { - // The native String method already delegates to @@method (this - // polyfilled function), leasing to infinite recursion. - // We avoid it by directly calling the native @@method method. - return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; - } - return { done: true, value: nativeMethod.call(str, regexp, arg2) }; - } - return { done: false }; - }); - - redefine(String.prototype, KEY, methods[0]); - redefine(RegExpPrototype$1, SYMBOL, methods[1]); - } - - if (SHAM) createNonEnumerableProperty(RegExpPrototype$1[SYMBOL], 'sham', true); - }; - - var charAt = stringMultibyte.charAt; - - // `AdvanceStringIndex` abstract operation - // https://tc39.es/ecma262/#sec-advancestringindex - var advanceStringIndex = function (S, index, unicode) { - return index + (unicode ? charAt(S, index).length : 1); - }; - - var floor$1 = Math.floor; - var replace = ''.replace; - var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g; - var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g; - - // `GetSubstitution` abstract operation - // https://tc39.es/ecma262/#sec-getsubstitution - var getSubstitution = function (matched, str, position, captures, namedCaptures, replacement) { - var tailPos = position + matched.length; - var m = captures.length; - var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; - if (namedCaptures !== undefined) { - namedCaptures = toObject(namedCaptures); - symbols = SUBSTITUTION_SYMBOLS; - } - return replace.call(replacement, symbols, function (match, ch) { - var capture; - switch (ch.charAt(0)) { - case '$': return '$'; - case '&': return matched; - case '`': return str.slice(0, position); - case "'": return str.slice(tailPos); - case '<': - capture = namedCaptures[ch.slice(1, -1)]; - break; - default: // \d\d? - var n = +ch; - if (n === 0) return match; - if (n > m) { - var f = floor$1(n / 10); - if (f === 0) return match; - if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); - return match; - } - capture = captures[n - 1]; - } - return capture === undefined ? '' : capture; - }); - }; - - // `RegExpExec` abstract operation - // https://tc39.es/ecma262/#sec-regexpexec - var regexpExecAbstract = function (R, S) { - var exec = R.exec; - if (typeof exec === 'function') { - var result = exec.call(R, S); - if (typeof result !== 'object') { - throw TypeError('RegExp exec method returned something other than an Object or null'); - } - return result; - } - - if (classofRaw(R) !== 'RegExp') { - throw TypeError('RegExp#exec called on incompatible receiver'); - } - - return regexpExec.call(R, S); - }; - - var REPLACE = wellKnownSymbol('replace'); - var max$2 = Math.max; - var min$5 = Math.min; - - var maybeToString = function (it) { - return it === undefined ? it : String(it); - }; - - // IE <= 11 replaces $0 with the whole match, as if it was $& - // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 - var REPLACE_KEEPS_$0 = (function () { - // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing - return 'a'.replace(/./, '$0') === '$0'; - })(); - - // Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string - var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { - if (/./[REPLACE]) { - return /./[REPLACE]('a', '$0') === ''; - } - return false; - })(); - - var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { - var re = /./; - re.exec = function () { - var result = []; - result.groups = { a: '7' }; - return result; - }; - return ''.replace(re, '$') !== '7'; - }); - - // @@replace logic - fixRegexpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) { - var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; - - return [ - // `String.prototype.replace` method - // https://tc39.es/ecma262/#sec-string.prototype.replace - function replace(searchValue, replaceValue) { - var O = requireObjectCoercible(this); - var replacer = searchValue == undefined ? undefined : searchValue[REPLACE]; - return replacer !== undefined - ? replacer.call(searchValue, O, replaceValue) - : nativeReplace.call(String(O), searchValue, replaceValue); - }, - // `RegExp.prototype[@@replace]` method - // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace - function (string, replaceValue) { - if ( - typeof replaceValue === 'string' && - replaceValue.indexOf(UNSAFE_SUBSTITUTE) === -1 && - replaceValue.indexOf('$<') === -1 - ) { - var res = maybeCallNative(nativeReplace, this, string, replaceValue); - if (res.done) return res.value; - } - - var rx = anObject(this); - var S = String(string); - - var functionalReplace = typeof replaceValue === 'function'; - if (!functionalReplace) replaceValue = String(replaceValue); - - var global = rx.global; - if (global) { - var fullUnicode = rx.unicode; - rx.lastIndex = 0; - } - var results = []; - while (true) { - var result = regexpExecAbstract(rx, S); - if (result === null) break; - - results.push(result); - if (!global) break; - - var matchStr = String(result[0]); - if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); - } - - var accumulatedResult = ''; - var nextSourcePosition = 0; - for (var i = 0; i < results.length; i++) { - result = results[i]; - - var matched = String(result[0]); - var position = max$2(min$5(toInteger(result.index), S.length), 0); - var captures = []; - // NOTE: This is equivalent to - // captures = result.slice(1).map(maybeToString) - // but for some reason `nativeSlice.call(result, 1, result.length)` (called in - // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and - // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. - for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); - var namedCaptures = result.groups; - if (functionalReplace) { - var replacerArgs = [matched].concat(captures, position, S); - if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); - var replacement = String(replaceValue.apply(undefined, replacerArgs)); - } else { - replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); - } - if (position >= nextSourcePosition) { - accumulatedResult += S.slice(nextSourcePosition, position) + replacement; - nextSourcePosition = position + matched.length; - } - } - return accumulatedResult + S.slice(nextSourcePosition); - } - ]; - }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE); - - var MATCH$2 = wellKnownSymbol('match'); + var MATCH$2 = wellKnownSymbol$3('match'); // `IsRegExp` abstract operation // https://tc39.es/ecma262/#sec-isregexp var isRegexp = function (it) { var isRegExp; - return isObject$4(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp'); + return isObject$c(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classof$1(it) == 'RegExp'); }; - var UNSUPPORTED_Y$1 = regexpStickyHelpers.UNSUPPORTED_Y; - var arrayPush = [].push; - var min$4 = Math.min; + var apply$2 = functionApply; + var call$6 = functionCall; + var uncurryThis$p = functionUncurryThis; + var fixRegExpWellKnownSymbolLogic$2 = fixRegexpWellKnownSymbolLogic; + var isRegExp$2 = isRegexp; + var anObject$5 = anObject$n; + var requireObjectCoercible$9 = requireObjectCoercible$e; + var speciesConstructor$1 = speciesConstructor$5; + var advanceStringIndex$1 = advanceStringIndex$3; + var toLength$4 = toLength$c; + var toString$e = toString$k; + var getMethod$2 = getMethod$7; + var arraySlice$4 = arraySliceSimple; + var callRegExpExec = regexpExecAbstract; + var regexpExec = regexpExec$3; + var stickyHelpers$1 = regexpStickyHelpers; + var fails$p = fails$V; + + var UNSUPPORTED_Y$1 = stickyHelpers$1.UNSUPPORTED_Y; var MAX_UINT32 = 0xFFFFFFFF; + var min$4 = Math.min; + var $push = [].push; + var exec$4 = uncurryThis$p(/./.exec); + var push$5 = uncurryThis$p($push); + var stringSlice$5 = uncurryThis$p(''.slice); // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec // Weex JS has frozen built-in prototypes, so use try / catch wrapper - var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { + var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails$p(function () { // eslint-disable-next-line regexp/no-empty-group -- required for testing var re = /(?:)/; var originalExec = re.exec; @@ -6252,7 +6314,7 @@ }); // @@split logic - fixRegexpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) { + fixRegExpWellKnownSymbolLogic$2('split', function (SPLIT, nativeSplit, maybeCallNative) { var internalSplit; if ( 'abbc'.split(/(b)*/)[1] == 'c' || @@ -6260,19 +6322,19 @@ 'test'.split(/(?:)/, -1).length != 4 || 'ab'.split(/(?:ab)*/).length != 2 || '.'.split(/(.?)(.?)/).length != 4 || - // eslint-disable-next-line regexp/no-assertion-capturing-group, regexp/no-empty-group -- required for testing + // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing '.'.split(/()()/).length > 1 || ''.split(/.?/).length ) { // based on es5-shim implementation, need to rework it internalSplit = function (separator, limit) { - var string = String(requireObjectCoercible(this)); + var string = toString$e(requireObjectCoercible$9(this)); var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; if (lim === 0) return []; if (separator === undefined) return [string]; // If `separator` is not a regex, use native split - if (!isRegexp(separator)) { - return nativeSplit.call(string, separator, lim); + if (!isRegExp$2(separator)) { + return call$6(nativeSplit, string, separator, lim); } var output = []; var flags = (separator.ignoreCase ? 'i' : '') + @@ -6283,11 +6345,11 @@ // Make `global` and avoid `lastIndex` issues by working with a copy var separatorCopy = new RegExp(separator.source, flags + 'g'); var match, lastIndex, lastLength; - while (match = regexpExec.call(separatorCopy, string)) { + while (match = call$6(regexpExec, separatorCopy, string)) { lastIndex = separatorCopy.lastIndex; if (lastIndex > lastLastIndex) { - output.push(string.slice(lastLastIndex, match.index)); - if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1)); + push$5(output, stringSlice$5(string, lastLastIndex, match.index)); + if (match.length > 1 && match.index < string.length) apply$2($push, output, arraySlice$4(match, 1)); lastLength = match[0].length; lastLastIndex = lastIndex; if (output.length >= lim) break; @@ -6295,14 +6357,14 @@ if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop } if (lastLastIndex === string.length) { - if (lastLength || !separatorCopy.test('')) output.push(''); - } else output.push(string.slice(lastLastIndex)); - return output.length > lim ? output.slice(0, lim) : output; + if (lastLength || !exec$4(separatorCopy, '')) push$5(output, ''); + } else push$5(output, stringSlice$5(string, lastLastIndex)); + return output.length > lim ? arraySlice$4(output, 0, lim) : output; }; // Chakra, V8 } else if ('0'.split(undefined, 0).length) { internalSplit = function (separator, limit) { - return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit); + return separator === undefined && limit === 0 ? [] : call$6(nativeSplit, this, separator, limit); }; } else internalSplit = nativeSplit; @@ -6310,11 +6372,11 @@ // `String.prototype.split` method // https://tc39.es/ecma262/#sec-string.prototype.split function split(separator, limit) { - var O = requireObjectCoercible(this); - var splitter = separator == undefined ? undefined : separator[SPLIT]; - return splitter !== undefined - ? splitter.call(separator, O, limit) - : internalSplit.call(String(O), separator, limit); + var O = requireObjectCoercible$9(this); + var splitter = separator == undefined ? undefined : getMethod$2(separator, SPLIT); + return splitter + ? call$6(splitter, separator, O, limit) + : call$6(internalSplit, toString$e(O), separator, limit); }, // `RegExp.prototype[@@split]` method // https://tc39.es/ecma262/#sec-regexp.prototype-@@split @@ -6322,12 +6384,13 @@ // NOTE: This cannot be properly polyfilled in engines that don't support // the 'y' flag. function (string, limit) { - var res = maybeCallNative(internalSplit, this, string, limit, internalSplit !== nativeSplit); + var rx = anObject$5(this); + var S = toString$e(string); + var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit); + if (res.done) return res.value; - var rx = anObject(this); - var S = String(string); - var C = speciesConstructor(rx, RegExp); + var C = speciesConstructor$1(rx, RegExp); var unicodeMatching = rx.unicode; var flags = (rx.ignoreCase ? 'i' : '') + @@ -6340,49 +6403,55 @@ var splitter = new C(UNSUPPORTED_Y$1 ? '^(?:' + rx.source + ')' : rx, flags); var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; if (lim === 0) return []; - if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : []; + if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : []; var p = 0; var q = 0; var A = []; while (q < S.length) { splitter.lastIndex = UNSUPPORTED_Y$1 ? 0 : q; - var z = regexpExecAbstract(splitter, UNSUPPORTED_Y$1 ? S.slice(q) : S); + var z = callRegExpExec(splitter, UNSUPPORTED_Y$1 ? stringSlice$5(S, q) : S); var e; if ( z === null || - (e = min$4(toLength(splitter.lastIndex + (UNSUPPORTED_Y$1 ? q : 0)), S.length)) === p + (e = min$4(toLength$4(splitter.lastIndex + (UNSUPPORTED_Y$1 ? q : 0)), S.length)) === p ) { - q = advanceStringIndex(S, q, unicodeMatching); + q = advanceStringIndex$1(S, q, unicodeMatching); } else { - A.push(S.slice(p, q)); + push$5(A, stringSlice$5(S, p, q)); if (A.length === lim) return A; for (var i = 1; i <= z.length - 1; i++) { - A.push(z[i]); + push$5(A, z[i]); if (A.length === lim) return A; } q = p = e; } } - A.push(S.slice(p)); + push$5(A, stringSlice$5(S, p)); return A; } ]; }, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y$1); // a string of all valid unicode whitespaces - var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + var whitespaces$4 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; - var whitespace = '[' + whitespaces + ']'; + var uncurryThis$o = functionUncurryThis; + var requireObjectCoercible$8 = requireObjectCoercible$e; + var toString$d = toString$k; + var whitespaces$3 = whitespaces$4; + + var replace$4 = uncurryThis$o(''.replace); + var whitespace = '[' + whitespaces$3 + ']'; var ltrim = RegExp('^' + whitespace + whitespace + '*'); var rtrim$2 = RegExp(whitespace + whitespace + '*$'); // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation var createMethod$2 = function (TYPE) { return function ($this) { - var string = String(requireObjectCoercible($this)); - if (TYPE & 1) string = string.replace(ltrim, ''); - if (TYPE & 2) string = string.replace(rtrim$2, ''); + var string = toString$d(requireObjectCoercible$8($this)); + if (TYPE & 1) string = replace$4(string, ltrim, ''); + if (TYPE & 2) string = replace$4(string, rtrim$2, ''); return string; }; }; @@ -6399,42 +6468,53 @@ trim: createMethod$2(3) }; + var PROPER_FUNCTION_NAME = functionName.PROPER; + var fails$o = fails$V; + var whitespaces$2 = whitespaces$4; + var non = '\u200B\u0085\u180E'; // check that a method works with the correct list // of whitespaces and has a correct name var stringTrimForced = function (METHOD_NAME) { - return fails(function () { - return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME; + return fails$o(function () { + return !!whitespaces$2[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces$2[METHOD_NAME].name !== METHOD_NAME); }); }; + var $$W = _export; var $trim = stringTrim.trim; - + var forcedStringTrimMethod$2 = stringTrimForced; // `String.prototype.trim` method // https://tc39.es/ecma262/#sec-string.prototype.trim - _export({ target: 'String', proto: true, forced: stringTrimForced('trim') }, { + $$W({ target: 'String', proto: true, forced: forcedStringTrimMethod$2('trim') }, { trim: function trim() { return $trim(this); } }); - var defineProperty$3 = objectDefineProperty.f; + var DESCRIPTORS$b = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$n = functionUncurryThis; + var defineProperty$6 = objectDefineProperty.f; var FunctionPrototype = Function.prototype; - var FunctionPrototypeToString = FunctionPrototype.toString; - var nameRE = /^\s*function ([^ (]*)/; + var functionToString = uncurryThis$n(FunctionPrototype.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec$2 = uncurryThis$n(nameRE.exec); var NAME = 'name'; // Function instances `.name` property // https://tc39.es/ecma262/#sec-function-instances-name - if (descriptors && !(NAME in FunctionPrototype)) { - defineProperty$3(FunctionPrototype, NAME, { + if (DESCRIPTORS$b && !FUNCTION_NAME_EXISTS) { + defineProperty$6(FunctionPrototype, NAME, { configurable: true, get: function () { try { - return FunctionPrototypeToString.call(this).match(nameRE)[1]; + return regExpExec$2(nameRE, functionToString(this))[1]; } catch (error) { return ''; } @@ -6442,42 +6522,54 @@ }); } + var $$V = _export; + var DESCRIPTORS$a = descriptors; + var create$5 = objectCreate; + // `Object.create` method // https://tc39.es/ecma262/#sec-object.create - _export({ target: 'Object', stat: true, sham: !descriptors }, { - create: objectCreate + $$V({ target: 'Object', stat: true, sham: !DESCRIPTORS$a }, { + create: create$5 }); - var slice$3 = [].slice; - var MSIE = /MSIE .\./.test(engineUserAgent); // <- dirty ie9- check + var $$U = _export; + var global$l = global$1o; + var apply$1 = functionApply; + var isCallable$2 = isCallable$r; + var userAgent$1 = engineUserAgent; + var arraySlice$3 = arraySlice$b; + var validateArgumentsLength$1 = validateArgumentsLength$4; + + var MSIE = /MSIE .\./.test(userAgent$1); // <- dirty ie9- check + var Function$2 = global$l.Function; var wrap$1 = function (scheduler) { return function (handler, timeout /* , ...arguments */) { - var boundArgs = arguments.length > 2; - var args = boundArgs ? slice$3.call(arguments, 2) : undefined; + var boundArgs = validateArgumentsLength$1(arguments.length, 1) > 2; + var fn = isCallable$2(handler) ? handler : Function$2(handler); + var args = boundArgs ? arraySlice$3(arguments, 2) : undefined; return scheduler(boundArgs ? function () { - // eslint-disable-next-line no-new-func -- spec requirement - (typeof handler == 'function' ? handler : Function(handler)).apply(this, args); - } : handler, timeout); + apply$1(fn, this, args); + } : fn, timeout); }; }; // ie9- setTimeout & setInterval additional parameters fix // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers - _export({ global: true, bind: true, forced: MSIE }, { + $$U({ global: true, bind: true, forced: MSIE }, { // `setTimeout` method // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout - setTimeout: wrap$1(global$2.setTimeout), + setTimeout: wrap$1(global$l.setTimeout), // `setInterval` method // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval - setInterval: wrap$1(global$2.setInterval) + setInterval: wrap$1(global$l.setInterval) }); - var global$1 = typeof globalThis !== 'undefined' && globalThis || typeof self !== 'undefined' && self || typeof global$1 !== 'undefined' && global$1; + var global$k = typeof globalThis !== 'undefined' && globalThis || typeof self !== 'undefined' && self || typeof global$k !== 'undefined' && global$k; var support = { - searchParams: 'URLSearchParams' in global$1, - iterable: 'Symbol' in global$1 && 'iterator' in Symbol, - blob: 'FileReader' in global$1 && 'Blob' in global$1 && function () { + searchParams: 'URLSearchParams' in global$k, + iterable: 'Symbol' in global$k && 'iterator' in Symbol, + blob: 'FileReader' in global$k && 'Blob' in global$k && function () { try { new Blob(); return true; @@ -6485,8 +6577,8 @@ return false; } }(), - formData: 'FormData' in global$1, - arrayBuffer: 'ArrayBuffer' in global$1 + formData: 'FormData' in global$k, + arrayBuffer: 'ArrayBuffer' in global$k }; function isDataView(obj) { @@ -6961,7 +7053,7 @@ }); }; - var DOMException$1 = global$1.DOMException; + var DOMException$1 = global$k.DOMException; try { new DOMException$1(); @@ -7024,7 +7116,7 @@ function fixUrl(url) { try { - return url === '' && global$1.location.href ? global$1.location.href : url; + return url === '' && global$k.location.href ? global$k.location.href : url; } catch (e) { return url; } @@ -7072,79 +7164,117 @@ } fetch$1.polyfill = true; - if (!global$1.fetch) { - global$1.fetch = fetch$1; - global$1.Headers = Headers; - global$1.Request = Request; - global$1.Response = Response; + if (!global$k.fetch) { + global$k.fetch = fetch$1; + global$k.Headers = Headers; + global$k.Request = Request; + global$k.Response = Response; } + var $$T = _export; + var DESCRIPTORS$9 = descriptors; + var defineProperty$5 = objectDefineProperty.f; + // `Object.defineProperty` method // https://tc39.es/ecma262/#sec-object.defineproperty - _export({ target: 'Object', stat: true, forced: !descriptors, sham: !descriptors }, { - defineProperty: objectDefineProperty.f + // eslint-disable-next-line es/no-object-defineproperty -- safe + $$T({ target: 'Object', stat: true, forced: Object.defineProperty !== defineProperty$5, sham: !DESCRIPTORS$9 }, { + defineProperty: defineProperty$5 }); + var $$S = _export; + var setPrototypeOf = objectSetPrototypeOf; + // `Object.setPrototypeOf` method // https://tc39.es/ecma262/#sec-object.setprototypeof - _export({ target: 'Object', stat: true }, { - setPrototypeOf: objectSetPrototypeOf + $$S({ target: 'Object', stat: true }, { + setPrototypeOf: setPrototypeOf }); - var FAILS_ON_PRIMITIVES$3 = fails(function () { objectGetPrototypeOf(1); }); + var $$R = _export; + var fails$n = fails$V; + var toObject$8 = toObject$i; + var nativeGetPrototypeOf = objectGetPrototypeOf; + var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + + var FAILS_ON_PRIMITIVES$4 = fails$n(function () { nativeGetPrototypeOf(1); }); // `Object.getPrototypeOf` method // https://tc39.es/ecma262/#sec-object.getprototypeof - _export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$3, sham: !correctPrototypeGetter }, { + $$R({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$4, sham: !CORRECT_PROTOTYPE_GETTER }, { getPrototypeOf: function getPrototypeOf(it) { - return objectGetPrototypeOf(toObject(it)); + return nativeGetPrototypeOf(toObject$8(it)); } }); - var slice$2 = [].slice; + var global$j = global$1o; + var uncurryThis$m = functionUncurryThis; + var aCallable$2 = aCallable$a; + var isObject$b = isObject$s; + var hasOwn$5 = hasOwnProperty_1; + var arraySlice$2 = arraySlice$b; + var NATIVE_BIND = functionBindNative; + + var Function$1 = global$j.Function; + var concat$1 = uncurryThis$m([].concat); + var join$3 = uncurryThis$m([].join); var factories = {}; var construct = function (C, argsLength, args) { - if (!(argsLength in factories)) { + if (!hasOwn$5(factories, argsLength)) { for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']'; - // eslint-disable-next-line no-new-func -- we have no proper alternatives, IE8- only - factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')'); + factories[argsLength] = Function$1('C,a', 'return new C(' + join$3(list, ',') + ')'); } return factories[argsLength](C, args); }; // `Function.prototype.bind` method implementation // https://tc39.es/ecma262/#sec-function.prototype.bind - var functionBind = Function.bind || function bind(that /* , ...args */) { - var fn = aFunction(this); - var partArgs = slice$2.call(arguments, 1); + var functionBind = NATIVE_BIND ? Function$1.bind : function bind(that /* , ...args */) { + var F = aCallable$2(this); + var Prototype = F.prototype; + var partArgs = arraySlice$2(arguments, 1); var boundFunction = function bound(/* args... */) { - var args = partArgs.concat(slice$2.call(arguments)); - return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args); + var args = concat$1(partArgs, arraySlice$2(arguments)); + return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args); }; - if (isObject$4(fn.prototype)) boundFunction.prototype = fn.prototype; + if (isObject$b(Prototype)) boundFunction.prototype = Prototype; return boundFunction; }; - var nativeConstruct = getBuiltIn('Reflect', 'construct'); + var $$Q = _export; + var getBuiltIn$1 = getBuiltIn$b; + var apply = functionApply; + var bind$7 = functionBind; + var aConstructor = aConstructor$3; + var anObject$4 = anObject$n; + var isObject$a = isObject$s; + var create$4 = objectCreate; + var fails$m = fails$V; + + var nativeConstruct = getBuiltIn$1('Reflect', 'construct'); + var ObjectPrototype = Object.prototype; + var push$4 = [].push; // `Reflect.construct` method // https://tc39.es/ecma262/#sec-reflect.construct // MS Edge supports only 2 arguments and argumentsList argument is optional // FF Nightly sets third argument as `new.target`, but does not create `this` from it - var NEW_TARGET_BUG = fails(function () { + var NEW_TARGET_BUG = fails$m(function () { function F() { /* empty */ } return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F); }); - var ARGS_BUG = !fails(function () { + + var ARGS_BUG = !fails$m(function () { nativeConstruct(function () { /* empty */ }); }); - var FORCED$a = NEW_TARGET_BUG || ARGS_BUG; - _export({ target: 'Reflect', stat: true, forced: FORCED$a, sham: FORCED$a }, { + var FORCED$c = NEW_TARGET_BUG || ARGS_BUG; + + $$Q({ target: 'Reflect', stat: true, forced: FORCED$c, sham: FORCED$c }, { construct: function construct(Target, args /* , newTarget */) { - aFunction(Target); - anObject(args); - var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]); + aConstructor(Target); + anObject$4(args); + var newTarget = arguments.length < 3 ? Target : aConstructor(arguments[2]); if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget); if (Target == newTarget) { // w/o altered newTarget, optimization for 0-4 arguments @@ -7157,51 +7287,78 @@ } // w/o altered newTarget, lot of arguments case var $args = [null]; - $args.push.apply($args, args); - return new (functionBind.apply(Target, $args))(); + apply(push$4, $args, args); + return new (apply(bind$7, Target, $args))(); } // with altered newTarget, not support built-in constructors var proto = newTarget.prototype; - var instance = objectCreate(isObject$4(proto) ? proto : Object.prototype); - var result = Function.apply.call(Target, instance, args); - return isObject$4(result) ? result : instance; + var instance = create$4(isObject$a(proto) ? proto : ObjectPrototype); + var result = apply(Target, instance, args); + return isObject$a(result) ? result : instance; } }); + var hasOwn$4 = hasOwnProperty_1; + + var isDataDescriptor$1 = function (descriptor) { + return descriptor !== undefined && (hasOwn$4(descriptor, 'value') || hasOwn$4(descriptor, 'writable')); + }; + + var $$P = _export; + var call$5 = functionCall; + var isObject$9 = isObject$s; + var anObject$3 = anObject$n; + var isDataDescriptor = isDataDescriptor$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var getPrototypeOf = objectGetPrototypeOf; + // `Reflect.get` method // https://tc39.es/ecma262/#sec-reflect.get function get$3(target, propertyKey /* , receiver */) { var receiver = arguments.length < 3 ? target : arguments[2]; var descriptor, prototype; - if (anObject(target) === receiver) return target[propertyKey]; - if (descriptor = objectGetOwnPropertyDescriptor.f(target, propertyKey)) return has$1(descriptor, 'value') + if (anObject$3(target) === receiver) return target[propertyKey]; + descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey); + if (descriptor) return isDataDescriptor(descriptor) ? descriptor.value - : descriptor.get === undefined - ? undefined - : descriptor.get.call(receiver); - if (isObject$4(prototype = objectGetPrototypeOf(target))) return get$3(prototype, propertyKey, receiver); + : descriptor.get === undefined ? undefined : call$5(descriptor.get, receiver); + if (isObject$9(prototype = getPrototypeOf(target))) return get$3(prototype, propertyKey, receiver); } - _export({ target: 'Reflect', stat: true }, { + $$P({ target: 'Reflect', stat: true }, { get: get$3 }); + var $$O = _export; + var fails$l = fails$V; + var toIndexedObject$1 = toIndexedObject$d; var nativeGetOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var DESCRIPTORS$8 = descriptors; - - var FAILS_ON_PRIMITIVES$2 = fails(function () { nativeGetOwnPropertyDescriptor(1); }); - var FORCED$9 = !descriptors || FAILS_ON_PRIMITIVES$2; + var FAILS_ON_PRIMITIVES$3 = fails$l(function () { nativeGetOwnPropertyDescriptor(1); }); + var FORCED$b = !DESCRIPTORS$8 || FAILS_ON_PRIMITIVES$3; // `Object.getOwnPropertyDescriptor` method // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor - _export({ target: 'Object', stat: true, forced: FORCED$9, sham: !descriptors }, { + $$O({ target: 'Object', stat: true, forced: FORCED$b, sham: !DESCRIPTORS$8 }, { getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { - return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); + return nativeGetOwnPropertyDescriptor(toIndexedObject$1(it), key); } }); - var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('splice'); + var $$N = _export; + var global$i = global$1o; + var toAbsoluteIndex$1 = toAbsoluteIndex$9; + var toIntegerOrInfinity$2 = toIntegerOrInfinity$b; + var lengthOfArrayLike$5 = lengthOfArrayLike$i; + var toObject$7 = toObject$i; + var arraySpeciesCreate$2 = arraySpeciesCreate$4; + var createProperty$2 = createProperty$5; + var arrayMethodHasSpeciesSupport$2 = arrayMethodHasSpeciesSupport$5; + var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport$2('splice'); + + var TypeError$6 = global$i.TypeError; var max$1 = Math.max; var min$3 = Math.min; var MAX_SAFE_INTEGER$1 = 0x1FFFFFFFFFFFFF; @@ -7210,11 +7367,11 @@ // `Array.prototype.splice` method // https://tc39.es/ecma262/#sec-array.prototype.splice // with adding support of @@species - _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + $$N({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { splice: function splice(start, deleteCount /* , ...items */) { - var O = toObject(this); - var len = toLength(O.length); - var actualStart = toAbsoluteIndex(start, len); + var O = toObject$7(this); + var len = lengthOfArrayLike$5(O); + var actualStart = toAbsoluteIndex$1(start, len); var argumentsLength = arguments.length; var insertCount, actualDeleteCount, A, k, from, to; if (argumentsLength === 0) { @@ -7224,15 +7381,15 @@ actualDeleteCount = len - actualStart; } else { insertCount = argumentsLength - 2; - actualDeleteCount = min$3(max$1(toInteger(deleteCount), 0), len - actualStart); + actualDeleteCount = min$3(max$1(toIntegerOrInfinity$2(deleteCount), 0), len - actualStart); } if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER$1) { - throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED); + throw TypeError$6(MAXIMUM_ALLOWED_LENGTH_EXCEEDED); } - A = arraySpeciesCreate(O, actualDeleteCount); + A = arraySpeciesCreate$2(O, actualDeleteCount); for (k = 0; k < actualDeleteCount; k++) { from = actualStart + k; - if (from in O) createProperty(A, k, O[from]); + if (from in O) createProperty$2(A, k, O[from]); } A.length = actualDeleteCount; if (insertCount < actualDeleteCount) { @@ -7259,17 +7416,24 @@ } }); + var defineWellKnownSymbol$1 = defineWellKnownSymbol$4; + // `Symbol.toStringTag` well-known symbol // https://tc39.es/ecma262/#sec-symbol.tostringtag - defineWellKnownSymbol('toStringTag'); + defineWellKnownSymbol$1('toStringTag'); + + var global$h = global$1o; + var setToStringTag$3 = setToStringTag$a; // JSON[@@toStringTag] property // https://tc39.es/ecma262/#sec-json-@@tostringtag - setToStringTag(global$2.JSON, 'JSON', true); + setToStringTag$3(global$h.JSON, 'JSON', true); + + var setToStringTag$2 = setToStringTag$a; // Math[@@toStringTag] property // https://tc39.es/ecma262/#sec-math-@@tostringtag - setToStringTag(Math, 'Math', true); + setToStringTag$2(Math, 'Math', true); (function (factory) { factory(); @@ -7789,48 +7953,62 @@ }; } - var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); + var $$M = _export; + var global$g = global$1o; + var fails$k = fails$V; + var isArray$3 = isArray$8; + var isObject$8 = isObject$s; + var toObject$6 = toObject$i; + var lengthOfArrayLike$4 = lengthOfArrayLike$i; + var createProperty$1 = createProperty$5; + var arraySpeciesCreate$1 = arraySpeciesCreate$4; + var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$5; + var wellKnownSymbol$2 = wellKnownSymbol$t; + var V8_VERSION = engineV8Version; + + var IS_CONCAT_SPREADABLE = wellKnownSymbol$2('isConcatSpreadable'); var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; + var TypeError$5 = global$g.TypeError; // We can't use this feature detection in V8 since it causes // deoptimization and serious performance degradation // https://github.com/zloirock/core-js/issues/679 - var IS_CONCAT_SPREADABLE_SUPPORT = engineV8Version >= 51 || !fails(function () { + var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails$k(function () { var array = []; array[IS_CONCAT_SPREADABLE] = false; return array.concat()[0] !== array; }); - var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); + var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport$1('concat'); var isConcatSpreadable = function (O) { - if (!isObject$4(O)) return false; + if (!isObject$8(O)) return false; var spreadable = O[IS_CONCAT_SPREADABLE]; - return spreadable !== undefined ? !!spreadable : isArray(O); + return spreadable !== undefined ? !!spreadable : isArray$3(O); }; - var FORCED$8 = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; + var FORCED$a = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; // `Array.prototype.concat` method // https://tc39.es/ecma262/#sec-array.prototype.concat // with adding support of @@isConcatSpreadable and @@species - _export({ target: 'Array', proto: true, forced: FORCED$8 }, { + $$M({ target: 'Array', proto: true, forced: FORCED$a }, { // eslint-disable-next-line no-unused-vars -- required for `.length` concat: function concat(arg) { - var O = toObject(this); - var A = arraySpeciesCreate(O, 0); + var O = toObject$6(this); + var A = arraySpeciesCreate$1(O, 0); var n = 0; var i, k, length, len, E; for (i = -1, length = arguments.length; i < length; i++) { E = i === -1 ? O : arguments[i]; if (isConcatSpreadable(E)) { - len = toLength(E.length); - if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); - for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); + len = lengthOfArrayLike$4(E); + if (n + len > MAX_SAFE_INTEGER) throw TypeError$5(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); } else { - if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); - createProperty(A, n++, E); + if (n >= MAX_SAFE_INTEGER) throw TypeError$5(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + createProperty$1(A, n++, E); } } A.length = n; @@ -7838,70 +8016,152 @@ } }); + var DESCRIPTORS$7 = descriptors; + var uncurryThis$l = functionUncurryThis; + var call$4 = functionCall; + var fails$j = fails$V; + var objectKeys$1 = objectKeys$4; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject$5 = toObject$i; + var IndexedObject = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$4 = Object.defineProperty; + var concat = uncurryThis$l([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$j(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$7 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol(); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] != 7 || objectKeys$1($assign({}, B)).join('') != alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$5(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$7 || call$4(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$L = _export; + var assign$2 = objectAssign; + // `Object.assign` method // https://tc39.es/ecma262/#sec-object.assign // eslint-disable-next-line es/no-object-assign -- required for testing - _export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, { - assign: objectAssign + $$L({ target: 'Object', stat: true, forced: Object.assign !== assign$2 }, { + assign: assign$2 }); + var $$K = _export; var $filter = arrayIteration.filter; - + var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$5; var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); // `Array.prototype.filter` method // https://tc39.es/ecma262/#sec-array.prototype.filter // with adding support of @@species - _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + $$K({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { filter: function filter(callbackfn /* , thisArg */) { return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); - var FAILS_ON_PRIMITIVES$1 = fails(function () { objectKeys(1); }); + var $$J = _export; + var toObject$4 = toObject$i; + var nativeKeys = objectKeys$4; + var fails$i = fails$V; + + var FAILS_ON_PRIMITIVES$2 = fails$i(function () { nativeKeys(1); }); // `Object.keys` method // https://tc39.es/ecma262/#sec-object.keys - _export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$1 }, { + $$J({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$2 }, { keys: function keys(it) { - return objectKeys(toObject(it)); + return nativeKeys(toObject$4(it)); } }); - var nativeReverse = [].reverse; + var $$I = _export; + var uncurryThis$k = functionUncurryThis; + var isArray$2 = isArray$8; + + var un$Reverse = uncurryThis$k([].reverse); var test$1 = [1, 2]; // `Array.prototype.reverse` method // https://tc39.es/ecma262/#sec-array.prototype.reverse // fix for Safari 12.0 bug // https://bugs.webkit.org/show_bug.cgi?id=188794 - _export({ target: 'Array', proto: true, forced: String(test$1) === String(test$1.reverse()) }, { + $$I({ target: 'Array', proto: true, forced: String(test$1) === String(test$1.reverse()) }, { reverse: function reverse() { // eslint-disable-next-line no-self-assign -- dirty hack - if (isArray(this)) this.length = this.length; - return nativeReverse.call(this); + if (isArray$2(this)) this.length = this.length; + return un$Reverse(this); } }); + var global$f = global$1o; + var fails$h = fails$V; + var uncurryThis$j = functionUncurryThis; + var toString$c = toString$k; var trim$4 = stringTrim.trim; + var whitespaces$1 = whitespaces$4; - - var $parseFloat = global$2.parseFloat; - var FORCED$7 = 1 / $parseFloat(whitespaces + '-0') !== -Infinity; + var charAt$2 = uncurryThis$j(''.charAt); + var n$ParseFloat = global$f.parseFloat; + var Symbol$2 = global$f.Symbol; + var ITERATOR$1 = Symbol$2 && Symbol$2.iterator; + var FORCED$9 = 1 / n$ParseFloat(whitespaces$1 + '-0') !== -Infinity + // MS Edge 18- broken with boxed symbols + || (ITERATOR$1 && !fails$h(function () { n$ParseFloat(Object(ITERATOR$1)); })); // `parseFloat` method // https://tc39.es/ecma262/#sec-parsefloat-string - var numberParseFloat = FORCED$7 ? function parseFloat(string) { - var trimmedString = trim$4(String(string)); - var result = $parseFloat(trimmedString); - return result === 0 && trimmedString.charAt(0) == '-' ? -0 : result; - } : $parseFloat; + var numberParseFloat = FORCED$9 ? function parseFloat(string) { + var trimmedString = trim$4(toString$c(string)); + var result = n$ParseFloat(trimmedString); + return result === 0 && charAt$2(trimmedString, 0) == '-' ? -0 : result; + } : n$ParseFloat; + + var $$H = _export; + var $parseFloat = numberParseFloat; // `parseFloat` method // https://tc39.es/ecma262/#sec-parsefloat-string - _export({ global: true, forced: parseFloat != numberParseFloat }, { - parseFloat: numberParseFloat + $$H({ global: true, forced: parseFloat != $parseFloat }, { + parseFloat: $parseFloat }); /* @@ -8192,6 +8452,10 @@ 'sled': true, 'yes': true }, + 'seamark:type': { + 'separation_lane': true, + 'separation_roundabout': true + }, 'waterway': { 'canal': true, 'ditch': true, @@ -8307,55 +8571,102 @@ tidal_channel: true }; + var global$e = global$1o; + var fails$g = fails$V; + var uncurryThis$i = functionUncurryThis; + var toString$b = toString$k; var trim$3 = stringTrim.trim; + var whitespaces = whitespaces$4; - - var $parseInt = global$2.parseInt; - var hex$2 = /^[+-]?0[Xx]/; - var FORCED$6 = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22; + var $parseInt$1 = global$e.parseInt; + var Symbol$1 = global$e.Symbol; + var ITERATOR = Symbol$1 && Symbol$1.iterator; + var hex$2 = /^[+-]?0x/i; + var exec$3 = uncurryThis$i(hex$2.exec); + var FORCED$8 = $parseInt$1(whitespaces + '08') !== 8 || $parseInt$1(whitespaces + '0x16') !== 22 + // MS Edge 18- broken with boxed symbols + || (ITERATOR && !fails$g(function () { $parseInt$1(Object(ITERATOR)); })); // `parseInt` method // https://tc39.es/ecma262/#sec-parseint-string-radix - var numberParseInt = FORCED$6 ? function parseInt(string, radix) { - var S = trim$3(String(string)); - return $parseInt(S, (radix >>> 0) || (hex$2.test(S) ? 16 : 10)); - } : $parseInt; + var numberParseInt = FORCED$8 ? function parseInt(string, radix) { + var S = trim$3(toString$b(string)); + return $parseInt$1(S, (radix >>> 0) || (exec$3(hex$2, S) ? 16 : 10)); + } : $parseInt$1; + + var $$G = _export; + var $parseInt = numberParseInt; // `parseInt` method // https://tc39.es/ecma262/#sec-parseint-string-radix - _export({ global: true, forced: parseInt != numberParseInt }, { - parseInt: numberParseInt + $$G({ global: true, forced: parseInt != $parseInt }, { + parseInt: $parseInt }); - var freezing = !fails(function () { - // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing - return Object.isExtensible(Object.preventExtensions({})); + var internalMetadata = {exports: {}}; + + // FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it + var fails$f = fails$V; + + var arrayBufferNonExtensible = fails$f(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } }); - var internalMetadata = createCommonjsModule(function (module) { - var defineProperty = objectDefineProperty.f; + var fails$e = fails$V; + var isObject$7 = isObject$s; + var classof = classofRaw$1; + var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + // eslint-disable-next-line es/no-object-isextensible -- safe + var $isExtensible = Object.isExtensible; + var FAILS_ON_PRIMITIVES$1 = fails$e(function () { $isExtensible(1); }); + // `Object.isExtensible` method + // https://tc39.es/ecma262/#sec-object.isextensible + var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$7(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) == 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; + } : $isExtensible; - var METADATA = uid('meta'); - var id = 0; + var fails$d = fails$V; - // eslint-disable-next-line es/no-object-isextensible -- safe - var isExtensible = Object.isExtensible || function () { - return true; - }; + var freezing = !fails$d(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); + }); + + var $$F = _export; + var uncurryThis$h = functionUncurryThis; + var hiddenKeys = hiddenKeys$6; + var isObject$6 = isObject$s; + var hasOwn$3 = hasOwnProperty_1; + var defineProperty$3 = objectDefineProperty.f; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; + var isExtensible = objectIsExtensible; + var uid = uid$5; + var FREEZING$1 = freezing; + + var REQUIRED = false; + var METADATA = uid('meta'); + var id$1 = 0; var setMetadata = function (it) { - defineProperty(it, METADATA, { value: { - objectID: 'O' + ++id, // object ID + defineProperty$3(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID weakData: {} // weak collections IDs } }); }; - var fastKey = function (it, create) { + var fastKey$1 = function (it, create) { // return a primitive with prefix - if (!isObject$4(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; - if (!has$1(it, METADATA)) { + if (!isObject$6(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$3(it, METADATA)) { // can't set metadata to uncaught frozen object if (!isExtensible(it)) return 'F'; // not necessary to add metadata @@ -8367,7 +8678,7 @@ }; var getWeakData = function (it, create) { - if (!has$1(it, METADATA)) { + if (!hasOwn$3(it, METADATA)) { // can't set metadata to uncaught frozen object if (!isExtensible(it)) return true; // not necessary to add metadata @@ -8379,52 +8690,92 @@ }; // add metadata on freeze-family methods calling - var onFreeze = function (it) { - if (freezing && meta.REQUIRED && isExtensible(it) && !has$1(it, METADATA)) setMetadata(it); + var onFreeze$1 = function (it) { + if (FREEZING$1 && REQUIRED && isExtensible(it) && !hasOwn$3(it, METADATA)) setMetadata(it); return it; }; - var meta = module.exports = { - REQUIRED: false, - fastKey: fastKey, - getWeakData: getWeakData, - onFreeze: onFreeze + var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$h([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$F({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } }; - hiddenKeys$1[METADATA] = true; - }); + var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey$1, + getWeakData: getWeakData, + onFreeze: onFreeze$1 + }; - var collection = function (CONSTRUCTOR_NAME, wrapper, common) { + hiddenKeys[METADATA] = true; + + var $$E = _export; + var global$d = global$1o; + var uncurryThis$g = functionUncurryThis; + var isForced$2 = isForced_1; + var redefine$4 = redefine$h.exports; + var InternalMetadataModule = internalMetadata.exports; + var iterate$1 = iterate$3; + var anInstance$2 = anInstance$7; + var isCallable$1 = isCallable$r; + var isObject$5 = isObject$s; + var fails$c = fails$V; + var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$4; + var setToStringTag$1 = setToStringTag$a; + var inheritIfRequired$2 = inheritIfRequired$4; + + var collection$2 = function (CONSTRUCTOR_NAME, wrapper, common) { var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; var ADDER = IS_MAP ? 'set' : 'add'; - var NativeConstructor = global$2[CONSTRUCTOR_NAME]; + var NativeConstructor = global$d[CONSTRUCTOR_NAME]; var NativePrototype = NativeConstructor && NativeConstructor.prototype; var Constructor = NativeConstructor; var exported = {}; var fixMethod = function (KEY) { - var nativeMethod = NativePrototype[KEY]; - redefine(NativePrototype, KEY, + var uncurriedNativeMethod = uncurryThis$g(NativePrototype[KEY]); + redefine$4(NativePrototype, KEY, KEY == 'add' ? function add(value) { - nativeMethod.call(this, value === 0 ? 0 : value); + uncurriedNativeMethod(this, value === 0 ? 0 : value); return this; } : KEY == 'delete' ? function (key) { - return IS_WEAK && !isObject$4(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); } : KEY == 'get' ? function get(key) { - return IS_WEAK && !isObject$4(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); + return IS_WEAK && !isObject$5(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); } : KEY == 'has' ? function has(key) { - return IS_WEAK && !isObject$4(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); } : function set(key, value) { - nativeMethod.call(this, key === 0 ? 0 : key, value); + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); return this; } ); }; - var REPLACE = isForced_1( + var REPLACE = isForced$2( CONSTRUCTOR_NAME, - typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + !isCallable$1(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$c(function () { new NativeConstructor().entries().next(); })) ); @@ -8432,18 +8783,18 @@ if (REPLACE) { // create collection constructor Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); - internalMetadata.REQUIRED = true; - } else if (isForced_1(CONSTRUCTOR_NAME, true)) { + InternalMetadataModule.enable(); + } else if (isForced$2(CONSTRUCTOR_NAME, true)) { var instance = new Constructor(); // early implementations not supports chaining var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false - var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + var THROWS_ON_PRIMITIVES = fails$c(function () { instance.has(1); }); // most early implementations doesn't supports iterables, most modern - not close it correctly // eslint-disable-next-line no-new -- required for testing - var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + var ACCEPT_ITERABLES = checkCorrectnessOfIteration$1(function (iterable) { new NativeConstructor(iterable); }); // for early implementations -0 and +0 not the same - var BUGGY_ZERO = !IS_WEAK && fails(function () { + var BUGGY_ZERO = !IS_WEAK && fails$c(function () { // V8 ~ Chromium 42- fails only with 5+ elements var $instance = new NativeConstructor(); var index = 5; @@ -8453,9 +8804,9 @@ if (!ACCEPT_ITERABLES) { Constructor = wrapper(function (dummy, iterable) { - anInstance(dummy, Constructor, CONSTRUCTOR_NAME); - var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); - if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + anInstance$2(dummy, NativePrototype); + var that = inheritIfRequired$2(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); return that; }); Constructor.prototype = NativePrototype; @@ -8475,9 +8826,9 @@ } exported[CONSTRUCTOR_NAME] = Constructor; - _export({ global: true, forced: Constructor != NativeConstructor }, exported); + $$E({ global: true, forced: Constructor != NativeConstructor }, exported); - setToStringTag(Constructor, CONSTRUCTOR_NAME); + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); @@ -8485,35 +8836,37 @@ }; var defineProperty$2 = objectDefineProperty.f; - - - - - - - - - var fastKey = internalMetadata.fastKey; - - - var setInternalState = internalState.set; - var internalStateGetterFor = internalState.getterFor; - - var collectionStrong = { + var create$3 = objectCreate; + var redefineAll = redefineAll$4; + var bind$6 = functionBindContext; + var anInstance$1 = anInstance$7; + var iterate = iterate$3; + var defineIterator = defineIterator$3; + var setSpecies$1 = setSpecies$5; + var DESCRIPTORS$6 = descriptors; + var fastKey = internalMetadata.exports.fastKey; + var InternalStateModule$1 = internalState; + + var setInternalState$1 = InternalStateModule$1.set; + var internalStateGetterFor = InternalStateModule$1.getterFor; + + var collectionStrong$2 = { getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { - var C = wrapper(function (that, iterable) { - anInstance(that, C, CONSTRUCTOR_NAME); - setInternalState(that, { + var Constructor = wrapper(function (that, iterable) { + anInstance$1(that, Prototype); + setInternalState$1(that, { type: CONSTRUCTOR_NAME, - index: objectCreate(null), + index: create$3(null), first: undefined, last: undefined, size: 0 }); - if (!descriptors) that.size = 0; + if (!DESCRIPTORS$6) that.size = 0; if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); }); + var Prototype = Constructor.prototype; + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); var define = function (that, key, value) { @@ -8535,7 +8888,7 @@ }; if (!state.first) state.first = entry; if (previous) previous.next = entry; - if (descriptors) state.size++; + if (DESCRIPTORS$6) state.size++; else that.size++; // add to index if (index !== 'F') state.index[index] = entry; @@ -8554,7 +8907,7 @@ } }; - redefineAll(C.prototype, { + redefineAll(Prototype, { // `{ Map, Set }.prototype.clear()` methods // https://tc39.es/ecma262/#sec-map.prototype.clear // https://tc39.es/ecma262/#sec-set.prototype.clear @@ -8570,7 +8923,7 @@ entry = entry.next; } state.first = state.last = undefined; - if (descriptors) state.size = 0; + if (DESCRIPTORS$6) state.size = 0; else that.size = 0; }, // `{ Map, Set }.prototype.delete(key)` methods @@ -8589,7 +8942,7 @@ if (next) next.previous = prev; if (state.first == entry) state.first = next; if (state.last == entry) state.last = prev; - if (descriptors) state.size--; + if (DESCRIPTORS$6) state.size--; else that.size--; } return !!entry; }, @@ -8598,7 +8951,7 @@ // https://tc39.es/ecma262/#sec-set.prototype.foreach forEach: function forEach(callbackfn /* , that = undefined */) { var state = getInternalState(this); - var boundFunction = functionBindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var boundFunction = bind$6(callbackfn, arguments.length > 1 ? arguments[1] : undefined); var entry; while (entry = entry ? entry.next : state.first) { boundFunction(entry.value, entry.key, this); @@ -8614,7 +8967,7 @@ } }); - redefineAll(C.prototype, IS_MAP ? { + redefineAll(Prototype, IS_MAP ? { // `Map.prototype.get(key)` method // https://tc39.es/ecma262/#sec-map.prototype.get get: function get(key) { @@ -8633,14 +8986,14 @@ return define(this, value = value === 0 ? 0 : value, value); } }); - if (descriptors) defineProperty$2(C.prototype, 'size', { + if (DESCRIPTORS$6) defineProperty$2(Prototype, 'size', { get: function () { return getInternalState(this).size; } }); - return C; + return Constructor; }, - setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); @@ -8653,8 +9006,8 @@ // https://tc39.es/ecma262/#sec-set.prototype.keys // https://tc39.es/ecma262/#sec-set.prototype.values // https://tc39.es/ecma262/#sec-set.prototype-@@iterator - defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { - setInternalState(this, { + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState$1(this, { type: ITERATOR_NAME, target: iterated, state: getInternalCollectionState(iterated), @@ -8682,15 +9035,18 @@ // `{ Map, Set }.prototype[@@species]` accessors // https://tc39.es/ecma262/#sec-get-map-@@species // https://tc39.es/ecma262/#sec-get-set-@@species - setSpecies(CONSTRUCTOR_NAME); + setSpecies$1(CONSTRUCTOR_NAME); } }; + var collection$1 = collection$2; + var collectionStrong$1 = collectionStrong$2; + // `Set` constructor // https://tc39.es/ecma262/#sec-set-objects - collection('Set', function (init) { + collection$1('Set', function (init) { return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; - }, collectionStrong); + }, collectionStrong$1); function d3_ascending (a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; @@ -8752,11 +9108,15 @@ }; } + var defineWellKnownSymbol = defineWellKnownSymbol$4; + // `Symbol.asyncIterator` well-known symbol // https://tc39.es/ecma262/#sec-symbol.asynciterator defineWellKnownSymbol('asyncIterator'); - createCommonjsModule(function (module) { + var runtime = {exports: {}}; + + (function (module) { var runtime = function (exports) { var Op = Object.prototype; @@ -8843,11 +9203,9 @@ var IteratorPrototype = {}; - - IteratorPrototype[iteratorSymbol] = function () { + define(IteratorPrototype, iteratorSymbol, function () { return this; - }; - + }); var getProto = Object.getPrototypeOf; var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); @@ -8858,8 +9216,9 @@ } var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); - GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; - GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunction.prototype = GeneratorFunctionPrototype; + define(Gp, "constructor", GeneratorFunctionPrototype); + define(GeneratorFunctionPrototype, "constructor", GeneratorFunction); GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"); // Helper for defining the .next, .throw, and .return methods of the // Iterator interface in terms of a single ._invoke method. @@ -8964,11 +9323,9 @@ } defineIteratorMethods(AsyncIterator.prototype); - - AsyncIterator.prototype[asyncIteratorSymbol] = function () { + define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; - }; - + }); exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of // AsyncIterator objects; they just return a Promise for the value of // the final result produced by the iterator. @@ -9145,13 +9502,12 @@ // object to not be returned from this call. This ensures that doesn't happen. // See https://github.com/facebook/regenerator/issues/274 for more details. - Gp[iteratorSymbol] = function () { + define(Gp, iteratorSymbol, function () { return this; - }; - - Gp.toString = function () { + }); + define(Gp, "toString", function () { return "[object Generator]"; - }; + }); function pushTryEntry(locs) { var entry = { @@ -9463,16 +9819,21 @@ } catch (accidentalStrictMode) { // This module should not be running in strict mode, so the above // assignment should always work unless something is misconfigured. Just - // in case runtime.js accidentally runs in strict mode, we can escape + // in case runtime.js accidentally runs in strict mode, in modern engines + // we can explicitly access globalThis. In older engines we can escape // strict mode using a global Function call. This could conceivably fail // if a Content Security Policy forbids using Function, but in that case // the proper solution is to fix the accidental strict mode problem. If // you've misconfigured your bundler to force strict mode and applied a // CSP to forbid Function, and you're not willing to fix either of those // problems, please detail your unique predicament in a GitHub issue. - Function("r", "regeneratorRuntime = r")(runtime); + if ((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) === "object") { + globalThis.regeneratorRuntime = runtime; + } else { + Function("r", "regeneratorRuntime = r")(runtime); + } } - }); + })(runtime); var _marked$3 = /*#__PURE__*/regeneratorRuntime.mark(numbers); @@ -9593,6 +9954,69 @@ var bisectRight = ascendingBisect.right; d3_bisector(number$1).center; + var anObject$2 = anObject$n; + var iteratorClose = iteratorClose$2; + + // call something on iterator step with safe closing on error + var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject$2(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + }; + + var global$c = global$1o; + var bind$5 = functionBindContext; + var call$3 = functionCall; + var toObject$3 = toObject$i; + var callWithSafeIterationClosing = callWithSafeIterationClosing$1; + var isArrayIteratorMethod = isArrayIteratorMethod$3; + var isConstructor = isConstructor$4; + var lengthOfArrayLike$3 = lengthOfArrayLike$i; + var createProperty = createProperty$5; + var getIterator = getIterator$4; + var getIteratorMethod = getIteratorMethod$5; + + var Array$1 = global$c.Array; + + // `Array.from` method implementation + // https://tc39.es/ecma262/#sec-array.from + var arrayFrom$1 = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject$3(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind$5(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this == Array$1 && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call$3(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike$3(O); + result = IS_CONSTRUCTOR ? new this(length) : Array$1(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; + }; + + var $$D = _export; + var from = arrayFrom$1; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$4; + var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { // eslint-disable-next-line es/no-array-from -- required for testing Array.from(iterable); @@ -9600,42 +10024,50 @@ // `Array.from` method // https://tc39.es/ecma262/#sec-array.from - _export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { - from: arrayFrom + $$D({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from }); + var $$C = _export; + var fill = arrayFill$1; + var addToUnscopables$4 = addToUnscopables$6; + // `Array.prototype.fill` method // https://tc39.es/ecma262/#sec-array.prototype.fill - _export({ target: 'Array', proto: true }, { - fill: arrayFill + $$C({ target: 'Array', proto: true }, { + fill: fill }); // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables - addToUnscopables('fill'); + addToUnscopables$4('fill'); + var $$B = _export; var $some = arrayIteration.some; + var arrayMethodIsStrict$4 = arrayMethodIsStrict$9; - - var STRICT_METHOD$3 = arrayMethodIsStrict('some'); + var STRICT_METHOD$4 = arrayMethodIsStrict$4('some'); // `Array.prototype.some` method // https://tc39.es/ecma262/#sec-array.prototype.some - _export({ target: 'Array', proto: true, forced: !STRICT_METHOD$3 }, { + $$B({ target: 'Array', proto: true, forced: !STRICT_METHOD$4 }, { some: function some(callbackfn /* , thisArg */) { return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); + var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = typedArrayConstructorsRequireWrappers; var exportTypedArrayStaticMethod = arrayBufferViewCore.exportTypedArrayStaticMethod; - + var typedArrayFrom = typedArrayFrom$2; // `%TypedArray%.from` method // https://tc39.es/ecma262/#sec-%typedarray%.from - exportTypedArrayStaticMethod('from', typedArrayFrom, typedArrayConstructorsRequireWrappers); + exportTypedArrayStaticMethod('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS); + + var createTypedArrayConstructor = typedArrayConstructor.exports; // `Float64Array` constructor // https://tc39.es/ecma262/#sec-typedarray-objects - typedArrayConstructor('Float64', function (init) { + createTypedArrayConstructor('Float64', function (init) { return function Float64Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; @@ -9707,38 +10139,61 @@ return Adder; }(); + var $$A = _export; + var DESCRIPTORS$5 = descriptors; + var defineProperties$1 = objectDefineProperties.f; + // `Object.defineProperties` method // https://tc39.es/ecma262/#sec-object.defineproperties - _export({ target: 'Object', stat: true, forced: !descriptors, sham: !descriptors }, { - defineProperties: objectDefineProperties + // eslint-disable-next-line es/no-object-defineproperties -- safe + $$A({ target: 'Object', stat: true, forced: Object.defineProperties !== defineProperties$1, sham: !DESCRIPTORS$5 }, { + defineProperties: defineProperties$1 }); + var collection = collection$2; + var collectionStrong = collectionStrong$2; + // `Map` constructor // https://tc39.es/ecma262/#sec-map-objects collection('Map', function (init) { return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; }, collectionStrong); + var $$z = _export; + var uncurryThis$f = functionUncurryThis; + var aCallable$1 = aCallable$a; + var toObject$2 = toObject$i; + var lengthOfArrayLike$2 = lengthOfArrayLike$i; + var toString$a = toString$k; + var fails$b = fails$V; + var internalSort = arraySort$1; + var arrayMethodIsStrict$3 = arrayMethodIsStrict$9; + var FF = engineFfVersion; + var IE_OR_EDGE = engineIsIeOrEdge; + var V8 = engineV8Version; + var WEBKIT = engineWebkitVersion; + var test = []; - var nativeSort = test.sort; + var un$Sort = uncurryThis$f(test.sort); + var push$3 = uncurryThis$f(test.push); // IE8- - var FAILS_ON_UNDEFINED = fails(function () { + var FAILS_ON_UNDEFINED = fails$b(function () { test.sort(undefined); }); // V8 bug - var FAILS_ON_NULL = fails(function () { + var FAILS_ON_NULL = fails$b(function () { test.sort(null); }); // Old WebKit - var STRICT_METHOD$2 = arrayMethodIsStrict('sort'); + var STRICT_METHOD$3 = arrayMethodIsStrict$3('sort'); - var STABLE_SORT = !fails(function () { + var STABLE_SORT = !fails$b(function () { // feature detection can be too slow, so check engines versions - if (engineV8Version) return engineV8Version < 70; - if (engineFfVersion && engineFfVersion > 3) return; - if (engineIsIeOrEdge) return true; - if (engineWebkitVersion) return engineWebkitVersion < 603; + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; var result = ''; var code, chr, value, index; @@ -9768,36 +10223,37 @@ return result !== 'DGBEFHACIJK'; }); - var FORCED$5 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD$2 || !STABLE_SORT; + var FORCED$7 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD$3 || !STABLE_SORT; var getSortCompare = function (comparefn) { return function (x, y) { if (y === undefined) return -1; if (x === undefined) return 1; if (comparefn !== undefined) return +comparefn(x, y) || 0; - return String(x) > String(y) ? 1 : -1; + return toString$a(x) > toString$a(y) ? 1 : -1; }; }; // `Array.prototype.sort` method // https://tc39.es/ecma262/#sec-array.prototype.sort - _export({ target: 'Array', proto: true, forced: FORCED$5 }, { + $$z({ target: 'Array', proto: true, forced: FORCED$7 }, { sort: function sort(comparefn) { - if (comparefn !== undefined) aFunction(comparefn); + if (comparefn !== undefined) aCallable$1(comparefn); - var array = toObject(this); + var array = toObject$2(this); - if (STABLE_SORT) return comparefn === undefined ? nativeSort.call(array) : nativeSort.call(array, comparefn); + if (STABLE_SORT) return comparefn === undefined ? un$Sort(array) : un$Sort(array, comparefn); var items = []; - var arrayLength = toLength(array.length); + var arrayLength = lengthOfArrayLike$2(array); var itemsLength, index; for (index = 0; index < arrayLength; index++) { - if (index in array) items.push(array[index]); + if (index in array) push$3(items, array[index]); } - items = arraySort(items, getSortCompare(comparefn)); + internalSort(items, getSortCompare(comparefn)); + itemsLength = items.length; index = 0; @@ -9954,7 +10410,7 @@ // ISC license, Copyright 2018 Vladimir Agafonkin. - function quickselect$2(array, k) { + function quickselect$3(array, k) { var left = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; var right = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1; var compare = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : d3_ascending; @@ -9968,7 +10424,7 @@ var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1); var newLeft = Math.max(left, Math.floor(k - m * s / n + sd)); var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd)); - quickselect$2(array, k, newLeft, newRight, compare); + quickselect$3(array, k, newLeft, newRight, compare); } var t = array[k]; @@ -10011,7 +10467,7 @@ var n, i = (n - 1) * p, i0 = Math.floor(i), - value0 = max(quickselect$2(values, i0).subarray(0, i0 + 1)), + value0 = max(quickselect$3(values, i0).subarray(0, i0 + 1)), value1 = min$2(values.subarray(i0 + 1)); return value0 + (value1 - value0) * (i - i0); } @@ -10092,11 +10548,13 @@ // `SameValue` abstract operation // https://tc39.es/ecma262/#sec-samevalue // eslint-disable-next-line es/no-object-is -- safe - var sameValue = Object.is || function is(x, y) { + var sameValue$1 = Object.is || function is(x, y) { // eslint-disable-next-line no-self-compare -- NaN check return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; }; + var $$y = _export; + // eslint-disable-next-line es/no-math-hypot -- required for testing var $hypot = Math.hypot; var abs$3 = Math.abs; @@ -10108,7 +10566,7 @@ // `Math.hypot` method // https://tc39.es/ecma262/#sec-math.hypot - _export({ target: 'Math', stat: true, forced: BUGGY }, { + $$y({ target: 'Math', stat: true, forced: BUGGY }, { // eslint-disable-next-line no-unused-vars -- required for `.length` hypot: function hypot(value1, value2) { var sum = 0; @@ -10139,10 +10597,13 @@ return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; }; + var $$x = _export; + var sign$1 = mathSign; + // `Math.sign` method // https://tc39.es/ecma262/#sec-math.sign - _export({ target: 'Math', stat: true }, { - sign: mathSign + $$x({ target: 'Math', stat: true }, { + sign: sign$1 }); var epsilon$1 = 1e-6; @@ -12454,26 +12915,26 @@ // constants var TAU = 2 * Math.PI; var EQUATORIAL_RADIUS = 6356752.314245179; - var POLAR_RADIUS$1 = 6378137.0; + var POLAR_RADIUS = 6378137.0; function geoLatToMeters(dLat) { - return dLat * (TAU * POLAR_RADIUS$1 / 360); + return dLat * (TAU * POLAR_RADIUS / 360); } function geoLonToMeters(dLon, atLat) { return Math.abs(atLat) >= 90 ? 0 : dLon * (TAU * EQUATORIAL_RADIUS / 360) * Math.abs(Math.cos(atLat * (Math.PI / 180))); } function geoMetersToLat(m) { - return m / (TAU * POLAR_RADIUS$1 / 360); + return m / (TAU * POLAR_RADIUS / 360); } function geoMetersToLon(m, atLat) { return Math.abs(atLat) >= 90 ? 0 : m / (TAU * EQUATORIAL_RADIUS / 360) / Math.abs(Math.cos(atLat * (Math.PI / 180))); } function geoMetersToOffset(meters, tileSize) { tileSize = tileSize || 256; - return [meters[0] * tileSize / (TAU * EQUATORIAL_RADIUS), -meters[1] * tileSize / (TAU * POLAR_RADIUS$1)]; + return [meters[0] * tileSize / (TAU * EQUATORIAL_RADIUS), -meters[1] * tileSize / (TAU * POLAR_RADIUS)]; } function geoOffsetToMeters(offset, tileSize) { tileSize = tileSize || 256; - return [offset[0] * TAU * EQUATORIAL_RADIUS / tileSize, -offset[1] * TAU * POLAR_RADIUS$1 / tileSize]; + return [offset[0] * TAU * EQUATORIAL_RADIUS / tileSize, -offset[1] * TAU * POLAR_RADIUS / tileSize]; } // Equirectangular approximation of spherical distances on Earth function geoSphericalDistance(a, b) { @@ -12605,34 +13066,37 @@ } }); + var $$w = _export; var $every = arrayIteration.every; + var arrayMethodIsStrict$2 = arrayMethodIsStrict$9; - - var STRICT_METHOD$1 = arrayMethodIsStrict('every'); + var STRICT_METHOD$2 = arrayMethodIsStrict$2('every'); // `Array.prototype.every` method // https://tc39.es/ecma262/#sec-array.prototype.every - _export({ target: 'Array', proto: true, forced: !STRICT_METHOD$1 }, { + $$w({ target: 'Array', proto: true, forced: !STRICT_METHOD$2 }, { every: function every(callbackfn /* , thisArg */) { return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); + var $$v = _export; var $reduce = arrayReduce.left; + var arrayMethodIsStrict$1 = arrayMethodIsStrict$9; + var CHROME_VERSION$1 = engineV8Version; + var IS_NODE$1 = engineIsNode; - - - - var STRICT_METHOD = arrayMethodIsStrict('reduce'); + var STRICT_METHOD$1 = arrayMethodIsStrict$1('reduce'); // Chrome 80-82 has a critical bug // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982 - var CHROME_BUG = !engineIsNode && engineV8Version > 79 && engineV8Version < 83; + var CHROME_BUG$1 = !IS_NODE$1 && CHROME_VERSION$1 > 79 && CHROME_VERSION$1 < 83; // `Array.prototype.reduce` method // https://tc39.es/ecma262/#sec-array.prototype.reduce - _export({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, { + $$v({ target: 'Array', proto: true, forced: !STRICT_METHOD$1 || CHROME_BUG$1 }, { reduce: function reduce(callbackfn /* , initialValue */) { - return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + var length = arguments.length; + return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined); } }); @@ -13390,8 +13854,9 @@ return new Selection$1(subgroups, parents); } + var $$u = _export; var $find = arrayIteration.find; - + var addToUnscopables$3 = addToUnscopables$6; var FIND = 'find'; var SKIPS_HOLES$1 = true; @@ -13401,14 +13866,14 @@ // `Array.prototype.find` method // https://tc39.es/ecma262/#sec-array.prototype.find - _export({ target: 'Array', proto: true, forced: SKIPS_HOLES$1 }, { + $$u({ target: 'Array', proto: true, forced: SKIPS_HOLES$1 }, { find: function find(callbackfn /* , that = undefined */) { return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables - addToUnscopables(FIND); + addToUnscopables$3(FIND); function matcher (selector) { return function () { @@ -13791,8 +14256,8 @@ } function defaultView (node) { - return node.ownerDocument && node.ownerDocument.defaultView || // node is a Node - node.document && node // node is a Window + return node.ownerDocument && node.ownerDocument.defaultView // node is a Node + || node.document && node // node is a Window || node.defaultView; // node is a Document } @@ -14620,23 +15085,38 @@ return drag; } + var DESCRIPTORS$4 = descriptors; + var global$b = global$1o; + var uncurryThis$e = functionUncurryThis; + var isForced$1 = isForced_1; + var inheritIfRequired$1 = inheritIfRequired$4; + var createNonEnumerableProperty = createNonEnumerableProperty$b; var defineProperty$1 = objectDefineProperty.f; var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f; - - - - - - + var isPrototypeOf$1 = objectIsPrototypeOf; + var isRegExp$1 = isRegexp; + var toString$9 = toString$k; + var regExpFlags$1 = regexpFlags$1; + var stickyHelpers = regexpStickyHelpers; + var redefine$3 = redefine$h.exports; + var fails$a = fails$V; + var hasOwn$2 = hasOwnProperty_1; var enforceInternalState = internalState.enforce; - - - - - - var MATCH$1 = wellKnownSymbol('match'); - var NativeRegExp = global$2.RegExp; - var RegExpPrototype = NativeRegExp.prototype; + var setSpecies = setSpecies$5; + var wellKnownSymbol$1 = wellKnownSymbol$t; + var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll; + var UNSUPPORTED_NCG = regexpUnsupportedNcg; + + var MATCH$1 = wellKnownSymbol$1('match'); + var NativeRegExp = global$b.RegExp; + var RegExpPrototype$1 = NativeRegExp.prototype; + var SyntaxError$1 = global$b.SyntaxError; + var getFlags = uncurryThis$e(regExpFlags$1); + var exec$2 = uncurryThis$e(RegExpPrototype$1.exec); + var charAt$1 = uncurryThis$e(''.charAt); + var replace$3 = uncurryThis$e(''.replace); + var stringIndexOf$1 = uncurryThis$e(''.indexOf); + var stringSlice$4 = uncurryThis$e(''.slice); // TODO: Use only propper RegExpIdentifierName var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/; var re1 = /a/g; @@ -14645,10 +15125,11 @@ // "new" should create a new object, old webkit bug var CORRECT_NEW = new NativeRegExp(re1) !== re1; - var UNSUPPORTED_Y = regexpStickyHelpers.UNSUPPORTED_Y; + var MISSED_STICKY = stickyHelpers.MISSED_STICKY; + var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y; - var BASE_FORCED = descriptors && - (!CORRECT_NEW || UNSUPPORTED_Y || regexpUnsupportedDotAll || regexpUnsupportedNcg || fails(function () { + var BASE_FORCED = DESCRIPTORS$4 && + (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails$a(function () { re2[MATCH$1] = false; // RegExp constructor can alter flags and IsRegExp works correct with @@match return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i'; @@ -14661,9 +15142,9 @@ var brackets = false; var chr; for (; index <= length; index++) { - chr = string.charAt(index); + chr = charAt$1(string, index); if (chr === '\\') { - result += chr + string.charAt(++index); + result += chr + charAt$1(string, ++index); continue; } if (!brackets && chr === '.') { @@ -14690,9 +15171,9 @@ var groupname = ''; var chr; for (; index <= length; index++) { - chr = string.charAt(index); + chr = charAt$1(string, index); if (chr === '\\') { - chr = chr + string.charAt(++index); + chr = chr + charAt$1(string, ++index); } else if (chr === ']') { brackets = false; } else if (!brackets) switch (true) { @@ -14700,7 +15181,7 @@ brackets = true; break; case chr === '(': - if (IS_NCG.test(string.slice(index + 1))) { + if (exec$2(IS_NCG, stringSlice$4(string, index + 1))) { index += 2; ncg = true; } @@ -14708,11 +15189,11 @@ groupid++; continue; case chr === '>' && ncg: - if (groupname === '' || has$1(names, groupname)) { - throw new SyntaxError('Invalid capture group name'); + if (groupname === '' || hasOwn$2(names, groupname)) { + throw new SyntaxError$1('Invalid capture group name'); } names[groupname] = true; - named.push([groupname, groupid]); + named[named.length] = [groupname, groupid]; ncg = false; groupname = ''; continue; @@ -14724,52 +15205,47 @@ // `RegExp` constructor // https://tc39.es/ecma262/#sec-regexp-constructor - if (isForced_1('RegExp', BASE_FORCED)) { + if (isForced$1('RegExp', BASE_FORCED)) { var RegExpWrapper = function RegExp(pattern, flags) { - var thisIsRegExp = this instanceof RegExpWrapper; - var patternIsRegExp = isRegexp(pattern); + var thisIsRegExp = isPrototypeOf$1(RegExpPrototype$1, this); + var patternIsRegExp = isRegExp$1(pattern); var flagsAreUndefined = flags === undefined; var groups = []; - var rawPattern, rawFlags, dotAll, sticky, handled, result, state; + var rawPattern = pattern; + var rawFlags, dotAll, sticky, handled, result, state; - if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) { + if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) { return pattern; } - if (CORRECT_NEW) { - if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source; - } else if (pattern instanceof RegExpWrapper) { - if (flagsAreUndefined) flags = regexpFlags.call(pattern); + if (patternIsRegExp || isPrototypeOf$1(RegExpPrototype$1, pattern)) { pattern = pattern.source; + if (flagsAreUndefined) flags = 'flags' in rawPattern ? rawPattern.flags : getFlags(rawPattern); } - pattern = pattern === undefined ? '' : String(pattern); - flags = flags === undefined ? '' : String(flags); + pattern = pattern === undefined ? '' : toString$9(pattern); + flags = flags === undefined ? '' : toString$9(flags); rawPattern = pattern; - if (regexpUnsupportedDotAll && 'dotAll' in re1) { - dotAll = !!flags && flags.indexOf('s') > -1; - if (dotAll) flags = flags.replace(/s/g, ''); + if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) { + dotAll = !!flags && stringIndexOf$1(flags, 's') > -1; + if (dotAll) flags = replace$3(flags, /s/g, ''); } rawFlags = flags; - if (UNSUPPORTED_Y && 'sticky' in re1) { - sticky = !!flags && flags.indexOf('y') > -1; - if (sticky) flags = flags.replace(/y/g, ''); + if (MISSED_STICKY && 'sticky' in re1) { + sticky = !!flags && stringIndexOf$1(flags, 'y') > -1; + if (sticky && UNSUPPORTED_Y) flags = replace$3(flags, /y/g, ''); } - if (regexpUnsupportedNcg) { + if (UNSUPPORTED_NCG) { handled = handleNCG(pattern); pattern = handled[0]; groups = handled[1]; } - result = inheritIfRequired( - CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags), - thisIsRegExp ? this : RegExpPrototype, - RegExpWrapper - ); + result = inheritIfRequired$1(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$1, RegExpWrapper); if (dotAll || sticky || groups.length) { state = enforceInternalState(result); @@ -14801,9 +15277,9 @@ proxy(keys$1[index$1++]); } - RegExpPrototype.constructor = RegExpWrapper; - RegExpWrapper.prototype = RegExpPrototype; - redefine(global$2, 'RegExp', RegExpWrapper); + RegExpPrototype$1.constructor = RegExpWrapper; + RegExpWrapper.prototype = RegExpPrototype$1; + redefine$3(global$b, 'RegExp', RegExpWrapper); } // https://tc39.es/ecma262/#sec-get-regexp-@@species @@ -15547,20 +16023,20 @@ }; } // General case. else { - var d1 = Math.sqrt(d2), - b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), - b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), - r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), - r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); - S = (r1 - r0) / rho; - - i = function i(t) { - var s = t * S, - coshr0 = cosh(r0), - u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); - return [ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / cosh(rho * s + r0)]; - }; - } + var d1 = Math.sqrt(d2), + b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), + b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), + r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), + r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); + S = (r1 - r0) / rho; + + i = function i(t) { + var s = t * S, + coshr0 = cosh(r0), + u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); + return [ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / cosh(rho * s + r0)]; + }; + } i.duration = S * 1000 * rho / Math.SQRT2; return i; @@ -15587,10 +16063,13 @@ return samples; } + var $$t = _export; + var bind$4 = functionBind; + // `Function.prototype.bind` method // https://tc39.es/ecma262/#sec-function.prototype.bind - _export({ target: 'Function', proto: true }, { - bind: functionBind + $$t({ target: 'Function', proto: true, forced: Function.bind !== bind$4 }, { + bind: bind$4 }); var frame = 0, @@ -15808,11 +16287,11 @@ delete schedules[i]; } // Cancel any pre-empted transitions. else if (+i < id) { - o.state = ENDED; - o.timer.stop(); - o.on.call("cancel", node, node.__data__, o.index, o.group); - delete schedules[i]; - } + o.state = ENDED; + o.timer.stop(); + o.on.call("cancel", node, node.__data__, o.index, o.group); + delete schedules[i]; + } } // Defer the first tick to end of the current frame; see d3/d3#1576. // Note the transition may be canceled after start and before the first tick! // Note this must be scheduled before the start event; see d3/d3-transition#16! @@ -16803,10 +17282,10 @@ return function (t) { if (t === 1) t = b; // Avoid rounding error on end. else { - var l = i(t), - k = w / l[2]; - t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); - } + var l = i(t), + k = w / l[2]; + t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); + } g.zoom(null, t); }; }); @@ -16886,11 +17365,11 @@ clearTimeout(g.wheel); } // If this wheel event won’t trigger a transform change, ignore it. else if (t.k === k) return; // Otherwise, capture the mouse point and location at the start. - else { - g.mouse = [p, t.invert(p)]; - interrupt(this); - g.start(); - } + else { + g.mouse = [p, t.invert(p)]; + interrupt(this); + g.start(); + } noevent(event); g.wheel = setTimeout(wheelidled, wheelDelay); @@ -17263,15 +17742,66 @@ return score; } - var onFreeze = internalMetadata.onFreeze; + var call$2 = functionCall; + var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic; + var anObject$1 = anObject$n; + var toLength$3 = toLength$c; + var toString$8 = toString$k; + var requireObjectCoercible$7 = requireObjectCoercible$e; + var getMethod$1 = getMethod$7; + var advanceStringIndex = advanceStringIndex$3; + var regExpExec$1 = regexpExecAbstract; + + // @@match logic + fixRegExpWellKnownSymbolLogic$1('match', function (MATCH, nativeMatch, maybeCallNative) { + return [ + // `String.prototype.match` method + // https://tc39.es/ecma262/#sec-string.prototype.match + function match(regexp) { + var O = requireObjectCoercible$7(this); + var matcher = regexp == undefined ? undefined : getMethod$1(regexp, MATCH); + return matcher ? call$2(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString$8(O)); + }, + // `RegExp.prototype[@@match]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@match + function (string) { + var rx = anObject$1(this); + var S = toString$8(string); + var res = maybeCallNative(nativeMatch, rx, S); + + if (res.done) return res.value; + + if (!rx.global) return regExpExec$1(rx, S); + + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + var A = []; + var n = 0; + var result; + while ((result = regExpExec$1(rx, S)) !== null) { + var matchStr = toString$8(result[0]); + A[n] = matchStr; + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength$3(rx.lastIndex), fullUnicode); + n++; + } + return n === 0 ? null : A; + } + ]; + }); + + var $$s = _export; + var FREEZING = freezing; + var fails$9 = fails$V; + var isObject$4 = isObject$s; + var onFreeze = internalMetadata.exports.onFreeze; // eslint-disable-next-line es/no-object-freeze -- safe var $freeze = Object.freeze; - var FAILS_ON_PRIMITIVES = fails(function () { $freeze(1); }); + var FAILS_ON_PRIMITIVES = fails$9(function () { $freeze(1); }); // `Object.freeze` method // https://tc39.es/ecma262/#sec-object.freeze - _export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !freezing }, { + $$s({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { freeze: function freeze(it) { return $freeze && isObject$4(it) ? $freeze(onFreeze(it)) : it; } @@ -17421,44 +17951,103 @@ }, []); } - // @@match logic - fixRegexpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) { - return [ - // `String.prototype.match` method - // https://tc39.es/ecma262/#sec-string.prototype.match - function match(regexp) { - var O = requireObjectCoercible(this); - var matcher = regexp == undefined ? undefined : regexp[MATCH]; - return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); - }, - // `RegExp.prototype[@@match]` method - // https://tc39.es/ecma262/#sec-regexp.prototype-@@match - function (string) { - var res = maybeCallNative(nativeMatch, this, string); - if (res.done) return res.value; + var uncurryThis$d = functionUncurryThis; - var rx = anObject(this); - var S = String(string); + // `thisNumberValue` abstract operation + // https://tc39.es/ecma262/#sec-thisnumbervalue + var thisNumberValue$3 = uncurryThis$d(1.0.valueOf); + + var DESCRIPTORS$3 = descriptors; + var global$a = global$1o; + var uncurryThis$c = functionUncurryThis; + var isForced = isForced_1; + var redefine$2 = redefine$h.exports; + var hasOwn$1 = hasOwnProperty_1; + var inheritIfRequired = inheritIfRequired$4; + var isPrototypeOf = objectIsPrototypeOf; + var isSymbol$1 = isSymbol$6; + var toPrimitive$1 = toPrimitive$3; + var fails$8 = fails$V; + var getOwnPropertyNames = objectGetOwnPropertyNames.f; + var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; + var defineProperty = objectDefineProperty.f; + var thisNumberValue$2 = thisNumberValue$3; + var trim$2 = stringTrim.trim; - if (!rx.global) return regexpExecAbstract(rx, S); + var NUMBER = 'Number'; + var NativeNumber = global$a[NUMBER]; + var NumberPrototype = NativeNumber.prototype; + var TypeError$4 = global$a.TypeError; + var arraySlice$1 = uncurryThis$c(''.slice); + var charCodeAt$1 = uncurryThis$c(''.charCodeAt); + + // `ToNumeric` abstract operation + // https://tc39.es/ecma262/#sec-tonumeric + var toNumeric = function (value) { + var primValue = toPrimitive$1(value, 'number'); + return typeof primValue == 'bigint' ? primValue : toNumber$1(primValue); + }; - var fullUnicode = rx.unicode; - rx.lastIndex = 0; - var A = []; - var n = 0; - var result; - while ((result = regexpExecAbstract(rx, S)) !== null) { - var matchStr = String(result[0]); - A[n] = matchStr; - if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); - n++; + // `ToNumber` abstract operation + // https://tc39.es/ecma262/#sec-tonumber + var toNumber$1 = function (argument) { + var it = toPrimitive$1(argument, 'number'); + var first, third, radix, maxCode, digits, length, index, code; + if (isSymbol$1(it)) throw TypeError$4('Cannot convert a Symbol value to a number'); + if (typeof it == 'string' && it.length > 2) { + it = trim$2(it); + first = charCodeAt$1(it, 0); + if (first === 43 || first === 45) { + third = charCodeAt$1(it, 2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (charCodeAt$1(it, 1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i + default: return +it; } - return n === 0 ? null : A; + digits = arraySlice$1(it, 2); + length = digits.length; + for (index = 0; index < length; index++) { + code = charCodeAt$1(digits, index); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); } - ]; - }); + } return +it; + }; + + // `Number` constructor + // https://tc39.es/ecma262/#sec-number-constructor + if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { + var NumberWrapper = function Number(value) { + var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value)); + var dummy = this; + // check on 1..constructor(foo) case + return isPrototypeOf(NumberPrototype, dummy) && fails$8(function () { thisNumberValue$2(dummy); }) + ? inheritIfRequired(Object(n), dummy, NumberWrapper) : n; + }; + for (var keys = DESCRIPTORS$3 ? getOwnPropertyNames(NativeNumber) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' + + // ESNext + 'fromString,range' + ).split(','), j$1 = 0, key; keys.length > j$1; j$1++) { + if (hasOwn$1(NativeNumber, key = keys[j$1]) && !hasOwn$1(NumberWrapper, key)) { + defineProperty(NumberWrapper, key, getOwnPropertyDescriptor$2(NativeNumber, key)); + } + } + NumberWrapper.prototype = NumberPrototype; + NumberPrototype.constructor = NumberWrapper; + redefine$2(global$a, NUMBER, NumberWrapper); + } + + var diacritics = {}; - var remove$6 = removeDiacritics; + var remove$6 = diacritics.remove = removeDiacritics; var replacementList = [{ base: ' ', chars: "\xA0" @@ -17759,8 +18348,8 @@ for (var i$1 = 0; i$1 < replacementList.length; i$1 += 1) { var chars = replacementList[i$1].chars; - for (var j$1 = 0; j$1 < chars.length; j$1 += 1) { - diacriticsMap[chars[j$1]] = replacementList[i$1].base; + for (var j = 0; j < chars.length; j += 1) { + diacriticsMap[chars[j]] = replacementList[i$1].base; } } @@ -17770,14 +18359,16 @@ }); } - var replacementList_1 = replacementList; - var diacriticsMap_1 = diacriticsMap; - var diacritics = { - remove: remove$6, - replacementList: replacementList_1, - diacriticsMap: diacriticsMap_1 - }; + diacritics.replacementList = replacementList; + diacritics.diacriticsMap = diacriticsMap; + + var lib = {}; + var isArabic$1 = {}; + + Object.defineProperty(isArabic$1, "__esModule", { + value: true + }); var arabicBlocks = [[0x0600, 0x06FF], [0x0750, 0x077F], [0x08A0, 0x08FF], [0xFB50, 0xFDFF], [0xFE70, 0xFEFF], [0x10E60, 0x10E7F], [0x1EC70, 0x1ECBF], [0x1EE00, 0x1EEFF] // Mathematical Alphabetic symbols https://www.unicode.org/charts/PDF/U1EE00.pdf ]; @@ -17800,7 +18391,7 @@ return false; } - var isArabic_2 = isArabic; + isArabic$1.isArabic = isArabic; function isMath(_char2) { if (_char2.length > 2) { @@ -17813,14 +18404,17 @@ return code >= 0x660 && code <= 0x66C || code >= 0x6F0 && code <= 0x6F9; } - var isMath_1 = isMath; - var isArabic_1 = /*#__PURE__*/Object.defineProperty({ - isArabic: isArabic_2, - isMath: isMath_1 - }, '__esModule', { + isArabic$1.isMath = isMath; + + var GlyphSplitter$1 = {}; + + var reference = {}; + + var unicodeArabic = {}; + + Object.defineProperty(unicodeArabic, "__esModule", { value: true }); - var arabicReference = { "alef": { "normal": ["\u0627"], @@ -18456,13 +19050,14 @@ "normal": ["\u08BD"] } }; - var _default$3 = arabicReference; - var unicodeArabic = /*#__PURE__*/Object.defineProperty({ - "default": _default$3 - }, '__esModule', { + + unicodeArabic["default"] = arabicReference; + + var unicodeLigatures = {}; + + Object.defineProperty(unicodeLigatures, "__esModule", { value: true }); - var ligatureReference = { "\u0626\u0627": { "isolated": "\uFBEA", @@ -19482,91 +20077,92 @@ "\u0631\u06CC\u0627\u0644": "\uFDFC" } }; - var _default$2 = ligatureReference; - var unicodeLigatures = /*#__PURE__*/Object.defineProperty({ - "default": _default$2 - }, '__esModule', { - value: true - }); - var reference = createCommonjsModule(function (module, exports) { + unicodeLigatures["default"] = ligatureReference; - Object.defineProperty(exports, "__esModule", { - value: true - }); - var letterList = Object.keys(unicodeArabic["default"]); - exports.letterList = letterList; - var ligatureList = Object.keys(unicodeLigatures["default"]); - exports.ligatureList = ligatureList; - var ligatureWordList = Object.keys(unicodeLigatures["default"].words); - exports.ligatureWordList = ligatureWordList; - var lams = "\u0644\u06B5\u06B6\u06B7\u06B8"; - exports.lams = lams; - var alefs = "\u0627\u0622\u0623\u0625\u0671\u0672\u0673\u0675\u0773\u0774"; - exports.alefs = alefs; // for (var l = 1; l < lams.length; l++) { - // console.log('-'); - // for (var a = 0; a < alefs.length; a++) { - // console.log(a + ': ' + lams[l] + alefs[a]); - // } - // } + Object.defineProperty(reference, "__esModule", { + value: true + }); + var unicode_arabic_1$3 = unicodeArabic; + var unicode_ligatures_1$2 = unicodeLigatures; + var letterList = Object.keys(unicode_arabic_1$3["default"]); + reference.letterList = letterList; + var ligatureList = Object.keys(unicode_ligatures_1$2["default"]); + reference.ligatureList = ligatureList; + var ligatureWordList = Object.keys(unicode_ligatures_1$2["default"].words); + reference.ligatureWordList = ligatureWordList; + var lams = "\u0644\u06B5\u06B6\u06B7\u06B8"; + reference.lams = lams; + var alefs = "\u0627\u0622\u0623\u0625\u0671\u0672\u0673\u0675\u0773\u0774"; + reference.alefs = alefs; // for (var l = 1; l < lams.length; l++) { + // console.log('-'); + // for (var a = 0; a < alefs.length; a++) { + // console.log(a + ': ' + lams[l] + alefs[a]); + // } + // } - var tashkeel = "\u0605\u0640\u0670\u0674\u06DF\u06E7\u06E8"; - exports.tashkeel = tashkeel; + var tashkeel = "\u0605\u0640\u0670\u0674\u06DF\u06E7\u06E8"; + reference.tashkeel = tashkeel; - function addToTashkeel(start, finish) { - for (var i = start; i <= finish; i++) { - exports.tashkeel = tashkeel += String.fromCharCode(i); - } + function addToTashkeel(start, finish) { + for (var i = start; i <= finish; i++) { + reference.tashkeel = tashkeel += String.fromCharCode(i); } + } - addToTashkeel(0x0610, 0x061A); - addToTashkeel(0x064B, 0x065F); - addToTashkeel(0x06D6, 0x06DC); - addToTashkeel(0x06E0, 0x06E4); - addToTashkeel(0x06EA, 0x06ED); - addToTashkeel(0x08D3, 0x08E1); - addToTashkeel(0x08E3, 0x08FF); - addToTashkeel(0xFE70, 0xFE7F); - var lineBreakers = "\u0627\u0629\u0648\u06C0\u06CF\u06FD\u06FE\u076B\u076C\u0771\u0773\u0774\u0778\u0779\u08E2\u08B1\u08B2\u08B9"; - exports.lineBreakers = lineBreakers; + addToTashkeel(0x0610, 0x061A); + addToTashkeel(0x064B, 0x065F); + addToTashkeel(0x06D6, 0x06DC); + addToTashkeel(0x06E0, 0x06E4); + addToTashkeel(0x06EA, 0x06ED); + addToTashkeel(0x08D3, 0x08E1); + addToTashkeel(0x08E3, 0x08FF); + addToTashkeel(0xFE70, 0xFE7F); + var lineBreakers = "\u0627\u0629\u0648\u06C0\u06CF\u06FD\u06FE\u076B\u076C\u0771\u0773\u0774\u0778\u0779\u08E2\u08B1\u08B2\u08B9"; + reference.lineBreakers = lineBreakers; - function addToLineBreakers(start, finish) { - for (var i = start; i <= finish; i++) { - exports.lineBreakers = lineBreakers += String.fromCharCode(i); - } + function addToLineBreakers(start, finish) { + for (var i = start; i <= finish; i++) { + reference.lineBreakers = lineBreakers += String.fromCharCode(i); } + } + + addToLineBreakers(0x0600, 0x061F); // it's OK to include tashkeel in this range as it is ignored - addToLineBreakers(0x0600, 0x061F); // it's OK to include tashkeel in this range as it is ignored + addToLineBreakers(0x0621, 0x0625); + addToLineBreakers(0x062F, 0x0632); + addToLineBreakers(0x0660, 0x066D); // numerals, math - addToLineBreakers(0x0621, 0x0625); - addToLineBreakers(0x062F, 0x0632); - addToLineBreakers(0x0660, 0x066D); // numerals, math + addToLineBreakers(0x0671, 0x0677); + addToLineBreakers(0x0688, 0x0699); + addToLineBreakers(0x06C3, 0x06CB); + addToLineBreakers(0x06D2, 0x06F9); + addToLineBreakers(0x0759, 0x075B); + addToLineBreakers(0x08AA, 0x08AE); + addToLineBreakers(0xFB50, 0xFDFD); // presentation forms look like they could connect, but never do + // Presentation Forms A includes diacritics but they are meant to stand alone - addToLineBreakers(0x0671, 0x0677); - addToLineBreakers(0x0688, 0x0699); - addToLineBreakers(0x06C3, 0x06CB); - addToLineBreakers(0x06D2, 0x06F9); - addToLineBreakers(0x0759, 0x075B); - addToLineBreakers(0x08AA, 0x08AE); - addToLineBreakers(0xFB50, 0xFDFD); // presentation forms look like they could connect, but never do - // Presentation Forms A includes diacritics but they are meant to stand alone + addToLineBreakers(0xFE80, 0xFEFC); // presentation forms look like they could connect, but never do + // numerals, math - addToLineBreakers(0xFE80, 0xFEFC); // presentation forms look like they could connect, but never do - // numerals, math + addToLineBreakers(0x10E60, 0x10E7F); + addToLineBreakers(0x1EC70, 0x1ECBF); + addToLineBreakers(0x1EE00, 0x1EEFF); - addToLineBreakers(0x10E60, 0x10E7F); - addToLineBreakers(0x1EC70, 0x1ECBF); - addToLineBreakers(0x1EE00, 0x1EEFF); + Object.defineProperty(GlyphSplitter$1, "__esModule", { + value: true }); + var isArabic_1$6 = isArabic$1; + var reference_1$5 = reference; function GlyphSplitter(word) { var letters = []; var lastLetter = ''; word.split('').forEach(function (letter) { - if (isArabic_1.isArabic(letter)) { - if (reference.tashkeel.indexOf(letter) > -1) { + if (isArabic_1$6.isArabic(letter)) { + if (reference_1$5.tashkeel.indexOf(letter) > -1) { letters[letters.length - 1] += letter; - } else if (lastLetter.length && (reference.lams.indexOf(lastLetter) === 0 && reference.alefs.indexOf(letter) > -1 || reference.lams.indexOf(lastLetter) > 0 && reference.alefs.indexOf(letter) === 0)) { + } else if (lastLetter.length && (reference_1$5.lams.indexOf(lastLetter) === 0 && reference_1$5.alefs.indexOf(letter) > -1 || reference_1$5.lams.indexOf(lastLetter) > 0 && reference_1$5.alefs.indexOf(letter) === 0)) { // valid LA forms letters[letters.length - 1] += letter; } else { @@ -19576,28 +20172,31 @@ letters.push(letter); } - if (reference.tashkeel.indexOf(letter) === -1) { + if (reference_1$5.tashkeel.indexOf(letter) === -1) { lastLetter = letter; } }); return letters; } - var GlyphSplitter_2 = GlyphSplitter; - var GlyphSplitter_1 = /*#__PURE__*/Object.defineProperty({ - GlyphSplitter: GlyphSplitter_2 - }, '__esModule', { + GlyphSplitter$1.GlyphSplitter = GlyphSplitter; + + var BaselineSplitter$1 = {}; + + Object.defineProperty(BaselineSplitter$1, "__esModule", { value: true }); + var isArabic_1$5 = isArabic$1; + var reference_1$4 = reference; function BaselineSplitter(word) { var letters = []; var lastLetter = ''; word.split('').forEach(function (letter) { - if (isArabic_1.isArabic(letter) && isArabic_1.isArabic(lastLetter)) { - if (lastLetter.length && reference.tashkeel.indexOf(letter) > -1) { + if (isArabic_1$5.isArabic(letter) && isArabic_1$5.isArabic(lastLetter)) { + if (lastLetter.length && reference_1$4.tashkeel.indexOf(letter) > -1) { letters[letters.length - 1] += letter; - } else if (reference.lineBreakers.indexOf(lastLetter) > -1) { + } else if (reference_1$4.lineBreakers.indexOf(lastLetter) > -1) { letters.push(letter); } else { letters[letters.length - 1] += letter; @@ -19606,7 +20205,7 @@ letters.push(letter); } - if (reference.tashkeel.indexOf(letter) === -1) { + if (reference_1$4.tashkeel.indexOf(letter) === -1) { // don't allow tashkeel to hide line break lastLetter = letter; } @@ -19614,12 +20213,17 @@ return letters; } - var BaselineSplitter_2 = BaselineSplitter; - var BaselineSplitter_1 = /*#__PURE__*/Object.defineProperty({ - BaselineSplitter: BaselineSplitter_2 - }, '__esModule', { + BaselineSplitter$1.BaselineSplitter = BaselineSplitter; + + var Normalization = {}; + + Object.defineProperty(Normalization, "__esModule", { value: true }); + var unicode_arabic_1$2 = unicodeArabic; + var unicode_ligatures_1$1 = unicodeLigatures; + var isArabic_1$4 = isArabic$1; + var reference_1$3 = reference; function Normal(word, breakPresentationForm) { // default is to turn initial/isolated/medial/final presentation form to generic @@ -19629,14 +20233,14 @@ var returnable = ''; word.split('').forEach(function (letter) { - if (!isArabic_1.isArabic(letter)) { + if (!isArabic_1$4.isArabic(letter)) { returnable += letter; return; } - for (var w = 0; w < reference.letterList.length; w++) { + for (var w = 0; w < reference_1$3.letterList.length; w++) { // ok so we are checking this potential lettertron - var letterForms = unicodeArabic["default"][reference.letterList[w]]; + var letterForms = unicode_arabic_1$2["default"][reference_1$3.letterList[w]]; var versions = Object.keys(letterForms); for (var v = 0; v < versions.length; v++) { @@ -19704,14 +20308,14 @@ } // try ligatures - for (var v2 = 0; v2 < reference.ligatureList.length; v2++) { - var normalForm = reference.ligatureList[v2]; + for (var v2 = 0; v2 < reference_1$3.ligatureList.length; v2++) { + var normalForm = reference_1$3.ligatureList[v2]; if (normalForm !== 'words') { - var ligForms = Object.keys(unicodeLigatures["default"][normalForm]); + var ligForms = Object.keys(unicode_ligatures_1$1["default"][normalForm]); for (var f = 0; f < ligForms.length; f++) { - if (unicodeLigatures["default"][normalForm][ligForms[f]] === letter) { + if (unicode_ligatures_1$1["default"][normalForm][ligForms[f]] === letter) { returnable += normalForm; return; } @@ -19720,10 +20324,10 @@ } // try words ligatures - for (var v3 = 0; v3 < reference.ligatureWordList.length; v3++) { - var _normalForm = reference.ligatureWordList[v3]; + for (var v3 = 0; v3 < reference_1$3.ligatureWordList.length; v3++) { + var _normalForm = reference_1$3.ligatureWordList[v3]; - if (unicodeLigatures["default"].words[_normalForm] === letter) { + if (unicode_ligatures_1$1["default"].words[_normalForm] === letter) { returnable += _normalForm; return; } @@ -19734,15 +20338,19 @@ return returnable; } - var Normal_1 = Normal; - var Normalization = /*#__PURE__*/Object.defineProperty({ - Normal: Normal_1 - }, '__esModule', { + Normalization.Normal = Normal; + + var CharShaper$1 = {}; + + Object.defineProperty(CharShaper$1, "__esModule", { value: true }); + var unicode_arabic_1$1 = unicodeArabic; + var isArabic_1$3 = isArabic$1; + var reference_1$2 = reference; function CharShaper(letter, form) { - if (!isArabic_1.isArabic(letter)) { + if (!isArabic_1$3.isArabic(letter)) { // fail not Arabic throw new Error('Not Arabic'); } @@ -19752,9 +20360,9 @@ return "\u0621"; } - for (var w = 0; w < reference.letterList.length; w++) { + for (var w = 0; w < reference_1$2.letterList.length; w++) { // ok so we are checking this potential lettertron - var letterForms = unicodeArabic["default"][reference.letterList[w]]; + var letterForms = unicode_arabic_1$1["default"][reference_1$2.letterList[w]]; var versions = Object.keys(letterForms); for (var v = 0; v < versions.length; v++) { @@ -19780,12 +20388,17 @@ } } - var CharShaper_2 = CharShaper; - var CharShaper_1 = /*#__PURE__*/Object.defineProperty({ - CharShaper: CharShaper_2 - }, '__esModule', { + CharShaper$1.CharShaper = CharShaper; + + var WordShaper$2 = {}; + + Object.defineProperty(WordShaper$2, "__esModule", { value: true }); + var isArabic_1$2 = isArabic$1; + var reference_1$1 = reference; + var CharShaper_1$1 = CharShaper$1; + var unicode_ligatures_1 = unicodeLigatures; function WordShaper$1(word) { var state = 'initial'; @@ -19795,31 +20408,31 @@ var nextLetter = ' '; for (var nxw = w + 1; nxw < word.length; nxw++) { - if (!isArabic_1.isArabic(word[nxw])) { + if (!isArabic_1$2.isArabic(word[nxw])) { break; } - if (reference.tashkeel.indexOf(word[nxw]) === -1) { + if (reference_1$1.tashkeel.indexOf(word[nxw]) === -1) { nextLetter = word[nxw]; break; } } - if (!isArabic_1.isArabic(word[w]) || isArabic_1.isMath(word[w])) { + if (!isArabic_1$2.isArabic(word[w]) || isArabic_1$2.isMath(word[w])) { // space or other non-Arabic output += word[w]; state = 'initial'; - } else if (reference.tashkeel.indexOf(word[w]) > -1) { + } else if (reference_1$1.tashkeel.indexOf(word[w]) > -1) { // tashkeel - add without changing state output += word[w]; - } else if (nextLetter === ' ' || // last Arabic letter in this word - reference.lineBreakers.indexOf(word[w]) > -1) { + } else if (nextLetter === ' ' // last Arabic letter in this word + || reference_1$1.lineBreakers.indexOf(word[w]) > -1) { // the current letter is known to break lines - output += CharShaper_1.CharShaper(word[w], state === 'initial' ? 'isolated' : 'final'); + output += CharShaper_1$1.CharShaper(word[w], state === 'initial' ? 'isolated' : 'final'); state = 'initial'; - } else if (reference.lams.indexOf(word[w]) > -1 && reference.alefs.indexOf(nextLetter) > -1) { + } else if (reference_1$1.lams.indexOf(word[w]) > -1 && reference_1$1.alefs.indexOf(nextLetter) > -1) { // LA letters - advance an additional letter after this - output += unicodeLigatures["default"][word[w] + nextLetter][state === 'initial' ? 'isolated' : 'final']; + output += unicode_ligatures_1["default"][word[w] + nextLetter][state === 'initial' ? 'isolated' : 'final']; while (word[w] !== nextLetter) { w++; @@ -19827,7 +20440,7 @@ state = 'initial'; } else { - output += CharShaper_1.CharShaper(word[w], state); + output += CharShaper_1$1.CharShaper(word[w], state); state = 'medial'; } } @@ -19835,21 +20448,25 @@ return output; } - var WordShaper_2 = WordShaper$1; - var WordShaper_1 = /*#__PURE__*/Object.defineProperty({ - WordShaper: WordShaper_2 - }, '__esModule', { + WordShaper$2.WordShaper = WordShaper$1; + + var ParentLetter$1 = {}; + + Object.defineProperty(ParentLetter$1, "__esModule", { value: true }); + var unicode_arabic_1 = unicodeArabic; + var isArabic_1$1 = isArabic$1; + var reference_1 = reference; function ParentLetter(letter) { - if (!isArabic_1.isArabic(letter)) { + if (!isArabic_1$1.isArabic(letter)) { throw new Error('Not an Arabic letter'); } - for (var w = 0; w < reference.letterList.length; w++) { + for (var w = 0; w < reference_1.letterList.length; w++) { // ok so we are checking this potential lettertron - var letterForms = unicodeArabic["default"][reference.letterList[w]]; + var letterForms = unicode_arabic_1["default"][reference_1.letterList[w]]; var versions = Object.keys(letterForms); for (var v = 0; v < versions.length; v++) { @@ -19877,16 +20494,16 @@ } } - var ParentLetter_2 = ParentLetter; + ParentLetter$1.ParentLetter = ParentLetter; function GrandparentLetter(letter) { - if (!isArabic_1.isArabic(letter)) { + if (!isArabic_1$1.isArabic(letter)) { throw new Error('Not an Arabic letter'); } - for (var w = 0; w < reference.letterList.length; w++) { + for (var w = 0; w < reference_1.letterList.length; w++) { // ok so we are checking this potential lettertron - var letterForms = unicodeArabic["default"][reference.letterList[w]]; + var letterForms = unicode_arabic_1["default"][reference_1.letterList[w]]; var versions = Object.keys(letterForms); for (var v = 0; v < versions.length; v++) { @@ -19914,22 +20531,26 @@ } } - var GrandparentLetter_1 = GrandparentLetter; - var ParentLetter_1 = /*#__PURE__*/Object.defineProperty({ - ParentLetter: ParentLetter_2, - GrandparentLetter: GrandparentLetter_1 - }, '__esModule', { + ParentLetter$1.GrandparentLetter = GrandparentLetter; + + Object.defineProperty(lib, "__esModule", { value: true }); - - isArabic_1.isArabic; - GlyphSplitter_1.GlyphSplitter; - BaselineSplitter_1.BaselineSplitter; - Normalization.Normal; - CharShaper_1.CharShaper; - var WordShaper = WordShaper_1.WordShaper; - ParentLetter_1.ParentLetter; - ParentLetter_1.GrandparentLetter; + var isArabic_1 = isArabic$1; + lib.isArabic = isArabic_1.isArabic; + var GlyphSplitter_1 = GlyphSplitter$1; + lib.GlyphSplitter = GlyphSplitter_1.GlyphSplitter; + var BaselineSplitter_1 = BaselineSplitter$1; + lib.BaselineSplitter = BaselineSplitter_1.BaselineSplitter; + var Normalization_1 = Normalization; + lib.Normal = Normalization_1.Normal; + var CharShaper_1 = CharShaper$1; + lib.CharShaper = CharShaper_1.CharShaper; + var WordShaper_1 = WordShaper$2; + var WordShaper = lib.WordShaper = WordShaper_1.WordShaper; + var ParentLetter_1 = ParentLetter$1; + lib.ParentLetter = ParentLetter_1.ParentLetter; + lib.GrandparentLetter = ParentLetter_1.GrandparentLetter; var rtlRegex = /[\u0590-\u05FF\u0600-\u06FF\u0750-\u07BF\u08A0–\u08BF]/; function fixRTLTextForSvg(inputText) { @@ -19978,7 +20599,14 @@ return ret; } - var propertyIsEnumerable = objectPropertyIsEnumerable.f; + var DESCRIPTORS$2 = descriptors; + var uncurryThis$b = functionUncurryThis; + var objectKeys = objectKeys$4; + var toIndexedObject = toIndexedObject$d; + var $propertyIsEnumerable = objectPropertyIsEnumerable.f; + + var propertyIsEnumerable = uncurryThis$b($propertyIsEnumerable); + var push$2 = uncurryThis$b([].push); // `Object.{ entries, values }` methods implementation var createMethod$1 = function (TO_ENTRIES) { @@ -19991,8 +20619,8 @@ var key; while (length > i) { key = keys[i++]; - if (!descriptors || propertyIsEnumerable.call(O, key)) { - result.push(TO_ENTRIES ? [key, O[key]] : O[key]); + if (!DESCRIPTORS$2 || propertyIsEnumerable(O, key)) { + push$2(result, TO_ENTRIES ? [key, O[key]] : O[key]); } } return result; @@ -20008,11 +20636,12 @@ values: createMethod$1(false) }; + var $$r = _export; var $values = objectToArray.values; // `Object.values` method // https://tc39.es/ecma262/#sec-object.values - _export({ target: 'Object', stat: true }, { + $$r({ target: 'Object', stat: true }, { values: function values(O) { return $values(O); } @@ -20040,15 +20669,30 @@ return delete s[k]; } }; - }(); // + }(); + + var _listeners = {}; // // corePreferences is an interface for persisting basic key-value strings // within and between iD sessions on the same site. // + /** + * @param {string} k + * @param {string?} v + * @returns {boolean} true if the action succeeded + */ function corePreferences(k, v) { try { - if (arguments.length === 1) return _storage.getItem(k);else if (v === null) _storage.removeItem(k);else _storage.setItem(k, v); + if (v === undefined) return _storage.getItem(k);else if (v === null) _storage.removeItem(k);else _storage.setItem(k, v); + + if (_listeners[k]) { + _listeners[k].forEach(function (handler) { + return handler(v); + }); + } + + return true; } catch (e) { /* eslint-disable no-console */ if (typeof console !== 'undefined') { @@ -20056,10 +20700,21 @@ } /* eslint-enable no-console */ + + return false; } - } + } // adds an event listener which is triggered whenever + + + corePreferences.onChange = function (k, handler) { + _listeners[k] = _listeners[k] || []; - var vparse = createCommonjsModule(function (module) { + _listeners[k].push(handler); + }; + + var vparse = {exports: {}}; + + (function (module) { (function (window) { function parseVersion(v) { @@ -20099,10 +20754,12 @@ window.parseVersion = parseVersion; } })(commonjsGlobal); - }); + })(vparse); + + var parseVersion = vparse.exports; var name = "iD"; - var version = "2.20.1"; + var version = "2.20.4"; var description = "A friendly editor for OpenStreetMap"; var main = "dist/iD.min.js"; var repository = "github:openstreetmap/iD"; @@ -20110,9 +20767,9 @@ var bugs = "https://github.com/openstreetmap/iD/issues"; var keywords = ["editor","openstreetmap"]; var license = "ISC"; - var scripts = {all:"npm-run-all -s clean build build:legacy dist",build:"npm-run-all -s build:css build:data build:dev","build:css":"node scripts/build_css.js","build:data":"shx mkdir -p dist/data && node scripts/build_data.js","build:dev":"rollup --config config/rollup.config.dev.js","build:legacy":"rollup --config config/rollup.config.legacy.js","build:stats":"rollup --config config/rollup.config.stats.js",clean:"shx rm -f dist/*.js dist/*.map dist/*.css dist/img/*.svg",dist:"npm-run-all -p dist:**","dist:mapillary":"shx mkdir -p dist/mapillary-js && shx cp -R node_modules/mapillary-js/dist/* dist/mapillary-js/","dist:pannellum":"shx mkdir -p dist/pannellum-streetside && shx cp -R node_modules/pannellum/build/* dist/pannellum-streetside/","dist:min:iD":"uglifyjs dist/iD.legacy.js --compress --mangle --output dist/iD.min.js","dist:svg:iD":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"iD-%s\" --symbol-sprite dist/img/iD-sprite.svg \"svg/iD-sprite/**/*.svg\"","dist:svg:community":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"community-%s\" --symbol-sprite dist/img/community-sprite.svg node_modules/osm-community-index/dist/img/*.svg","dist:svg:fa":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/fa-sprite.svg svg/fontawesome/*.svg","dist:svg:maki":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"maki-%s\" --symbol-sprite dist/img/maki-sprite.svg node_modules/@mapbox/maki/icons/*.svg","dist:svg:mapillary:signs":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/mapillary-sprite.svg node_modules/mapillary_sprite_source/package_signs/*.svg","dist:svg:mapillary:objects":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/mapillary-object-sprite.svg node_modules/mapillary_sprite_source/package_objects/*.svg","dist:svg:temaki":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"temaki-%s\" --symbol-sprite dist/img/temaki-sprite.svg node_modules/@ideditor/temaki/icons/*.svg",imagery:"node scripts/update_imagery.js",lint:"eslint scripts test/spec modules","lint:fix":"eslint scripts test/spec modules --fix",start:"npm-run-all -s build start:server",quickstart:"npm-run-all -s build:dev start:server","start:server":"node scripts/server.js",test:"npm-run-all -s lint build:css build:data build:legacy test:spec","test:spec":"phantomjs --web-security=no node_modules/mocha-phantomjs-core/mocha-phantomjs-core.js test/index.html spec",translations:"node scripts/update_locales.js"}; + var scripts = {all:"npm-run-all -s clean build build:legacy dist",build:"npm-run-all -s build:css build:data build:dev","build:css":"node scripts/build_css.js","build:data":"shx mkdir -p dist/data && node scripts/build_data.js","build:dev":"rollup --config config/rollup.config.dev.js","build:legacy":"rollup --config config/rollup.config.legacy.js","build:stats":"rollup --config config/rollup.config.stats.js",clean:"shx rm -f dist/*.js dist/*.map dist/*.css dist/img/*.svg",dist:"npm-run-all -p dist:**","dist:mapillary":"shx mkdir -p dist/mapillary-js && shx cp -R node_modules/mapillary-js/dist/* dist/mapillary-js/","dist:pannellum":"shx mkdir -p dist/pannellum-streetside && shx cp -R node_modules/pannellum/build/* dist/pannellum-streetside/","dist:min:iD":"uglifyjs dist/iD.legacy.js --compress --mangle --output dist/iD.min.js","dist:svg:iD":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"iD-%s\" --symbol-sprite dist/img/iD-sprite.svg \"svg/iD-sprite/**/*.svg\"","dist:svg:community":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"community-%s\" --symbol-sprite dist/img/community-sprite.svg node_modules/osm-community-index/dist/img/*.svg","dist:svg:fa":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/fa-sprite.svg svg/fontawesome/*.svg","dist:svg:maki":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"maki-%s\" --symbol-sprite dist/img/maki-sprite.svg node_modules/@mapbox/maki/icons/*.svg","dist:svg:mapillary:signs":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/mapillary-sprite.svg node_modules/mapillary_sprite_source/package_signs/*.svg","dist:svg:mapillary:objects":"svg-sprite --symbol --symbol-dest . --symbol-sprite dist/img/mapillary-object-sprite.svg node_modules/mapillary_sprite_source/package_objects/*.svg","dist:svg:temaki":"svg-sprite --symbol --symbol-dest . --shape-id-generator \"temaki-%s\" --symbol-sprite dist/img/temaki-sprite.svg node_modules/@ideditor/temaki/icons/*.svg",imagery:"node scripts/update_imagery.js",lint:"eslint scripts test/spec modules","lint:fix":"eslint scripts test/spec modules --fix",start:"npm-run-all -s build start:server",quickstart:"npm-run-all -s build:dev start:server","start:server":"node scripts/server.js",test:"npm-run-all -s lint build test:spec","test:spec":"karma start karma.conf.js",translations:"node scripts/update_locales.js"}; var dependencies = {"@ideditor/country-coder":"~5.0.3","@ideditor/location-conflation":"~1.0.2","@mapbox/geojson-area":"^0.2.2","@mapbox/sexagesimal":"1.2.0","@mapbox/vector-tile":"^1.3.1","@tmcw/togeojson":"^4.5.0","@turf/bbox-clip":"^6.0.0","abortcontroller-polyfill":"^1.4.0","aes-js":"^3.1.2","alif-toolkit":"^1.2.9","core-js":"^3.6.5",diacritics:"1.3.0","fast-deep-equal":"~3.1.1","fast-json-stable-stringify":"2.1.0","lodash-es":"~4.17.15",marked:"~2.0.0","node-diff3":"2.1.0","osm-auth":"1.1.0",pannellum:"2.5.6",pbf:"^3.2.1","polygon-clipping":"~0.15.1",rbush:"3.0.1","whatwg-fetch":"^3.4.1","which-polygon":"2.2.0"}; - var devDependencies = {"@babel/core":"^7.11.6","@babel/preset-env":"^7.11.5","@fortawesome/fontawesome-svg-core":"^1.2.32","@fortawesome/free-brands-svg-icons":"~5.15.1","@fortawesome/free-regular-svg-icons":"~5.15.1","@fortawesome/free-solid-svg-icons":"~5.15.1","@ideditor/temaki":"~4.4.0","@mapbox/maki":"^6.0.0","@rollup/plugin-babel":"^5.2.1","@rollup/plugin-commonjs":"^17.0.0","@rollup/plugin-json":"^4.0.1","@rollup/plugin-node-resolve":"~11.2.0",autoprefixer:"^10.0.1",btoa:"^1.2.1",chai:"^4.1.0","cldr-core":"37.0.0","cldr-localenames-full":"37.0.0",colors:"^1.1.2","concat-files":"^0.1.1",d3:"~6.6.0","editor-layer-index":"github:osmlab/editor-layer-index#gh-pages",eslint:"^7.1.0",gaze:"^1.1.3",glob:"^7.1.0",happen:"^0.3.1","js-yaml":"^4.0.0","json-stringify-pretty-compact":"^3.0.0",mapillary_sprite_source:"^1.8.0","mapillary-js":"4.0.0",minimist:"^1.2.3",mocha:"^7.0.1","mocha-phantomjs-core":"^2.1.0","name-suggestion-index":"~6.0","node-fetch":"^2.6.1","npm-run-all":"^4.0.0","object-inspect":"1.10.3","osm-community-index":"~5.1.0","phantomjs-prebuilt":"~2.1.16",postcss:"^8.1.1","postcss-selector-prepend":"^0.5.0",rollup:"~2.52.8","rollup-plugin-includepaths":"~0.2.3","rollup-plugin-progress":"^1.1.1","rollup-plugin-visualizer":"~4.2.0",shelljs:"^0.8.0",shx:"^0.3.0",sinon:"7.5.0","sinon-chai":"^3.3.0",smash:"0.0","static-server":"^2.2.1","svg-sprite":"1.5.1","uglify-js":"~3.13.0",vparse:"~1.1.0"}; + var devDependencies = {"@babel/core":"^7.11.6","@babel/preset-env":"^7.11.5","@fortawesome/fontawesome-svg-core":"^1.2.32","@fortawesome/free-brands-svg-icons":"~5.15.1","@fortawesome/free-regular-svg-icons":"~5.15.1","@fortawesome/free-solid-svg-icons":"~5.15.1","@ideditor/temaki":"~5.0.0","@mapbox/maki":"^6.0.0","@rollup/plugin-babel":"^5.2.1","@rollup/plugin-commonjs":"^21.0.0","@rollup/plugin-json":"^4.0.1","@rollup/plugin-node-resolve":"~13.0.5",autoprefixer:"^10.0.1",btoa:"^1.2.1",chai:"^4.3.4","cldr-core":"37.0.0","cldr-localenames-full":"37.0.0",chalk:"^4.1.2","concat-files":"^0.1.1",d3:"~6.6.0","editor-layer-index":"github:osmlab/editor-layer-index#gh-pages",eslint:"^7.1.0","fetch-mock":"^9.11.0",gaze:"^1.1.3",glob:"^7.1.0",happen:"^0.3.2","js-yaml":"^4.0.0","json-stringify-pretty-compact":"^3.0.0",karma:"^6.3.5","karma-chrome-launcher":"^3.1.0","karma-coverage":"^2.0.3","karma-mocha":"^2.0.1","karma-remap-istanbul":"^0.6.0",mapillary_sprite_source:"^1.8.0","mapillary-js":"4.0.0",minimist:"^1.2.3",mocha:"^8.4.0","name-suggestion-index":"~6.0","node-fetch":"^2.6.1","npm-run-all":"^4.0.0","object-inspect":"1.10.3","osm-community-index":"~5.1.0",postcss:"^8.1.1","postcss-selector-prepend":"^0.5.0",rollup:"~2.52.8","rollup-plugin-includepaths":"~0.2.3","rollup-plugin-progress":"^1.1.1","rollup-plugin-visualizer":"~4.2.0",shelljs:"^0.8.0",shx:"^0.3.0",sinon:"^11.1.2","sinon-chai":"^3.7.0",smash:"0.0","static-server":"^2.2.1","svg-sprite":"1.5.1","uglify-js":"~3.13.0",vparse:"~1.1.0"}; var engines = {node:">=10"}; var browserslist = ["> 0.2%, last 6 major versions, Firefox ESR, IE 11, maintained node versions"]; var packageJSON = { @@ -20138,7 +20795,7 @@ function coreFileFetcher() { var ociVersion = packageJSON.devDependencies['osm-community-index']; - var v = vparse(ociVersion); + var v = parseVersion(ociVersion); var vMinor = "".concat(v.major, ".").concat(v.minor); var _this = {}; var _inflight = {}; @@ -20188,7 +20845,16 @@ var prom = _inflight[url]; if (!prom) { - _inflight[url] = prom = utilFetchJson(url).then(function (result) { + _inflight[url] = prom = fetch(url).then(function (response) { + // fetch in PhantomJS tests may return ok=false and status=0 even if it's okay + if (!response.ok && response.status !== 0 || !response.json) { + throw new Error(response.status + ' ' + response.statusText); + } + + if (response.status === 204 || response.status === 205) return; // No Content, Reset Content + + return response.json(); + }).then(function (result) { delete _inflight[url]; if (!result) { @@ -20238,101 +20904,41 @@ return _this; } - var getOwnPropertyNames = objectGetOwnPropertyNames.f; - var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; - var defineProperty = objectDefineProperty.f; - var trim$2 = stringTrim.trim; - - var NUMBER = 'Number'; - var NativeNumber = global$2[NUMBER]; - var NumberPrototype = NativeNumber.prototype; - - // Opera ~12 has broken Object#toString - var BROKEN_CLASSOF = classofRaw(objectCreate(NumberPrototype)) == NUMBER; - - // `ToNumber` abstract operation - // https://tc39.es/ecma262/#sec-tonumber - var toNumber$1 = function (argument) { - var it = toPrimitive(argument, false); - var first, third, radix, maxCode, digits, length, index, code; - if (typeof it == 'string' && it.length > 2) { - it = trim$2(it); - first = it.charCodeAt(0); - if (first === 43 || first === 45) { - third = it.charCodeAt(2); - if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix - } else if (first === 48) { - switch (it.charCodeAt(1)) { - case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i - case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i - default: return +it; - } - digits = it.slice(2); - length = digits.length; - for (index = 0; index < length; index++) { - code = digits.charCodeAt(index); - // parseInt parses a string to a first unavailable symbol - // but ToNumber should return NaN if a string contains unavailable symbols - if (code < 48 || code > maxCode) return NaN; - } return parseInt(digits, radix); - } - } return +it; - }; - - // `Number` constructor - // https://tc39.es/ecma262/#sec-number-constructor - if (isForced_1(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { - var NumberWrapper = function Number(value) { - var it = arguments.length < 1 ? 0 : value; - var dummy = this; - return dummy instanceof NumberWrapper - // check on 1..constructor(foo) case - && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classofRaw(dummy) != NUMBER) - ? inheritIfRequired(new NativeNumber(toNumber$1(it)), dummy, NumberWrapper) : toNumber$1(it); - }; - for (var keys = descriptors ? getOwnPropertyNames(NativeNumber) : ( - // ES3: - 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + - // ES2015 (in case, if modules with ES2015 Number statics required before): - 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + - 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger,' + - // ESNext - 'fromString,range' - ).split(','), j = 0, key; keys.length > j; j++) { - if (has$1(NativeNumber, key = keys[j]) && !has$1(NumberWrapper, key)) { - defineProperty(NumberWrapper, key, getOwnPropertyDescriptor$2(NativeNumber, key)); - } - } - NumberWrapper.prototype = NumberPrototype; - NumberPrototype.constructor = NumberWrapper; - redefine(global$2, NUMBER, NumberWrapper); - } + var global$9 = global$1o; + var toIntegerOrInfinity$1 = toIntegerOrInfinity$b; + var toString$7 = toString$k; + var requireObjectCoercible$6 = requireObjectCoercible$e; - // `thisNumberValue` abstract operation - // https://tc39.es/ecma262/#sec-thisnumbervalue - var thisNumberValue = function (value) { - if (typeof value != 'number' && classofRaw(value) != 'Number') { - throw TypeError('Incorrect invocation'); - } - return +value; - }; + var RangeError$5 = global$9.RangeError; // `String.prototype.repeat` method implementation // https://tc39.es/ecma262/#sec-string.prototype.repeat var stringRepeat = function repeat(count) { - var str = String(requireObjectCoercible(this)); + var str = toString$7(requireObjectCoercible$6(this)); var result = ''; - var n = toInteger(count); - if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions'); + var n = toIntegerOrInfinity$1(count); + if (n < 0 || n == Infinity) throw RangeError$5('Wrong number of repetitions'); for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str; return result; }; - var nativeToFixed = 1.0.toFixed; - var floor = Math.floor; + var $$q = _export; + var global$8 = global$1o; + var uncurryThis$a = functionUncurryThis; + var toIntegerOrInfinity = toIntegerOrInfinity$b; + var thisNumberValue$1 = thisNumberValue$3; + var $repeat$1 = stringRepeat; + var fails$7 = fails$V; + + var RangeError$4 = global$8.RangeError; + var String$1 = global$8.String; + var floor$2 = Math.floor; + var repeat$2 = uncurryThis$a($repeat$1); + var stringSlice$3 = uncurryThis$a(''.slice); + var un$ToFixed = uncurryThis$a(1.0.toFixed); - var pow = function (x, n, acc) { - return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); + var pow$1 = function (x, n, acc) { + return n === 0 ? acc : n % 2 === 1 ? pow$1(x, n - 1, acc * x) : pow$1(x * x, n / 2, acc); }; var log = function (x) { @@ -20354,7 +20960,7 @@ while (++index < 6) { c2 += n * data[index]; data[index] = c2 % 1e7; - c2 = floor(c2 / 1e7); + c2 = floor$2(c2 / 1e7); } }; @@ -20363,7 +20969,7 @@ var c = 0; while (--index >= 0) { c += data[index]; - data[index] = floor(c / n); + data[index] = floor$2(c / n); c = (c % n) * 1e7; } }; @@ -20373,44 +20979,45 @@ var s = ''; while (--index >= 0) { if (s !== '' || index === 0 || data[index] !== 0) { - var t = String(data[index]); - s = s === '' ? t : s + stringRepeat.call('0', 7 - t.length) + t; + var t = String$1(data[index]); + s = s === '' ? t : s + repeat$2('0', 7 - t.length) + t; } } return s; }; - var FORCED$4 = nativeToFixed && ( - 0.00008.toFixed(3) !== '0.000' || - 0.9.toFixed(0) !== '1' || - 1.255.toFixed(2) !== '1.25' || - 1000000000000000128.0.toFixed(0) !== '1000000000000000128' - ) || !fails(function () { + var FORCED$6 = fails$7(function () { + return un$ToFixed(0.00008, 3) !== '0.000' || + un$ToFixed(0.9, 0) !== '1' || + un$ToFixed(1.255, 2) !== '1.25' || + un$ToFixed(1000000000000000128.0, 0) !== '1000000000000000128'; + }) || !fails$7(function () { // V8 ~ Android 4.3- - nativeToFixed.call({}); + un$ToFixed({}); }); // `Number.prototype.toFixed` method // https://tc39.es/ecma262/#sec-number.prototype.tofixed - _export({ target: 'Number', proto: true, forced: FORCED$4 }, { + $$q({ target: 'Number', proto: true, forced: FORCED$6 }, { toFixed: function toFixed(fractionDigits) { - var number = thisNumberValue(this); - var fractDigits = toInteger(fractionDigits); + var number = thisNumberValue$1(this); + var fractDigits = toIntegerOrInfinity(fractionDigits); var data = [0, 0, 0, 0, 0, 0]; var sign = ''; var result = '0'; var e, z, j, k; - if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits'); + // TODO: ES2018 increased the maximum number of fraction digits to 100, need to improve the implementation + if (fractDigits < 0 || fractDigits > 20) throw RangeError$4('Incorrect fraction digits'); // eslint-disable-next-line no-self-compare -- NaN check if (number != number) return 'NaN'; - if (number <= -1e21 || number >= 1e21) return String(number); + if (number <= -1e21 || number >= 1e21) return String$1(number); if (number < 0) { sign = '-'; number = -number; } if (number > 1e-21) { - e = log(number * pow(2, 69, 1)) - 69; - z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1); + e = log(number * pow$1(2, 69, 1)) - 69; + z = e < 0 ? number * pow$1(2, -e, 1) : number / pow$1(2, e, 1); z *= 0x10000000000000; e = 52 - e; if (e > 0) { @@ -20420,7 +21027,7 @@ multiply(data, 1e7, 0); j -= 7; } - multiply(data, pow(10, j, 1), 0); + multiply(data, pow$1(10, j, 1), 0); j = e - 1; while (j >= 23) { divide(data, 1 << 23); @@ -20433,43 +21040,55 @@ } else { multiply(data, 0, z); multiply(data, 1 << -e, 0); - result = dataToString(data) + stringRepeat.call('0', fractDigits); + result = dataToString(data) + repeat$2('0', fractDigits); } } if (fractDigits > 0) { k = result.length; result = sign + (k <= fractDigits - ? '0.' + stringRepeat.call('0', fractDigits - k) + result - : result.slice(0, k - fractDigits) + '.' + result.slice(k - fractDigits)); + ? '0.' + repeat$2('0', fractDigits - k) + result + : stringSlice$3(result, 0, k - fractDigits) + '.' + stringSlice$3(result, k - fractDigits)); } else { result = sign + result; } return result; } }); - var globalIsFinite = global$2.isFinite; + var global$7 = global$1o; + + var globalIsFinite = global$7.isFinite; // `Number.isFinite` method // https://tc39.es/ecma262/#sec-number.isfinite // eslint-disable-next-line es/no-number-isfinite -- safe - var numberIsFinite = Number.isFinite || function isFinite(it) { + var numberIsFinite$1 = Number.isFinite || function isFinite(it) { return typeof it == 'number' && globalIsFinite(it); }; + var $$p = _export; + var numberIsFinite = numberIsFinite$1; + // `Number.isFinite` method // https://tc39.es/ecma262/#sec-number.isfinite - _export({ target: 'Number', stat: true }, { isFinite: numberIsFinite }); + $$p({ target: 'Number', stat: true }, { isFinite: numberIsFinite }); - var fromCharCode = String.fromCharCode; + var $$o = _export; + var global$6 = global$1o; + var uncurryThis$9 = functionUncurryThis; + var toAbsoluteIndex = toAbsoluteIndex$9; + + var RangeError$3 = global$6.RangeError; + var fromCharCode$1 = String.fromCharCode; // eslint-disable-next-line es/no-string-fromcodepoint -- required for testing var $fromCodePoint = String.fromCodePoint; + var join$2 = uncurryThis$9([].join); // length should be 1, old FF problem var INCORRECT_LENGTH = !!$fromCodePoint && $fromCodePoint.length != 1; // `String.fromCodePoint` method // https://tc39.es/ecma262/#sec-string.fromcodepoint - _export({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, { + $$o({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, { // eslint-disable-next-line no-unused-vars -- required for `.length` fromCodePoint: function fromCodePoint(x) { var elements = []; @@ -20478,44 +21097,56 @@ var code; while (length > i) { code = +arguments[i++]; - if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point'); - elements.push(code < 0x10000 - ? fromCharCode(code) - : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00) - ); - } return elements.join(''); + if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError$3(code + ' is not a valid code point'); + elements[i] = code < 0x10000 + ? fromCharCode$1(code) + : fromCharCode$1(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00); + } return join$2(elements, ''); } }); + var call$1 = functionCall; + var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic; + var anObject = anObject$n; + var requireObjectCoercible$5 = requireObjectCoercible$e; + var sameValue = sameValue$1; + var toString$6 = toString$k; + var getMethod = getMethod$7; + var regExpExec = regexpExecAbstract; + // @@search logic - fixRegexpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) { + fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) { return [ // `String.prototype.search` method // https://tc39.es/ecma262/#sec-string.prototype.search function search(regexp) { - var O = requireObjectCoercible(this); - var searcher = regexp == undefined ? undefined : regexp[SEARCH]; - return searcher !== undefined ? searcher.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); + var O = requireObjectCoercible$5(this); + var searcher = regexp == undefined ? undefined : getMethod(regexp, SEARCH); + return searcher ? call$1(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString$6(O)); }, // `RegExp.prototype[@@search]` method // https://tc39.es/ecma262/#sec-regexp.prototype-@@search function (string) { - var res = maybeCallNative(nativeSearch, this, string); - if (res.done) return res.value; - var rx = anObject(this); - var S = String(string); + var S = toString$6(string); + var res = maybeCallNative(nativeSearch, rx, S); + + if (res.done) return res.value; var previousLastIndex = rx.lastIndex; if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; - var result = regexpExecAbstract(rx, S); + var result = regExpExec(rx, S); if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; return result === null ? -1 : result.index; } ]; }); - var quickselect$1 = createCommonjsModule(function (module, exports) { + var rbush$2 = {exports: {}}; + + var quickselect$2 = {exports: {}}; + + (function (module, exports) { (function (global, factory) { module.exports = factory() ; })(commonjsGlobal, function () { @@ -20578,13 +21209,16 @@ return quickselect; }); - }); + })(quickselect$2); - var rbush_1 = rbush; - var _default$1 = rbush; + rbush$2.exports = rbush$1; - function rbush(maxEntries, format) { - if (!(this instanceof rbush)) return new rbush(maxEntries, format); // max entries in a node is 9 by default; min node fill is 40% for best performance + rbush$2.exports["default"] = rbush$1; + + var quickselect$1 = quickselect$2.exports; + + function rbush$1(maxEntries, format) { + if (!(this instanceof rbush$1)) return new rbush$1(maxEntries, format); // max entries in a node is 9 by default; min node fill is 40% for best performance this._maxEntries = Math.max(4, maxEntries || 9); this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)); @@ -20596,7 +21230,7 @@ this.clear(); } - rbush.prototype = { + rbush$1.prototype = { all: function all() { return this._all(this.data, []); }, @@ -21082,14 +21716,13 @@ stack.push(left, mid, mid, right); } } - rbush_1["default"] = _default$1; - var lineclip_1 = lineclip$1; - lineclip$1.polyline = lineclip$1; - lineclip$1.polygon = polygonclip$1; // Cohen-Sutherland line clippign algorithm, adapted to efficiently + var lineclip_1 = lineclip$2; + lineclip$2.polyline = lineclip$2; + lineclip$2.polygon = polygonclip$1; // Cohen-Sutherland line clippign algorithm, adapted to efficiently // handle polylines rather than just segments - function lineclip$1(points, bbox, result) { + function lineclip$2(points, bbox, result) { var len = points.length, codeA = bitCode$1(points[0], bbox), part = [], @@ -21197,6 +21830,8 @@ return code; } + var rbush = rbush$2.exports; + var lineclip$1 = lineclip_1; var whichPolygon_1 = whichPolygon; function whichPolygon(data) { @@ -21215,7 +21850,7 @@ } } - var tree = rbush_1().load(bboxes); + var tree = rbush().load(bboxes); function query(p, multi) { var output = [], @@ -21263,7 +21898,7 @@ if (insidePolygon(polygon, bboxCenter)) return true; for (var i = 0; i < polygon.length; i++) { - if (lineclip_1(polygon[i], bbox).length > 0) return true; + if (lineclip$1(polygon[i], bbox).length > 0) return true; } return false; @@ -27383,17 +28018,22 @@ return feature2 && feature2.properties.roadSpeedUnit || null; } - var RADIUS = 6378137; - var FLATTENING = 1 / 298.257223563; - var POLAR_RADIUS = 6356752.3142; - var wgs84 = { - RADIUS: RADIUS, - FLATTENING: FLATTENING, - POLAR_RADIUS: POLAR_RADIUS - }; + function roadHeightUnit(query) { + var feature2 = smallestOrMatchingFeature(query); + return feature2 && feature2.properties.roadHeightUnit || null; + } + + var geojsonArea = {}; + + var wgs84$1 = {}; + + wgs84$1.RADIUS = 6378137; + wgs84$1.FLATTENING = 1 / 298.257223563; + wgs84$1.POLAR_RADIUS = 6356752.3142; - var geometry_1 = geometry; - var ring = ringArea; + var wgs84 = wgs84$1; + geojsonArea.geometry = geometry; + geojsonArea.ring = ringArea; function geometry(_) { var area = 0, @@ -27500,26 +28140,26 @@ return _ * Math.PI / 180; } - var geojsonArea = { - geometry: geometry_1, - ring: ring - }; + var inputValidation = {}; + var $$n = _export; var $includes = arrayIncludes.includes; - + var addToUnscopables$2 = addToUnscopables$6; // `Array.prototype.includes` method // https://tc39.es/ecma262/#sec-array.prototype.includes - _export({ target: 'Array', proto: true }, { + $$n({ target: 'Array', proto: true }, { includes: function includes(el /* , fromIndex = 0 */) { return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); } }); // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables - addToUnscopables('includes'); + addToUnscopables$2('includes'); - var validateCenter_1$1 = function validateCenter(center) { + var validateCenter$1 = {}; + + validateCenter$1.validateCenter = function validateCenter(center) { var validCenterLengths = [2, 3]; if (!Array.isArray(center) || !validCenterLengths.includes(center.length)) { @@ -27543,11 +28183,9 @@ } }; - var validateCenter$1 = { - validateCenter: validateCenter_1$1 - }; + var validateRadius$1 = {}; - var validateRadius_1$1 = function validateRadius(radius) { + validateRadius$1.validateRadius = function validateRadius(radius) { if (typeof radius !== "number") { throw new Error("ERROR! Radius has to be a positive number but was: ".concat(_typeof(radius))); } @@ -27557,11 +28195,9 @@ } }; - var validateRadius$1 = { - validateRadius: validateRadius_1$1 - }; + var validateNumberOfEdges$1 = {}; - var validateNumberOfEdges_1$1 = function validateNumberOfEdges(numberOfEdges) { + validateNumberOfEdges$1.validateNumberOfEdges = function validateNumberOfEdges(numberOfEdges) { if (typeof numberOfEdges !== "number") { var ARGUMENT_TYPE = Array.isArray(numberOfEdges) ? "array" : _typeof(numberOfEdges); throw new Error("ERROR! Number of edges has to be a number but was: ".concat(ARGUMENT_TYPE)); @@ -27572,11 +28208,9 @@ } }; - var validateNumberOfEdges$1 = { - validateNumberOfEdges: validateNumberOfEdges_1$1 - }; + var validateEarthRadius$1 = {}; - var validateEarthRadius_1$1 = function validateEarthRadius(earthRadius) { + validateEarthRadius$1.validateEarthRadius = function validateEarthRadius(earthRadius) { if (typeof earthRadius !== "number") { var ARGUMENT_TYPE = Array.isArray(earthRadius) ? "array" : _typeof(earthRadius); throw new Error("ERROR! Earth radius has to be a number but was: ".concat(ARGUMENT_TYPE)); @@ -27587,21 +28221,15 @@ } }; - var validateEarthRadius$1 = { - validateEarthRadius: validateEarthRadius_1$1 - }; + var validateBearing$1 = {}; - var validateBearing_1$1 = function validateBearing(bearing) { + validateBearing$1.validateBearing = function validateBearing(bearing) { if (typeof bearing !== "number") { var ARGUMENT_TYPE = Array.isArray(bearing) ? "array" : _typeof(bearing); throw new Error("ERROR! Bearing has to be a number but was: ".concat(ARGUMENT_TYPE)); } }; - var validateBearing$1 = { - validateBearing: validateBearing_1$1 - }; - var validateCenter = validateCenter$1.validateCenter; var validateRadius = validateRadius$1.validateRadius; var validateNumberOfEdges = validateNumberOfEdges$1.validateNumberOfEdges; @@ -27621,20 +28249,12 @@ validateBearing(bearing); } - var validateCenter_1 = validateCenter; - var validateRadius_1 = validateRadius; - var validateNumberOfEdges_1 = validateNumberOfEdges; - var validateEarthRadius_1 = validateEarthRadius; - var validateBearing_1 = validateBearing; - var validateInput_1 = validateInput$1; - var inputValidation = { - validateCenter: validateCenter_1, - validateRadius: validateRadius_1, - validateNumberOfEdges: validateNumberOfEdges_1, - validateEarthRadius: validateEarthRadius_1, - validateBearing: validateBearing_1, - validateInput: validateInput_1 - }; + inputValidation.validateCenter = validateCenter; + inputValidation.validateRadius = validateRadius; + inputValidation.validateNumberOfEdges = validateNumberOfEdges; + inputValidation.validateEarthRadius = validateEarthRadius; + inputValidation.validateBearing = validateBearing; + inputValidation.validateInput = validateInput$1; var validateInput = inputValidation.validateInput; var defaultEarthRadius = 6378137; // equatorial Earth radius @@ -27732,37 +28352,50 @@ return argument === null || argument === undefined; } + var $$m = _export; + // `Number.EPSILON` constant // https://tc39.es/ecma262/#sec-number.epsilon - _export({ target: 'Number', stat: true }, { + $$m({ target: 'Number', stat: true }, { EPSILON: Math.pow(2, -52) }); + var uncurryThis$8 = functionUncurryThis; + var requireObjectCoercible$4 = requireObjectCoercible$e; + var toString$5 = toString$k; + var quot = /"/g; + var replace$2 = uncurryThis$8(''.replace); // `CreateHTML` abstract operation // https://tc39.es/ecma262/#sec-createhtml var createHtml = function (string, tag, attribute, value) { - var S = String(requireObjectCoercible(string)); + var S = toString$5(requireObjectCoercible$4(string)); var p1 = '<' + tag; - if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; + if (attribute !== '') p1 += ' ' + attribute + '="' + replace$2(toString$5(value), quot, '"') + '"'; return p1 + '>' + S + ''; }; + var fails$6 = fails$V; + // check the existence of a method, lowercase // of a tag and escaping quotes in arguments var stringHtmlForced = function (METHOD_NAME) { - return fails(function () { + return fails$6(function () { var test = ''[METHOD_NAME]('"'); return test !== test.toLowerCase() || test.split('"').length > 3; }); }; + var $$l = _export; + var createHTML = createHtml; + var forcedStringHTMLMethod = stringHtmlForced; + // `String.prototype.link` method // https://tc39.es/ecma262/#sec-string.prototype.link - _export({ target: 'String', proto: true, forced: stringHtmlForced('link') }, { + $$l({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, { link: function link(url) { - return createHtml(this, 'a', 'href', url); + return createHTML(this, 'a', 'href', url); } }); @@ -27880,7 +28513,7 @@ return node; } - function split(key, v, comparator) { + function split$2(key, v, comparator) { var left = null; var right = null; @@ -28353,7 +28986,7 @@ Tree.prototype.update = function (key, newKey, newData) { var comparator = this._comparator; - var _a = split(key, this._root, comparator), + var _a = split$2(key, this._root, comparator), left = _a.left, right = _a.right; @@ -28367,7 +29000,7 @@ }; Tree.prototype.split = function (key) { - return split(key, this._root, this._comparator); + return split$2(key, this._root, this._comparator); }; return Tree; @@ -30329,132 +30962,142 @@ difference: difference }; - var geojsonPrecision = createCommonjsModule(function (module) { - (function () { - function parse(t, coordinatePrecision, extrasPrecision) { - function point(p) { - return p.map(function (e, index) { - if (index < 2) { - return 1 * e.toFixed(coordinatePrecision); - } else { - return 1 * e.toFixed(extrasPrecision); - } - }); - } + var geojsonPrecision = {exports: {}}; - function multi(l) { - return l.map(point); - } + (function () { + function parse(t, coordinatePrecision, extrasPrecision) { + function point(p) { + return p.map(function (e, index) { + if (index < 2) { + return 1 * e.toFixed(coordinatePrecision); + } else { + return 1 * e.toFixed(extrasPrecision); + } + }); + } - function poly(p) { - return p.map(multi); - } + function multi(l) { + return l.map(point); + } - function multiPoly(m) { - return m.map(poly); - } + function poly(p) { + return p.map(multi); + } - function geometry(obj) { - if (!obj) { - return {}; - } + function multiPoly(m) { + return m.map(poly); + } - switch (obj.type) { - case "Point": - obj.coordinates = point(obj.coordinates); - return obj; + function geometry(obj) { + if (!obj) { + return {}; + } - case "LineString": - case "MultiPoint": - obj.coordinates = multi(obj.coordinates); - return obj; + switch (obj.type) { + case "Point": + obj.coordinates = point(obj.coordinates); + return obj; - case "Polygon": - case "MultiLineString": - obj.coordinates = poly(obj.coordinates); - return obj; + case "LineString": + case "MultiPoint": + obj.coordinates = multi(obj.coordinates); + return obj; - case "MultiPolygon": - obj.coordinates = multiPoly(obj.coordinates); - return obj; + case "Polygon": + case "MultiLineString": + obj.coordinates = poly(obj.coordinates); + return obj; - case "GeometryCollection": - obj.geometries = obj.geometries.map(geometry); - return obj; + case "MultiPolygon": + obj.coordinates = multiPoly(obj.coordinates); + return obj; - default: - return {}; - } - } + case "GeometryCollection": + obj.geometries = obj.geometries.map(geometry); + return obj; - function feature(obj) { - obj.geometry = geometry(obj.geometry); - return obj; + default: + return {}; } + } - function featureCollection(f) { - f.features = f.features.map(feature); - return f; - } + function feature(obj) { + obj.geometry = geometry(obj.geometry); + return obj; + } - function geometryCollection(g) { - g.geometries = g.geometries.map(geometry); - return g; - } + function featureCollection(f) { + f.features = f.features.map(feature); + return f; + } - if (!t) { - return t; - } + function geometryCollection(g) { + g.geometries = g.geometries.map(geometry); + return g; + } - switch (t.type) { - case "Feature": - return feature(t); + if (!t) { + return t; + } - case "GeometryCollection": - return geometryCollection(t); + switch (t.type) { + case "Feature": + return feature(t); - case "FeatureCollection": - return featureCollection(t); + case "GeometryCollection": + return geometryCollection(t); - case "Point": - case "LineString": - case "Polygon": - case "MultiPoint": - case "MultiPolygon": - case "MultiLineString": - return geometry(t); + case "FeatureCollection": + return featureCollection(t); - default: - return t; - } + case "Point": + case "LineString": + case "Polygon": + case "MultiPoint": + case "MultiPolygon": + case "MultiLineString": + return geometry(t); + + default: + return t; } + } - module.exports = parse; - module.exports.parse = parse; - })(); - }); + geojsonPrecision.exports = parse; + geojsonPrecision.exports.parse = parse; + })(); + + var precision = geojsonPrecision.exports; - var FORCED$3 = fails(function () { + var $$k = _export; + var fails$5 = fails$V; + var toObject$1 = toObject$i; + var toPrimitive = toPrimitive$3; + + var FORCED$5 = fails$5(function () { return new Date(NaN).toJSON() !== null || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1; }); // `Date.prototype.toJSON` method // https://tc39.es/ecma262/#sec-date.prototype.tojson - _export({ target: 'Date', proto: true, forced: FORCED$3 }, { + $$k({ target: 'Date', proto: true, forced: FORCED$5 }, { // eslint-disable-next-line no-unused-vars -- required for `.length` toJSON: function toJSON(key) { - var O = toObject(this); - var pv = toPrimitive(O); + var O = toObject$1(this); + var pv = toPrimitive(O, 'number'); return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); } }); + var $$j = _export; + var call = functionCall; + // `URL.prototype.toJSON` method // https://url.spec.whatwg.org/#dom-url-tojson - _export({ target: 'URL', proto: true, enumerable: true }, { + $$j({ target: 'URL', proto: true, enumerable: true }, { toJSON: function toJSON() { - return URL.prototype.toString.call(this); + return call(URL.prototype.toString, this); } }); @@ -30774,7 +31417,7 @@ var EDGES = 10; var PRECISION = 3; var area = Math.PI * radius * radius; - var feature = this._cache[id] = geojsonPrecision({ + var feature = this._cache[id] = precision({ type: 'Feature', id: id, properties: { @@ -31030,13 +31673,17 @@ return aRank > bRank ? 1 : aRank < bRank ? -1 : a.id.localeCompare(b.id); } + var $$i = _export; + // `Number.MAX_SAFE_INTEGER` constant // https://tc39.es/ecma262/#sec-number.max_safe_integer - _export({ target: 'Number', stat: true }, { + $$i({ target: 'Number', stat: true }, { MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF }); - var aesJs = createCommonjsModule(function (module, exports) { + var aesJs = {exports: {}}; + + (function (module, exports) { (function (root) { function checkInt(value) { @@ -31803,7 +32450,9 @@ // https://github.com/amdjs/amdjs-api/wiki/AMD } })(); - }); + })(aesJs); + + var aesjs = aesJs.exports; // We can use keys that are 128 bits (16 bytes), 192 bits (24 bytes) or 256 bits (32 bytes). // To generate a random key: window.crypto.getRandomValues(new Uint8Array(16)); @@ -31812,18 +32461,18 @@ var DEFAULT_128 = [250, 157, 60, 79, 142, 134, 229, 129, 138, 126, 210, 129, 29, 71, 160, 208]; function utilAesEncrypt(text, key) { key = key || DEFAULT_128; - var textBytes = aesJs.utils.utf8.toBytes(text); - var aesCtr = new aesJs.ModeOfOperation.ctr(key); + var textBytes = aesjs.utils.utf8.toBytes(text); + var aesCtr = new aesjs.ModeOfOperation.ctr(key); var encryptedBytes = aesCtr.encrypt(textBytes); - var encryptedHex = aesJs.utils.hex.fromBytes(encryptedBytes); + var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes); return encryptedHex; } function utilAesDecrypt(encryptedHex, key) { key = key || DEFAULT_128; - var encryptedBytes = aesJs.utils.hex.toBytes(encryptedHex); - var aesCtr = new aesJs.ModeOfOperation.ctr(key); + var encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex); + var aesCtr = new aesjs.ModeOfOperation.ctr(key); var decryptedBytes = aesCtr.decrypt(encryptedBytes); - var text = aesJs.utils.utf8.fromBytes(decryptedBytes); + var text = aesjs.utils.utf8.fromBytes(decryptedBytes); return text; } @@ -31975,6 +32624,8 @@ // Like selection.property('value', ...), but avoids no-op value sets, // which can result in layout/repaint thrashing in some situations. + + /** @returns {string} */ function utilGetSetValue(selection, value) { function d3_selection_value(value) { function valueNull() { @@ -33049,8 +33700,9 @@ return _this; } + var $$h = _export; var $findIndex = arrayIteration.findIndex; - + var addToUnscopables$1 = addToUnscopables$6; var FIND_INDEX = 'findIndex'; var SKIPS_HOLES = true; @@ -33060,21 +33712,28 @@ // `Array.prototype.findIndex` method // https://tc39.es/ecma262/#sec-array.prototype.findindex - _export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + $$h({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { findIndex: function findIndex(callbackfn /* , that = undefined */) { return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } }); // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables - addToUnscopables(FIND_INDEX); + addToUnscopables$1(FIND_INDEX); + + var global$5 = global$1o; + var isRegExp = isRegexp; + + var TypeError$3 = global$5.TypeError; var notARegexp = function (it) { - if (isRegexp(it)) { - throw TypeError("The method doesn't accept regular expressions"); + if (isRegExp(it)) { + throw TypeError$3("The method doesn't accept regular expressions"); } return it; }; + var wellKnownSymbol = wellKnownSymbol$t; + var MATCH = wellKnownSymbol('match'); var correctIsRegexpLogic = function (METHOD_NAME) { @@ -33089,7663 +33748,26968 @@ } return false; }; + var $$g = _export; + var uncurryThis$7 = functionUncurryThis; + var notARegExp$2 = notARegexp; + var requireObjectCoercible$3 = requireObjectCoercible$e; + var toString$4 = toString$k; + var correctIsRegExpLogic$2 = correctIsRegexpLogic; + + var stringIndexOf = uncurryThis$7(''.indexOf); + // `String.prototype.includes` method // https://tc39.es/ecma262/#sec-string.prototype.includes - _export({ target: 'String', proto: true, forced: !correctIsRegexpLogic('includes') }, { + $$g({ target: 'String', proto: true, forced: !correctIsRegExpLogic$2('includes') }, { includes: function includes(searchString /* , position = 0 */) { - return !!~String(requireObjectCoercible(this)) - .indexOf(notARegexp(searchString), arguments.length > 1 ? arguments[1] : undefined); + return !!~stringIndexOf( + toString$4(requireObjectCoercible$3(this)), + toString$4(notARegExp$2(searchString)), + arguments.length > 1 ? arguments[1] : undefined + ); } }); - var _mainLocalizer = coreLocalizer(); // singleton + /** Detect free variable `global` from Node.js. */ + var freeGlobal = (typeof global === "undefined" ? "undefined" : _typeof(global)) == 'object' && global && global.Object === Object && global; + /** Detect free variable `self`. */ - var _t = _mainLocalizer.t; - // coreLocalizer manages language and locale parameters including translated strings - // + var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' && self && self.Object === Object && self; + /** Used as a reference to the global object. */ - function coreLocalizer() { - var localizer = {}; - var _dataLanguages = {}; // `_dataLocales` is an object containing all _supported_ locale codes -> language info. - // * `rtl` - right-to-left or left-to-right text direction - // * `pct` - the percent of strings translated; 1 = 100%, full coverage - // - // { - // en: { rtl: false, pct: {…} }, - // de: { rtl: false, pct: {…} }, - // … - // } + var root = freeGlobal || freeSelf || Function('return this')(); - var _dataLocales = {}; // `localeStrings` is an object containing all _loaded_ locale codes -> string data. - // { - // en: { icons: {…}, toolbar: {…}, modes: {…}, operations: {…}, … }, - // de: { icons: {…}, toolbar: {…}, modes: {…}, operations: {…}, … }, - // … - // } + /** Built-in value references. */ - var _localeStrings = {}; // the current locale + var _Symbol = root.Symbol; - var _localeCode = 'en-US'; // `_localeCodes` must contain `_localeCode` first, optionally followed by fallbacks + /** Used for built-in method references. */ - var _localeCodes = ['en-US', 'en']; - var _languageCode = 'en'; - var _textDirection = 'ltr'; - var _usesMetric = false; - var _languageNames = {}; - var _scriptNames = {}; // getters for the current locale parameters + var objectProto$1 = Object.prototype; + /** Used to check objects for own properties. */ - localizer.localeCode = function () { - return _localeCode; - }; + var hasOwnProperty$2 = objectProto$1.hasOwnProperty; + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ - localizer.localeCodes = function () { - return _localeCodes; - }; + var nativeObjectToString$1 = objectProto$1.toString; + /** Built-in value references. */ - localizer.languageCode = function () { - return _languageCode; - }; + var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined; + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ - localizer.textDirection = function () { - return _textDirection; - }; + function getRawTag(value) { + var isOwn = hasOwnProperty$2.call(value, symToStringTag$1), + tag = value[symToStringTag$1]; - localizer.usesMetric = function () { - return _usesMetric; - }; + try { + value[symToStringTag$1] = undefined; + var unmasked = true; + } catch (e) {} - localizer.languageNames = function () { - return _languageNames; - }; + var result = nativeObjectToString$1.call(value); - localizer.scriptNames = function () { - return _scriptNames; - }; // The client app may want to manually set the locale, regardless of the - // settings provided by the browser + if (unmasked) { + if (isOwn) { + value[symToStringTag$1] = tag; + } else { + delete value[symToStringTag$1]; + } + } + return result; + } - var _preferredLocaleCodes = []; + /** Used for built-in method references. */ + var objectProto = Object.prototype; + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ - localizer.preferredLocaleCodes = function (codes) { - if (!arguments.length) return _preferredLocaleCodes; + var nativeObjectToString = objectProto.toString; + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ - if (typeof codes === 'string') { - // be generous and accept delimited strings as input - _preferredLocaleCodes = codes.split(/,|;| /gi).filter(Boolean); - } else { - _preferredLocaleCodes = codes; - } + function objectToString(value) { + return nativeObjectToString.call(value); + } - return localizer; - }; + /** `Object#toString` result references. */ - var _loadPromise; + var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + /** Built-in value references. */ - localizer.ensureLoaded = function () { - if (_loadPromise) return _loadPromise; - var filesToFetch = [// load the list of languages - 'languages', // load the list of supported locales - 'locales']; - var localeDirs = { - general: 'locales', - tagging: 'https://cdn.jsdelivr.net/npm/@openstreetmap/id-tagging-schema@3/dist/translations' - }; - var fileMap = _mainFileFetcher.fileMap(); + var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined; + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ - for (var scopeId in localeDirs) { - var key = "locales_index_".concat(scopeId); - fileMap[key] = localeDirs[scopeId] + '/index.min.json'; - filesToFetch.push(key); - } + function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } - return _loadPromise = Promise.all(filesToFetch.map(function (key) { - return _mainFileFetcher.get(key); - })).then(function (results) { - _dataLanguages = results[0]; - _dataLocales = results[1]; - var indexes = results.slice(2); + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); + } - var requestedLocales = (_preferredLocaleCodes || []). // List of locales preferred by the browser in priority order. - concat(utilDetect().browserLocales) // fallback to English since it's the only guaranteed complete language - .concat(['en']); + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike(value) { + return value != null && _typeof(value) == 'object'; + } - _localeCodes = localesToUseFrom(requestedLocales); // Run iD in the highest-priority locale; the rest are fallbacks + /** `Object#toString` result references. */ - _localeCode = _localeCodes[0]; - var loadStringsPromises = []; - indexes.forEach(function (index, i) { - // Will always return the index for `en` if nothing else - var fullCoverageIndex = _localeCodes.findIndex(function (locale) { - return index[locale] && index[locale].pct === 1; - }); // We only need to load locales up until we find one with full coverage + var symbolTag = '[object Symbol]'; + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return _typeof(value) == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag; + } - _localeCodes.slice(0, fullCoverageIndex + 1).forEach(function (code) { - var scopeId = Object.keys(localeDirs)[i]; - var directory = Object.values(localeDirs)[i]; - if (index[code]) loadStringsPromises.push(localizer.loadLocale(code, scopeId, directory)); - }); - }); - return Promise.all(loadStringsPromises); - }).then(function () { - updateForCurrentLocale(); - })["catch"](function (err) { - return console.error(err); - }); // eslint-disable-line - }; // Returns the locales from `requestedLocales` supported by iD that we should use + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } - function localesToUseFrom(requestedLocales) { - var supportedLocales = _dataLocales; - var toUse = []; + return result; + } - for (var i in requestedLocales) { - var locale = requestedLocales[i]; - if (supportedLocales[locale]) toUse.push(locale); + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray$1 = Array.isArray; - if (locale.includes('-')) { - // Full locale ('es-ES'), add fallback to the base ('es') - var langPart = locale.split('-')[0]; - if (supportedLocales[langPart]) toUse.push(langPart); - } - } // remove duplicates + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + /** Used to convert symbols to primitives and strings. */ - return utilArrayUniq(toUse); + var symbolProto = _Symbol ? _Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; } - function updateForCurrentLocale() { - if (!_localeCode) return; - _languageCode = _localeCode.split('-')[0]; - var currentData = _dataLocales[_localeCode] || _dataLocales[_languageCode]; - var hash = utilStringQs(window.location.hash); + if (isArray$1(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } - if (hash.rtl === 'true') { - _textDirection = 'rtl'; - } else if (hash.rtl === 'false') { - _textDirection = 'ltr'; - } else { - _textDirection = currentData && currentData.rtl ? 'rtl' : 'ltr'; - } - - var locale = _localeCode; - if (locale.toLowerCase() === 'en-us') locale = 'en'; - _languageNames = _localeStrings.general[locale].languageNames; - _scriptNames = _localeStrings.general[locale].scriptNames; - _usesMetric = _localeCode.slice(-3).toLowerCase() !== '-us'; + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; } - /* Locales */ - // Returns a Promise to load the strings for the requested locale + var result = value + ''; + return result == '0' && 1 / value == -INFINITY ? '-0' : result; + } - localizer.loadLocale = function (locale, scopeId, directory) { - // US English is the default - if (locale.toLowerCase() === 'en-us') locale = 'en'; + /** Used to match a single whitespace character. */ + var reWhitespace = /\s/; + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace + * character of `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the index of the last non-whitespace character. + */ - if (_localeStrings[scopeId] && _localeStrings[scopeId][locale]) { - // already loaded - return Promise.resolve(locale); - } + function trimmedEndIndex(string) { + var index = string.length; - var fileMap = _mainFileFetcher.fileMap(); - var key = "locale_".concat(scopeId, "_").concat(locale); - fileMap[key] = "".concat(directory, "/").concat(locale, ".min.json"); - return _mainFileFetcher.get(key).then(function (d) { - if (!_localeStrings[scopeId]) _localeStrings[scopeId] = {}; - _localeStrings[scopeId][locale] = d[locale]; - return locale; - }); - }; + while (index-- && reWhitespace.test(string.charAt(index))) {} - localizer.pluralRule = function (number) { - return pluralRule(number, _localeCode); - }; // Returns the plural rule for the given `number` with the given `localeCode`. - // One of: `zero`, `one`, `two`, `few`, `many`, `other` + return index; + } + /** Used to match leading whitespace. */ - function pluralRule(number, localeCode) { - // modern browsers have this functionality built-in - var rules = 'Intl' in window && Intl.PluralRules && new Intl.PluralRules(localeCode); + var reTrimStart = /^\s+/; + /** + * The base implementation of `_.trim`. + * + * @private + * @param {string} string The string to trim. + * @returns {string} Returns the trimmed string. + */ - if (rules) { - return rules.select(number); - } // fallback to basic one/other, as in English + function baseTrim(string) { + return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string; + } + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + function isObject$2(value) { + var type = _typeof(value); - if (number === 1) return 'one'; - return 'other'; - } - /** - * Try to find that string in `locale` or the current `_localeCode` matching - * the given `stringId`. If no string can be found in the requested locale, - * we'll recurse down all the `_localeCodes` until one is found. - * - * @param {string} stringId string identifier - * @param {object?} replacements token replacements and default string - * @param {string?} locale locale to use (defaults to currentLocale) - * @return {string?} localized string - */ + return value != null && (type == 'object' || type == 'function'); + } + /** Used as references for various `Number` constants. */ - localizer.tInfo = function (origStringId, replacements, locale) { - var stringId = origStringId.trim(); - var scopeId = 'general'; + var NAN = 0 / 0; + /** Used to detect bad signed hexadecimal string values. */ - if (stringId[0] === '_') { - var split = stringId.split('.'); - scopeId = split[0].slice(1); - stringId = split.slice(1).join('.'); - } + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + /** Used to detect binary string values. */ - locale = locale || _localeCode; - var path = stringId.split('.').map(function (s) { - return s.replace(//g, '.'); - }).reverse(); - var stringsKey = locale; // US English is the default + var reIsBinary = /^0b[01]+$/i; + /** Used to detect octal string values. */ - if (stringsKey.toLowerCase() === 'en-us') stringsKey = 'en'; - var result = _localeStrings && _localeStrings[scopeId] && _localeStrings[scopeId][stringsKey]; + var reIsOctal = /^0o[0-7]+$/i; + /** Built-in method references without a dependency on `root`. */ - while (result !== undefined && path.length) { - result = result[path.pop()]; - } + var freeParseInt = parseInt; + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ - if (result !== undefined) { - if (replacements) { - if (_typeof(result) === 'object' && Object.keys(result).length) { - // If plural forms are provided, dig one level deeper based on the - // first numeric token replacement provided. - var number = Object.values(replacements).find(function (value) { - return typeof value === 'number'; - }); + function toNumber(value) { + if (typeof value == 'number') { + return value; + } - if (number !== undefined) { - var rule = pluralRule(number, locale); + if (isSymbol(value)) { + return NAN; + } - if (result[rule]) { - result = result[rule]; - } else { - // We're pretty sure this should be a plural but no string - // could be found for the given rule. Just pick the first - // string and hope it makes sense. - result = Object.values(result)[0]; - } - } - } + if (isObject$2(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject$2(other) ? other + '' : other; + } - if (typeof result === 'string') { - for (var key in replacements) { - var value = replacements[key]; + if (typeof value != 'string') { + return value === 0 ? value : +value; + } - if (typeof value === 'number') { - if (value.toLocaleString) { - // format numbers for the locale - value = value.toLocaleString(locale, { - style: 'decimal', - useGrouping: true, - minimumFractionDigits: 0 - }); - } else { - value = value.toString(); - } - } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; + } - var token = "{".concat(key, "}"); - var regex = new RegExp(token, 'g'); - result = result.replace(regex, value); - } - } - } + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ - if (typeof result === 'string') { - // found a localized string! - return { - text: result, - locale: locale - }; - } - } // no localized string found... - // attempt to fallback to a lower-priority language + function toString$3(value) { + return value == null ? '' : baseToString(value); + } + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyOf(object) { + return function (key) { + return object == null ? undefined : object[key]; + }; + } - var index = _localeCodes.indexOf(locale); + /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ - if (index >= 0 && index < _localeCodes.length - 1) { - // eventually this will be 'en' or another locale with 100% coverage - var fallback = _localeCodes[index + 1]; - return localizer.tInfo(origStringId, replacements, fallback); - } + var now = function now() { + return root.Date.now(); + }; - if (replacements && 'default' in replacements) { - // Fallback to a default value if one is specified in `replacements` - return { - text: replacements["default"], - locale: null - }; - } + /** Error message constants. */ - var missing = "Missing ".concat(locale, " translation: ").concat(origStringId); - if (typeof console !== 'undefined') console.error(missing); // eslint-disable-line + var FUNC_ERROR_TEXT$1 = 'Expected a function'; + /* Built-in method references for those with the same name as other `lodash` methods. */ - return { - text: missing, - locale: 'en' - }; - }; + var nativeMax = Math.max, + nativeMin = Math.min; + /** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ - localizer.hasTextForStringId = function (stringId) { - return !!localizer.tInfo(stringId, { - "default": 'nothing found' - }).locale; - }; // Returns only the localized text, discarding the locale info + function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT$1); + } - localizer.t = function (stringId, replacements, locale) { - return localizer.tInfo(stringId, replacements, locale).text; - }; // Returns the localized text wrapped in an HTML element encoding the locale info + wait = toNumber(wait) || 0; + if (isObject$2(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } - localizer.t.html = function (stringId, replacements, locale) { - var info = localizer.tInfo(stringId, replacements, locale); // text may be empty or undefined if `replacements.default` is + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } - return info.text ? localizer.htmlForLocalizedText(info.text, info.locale) : ''; - }; + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; // Start the timer for the trailing edge. - localizer.htmlForLocalizedText = function (text, localeCode) { - return "").concat(text, ""); - }; + timerId = setTimeout(timerExpired, wait); // Invoke the leading edge. - localizer.languageName = function (code, options) { - if (_languageNames[code]) { - // name in locale language - // e.g. "German" - return _languageNames[code]; - } // sometimes we only want the local name + return leading ? invokeFunc(time) : result; + } + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting; + } - if (options && options.localOnly) return null; - var langInfo = _dataLanguages[code]; + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. - if (langInfo) { - if (langInfo.nativeName) { - // name in native language - // e.g. "Deutsch (de)" - return localizer.t('translate.language_and_code', { - language: langInfo.nativeName, - code: code - }); - } else if (langInfo.base && langInfo.script) { - var base = langInfo.base; // the code of the language this is based on + return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; + } - if (_languageNames[base]) { - // base language name in locale language - var scriptCode = langInfo.script; - var script = _scriptNames[scriptCode] || scriptCode; // e.g. "Serbian (Cyrillic)" + function timerExpired() { + var time = now(); - return localizer.t('translate.language_and_code', { - language: _languageNames[base], - code: script - }); - } else if (_dataLanguages[base] && _dataLanguages[base].nativeName) { - // e.g. "српски (sr-Cyrl)" - return localizer.t('translate.language_and_code', { - language: _dataLanguages[base].nativeName, - code: code - }); - } - } - } + if (shouldInvoke(time)) { + return trailingEdge(time); + } // Restart the timer. - return code; // if not found, use the code - }; - return localizer; - } + timerId = setTimeout(timerExpired, remainingWait(time)); + } - // `presetCollection` is a wrapper around an `Array` of presets `collection`, - // and decorated with some extra methods for searching and matching geometry - // + function trailingEdge(time) { + timerId = undefined; // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. - function presetCollection(collection) { - var MAXRESULTS = 50; - var _this = {}; - var _memo = {}; - _this.collection = collection; + if (trailing && lastArgs) { + return invokeFunc(time); + } - _this.item = function (id) { - if (_memo[id]) return _memo[id]; + lastArgs = lastThis = undefined; + return result; + } - var found = _this.collection.find(function (d) { - return d.id === id; - }); + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } - if (found) _memo[id] = found; - return found; - }; + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } - _this.index = function (id) { - return _this.collection.findIndex(function (d) { - return d.id === id; - }); - }; + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } - _this.matchGeometry = function (geometry) { - return presetCollection(_this.collection.filter(function (d) { - return d.matchGeometry(geometry); - })); - }; + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + lastArgs = arguments; + lastThis = this; + lastCallTime = time; - _this.matchAllGeometry = function (geometries) { - return presetCollection(_this.collection.filter(function (d) { - return d && d.matchAllGeometry(geometries); - })); - }; - - _this.matchAnyGeometry = function (geometries) { - return presetCollection(_this.collection.filter(function (d) { - return geometries.some(function (geom) { - return d.matchGeometry(geom); - }); - })); - }; - - _this.fallback = function (geometry) { - var id = geometry; - if (id === 'vertex') id = 'point'; - return _this.item(id); - }; - - _this.search = function (value, geometry, loc) { - if (!value) return _this; // don't remove diacritical characters since we're assuming the user is being intentional - - value = value.toLowerCase().trim(); // match at name beginning or just after a space (e.g. "office" -> match "Law Office") - - function leading(a) { - var index = a.indexOf(value); - return index === 0 || a[index - 1] === ' '; - } // match at name beginning only + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + clearTimeout(timerId); + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } - function leadingStrict(a) { - var index = a.indexOf(value); - return index === 0; + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); } - function sortPresets(nameProp) { - return function sortNames(a, b) { - var aCompare = a[nameProp](); - var bCompare = b[nameProp](); // priority if search string matches preset name exactly - #4325 + return result; + } - if (value === aCompare) return -1; - if (value === bCompare) return 1; // priority for higher matchScore + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } - var i = b.originalScore - a.originalScore; - if (i !== 0) return i; // priority if search string appears earlier in preset name + /** Used to map characters to HTML entities. */ - i = aCompare.indexOf(value) - bCompare.indexOf(value); - if (i !== 0) return i; // priority for shorter preset names + var htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + }; + /** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ - return aCompare.length - bCompare.length; - }; - } + var escapeHtmlChar = basePropertyOf(htmlEscapes); - var pool = _this.collection; + /** Used to match HTML entities and HTML characters. */ - if (Array.isArray(loc)) { - var validLocations = _mainLocations.locationsAt(loc); - pool = pool.filter(function (a) { - return !a.locationSetID || validLocations[a.locationSetID]; - }); - } + var reUnescapedHtml = /[&<>"']/g, + reHasUnescapedHtml = RegExp(reUnescapedHtml.source); + /** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. + * + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ - var searchable = pool.filter(function (a) { - return a.searchable !== false && a.suggestion !== true; - }); - var suggestions = pool.filter(function (a) { - return a.suggestion === true; - }); // matches value to preset.name + function escape$4(string) { + string = toString$3(string); + return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string; + } - var leadingNames = searchable.filter(function (a) { - return leading(a.searchName()); - }).sort(sortPresets('searchName')); // matches value to preset suggestion name + /** Error message constants. */ - var leadingSuggestions = suggestions.filter(function (a) { - return leadingStrict(a.searchName()); - }).sort(sortPresets('searchName')); - var leadingNamesStripped = searchable.filter(function (a) { - return leading(a.searchNameStripped()); - }).sort(sortPresets('searchNameStripped')); - var leadingSuggestionsStripped = suggestions.filter(function (a) { - return leadingStrict(a.searchNameStripped()); - }).sort(sortPresets('searchNameStripped')); // matches value to preset.terms values + var FUNC_ERROR_TEXT = 'Expected a function'; + /** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */ - var leadingTerms = searchable.filter(function (a) { - return (a.terms() || []).some(leading); - }); - var leadingSuggestionTerms = suggestions.filter(function (a) { - return (a.terms() || []).some(leading); - }); // matches value to preset.tags values + function throttle(func, wait, options) { + var leading = true, + trailing = true; - var leadingTagValues = searchable.filter(function (a) { - return Object.values(a.tags || {}).filter(function (val) { - return val !== '*'; - }).some(leading); - }); // finds close matches to value in preset.name + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } - var similarName = searchable.map(function (a) { - return { - preset: a, - dist: utilEditDistance(value, a.searchName()) - }; - }).filter(function (a) { - return a.dist + Math.min(value.length - a.preset.searchName().length, 0) < 3; - }).sort(function (a, b) { - return a.dist - b.dist; - }).map(function (a) { - return a.preset; - }); // finds close matches to value to preset suggestion name + if (isObject$2(options)) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } - var similarSuggestions = suggestions.map(function (a) { - return { - preset: a, - dist: utilEditDistance(value, a.searchName()) - }; - }).filter(function (a) { - return a.dist + Math.min(value.length - a.preset.searchName().length, 0) < 1; - }).sort(function (a, b) { - return a.dist - b.dist; - }).map(function (a) { - return a.preset; - }); // finds close matches to value in preset.terms + return debounce(func, wait, { + 'leading': leading, + 'maxWait': wait, + 'trailing': trailing + }); + } - var similarTerms = searchable.filter(function (a) { - return (a.terms() || []).some(function (b) { - return utilEditDistance(value, b) + Math.min(value.length - b.length, 0) < 3; - }); - }); - var results = leadingNames.concat(leadingSuggestions, leadingNamesStripped, leadingSuggestionsStripped, leadingTerms, leadingSuggestionTerms, leadingTagValues, similarName, similarSuggestions, similarTerms).slice(0, MAXRESULTS - 1); + var $$f = _export; + var lastIndexOf = arrayLastIndexOf; - if (geometry) { - if (typeof geometry === 'string') { - results.push(_this.fallback(geometry)); - } else { - geometry.forEach(function (geom) { - return results.push(_this.fallback(geom)); - }); - } - } + // `Array.prototype.lastIndexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.lastindexof + // eslint-disable-next-line es/no-array-prototype-lastindexof -- required for testing + $$f({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, { + lastIndexOf: lastIndexOf + }); - return presetCollection(utilArrayUniq(results)); - }; + /** Used to map HTML entities to characters. */ - return _this; - } + var htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'" + }; + /** + * Used by `_.unescape` to convert HTML entities to characters. + * + * @private + * @param {string} chr The matched character to unescape. + * @returns {string} Returns the unescaped character. + */ - // `presetCategory` builds a `presetCollection` of member presets, - // decorated with some extra methods for searching and matching geometry - // + var unescapeHtmlChar = basePropertyOf(htmlUnescapes); - function presetCategory(categoryID, category, allPresets) { - var _this = Object.assign({}, category); // shallow copy + /** Used to match HTML entities and HTML characters. */ + var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, + reHasEscapedHtml = RegExp(reEscapedHtml.source); + /** + * The inverse of `_.escape`; this method converts the HTML entities + * `&`, `<`, `>`, `"`, and `'` in `string` to + * their corresponding characters. + * + * **Note:** No other HTML entities are unescaped. To unescape additional + * HTML entities use a third-party library like [_he_](https://mths.be/he). + * + * @static + * @memberOf _ + * @since 0.6.0 + * @category String + * @param {string} [string=''] The string to unescape. + * @returns {string} Returns the unescaped string. + * @example + * + * _.unescape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ - var _searchName; // cache + function unescape$3(string) { + string = toString$3(string); + return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string; + } + var global$4 = global$1o; + var isArray = isArray$8; + var lengthOfArrayLike$1 = lengthOfArrayLike$i; + var bind$3 = functionBindContext; - var _searchNameStripped; // cache + var TypeError$2 = global$4.TypeError; + // `FlattenIntoArray` abstract operation + // https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray + var flattenIntoArray$1 = function (target, original, source, sourceLen, start, depth, mapper, thisArg) { + var targetIndex = start; + var sourceIndex = 0; + var mapFn = mapper ? bind$3(mapper, thisArg) : false; + var element, elementLen; - _this.id = categoryID; - _this.members = presetCollection((category.members || []).map(function (presetID) { - return allPresets[presetID]; - }).filter(Boolean)); - _this.geometry = _this.members.collection.reduce(function (acc, preset) { - for (var i in preset.geometry) { - var geometry = preset.geometry[i]; + while (sourceIndex < sourceLen) { + if (sourceIndex in source) { + element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; - if (acc.indexOf(geometry) === -1) { - acc.push(geometry); + if (depth > 0 && isArray(element)) { + elementLen = lengthOfArrayLike$1(element); + targetIndex = flattenIntoArray$1(target, original, element, elementLen, targetIndex, depth - 1) - 1; + } else { + if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError$2('Exceed the acceptable array length'); + target[targetIndex] = element; } - } - return acc; - }, []); - - _this.matchGeometry = function (geom) { - return _this.geometry.indexOf(geom) >= 0; - }; + targetIndex++; + } + sourceIndex++; + } + return targetIndex; + }; - _this.matchAllGeometry = function (geometries) { - return _this.members.collection.some(function (preset) { - return preset.matchAllGeometry(geometries); - }); - }; + var flattenIntoArray_1 = flattenIntoArray$1; - _this.matchScore = function () { - return -1; - }; + var $$e = _export; + var flattenIntoArray = flattenIntoArray_1; + var aCallable = aCallable$a; + var toObject = toObject$i; + var lengthOfArrayLike = lengthOfArrayLike$i; + var arraySpeciesCreate = arraySpeciesCreate$4; - _this.name = function () { - return _t("_tagging.presets.categories.".concat(categoryID, ".name"), { - 'default': categoryID - }); - }; + // `Array.prototype.flatMap` method + // https://tc39.es/ecma262/#sec-array.prototype.flatmap + $$e({ target: 'Array', proto: true }, { + flatMap: function flatMap(callbackfn /* , thisArg */) { + var O = toObject(this); + var sourceLen = lengthOfArrayLike(O); + var A; + aCallable(callbackfn); + A = arraySpeciesCreate(O, 0); + A.length = flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return A; + } + }); - _this.nameLabel = function () { - return _t.html("_tagging.presets.categories.".concat(categoryID, ".name"), { - 'default': categoryID - }); - }; + // this method was added to unscopables after implementation + // in popular engines, so it's moved to a separate module + var addToUnscopables = addToUnscopables$6; - _this.terms = function () { - return []; - }; + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables('flatMap'); - _this.searchName = function () { - if (!_searchName) { - _searchName = (_this.suggestion ? _this.originalName : _this.name()).toLowerCase(); - } + var $$d = _export; + var uncurryThis$6 = functionUncurryThis; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var toLength$2 = toLength$c; + var toString$2 = toString$k; + var notARegExp$1 = notARegexp; + var requireObjectCoercible$2 = requireObjectCoercible$e; + var correctIsRegExpLogic$1 = correctIsRegexpLogic; - return _searchName; - }; + // eslint-disable-next-line es/no-string-prototype-endswith -- safe + var un$EndsWith = uncurryThis$6(''.endsWith); + var slice$2 = uncurryThis$6(''.slice); + var min$1 = Math.min; - _this.searchNameStripped = function () { - if (!_searchNameStripped) { - _searchNameStripped = _this.searchName(); // split combined diacritical characters into their parts + var CORRECT_IS_REGEXP_LOGIC$1 = correctIsRegExpLogic$1('endsWith'); + // https://github.com/zloirock/core-js/pull/702 + var MDN_POLYFILL_BUG$1 = !CORRECT_IS_REGEXP_LOGIC$1 && !!function () { + var descriptor = getOwnPropertyDescriptor$1(String.prototype, 'endsWith'); + return descriptor && !descriptor.writable; + }(); - if (_searchNameStripped.normalize) _searchNameStripped = _searchNameStripped.normalize('NFD'); // remove diacritics + // `String.prototype.endsWith` method + // https://tc39.es/ecma262/#sec-string.prototype.endswith + $$d({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG$1 && !CORRECT_IS_REGEXP_LOGIC$1 }, { + endsWith: function endsWith(searchString /* , endPosition = @length */) { + var that = toString$2(requireObjectCoercible$2(this)); + notARegExp$1(searchString); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = that.length; + var end = endPosition === undefined ? len : min$1(toLength$2(endPosition), len); + var search = toString$2(searchString); + return un$EndsWith + ? un$EndsWith(that, search, end) + : slice$2(that, end - search.length, end) === search; + } + }); - _searchNameStripped = _searchNameStripped.replace(/[\u0300-\u036f]/g, ''); - } + // https://github.com/tc39/proposal-string-pad-start-end + var uncurryThis$5 = functionUncurryThis; + var toLength$1 = toLength$c; + var toString$1 = toString$k; + var $repeat = stringRepeat; + var requireObjectCoercible$1 = requireObjectCoercible$e; + + var repeat$1 = uncurryThis$5($repeat); + var stringSlice$2 = uncurryThis$5(''.slice); + var ceil = Math.ceil; - return _searchNameStripped; + // `String.prototype.{ padStart, padEnd }` methods implementation + var createMethod = function (IS_END) { + return function ($this, maxLength, fillString) { + var S = toString$1(requireObjectCoercible$1($this)); + var intMaxLength = toLength$1(maxLength); + var stringLength = S.length; + var fillStr = fillString === undefined ? ' ' : toString$1(fillString); + var fillLen, stringFiller; + if (intMaxLength <= stringLength || fillStr == '') return S; + fillLen = intMaxLength - stringLength; + stringFiller = repeat$1(fillStr, ceil(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) stringFiller = stringSlice$2(stringFiller, 0, fillLen); + return IS_END ? S + stringFiller : stringFiller + S; }; + }; - return _this; - } - - // `presetField` decorates a given `field` Object - // with some extra methods for searching and matching geometry - // - - function presetField(fieldID, field) { - var _this = Object.assign({}, field); // shallow copy - + var stringPad = { + // `String.prototype.padStart` method + // https://tc39.es/ecma262/#sec-string.prototype.padstart + start: createMethod(false), + // `String.prototype.padEnd` method + // https://tc39.es/ecma262/#sec-string.prototype.padend + end: createMethod(true) + }; - _this.id = fieldID; // for use in classes, element ids, css selectors + // https://github.com/zloirock/core-js/issues/280 + var userAgent = engineUserAgent; - _this.safeid = utilSafeClassName(fieldID); + var stringPadWebkitBug = /Version\/10(?:\.\d+){1,2}(?: [\w./]+)?(?: Mobile\/\w+)? Safari\//.test(userAgent); - _this.matchGeometry = function (geom) { - return !_this.geometry || _this.geometry.indexOf(geom) !== -1; - }; + var $$c = _export; + var $padEnd = stringPad.end; + var WEBKIT_BUG$1 = stringPadWebkitBug; - _this.matchAllGeometry = function (geometries) { - return !_this.geometry || geometries.every(function (geom) { - return _this.geometry.indexOf(geom) !== -1; - }); - }; + // `String.prototype.padEnd` method + // https://tc39.es/ecma262/#sec-string.prototype.padend + $$c({ target: 'String', proto: true, forced: WEBKIT_BUG$1 }, { + padEnd: function padEnd(maxLength /* , fillString = ' ' */) { + return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } + }); - _this.t = function (scope, options) { - return _t("_tagging.presets.fields.".concat(fieldID, ".").concat(scope), options); - }; + var $$b = _export; + var $padStart = stringPad.start; + var WEBKIT_BUG = stringPadWebkitBug; - _this.t.html = function (scope, options) { - return _t.html("_tagging.presets.fields.".concat(fieldID, ".").concat(scope), options); - }; + // `String.prototype.padStart` method + // https://tc39.es/ecma262/#sec-string.prototype.padstart + $$b({ target: 'String', proto: true, forced: WEBKIT_BUG }, { + padStart: function padStart(maxLength /* , fillString = ' ' */) { + return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } + }); - _this.hasTextForStringId = function (scope) { - return _mainLocalizer.hasTextForStringId("_tagging.presets.fields.".concat(fieldID, ".").concat(scope)); - }; + var $$a = _export; + var $reduceRight = arrayReduce.right; + var arrayMethodIsStrict = arrayMethodIsStrict$9; + var CHROME_VERSION = engineV8Version; + var IS_NODE = engineIsNode; - _this.title = function () { - return _this.overrideLabel || _this.t('label', { - 'default': fieldID - }); - }; + var STRICT_METHOD = arrayMethodIsStrict('reduceRight'); + // Chrome 80-82 has a critical bug + // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982 + var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83; - _this.label = function () { - return _this.overrideLabel || _this.t.html('label', { - 'default': fieldID - }); - }; + // `Array.prototype.reduceRight` method + // https://tc39.es/ecma262/#sec-array.prototype.reduceright + $$a({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, { + reduceRight: function reduceRight(callbackfn /* , initialValue */) { + return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + } + }); - var _placeholder = _this.placeholder; + var $$9 = _export; + var repeat = stringRepeat; - _this.placeholder = function () { - return _this.t('placeholder', { - 'default': _placeholder - }); - }; + // `String.prototype.repeat` method + // https://tc39.es/ecma262/#sec-string.prototype.repeat + $$9({ target: 'String', proto: true }, { + repeat: repeat + }); - _this.originalTerms = (_this.terms || []).join(); + var $$8 = _export; + var uncurryThis$4 = functionUncurryThis; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var toLength = toLength$c; + var toString = toString$k; + var notARegExp = notARegexp; + var requireObjectCoercible = requireObjectCoercible$e; + var correctIsRegExpLogic = correctIsRegexpLogic; - _this.terms = function () { - return _this.t('terms', { - 'default': _this.originalTerms - }).toLowerCase().trim().split(/\s*,+\s*/); - }; + // eslint-disable-next-line es/no-string-prototype-startswith -- safe + var un$StartsWith = uncurryThis$4(''.startsWith); + var stringSlice$1 = uncurryThis$4(''.slice); + var min = Math.min; - _this.increment = _this.type === 'number' ? _this.increment || 1 : undefined; - return _this; - } + var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith'); + // https://github.com/zloirock/core-js/pull/702 + var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; + }(); - // `Array.prototype.lastIndexOf` method - // https://tc39.es/ecma262/#sec-array.prototype.lastindexof - // eslint-disable-next-line es/no-array-prototype-lastindexof -- required for testing - _export({ target: 'Array', proto: true, forced: arrayLastIndexOf !== [].lastIndexOf }, { - lastIndexOf: arrayLastIndexOf + // `String.prototype.startsWith` method + // https://tc39.es/ecma262/#sec-string.prototype.startswith + $$8({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString(requireObjectCoercible(this)); + notARegExp(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = toString(searchString); + return un$StartsWith + ? un$StartsWith(that, search, index) + : stringSlice$1(that, index, index + search.length) === search; + } }); - // `presetPreset` decorates a given `preset` Object - // with some extra methods for searching and matching geometry - // + var $$7 = _export; + var $trimEnd = stringTrim.end; + var forcedStringTrimMethod$1 = stringTrimForced; - function presetPreset(presetID, preset, addable, allFields, allPresets) { - allFields = allFields || {}; - allPresets = allPresets || {}; + var FORCED$4 = forcedStringTrimMethod$1('trimEnd'); - var _this = Object.assign({}, preset); // shallow copy + var trimEnd = FORCED$4 ? function trimEnd() { + return $trimEnd(this); + // eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe + } : ''.trimEnd; + // `String.prototype.{ trimEnd, trimRight }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + // https://tc39.es/ecma262/#String.prototype.trimright + $$7({ target: 'String', proto: true, name: 'trimEnd', forced: FORCED$4 }, { + trimEnd: trimEnd, + trimRight: trimEnd + }); - var _addable = addable || false; + var $$6 = _export; + var $trimStart = stringTrim.start; + var forcedStringTrimMethod = stringTrimForced; - var _resolvedFields; // cache + var FORCED$3 = forcedStringTrimMethod('trimStart'); + var trimStart = FORCED$3 ? function trimStart() { + return $trimStart(this); + // eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe + } : ''.trimStart; - var _resolvedMoreFields; // cache + // `String.prototype.{ trimStart, trimLeft }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + // https://tc39.es/ecma262/#String.prototype.trimleft + $$6({ target: 'String', proto: true, name: 'trimStart', forced: FORCED$3 }, { + trimStart: trimStart, + trimLeft: trimStart + }); + var _mainLocalizer = coreLocalizer(); // singleton - var _searchName; // cache + var _t = _mainLocalizer.t; + // coreLocalizer manages language and locale parameters including translated strings + // - var _searchNameStripped; // cache + function coreLocalizer() { + var localizer = {}; + var _dataLanguages = {}; // `_dataLocales` is an object containing all _supported_ locale codes -> language info. + // * `rtl` - right-to-left or left-to-right text direction + // * `pct` - the percent of strings translated; 1 = 100%, full coverage + // + // { + // en: { rtl: false, pct: {…} }, + // de: { rtl: false, pct: {…} }, + // … + // } + var _dataLocales = {}; // `localeStrings` is an object containing all _loaded_ locale codes -> string data. + // { + // en: { icons: {…}, toolbar: {…}, modes: {…}, operations: {…}, … }, + // de: { icons: {…}, toolbar: {…}, modes: {…}, operations: {…}, … }, + // … + // } - _this.id = presetID; - _this.safeid = utilSafeClassName(presetID); // for use in css classes, selectors, element ids + var _localeStrings = {}; // the current locale - _this.originalTerms = (_this.terms || []).join(); - _this.originalName = _this.name || ''; - _this.originalScore = _this.matchScore || 1; - _this.originalReference = _this.reference || {}; - _this.originalFields = _this.fields || []; - _this.originalMoreFields = _this.moreFields || []; + var _localeCode = 'en-US'; // `_localeCodes` must contain `_localeCode` first, optionally followed by fallbacks - _this.fields = function () { - return _resolvedFields || (_resolvedFields = resolve('fields')); + var _localeCodes = ['en-US', 'en']; + var _languageCode = 'en'; + var _textDirection = 'ltr'; + var _usesMetric = false; + var _languageNames = {}; + var _scriptNames = {}; // getters for the current locale parameters + + localizer.localeCode = function () { + return _localeCode; }; - _this.moreFields = function () { - return _resolvedMoreFields || (_resolvedMoreFields = resolve('moreFields')); + localizer.localeCodes = function () { + return _localeCodes; }; - _this.resetFields = function () { - return _resolvedFields = _resolvedMoreFields = null; + localizer.languageCode = function () { + return _languageCode; }; - _this.tags = _this.tags || {}; - _this.addTags = _this.addTags || _this.tags; - _this.removeTags = _this.removeTags || _this.addTags; - _this.geometry = _this.geometry || []; + localizer.textDirection = function () { + return _textDirection; + }; - _this.matchGeometry = function (geom) { - return _this.geometry.indexOf(geom) >= 0; + localizer.usesMetric = function () { + return _usesMetric; }; - _this.matchAllGeometry = function (geoms) { - return geoms.every(_this.matchGeometry); + localizer.languageNames = function () { + return _languageNames; }; - _this.matchScore = function (entityTags) { - var tags = _this.tags; - var seen = {}; - var score = 0; // match on tags + localizer.scriptNames = function () { + return _scriptNames; + }; // The client app may want to manually set the locale, regardless of the + // settings provided by the browser - for (var k in tags) { - seen[k] = true; - if (entityTags[k] === tags[k]) { - score += _this.originalScore; - } else if (tags[k] === '*' && k in entityTags) { - score += _this.originalScore / 2; - } else { - return -1; - } - } // boost score for additional matches in addTags - #6802 + var _preferredLocaleCodes = []; + localizer.preferredLocaleCodes = function (codes) { + if (!arguments.length) return _preferredLocaleCodes; - var addTags = _this.addTags; + if (typeof codes === 'string') { + // be generous and accept delimited strings as input + _preferredLocaleCodes = codes.split(/,|;| /gi).filter(Boolean); + } else { + _preferredLocaleCodes = codes; + } - for (var _k in addTags) { - if (!seen[_k] && entityTags[_k] === addTags[_k]) { - score += _this.originalScore; + return localizer; + }; + + var _loadPromise; + + localizer.ensureLoaded = function () { + if (_loadPromise) return _loadPromise; + var filesToFetch = ['languages', // load the list of languages + 'locales' // load the list of supported locales + ]; + var localeDirs = { + general: 'locales', + tagging: 'https://cdn.jsdelivr.net/npm/@openstreetmap/id-tagging-schema@3/dist/translations' + }; + var fileMap = _mainFileFetcher.fileMap(); + + for (var scopeId in localeDirs) { + var key = "locales_index_".concat(scopeId); + + if (!fileMap[key]) { + fileMap[key] = localeDirs[scopeId] + '/index.min.json'; } + + filesToFetch.push(key); } - return score; - }; + return _loadPromise = Promise.all(filesToFetch.map(function (key) { + return _mainFileFetcher.get(key); + })).then(function (results) { + _dataLanguages = results[0]; + _dataLocales = results[1]; + var indexes = results.slice(2); - _this.t = function (scope, options) { - var textID = "_tagging.presets.presets.".concat(presetID, ".").concat(scope); - return _t(textID, options); - }; + var requestedLocales = (_preferredLocaleCodes || []).concat(utilDetect().browserLocales) // List of locales preferred by the browser in priority order. + .concat(['en']); // fallback to English since it's the only guaranteed complete language - _this.t.html = function (scope, options) { - var textID = "_tagging.presets.presets.".concat(presetID, ".").concat(scope); - return _t.html(textID, options); - }; - _this.name = function () { - return _this.t('name', { - 'default': _this.originalName - }); - }; + _localeCodes = localesToUseFrom(requestedLocales); + _localeCode = _localeCodes[0]; // Run iD in the highest-priority locale; the rest are fallbacks - _this.nameLabel = function () { - return _this.t.html('name', { - 'default': _this.originalName - }); - }; + var loadStringsPromises = []; + indexes.forEach(function (index, i) { + // Will always return the index for `en` if nothing else + var fullCoverageIndex = _localeCodes.findIndex(function (locale) { + return index[locale] && index[locale].pct === 1; + }); // We only need to load locales up until we find one with full coverage - _this.subtitle = function () { - if (_this.suggestion) { - var path = presetID.split('/'); - path.pop(); // remove brand name - return _t('_tagging.presets.presets.' + path.join('/') + '.name'); - } + _localeCodes.slice(0, fullCoverageIndex + 1).forEach(function (code) { + var scopeId = Object.keys(localeDirs)[i]; + var directory = Object.values(localeDirs)[i]; + if (index[code]) loadStringsPromises.push(localizer.loadLocale(code, scopeId, directory)); + }); + }); + return Promise.all(loadStringsPromises); + }).then(function () { + updateForCurrentLocale(); + })["catch"](function (err) { + return console.error(err); + }); // eslint-disable-line + }; // Returns the locales from `requestedLocales` supported by iD that we should use - return null; - }; - _this.subtitleLabel = function () { - if (_this.suggestion) { - var path = presetID.split('/'); - path.pop(); // remove brand name + function localesToUseFrom(requestedLocales) { + var supportedLocales = _dataLocales; + var toUse = []; - return _t.html('_tagging.presets.presets.' + path.join('/') + '.name'); - } + for (var i in requestedLocales) { + var locale = requestedLocales[i]; + if (supportedLocales[locale]) toUse.push(locale); - return null; - }; + if (locale.includes('-')) { + // Full locale ('es-ES'), add fallback to the base ('es') + var langPart = locale.split('-')[0]; + if (supportedLocales[langPart]) toUse.push(langPart); + } + } // remove duplicates - _this.terms = function () { - return _this.t('terms', { - 'default': _this.originalTerms - }).toLowerCase().trim().split(/\s*,+\s*/); - }; - _this.searchName = function () { - if (!_searchName) { - _searchName = (_this.suggestion ? _this.originalName : _this.name()).toLowerCase(); + return utilArrayUniq(toUse); + } + + function updateForCurrentLocale() { + if (!_localeCode) return; + _languageCode = _localeCode.split('-')[0]; + var currentData = _dataLocales[_localeCode] || _dataLocales[_languageCode]; + var hash = utilStringQs(window.location.hash); + + if (hash.rtl === 'true') { + _textDirection = 'rtl'; + } else if (hash.rtl === 'false') { + _textDirection = 'ltr'; + } else { + _textDirection = currentData && currentData.rtl ? 'rtl' : 'ltr'; } - return _searchName; - }; + var locale = _localeCode; + if (locale.toLowerCase() === 'en-us') locale = 'en'; + _languageNames = _localeStrings.general[locale].languageNames; + _scriptNames = _localeStrings.general[locale].scriptNames; + _usesMetric = _localeCode.slice(-3).toLowerCase() !== '-us'; + } + /* Locales */ + // Returns a Promise to load the strings for the requested locale - _this.searchNameStripped = function () { - if (!_searchNameStripped) { - _searchNameStripped = _this.searchName(); // split combined diacritical characters into their parts - if (_searchNameStripped.normalize) _searchNameStripped = _searchNameStripped.normalize('NFD'); // remove diacritics + localizer.loadLocale = function (locale, scopeId, directory) { + // US English is the default + if (locale.toLowerCase() === 'en-us') locale = 'en'; - _searchNameStripped = _searchNameStripped.replace(/[\u0300-\u036f]/g, ''); + if (_localeStrings[scopeId] && _localeStrings[scopeId][locale]) { + // already loaded + return Promise.resolve(locale); } - return _searchNameStripped; - }; + var fileMap = _mainFileFetcher.fileMap(); + var key = "locale_".concat(scopeId, "_").concat(locale); - _this.isFallback = function () { - var tagCount = Object.keys(_this.tags).length; - return tagCount === 0 || tagCount === 1 && _this.tags.hasOwnProperty('area'); - }; + if (!fileMap[key]) { + fileMap[key] = "".concat(directory, "/").concat(locale, ".min.json"); + } - _this.addable = function (val) { - if (!arguments.length) return _addable; - _addable = val; - return _this; + return _mainFileFetcher.get(key).then(function (d) { + if (!_localeStrings[scopeId]) _localeStrings[scopeId] = {}; + _localeStrings[scopeId][locale] = d[locale]; + return locale; + }); }; - _this.reference = function () { - // Lookup documentation on Wikidata... - var qid = _this.tags.wikidata || _this.tags['flag:wikidata'] || _this.tags['brand:wikidata'] || _this.tags['network:wikidata'] || _this.tags['operator:wikidata']; + localizer.pluralRule = function (number) { + return pluralRule(number, _localeCode); + }; // Returns the plural rule for the given `number` with the given `localeCode`. + // One of: `zero`, `one`, `two`, `few`, `many`, `other` - if (qid) { - return { - qid: qid - }; - } // Lookup documentation on OSM Wikibase... + function pluralRule(number, localeCode) { + // modern browsers have this functionality built-in + var rules = 'Intl' in window && Intl.PluralRules && new Intl.PluralRules(localeCode); - var key = _this.originalReference.key || Object.keys(utilObjectOmit(_this.tags, 'name'))[0]; - var value = _this.originalReference.value || _this.tags[key]; + if (rules) { + return rules.select(number); + } // fallback to basic one/other, as in English - if (value === '*') { - return { - key: key - }; - } else { - return { - key: key, - value: value - }; - } - }; - _this.unsetTags = function (tags, geometry, ignoringKeys, skipFieldDefaults) { - // allow manually keeping some tags - var removeTags = ignoringKeys ? utilObjectOmit(_this.removeTags, ignoringKeys) : _this.removeTags; - tags = utilObjectOmit(tags, Object.keys(removeTags)); + if (number === 1) return 'one'; + return 'other'; + } + /** + * Try to find that string in `locale` or the current `_localeCode` matching + * the given `stringId`. If no string can be found in the requested locale, + * we'll recurse down all the `_localeCodes` until one is found. + * + * @param {string} stringId string identifier + * @param {object?} replacements token replacements and default string + * @param {string?} locale locale to use (defaults to currentLocale) + * @return {string?} localized string + */ - if (geometry && !skipFieldDefaults) { - _this.fields().forEach(function (field) { - if (field.matchGeometry(geometry) && field.key && field["default"] === tags[field.key]) { - delete tags[field.key]; - } - }); - } - delete tags.area; - return tags; - }; + localizer.tInfo = function (origStringId, replacements, locale) { + var stringId = origStringId.trim(); + var scopeId = 'general'; - _this.setTags = function (tags, geometry, skipFieldDefaults) { - var addTags = _this.addTags; - tags = Object.assign({}, tags); // shallow copy + if (stringId[0] === '_') { + var split = stringId.split('.'); + scopeId = split[0].slice(1); + stringId = split.slice(1).join('.'); + } - for (var k in addTags) { - if (addTags[k] === '*') { - // if this tag is ancillary, don't override an existing value since any value is okay - if (_this.tags[k] || !tags[k] || tags[k] === 'no') { - tags[k] = 'yes'; - } - } else { - tags[k] = addTags[k]; - } - } // Add area=yes if necessary. - // This is necessary if the geometry is already an area (e.g. user drew an area) AND any of: - // 1. chosen preset could be either an area or a line (`barrier=city_wall`) - // 2. chosen preset doesn't have a key in osmAreaKeys (`railway=station`) + locale = locale || _localeCode; + var path = stringId.split('.').map(function (s) { + return s.replace(//g, '.'); + }).reverse(); + var stringsKey = locale; // US English is the default + if (stringsKey.toLowerCase() === 'en-us') stringsKey = 'en'; + var result = _localeStrings && _localeStrings[scopeId] && _localeStrings[scopeId][stringsKey]; - if (!addTags.hasOwnProperty('area')) { - delete tags.area; + while (result !== undefined && path.length) { + result = result[path.pop()]; + } - if (geometry === 'area') { - var needsAreaTag = true; + if (result !== undefined) { + if (replacements) { + if (_typeof(result) === 'object' && Object.keys(result).length) { + // If plural forms are provided, dig one level deeper based on the + // first numeric token replacement provided. + var number = Object.values(replacements).find(function (value) { + return typeof value === 'number'; + }); - if (_this.geometry.indexOf('line') === -1) { - for (var _k2 in addTags) { - if (_k2 in osmAreaKeys) { - needsAreaTag = false; - break; + if (number !== undefined) { + var rule = pluralRule(number, locale); + + if (result[rule]) { + result = result[rule]; + } else { + // We're pretty sure this should be a plural but no string + // could be found for the given rule. Just pick the first + // string and hope it makes sense. + result = Object.values(result)[0]; } } } - if (needsAreaTag) { - tags.area = 'yes'; + if (typeof result === 'string') { + for (var key in replacements) { + var value = replacements[key]; + + if (typeof value === 'number') { + if (value.toLocaleString) { + // format numbers for the locale + value = value.toLocaleString(locale, { + style: 'decimal', + useGrouping: true, + minimumFractionDigits: 0 + }); + } else { + value = value.toString(); + } + } + + var token = "{".concat(key, "}"); + var regex = new RegExp(token, 'g'); + result = result.replace(regex, value); + } } } + + if (typeof result === 'string') { + // found a localized string! + return { + text: result, + locale: locale + }; + } + } // no localized string found... + // attempt to fallback to a lower-priority language + + + var index = _localeCodes.indexOf(locale); + + if (index >= 0 && index < _localeCodes.length - 1) { + // eventually this will be 'en' or another locale with 100% coverage + var fallback = _localeCodes[index + 1]; + return localizer.tInfo(origStringId, replacements, fallback); } - if (geometry && !skipFieldDefaults) { - _this.fields().forEach(function (field) { - if (field.matchGeometry(geometry) && field.key && !tags[field.key] && field["default"]) { - tags[field.key] = field["default"]; - } - }); + if (replacements && 'default' in replacements) { + // Fallback to a default value if one is specified in `replacements` + return { + text: replacements["default"], + locale: null + }; } - return tags; - }; // For a preset without fields, use the fields of the parent preset. - // Replace {preset} placeholders with the fields of the specified presets. + var missing = "Missing ".concat(locale, " translation: ").concat(origStringId); + if (typeof console !== 'undefined') console.error(missing); // eslint-disable-line + return { + text: missing, + locale: 'en' + }; + }; - function resolve(which) { - var fieldIDs = which === 'fields' ? _this.originalFields : _this.originalMoreFields; - var resolved = []; - fieldIDs.forEach(function (fieldID) { - var match = fieldID.match(/\{(.*)\}/); + localizer.hasTextForStringId = function (stringId) { + return !!localizer.tInfo(stringId, { + "default": 'nothing found' + }).locale; + }; // Returns only the localized text, discarding the locale info - if (match !== null) { - // a presetID wrapped in braces {} - resolved = resolved.concat(inheritFields(match[1], which)); - } else if (allFields[fieldID]) { - // a normal fieldID - resolved.push(allFields[fieldID]); - } else { - console.log("Cannot resolve \"".concat(fieldID, "\" found in ").concat(_this.id, ".").concat(which)); // eslint-disable-line no-console - } - }); // no fields resolved, so use the parent's if possible - if (!resolved.length) { - var endIndex = _this.id.lastIndexOf('/'); + localizer.t = function (stringId, replacements, locale) { + return localizer.tInfo(stringId, replacements, locale).text; + }; // Returns the localized text wrapped in an HTML element encoding the locale info - var parentID = endIndex && _this.id.substring(0, endIndex); + /** + * @deprecated This method is considered deprecated. Instead, use the direct DOM manipulating + * method `t.append`. + */ - if (parentID) { - resolved = inheritFields(parentID, which); - } - } - return utilArrayUniq(resolved); // returns an array of fields to inherit from the given presetID, if found + localizer.t.html = function (stringId, replacements, locale) { + // replacement string might be html unsafe, so we need to escape it except if it is explicitly marked as html code + replacements = Object.assign({}, replacements); - function inheritFields(presetID, which) { - var parent = allPresets[presetID]; - if (!parent) return []; + for (var k in replacements) { + if (typeof replacements[k] === 'string') { + replacements[k] = escape$4(replacements[k]); + } - if (which === 'fields') { - return parent.fields().filter(shouldInherit); - } else if (which === 'moreFields') { - return parent.moreFields(); - } else { - return []; + if (_typeof(replacements[k]) === 'object' && typeof replacements[k].html === 'string') { + replacements[k] = replacements[k].html; } - } // Skip `fields` for the keys which define the preset. - // These are usually `typeCombo` fields like `shop=*` + } + var info = localizer.tInfo(stringId, replacements, locale); // text may be empty or undefined if `replacements.default` is - function shouldInherit(f) { - if (f.key && _this.tags[f.key] !== undefined && // inherit anyway if multiple values are allowed or just a checkbox - f.type !== 'multiCombo' && f.type !== 'semiCombo' && f.type !== 'manyCombo' && f.type !== 'check') return false; - return true; + if (info.text) { + return "").concat(info.text, ""); + } else { + return ''; } - } - - return _this; - } + }; // Adds localized text wrapped as an HTML span element with locale info to the DOM - var _mainPresetIndex = presetIndex(); // singleton - // `presetIndex` wraps a `presetCollection` - // with methods for loading new data and returning defaults - // - function presetIndex() { - var dispatch = dispatch$8('favoritePreset', 'recentsChange'); - var MAXRECENTS = 30; // seed the preset lists with geometry fallbacks + localizer.t.append = function (stringId, replacements, locale) { + return function (selection) { + var info = localizer.tInfo(stringId, replacements, locale); + return selection.append('span').attr('class', 'localized-text').attr('lang', info.locale || 'und').text((replacements && replacements.prefix || '') + info.text + (replacements && replacements.suffix || '')); + }; + }; - var POINT = presetPreset('point', { - name: 'Point', - tags: {}, - geometry: ['point', 'vertex'], - matchScore: 0.1 - }); - var LINE = presetPreset('line', { - name: 'Line', - tags: {}, - geometry: ['line'], - matchScore: 0.1 - }); - var AREA = presetPreset('area', { - name: 'Area', - tags: { - area: 'yes' - }, - geometry: ['area'], - matchScore: 0.1 - }); - var RELATION = presetPreset('relation', { - name: 'Relation', - tags: {}, - geometry: ['relation'], - matchScore: 0.1 - }); + localizer.languageName = function (code, options) { + if (_languageNames[code]) { + // name in locale language + // e.g. "German" + return _languageNames[code]; + } // sometimes we only want the local name - var _this = presetCollection([POINT, LINE, AREA, RELATION]); - var _presets = { - point: POINT, - line: LINE, - area: AREA, - relation: RELATION - }; - var _defaults = { - point: presetCollection([POINT]), - vertex: presetCollection([POINT]), - line: presetCollection([LINE]), - area: presetCollection([AREA]), - relation: presetCollection([RELATION]) - }; - var _fields = {}; - var _categories = {}; - var _universal = []; - var _addablePresetIDs = null; // Set of preset IDs that the user can add + if (options && options.localOnly) return null; + var langInfo = _dataLanguages[code]; - var _recents; + if (langInfo) { + if (langInfo.nativeName) { + // name in native language + // e.g. "Deutsch (de)" + return localizer.t('translate.language_and_code', { + language: langInfo.nativeName, + code: code + }); + } else if (langInfo.base && langInfo.script) { + var base = langInfo.base; // the code of the language this is based on - var _favorites; // Index of presets by (geometry, tag key). + if (_languageNames[base]) { + // base language name in locale language + var scriptCode = langInfo.script; + var script = _scriptNames[scriptCode] || scriptCode; // e.g. "Serbian (Cyrillic)" + return localizer.t('translate.language_and_code', { + language: _languageNames[base], + code: script + }); + } else if (_dataLanguages[base] && _dataLanguages[base].nativeName) { + // e.g. "српски (sr-Cyrl)" + return localizer.t('translate.language_and_code', { + language: _dataLanguages[base].nativeName, + code: code + }); + } + } + } - var _geometryIndex = { - point: {}, - vertex: {}, - line: {}, - area: {}, - relation: {} + return code; // if not found, use the code }; - var _loadPromise; + return localizer; + } - _this.ensureLoaded = function () { - if (_loadPromise) return _loadPromise; - return _loadPromise = Promise.all([_mainFileFetcher.get('preset_categories'), _mainFileFetcher.get('preset_defaults'), _mainFileFetcher.get('preset_presets'), _mainFileFetcher.get('preset_fields')]).then(function (vals) { - _this.merge({ - categories: vals[0], - defaults: vals[1], - presets: vals[2], - fields: vals[3] - }); + // `presetCollection` is a wrapper around an `Array` of presets `collection`, + // and decorated with some extra methods for searching and matching geometry + // - osmSetAreaKeys(_this.areaKeys()); - osmSetPointTags(_this.pointTags()); - osmSetVertexTags(_this.vertexTags()); + function presetCollection(collection) { + var MAXRESULTS = 50; + var _this = {}; + var _memo = {}; + _this.collection = collection; + + _this.item = function (id) { + if (_memo[id]) return _memo[id]; + + var found = _this.collection.find(function (d) { + return d.id === id; }); - }; // `merge` accepts an object containing new preset data (all properties optional): - // { - // fields: {}, - // presets: {}, - // categories: {}, - // defaults: {}, - // featureCollection: {} - //} + if (found) _memo[id] = found; + return found; + }; - _this.merge = function (d) { - var newLocationSets = []; // Merge Fields + _this.index = function (id) { + return _this.collection.findIndex(function (d) { + return d.id === id; + }); + }; - if (d.fields) { - Object.keys(d.fields).forEach(function (fieldID) { - var f = d.fields[fieldID]; + _this.matchGeometry = function (geometry) { + return presetCollection(_this.collection.filter(function (d) { + return d.matchGeometry(geometry); + })); + }; - if (f) { - // add or replace - f = presetField(fieldID, f); - if (f.locationSet) newLocationSets.push(f); - _fields[fieldID] = f; - } else { - // remove - delete _fields[fieldID]; - } + _this.matchAllGeometry = function (geometries) { + return presetCollection(_this.collection.filter(function (d) { + return d && d.matchAllGeometry(geometries); + })); + }; + + _this.matchAnyGeometry = function (geometries) { + return presetCollection(_this.collection.filter(function (d) { + return geometries.some(function (geom) { + return d.matchGeometry(geom); }); - } // Merge Presets + })); + }; + _this.fallback = function (geometry) { + var id = geometry; + if (id === 'vertex') id = 'point'; + return _this.item(id); + }; - if (d.presets) { - Object.keys(d.presets).forEach(function (presetID) { - var p = d.presets[presetID]; + _this.search = function (value, geometry, loc) { + if (!value) return _this; // don't remove diacritical characters since we're assuming the user is being intentional - if (p) { - // add or replace - var isAddable = !_addablePresetIDs || _addablePresetIDs.has(presetID); + value = value.toLowerCase().trim(); // match at name beginning or just after a space (e.g. "office" -> match "Law Office") - p = presetPreset(presetID, p, isAddable, _fields, _presets); - if (p.locationSet) newLocationSets.push(p); - _presets[presetID] = p; - } else { - // remove (but not if it's a fallback) - var existing = _presets[presetID]; + function leading(a) { + var index = a.indexOf(value); + return index === 0 || a[index - 1] === ' '; + } // match at name beginning only - if (existing && !existing.isFallback()) { - delete _presets[presetID]; - } - } - }); - } // Merge Categories + function leadingStrict(a) { + var index = a.indexOf(value); + return index === 0; + } - if (d.categories) { - Object.keys(d.categories).forEach(function (categoryID) { - var c = d.categories[categoryID]; + function sortPresets(nameProp) { + return function sortNames(a, b) { + var aCompare = a[nameProp](); + var bCompare = b[nameProp](); // priority if search string matches preset name exactly - #4325 - if (c) { - // add or replace - c = presetCategory(categoryID, c, _presets); - if (c.locationSet) newLocationSets.push(c); - _categories[categoryID] = c; - } else { - // remove - delete _categories[categoryID]; - } - }); - } // Rebuild _this.collection after changing presets and categories + if (value === aCompare) return -1; + if (value === bCompare) return 1; // priority for higher matchScore + var i = b.originalScore - a.originalScore; + if (i !== 0) return i; // priority if search string appears earlier in preset name - _this.collection = Object.values(_presets).concat(Object.values(_categories)); // Merge Defaults + i = aCompare.indexOf(value) - bCompare.indexOf(value); + if (i !== 0) return i; // priority for shorter preset names - if (d.defaults) { - Object.keys(d.defaults).forEach(function (geometry) { - var def = d.defaults[geometry]; + return aCompare.length - bCompare.length; + }; + } - if (Array.isArray(def)) { - // add or replace - _defaults[geometry] = presetCollection(def.map(function (id) { - return _presets[id] || _categories[id]; - }).filter(Boolean)); - } else { - // remove - delete _defaults[geometry]; - } - }); - } // Rebuild universal fields array + var pool = _this.collection; + if (Array.isArray(loc)) { + var validLocations = _mainLocations.locationsAt(loc); + pool = pool.filter(function (a) { + return !a.locationSetID || validLocations[a.locationSetID]; + }); + } - _universal = Object.values(_fields).filter(function (field) { - return field.universal; - }); // Reset all the preset fields - they'll need to be resolved again + var searchable = pool.filter(function (a) { + return a.searchable !== false && a.suggestion !== true; + }); + var suggestions = pool.filter(function (a) { + return a.suggestion === true; + }); // matches value to preset.name - Object.values(_presets).forEach(function (preset) { - return preset.resetFields(); - }); // Rebuild geometry index + var leadingNames = searchable.filter(function (a) { + return leading(a.searchName()); + }).sort(sortPresets('searchName')); // matches value to preset suggestion name - _geometryIndex = { - point: {}, - vertex: {}, - line: {}, - area: {}, - relation: {} - }; + var leadingSuggestions = suggestions.filter(function (a) { + return leadingStrict(a.searchName()); + }).sort(sortPresets('searchName')); + var leadingNamesStripped = searchable.filter(function (a) { + return leading(a.searchNameStripped()); + }).sort(sortPresets('searchNameStripped')); + var leadingSuggestionsStripped = suggestions.filter(function (a) { + return leadingStrict(a.searchNameStripped()); + }).sort(sortPresets('searchNameStripped')); // matches value to preset.terms values - _this.collection.forEach(function (preset) { - (preset.geometry || []).forEach(function (geometry) { - var g = _geometryIndex[geometry]; + var leadingTerms = searchable.filter(function (a) { + return (a.terms() || []).some(leading); + }); + var leadingSuggestionTerms = suggestions.filter(function (a) { + return (a.terms() || []).some(leading); + }); // matches value to preset.tags values - for (var key in preset.tags) { - (g[key] = g[key] || []).push(preset); - } - }); - }); // Merge Custom Features + var leadingTagValues = searchable.filter(function (a) { + return Object.values(a.tags || {}).filter(function (val) { + return val !== '*'; + }).some(leading); + }); // finds close matches to value in preset.name + var similarName = searchable.map(function (a) { + return { + preset: a, + dist: utilEditDistance(value, a.searchName()) + }; + }).filter(function (a) { + return a.dist + Math.min(value.length - a.preset.searchName().length, 0) < 3; + }).sort(function (a, b) { + return a.dist - b.dist; + }).map(function (a) { + return a.preset; + }); // finds close matches to value to preset suggestion name - if (d.featureCollection && Array.isArray(d.featureCollection.features)) { - _mainLocations.mergeCustomGeoJSON(d.featureCollection); - } // Resolve all locationSet features. + var similarSuggestions = suggestions.map(function (a) { + return { + preset: a, + dist: utilEditDistance(value, a.searchName()) + }; + }).filter(function (a) { + return a.dist + Math.min(value.length - a.preset.searchName().length, 0) < 1; + }).sort(function (a, b) { + return a.dist - b.dist; + }).map(function (a) { + return a.preset; + }); // finds close matches to value in preset.terms + var similarTerms = searchable.filter(function (a) { + return (a.terms() || []).some(function (b) { + return utilEditDistance(value, b) + Math.min(value.length - b.length, 0) < 3; + }); + }); + var results = leadingNames.concat(leadingSuggestions, leadingNamesStripped, leadingSuggestionsStripped, leadingTerms, leadingSuggestionTerms, leadingTagValues, similarName, similarSuggestions, similarTerms).slice(0, MAXRESULTS - 1); - if (newLocationSets.length) { - _mainLocations.mergeLocationSets(newLocationSets); + if (geometry) { + if (typeof geometry === 'string') { + results.push(_this.fallback(geometry)); + } else { + geometry.forEach(function (geom) { + return results.push(_this.fallback(geom)); + }); + } } - return _this; + return presetCollection(utilArrayUniq(results)); }; - _this.match = function (entity, resolver) { - return resolver["transient"](entity, 'presetMatch', function () { - var geometry = entity.geometry(resolver); // Treat entities on addr:interpolation lines as points, not vertices - #3241 - - if (geometry === 'vertex' && entity.isOnAddressLine(resolver)) { - geometry = 'point'; - } + return _this; + } - var entityExtent = entity.extent(resolver); - return _this.matchTags(entity.tags, geometry, entityExtent.center()); - }); - }; + // `presetCategory` builds a `presetCollection` of member presets, + // decorated with some extra methods for searching and matching geometry + // - _this.matchTags = function (tags, geometry, loc) { - var geometryMatches = _geometryIndex[geometry]; - var address; - var best = -1; - var match; - var validLocations; + function presetCategory(categoryID, category, allPresets) { + var _this = Object.assign({}, category); // shallow copy - if (Array.isArray(loc)) { - validLocations = _mainLocations.locationsAt(loc); - } - for (var k in tags) { - // If any part of an address is present, allow fallback to "Address" preset - #4353 - if (/^addr:/.test(k) && geometryMatches['addr:*']) { - address = geometryMatches['addr:*'][0]; - } + var _searchName; // cache - var keyMatches = geometryMatches[k]; - if (!keyMatches) continue; - for (var i = 0; i < keyMatches.length; i++) { - var candidate = keyMatches[i]; // discard candidate preset if location is not valid at `loc` + var _searchNameStripped; // cache - if (validLocations && candidate.locationSetID) { - if (!validLocations[candidate.locationSetID]) continue; - } - var score = candidate.matchScore(tags); + _this.id = categoryID; + _this.members = presetCollection((category.members || []).map(function (presetID) { + return allPresets[presetID]; + }).filter(Boolean)); + _this.geometry = _this.members.collection.reduce(function (acc, preset) { + for (var i in preset.geometry) { + var geometry = preset.geometry[i]; - if (score > best) { - best = score; - match = candidate; - } + if (acc.indexOf(geometry) === -1) { + acc.push(geometry); } } - if (address && (!match || match.isFallback())) { - match = address; - } + return acc; + }, []); - return match || _this.fallback(geometry); + _this.matchGeometry = function (geom) { + return _this.geometry.indexOf(geom) >= 0; }; - _this.allowsVertex = function (entity, resolver) { - if (entity.type !== 'node') return false; - if (Object.keys(entity.tags).length === 0) return true; - return resolver["transient"](entity, 'vertexMatch', function () { - // address lines allow vertices to act as standalone points - if (entity.isOnAddressLine(resolver)) return true; - var geometries = osmNodeGeometriesForTags(entity.tags); - if (geometries.vertex) return true; - if (geometries.point) return false; // allow vertices for unspecified points - - return true; + _this.matchAllGeometry = function (geometries) { + return _this.members.collection.some(function (preset) { + return preset.matchAllGeometry(geometries); }); - }; // Because of the open nature of tagging, iD will never have a complete - // list of tags used in OSM, so we want it to have logic like "assume - // that a closed way with an amenity tag is an area, unless the amenity - // is one of these specific types". This function computes a structure - // that allows testing of such conditions, based on the presets designated - // as as supporting (or not supporting) the area geometry. - // - // The returned object L is a keeplist/discardlist of tags. A closed way - // with a tag (k, v) is considered to be an area if `k in L && !(v in L[k])` - // (see `Way#isArea()`). In other words, the keys of L form the keeplist, - // and the subkeys form the discardlist. + }; + _this.matchScore = function () { + return -1; + }; - _this.areaKeys = function () { - // The ignore list is for keys that imply lines. (We always add `area=yes` for exceptions) - var ignore = ['barrier', 'highway', 'footway', 'railway', 'junction', 'type']; - var areaKeys = {}; // ignore name-suggestion-index and deprecated presets + _this.name = function () { + return _t("_tagging.presets.categories.".concat(categoryID, ".name"), { + 'default': categoryID + }); + }; - var presets = _this.collection.filter(function (p) { - return !p.suggestion && !p.replacement; - }); // keeplist + _this.nameLabel = function () { + return _t.html("_tagging.presets.categories.".concat(categoryID, ".name"), { + 'default': categoryID + }); + }; + _this.terms = function () { + return []; + }; - presets.forEach(function (p) { - var keys = p.tags && Object.keys(p.tags); - var key = keys && keys.length && keys[0]; // pick the first tag + _this.searchName = function () { + if (!_searchName) { + _searchName = (_this.suggestion ? _this.originalName : _this.name()).toLowerCase(); + } - if (!key) return; - if (ignore.indexOf(key) !== -1) return; + return _searchName; + }; - if (p.geometry.indexOf('area') !== -1) { - // probably an area.. - areaKeys[key] = areaKeys[key] || {}; - } - }); // discardlist + _this.searchNameStripped = function () { + if (!_searchNameStripped) { + _searchNameStripped = _this.searchName(); // split combined diacritical characters into their parts - presets.forEach(function (p) { - var key; + if (_searchNameStripped.normalize) _searchNameStripped = _searchNameStripped.normalize('NFD'); // remove diacritics - for (key in p.addTags) { - // examine all addTags to get a better sense of what can be tagged on lines - #6800 - var value = p.addTags[key]; + _searchNameStripped = _searchNameStripped.replace(/[\u0300-\u036f]/g, ''); + } - if (key in areaKeys && // probably an area... - p.geometry.indexOf('line') !== -1 && // but sometimes a line - value !== '*') { - areaKeys[key][value] = true; - } - } - }); - return areaKeys; + return _searchNameStripped; }; - _this.pointTags = function () { - return _this.collection.reduce(function (pointTags, d) { - // ignore name-suggestion-index, deprecated, and generic presets - if (d.suggestion || d.replacement || d.searchable === false) return pointTags; // only care about the primary tag + return _this; + } - var keys = d.tags && Object.keys(d.tags); - var key = keys && keys.length && keys[0]; // pick the first tag + // `presetField` decorates a given `field` Object + // with some extra methods for searching and matching geometry + // - if (!key) return pointTags; // if this can be a point + function presetField(fieldID, field) { + var _this = Object.assign({}, field); // shallow copy - if (d.geometry.indexOf('point') !== -1) { - pointTags[key] = pointTags[key] || {}; - pointTags[key][d.tags[key]] = true; - } - return pointTags; - }, {}); - }; + _this.id = fieldID; // for use in classes, element ids, css selectors - _this.vertexTags = function () { - return _this.collection.reduce(function (vertexTags, d) { - // ignore name-suggestion-index, deprecated, and generic presets - if (d.suggestion || d.replacement || d.searchable === false) return vertexTags; // only care about the primary tag + _this.safeid = utilSafeClassName(fieldID); - var keys = d.tags && Object.keys(d.tags); - var key = keys && keys.length && keys[0]; // pick the first tag + _this.matchGeometry = function (geom) { + return !_this.geometry || _this.geometry.indexOf(geom) !== -1; + }; - if (!key) return vertexTags; // if this can be a vertex + _this.matchAllGeometry = function (geometries) { + return !_this.geometry || geometries.every(function (geom) { + return _this.geometry.indexOf(geom) !== -1; + }); + }; - if (d.geometry.indexOf('vertex') !== -1) { - vertexTags[key] = vertexTags[key] || {}; - vertexTags[key][d.tags[key]] = true; - } + _this.t = function (scope, options) { + return _t("_tagging.presets.fields.".concat(fieldID, ".").concat(scope), options); + }; - return vertexTags; - }, {}); + _this.t.html = function (scope, options) { + return _t.html("_tagging.presets.fields.".concat(fieldID, ".").concat(scope), options); }; - _this.field = function (id) { - return _fields[id]; + _this.hasTextForStringId = function (scope) { + return _mainLocalizer.hasTextForStringId("_tagging.presets.fields.".concat(fieldID, ".").concat(scope)); }; - _this.universal = function () { - return _universal; + _this.title = function () { + return _this.overrideLabel || _this.t('label', { + 'default': fieldID + }); }; - _this.defaults = function (geometry, n, startWithRecents, loc) { - var recents = []; + _this.label = function () { + return _this.overrideLabel || _this.t.html('label', { + 'default': fieldID + }); + }; - if (startWithRecents) { - recents = _this.recent().matchGeometry(geometry).collection.slice(0, 4); - } + var _placeholder = _this.placeholder; - var defaults; + _this.placeholder = function () { + return _this.t('placeholder', { + 'default': _placeholder + }); + }; - if (_addablePresetIDs) { - defaults = Array.from(_addablePresetIDs).map(function (id) { - var preset = _this.item(id); + _this.originalTerms = (_this.terms || []).join(); - if (preset && preset.matchGeometry(geometry)) return preset; - return null; - }).filter(Boolean); - } else { - defaults = _defaults[geometry].collection.concat(_this.fallback(geometry)); - } + _this.terms = function () { + return _this.t('terms', { + 'default': _this.originalTerms + }).toLowerCase().trim().split(/\s*,+\s*/); + }; - var result = presetCollection(utilArrayUniq(recents.concat(defaults)).slice(0, n - 1)); + _this.increment = _this.type === 'number' ? _this.increment || 1 : undefined; + return _this; + } - if (Array.isArray(loc)) { - var validLocations = _mainLocations.locationsAt(loc); - result.collection = result.collection.filter(function (a) { - return !a.locationSetID || validLocations[a.locationSetID]; - }); - } + // `presetPreset` decorates a given `preset` Object + // with some extra methods for searching and matching geometry + // - return result; - }; // pass a Set of addable preset ids + function presetPreset(presetID, preset, addable, allFields, allPresets) { + allFields = allFields || {}; + allPresets = allPresets || {}; + var _this = Object.assign({}, preset); // shallow copy - _this.addablePresetIDs = function (val) { - if (!arguments.length) return _addablePresetIDs; // accept and convert arrays - if (Array.isArray(val)) val = new Set(val); - _addablePresetIDs = val; + var _addable = addable || false; - if (_addablePresetIDs) { - // reset all presets - _this.collection.forEach(function (p) { - // categories aren't addable - if (p.addable) p.addable(_addablePresetIDs.has(p.id)); - }); - } else { - _this.collection.forEach(function (p) { - if (p.addable) p.addable(true); - }); - } + var _resolvedFields; // cache - return _this; - }; - _this.recent = function () { - return presetCollection(utilArrayUniq(_this.getRecents().map(function (d) { - return d.preset; - }))); - }; + var _resolvedMoreFields; // cache - function RibbonItem(preset, source) { - var item = {}; - item.preset = preset; - item.source = source; - item.isFavorite = function () { - return item.source === 'favorite'; - }; - - item.isRecent = function () { - return item.source === 'recent'; - }; - - item.matches = function (preset) { - return item.preset.id === preset.id; - }; + var _searchName; // cache - item.minified = function () { - return { - pID: item.preset.id - }; - }; - return item; - } + var _searchNameStripped; // cache - function ribbonItemForMinified(d, source) { - if (d && d.pID) { - var preset = _this.item(d.pID); - if (!preset) return null; - return RibbonItem(preset, source); - } + _this.id = presetID; + _this.safeid = utilSafeClassName(presetID); // for use in css classes, selectors, element ids - return null; - } + _this.originalTerms = (_this.terms || []).join(); + _this.originalName = _this.name || ''; + _this.originalScore = _this.matchScore || 1; + _this.originalReference = _this.reference || {}; + _this.originalFields = _this.fields || []; + _this.originalMoreFields = _this.moreFields || []; - _this.getGenericRibbonItems = function () { - return ['point', 'line', 'area'].map(function (id) { - return RibbonItem(_this.item(id), 'generic'); - }); + _this.fields = function () { + return _resolvedFields || (_resolvedFields = resolve('fields')); }; - _this.getAddable = function () { - if (!_addablePresetIDs) return []; - return _addablePresetIDs.map(function (id) { - var preset = _this.item(id); - - if (preset) return RibbonItem(preset, 'addable'); - return null; - }).filter(Boolean); + _this.moreFields = function () { + return _resolvedMoreFields || (_resolvedMoreFields = resolve('moreFields')); }; - function setRecents(items) { - _recents = items; - var minifiedItems = items.map(function (d) { - return d.minified(); - }); - corePreferences('preset_recents', JSON.stringify(minifiedItems)); - dispatch.call('recentsChange'); - } - - _this.getRecents = function () { - if (!_recents) { - // fetch from local storage - _recents = (JSON.parse(corePreferences('preset_recents')) || []).reduce(function (acc, d) { - var item = ribbonItemForMinified(d, 'recent'); - if (item && item.preset.addable()) acc.push(item); - return acc; - }, []); - } - - return _recents; + _this.resetFields = function () { + return _resolvedFields = _resolvedMoreFields = null; }; - _this.addRecent = function (preset, besidePreset, after) { - var recents = _this.getRecents(); + _this.tags = _this.tags || {}; + _this.addTags = _this.addTags || _this.tags; + _this.removeTags = _this.removeTags || _this.addTags; + _this.geometry = _this.geometry || []; - var beforeItem = _this.recentMatching(besidePreset); + _this.matchGeometry = function (geom) { + return _this.geometry.indexOf(geom) >= 0; + }; - var toIndex = recents.indexOf(beforeItem); - if (after) toIndex += 1; - var newItem = RibbonItem(preset, 'recent'); - recents.splice(toIndex, 0, newItem); - setRecents(recents); + _this.matchAllGeometry = function (geoms) { + return geoms.every(_this.matchGeometry); }; - _this.removeRecent = function (preset) { - var item = _this.recentMatching(preset); + _this.matchScore = function (entityTags) { + var tags = _this.tags; + var seen = {}; + var score = 0; // match on tags - if (item) { - var items = _this.getRecents(); + for (var k in tags) { + seen[k] = true; - items.splice(items.indexOf(item), 1); - setRecents(items); - } - }; + if (entityTags[k] === tags[k]) { + score += _this.originalScore; + } else if (tags[k] === '*' && k in entityTags) { + score += _this.originalScore / 2; + } else { + return -1; + } + } // boost score for additional matches in addTags - #6802 - _this.recentMatching = function (preset) { - var items = _this.getRecents(); - for (var i in items) { - if (items[i].matches(preset)) { - return items[i]; + var addTags = _this.addTags; + + for (var _k in addTags) { + if (!seen[_k] && entityTags[_k] === addTags[_k]) { + score += _this.originalScore; } } - return null; + return score; }; - _this.moveItem = function (items, fromIndex, toIndex) { - if (fromIndex === toIndex || fromIndex < 0 || toIndex < 0 || fromIndex >= items.length || toIndex >= items.length) return null; - items.splice(toIndex, 0, items.splice(fromIndex, 1)[0]); - return items; + _this.t = function (scope, options) { + var textID = "_tagging.presets.presets.".concat(presetID, ".").concat(scope); + return _t(textID, options); }; - _this.moveRecent = function (item, beforeItem) { - var recents = _this.getRecents(); - - var fromIndex = recents.indexOf(item); - var toIndex = recents.indexOf(beforeItem); - - var items = _this.moveItem(recents, fromIndex, toIndex); - - if (items) setRecents(items); + _this.t.html = function (scope, options) { + var textID = "_tagging.presets.presets.".concat(presetID, ".").concat(scope); + return _t.html(textID, options); }; - _this.setMostRecent = function (preset) { - if (preset.searchable === false) return; - - var items = _this.getRecents(); - - var item = _this.recentMatching(preset); - - if (item) { - items.splice(items.indexOf(item), 1); - } else { - item = RibbonItem(preset, 'recent'); - } // remove the last recent (first in, first out) + _this.name = function () { + return _this.t('name', { + 'default': _this.originalName + }); + }; + _this.nameLabel = function () { + return _this.t.html('name', { + 'default': _this.originalName + }); + }; - while (items.length >= MAXRECENTS) { - items.pop(); - } // prepend array + _this.subtitle = function () { + if (_this.suggestion) { + var path = presetID.split('/'); + path.pop(); // remove brand name + return _t('_tagging.presets.presets.' + path.join('/') + '.name'); + } - items.unshift(item); - setRecents(items); + return null; }; - function setFavorites(items) { - _favorites = items; - var minifiedItems = items.map(function (d) { - return d.minified(); - }); - corePreferences('preset_favorites', JSON.stringify(minifiedItems)); // call update - - dispatch.call('favoritePreset'); - } + _this.subtitleLabel = function () { + if (_this.suggestion) { + var path = presetID.split('/'); + path.pop(); // remove brand name - _this.addFavorite = function (preset, besidePreset, after) { - var favorites = _this.getFavorites(); + return _t.html('_tagging.presets.presets.' + path.join('/') + '.name'); + } - var beforeItem = _this.favoriteMatching(besidePreset); + return null; + }; - var toIndex = favorites.indexOf(beforeItem); - if (after) toIndex += 1; - var newItem = RibbonItem(preset, 'favorite'); - favorites.splice(toIndex, 0, newItem); - setFavorites(favorites); + _this.terms = function () { + return _this.t('terms', { + 'default': _this.originalTerms + }).toLowerCase().trim().split(/\s*,+\s*/); }; - _this.toggleFavorite = function (preset) { - var favs = _this.getFavorites(); + _this.searchName = function () { + if (!_searchName) { + _searchName = (_this.suggestion ? _this.originalName : _this.name()).toLowerCase(); + } - var favorite = _this.favoriteMatching(preset); + return _searchName; + }; - if (favorite) { - favs.splice(favs.indexOf(favorite), 1); - } else { - // only allow 10 favorites - if (favs.length === 10) { - // remove the last favorite (last in, first out) - favs.pop(); - } // append array + _this.searchNameStripped = function () { + if (!_searchNameStripped) { + _searchNameStripped = _this.searchName(); // split combined diacritical characters into their parts + if (_searchNameStripped.normalize) _searchNameStripped = _searchNameStripped.normalize('NFD'); // remove diacritics - favs.push(RibbonItem(preset, 'favorite')); + _searchNameStripped = _searchNameStripped.replace(/[\u0300-\u036f]/g, ''); } - setFavorites(favs); + return _searchNameStripped; }; - _this.removeFavorite = function (preset) { - var item = _this.favoriteMatching(preset); - - if (item) { - var items = _this.getFavorites(); + _this.isFallback = function () { + var tagCount = Object.keys(_this.tags).length; + return tagCount === 0 || tagCount === 1 && _this.tags.hasOwnProperty('area'); + }; - items.splice(items.indexOf(item), 1); - setFavorites(items); - } + _this.addable = function (val) { + if (!arguments.length) return _addable; + _addable = val; + return _this; }; - _this.getFavorites = function () { - if (!_favorites) { - // fetch from local storage - var rawFavorites = JSON.parse(corePreferences('preset_favorites')); + _this.reference = function () { + // Lookup documentation on Wikidata... + var qid = _this.tags.wikidata || _this.tags['flag:wikidata'] || _this.tags['brand:wikidata'] || _this.tags['network:wikidata'] || _this.tags['operator:wikidata']; - if (!rawFavorites) { - rawFavorites = []; - corePreferences('preset_favorites', JSON.stringify(rawFavorites)); - } + if (qid) { + return { + qid: qid + }; + } // Lookup documentation on OSM Wikibase... - _favorites = rawFavorites.reduce(function (output, d) { - var item = ribbonItemForMinified(d, 'favorite'); - if (item && item.preset.addable()) output.push(item); - return output; - }, []); - } - return _favorites; + var key = _this.originalReference.key || Object.keys(utilObjectOmit(_this.tags, 'name'))[0]; + var value = _this.originalReference.value || _this.tags[key]; + + if (value === '*') { + return { + key: key + }; + } else { + return { + key: key, + value: value + }; + } }; - _this.favoriteMatching = function (preset) { - var favs = _this.getFavorites(); + _this.unsetTags = function (tags, geometry, ignoringKeys, skipFieldDefaults) { + // allow manually keeping some tags + var removeTags = ignoringKeys ? utilObjectOmit(_this.removeTags, ignoringKeys) : _this.removeTags; + tags = utilObjectOmit(tags, Object.keys(removeTags)); - for (var index in favs) { - if (favs[index].matches(preset)) { - return favs[index]; - } + if (geometry && !skipFieldDefaults) { + _this.fields().forEach(function (field) { + if (field.matchGeometry(geometry) && field.key && field["default"] === tags[field.key]) { + delete tags[field.key]; + } + }); } - return null; + delete tags.area; + return tags; }; - return utilRebind(_this, dispatch, 'on'); - } + _this.setTags = function (tags, geometry, skipFieldDefaults) { + var addTags = _this.addTags; + tags = Object.assign({}, tags); // shallow copy - function utilTagText(entity) { - var obj = entity && entity.tags || {}; - return Object.keys(obj).map(function (k) { - return k + '=' + obj[k]; - }).join(', '); - } - function utilTotalExtent(array, graph) { - var extent = geoExtent(); - var val, entity; + for (var k in addTags) { + if (addTags[k] === '*') { + // if this tag is ancillary, don't override an existing value since any value is okay + if (_this.tags[k] || !tags[k] || tags[k] === 'no') { + tags[k] = 'yes'; + } + } else { + tags[k] = addTags[k]; + } + } // Add area=yes if necessary. + // This is necessary if the geometry is already an area (e.g. user drew an area) AND any of: + // 1. chosen preset could be either an area or a line (`barrier=city_wall`) + // 2. chosen preset doesn't have a key in osmAreaKeys (`railway=station`) - for (var i = 0; i < array.length; i++) { - val = array[i]; - entity = typeof val === 'string' ? graph.hasEntity(val) : val; - if (entity) { - extent._extend(entity.extent(graph)); - } - } + if (!addTags.hasOwnProperty('area')) { + delete tags.area; - return extent; - } - function utilTagDiff(oldTags, newTags) { - var tagDiff = []; - var keys = utilArrayUnion(Object.keys(oldTags), Object.keys(newTags)).sort(); - keys.forEach(function (k) { - var oldVal = oldTags[k]; - var newVal = newTags[k]; + if (geometry === 'area') { + var needsAreaTag = true; - if ((oldVal || oldVal === '') && (newVal === undefined || newVal !== oldVal)) { - tagDiff.push({ - type: '-', - key: k, - oldVal: oldVal, - newVal: newVal, - display: '- ' + k + '=' + oldVal - }); + if (_this.geometry.indexOf('line') === -1) { + for (var _k2 in addTags) { + if (_k2 in osmAreaKeys) { + needsAreaTag = false; + break; + } + } + } + + if (needsAreaTag) { + tags.area = 'yes'; + } + } } - if ((newVal || newVal === '') && (oldVal === undefined || newVal !== oldVal)) { - tagDiff.push({ - type: '+', - key: k, - oldVal: oldVal, - newVal: newVal, - display: '+ ' + k + '=' + newVal + if (geometry && !skipFieldDefaults) { + _this.fields().forEach(function (field) { + if (field.matchGeometry(geometry) && field.key && !tags[field.key] && field["default"]) { + tags[field.key] = field["default"]; + } }); } - }); - return tagDiff; - } - function utilEntitySelector(ids) { - return ids.length ? '.' + ids.join(',.') : 'nothing'; - } // returns an selector to select entity ids for: - // - entityIDs passed in - // - shallow descendant entityIDs for any of those entities that are relations - - function utilEntityOrMemberSelector(ids, graph) { - var seen = new Set(ids); - ids.forEach(collectShallowDescendants); - return utilEntitySelector(Array.from(seen)); - function collectShallowDescendants(id) { - var entity = graph.hasEntity(id); - if (!entity || entity.type !== 'relation') return; - entity.members.map(function (member) { - return member.id; - }).forEach(function (id) { - seen.add(id); - }); - } - } // returns an selector to select entity ids for: - // - entityIDs passed in - // - deep descendant entityIDs for any of those entities that are relations + return tags; + }; // For a preset without fields, use the fields of the parent preset. + // Replace {preset} placeholders with the fields of the specified presets. - function utilEntityOrDeepMemberSelector(ids, graph) { - return utilEntitySelector(utilEntityAndDeepMemberIDs(ids, graph)); - } // returns an selector to select entity ids for: - // - entityIDs passed in - // - deep descendant entityIDs for any of those entities that are relations - function utilEntityAndDeepMemberIDs(ids, graph) { - var seen = new Set(); - ids.forEach(collectDeepDescendants); - return Array.from(seen); + function resolve(which) { + var fieldIDs = which === 'fields' ? _this.originalFields : _this.originalMoreFields; + var resolved = []; + fieldIDs.forEach(function (fieldID) { + var match = fieldID.match(/\{(.*)\}/); - function collectDeepDescendants(id) { - if (seen.has(id)) return; - seen.add(id); - var entity = graph.hasEntity(id); - if (!entity || entity.type !== 'relation') return; - entity.members.map(function (member) { - return member.id; - }).forEach(collectDeepDescendants); // recurse - } - } // returns an selector to select entity ids for: - // - deep descendant entityIDs for any of those entities that are relations + if (match !== null) { + // a presetID wrapped in braces {} + resolved = resolved.concat(inheritFields(match[1], which)); + } else if (allFields[fieldID]) { + // a normal fieldID + resolved.push(allFields[fieldID]); + } else { + console.log("Cannot resolve \"".concat(fieldID, "\" found in ").concat(_this.id, ".").concat(which)); // eslint-disable-line no-console + } + }); // no fields resolved, so use the parent's if possible - function utilDeepMemberSelector(ids, graph, skipMultipolgonMembers) { - var idsSet = new Set(ids); - var seen = new Set(); - var returners = new Set(); - ids.forEach(collectDeepDescendants); - return utilEntitySelector(Array.from(returners)); + if (!resolved.length) { + var endIndex = _this.id.lastIndexOf('/'); - function collectDeepDescendants(id) { - if (seen.has(id)) return; - seen.add(id); + var parentID = endIndex && _this.id.substring(0, endIndex); - if (!idsSet.has(id)) { - returners.add(id); + if (parentID) { + resolved = inheritFields(parentID, which); + } } - var entity = graph.hasEntity(id); - if (!entity || entity.type !== 'relation') return; - if (skipMultipolgonMembers && entity.isMultipolygon()) return; - entity.members.map(function (member) { - return member.id; - }).forEach(collectDeepDescendants); // recurse - } - } // Adds or removes highlight styling for the specified entities + return utilArrayUniq(resolved); // returns an array of fields to inherit from the given presetID, if found - function utilHighlightEntities(ids, highlighted, context) { - context.surface().selectAll(utilEntityOrDeepMemberSelector(ids, context.graph())).classed('highlighted', highlighted); - } // returns an Array that is the union of: - // - nodes for any nodeIDs passed in - // - child nodes of any wayIDs passed in - // - descendant member and child nodes of relationIDs passed in + function inheritFields(presetID, which) { + var parent = allPresets[presetID]; + if (!parent) return []; - function utilGetAllNodes(ids, graph) { - var seen = new Set(); - var nodes = new Set(); - ids.forEach(collectNodes); - return Array.from(nodes); + if (which === 'fields') { + return parent.fields().filter(shouldInherit); + } else if (which === 'moreFields') { + return parent.moreFields(); + } else { + return []; + } + } // Skip `fields` for the keys which define the preset. + // These are usually `typeCombo` fields like `shop=*` - function collectNodes(id) { - if (seen.has(id)) return; - seen.add(id); - var entity = graph.hasEntity(id); - if (!entity) return; - if (entity.type === 'node') { - nodes.add(entity); - } else if (entity.type === 'way') { - entity.nodes.forEach(collectNodes); - } else { - entity.members.map(function (member) { - return member.id; - }).forEach(collectNodes); // recurse + function shouldInherit(f) { + if (f.key && _this.tags[f.key] !== undefined && // inherit anyway if multiple values are allowed or just a checkbox + f.type !== 'multiCombo' && f.type !== 'semiCombo' && f.type !== 'manyCombo' && f.type !== 'check') return false; + return true; } } + + return _this; } - function utilDisplayName(entity) { - var localizedNameKey = 'name:' + _mainLocalizer.languageCode().toLowerCase(); - var name = entity.tags[localizedNameKey] || entity.tags.name || ''; - if (name) return name; - var tags = { - direction: entity.tags.direction, - from: entity.tags.from, - network: entity.tags.cycle_network || entity.tags.network, - ref: entity.tags.ref, - to: entity.tags.to, - via: entity.tags.via - }; - var keyComponents = []; - if (tags.network) { - keyComponents.push('network'); - } + var _mainPresetIndex = presetIndex(); // singleton + // `presetIndex` wraps a `presetCollection` + // with methods for loading new data and returning defaults + // - if (tags.ref) { - keyComponents.push('ref'); - } // Routes may need more disambiguation based on direction or destination + function presetIndex() { + var dispatch = dispatch$8('favoritePreset', 'recentsChange'); + var MAXRECENTS = 30; // seed the preset lists with geometry fallbacks + var POINT = presetPreset('point', { + name: 'Point', + tags: {}, + geometry: ['point', 'vertex'], + matchScore: 0.1 + }); + var LINE = presetPreset('line', { + name: 'Line', + tags: {}, + geometry: ['line'], + matchScore: 0.1 + }); + var AREA = presetPreset('area', { + name: 'Area', + tags: { + area: 'yes' + }, + geometry: ['area'], + matchScore: 0.1 + }); + var RELATION = presetPreset('relation', { + name: 'Relation', + tags: {}, + geometry: ['relation'], + matchScore: 0.1 + }); - if (entity.tags.route) { - if (tags.direction) { - keyComponents.push('direction'); - } else if (tags.from && tags.to) { - keyComponents.push('from'); - keyComponents.push('to'); + var _this = presetCollection([POINT, LINE, AREA, RELATION]); - if (tags.via) { - keyComponents.push('via'); - } - } - } + var _presets = { + point: POINT, + line: LINE, + area: AREA, + relation: RELATION + }; + var _defaults = { + point: presetCollection([POINT]), + vertex: presetCollection([POINT]), + line: presetCollection([LINE]), + area: presetCollection([AREA]), + relation: presetCollection([RELATION]) + }; + var _fields = {}; + var _categories = {}; + var _universal = []; + var _addablePresetIDs = null; // Set of preset IDs that the user can add - if (keyComponents.length) { - name = _t('inspector.display_name.' + keyComponents.join('_'), tags); - } + var _recents; - return name; - } - function utilDisplayNameForPath(entity) { - var name = utilDisplayName(entity); - var isFirefox = utilDetect().browser.toLowerCase().indexOf('firefox') > -1; + var _favorites; // Index of presets by (geometry, tag key). - if (!isFirefox && name && rtlRegex.test(name)) { - name = fixRTLTextForSvg(name); - } - return name; - } - function utilDisplayType(id) { - return { - n: _t('inspector.node'), - w: _t('inspector.way'), - r: _t('inspector.relation') - }[id.charAt(0)]; - } // `utilDisplayLabel` - // Returns a string suitable for display - // By default returns something like name/ref, fallback to preset type, fallback to OSM type - // "Main Street" or "Tertiary Road" - // If `verbose=true`, include both preset name and feature name. - // "Tertiary Road Main Street" - // + var _geometryIndex = { + point: {}, + vertex: {}, + line: {}, + area: {}, + relation: {} + }; - function utilDisplayLabel(entity, graphOrGeometry, verbose) { - var result; - var displayName = utilDisplayName(entity); - var preset = typeof graphOrGeometry === 'string' ? _mainPresetIndex.matchTags(entity.tags, graphOrGeometry) : _mainPresetIndex.match(entity, graphOrGeometry); - var presetName = preset && (preset.suggestion ? preset.subtitle() : preset.name()); + var _loadPromise; - if (verbose) { - result = [presetName, displayName].filter(Boolean).join(' '); - } else { - result = displayName || presetName; - } // Fallback to the OSM type (node/way/relation) + _this.ensureLoaded = function () { + if (_loadPromise) return _loadPromise; + return _loadPromise = Promise.all([_mainFileFetcher.get('preset_categories'), _mainFileFetcher.get('preset_defaults'), _mainFileFetcher.get('preset_presets'), _mainFileFetcher.get('preset_fields')]).then(function (vals) { + _this.merge({ + categories: vals[0], + defaults: vals[1], + presets: vals[2], + fields: vals[3] + }); + osmSetAreaKeys(_this.areaKeys()); + osmSetPointTags(_this.pointTags()); + osmSetVertexTags(_this.vertexTags()); + }); + }; // `merge` accepts an object containing new preset data (all properties optional): + // { + // fields: {}, + // presets: {}, + // categories: {}, + // defaults: {}, + // featureCollection: {} + //} - return result || utilDisplayType(entity.id); - } - function utilEntityRoot(entityType) { - return { - node: 'n', - way: 'w', - relation: 'r' - }[entityType]; - } // Returns a single object containing the tags of all the given entities. - // Example: - // { - // highway: 'service', - // service: 'parking_aisle' - // } - // + - // { - // highway: 'service', - // service: 'driveway', - // width: '3' - // } - // = - // { - // highway: 'service', - // service: [ 'driveway', 'parking_aisle' ], - // width: [ '3', undefined ] - // } - function utilCombinedTags(entityIDs, graph) { - var tags = {}; - var tagCounts = {}; - var allKeys = new Set(); - var entities = entityIDs.map(function (entityID) { - return graph.hasEntity(entityID); - }).filter(Boolean); // gather the aggregate keys + _this.merge = function (d) { + var newLocationSets = []; // Merge Fields - entities.forEach(function (entity) { - var keys = Object.keys(entity.tags).filter(Boolean); - keys.forEach(function (key) { - allKeys.add(key); - }); - }); - entities.forEach(function (entity) { - allKeys.forEach(function (key) { - var value = entity.tags[key]; // purposely allow `undefined` + if (d.fields) { + Object.keys(d.fields).forEach(function (fieldID) { + var f = d.fields[fieldID]; - if (!tags.hasOwnProperty(key)) { - // first value, set as raw - tags[key] = value; - } else { - if (!Array.isArray(tags[key])) { - if (tags[key] !== value) { - // first alternate value, replace single value with array - tags[key] = [tags[key], value]; - } + if (f) { + // add or replace + f = presetField(fieldID, f); + if (f.locationSet) newLocationSets.push(f); + _fields[fieldID] = f; } else { - // type is array - if (tags[key].indexOf(value) === -1) { - // subsequent alternate value, add to array - tags[key].push(value); - } + // remove + delete _fields[fieldID]; } - } + }); + } // Merge Presets - var tagHash = key + '=' + value; - if (!tagCounts[tagHash]) tagCounts[tagHash] = 0; - tagCounts[tagHash] += 1; - }); - }); - for (var key in tags) { - if (!Array.isArray(tags[key])) continue; // sort values by frequency then alphabetically + if (d.presets) { + Object.keys(d.presets).forEach(function (presetID) { + var p = d.presets[presetID]; - tags[key] = tags[key].sort(function (val1, val2) { - var key = key; // capture + if (p) { + // add or replace + var isAddable = !_addablePresetIDs || _addablePresetIDs.has(presetID); - var count2 = tagCounts[key + '=' + val2]; - var count1 = tagCounts[key + '=' + val1]; + p = presetPreset(presetID, p, isAddable, _fields, _presets); + if (p.locationSet) newLocationSets.push(p); + _presets[presetID] = p; + } else { + // remove (but not if it's a fallback) + var existing = _presets[presetID]; - if (count2 !== count1) { - return count2 - count1; - } + if (existing && !existing.isFallback()) { + delete _presets[presetID]; + } + } + }); + } // Merge Categories - if (val2 && val1) { - return val1.localeCompare(val2); - } - return val1 ? 1 : -1; - }); - } + if (d.categories) { + Object.keys(d.categories).forEach(function (categoryID) { + var c = d.categories[categoryID]; - return tags; - } - function utilStringQs(str) { - var i = 0; // advance past any leading '?' or '#' characters + if (c) { + // add or replace + c = presetCategory(categoryID, c, _presets); + if (c.locationSet) newLocationSets.push(c); + _categories[categoryID] = c; + } else { + // remove + delete _categories[categoryID]; + } + }); + } // Rebuild _this.collection after changing presets and categories - while (i < str.length && (str[i] === '?' || str[i] === '#')) { - i++; - } - str = str.slice(i); - return str.split('&').reduce(function (obj, pair) { - var parts = pair.split('='); + _this.collection = Object.values(_presets).concat(Object.values(_categories)); // Merge Defaults - if (parts.length === 2) { - obj[parts[0]] = null === parts[1] ? '' : decodeURIComponent(parts[1]); - } + if (d.defaults) { + Object.keys(d.defaults).forEach(function (geometry) { + var def = d.defaults[geometry]; - return obj; - }, {}); - } - function utilQsString(obj, noencode) { - // encode everything except special characters used in certain hash parameters: - // "/" in map states, ":", ",", {" and "}" in background - function softEncode(s) { - return encodeURIComponent(s).replace(/(%2F|%3A|%2C|%7B|%7D)/g, decodeURIComponent); - } + if (Array.isArray(def)) { + // add or replace + _defaults[geometry] = presetCollection(def.map(function (id) { + return _presets[id] || _categories[id]; + }).filter(Boolean)); + } else { + // remove + delete _defaults[geometry]; + } + }); + } // Rebuild universal fields array - return Object.keys(obj).sort().map(function (key) { - return encodeURIComponent(key) + '=' + (noencode ? softEncode(obj[key]) : encodeURIComponent(obj[key])); - }).join('&'); - } - function utilPrefixDOMProperty(property) { - var prefixes = ['webkit', 'ms', 'moz', 'o']; - var i = -1; - var n = prefixes.length; - var s = document.body; - if (property in s) return property; - property = property.substr(0, 1).toUpperCase() + property.substr(1); - while (++i < n) { - if (prefixes[i] + property in s) { - return prefixes[i] + property; - } - } + _universal = Object.values(_fields).filter(function (field) { + return field.universal; + }); // Reset all the preset fields - they'll need to be resolved again - return false; - } - function utilPrefixCSSProperty(property) { - var prefixes = ['webkit', 'ms', 'Moz', 'O']; - var i = -1; - var n = prefixes.length; - var s = document.body.style; + Object.values(_presets).forEach(function (preset) { + return preset.resetFields(); + }); // Rebuild geometry index - if (property.toLowerCase() in s) { - return property.toLowerCase(); - } + _geometryIndex = { + point: {}, + vertex: {}, + line: {}, + area: {}, + relation: {} + }; - while (++i < n) { - if (prefixes[i] + property in s) { - return '-' + prefixes[i].toLowerCase() + property.replace(/([A-Z])/g, '-$1').toLowerCase(); - } - } + _this.collection.forEach(function (preset) { + (preset.geometry || []).forEach(function (geometry) { + var g = _geometryIndex[geometry]; - return false; - } - var transformProperty; - function utilSetTransform(el, x, y, scale) { - var prop = transformProperty = transformProperty || utilPrefixCSSProperty('Transform'); - var translate = utilDetect().opera ? 'translate(' + x + 'px,' + y + 'px)' : 'translate3d(' + x + 'px,' + y + 'px,0)'; - return el.style(prop, translate + (scale ? ' scale(' + scale + ')' : '')); - } // Calculates Levenshtein distance between two strings - // see: https://en.wikipedia.org/wiki/Levenshtein_distance - // first converts the strings to lowercase and replaces diacritic marks with ascii equivalents. + for (var key in preset.tags) { + g[key] = g[key] || {}; + var value = preset.tags[key]; + (g[key][value] = g[key][value] || []).push(preset); + } + }); + }); // Merge Custom Features - function utilEditDistance(a, b) { - a = remove$6(a.toLowerCase()); - b = remove$6(b.toLowerCase()); - if (a.length === 0) return b.length; - if (b.length === 0) return a.length; - var matrix = []; - var i, j; - for (i = 0; i <= b.length; i++) { - matrix[i] = [i]; - } + if (d.featureCollection && Array.isArray(d.featureCollection.features)) { + _mainLocations.mergeCustomGeoJSON(d.featureCollection); + } // Resolve all locationSet features. - for (j = 0; j <= a.length; j++) { - matrix[0][j] = j; - } - for (i = 1; i <= b.length; i++) { - for (j = 1; j <= a.length; j++) { - if (b.charAt(i - 1) === a.charAt(j - 1)) { - matrix[i][j] = matrix[i - 1][j - 1]; - } else { - matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution - Math.min(matrix[i][j - 1] + 1, // insertion - matrix[i - 1][j] + 1)); // deletion - } + if (newLocationSets.length) { + _mainLocations.mergeLocationSets(newLocationSets); } - } - - return matrix[b.length][a.length]; - } // a d3.mouse-alike which - // 1. Only works on HTML elements, not SVG - // 2. Does not cause style recalculation - function utilFastMouse(container) { - var rect = container.getBoundingClientRect(); - var rectLeft = rect.left; - var rectTop = rect.top; - var clientLeft = +container.clientLeft; - var clientTop = +container.clientTop; - return function (e) { - return [e.clientX - rectLeft - clientLeft, e.clientY - rectTop - clientTop]; + return _this; }; - } - function utilAsyncMap(inputs, func, callback) { - var remaining = inputs.length; - var results = []; - var errors = []; - inputs.forEach(function (d, i) { - func(d, function done(err, data) { - errors[i] = err; - results[i] = data; - remaining--; - if (!remaining) callback(errors, results); - }); - }); - } // wraps an index to an interval [0..length-1] - function utilWrap(index, length) { - if (index < 0) { - index += Math.ceil(-index / length) * length; - } + _this.match = function (entity, resolver) { + return resolver["transient"](entity, 'presetMatch', function () { + var geometry = entity.geometry(resolver); // Treat entities on addr:interpolation lines as points, not vertices - #3241 - return index % length; - } - /** - * a replacement for functor - * - * @param {*} value any value - * @returns {Function} a function that returns that value or the value if it's a function - */ + if (geometry === 'vertex' && entity.isOnAddressLine(resolver)) { + geometry = 'point'; + } - function utilFunctor(value) { - if (typeof value === 'function') return value; - return function () { - return value; + var entityExtent = entity.extent(resolver); + return _this.matchTags(entity.tags, geometry, entityExtent.center()); + }); }; - } - function utilNoAuto(selection) { - var isText = selection.size() && selection.node().tagName.toLowerCase() === 'textarea'; - return selection // assign 'new-password' even for non-password fields to prevent browsers (Chrome) ignoring 'off' - .attr('autocomplete', 'new-password').attr('autocorrect', 'off').attr('autocapitalize', 'off').attr('spellcheck', isText ? 'true' : 'false'); - } // https://stackoverflow.com/questions/194846/is-there-any-kind-of-hash-code-function-in-javascript - // https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/ - function utilHashcode(str) { - var hash = 0; + _this.matchTags = function (tags, geometry, loc) { + var keyIndex = _geometryIndex[geometry]; + var bestScore = -1; + var bestMatch; + var matchCandidates = []; - if (str.length === 0) { - return hash; - } + for (var k in tags) { + var indexMatches = []; + var valueIndex = keyIndex[k]; + if (!valueIndex) continue; + var keyValueMatches = valueIndex[tags[k]]; + if (keyValueMatches) indexMatches.push.apply(indexMatches, _toConsumableArray(keyValueMatches)); + var keyStarMatches = valueIndex['*']; + if (keyStarMatches) indexMatches.push.apply(indexMatches, _toConsumableArray(keyStarMatches)); + if (indexMatches.length === 0) continue; + + for (var i = 0; i < indexMatches.length; i++) { + var candidate = indexMatches[i]; + var score = candidate.matchScore(tags); - for (var i = 0; i < str.length; i++) { - var _char = str.charCodeAt(i); + if (score === -1) { + continue; + } - hash = (hash << 5) - hash + _char; - hash = hash & hash; // Convert to 32bit integer - } + matchCandidates.push({ + score: score, + candidate: candidate + }); - return hash; - } // Returns version of `str` with all runs of special characters replaced by `_`; - // suitable for HTML ids, classes, selectors, etc. + if (score > bestScore) { + bestScore = score; + bestMatch = candidate; + } + } + } - function utilSafeClassName(str) { - return str.toLowerCase().replace(/[^a-z0-9]+/g, '_'); - } // Returns string based on `val` that is highly unlikely to collide with an id - // used previously or that's present elsewhere in the document. Useful for preventing - // browser-provided autofills or when embedding iD on pages with unknown elements. + if (bestMatch && bestMatch.locationSetID && bestMatch.locationSetID !== '+[Q2]' && Array.isArray(loc)) { + var validLocations = _mainLocations.locationsAt(loc); - function utilUniqueDomId(val) { - return 'ideditor-' + utilSafeClassName(val.toString()) + '-' + new Date().getTime().toString(); - } // Returns the length of `str` in unicode characters. This can be less than - // `String.length()` since a single unicode character can be composed of multiple - // JavaScript UTF-16 code units. + if (!validLocations[bestMatch.locationSetID]) { + matchCandidates.sort(function (a, b) { + return a.score < b.score ? 1 : -1; + }); - function utilUnicodeCharsCount(str) { - // Native ES2015 implementations of `Array.from` split strings into unicode characters - return Array.from(str).length; - } // Returns a new string representing `str` cut from its start to `limit` length - // in unicode characters. Note that this runs the risk of splitting graphemes. + for (var _i = 0; _i < matchCandidates.length; _i++) { + var candidateScore = matchCandidates[_i]; - function utilUnicodeCharsTruncated(str, limit) { - return Array.from(str).slice(0, limit).join(''); - } // Variation of d3.json (https://github.com/d3/d3-fetch/blob/master/src/json.js) + if (!candidateScore.candidate.locationSetID || validLocations[candidateScore.candidate.locationSetID]) { + bestMatch = candidateScore.candidate; + bestScore = candidateScore.score; + break; + } + } + } + } // If any part of an address is present, allow fallback to "Address" preset - #4353 - function utilFetchJson(resourse, init) { - return fetch(resourse, init).then(function (response) { - // fetch in PhantomJS tests may return ok=false and status=0 even if it's okay - if (!response.ok && response.status !== 0 || !response.json) throw new Error(response.status + ' ' + response.statusText); - if (response.status === 204 || response.status === 205) return; - return response.json(); - }); - } - function osmEntity(attrs) { - // For prototypal inheritance. - if (this instanceof osmEntity) return; // Create the appropriate subtype. - - if (attrs && attrs.type) { - return osmEntity[attrs.type].apply(this, arguments); - } else if (attrs && attrs.id) { - return osmEntity[osmEntity.id.type(attrs.id)].apply(this, arguments); - } // Initialize a generic Entity (used only in tests). + if (!bestMatch || bestMatch.isFallback()) { + for (var _k in tags) { + if (/^addr:/.test(_k) && keyIndex['addr:*'] && keyIndex['addr:*']['*']) { + bestMatch = keyIndex['addr:*']['*'][0]; + break; + } + } + } + return bestMatch || _this.fallback(geometry); + }; - return new osmEntity().initialize(arguments); - } + _this.allowsVertex = function (entity, resolver) { + if (entity.type !== 'node') return false; + if (Object.keys(entity.tags).length === 0) return true; + return resolver["transient"](entity, 'vertexMatch', function () { + // address lines allow vertices to act as standalone points + if (entity.isOnAddressLine(resolver)) return true; + var geometries = osmNodeGeometriesForTags(entity.tags); + if (geometries.vertex) return true; + if (geometries.point) return false; // allow vertices for unspecified points - osmEntity.id = function (type) { - return osmEntity.id.fromOSM(type, osmEntity.id.next[type]--); - }; + return true; + }); + }; // Because of the open nature of tagging, iD will never have a complete + // list of tags used in OSM, so we want it to have logic like "assume + // that a closed way with an amenity tag is an area, unless the amenity + // is one of these specific types". This function computes a structure + // that allows testing of such conditions, based on the presets designated + // as as supporting (or not supporting) the area geometry. + // + // The returned object L is a keeplist/discardlist of tags. A closed way + // with a tag (k, v) is considered to be an area if `k in L && !(v in L[k])` + // (see `Way#isArea()`). In other words, the keys of L form the keeplist, + // and the subkeys form the discardlist. - osmEntity.id.next = { - changeset: -1, - node: -1, - way: -1, - relation: -1 - }; - osmEntity.id.fromOSM = function (type, id) { - return type[0] + id; - }; + _this.areaKeys = function () { + // The ignore list is for keys that imply lines. (We always add `area=yes` for exceptions) + var ignore = ['barrier', 'highway', 'footway', 'railway', 'junction', 'type']; + var areaKeys = {}; // ignore name-suggestion-index and deprecated presets - osmEntity.id.toOSM = function (id) { - return id.slice(1); - }; + var presets = _this.collection.filter(function (p) { + return !p.suggestion && !p.replacement; + }); // keeplist - osmEntity.id.type = function (id) { - return { - 'c': 'changeset', - 'n': 'node', - 'w': 'way', - 'r': 'relation' - }[id[0]]; - }; // A function suitable for use as the second argument to d3.selection#data(). + presets.forEach(function (p) { + var keys = p.tags && Object.keys(p.tags); + var key = keys && keys.length && keys[0]; // pick the first tag - osmEntity.key = function (entity) { - return entity.id + 'v' + (entity.v || 0); - }; + if (!key) return; + if (ignore.indexOf(key) !== -1) return; - var _deprecatedTagValuesByKey; + if (p.geometry.indexOf('area') !== -1) { + // probably an area.. + areaKeys[key] = areaKeys[key] || {}; + } + }); // discardlist - osmEntity.deprecatedTagValuesByKey = function (dataDeprecated) { - if (!_deprecatedTagValuesByKey) { - _deprecatedTagValuesByKey = {}; - dataDeprecated.forEach(function (d) { - var oldKeys = Object.keys(d.old); + presets.forEach(function (p) { + var key; - if (oldKeys.length === 1) { - var oldKey = oldKeys[0]; - var oldValue = d.old[oldKey]; + for (key in p.addTags) { + // examine all addTags to get a better sense of what can be tagged on lines - #6800 + var value = p.addTags[key]; - if (oldValue !== '*') { - if (!_deprecatedTagValuesByKey[oldKey]) { - _deprecatedTagValuesByKey[oldKey] = [oldValue]; - } else { - _deprecatedTagValuesByKey[oldKey].push(oldValue); - } + if (key in areaKeys && // probably an area... + p.geometry.indexOf('line') !== -1 && // but sometimes a line + value !== '*') { + areaKeys[key][value] = true; } } }); - } + return areaKeys; + }; - return _deprecatedTagValuesByKey; - }; + _this.pointTags = function () { + return _this.collection.reduce(function (pointTags, d) { + // ignore name-suggestion-index, deprecated, and generic presets + if (d.suggestion || d.replacement || d.searchable === false) return pointTags; // only care about the primary tag - osmEntity.prototype = { - tags: {}, - initialize: function initialize(sources) { - for (var i = 0; i < sources.length; ++i) { - var source = sources[i]; + var keys = d.tags && Object.keys(d.tags); + var key = keys && keys.length && keys[0]; // pick the first tag - for (var prop in source) { - if (Object.prototype.hasOwnProperty.call(source, prop)) { - if (source[prop] === undefined) { - delete this[prop]; - } else { - this[prop] = source[prop]; - } - } + if (!key) return pointTags; // if this can be a point + + if (d.geometry.indexOf('point') !== -1) { + pointTags[key] = pointTags[key] || {}; + pointTags[key][d.tags[key]] = true; } - } - if (!this.id && this.type) { - this.id = osmEntity.id(this.type); - } + return pointTags; + }, {}); + }; - if (!this.hasOwnProperty('visible')) { - this.visible = true; - } + _this.vertexTags = function () { + return _this.collection.reduce(function (vertexTags, d) { + // ignore name-suggestion-index, deprecated, and generic presets + if (d.suggestion || d.replacement || d.searchable === false) return vertexTags; // only care about the primary tag - if (debug) { - Object.freeze(this); - Object.freeze(this.tags); - if (this.loc) Object.freeze(this.loc); - if (this.nodes) Object.freeze(this.nodes); - if (this.members) Object.freeze(this.members); - } + var keys = d.tags && Object.keys(d.tags); + var key = keys && keys.length && keys[0]; // pick the first tag - return this; - }, - copy: function copy(resolver, copies) { - if (copies[this.id]) return copies[this.id]; - var copy = osmEntity(this, { - id: undefined, - user: undefined, - version: undefined - }); - copies[this.id] = copy; - return copy; - }, - osmId: function osmId() { - return osmEntity.id.toOSM(this.id); - }, - isNew: function isNew() { - return this.osmId() < 0; - }, - update: function update(attrs) { - return osmEntity(this, attrs, { - v: 1 + (this.v || 0) - }); - }, - mergeTags: function mergeTags(tags) { - var merged = Object.assign({}, this.tags); // shallow copy + if (!key) return vertexTags; // if this can be a vertex - var changed = false; + if (d.geometry.indexOf('vertex') !== -1) { + vertexTags[key] = vertexTags[key] || {}; + vertexTags[key][d.tags[key]] = true; + } - for (var k in tags) { - var t1 = merged[k]; - var t2 = tags[k]; + return vertexTags; + }, {}); + }; - if (!t1) { - changed = true; - merged[k] = t2; - } else if (t1 !== t2) { - changed = true; - merged[k] = utilUnicodeCharsTruncated(utilArrayUnion(t1.split(/;\s*/), t2.split(/;\s*/)).join(';'), 255 // avoid exceeding character limit; see also services/osm.js -> maxCharsForTagValue() - ); - } - } + _this.field = function (id) { + return _fields[id]; + }; - return changed ? this.update({ - tags: merged - }) : this; - }, - intersects: function intersects(extent, resolver) { - return this.extent(resolver).intersects(extent); - }, - hasNonGeometryTags: function hasNonGeometryTags() { - return Object.keys(this.tags).some(function (k) { - return k !== 'area'; - }); - }, - hasParentRelations: function hasParentRelations(resolver) { - return resolver.parentRelations(this).length > 0; - }, - hasInterestingTags: function hasInterestingTags() { - return Object.keys(this.tags).some(osmIsInterestingTag); - }, - isHighwayIntersection: function isHighwayIntersection() { - return false; - }, - isDegenerate: function isDegenerate() { - return true; - }, - deprecatedTags: function deprecatedTags(dataDeprecated) { - var tags = this.tags; // if there are no tags, none can be deprecated + _this.universal = function () { + return _universal; + }; - if (Object.keys(tags).length === 0) return []; - var deprecated = []; - dataDeprecated.forEach(function (d) { - var oldKeys = Object.keys(d.old); + _this.defaults = function (geometry, n, startWithRecents, loc) { + var recents = []; - if (d.replace) { - var hasExistingValues = Object.keys(d.replace).some(function (replaceKey) { - if (!tags[replaceKey] || d.old[replaceKey]) return false; - var replaceValue = d.replace[replaceKey]; - if (replaceValue === '*') return false; - if (replaceValue === tags[replaceKey]) return false; - return true; - }); // don't flag deprecated tags if the upgrade path would overwrite existing data - #7843 + if (startWithRecents) { + recents = _this.recent().matchGeometry(geometry).collection.slice(0, 4); + } - if (hasExistingValues) return; - } + var defaults; - var matchesDeprecatedTags = oldKeys.every(function (oldKey) { - if (!tags[oldKey]) return false; - if (d.old[oldKey] === '*') return true; - if (d.old[oldKey] === tags[oldKey]) return true; - var vals = tags[oldKey].split(';').filter(Boolean); + if (_addablePresetIDs) { + defaults = Array.from(_addablePresetIDs).map(function (id) { + var preset = _this.item(id); - if (vals.length === 0) { - return false; - } else if (vals.length > 1) { - return vals.indexOf(d.old[oldKey]) !== -1; - } else { - if (tags[oldKey] === d.old[oldKey]) { - if (d.replace && d.old[oldKey] === d.replace[oldKey]) { - var replaceKeys = Object.keys(d.replace); - return !replaceKeys.every(function (replaceKey) { - return tags[replaceKey] === d.replace[replaceKey]; - }); - } else { - return true; - } - } - } + if (preset && preset.matchGeometry(geometry)) return preset; + return null; + }).filter(Boolean); + } else { + defaults = _defaults[geometry].collection.concat(_this.fallback(geometry)); + } - return false; + var result = presetCollection(utilArrayUniq(recents.concat(defaults)).slice(0, n - 1)); + + if (Array.isArray(loc)) { + var validLocations = _mainLocations.locationsAt(loc); + result.collection = result.collection.filter(function (a) { + return !a.locationSetID || validLocations[a.locationSetID]; }); + } - if (matchesDeprecatedTags) { - deprecated.push(d); - } - }); - return deprecated; - } - }; + return result; + }; // pass a Set of addable preset ids - function osmLanes(entity) { - if (entity.type !== 'way') return null; - if (!entity.tags.highway) return null; - var tags = entity.tags; - var isOneWay = entity.isOneWay(); - var laneCount = getLaneCount(tags, isOneWay); - var maxspeed = parseMaxspeed(tags); - var laneDirections = parseLaneDirections(tags, isOneWay, laneCount); - var forward = laneDirections.forward; - var backward = laneDirections.backward; - var bothways = laneDirections.bothways; // parse the piped string 'x|y|z' format - var turnLanes = {}; - turnLanes.unspecified = parseTurnLanes(tags['turn:lanes']); - turnLanes.forward = parseTurnLanes(tags['turn:lanes:forward']); - turnLanes.backward = parseTurnLanes(tags['turn:lanes:backward']); - var maxspeedLanes = {}; - maxspeedLanes.unspecified = parseMaxspeedLanes(tags['maxspeed:lanes'], maxspeed); - maxspeedLanes.forward = parseMaxspeedLanes(tags['maxspeed:lanes:forward'], maxspeed); - maxspeedLanes.backward = parseMaxspeedLanes(tags['maxspeed:lanes:backward'], maxspeed); - var psvLanes = {}; - psvLanes.unspecified = parseMiscLanes(tags['psv:lanes']); - psvLanes.forward = parseMiscLanes(tags['psv:lanes:forward']); - psvLanes.backward = parseMiscLanes(tags['psv:lanes:backward']); - var busLanes = {}; - busLanes.unspecified = parseMiscLanes(tags['bus:lanes']); - busLanes.forward = parseMiscLanes(tags['bus:lanes:forward']); - busLanes.backward = parseMiscLanes(tags['bus:lanes:backward']); - var taxiLanes = {}; - taxiLanes.unspecified = parseMiscLanes(tags['taxi:lanes']); - taxiLanes.forward = parseMiscLanes(tags['taxi:lanes:forward']); - taxiLanes.backward = parseMiscLanes(tags['taxi:lanes:backward']); - var hovLanes = {}; - hovLanes.unspecified = parseMiscLanes(tags['hov:lanes']); - hovLanes.forward = parseMiscLanes(tags['hov:lanes:forward']); - hovLanes.backward = parseMiscLanes(tags['hov:lanes:backward']); - var hgvLanes = {}; - hgvLanes.unspecified = parseMiscLanes(tags['hgv:lanes']); - hgvLanes.forward = parseMiscLanes(tags['hgv:lanes:forward']); - hgvLanes.backward = parseMiscLanes(tags['hgv:lanes:backward']); - var bicyclewayLanes = {}; - bicyclewayLanes.unspecified = parseBicycleWay(tags['bicycleway:lanes']); - bicyclewayLanes.forward = parseBicycleWay(tags['bicycleway:lanes:forward']); - bicyclewayLanes.backward = parseBicycleWay(tags['bicycleway:lanes:backward']); - var lanesObj = { - forward: [], - backward: [], - unspecified: [] - }; // map forward/backward/unspecified of each lane type to lanesObj + _this.addablePresetIDs = function (val) { + if (!arguments.length) return _addablePresetIDs; // accept and convert arrays - mapToLanesObj(lanesObj, turnLanes, 'turnLane'); - mapToLanesObj(lanesObj, maxspeedLanes, 'maxspeed'); - mapToLanesObj(lanesObj, psvLanes, 'psv'); - mapToLanesObj(lanesObj, busLanes, 'bus'); - mapToLanesObj(lanesObj, taxiLanes, 'taxi'); - mapToLanesObj(lanesObj, hovLanes, 'hov'); - mapToLanesObj(lanesObj, hgvLanes, 'hgv'); - mapToLanesObj(lanesObj, bicyclewayLanes, 'bicycleway'); - return { - metadata: { - count: laneCount, - oneway: isOneWay, - forward: forward, - backward: backward, - bothways: bothways, - turnLanes: turnLanes, - maxspeed: maxspeed, - maxspeedLanes: maxspeedLanes, - psvLanes: psvLanes, - busLanes: busLanes, - taxiLanes: taxiLanes, - hovLanes: hovLanes, - hgvLanes: hgvLanes, - bicyclewayLanes: bicyclewayLanes - }, - lanes: lanesObj - }; - } + if (Array.isArray(val)) val = new Set(val); + _addablePresetIDs = val; - function getLaneCount(tags, isOneWay) { - var count; + if (_addablePresetIDs) { + // reset all presets + _this.collection.forEach(function (p) { + // categories aren't addable + if (p.addable) p.addable(_addablePresetIDs.has(p.id)); + }); + } else { + _this.collection.forEach(function (p) { + if (p.addable) p.addable(true); + }); + } - if (tags.lanes) { - count = parseInt(tags.lanes, 10); + return _this; + }; - if (count > 0) { - return count; - } - } + _this.recent = function () { + return presetCollection(utilArrayUniq(_this.getRecents().map(function (d) { + return d.preset; + }))); + }; - switch (tags.highway) { - case 'trunk': - case 'motorway': - count = isOneWay ? 2 : 4; - break; + function RibbonItem(preset, source) { + var item = {}; + item.preset = preset; + item.source = source; - default: - count = isOneWay ? 1 : 2; - break; - } + item.isFavorite = function () { + return item.source === 'favorite'; + }; - return count; - } + item.isRecent = function () { + return item.source === 'recent'; + }; - function parseMaxspeed(tags) { - var maxspeed = tags.maxspeed; - if (!maxspeed) return; - var maxspeedRegex = /^([0-9][\.0-9]+?)(?:[ ]?(?:km\/h|kmh|kph|mph|knots))?$/; - if (!maxspeedRegex.test(maxspeed)) return; - return parseInt(maxspeed, 10); - } + item.matches = function (preset) { + return item.preset.id === preset.id; + }; - function parseLaneDirections(tags, isOneWay, laneCount) { - var forward = parseInt(tags['lanes:forward'], 10); - var backward = parseInt(tags['lanes:backward'], 10); - var bothways = parseInt(tags['lanes:both_ways'], 10) > 0 ? 1 : 0; + item.minified = function () { + return { + pID: item.preset.id + }; + }; - if (parseInt(tags.oneway, 10) === -1) { - forward = 0; - bothways = 0; - backward = laneCount; - } else if (isOneWay) { - forward = laneCount; - bothways = 0; - backward = 0; - } else if (isNaN(forward) && isNaN(backward)) { - backward = Math.floor((laneCount - bothways) / 2); - forward = laneCount - bothways - backward; - } else if (isNaN(forward)) { - if (backward > laneCount - bothways) { - backward = laneCount - bothways; - } + return item; + } - forward = laneCount - bothways - backward; - } else if (isNaN(backward)) { - if (forward > laneCount - bothways) { - forward = laneCount - bothways; + function ribbonItemForMinified(d, source) { + if (d && d.pID) { + var preset = _this.item(d.pID); + + if (!preset) return null; + return RibbonItem(preset, source); } - backward = laneCount - bothways - forward; + return null; } - return { - forward: forward, - backward: backward, - bothways: bothways - }; - } - - function parseTurnLanes(tag) { - if (!tag) return; - var validValues = ['left', 'slight_left', 'sharp_left', 'through', 'right', 'slight_right', 'sharp_right', 'reverse', 'merge_to_left', 'merge_to_right', 'none']; - return tag.split('|').map(function (s) { - if (s === '') s = 'none'; - return s.split(';').map(function (d) { - return validValues.indexOf(d) === -1 ? 'unknown' : d; + _this.getGenericRibbonItems = function () { + return ['point', 'line', 'area'].map(function (id) { + return RibbonItem(_this.item(id), 'generic'); }); - }); - } + }; - function parseMaxspeedLanes(tag, maxspeed) { - if (!tag) return; - return tag.split('|').map(function (s) { - if (s === 'none') return s; - var m = parseInt(s, 10); - if (s === '' || m === maxspeed) return null; - return isNaN(m) ? 'unknown' : m; - }); - } + _this.getAddable = function () { + if (!_addablePresetIDs) return []; + return _addablePresetIDs.map(function (id) { + var preset = _this.item(id); - function parseMiscLanes(tag) { - if (!tag) return; - var validValues = ['yes', 'no', 'designated']; - return tag.split('|').map(function (s) { - if (s === '') s = 'no'; - return validValues.indexOf(s) === -1 ? 'unknown' : s; - }); - } + if (preset) return RibbonItem(preset, 'addable'); + return null; + }).filter(Boolean); + }; - function parseBicycleWay(tag) { - if (!tag) return; - var validValues = ['yes', 'no', 'designated', 'lane']; - return tag.split('|').map(function (s) { - if (s === '') s = 'no'; - return validValues.indexOf(s) === -1 ? 'unknown' : s; - }); - } - - function mapToLanesObj(lanesObj, data, key) { - if (data.forward) { - data.forward.forEach(function (l, i) { - if (!lanesObj.forward[i]) lanesObj.forward[i] = {}; - lanesObj.forward[i][key] = l; - }); - } - - if (data.backward) { - data.backward.forEach(function (l, i) { - if (!lanesObj.backward[i]) lanesObj.backward[i] = {}; - lanesObj.backward[i][key] = l; + function setRecents(items) { + _recents = items; + var minifiedItems = items.map(function (d) { + return d.minified(); }); + corePreferences('preset_recents', JSON.stringify(minifiedItems)); + dispatch.call('recentsChange'); } - if (data.unspecified) { - data.unspecified.forEach(function (l, i) { - if (!lanesObj.unspecified[i]) lanesObj.unspecified[i] = {}; - lanesObj.unspecified[i][key] = l; - }); - } - } + _this.getRecents = function () { + if (!_recents) { + // fetch from local storage + _recents = (JSON.parse(corePreferences('preset_recents')) || []).reduce(function (acc, d) { + var item = ribbonItemForMinified(d, 'recent'); + if (item && item.preset.addable()) acc.push(item); + return acc; + }, []); + } - function osmWay() { - if (!(this instanceof osmWay)) { - return new osmWay().initialize(arguments); - } else if (arguments.length) { - this.initialize(arguments); - } - } - osmEntity.way = osmWay; - osmWay.prototype = Object.create(osmEntity.prototype); - Object.assign(osmWay.prototype, { - type: 'way', - nodes: [], - copy: function copy(resolver, copies) { - if (copies[this.id]) return copies[this.id]; - var copy = osmEntity.prototype.copy.call(this, resolver, copies); - var nodes = this.nodes.map(function (id) { - return resolver.entity(id).copy(resolver, copies).id; - }); - copy = copy.update({ - nodes: nodes - }); - copies[this.id] = copy; - return copy; - }, - extent: function extent(resolver) { - return resolver["transient"](this, 'extent', function () { - var extent = geoExtent(); + return _recents; + }; - for (var i = 0; i < this.nodes.length; i++) { - var node = resolver.hasEntity(this.nodes[i]); + _this.addRecent = function (preset, besidePreset, after) { + var recents = _this.getRecents(); - if (node) { - extent._extend(node.extent()); - } - } + var beforeItem = _this.recentMatching(besidePreset); - return extent; - }); - }, - first: function first() { - return this.nodes[0]; - }, - last: function last() { - return this.nodes[this.nodes.length - 1]; - }, - contains: function contains(node) { - return this.nodes.indexOf(node) >= 0; - }, - affix: function affix(node) { - if (this.nodes[0] === node) return 'prefix'; - if (this.nodes[this.nodes.length - 1] === node) return 'suffix'; - }, - layer: function layer() { - // explicit layer tag, clamp between -10, 10.. - if (isFinite(this.tags.layer)) { - return Math.max(-10, Math.min(+this.tags.layer, 10)); - } // implied layer tag.. + var toIndex = recents.indexOf(beforeItem); + if (after) toIndex += 1; + var newItem = RibbonItem(preset, 'recent'); + recents.splice(toIndex, 0, newItem); + setRecents(recents); + }; + _this.removeRecent = function (preset) { + var item = _this.recentMatching(preset); - if (this.tags.covered === 'yes') return -1; - if (this.tags.location === 'overground') return 1; - if (this.tags.location === 'underground') return -1; - if (this.tags.location === 'underwater') return -10; - if (this.tags.power === 'line') return 10; - if (this.tags.power === 'minor_line') return 10; - if (this.tags.aerialway) return 10; - if (this.tags.bridge) return 1; - if (this.tags.cutting) return -1; - if (this.tags.tunnel) return -1; - if (this.tags.waterway) return -1; - if (this.tags.man_made === 'pipeline') return -10; - if (this.tags.boundary) return -10; - return 0; - }, - // the approximate width of the line based on its tags except its `width` tag - impliedLineWidthMeters: function impliedLineWidthMeters() { - var averageWidths = { - highway: { - // width is for single lane - motorway: 5, - motorway_link: 5, - trunk: 4.5, - trunk_link: 4.5, - primary: 4, - secondary: 4, - tertiary: 4, - primary_link: 4, - secondary_link: 4, - tertiary_link: 4, - unclassified: 4, - road: 4, - living_street: 4, - bus_guideway: 4, - pedestrian: 4, - residential: 3.5, - service: 3.5, - track: 3, - cycleway: 2.5, - bridleway: 2, - corridor: 2, - steps: 2, - path: 1.5, - footway: 1.5 - }, - railway: { - // width includes ties and rail bed, not just track gauge - rail: 2.5, - light_rail: 2.5, - tram: 2.5, - subway: 2.5, - monorail: 2.5, - funicular: 2.5, - disused: 2.5, - preserved: 2.5, - miniature: 1.5, - narrow_gauge: 1.5 - }, - waterway: { - river: 50, - canal: 25, - stream: 5, - tidal_channel: 5, - fish_pass: 2.5, - drain: 2.5, - ditch: 1.5 - } - }; + if (item) { + var items = _this.getRecents(); - for (var key in averageWidths) { - if (this.tags[key] && averageWidths[key][this.tags[key]]) { - var width = averageWidths[key][this.tags[key]]; + items.splice(items.indexOf(item), 1); + setRecents(items); + } + }; - if (key === 'highway') { - var laneCount = this.tags.lanes && parseInt(this.tags.lanes, 10); - if (!laneCount) laneCount = this.isOneWay() ? 1 : 2; - return width * laneCount; - } + _this.recentMatching = function (preset) { + var items = _this.getRecents(); - return width; + for (var i in items) { + if (items[i].matches(preset)) { + return items[i]; } } return null; - }, - isOneWay: function isOneWay() { - // explicit oneway tag.. - var values = { - 'yes': true, - '1': true, - '-1': true, - 'reversible': true, - 'alternating': true, - 'no': false, - '0': false - }; - - if (values[this.tags.oneway] !== undefined) { - return values[this.tags.oneway]; - } // implied oneway tag.. - - - for (var key in this.tags) { - if (key in osmOneWayTags && this.tags[key] in osmOneWayTags[key]) { - return true; - } - } + }; - return false; - }, - // Some identifier for tag that implies that this way is "sided", - // i.e. the right side is the 'inside' (e.g. the right side of a - // natural=cliff is lower). - sidednessIdentifier: function sidednessIdentifier() { - for (var key in this.tags) { - var value = this.tags[key]; + _this.moveItem = function (items, fromIndex, toIndex) { + if (fromIndex === toIndex || fromIndex < 0 || toIndex < 0 || fromIndex >= items.length || toIndex >= items.length) return null; + items.splice(toIndex, 0, items.splice(fromIndex, 1)[0]); + return items; + }; - if (key in osmRightSideIsInsideTags && value in osmRightSideIsInsideTags[key]) { - if (osmRightSideIsInsideTags[key][value] === true) { - return key; - } else { - // if the map's value is something other than a - // literal true, we should use it so we can - // special case some keys (e.g. natural=coastline - // is handled differently to other naturals). - return osmRightSideIsInsideTags[key][value]; - } - } - } + _this.moveRecent = function (item, beforeItem) { + var recents = _this.getRecents(); - return null; - }, - isSided: function isSided() { - if (this.tags.two_sided === 'yes') { - return false; - } + var fromIndex = recents.indexOf(item); + var toIndex = recents.indexOf(beforeItem); - return this.sidednessIdentifier() !== null; - }, - lanes: function lanes() { - return osmLanes(this); - }, - isClosed: function isClosed() { - return this.nodes.length > 1 && this.first() === this.last(); - }, - isConvex: function isConvex(resolver) { - if (!this.isClosed() || this.isDegenerate()) return null; - var nodes = utilArrayUniq(resolver.childNodes(this)); - var coords = nodes.map(function (n) { - return n.loc; - }); - var curr = 0; - var prev = 0; + var items = _this.moveItem(recents, fromIndex, toIndex); - for (var i = 0; i < coords.length; i++) { - var o = coords[(i + 1) % coords.length]; - var a = coords[i]; - var b = coords[(i + 2) % coords.length]; - var res = geoVecCross(a, b, o); - curr = res > 0 ? 1 : res < 0 ? -1 : 0; + if (items) setRecents(items); + }; - if (curr === 0) { - continue; - } else if (prev && curr !== prev) { - return false; - } + _this.setMostRecent = function (preset) { + if (preset.searchable === false) return; - prev = curr; - } + var items = _this.getRecents(); - return true; - }, - // returns an object with the tag that implies this is an area, if any - tagSuggestingArea: function tagSuggestingArea() { - return osmTagSuggestingArea(this.tags); - }, - isArea: function isArea() { - if (this.tags.area === 'yes') return true; - if (!this.isClosed() || this.tags.area === 'no') return false; - return this.tagSuggestingArea() !== null; - }, - isDegenerate: function isDegenerate() { - return new Set(this.nodes).size < (this.isArea() ? 3 : 2); - }, - areAdjacent: function areAdjacent(n1, n2) { - for (var i = 0; i < this.nodes.length; i++) { - if (this.nodes[i] === n1) { - if (this.nodes[i - 1] === n2) return true; - if (this.nodes[i + 1] === n2) return true; - } - } + var item = _this.recentMatching(preset); - return false; - }, - geometry: function geometry(graph) { - return graph["transient"](this, 'geometry', function () { - return this.isArea() ? 'area' : 'line'; - }); - }, - // returns an array of objects representing the segments between the nodes in this way - segments: function segments(graph) { - function segmentExtent(graph) { - var n1 = graph.hasEntity(this.nodes[0]); - var n2 = graph.hasEntity(this.nodes[1]); - return n1 && n2 && geoExtent([[Math.min(n1.loc[0], n2.loc[0]), Math.min(n1.loc[1], n2.loc[1])], [Math.max(n1.loc[0], n2.loc[0]), Math.max(n1.loc[1], n2.loc[1])]]); - } + if (item) { + items.splice(items.indexOf(item), 1); + } else { + item = RibbonItem(preset, 'recent'); + } // remove the last recent (first in, first out) - return graph["transient"](this, 'segments', function () { - var segments = []; - for (var i = 0; i < this.nodes.length - 1; i++) { - segments.push({ - id: this.id + '-' + i, - wayId: this.id, - index: i, - nodes: [this.nodes[i], this.nodes[i + 1]], - extent: segmentExtent - }); - } + while (items.length >= MAXRECENTS) { + items.pop(); + } // prepend array - return segments; - }); - }, - // If this way is not closed, append the beginning node to the end of the nodelist to close it. - close: function close() { - if (this.isClosed() || !this.nodes.length) return this; - var nodes = this.nodes.slice(); - nodes = nodes.filter(noRepeatNodes); - nodes.push(nodes[0]); - return this.update({ - nodes: nodes - }); - }, - // If this way is closed, remove any connector nodes from the end of the nodelist to unclose it. - unclose: function unclose() { - if (!this.isClosed()) return this; - var nodes = this.nodes.slice(); - var connector = this.first(); - var i = nodes.length - 1; // remove trailing connectors.. - while (i > 0 && nodes.length > 1 && nodes[i] === connector) { - nodes.splice(i, 1); - i = nodes.length - 1; - } + items.unshift(item); + setRecents(items); + }; - nodes = nodes.filter(noRepeatNodes); - return this.update({ - nodes: nodes + function setFavorites(items) { + _favorites = items; + var minifiedItems = items.map(function (d) { + return d.minified(); }); - }, - // Adds a node (id) in front of the node which is currently at position index. - // If index is undefined, the node will be added to the end of the way for linear ways, - // or just before the final connecting node for circular ways. - // Consecutive duplicates are eliminated including existing ones. - // Circularity is always preserved when adding a node. - addNode: function addNode(id, index) { - var nodes = this.nodes.slice(); - var isClosed = this.isClosed(); - var max = isClosed ? nodes.length - 1 : nodes.length; - - if (index === undefined) { - index = max; - } - - if (index < 0 || index > max) { - throw new RangeError('index ' + index + ' out of range 0..' + max); - } // If this is a closed way, remove all connector nodes except the first one - // (there may be duplicates) and adjust index if necessary.. + corePreferences('preset_favorites', JSON.stringify(minifiedItems)); // call update + dispatch.call('favoritePreset'); + } - if (isClosed) { - var connector = this.first(); // leading connectors.. + _this.addFavorite = function (preset, besidePreset, after) { + var favorites = _this.getFavorites(); - var i = 1; + var beforeItem = _this.favoriteMatching(besidePreset); - while (i < nodes.length && nodes.length > 2 && nodes[i] === connector) { - nodes.splice(i, 1); - if (index > i) index--; - } // trailing connectors.. + var toIndex = favorites.indexOf(beforeItem); + if (after) toIndex += 1; + var newItem = RibbonItem(preset, 'favorite'); + favorites.splice(toIndex, 0, newItem); + setFavorites(favorites); + }; + _this.toggleFavorite = function (preset) { + var favs = _this.getFavorites(); - i = nodes.length - 1; + var favorite = _this.favoriteMatching(preset); - while (i > 0 && nodes.length > 1 && nodes[i] === connector) { - nodes.splice(i, 1); - if (index > i) index--; - i = nodes.length - 1; - } - } + if (favorite) { + favs.splice(favs.indexOf(favorite), 1); + } else { + // only allow 10 favorites + if (favs.length === 10) { + // remove the last favorite (last in, first out) + favs.pop(); + } // append array - nodes.splice(index, 0, id); - nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. - if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { - nodes.push(nodes[0]); + favs.push(RibbonItem(preset, 'favorite')); } - return this.update({ - nodes: nodes - }); - }, - // Replaces the node which is currently at position index with the given node (id). - // Consecutive duplicates are eliminated including existing ones. - // Circularity is preserved when updating a node. - updateNode: function updateNode(id, index) { - var nodes = this.nodes.slice(); - var isClosed = this.isClosed(); - var max = nodes.length - 1; + setFavorites(favs); + }; - if (index === undefined || index < 0 || index > max) { - throw new RangeError('index ' + index + ' out of range 0..' + max); - } // If this is a closed way, remove all connector nodes except the first one - // (there may be duplicates) and adjust index if necessary.. + _this.removeFavorite = function (preset) { + var item = _this.favoriteMatching(preset); + if (item) { + var items = _this.getFavorites(); - if (isClosed) { - var connector = this.first(); // leading connectors.. + items.splice(items.indexOf(item), 1); + setFavorites(items); + } + }; - var i = 1; + _this.getFavorites = function () { + if (!_favorites) { + // fetch from local storage + var rawFavorites = JSON.parse(corePreferences('preset_favorites')); - while (i < nodes.length && nodes.length > 2 && nodes[i] === connector) { - nodes.splice(i, 1); - if (index > i) index--; - } // trailing connectors.. + if (!rawFavorites) { + rawFavorites = []; + corePreferences('preset_favorites', JSON.stringify(rawFavorites)); + } + _favorites = rawFavorites.reduce(function (output, d) { + var item = ribbonItemForMinified(d, 'favorite'); + if (item && item.preset.addable()) output.push(item); + return output; + }, []); + } - i = nodes.length - 1; + return _favorites; + }; - while (i > 0 && nodes.length > 1 && nodes[i] === connector) { - nodes.splice(i, 1); - if (index === i) index = 0; // update leading connector instead + _this.favoriteMatching = function (preset) { + var favs = _this.getFavorites(); - i = nodes.length - 1; + for (var index in favs) { + if (favs[index].matches(preset)) { + return favs[index]; } } - nodes.splice(index, 1, id); - nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. + return null; + }; - if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { - nodes.push(nodes[0]); - } + return utilRebind(_this, dispatch, 'on'); + } - return this.update({ - nodes: nodes - }); - }, - // Replaces each occurrence of node id needle with replacement. - // Consecutive duplicates are eliminated including existing ones. - // Circularity is preserved. - replaceNode: function replaceNode(needleID, replacementID) { - var nodes = this.nodes.slice(); - var isClosed = this.isClosed(); - - for (var i = 0; i < nodes.length; i++) { - if (nodes[i] === needleID) { - nodes[i] = replacementID; - } - } + function utilTagText(entity) { + var obj = entity && entity.tags || {}; + return Object.keys(obj).map(function (k) { + return k + '=' + obj[k]; + }).join(', '); + } + function utilTotalExtent(array, graph) { + var extent = geoExtent(); + var val, entity; - nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. + for (var i = 0; i < array.length; i++) { + val = array[i]; + entity = typeof val === 'string' ? graph.hasEntity(val) : val; - if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { - nodes.push(nodes[0]); + if (entity) { + extent._extend(entity.extent(graph)); } + } - return this.update({ - nodes: nodes - }); - }, - // Removes each occurrence of node id. - // Consecutive duplicates are eliminated including existing ones. - // Circularity is preserved. - removeNode: function removeNode(id) { - var nodes = this.nodes.slice(); - var isClosed = this.isClosed(); - nodes = nodes.filter(function (node) { - return node !== id; - }).filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. + return extent; + } + function utilTagDiff(oldTags, newTags) { + var tagDiff = []; + var keys = utilArrayUnion(Object.keys(oldTags), Object.keys(newTags)).sort(); + keys.forEach(function (k) { + var oldVal = oldTags[k]; + var newVal = newTags[k]; - if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { - nodes.push(nodes[0]); + if ((oldVal || oldVal === '') && (newVal === undefined || newVal !== oldVal)) { + tagDiff.push({ + type: '-', + key: k, + oldVal: oldVal, + newVal: newVal, + display: '- ' + k + '=' + oldVal + }); } - return this.update({ - nodes: nodes - }); - }, - asJXON: function asJXON(changeset_id) { - var r = { - way: { - '@id': this.osmId(), - '@version': this.version || 0, - nd: this.nodes.map(function (id) { - return { - keyAttributes: { - ref: osmEntity.id.toOSM(id) - } - }; - }, this), - tag: Object.keys(this.tags).map(function (k) { - return { - keyAttributes: { - k: k, - v: this.tags[k] - } - }; - }, this) - } - }; - - if (changeset_id) { - r.way['@changeset'] = changeset_id; + if ((newVal || newVal === '') && (oldVal === undefined || newVal !== oldVal)) { + tagDiff.push({ + type: '+', + key: k, + oldVal: oldVal, + newVal: newVal, + display: '+ ' + k + '=' + newVal + }); } + }); + return tagDiff; + } + function utilEntitySelector(ids) { + return ids.length ? '.' + ids.join(',.') : 'nothing'; + } // returns an selector to select entity ids for: + // - entityIDs passed in + // - shallow descendant entityIDs for any of those entities that are relations - return r; - }, - asGeoJSON: function asGeoJSON(resolver) { - return resolver["transient"](this, 'GeoJSON', function () { - var coordinates = resolver.childNodes(this).map(function (n) { - return n.loc; - }); + function utilEntityOrMemberSelector(ids, graph) { + var seen = new Set(ids); + ids.forEach(collectShallowDescendants); + return utilEntitySelector(Array.from(seen)); - if (this.isArea() && this.isClosed()) { - return { - type: 'Polygon', - coordinates: [coordinates] - }; - } else { - return { - type: 'LineString', - coordinates: coordinates - }; - } + function collectShallowDescendants(id) { + var entity = graph.hasEntity(id); + if (!entity || entity.type !== 'relation') return; + entity.members.map(function (member) { + return member.id; + }).forEach(function (id) { + seen.add(id); }); - }, - area: function area(resolver) { - return resolver["transient"](this, 'area', function () { - var nodes = resolver.childNodes(this); - var json = { - type: 'Polygon', - coordinates: [nodes.map(function (n) { - return n.loc; - })] - }; - - if (!this.isClosed() && nodes.length) { - json.coordinates[0].push(nodes[0].loc); - } + } + } // returns an selector to select entity ids for: + // - entityIDs passed in + // - deep descendant entityIDs for any of those entities that are relations - var area = d3_geoArea(json); // Heuristic for detecting counterclockwise winding order. Assumes - // that OpenStreetMap polygons are not hemisphere-spanning. + function utilEntityOrDeepMemberSelector(ids, graph) { + return utilEntitySelector(utilEntityAndDeepMemberIDs(ids, graph)); + } // returns an selector to select entity ids for: + // - entityIDs passed in + // - deep descendant entityIDs for any of those entities that are relations - if (area > 2 * Math.PI) { - json.coordinates[0] = json.coordinates[0].reverse(); - area = d3_geoArea(json); - } + function utilEntityAndDeepMemberIDs(ids, graph) { + var seen = new Set(); + ids.forEach(collectDeepDescendants); + return Array.from(seen); - return isNaN(area) ? 0 : area; - }); + function collectDeepDescendants(id) { + if (seen.has(id)) return; + seen.add(id); + var entity = graph.hasEntity(id); + if (!entity || entity.type !== 'relation') return; + entity.members.map(function (member) { + return member.id; + }).forEach(collectDeepDescendants); // recurse } - }); // Filter function to eliminate consecutive duplicates. + } // returns an selector to select entity ids for: + // - deep descendant entityIDs for any of those entities that are relations - function noRepeatNodes(node, i, arr) { - return i === 0 || node !== arr[i - 1]; - } + function utilDeepMemberSelector(ids, graph, skipMultipolgonMembers) { + var idsSet = new Set(ids); + var seen = new Set(); + var returners = new Set(); + ids.forEach(collectDeepDescendants); + return utilEntitySelector(Array.from(returners)); - // - // 1. Relation tagged with `type=multipolygon` and no interesting tags. - // 2. One and only one member with the `outer` role. Must be a way with interesting tags. - // 3. No members without a role. - // - // Old multipolygons are no longer recommended but are still rendered as areas by iD. + function collectDeepDescendants(id) { + if (seen.has(id)) return; + seen.add(id); - function osmOldMultipolygonOuterMemberOfRelation(entity, graph) { - if (entity.type !== 'relation' || !entity.isMultipolygon() || Object.keys(entity.tags).filter(osmIsInterestingTag).length > 1) { - return false; + if (!idsSet.has(id)) { + returners.add(id); + } + + var entity = graph.hasEntity(id); + if (!entity || entity.type !== 'relation') return; + if (skipMultipolgonMembers && entity.isMultipolygon()) return; + entity.members.map(function (member) { + return member.id; + }).forEach(collectDeepDescendants); // recurse } + } // Adds or removes highlight styling for the specified entities - var outerMember; + function utilHighlightEntities(ids, highlighted, context) { + context.surface().selectAll(utilEntityOrDeepMemberSelector(ids, context.graph())).classed('highlighted', highlighted); + } // returns an Array that is the union of: + // - nodes for any nodeIDs passed in + // - child nodes of any wayIDs passed in + // - descendant member and child nodes of relationIDs passed in - for (var memberIndex in entity.members) { - var member = entity.members[memberIndex]; + function utilGetAllNodes(ids, graph) { + var seen = new Set(); + var nodes = new Set(); + ids.forEach(collectNodes); + return Array.from(nodes); - if (!member.role || member.role === 'outer') { - if (outerMember) return false; - if (member.type !== 'way') return false; - if (!graph.hasEntity(member.id)) return false; - outerMember = graph.entity(member.id); + function collectNodes(id) { + if (seen.has(id)) return; + seen.add(id); + var entity = graph.hasEntity(id); + if (!entity) return; - if (Object.keys(outerMember.tags).filter(osmIsInterestingTag).length === 0) { - return false; - } + if (entity.type === 'node') { + nodes.add(entity); + } else if (entity.type === 'way') { + entity.nodes.forEach(collectNodes); + } else { + entity.members.map(function (member) { + return member.id; + }).forEach(collectNodes); // recurse } } + } + function utilDisplayName(entity) { + var localizedNameKey = 'name:' + _mainLocalizer.languageCode().toLowerCase(); + var name = entity.tags[localizedNameKey] || entity.tags.name || ''; + if (name) return name; + var tags = { + direction: entity.tags.direction, + from: entity.tags.from, + network: entity.tags.cycle_network || entity.tags.network, + ref: entity.tags.ref, + to: entity.tags.to, + via: entity.tags.via + }; + var keyComponents = []; - return outerMember; - } // For fixing up rendering of multipolygons with tags on the outer member. - // https://github.com/openstreetmap/iD/issues/613 - - function osmIsOldMultipolygonOuterMember(entity, graph) { - if (entity.type !== 'way' || Object.keys(entity.tags).filter(osmIsInterestingTag).length === 0) { - return false; + if (tags.network) { + keyComponents.push('network'); } - var parents = graph.parentRelations(entity); - if (parents.length !== 1) return false; - var parent = parents[0]; - - if (!parent.isMultipolygon() || Object.keys(parent.tags).filter(osmIsInterestingTag).length > 1) { - return false; - } + if (tags.ref) { + keyComponents.push('ref'); + } // Routes may need more disambiguation based on direction or destination - var members = parent.members, - member; - for (var i = 0; i < members.length; i++) { - member = members[i]; + if (entity.tags.route) { + if (tags.direction) { + keyComponents.push('direction'); + } else if (tags.from && tags.to) { + keyComponents.push('from'); + keyComponents.push('to'); - if (member.id === entity.id && member.role && member.role !== 'outer') { - // Not outer member - return false; + if (tags.via) { + keyComponents.push('via'); + } } + } - if (member.id !== entity.id && (!member.role || member.role === 'outer')) { - // Not a simple multipolygon - return false; - } + if (keyComponents.length) { + name = _t('inspector.display_name.' + keyComponents.join('_'), tags); } - return parent; + return name; } - function osmOldMultipolygonOuterMember(entity, graph) { - if (entity.type !== 'way') return false; - var parents = graph.parentRelations(entity); - if (parents.length !== 1) return false; - var parent = parents[0]; + function utilDisplayNameForPath(entity) { + var name = utilDisplayName(entity); + var isFirefox = utilDetect().browser.toLowerCase().indexOf('firefox') > -1; + var isNewChromium = Number(utilDetect().version.split('.')[0]) >= 96.0; - if (!parent.isMultipolygon() || Object.keys(parent.tags).filter(osmIsInterestingTag).length > 1) { - return false; + if (!isFirefox && !isNewChromium && name && rtlRegex.test(name)) { + name = fixRTLTextForSvg(name); } - var members = parent.members, - member, - outerMember; + return name; + } + function utilDisplayType(id) { + return { + n: _t('inspector.node'), + w: _t('inspector.way'), + r: _t('inspector.relation') + }[id.charAt(0)]; + } // `utilDisplayLabel` + // Returns a string suitable for display + // By default returns something like name/ref, fallback to preset type, fallback to OSM type + // "Main Street" or "Tertiary Road" + // If `verbose=true`, include both preset name and feature name. + // "Tertiary Road Main Street" + // - for (var i = 0; i < members.length; i++) { - member = members[i]; + function utilDisplayLabel(entity, graphOrGeometry, verbose) { + var result; + var displayName = utilDisplayName(entity); + var preset = typeof graphOrGeometry === 'string' ? _mainPresetIndex.matchTags(entity.tags, graphOrGeometry) : _mainPresetIndex.match(entity, graphOrGeometry); + var presetName = preset && (preset.suggestion ? preset.subtitle() : preset.name()); - if (!member.role || member.role === 'outer') { - if (outerMember) return false; // Not a simple multipolygon + if (verbose) { + result = [presetName, displayName].filter(Boolean).join(' '); + } else { + result = displayName || presetName; + } // Fallback to the OSM type (node/way/relation) - outerMember = member; - } - } - if (!outerMember) return false; - var outerEntity = graph.hasEntity(outerMember.id); + return result || utilDisplayType(entity.id); + } + function utilEntityRoot(entityType) { + return { + node: 'n', + way: 'w', + relation: 'r' + }[entityType]; + } // Returns a single object containing the tags of all the given entities. + // Example: + // { + // highway: 'service', + // service: 'parking_aisle' + // } + // + + // { + // highway: 'service', + // service: 'driveway', + // width: '3' + // } + // = + // { + // highway: 'service', + // service: [ 'driveway', 'parking_aisle' ], + // width: [ '3', undefined ] + // } - if (!outerEntity || !Object.keys(outerEntity.tags).filter(osmIsInterestingTag).length) { - return false; - } + function utilCombinedTags(entityIDs, graph) { + var tags = {}; + var tagCounts = {}; + var allKeys = new Set(); + var entities = entityIDs.map(function (entityID) { + return graph.hasEntity(entityID); + }).filter(Boolean); // gather the aggregate keys - return outerEntity; - } // Join `toJoin` array into sequences of connecting ways. - // Segments which share identical start/end nodes will, as much as possible, - // be connected with each other. - // - // The return value is a nested array. Each constituent array contains elements - // of `toJoin` which have been determined to connect. - // - // Each consitituent array also has a `nodes` property whose value is an - // ordered array of member nodes, with appropriate order reversal and - // start/end coordinate de-duplication. - // - // Members of `toJoin` must have, at minimum, `type` and `id` properties. - // Thus either an array of `osmWay`s or a relation member array may be used. - // - // If an member is an `osmWay`, its tags and childnodes may be reversed via - // `actionReverse` in the output. - // - // The returned sequences array also has an `actions` array property, containing - // any reversal actions that should be applied to the graph, should the calling - // code attempt to actually join the given ways. - // - // Incomplete members (those for which `graph.hasEntity(element.id)` returns - // false) and non-way members are ignored. - // + entities.forEach(function (entity) { + var keys = Object.keys(entity.tags).filter(Boolean); + keys.forEach(function (key) { + allKeys.add(key); + }); + }); + entities.forEach(function (entity) { + allKeys.forEach(function (key) { + var value = entity.tags[key]; // purposely allow `undefined` - function osmJoinWays(toJoin, graph) { - function resolve(member) { - return graph.childNodes(graph.entity(member.id)); - } + if (!tags.hasOwnProperty(key)) { + // first value, set as raw + tags[key] = value; + } else { + if (!Array.isArray(tags[key])) { + if (tags[key] !== value) { + // first alternate value, replace single value with array + tags[key] = [tags[key], value]; + } + } else { + // type is array + if (tags[key].indexOf(value) === -1) { + // subsequent alternate value, add to array + tags[key].push(value); + } + } + } - function reverse(item) { - var action = actionReverse(item.id, { - reverseOneway: true + var tagHash = key + '=' + value; + if (!tagCounts[tagHash]) tagCounts[tagHash] = 0; + tagCounts[tagHash] += 1; }); - sequences.actions.push(action); - return item instanceof osmWay ? action(graph).entity(item.id) : item; - } // make a copy containing only the items to join + }); + for (var key in tags) { + if (!Array.isArray(tags[key])) continue; // sort values by frequency then alphabetically - toJoin = toJoin.filter(function (member) { - return member.type === 'way' && graph.hasEntity(member.id); - }); // Are the things we are joining relation members or `osmWays`? - // If `osmWays`, skip the "prefer a forward path" code below (see #4872) + tags[key] = tags[key].sort(function (val1, val2) { + var key = key; // capture - var i; - var joinAsMembers = true; + var count2 = tagCounts[key + '=' + val2]; + var count1 = tagCounts[key + '=' + val1]; - for (i = 0; i < toJoin.length; i++) { - if (toJoin[i] instanceof osmWay) { - joinAsMembers = false; - break; - } - } + if (count2 !== count1) { + return count2 - count1; + } - var sequences = []; - sequences.actions = []; + if (val2 && val1) { + return val1.localeCompare(val2); + } - while (toJoin.length) { - // start a new sequence - var item = toJoin.shift(); - var currWays = [item]; - var currNodes = resolve(item).slice(); // add to it + return val1 ? 1 : -1; + }); + } - while (toJoin.length) { - var start = currNodes[0]; - var end = currNodes[currNodes.length - 1]; - var fn = null; - var nodes = null; // Find the next way/member to join. + return tags; + } + function utilStringQs(str) { + var i = 0; // advance past any leading '?' or '#' characters - for (i = 0; i < toJoin.length; i++) { - item = toJoin[i]; - nodes = resolve(item); // (for member ordering only, not way ordering - see #4872) - // Strongly prefer to generate a forward path that preserves the order - // of the members array. For multipolygons and most relations, member - // order does not matter - but for routes, it does. (see #4589) - // If we started this sequence backwards (i.e. next member way attaches to - // the start node and not the end node), reverse the initial way before continuing. + while (i < str.length && (str[i] === '?' || str[i] === '#')) { + i++; + } - if (joinAsMembers && currWays.length === 1 && nodes[0] !== end && nodes[nodes.length - 1] !== end && (nodes[nodes.length - 1] === start || nodes[0] === start)) { - currWays[0] = reverse(currWays[0]); - currNodes.reverse(); - start = currNodes[0]; - end = currNodes[currNodes.length - 1]; - } - - if (nodes[0] === end) { - fn = currNodes.push; // join to end - - nodes = nodes.slice(1); - break; - } else if (nodes[nodes.length - 1] === end) { - fn = currNodes.push; // join to end - - nodes = nodes.slice(0, -1).reverse(); - item = reverse(item); - break; - } else if (nodes[nodes.length - 1] === start) { - fn = currNodes.unshift; // join to beginning - - nodes = nodes.slice(0, -1); - break; - } else if (nodes[0] === start) { - fn = currNodes.unshift; // join to beginning - - nodes = nodes.slice(1).reverse(); - item = reverse(item); - break; - } else { - fn = nodes = null; - } - } - - if (!nodes) { - // couldn't find a joinable way/member - break; - } + str = str.slice(i); + return str.split('&').reduce(function (obj, pair) { + var parts = pair.split('='); - fn.apply(currWays, [item]); - fn.apply(currNodes, nodes); - toJoin.splice(i, 1); + if (parts.length === 2) { + obj[parts[0]] = null === parts[1] ? '' : decodeURIComponent(parts[1]); } - currWays.nodes = currNodes; - sequences.push(currWays); + return obj; + }, {}); + } + function utilQsString(obj, noencode) { + // encode everything except special characters used in certain hash parameters: + // "/" in map states, ":", ",", {" and "}" in background + function softEncode(s) { + return encodeURIComponent(s).replace(/(%2F|%3A|%2C|%7B|%7D)/g, decodeURIComponent); } - return sequences; + return Object.keys(obj).sort().map(function (key) { + return encodeURIComponent(key) + '=' + (noencode ? softEncode(obj[key]) : encodeURIComponent(obj[key])); + }).join('&'); } + function utilPrefixDOMProperty(property) { + var prefixes = ['webkit', 'ms', 'moz', 'o']; + var i = -1; + var n = prefixes.length; + var s = document.body; + if (property in s) return property; + property = property.substr(0, 1).toUpperCase() + property.substr(1); - function actionAddMember(relationId, member, memberIndex, insertPair) { - return function action(graph) { - var relation = graph.entity(relationId); // There are some special rules for Public Transport v2 routes. + while (++i < n) { + if (prefixes[i] + property in s) { + return prefixes[i] + property; + } + } - var isPTv2 = /stop|platform/.test(member.role); + return false; + } + function utilPrefixCSSProperty(property) { + var prefixes = ['webkit', 'ms', 'Moz', 'O']; + var i = -1; + var n = prefixes.length; + var s = document.body.style; - if ((isNaN(memberIndex) || insertPair) && member.type === 'way' && !isPTv2) { - // Try to perform sensible inserts based on how the ways join together - graph = addWayMember(relation, graph); - } else { - // see https://wiki.openstreetmap.org/wiki/Public_transport#Service_routes - // Stops and Platforms for PTv2 should be ordered first. - // hack: We do not currently have the ability to place them in the exactly correct order. - if (isPTv2 && isNaN(memberIndex)) { - memberIndex = 0; - } + if (property.toLowerCase() in s) { + return property.toLowerCase(); + } - graph = graph.replace(relation.addMember(member, memberIndex)); + while (++i < n) { + if (prefixes[i] + property in s) { + return '-' + prefixes[i].toLowerCase() + property.replace(/([A-Z])/g, '-$1').toLowerCase(); } + } - return graph; - }; // Add a way member into the relation "wherever it makes sense". - // In this situation we were not supplied a memberIndex. + return false; + } + var transformProperty; + function utilSetTransform(el, x, y, scale) { + var prop = transformProperty = transformProperty || utilPrefixCSSProperty('Transform'); + var translate = utilDetect().opera ? 'translate(' + x + 'px,' + y + 'px)' : 'translate3d(' + x + 'px,' + y + 'px,0)'; + return el.style(prop, translate + (scale ? ' scale(' + scale + ')' : '')); + } // Calculates Levenshtein distance between two strings + // see: https://en.wikipedia.org/wiki/Levenshtein_distance + // first converts the strings to lowercase and replaces diacritic marks with ascii equivalents. - function addWayMember(relation, graph) { - var groups, tempWay, item, i, j, k; // remove PTv2 stops and platforms before doing anything. + function utilEditDistance(a, b) { + a = remove$6(a.toLowerCase()); + b = remove$6(b.toLowerCase()); + if (a.length === 0) return b.length; + if (b.length === 0) return a.length; + var matrix = []; + var i, j; - var PTv2members = []; - var members = []; + for (i = 0; i <= b.length; i++) { + matrix[i] = [i]; + } - for (i = 0; i < relation.members.length; i++) { - var m = relation.members[i]; + for (j = 0; j <= a.length; j++) { + matrix[0][j] = j; + } - if (/stop|platform/.test(m.role)) { - PTv2members.push(m); + for (i = 1; i <= b.length; i++) { + for (j = 1; j <= a.length; j++) { + if (b.charAt(i - 1) === a.charAt(j - 1)) { + matrix[i][j] = matrix[i - 1][j - 1]; } else { - members.push(m); + matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution + Math.min(matrix[i][j - 1] + 1, // insertion + matrix[i - 1][j] + 1)); // deletion } } + } - relation = relation.update({ - members: members + return matrix[b.length][a.length]; + } // a d3.mouse-alike which + // 1. Only works on HTML elements, not SVG + // 2. Does not cause style recalculation + + function utilFastMouse(container) { + var rect = container.getBoundingClientRect(); + var rectLeft = rect.left; + var rectTop = rect.top; + var clientLeft = +container.clientLeft; + var clientTop = +container.clientTop; + return function (e) { + return [e.clientX - rectLeft - clientLeft, e.clientY - rectTop - clientTop]; + }; + } + function utilAsyncMap(inputs, func, callback) { + var remaining = inputs.length; + var results = []; + var errors = []; + inputs.forEach(function (d, i) { + func(d, function done(err, data) { + errors[i] = err; + results[i] = data; + remaining--; + if (!remaining) callback(errors, results); }); + }); + } // wraps an index to an interval [0..length-1] - if (insertPair) { - // We're adding a member that must stay paired with an existing member. - // (This feature is used by `actionSplit`) - // - // This is tricky because the members may exist multiple times in the - // member list, and with different A-B/B-A ordering and different roles. - // (e.g. a bus route that loops out and back - #4589). - // - // Replace the existing member with a temporary way, - // so that `osmJoinWays` can treat the pair like a single way. - tempWay = osmWay({ - id: 'wTemp', - nodes: insertPair.nodes - }); - graph = graph.replace(tempWay); - var tempMember = { - id: tempWay.id, - type: 'way', - role: member.role - }; - var tempRelation = relation.replaceMember({ - id: insertPair.originalID - }, tempMember, true); - groups = utilArrayGroupBy(tempRelation.members, 'type'); - groups.way = groups.way || []; - } else { - // Add the member anywhere, one time. Just push and let `osmJoinWays` decide where to put it. - groups = utilArrayGroupBy(relation.members, 'type'); - groups.way = groups.way || []; - groups.way.push(member); - } + function utilWrap(index, length) { + if (index < 0) { + index += Math.ceil(-index / length) * length; + } - members = withIndex(groups.way); - var joined = osmJoinWays(members, graph); // `joined` might not contain all of the way members, - // But will contain only the completed (downloaded) members + return index % length; + } + /** + * a replacement for functor + * + * @param {*} value any value + * @returns {Function} a function that returns that value or the value if it's a function + */ - for (i = 0; i < joined.length; i++) { - var segment = joined[i]; - var nodes = segment.nodes.slice(); - var startIndex = segment[0].index; // j = array index in `members` where this segment starts + function utilFunctor(value) { + if (typeof value === 'function') return value; + return function () { + return value; + }; + } + function utilNoAuto(selection) { + var isText = selection.size() && selection.node().tagName.toLowerCase() === 'textarea'; + return selection // assign 'new-password' even for non-password fields to prevent browsers (Chrome) ignoring 'off' + .attr('autocomplete', 'new-password').attr('autocorrect', 'off').attr('autocapitalize', 'off').attr('spellcheck', isText ? 'true' : 'false'); + } // https://stackoverflow.com/questions/194846/is-there-any-kind-of-hash-code-function-in-javascript + // https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/ - for (j = 0; j < members.length; j++) { - if (members[j].index === startIndex) { - break; - } - } // k = each member in segment + function utilHashcode(str) { + var hash = 0; + if (str.length === 0) { + return hash; + } - for (k = 0; k < segment.length; k++) { - item = segment[k]; - var way = graph.entity(item.id); // If this is a paired item, generate members in correct order and role + for (var i = 0; i < str.length; i++) { + var _char = str.charCodeAt(i); - if (tempWay && item.id === tempWay.id) { - if (nodes[0].id === insertPair.nodes[0]) { - item.pair = [{ - id: insertPair.originalID, - type: 'way', - role: item.role - }, { - id: insertPair.insertedID, - type: 'way', - role: item.role - }]; - } else { - item.pair = [{ - id: insertPair.insertedID, - type: 'way', - role: item.role - }, { - id: insertPair.originalID, - type: 'way', - role: item.role - }]; - } - } // reorder `members` if necessary + hash = (hash << 5) - hash + _char; + hash = hash & hash; // Convert to 32bit integer + } + return hash; + } // Returns version of `str` with all runs of special characters replaced by `_`; + // suitable for HTML ids, classes, selectors, etc. - if (k > 0) { - if (j + k >= members.length || item.index !== members[j + k].index) { - moveMember(members, item.index, j + k); - } - } + function utilSafeClassName(str) { + return str.toLowerCase().replace(/[^a-z0-9]+/g, '_'); + } // Returns string based on `val` that is highly unlikely to collide with an id + // used previously or that's present elsewhere in the document. Useful for preventing + // browser-provided autofills or when embedding iD on pages with unknown elements. - nodes.splice(0, way.nodes.length - 1); - } - } + function utilUniqueDomId(val) { + return 'ideditor-' + utilSafeClassName(val.toString()) + '-' + new Date().getTime().toString(); + } // Returns the length of `str` in unicode characters. This can be less than + // `String.length()` since a single unicode character can be composed of multiple + // JavaScript UTF-16 code units. - if (tempWay) { - graph = graph.remove(tempWay); - } // Final pass: skip dead items, split pairs, remove index properties + function utilUnicodeCharsCount(str) { + // Native ES2015 implementations of `Array.from` split strings into unicode characters + return Array.from(str).length; + } // Returns a new string representing `str` cut from its start to `limit` length + // in unicode characters. Note that this runs the risk of splitting graphemes. + function utilUnicodeCharsTruncated(str, limit) { + return Array.from(str).slice(0, limit).join(''); + } - var wayMembers = []; + function toNumericID(id) { + var match = id.match(/^[cnwr](-?\d+)$/); - for (i = 0; i < members.length; i++) { - item = members[i]; - if (item.index === -1) continue; + if (match) { + return parseInt(match[1], 10); + } - if (item.pair) { - wayMembers.push(item.pair[0]); - wayMembers.push(item.pair[1]); - } else { - wayMembers.push(utilObjectOmit(item, ['index'])); - } - } // Put stops and platforms first, then nodes, ways, relations - // This is recommended for Public Transport v2 routes: - // see https://wiki.openstreetmap.org/wiki/Public_transport#Service_routes + return NaN; + } + function compareNumericIDs(left, right) { + if (isNaN(left) && isNaN(right)) return -1; + if (isNaN(left)) return 1; + if (isNaN(right)) return -1; + if (Math.sign(left) !== Math.sign(right)) return -Math.sign(left); + if (Math.sign(left) < 0) return Math.sign(right - left); + return Math.sign(left - right); + } // Returns -1 if the first parameter ID is older than the second, + // 1 if the second parameter is older, 0 if they are the same. + // If both IDs are test IDs, the function returns -1. - var newMembers = PTv2members.concat(groups.node || [], wayMembers, groups.relation || []); - return graph.replace(relation.update({ - members: newMembers - })); // `moveMember()` changes the `members` array in place by splicing - // the item with `.index = findIndex` to where it belongs, - // and marking the old position as "dead" with `.index = -1` - // - // j=5, k=0 jk - // segment 5 4 7 6 - // members 0 1 2 3 4 5 6 7 8 9 keep 5 in j+k - // - // j=5, k=1 j k - // segment 5 4 7 6 - // members 0 1 2 3 4 5 6 7 8 9 move 4 to j+k - // members 0 1 2 3 x 5 4 6 7 8 9 moved - // - // j=5, k=2 j k - // segment 5 4 7 6 - // members 0 1 2 3 x 5 4 6 7 8 9 move 7 to j+k - // members 0 1 2 3 x 5 4 7 6 x 8 9 moved - // - // j=5, k=3 j k - // segment 5 4 7 6 - // members 0 1 2 3 x 5 4 7 6 x 8 9 keep 6 in j+k - // - function moveMember(arr, findIndex, toIndex) { - var i; + function utilCompareIDs(left, right) { + return compareNumericIDs(toNumericID(left), toNumericID(right)); + } // Returns the chronologically oldest ID in the list. + // Database IDs (with positive numbers) before editor ones (with negative numbers). + // Among each category, the closest number to 0 is the oldest. + // Test IDs (any string that does not conform to OSM's ID scheme) are taken last. - for (i = 0; i < arr.length; i++) { - if (arr[i].index === findIndex) { - break; - } - } + function utilOldestID(ids) { + if (ids.length === 0) { + return undefined; + } - var item = Object.assign({}, arr[i]); // shallow copy + var oldestIDIndex = 0; + var oldestID = toNumericID(ids[0]); - arr[i].index = -1; // mark as dead + for (var i = 1; i < ids.length; i++) { + var num = toNumericID(ids[i]); - item.index = toIndex; - arr.splice(toIndex, 0, item); - } // This is the same as `Relation.indexedMembers`, - // Except we don't want to index all the members, only the ways + if (compareNumericIDs(oldestID, num) === 1) { + oldestIDIndex = i; + oldestID = num; + } + } + return ids[oldestIDIndex]; + } - function withIndex(arr) { - var result = new Array(arr.length); + function osmEntity(attrs) { + // For prototypal inheritance. + if (this instanceof osmEntity) return; // Create the appropriate subtype. - for (var i = 0; i < arr.length; i++) { - result[i] = Object.assign({}, arr[i]); // shallow copy + if (attrs && attrs.type) { + return osmEntity[attrs.type].apply(this, arguments); + } else if (attrs && attrs.id) { + return osmEntity[osmEntity.id.type(attrs.id)].apply(this, arguments); + } // Initialize a generic Entity (used only in tests). - result[i].index = i; - } - return result; - } - } + return new osmEntity().initialize(arguments); } - function actionAddMidpoint(midpoint, node) { - return function (graph) { - graph = graph.replace(node.move(midpoint.loc)); - var parents = utilArrayIntersection(graph.parentWays(graph.entity(midpoint.edge[0])), graph.parentWays(graph.entity(midpoint.edge[1]))); - parents.forEach(function (way) { - for (var i = 0; i < way.nodes.length - 1; i++) { - if (geoEdgeEqual([way.nodes[i], way.nodes[i + 1]], midpoint.edge)) { - graph = graph.replace(graph.entity(way.id).addNode(node.id, i + 1)); // Add only one midpoint on doubled-back segments, - // turning them into self-intersections. + osmEntity.id = function (type) { + return osmEntity.id.fromOSM(type, osmEntity.id.next[type]--); + }; - return; - } - } - }); - return graph; - }; - } + osmEntity.id.next = { + changeset: -1, + node: -1, + way: -1, + relation: -1 + }; - // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/AddNodeToWayAction.as - function actionAddVertex(wayId, nodeId, index) { - return function (graph) { - return graph.replace(graph.entity(wayId).addNode(nodeId, index)); - }; - } + osmEntity.id.fromOSM = function (type, id) { + return type[0] + id; + }; - function actionChangeMember(relationId, member, memberIndex) { - return function (graph) { - return graph.replace(graph.entity(relationId).updateMember(member, memberIndex)); - }; - } + osmEntity.id.toOSM = function (id) { + var match = id.match(/^[cnwr](-?\d+)$/); - function actionChangePreset(entityID, oldPreset, newPreset, skipFieldDefaults) { - return function action(graph) { - var entity = graph.entity(entityID); - var geometry = entity.geometry(graph); - var tags = entity.tags; // preserve tags that the new preset might care about, if any + if (match) { + return match[1]; + } - if (oldPreset) tags = oldPreset.unsetTags(tags, geometry, newPreset && newPreset.addTags ? Object.keys(newPreset.addTags) : null); - if (newPreset) tags = newPreset.setTags(tags, geometry, skipFieldDefaults); - return graph.replace(entity.update({ - tags: tags - })); - }; - } + return ''; + }; - function actionChangeTags(entityId, tags) { - return function (graph) { - var entity = graph.entity(entityId); - return graph.replace(entity.update({ - tags: tags - })); - }; - } + osmEntity.id.type = function (id) { + return { + 'c': 'changeset', + 'n': 'node', + 'w': 'way', + 'r': 'relation' + }[id[0]]; + }; // A function suitable for use as the second argument to d3.selection#data(). - function osmNode() { - if (!(this instanceof osmNode)) { - return new osmNode().initialize(arguments); - } else if (arguments.length) { - this.initialize(arguments); - } - } - osmEntity.node = osmNode; - osmNode.prototype = Object.create(osmEntity.prototype); - Object.assign(osmNode.prototype, { - type: 'node', - loc: [9999, 9999], - extent: function extent() { - return new geoExtent(this.loc); - }, - geometry: function geometry(graph) { - return graph["transient"](this, 'geometry', function () { - return graph.isPoi(this) ? 'point' : 'vertex'; - }); - }, - move: function move(loc) { - return this.update({ - loc: loc - }); - }, - isDegenerate: function isDegenerate() { - return !(Array.isArray(this.loc) && this.loc.length === 2 && this.loc[0] >= -180 && this.loc[0] <= 180 && this.loc[1] >= -90 && this.loc[1] <= 90); - }, - // Inspect tags and geometry to determine which direction(s) this node/vertex points - directions: function directions(resolver, projection) { - var val; - var i; // which tag to use? - if (this.isHighwayIntersection(resolver) && (this.tags.stop || '').toLowerCase() === 'all') { - // all-way stop tag on a highway intersection - val = 'all'; - } else { - // generic direction tag - val = (this.tags.direction || '').toLowerCase(); // better suffix-style direction tag + osmEntity.key = function (entity) { + return entity.id + 'v' + (entity.v || 0); + }; - var re = /:direction$/i; - var keys = Object.keys(this.tags); + var _deprecatedTagValuesByKey; - for (i = 0; i < keys.length; i++) { - if (re.test(keys[i])) { - val = this.tags[keys[i]].toLowerCase(); - break; + osmEntity.deprecatedTagValuesByKey = function (dataDeprecated) { + if (!_deprecatedTagValuesByKey) { + _deprecatedTagValuesByKey = {}; + dataDeprecated.forEach(function (d) { + var oldKeys = Object.keys(d.old); + + if (oldKeys.length === 1) { + var oldKey = oldKeys[0]; + var oldValue = d.old[oldKey]; + + if (oldValue !== '*') { + if (!_deprecatedTagValuesByKey[oldKey]) { + _deprecatedTagValuesByKey[oldKey] = [oldValue]; + } else { + _deprecatedTagValuesByKey[oldKey].push(oldValue); + } } } - } + }); + } - if (val === '') return []; - var cardinal = { - north: 0, - n: 0, - northnortheast: 22, - nne: 22, - northeast: 45, - ne: 45, - eastnortheast: 67, - ene: 67, - east: 90, - e: 90, - eastsoutheast: 112, - ese: 112, - southeast: 135, - se: 135, - southsoutheast: 157, - sse: 157, - south: 180, - s: 180, - southsouthwest: 202, - ssw: 202, - southwest: 225, - sw: 225, - westsouthwest: 247, - wsw: 247, - west: 270, - w: 270, - westnorthwest: 292, - wnw: 292, - northwest: 315, - nw: 315, - northnorthwest: 337, - nnw: 337 - }; - var values = val.split(';'); - var results = []; - values.forEach(function (v) { - // swap cardinal for numeric directions - if (cardinal[v] !== undefined) { - v = cardinal[v]; - } // numeric direction - just add to results + return _deprecatedTagValuesByKey; + }; + osmEntity.prototype = { + tags: {}, + initialize: function initialize(sources) { + for (var i = 0; i < sources.length; ++i) { + var source = sources[i]; - if (v !== '' && !isNaN(+v)) { - results.push(+v); - return; - } // string direction - inspect parent ways + for (var prop in source) { + if (Object.prototype.hasOwnProperty.call(source, prop)) { + if (source[prop] === undefined) { + delete this[prop]; + } else { + this[prop] = source[prop]; + } + } + } + } + if (!this.id && this.type) { + this.id = osmEntity.id(this.type); + } - var lookBackward = this.tags['traffic_sign:backward'] || v === 'backward' || v === 'both' || v === 'all'; - var lookForward = this.tags['traffic_sign:forward'] || v === 'forward' || v === 'both' || v === 'all'; - if (!lookForward && !lookBackward) return; - var nodeIds = {}; - resolver.parentWays(this).forEach(function (parent) { - var nodes = parent.nodes; + if (!this.hasOwnProperty('visible')) { + this.visible = true; + } - for (i = 0; i < nodes.length; i++) { - if (nodes[i] === this.id) { - // match current entity - if (lookForward && i > 0) { - nodeIds[nodes[i - 1]] = true; // look back to prev node - } + if (debug) { + Object.freeze(this); + Object.freeze(this.tags); + if (this.loc) Object.freeze(this.loc); + if (this.nodes) Object.freeze(this.nodes); + if (this.members) Object.freeze(this.members); + } - if (lookBackward && i < nodes.length - 1) { - nodeIds[nodes[i + 1]] = true; // look ahead to next node - } - } - } - }, this); - Object.keys(nodeIds).forEach(function (nodeId) { - // +90 because geoAngle returns angle from X axis, not Y (north) - results.push(geoAngle(this, resolver.entity(nodeId), projection) * (180 / Math.PI) + 90); - }, this); - }, this); - return utilArrayUniq(results); + return this; }, - isCrossing: function isCrossing() { - return this.tags.highway === 'crossing' || this.tags.railway && this.tags.railway.indexOf('crossing') !== -1; + copy: function copy(resolver, copies) { + if (copies[this.id]) return copies[this.id]; + var copy = osmEntity(this, { + id: undefined, + user: undefined, + version: undefined + }); + copies[this.id] = copy; + return copy; }, - isEndpoint: function isEndpoint(resolver) { - return resolver["transient"](this, 'isEndpoint', function () { - var id = this.id; - return resolver.parentWays(this).filter(function (parent) { - return !parent.isClosed() && !!parent.affix(id); - }).length > 0; + osmId: function osmId() { + return osmEntity.id.toOSM(this.id); + }, + isNew: function isNew() { + var osmId = osmEntity.id.toOSM(this.id); + return osmId.length === 0 || osmId[0] === '-'; + }, + update: function update(attrs) { + return osmEntity(this, attrs, { + v: 1 + (this.v || 0) }); }, - isConnected: function isConnected(resolver) { - return resolver["transient"](this, 'isConnected', function () { - var parents = resolver.parentWays(this); - - if (parents.length > 1) { - // vertex is connected to multiple parent ways - for (var i in parents) { - if (parents[i].geometry(resolver) === 'line' && parents[i].hasInterestingTags()) return true; - } - } else if (parents.length === 1) { - var way = parents[0]; - var nodes = way.nodes.slice(); + mergeTags: function mergeTags(tags) { + var merged = Object.assign({}, this.tags); // shallow copy - if (way.isClosed()) { - nodes.pop(); - } // ignore connecting node if closed - // return true if vertex appears multiple times (way is self intersecting) + var changed = false; + for (var k in tags) { + var t1 = merged[k]; + var t2 = tags[k]; - return nodes.indexOf(this.id) !== nodes.lastIndexOf(this.id); + if (!t1) { + changed = true; + merged[k] = t2; + } else if (t1 !== t2) { + changed = true; + merged[k] = utilUnicodeCharsTruncated(utilArrayUnion(t1.split(/;\s*/), t2.split(/;\s*/)).join(';'), 255 // avoid exceeding character limit; see also services/osm.js -> maxCharsForTagValue() + ); } + } - return false; - }); + return changed ? this.update({ + tags: merged + }) : this; }, - parentIntersectionWays: function parentIntersectionWays(resolver) { - return resolver["transient"](this, 'parentIntersectionWays', function () { - return resolver.parentWays(this).filter(function (parent) { - return (parent.tags.highway || parent.tags.waterway || parent.tags.railway || parent.tags.aeroway) && parent.geometry(resolver) === 'line'; - }); + intersects: function intersects(extent, resolver) { + return this.extent(resolver).intersects(extent); + }, + hasNonGeometryTags: function hasNonGeometryTags() { + return Object.keys(this.tags).some(function (k) { + return k !== 'area'; }); }, - isIntersection: function isIntersection(resolver) { - return this.parentIntersectionWays(resolver).length > 1; + hasParentRelations: function hasParentRelations(resolver) { + return resolver.parentRelations(this).length > 0; }, - isHighwayIntersection: function isHighwayIntersection(resolver) { - return resolver["transient"](this, 'isHighwayIntersection', function () { - return resolver.parentWays(this).filter(function (parent) { - return parent.tags.highway && parent.geometry(resolver) === 'line'; - }).length > 1; - }); + hasInterestingTags: function hasInterestingTags() { + return Object.keys(this.tags).some(osmIsInterestingTag); }, - isOnAddressLine: function isOnAddressLine(resolver) { - return resolver["transient"](this, 'isOnAddressLine', function () { - return resolver.parentWays(this).filter(function (parent) { - return parent.tags.hasOwnProperty('addr:interpolation') && parent.geometry(resolver) === 'line'; - }).length > 0; - }); + isHighwayIntersection: function isHighwayIntersection() { + return false; }, - asJXON: function asJXON(changeset_id) { - var r = { - node: { - '@id': this.osmId(), - '@lon': this.loc[0], - '@lat': this.loc[1], - '@version': this.version || 0, - tag: Object.keys(this.tags).map(function (k) { - return { - keyAttributes: { - k: k, - v: this.tags[k] - } - }; - }, this) - } - }; - if (changeset_id) r.node['@changeset'] = changeset_id; - return r; + isDegenerate: function isDegenerate() { + return true; }, - asGeoJSON: function asGeoJSON() { - return { - type: 'Point', - coordinates: this.loc - }; - } - }); - - function actionCircularize(wayId, projection, maxAngle) { - maxAngle = (maxAngle || 20) * Math.PI / 180; + deprecatedTags: function deprecatedTags(dataDeprecated) { + var tags = this.tags; // if there are no tags, none can be deprecated - var action = function action(graph, t) { - if (t === null || !isFinite(t)) t = 1; - t = Math.min(Math.max(+t, 0), 1); - var way = graph.entity(wayId); - var origNodes = {}; - graph.childNodes(way).forEach(function (node) { - if (!origNodes[node.id]) origNodes[node.id] = node; - }); + if (Object.keys(tags).length === 0) return []; + var deprecated = []; + dataDeprecated.forEach(function (d) { + var oldKeys = Object.keys(d.old); - if (!way.isConvex(graph)) { - graph = action.makeConvex(graph); - } + if (d.replace) { + var hasExistingValues = Object.keys(d.replace).some(function (replaceKey) { + if (!tags[replaceKey] || d.old[replaceKey]) return false; + var replaceValue = d.replace[replaceKey]; + if (replaceValue === '*') return false; + if (replaceValue === tags[replaceKey]) return false; + return true; + }); // don't flag deprecated tags if the upgrade path would overwrite existing data - #7843 - var nodes = utilArrayUniq(graph.childNodes(way)); - var keyNodes = nodes.filter(function (n) { - return graph.parentWays(n).length !== 1; - }); - var points = nodes.map(function (n) { - return projection(n.loc); - }); - var keyPoints = keyNodes.map(function (n) { - return projection(n.loc); - }); - var centroid = points.length === 2 ? geoVecInterp(points[0], points[1], 0.5) : d3_polygonCentroid(points); - var radius = d3_median(points, function (p) { - return geoVecLength(centroid, p); - }); - var sign = d3_polygonArea(points) > 0 ? 1 : -1; - var ids, i, j, k; // we need at least two key nodes for the algorithm to work + if (hasExistingValues) return; + } - if (!keyNodes.length) { - keyNodes = [nodes[0]]; - keyPoints = [points[0]]; - } + var matchesDeprecatedTags = oldKeys.every(function (oldKey) { + if (!tags[oldKey]) return false; + if (d.old[oldKey] === '*') return true; + if (d.old[oldKey] === tags[oldKey]) return true; + var vals = tags[oldKey].split(';').filter(Boolean); - if (keyNodes.length === 1) { - var index = nodes.indexOf(keyNodes[0]); - var oppositeIndex = Math.floor((index + nodes.length / 2) % nodes.length); - keyNodes.push(nodes[oppositeIndex]); - keyPoints.push(points[oppositeIndex]); - } // key points and nodes are those connected to the ways, - // they are projected onto the circle, in between nodes are moved - // to constant intervals between key nodes, extra in between nodes are - // added if necessary. + if (vals.length === 0) { + return false; + } else if (vals.length > 1) { + return vals.indexOf(d.old[oldKey]) !== -1; + } else { + if (tags[oldKey] === d.old[oldKey]) { + if (d.replace && d.old[oldKey] === d.replace[oldKey]) { + var replaceKeys = Object.keys(d.replace); + return !replaceKeys.every(function (replaceKey) { + return tags[replaceKey] === d.replace[replaceKey]; + }); + } else { + return true; + } + } + } + return false; + }); - for (i = 0; i < keyPoints.length; i++) { - var nextKeyNodeIndex = (i + 1) % keyNodes.length; - var startNode = keyNodes[i]; - var endNode = keyNodes[nextKeyNodeIndex]; - var startNodeIndex = nodes.indexOf(startNode); - var endNodeIndex = nodes.indexOf(endNode); - var numberNewPoints = -1; - var indexRange = endNodeIndex - startNodeIndex; - var nearNodes = {}; - var inBetweenNodes = []; - var startAngle, endAngle, totalAngle, eachAngle; - var angle, loc, node, origNode; + if (matchesDeprecatedTags) { + deprecated.push(d); + } + }); + return deprecated; + } + }; - if (indexRange < 0) { - indexRange += nodes.length; - } // position this key node + function osmLanes(entity) { + if (entity.type !== 'way') return null; + if (!entity.tags.highway) return null; + var tags = entity.tags; + var isOneWay = entity.isOneWay(); + var laneCount = getLaneCount(tags, isOneWay); + var maxspeed = parseMaxspeed(tags); + var laneDirections = parseLaneDirections(tags, isOneWay, laneCount); + var forward = laneDirections.forward; + var backward = laneDirections.backward; + var bothways = laneDirections.bothways; // parse the piped string 'x|y|z' format + var turnLanes = {}; + turnLanes.unspecified = parseTurnLanes(tags['turn:lanes']); + turnLanes.forward = parseTurnLanes(tags['turn:lanes:forward']); + turnLanes.backward = parseTurnLanes(tags['turn:lanes:backward']); + var maxspeedLanes = {}; + maxspeedLanes.unspecified = parseMaxspeedLanes(tags['maxspeed:lanes'], maxspeed); + maxspeedLanes.forward = parseMaxspeedLanes(tags['maxspeed:lanes:forward'], maxspeed); + maxspeedLanes.backward = parseMaxspeedLanes(tags['maxspeed:lanes:backward'], maxspeed); + var psvLanes = {}; + psvLanes.unspecified = parseMiscLanes(tags['psv:lanes']); + psvLanes.forward = parseMiscLanes(tags['psv:lanes:forward']); + psvLanes.backward = parseMiscLanes(tags['psv:lanes:backward']); + var busLanes = {}; + busLanes.unspecified = parseMiscLanes(tags['bus:lanes']); + busLanes.forward = parseMiscLanes(tags['bus:lanes:forward']); + busLanes.backward = parseMiscLanes(tags['bus:lanes:backward']); + var taxiLanes = {}; + taxiLanes.unspecified = parseMiscLanes(tags['taxi:lanes']); + taxiLanes.forward = parseMiscLanes(tags['taxi:lanes:forward']); + taxiLanes.backward = parseMiscLanes(tags['taxi:lanes:backward']); + var hovLanes = {}; + hovLanes.unspecified = parseMiscLanes(tags['hov:lanes']); + hovLanes.forward = parseMiscLanes(tags['hov:lanes:forward']); + hovLanes.backward = parseMiscLanes(tags['hov:lanes:backward']); + var hgvLanes = {}; + hgvLanes.unspecified = parseMiscLanes(tags['hgv:lanes']); + hgvLanes.forward = parseMiscLanes(tags['hgv:lanes:forward']); + hgvLanes.backward = parseMiscLanes(tags['hgv:lanes:backward']); + var bicyclewayLanes = {}; + bicyclewayLanes.unspecified = parseBicycleWay(tags['bicycleway:lanes']); + bicyclewayLanes.forward = parseBicycleWay(tags['bicycleway:lanes:forward']); + bicyclewayLanes.backward = parseBicycleWay(tags['bicycleway:lanes:backward']); + var lanesObj = { + forward: [], + backward: [], + unspecified: [] + }; // map forward/backward/unspecified of each lane type to lanesObj - var distance = geoVecLength(centroid, keyPoints[i]) || 1e-4; - keyPoints[i] = [centroid[0] + (keyPoints[i][0] - centroid[0]) / distance * radius, centroid[1] + (keyPoints[i][1] - centroid[1]) / distance * radius]; - loc = projection.invert(keyPoints[i]); - node = keyNodes[i]; - origNode = origNodes[node.id]; - node = node.move(geoVecInterp(origNode.loc, loc, t)); - graph = graph.replace(node); // figure out the between delta angle we want to match to + mapToLanesObj(lanesObj, turnLanes, 'turnLane'); + mapToLanesObj(lanesObj, maxspeedLanes, 'maxspeed'); + mapToLanesObj(lanesObj, psvLanes, 'psv'); + mapToLanesObj(lanesObj, busLanes, 'bus'); + mapToLanesObj(lanesObj, taxiLanes, 'taxi'); + mapToLanesObj(lanesObj, hovLanes, 'hov'); + mapToLanesObj(lanesObj, hgvLanes, 'hgv'); + mapToLanesObj(lanesObj, bicyclewayLanes, 'bicycleway'); + return { + metadata: { + count: laneCount, + oneway: isOneWay, + forward: forward, + backward: backward, + bothways: bothways, + turnLanes: turnLanes, + maxspeed: maxspeed, + maxspeedLanes: maxspeedLanes, + psvLanes: psvLanes, + busLanes: busLanes, + taxiLanes: taxiLanes, + hovLanes: hovLanes, + hgvLanes: hgvLanes, + bicyclewayLanes: bicyclewayLanes + }, + lanes: lanesObj + }; + } - startAngle = Math.atan2(keyPoints[i][1] - centroid[1], keyPoints[i][0] - centroid[0]); - endAngle = Math.atan2(keyPoints[nextKeyNodeIndex][1] - centroid[1], keyPoints[nextKeyNodeIndex][0] - centroid[0]); - totalAngle = endAngle - startAngle; // detects looping around -pi/pi + function getLaneCount(tags, isOneWay) { + var count; - if (totalAngle * sign > 0) { - totalAngle = -sign * (2 * Math.PI - Math.abs(totalAngle)); - } + if (tags.lanes) { + count = parseInt(tags.lanes, 10); - do { - numberNewPoints++; - eachAngle = totalAngle / (indexRange + numberNewPoints); - } while (Math.abs(eachAngle) > maxAngle); // move existing nodes + if (count > 0) { + return count; + } + } + switch (tags.highway) { + case 'trunk': + case 'motorway': + count = isOneWay ? 2 : 4; + break; - for (j = 1; j < indexRange; j++) { - angle = startAngle + j * eachAngle; - loc = projection.invert([centroid[0] + Math.cos(angle) * radius, centroid[1] + Math.sin(angle) * radius]); - node = nodes[(j + startNodeIndex) % nodes.length]; - origNode = origNodes[node.id]; - nearNodes[node.id] = angle; - node = node.move(geoVecInterp(origNode.loc, loc, t)); - graph = graph.replace(node); - } // add new in between nodes if necessary + default: + count = isOneWay ? 1 : 2; + break; + } + return count; + } - for (j = 0; j < numberNewPoints; j++) { - angle = startAngle + (indexRange + j) * eachAngle; - loc = projection.invert([centroid[0] + Math.cos(angle) * radius, centroid[1] + Math.sin(angle) * radius]); // choose a nearnode to use as the original + function parseMaxspeed(tags) { + var maxspeed = tags.maxspeed; + if (!maxspeed) return; + var maxspeedRegex = /^([0-9][\.0-9]+?)(?:[ ]?(?:km\/h|kmh|kph|mph|knots))?$/; + if (!maxspeedRegex.test(maxspeed)) return; + return parseInt(maxspeed, 10); + } - var min = Infinity; + function parseLaneDirections(tags, isOneWay, laneCount) { + var forward = parseInt(tags['lanes:forward'], 10); + var backward = parseInt(tags['lanes:backward'], 10); + var bothways = parseInt(tags['lanes:both_ways'], 10) > 0 ? 1 : 0; - for (var nodeId in nearNodes) { - var nearAngle = nearNodes[nodeId]; - var dist = Math.abs(nearAngle - angle); + if (parseInt(tags.oneway, 10) === -1) { + forward = 0; + bothways = 0; + backward = laneCount; + } else if (isOneWay) { + forward = laneCount; + bothways = 0; + backward = 0; + } else if (isNaN(forward) && isNaN(backward)) { + backward = Math.floor((laneCount - bothways) / 2); + forward = laneCount - bothways - backward; + } else if (isNaN(forward)) { + if (backward > laneCount - bothways) { + backward = laneCount - bothways; + } - if (dist < min) { - min = dist; - origNode = origNodes[nodeId]; - } - } + forward = laneCount - bothways - backward; + } else if (isNaN(backward)) { + if (forward > laneCount - bothways) { + forward = laneCount - bothways; + } - node = osmNode({ - loc: geoVecInterp(origNode.loc, loc, t) - }); - graph = graph.replace(node); - nodes.splice(endNodeIndex + j, 0, node); - inBetweenNodes.push(node.id); - } // Check for other ways that share these keyNodes.. - // If keyNodes are adjacent in both ways, - // we can add inBetweenNodes to that shared way too.. + backward = laneCount - bothways - forward; + } + return { + forward: forward, + backward: backward, + bothways: bothways + }; + } - if (indexRange === 1 && inBetweenNodes.length) { - var startIndex1 = way.nodes.lastIndexOf(startNode.id); - var endIndex1 = way.nodes.lastIndexOf(endNode.id); - var wayDirection1 = endIndex1 - startIndex1; + function parseTurnLanes(tag) { + if (!tag) return; + var validValues = ['left', 'slight_left', 'sharp_left', 'through', 'right', 'slight_right', 'sharp_right', 'reverse', 'merge_to_left', 'merge_to_right', 'none']; + return tag.split('|').map(function (s) { + if (s === '') s = 'none'; + return s.split(';').map(function (d) { + return validValues.indexOf(d) === -1 ? 'unknown' : d; + }); + }); + } - if (wayDirection1 < -1) { - wayDirection1 = 1; - } + function parseMaxspeedLanes(tag, maxspeed) { + if (!tag) return; + return tag.split('|').map(function (s) { + if (s === 'none') return s; + var m = parseInt(s, 10); + if (s === '' || m === maxspeed) return null; + return isNaN(m) ? 'unknown' : m; + }); + } - var parentWays = graph.parentWays(keyNodes[i]); + function parseMiscLanes(tag) { + if (!tag) return; + var validValues = ['yes', 'no', 'designated']; + return tag.split('|').map(function (s) { + if (s === '') s = 'no'; + return validValues.indexOf(s) === -1 ? 'unknown' : s; + }); + } - for (j = 0; j < parentWays.length; j++) { - var sharedWay = parentWays[j]; - if (sharedWay === way) continue; + function parseBicycleWay(tag) { + if (!tag) return; + var validValues = ['yes', 'no', 'designated', 'lane']; + return tag.split('|').map(function (s) { + if (s === '') s = 'no'; + return validValues.indexOf(s) === -1 ? 'unknown' : s; + }); + } - if (sharedWay.areAdjacent(startNode.id, endNode.id)) { - var startIndex2 = sharedWay.nodes.lastIndexOf(startNode.id); - var endIndex2 = sharedWay.nodes.lastIndexOf(endNode.id); - var wayDirection2 = endIndex2 - startIndex2; - var insertAt = endIndex2; + function mapToLanesObj(lanesObj, data, key) { + if (data.forward) { + data.forward.forEach(function (l, i) { + if (!lanesObj.forward[i]) lanesObj.forward[i] = {}; + lanesObj.forward[i][key] = l; + }); + } - if (wayDirection2 < -1) { - wayDirection2 = 1; - } + if (data.backward) { + data.backward.forEach(function (l, i) { + if (!lanesObj.backward[i]) lanesObj.backward[i] = {}; + lanesObj.backward[i][key] = l; + }); + } - if (wayDirection1 !== wayDirection2) { - inBetweenNodes.reverse(); - insertAt = startIndex2; - } + if (data.unspecified) { + data.unspecified.forEach(function (l, i) { + if (!lanesObj.unspecified[i]) lanesObj.unspecified[i] = {}; + lanesObj.unspecified[i][key] = l; + }); + } + } - for (k = 0; k < inBetweenNodes.length; k++) { - sharedWay = sharedWay.addNode(inBetweenNodes[k], insertAt + k); - } + function osmWay() { + if (!(this instanceof osmWay)) { + return new osmWay().initialize(arguments); + } else if (arguments.length) { + this.initialize(arguments); + } + } + osmEntity.way = osmWay; + osmWay.prototype = Object.create(osmEntity.prototype); + Object.assign(osmWay.prototype, { + type: 'way', + nodes: [], + copy: function copy(resolver, copies) { + if (copies[this.id]) return copies[this.id]; + var copy = osmEntity.prototype.copy.call(this, resolver, copies); + var nodes = this.nodes.map(function (id) { + return resolver.entity(id).copy(resolver, copies).id; + }); + copy = copy.update({ + nodes: nodes + }); + copies[this.id] = copy; + return copy; + }, + extent: function extent(resolver) { + return resolver["transient"](this, 'extent', function () { + var extent = geoExtent(); - graph = graph.replace(sharedWay); - } + for (var i = 0; i < this.nodes.length; i++) { + var node = resolver.hasEntity(this.nodes[i]); + + if (node) { + extent._extend(node.extent()); } } - } // update the way to have all the new nodes - - ids = nodes.map(function (n) { - return n.id; - }); - ids.push(ids[0]); - way = way.update({ - nodes: ids - }); - graph = graph.replace(way); - return graph; - }; - - action.makeConvex = function (graph) { - var way = graph.entity(wayId); - var nodes = utilArrayUniq(graph.childNodes(way)); - var points = nodes.map(function (n) { - return projection(n.loc); + return extent; }); - var sign = d3_polygonArea(points) > 0 ? 1 : -1; - var hull = d3_polygonHull(points); - var i, j; // D3 convex hulls go counterclockwise.. + }, + first: function first() { + return this.nodes[0]; + }, + last: function last() { + return this.nodes[this.nodes.length - 1]; + }, + contains: function contains(node) { + return this.nodes.indexOf(node) >= 0; + }, + affix: function affix(node) { + if (this.nodes[0] === node) return 'prefix'; + if (this.nodes[this.nodes.length - 1] === node) return 'suffix'; + }, + layer: function layer() { + // explicit layer tag, clamp between -10, 10.. + if (isFinite(this.tags.layer)) { + return Math.max(-10, Math.min(+this.tags.layer, 10)); + } // implied layer tag.. - if (sign === -1) { - nodes.reverse(); - points.reverse(); - } - for (i = 0; i < hull.length - 1; i++) { - var startIndex = points.indexOf(hull[i]); - var endIndex = points.indexOf(hull[i + 1]); - var indexRange = endIndex - startIndex; + if (this.tags.covered === 'yes') return -1; + if (this.tags.location === 'overground') return 1; + if (this.tags.location === 'underground') return -1; + if (this.tags.location === 'underwater') return -10; + if (this.tags.power === 'line') return 10; + if (this.tags.power === 'minor_line') return 10; + if (this.tags.aerialway) return 10; + if (this.tags.bridge) return 1; + if (this.tags.cutting) return -1; + if (this.tags.tunnel) return -1; + if (this.tags.waterway) return -1; + if (this.tags.man_made === 'pipeline') return -10; + if (this.tags.boundary) return -10; + return 0; + }, + // the approximate width of the line based on its tags except its `width` tag + impliedLineWidthMeters: function impliedLineWidthMeters() { + var averageWidths = { + highway: { + // width is for single lane + motorway: 5, + motorway_link: 5, + trunk: 4.5, + trunk_link: 4.5, + primary: 4, + secondary: 4, + tertiary: 4, + primary_link: 4, + secondary_link: 4, + tertiary_link: 4, + unclassified: 4, + road: 4, + living_street: 4, + bus_guideway: 4, + pedestrian: 4, + residential: 3.5, + service: 3.5, + track: 3, + cycleway: 2.5, + bridleway: 2, + corridor: 2, + steps: 2, + path: 1.5, + footway: 1.5 + }, + railway: { + // width includes ties and rail bed, not just track gauge + rail: 2.5, + light_rail: 2.5, + tram: 2.5, + subway: 2.5, + monorail: 2.5, + funicular: 2.5, + disused: 2.5, + preserved: 2.5, + miniature: 1.5, + narrow_gauge: 1.5 + }, + waterway: { + river: 50, + canal: 25, + stream: 5, + tidal_channel: 5, + fish_pass: 2.5, + drain: 2.5, + ditch: 1.5 + } + }; - if (indexRange < 0) { - indexRange += nodes.length; - } // move interior nodes to the surface of the convex hull.. + for (var key in averageWidths) { + if (this.tags[key] && averageWidths[key][this.tags[key]]) { + var width = averageWidths[key][this.tags[key]]; + if (key === 'highway') { + var laneCount = this.tags.lanes && parseInt(this.tags.lanes, 10); + if (!laneCount) laneCount = this.isOneWay() ? 1 : 2; + return width * laneCount; + } - for (j = 1; j < indexRange; j++) { - var point = geoVecInterp(hull[i], hull[i + 1], j / indexRange); - var node = nodes[(j + startIndex) % nodes.length].move(projection.invert(point)); - graph = graph.replace(node); + return width; } } - return graph; - }; + return null; + }, + isOneWay: function isOneWay() { + // explicit oneway tag.. + var values = { + 'yes': true, + '1': true, + '-1': true, + 'reversible': true, + 'alternating': true, + 'no': false, + '0': false + }; - action.disabled = function (graph) { - if (!graph.entity(wayId).isClosed()) { - return 'not_closed'; - } //disable when already circular + if (values[this.tags.oneway] !== undefined) { + return values[this.tags.oneway]; + } // implied oneway tag.. - var way = graph.entity(wayId); - var nodes = utilArrayUniq(graph.childNodes(way)); - var points = nodes.map(function (n) { - return projection(n.loc); - }); - var hull = d3_polygonHull(points); - var epsilonAngle = Math.PI / 180; + for (var key in this.tags) { + if (key in osmOneWayTags && this.tags[key] in osmOneWayTags[key]) { + return true; + } + } - if (hull.length !== points.length || hull.length < 3) { + return false; + }, + // Some identifier for tag that implies that this way is "sided", + // i.e. the right side is the 'inside' (e.g. the right side of a + // natural=cliff is lower). + sidednessIdentifier: function sidednessIdentifier() { + for (var key in this.tags) { + var value = this.tags[key]; + + if (key in osmRightSideIsInsideTags && value in osmRightSideIsInsideTags[key]) { + if (osmRightSideIsInsideTags[key][value] === true) { + return key; + } else { + // if the map's value is something other than a + // literal true, we should use it so we can + // special case some keys (e.g. natural=coastline + // is handled differently to other naturals). + return osmRightSideIsInsideTags[key][value]; + } + } + } + + return null; + }, + isSided: function isSided() { + if (this.tags.two_sided === 'yes') { return false; } - var centroid = d3_polygonCentroid(points); - var radius = geoVecLengthSquare(centroid, points[0]); - var i, actualPoint; // compare distances between centroid and points + return this.sidednessIdentifier() !== null; + }, + lanes: function lanes() { + return osmLanes(this); + }, + isClosed: function isClosed() { + return this.nodes.length > 1 && this.first() === this.last(); + }, + isConvex: function isConvex(resolver) { + if (!this.isClosed() || this.isDegenerate()) return null; + var nodes = utilArrayUniq(resolver.childNodes(this)); + var coords = nodes.map(function (n) { + return n.loc; + }); + var curr = 0; + var prev = 0; - for (i = 0; i < hull.length; i++) { - actualPoint = hull[i]; - var actualDist = geoVecLengthSquare(actualPoint, centroid); - var diff = Math.abs(actualDist - radius); //compare distances with epsilon-error (5%) + for (var i = 0; i < coords.length; i++) { + var o = coords[(i + 1) % coords.length]; + var a = coords[i]; + var b = coords[(i + 2) % coords.length]; + var res = geoVecCross(a, b, o); + curr = res > 0 ? 1 : res < 0 ? -1 : 0; - if (diff > 0.05 * radius) { + if (curr === 0) { + continue; + } else if (prev && curr !== prev) { return false; } - } //check if central angles are smaller than maxAngle - - for (i = 0; i < hull.length; i++) { - actualPoint = hull[i]; - var nextPoint = hull[(i + 1) % hull.length]; - var startAngle = Math.atan2(actualPoint[1] - centroid[1], actualPoint[0] - centroid[0]); - var endAngle = Math.atan2(nextPoint[1] - centroid[1], nextPoint[0] - centroid[0]); - var angle = endAngle - startAngle; + prev = curr; + } - if (angle < 0) { - angle = -angle; + return true; + }, + // returns an object with the tag that implies this is an area, if any + tagSuggestingArea: function tagSuggestingArea() { + return osmTagSuggestingArea(this.tags); + }, + isArea: function isArea() { + if (this.tags.area === 'yes') return true; + if (!this.isClosed() || this.tags.area === 'no') return false; + return this.tagSuggestingArea() !== null; + }, + isDegenerate: function isDegenerate() { + return new Set(this.nodes).size < (this.isArea() ? 3 : 2); + }, + areAdjacent: function areAdjacent(n1, n2) { + for (var i = 0; i < this.nodes.length; i++) { + if (this.nodes[i] === n1) { + if (this.nodes[i - 1] === n2) return true; + if (this.nodes[i + 1] === n2) return true; } + } - if (angle > Math.PI) { - angle = 2 * Math.PI - angle; - } + return false; + }, + geometry: function geometry(graph) { + return graph["transient"](this, 'geometry', function () { + return this.isArea() ? 'area' : 'line'; + }); + }, + // returns an array of objects representing the segments between the nodes in this way + segments: function segments(graph) { + function segmentExtent(graph) { + var n1 = graph.hasEntity(this.nodes[0]); + var n2 = graph.hasEntity(this.nodes[1]); + return n1 && n2 && geoExtent([[Math.min(n1.loc[0], n2.loc[0]), Math.min(n1.loc[1], n2.loc[1])], [Math.max(n1.loc[0], n2.loc[0]), Math.max(n1.loc[1], n2.loc[1])]]); + } - if (angle > maxAngle + epsilonAngle) { - return false; + return graph["transient"](this, 'segments', function () { + var segments = []; + + for (var i = 0; i < this.nodes.length - 1; i++) { + segments.push({ + id: this.id + '-' + i, + wayId: this.id, + index: i, + nodes: [this.nodes[i], this.nodes[i + 1]], + extent: segmentExtent + }); } - } - return 'already_circular'; - }; + return segments; + }); + }, + // If this way is not closed, append the beginning node to the end of the nodelist to close it. + close: function close() { + if (this.isClosed() || !this.nodes.length) return this; + var nodes = this.nodes.slice(); + nodes = nodes.filter(noRepeatNodes); + nodes.push(nodes[0]); + return this.update({ + nodes: nodes + }); + }, + // If this way is closed, remove any connector nodes from the end of the nodelist to unclose it. + unclose: function unclose() { + if (!this.isClosed()) return this; + var nodes = this.nodes.slice(); + var connector = this.first(); + var i = nodes.length - 1; // remove trailing connectors.. - action.transitionable = true; - return action; - } + while (i > 0 && nodes.length > 1 && nodes[i] === connector) { + nodes.splice(i, 1); + i = nodes.length - 1; + } - function actionDeleteWay(wayID) { - function canDeleteNode(node, graph) { - // don't delete nodes still attached to ways or relations - if (graph.parentWays(node).length || graph.parentRelations(node).length) return false; - var geometries = osmNodeGeometriesForTags(node.tags); // don't delete if this node can be a standalone point + nodes = nodes.filter(noRepeatNodes); + return this.update({ + nodes: nodes + }); + }, + // Adds a node (id) in front of the node which is currently at position index. + // If index is undefined, the node will be added to the end of the way for linear ways, + // or just before the final connecting node for circular ways. + // Consecutive duplicates are eliminated including existing ones. + // Circularity is always preserved when adding a node. + addNode: function addNode(id, index) { + var nodes = this.nodes.slice(); + var isClosed = this.isClosed(); + var max = isClosed ? nodes.length - 1 : nodes.length; - if (geometries.point) return false; // delete if this node only be a vertex + if (index === undefined) { + index = max; + } - if (geometries.vertex) return true; // iD doesn't know if this should be a point or vertex, - // so only delete if there are no interesting tags + if (index < 0 || index > max) { + throw new RangeError('index ' + index + ' out of range 0..' + max); + } // If this is a closed way, remove all connector nodes except the first one + // (there may be duplicates) and adjust index if necessary.. - return !node.hasInterestingTags(); - } - var action = function action(graph) { - var way = graph.entity(wayID); - graph.parentRelations(way).forEach(function (parent) { - parent = parent.removeMembersWithID(wayID); - graph = graph.replace(parent); + if (isClosed) { + var connector = this.first(); // leading connectors.. - if (parent.isDegenerate()) { - graph = actionDeleteRelation(parent.id)(graph); - } - }); - new Set(way.nodes).forEach(function (nodeID) { - graph = graph.replace(way.removeNode(nodeID)); - var node = graph.entity(nodeID); + var i = 1; - if (canDeleteNode(node, graph)) { - graph = graph.remove(node); - } - }); - return graph.remove(way); - }; + while (i < nodes.length && nodes.length > 2 && nodes[i] === connector) { + nodes.splice(i, 1); + if (index > i) index--; + } // trailing connectors.. - return action; - } - function actionDeleteMultiple(ids) { - var actions = { - way: actionDeleteWay, - node: actionDeleteNode, - relation: actionDeleteRelation - }; + i = nodes.length - 1; - var action = function action(graph) { - ids.forEach(function (id) { - if (graph.hasEntity(id)) { - // It may have been deleted already. - graph = actions[graph.entity(id).type](id)(graph); + while (i > 0 && nodes.length > 1 && nodes[i] === connector) { + nodes.splice(i, 1); + if (index > i) index--; + i = nodes.length - 1; } - }); - return graph; - }; + } - return action; - } + nodes.splice(index, 0, id); + nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. - function actionDeleteRelation(relationID, allowUntaggedMembers) { - function canDeleteEntity(entity, graph) { - return !graph.parentWays(entity).length && !graph.parentRelations(entity).length && !entity.hasInterestingTags() && !allowUntaggedMembers; - } + if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { + nodes.push(nodes[0]); + } - var action = function action(graph) { - var relation = graph.entity(relationID); - graph.parentRelations(relation).forEach(function (parent) { - parent = parent.removeMembersWithID(relationID); - graph = graph.replace(parent); + return this.update({ + nodes: nodes + }); + }, + // Replaces the node which is currently at position index with the given node (id). + // Consecutive duplicates are eliminated including existing ones. + // Circularity is preserved when updating a node. + updateNode: function updateNode(id, index) { + var nodes = this.nodes.slice(); + var isClosed = this.isClosed(); + var max = nodes.length - 1; - if (parent.isDegenerate()) { - graph = actionDeleteRelation(parent.id)(graph); + if (index === undefined || index < 0 || index > max) { + throw new RangeError('index ' + index + ' out of range 0..' + max); + } // If this is a closed way, remove all connector nodes except the first one + // (there may be duplicates) and adjust index if necessary.. + + + if (isClosed) { + var connector = this.first(); // leading connectors.. + + var i = 1; + + while (i < nodes.length && nodes.length > 2 && nodes[i] === connector) { + nodes.splice(i, 1); + if (index > i) index--; + } // trailing connectors.. + + + i = nodes.length - 1; + + while (i > 0 && nodes.length > 1 && nodes[i] === connector) { + nodes.splice(i, 1); + if (index === i) index = 0; // update leading connector instead + + i = nodes.length - 1; } + } + + nodes.splice(index, 1, id); + nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. + + if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { + nodes.push(nodes[0]); + } + + return this.update({ + nodes: nodes }); - var memberIDs = utilArrayUniq(relation.members.map(function (m) { - return m.id; - })); - memberIDs.forEach(function (memberID) { - graph = graph.replace(relation.removeMembersWithID(memberID)); - var entity = graph.entity(memberID); + }, + // Replaces each occurrence of node id needle with replacement. + // Consecutive duplicates are eliminated including existing ones. + // Circularity is preserved. + replaceNode: function replaceNode(needleID, replacementID) { + var nodes = this.nodes.slice(); + var isClosed = this.isClosed(); - if (canDeleteEntity(entity, graph)) { - graph = actionDeleteMultiple([memberID])(graph); + for (var i = 0; i < nodes.length; i++) { + if (nodes[i] === needleID) { + nodes[i] = replacementID; } + } + + nodes = nodes.filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. + + if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { + nodes.push(nodes[0]); + } + + return this.update({ + nodes: nodes }); - return graph.remove(relation); - }; + }, + // Removes each occurrence of node id. + // Consecutive duplicates are eliminated including existing ones. + // Circularity is preserved. + removeNode: function removeNode(id) { + var nodes = this.nodes.slice(); + var isClosed = this.isClosed(); + nodes = nodes.filter(function (node) { + return node !== id; + }).filter(noRepeatNodes); // If the way was closed before, append a connector node to keep it closed.. - return action; - } + if (isClosed && (nodes.length === 1 || nodes[0] !== nodes[nodes.length - 1])) { + nodes.push(nodes[0]); + } - function actionDeleteNode(nodeId) { - var action = function action(graph) { - var node = graph.entity(nodeId); - graph.parentWays(node).forEach(function (parent) { - parent = parent.removeNode(nodeId); - graph = graph.replace(parent); + return this.update({ + nodes: nodes + }); + }, + asJXON: function asJXON(changeset_id) { + var r = { + way: { + '@id': this.osmId(), + '@version': this.version || 0, + nd: this.nodes.map(function (id) { + return { + keyAttributes: { + ref: osmEntity.id.toOSM(id) + } + }; + }, this), + tag: Object.keys(this.tags).map(function (k) { + return { + keyAttributes: { + k: k, + v: this.tags[k] + } + }; + }, this) + } + }; - if (parent.isDegenerate()) { - graph = actionDeleteWay(parent.id)(graph); + if (changeset_id) { + r.way['@changeset'] = changeset_id; + } + + return r; + }, + asGeoJSON: function asGeoJSON(resolver) { + return resolver["transient"](this, 'GeoJSON', function () { + var coordinates = resolver.childNodes(this).map(function (n) { + return n.loc; + }); + + if (this.isArea() && this.isClosed()) { + return { + type: 'Polygon', + coordinates: [coordinates] + }; + } else { + return { + type: 'LineString', + coordinates: coordinates + }; } }); - graph.parentRelations(node).forEach(function (parent) { - parent = parent.removeMembersWithID(nodeId); - graph = graph.replace(parent); + }, + area: function area(resolver) { + return resolver["transient"](this, 'area', function () { + var nodes = resolver.childNodes(this); + var json = { + type: 'Polygon', + coordinates: [nodes.map(function (n) { + return n.loc; + })] + }; - if (parent.isDegenerate()) { - graph = actionDeleteRelation(parent.id)(graph); + if (!this.isClosed() && nodes.length) { + json.coordinates[0].push(nodes[0].loc); + } + + var area = d3_geoArea(json); // Heuristic for detecting counterclockwise winding order. Assumes + // that OpenStreetMap polygons are not hemisphere-spanning. + + if (area > 2 * Math.PI) { + json.coordinates[0] = json.coordinates[0].reverse(); + area = d3_geoArea(json); } + + return isNaN(area) ? 0 : area; }); - return graph.remove(node); - }; + } + }); // Filter function to eliminate consecutive duplicates. - return action; + function noRepeatNodes(node, i, arr) { + return i === 0 || node !== arr[i - 1]; } // - // First choose a node to be the survivor, with preference given - // to an existing (not new) node. - // - // Tags and relation memberships of of non-surviving nodes are merged - // to the survivor. - // - // This is the inverse of `iD.actionDisconnect`. - // - // Reference: - // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeNodesAction.as - // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/MergeNodesAction.java + // 1. Relation tagged with `type=multipolygon` and no interesting tags. + // 2. One and only one member with the `outer` role. Must be a way with interesting tags. + // 3. No members without a role. // + // Old multipolygons are no longer recommended but are still rendered as areas by iD. - function actionConnect(nodeIDs) { - var action = function action(graph) { - var survivor; - var node; - var parents; - var i, j; // Choose a survivor node, prefer an existing (not new) node - #4974 + function osmOldMultipolygonOuterMemberOfRelation(entity, graph) { + if (entity.type !== 'relation' || !entity.isMultipolygon() || Object.keys(entity.tags).filter(osmIsInterestingTag).length > 1) { + return false; + } - for (i = 0; i < nodeIDs.length; i++) { - survivor = graph.entity(nodeIDs[i]); - if (survivor.version) break; // found one - } // Replace all non-surviving nodes with the survivor and merge tags. + var outerMember; + for (var memberIndex in entity.members) { + var member = entity.members[memberIndex]; - for (i = 0; i < nodeIDs.length; i++) { - node = graph.entity(nodeIDs[i]); - if (node.id === survivor.id) continue; - parents = graph.parentWays(node); + if (!member.role || member.role === 'outer') { + if (outerMember) return false; + if (member.type !== 'way') return false; + if (!graph.hasEntity(member.id)) return false; + outerMember = graph.entity(member.id); - for (j = 0; j < parents.length; j++) { - graph = graph.replace(parents[j].replaceNode(node.id, survivor.id)); + if (Object.keys(outerMember.tags).filter(osmIsInterestingTag).length === 0) { + return false; } + } + } - parents = graph.parentRelations(node); + return outerMember; + } // For fixing up rendering of multipolygons with tags on the outer member. + // https://github.com/openstreetmap/iD/issues/613 - for (j = 0; j < parents.length; j++) { - graph = graph.replace(parents[j].replaceMember(node, survivor)); - } + function osmIsOldMultipolygonOuterMember(entity, graph) { + if (entity.type !== 'way' || Object.keys(entity.tags).filter(osmIsInterestingTag).length === 0) { + return false; + } - survivor = survivor.mergeTags(node.tags); - graph = actionDeleteNode(node.id)(graph); - } + var parents = graph.parentRelations(entity); + if (parents.length !== 1) return false; + var parent = parents[0]; - graph = graph.replace(survivor); // find and delete any degenerate ways created by connecting adjacent vertices + if (!parent.isMultipolygon() || Object.keys(parent.tags).filter(osmIsInterestingTag).length > 1) { + return false; + } - parents = graph.parentWays(survivor); + var members = parent.members, + member; - for (i = 0; i < parents.length; i++) { - if (parents[i].isDegenerate()) { - graph = actionDeleteWay(parents[i].id)(graph); - } + for (var i = 0; i < members.length; i++) { + member = members[i]; + + if (member.id === entity.id && member.role && member.role !== 'outer') { + // Not outer member + return false; } - return graph; - }; + if (member.id !== entity.id && (!member.role || member.role === 'outer')) { + // Not a simple multipolygon + return false; + } + } - action.disabled = function (graph) { - var seen = {}; - var restrictionIDs = []; - var survivor; - var node, way; - var relations, relation, role; - var i, j, k; // Choose a survivor node, prefer an existing (not new) node - #4974 + return parent; + } + function osmOldMultipolygonOuterMember(entity, graph) { + if (entity.type !== 'way') return false; + var parents = graph.parentRelations(entity); + if (parents.length !== 1) return false; + var parent = parents[0]; - for (i = 0; i < nodeIDs.length; i++) { - survivor = graph.entity(nodeIDs[i]); - if (survivor.version) break; // found one - } // 1. disable if the nodes being connected have conflicting relation roles + if (!parent.isMultipolygon() || Object.keys(parent.tags).filter(osmIsInterestingTag).length > 1) { + return false; + } + var members = parent.members, + member, + outerMember; - for (i = 0; i < nodeIDs.length; i++) { - node = graph.entity(nodeIDs[i]); - relations = graph.parentRelations(node); + for (var i = 0; i < members.length; i++) { + member = members[i]; - for (j = 0; j < relations.length; j++) { - relation = relations[j]; - role = relation.memberById(node.id).role || ''; // if this node is a via node in a restriction, remember for later + if (!member.role || member.role === 'outer') { + if (outerMember) return false; // Not a simple multipolygon - if (relation.hasFromViaTo()) { - restrictionIDs.push(relation.id); - } + outerMember = member; + } + } - if (seen[relation.id] !== undefined && seen[relation.id] !== role) { - return 'relation'; - } else { - seen[relation.id] = role; - } - } - } // gather restrictions for parent ways + if (!outerMember) return false; + var outerEntity = graph.hasEntity(outerMember.id); + if (!outerEntity || !Object.keys(outerEntity.tags).filter(osmIsInterestingTag).length) { + return false; + } - for (i = 0; i < nodeIDs.length; i++) { - node = graph.entity(nodeIDs[i]); - var parents = graph.parentWays(node); + return outerEntity; + } // Join `toJoin` array into sequences of connecting ways. + // Segments which share identical start/end nodes will, as much as possible, + // be connected with each other. + // + // The return value is a nested array. Each constituent array contains elements + // of `toJoin` which have been determined to connect. + // + // Each consitituent array also has a `nodes` property whose value is an + // ordered array of member nodes, with appropriate order reversal and + // start/end coordinate de-duplication. + // + // Members of `toJoin` must have, at minimum, `type` and `id` properties. + // Thus either an array of `osmWay`s or a relation member array may be used. + // + // If an member is an `osmWay`, its tags and childnodes may be reversed via + // `actionReverse` in the output. + // + // The returned sequences array also has an `actions` array property, containing + // any reversal actions that should be applied to the graph, should the calling + // code attempt to actually join the given ways. + // + // Incomplete members (those for which `graph.hasEntity(element.id)` returns + // false) and non-way members are ignored. + // - for (j = 0; j < parents.length; j++) { - var parent = parents[j]; - relations = graph.parentRelations(parent); + function osmJoinWays(toJoin, graph) { + function resolve(member) { + return graph.childNodes(graph.entity(member.id)); + } - for (k = 0; k < relations.length; k++) { - relation = relations[k]; + function reverse(item) { + var action = actionReverse(item.id, { + reverseOneway: true + }); + sequences.actions.push(action); + return item instanceof osmWay ? action(graph).entity(item.id) : item; + } // make a copy containing only the items to join - if (relation.hasFromViaTo()) { - restrictionIDs.push(relation.id); - } - } - } - } // test restrictions + toJoin = toJoin.filter(function (member) { + return member.type === 'way' && graph.hasEntity(member.id); + }); // Are the things we are joining relation members or `osmWays`? + // If `osmWays`, skip the "prefer a forward path" code below (see #4872) - restrictionIDs = utilArrayUniq(restrictionIDs); + var i; + var joinAsMembers = true; - for (i = 0; i < restrictionIDs.length; i++) { - relation = graph.entity(restrictionIDs[i]); - if (!relation.isComplete(graph)) continue; - var memberWays = relation.members.filter(function (m) { - return m.type === 'way'; - }).map(function (m) { - return graph.entity(m.id); - }); - memberWays = utilArrayUniq(memberWays); - var f = relation.memberByRole('from'); - var t = relation.memberByRole('to'); - var isUturn = f.id === t.id; // 2a. disable if connection would damage a restriction - // (a key node is a node at the junction of ways) + for (i = 0; i < toJoin.length; i++) { + if (toJoin[i] instanceof osmWay) { + joinAsMembers = false; + break; + } + } - var nodes = { - from: [], - via: [], - to: [], - keyfrom: [], - keyto: [] - }; + var sequences = []; + sequences.actions = []; - for (j = 0; j < relation.members.length; j++) { - collectNodes(relation.members[j], nodes); - } + while (toJoin.length) { + // start a new sequence + var item = toJoin.shift(); + var currWays = [item]; + var currNodes = resolve(item).slice(); // add to it - nodes.keyfrom = utilArrayUniq(nodes.keyfrom.filter(hasDuplicates)); - nodes.keyto = utilArrayUniq(nodes.keyto.filter(hasDuplicates)); - var filter = keyNodeFilter(nodes.keyfrom, nodes.keyto); - nodes.from = nodes.from.filter(filter); - nodes.via = nodes.via.filter(filter); - nodes.to = nodes.to.filter(filter); - var connectFrom = false; - var connectVia = false; - var connectTo = false; - var connectKeyFrom = false; - var connectKeyTo = false; + while (toJoin.length) { + var start = currNodes[0]; + var end = currNodes[currNodes.length - 1]; + var fn = null; + var nodes = null; // Find the next way/member to join. - for (j = 0; j < nodeIDs.length; j++) { - var n = nodeIDs[j]; + for (i = 0; i < toJoin.length; i++) { + item = toJoin[i]; + nodes = resolve(item); // (for member ordering only, not way ordering - see #4872) + // Strongly prefer to generate a forward path that preserves the order + // of the members array. For multipolygons and most relations, member + // order does not matter - but for routes, it does. (see #4589) + // If we started this sequence backwards (i.e. next member way attaches to + // the start node and not the end node), reverse the initial way before continuing. - if (nodes.from.indexOf(n) !== -1) { - connectFrom = true; + if (joinAsMembers && currWays.length === 1 && nodes[0] !== end && nodes[nodes.length - 1] !== end && (nodes[nodes.length - 1] === start || nodes[0] === start)) { + currWays[0] = reverse(currWays[0]); + currNodes.reverse(); + start = currNodes[0]; + end = currNodes[currNodes.length - 1]; } - if (nodes.via.indexOf(n) !== -1) { - connectVia = true; - } + if (nodes[0] === end) { + fn = currNodes.push; // join to end - if (nodes.to.indexOf(n) !== -1) { - connectTo = true; - } + nodes = nodes.slice(1); + break; + } else if (nodes[nodes.length - 1] === end) { + fn = currNodes.push; // join to end - if (nodes.keyfrom.indexOf(n) !== -1) { - connectKeyFrom = true; - } + nodes = nodes.slice(0, -1).reverse(); + item = reverse(item); + break; + } else if (nodes[nodes.length - 1] === start) { + fn = currNodes.unshift; // join to beginning - if (nodes.keyto.indexOf(n) !== -1) { - connectKeyTo = true; + nodes = nodes.slice(0, -1); + break; + } else if (nodes[0] === start) { + fn = currNodes.unshift; // join to beginning + + nodes = nodes.slice(1).reverse(); + item = reverse(item); + break; + } else { + fn = nodes = null; } } - if (connectFrom && connectTo && !isUturn) { - return 'restriction'; + if (!nodes) { + // couldn't find a joinable way/member + break; } - if (connectFrom && connectVia) { - return 'restriction'; - } + fn.apply(currWays, [item]); + fn.apply(currNodes, nodes); + toJoin.splice(i, 1); + } - if (connectTo && connectVia) { - return 'restriction'; - } // connecting to a key node - - // if both nodes are on a member way (i.e. part of the turn restriction), - // the connecting node must be adjacent to the key node. + currWays.nodes = currNodes; + sequences.push(currWays); + } + return sequences; + } - if (connectKeyFrom || connectKeyTo) { - if (nodeIDs.length !== 2) { - return 'restriction'; - } + function actionAddMember(relationId, member, memberIndex, insertPair) { + return function action(graph) { + var relation = graph.entity(relationId); // There are some special rules for Public Transport v2 routes. - var n0 = null; - var n1 = null; - - for (j = 0; j < memberWays.length; j++) { - way = memberWays[j]; - - if (way.contains(nodeIDs[0])) { - n0 = nodeIDs[0]; - } - - if (way.contains(nodeIDs[1])) { - n1 = nodeIDs[1]; - } - } - - if (n0 && n1) { - // both nodes are part of the restriction - var ok = false; - - for (j = 0; j < memberWays.length; j++) { - way = memberWays[j]; + var isPTv2 = /stop|platform/.test(member.role); - if (way.areAdjacent(n0, n1)) { - ok = true; - break; - } - } + if ((isNaN(memberIndex) || insertPair) && member.type === 'way' && !isPTv2) { + // Try to perform sensible inserts based on how the ways join together + graph = addWayMember(relation, graph); + } else { + // see https://wiki.openstreetmap.org/wiki/Public_transport#Service_routes + // Stops and Platforms for PTv2 should be ordered first. + // hack: We do not currently have the ability to place them in the exactly correct order. + if (isPTv2 && isNaN(memberIndex)) { + memberIndex = 0; + } - if (!ok) { - return 'restriction'; - } - } - } // 2b. disable if nodes being connected will destroy a member way in a restriction - // (to test, make a copy and try actually connecting the nodes) + graph = graph.replace(relation.addMember(member, memberIndex)); + } + return graph; + }; // Add a way member into the relation "wherever it makes sense". + // In this situation we were not supplied a memberIndex. - for (j = 0; j < memberWays.length; j++) { - way = memberWays[j].update({}); // make copy + function addWayMember(relation, graph) { + var groups, tempWay, insertPairIsReversed, item, i, j, k; // remove PTv2 stops and platforms before doing anything. - for (k = 0; k < nodeIDs.length; k++) { - if (nodeIDs[k] === survivor.id) continue; + var PTv2members = []; + var members = []; - if (way.areAdjacent(nodeIDs[k], survivor.id)) { - way = way.removeNode(nodeIDs[k]); - } else { - way = way.replaceNode(nodeIDs[k], survivor.id); - } - } + for (i = 0; i < relation.members.length; i++) { + var m = relation.members[i]; - if (way.isDegenerate()) { - return 'restriction'; - } + if (/stop|platform/.test(m.role)) { + PTv2members.push(m); + } else { + members.push(m); } } - return false; // if a key node appears multiple times (indexOf !== lastIndexOf) it's a FROM-VIA or TO-VIA junction - - function hasDuplicates(n, i, arr) { - return arr.indexOf(n) !== arr.lastIndexOf(n); - } + relation = relation.update({ + members: members + }); - function keyNodeFilter(froms, tos) { - return function (n) { - return froms.indexOf(n) === -1 && tos.indexOf(n) === -1; + if (insertPair) { + // We're adding a member that must stay paired with an existing member. + // (This feature is used by `actionSplit`) + // + // This is tricky because the members may exist multiple times in the + // member list, and with different A-B/B-A ordering and different roles. + // (e.g. a bus route that loops out and back - #4589). + // + // Replace the existing member with a temporary way, + // so that `osmJoinWays` can treat the pair like a single way. + tempWay = osmWay({ + id: 'wTemp', + nodes: insertPair.nodes + }); + graph = graph.replace(tempWay); + var tempMember = { + id: tempWay.id, + type: 'way', + role: member.role }; - } + var tempRelation = relation.replaceMember({ + id: insertPair.originalID + }, tempMember, true); + groups = utilArrayGroupBy(tempRelation.members, 'type'); + groups.way = groups.way || []; // Insert pair is reversed if the inserted way comes before the original one. + // (Except when they form a loop.) - function collectNodes(member, collection) { - var entity = graph.hasEntity(member.id); - if (!entity) return; - var role = member.role || ''; + var originalWay = graph.entity(insertPair.originalID); + var insertedWay = graph.entity(insertPair.insertedID); + insertPairIsReversed = originalWay.nodes.length > 0 && insertedWay.nodes.length > 0 && insertedWay.nodes[insertedWay.nodes.length - 1] === originalWay.nodes[0] && originalWay.nodes[originalWay.nodes.length - 1] !== insertedWay.nodes[0]; + } else { + // Add the member anywhere, one time. Just push and let `osmJoinWays` decide where to put it. + groups = utilArrayGroupBy(relation.members, 'type'); + groups.way = groups.way || []; + groups.way.push(member); + } - if (!collection[role]) { - collection[role] = []; - } + members = withIndex(groups.way); + var joined = osmJoinWays(members, graph); // `joined` might not contain all of the way members, + // But will contain only the completed (downloaded) members - if (member.type === 'node') { - collection[role].push(member.id); + for (i = 0; i < joined.length; i++) { + var segment = joined[i]; + var nodes = segment.nodes.slice(); + var startIndex = segment[0].index; // j = array index in `members` where this segment starts - if (role === 'via') { - collection.keyfrom.push(member.id); - collection.keyto.push(member.id); + for (j = 0; j < members.length; j++) { + if (members[j].index === startIndex) { + break; } - } else if (member.type === 'way') { - collection[role].push.apply(collection[role], entity.nodes); + } // k = each member in segment - if (role === 'from' || role === 'via') { - collection.keyfrom.push(entity.first()); - collection.keyfrom.push(entity.last()); - } - if (role === 'to' || role === 'via') { - collection.keyto.push(entity.first()); - collection.keyto.push(entity.last()); - } - } - } - }; + for (k = 0; k < segment.length; k++) { + item = segment[k]; + var way = graph.entity(item.id); // If this is a paired item, generate members in correct order and role - return action; - } + if (tempWay && item.id === tempWay.id) { + var reverse = nodes[0].id !== insertPair.nodes[0] ^ insertPairIsReversed; - function actionCopyEntities(ids, fromGraph) { - var _copies = {}; + if (reverse) { + item.pair = [{ + id: insertPair.insertedID, + type: 'way', + role: item.role + }, { + id: insertPair.originalID, + type: 'way', + role: item.role + }]; + } else { + item.pair = [{ + id: insertPair.originalID, + type: 'way', + role: item.role + }, { + id: insertPair.insertedID, + type: 'way', + role: item.role + }]; + } + } // reorder `members` if necessary - var action = function action(graph) { - ids.forEach(function (id) { - fromGraph.entity(id).copy(fromGraph, _copies); - }); - for (var id in _copies) { - graph = graph.replace(_copies[id]); - } + if (k > 0) { + if (j + k >= members.length || item.index !== members[j + k].index) { + moveMember(members, item.index, j + k); + } + } - return graph; - }; + nodes.splice(0, way.nodes.length - 1); + } + } - action.copies = function () { - return _copies; - }; + if (tempWay) { + graph = graph.remove(tempWay); + } // Final pass: skip dead items, split pairs, remove index properties - return action; - } - function actionDeleteMember(relationId, memberIndex) { - return function (graph) { - var relation = graph.entity(relationId).removeMember(memberIndex); - graph = graph.replace(relation); + var wayMembers = []; - if (relation.isDegenerate()) { - graph = actionDeleteRelation(relation.id)(graph); - } + for (i = 0; i < members.length; i++) { + item = members[i]; + if (item.index === -1) continue; - return graph; - }; - } + if (item.pair) { + wayMembers.push(item.pair[0]); + wayMembers.push(item.pair[1]); + } else { + wayMembers.push(utilObjectOmit(item, ['index'])); + } + } // Put stops and platforms first, then nodes, ways, relations + // This is recommended for Public Transport v2 routes: + // see https://wiki.openstreetmap.org/wiki/Public_transport#Service_routes - function actionDiscardTags(difference, discardTags) { - discardTags = discardTags || {}; - return function (graph) { - difference.modified().forEach(checkTags); - difference.created().forEach(checkTags); - return graph; - function checkTags(entity) { - var keys = Object.keys(entity.tags); - var didDiscard = false; - var tags = {}; + var newMembers = PTv2members.concat(groups.node || [], wayMembers, groups.relation || []); + return graph.replace(relation.update({ + members: newMembers + })); // `moveMember()` changes the `members` array in place by splicing + // the item with `.index = findIndex` to where it belongs, + // and marking the old position as "dead" with `.index = -1` + // + // j=5, k=0 jk + // segment 5 4 7 6 + // members 0 1 2 3 4 5 6 7 8 9 keep 5 in j+k + // + // j=5, k=1 j k + // segment 5 4 7 6 + // members 0 1 2 3 4 5 6 7 8 9 move 4 to j+k + // members 0 1 2 3 x 5 4 6 7 8 9 moved + // + // j=5, k=2 j k + // segment 5 4 7 6 + // members 0 1 2 3 x 5 4 6 7 8 9 move 7 to j+k + // members 0 1 2 3 x 5 4 7 6 x 8 9 moved + // + // j=5, k=3 j k + // segment 5 4 7 6 + // members 0 1 2 3 x 5 4 7 6 x 8 9 keep 6 in j+k + // - for (var i = 0; i < keys.length; i++) { - var k = keys[i]; + function moveMember(arr, findIndex, toIndex) { + var i; - if (discardTags[k] || !entity.tags[k]) { - didDiscard = true; - } else { - tags[k] = entity.tags[k]; + for (i = 0; i < arr.length; i++) { + if (arr[i].index === findIndex) { + break; } } - if (didDiscard) { - graph = graph.replace(entity.update({ - tags: tags - })); - } - } - }; - } - - // - // Optionally, disconnect only the given ways. - // - // For testing convenience, accepts an ID to assign to the (first) new node. - // Normally, this will be undefined and the way will automatically - // be assigned a new ID. - // - // This is the inverse of `iD.actionConnect`. - // - // Reference: - // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/UnjoinNodeAction.as - // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/UnGlueAction.java - // + var item = Object.assign({}, arr[i]); // shallow copy - function actionDisconnect(nodeId, newNodeId) { - var wayIds; + arr[i].index = -1; // mark as dead - var action = function action(graph) { - var node = graph.entity(nodeId); - var connections = action.connections(graph); - connections.forEach(function (connection) { - var way = graph.entity(connection.wayID); - var newNode = osmNode({ - id: newNodeId, - loc: node.loc, - tags: node.tags - }); - graph = graph.replace(newNode); + item.index = toIndex; + arr.splice(toIndex, 0, item); + } // This is the same as `Relation.indexedMembers`, + // Except we don't want to index all the members, only the ways - if (connection.index === 0 && way.isArea()) { - // replace shared node with shared node.. - graph = graph.replace(way.replaceNode(way.nodes[0], newNode.id)); - } else if (way.isClosed() && connection.index === way.nodes.length - 1) { - // replace closing node with new new node.. - graph = graph.replace(way.unclose().addNode(newNode.id)); - } else { - // replace shared node with multiple new nodes.. - graph = graph.replace(way.updateNode(newNode.id, connection.index)); - } - }); - return graph; - }; - action.connections = function (graph) { - var candidates = []; - var keeping = false; - var parentWays = graph.parentWays(graph.entity(nodeId)); - var way, waynode; + function withIndex(arr) { + var result = new Array(arr.length); - for (var i = 0; i < parentWays.length; i++) { - way = parentWays[i]; + for (var i = 0; i < arr.length; i++) { + result[i] = Object.assign({}, arr[i]); // shallow copy - if (wayIds && wayIds.indexOf(way.id) === -1) { - keeping = true; - continue; + result[i].index = i; } - if (way.isArea() && way.nodes[0] === nodeId) { - candidates.push({ - wayID: way.id, - index: 0 - }); - } else { - for (var j = 0; j < way.nodes.length; j++) { - waynode = way.nodes[j]; - - if (waynode === nodeId) { - if (way.isClosed() && parentWays.length > 1 && wayIds && wayIds.indexOf(way.id) !== -1 && j === way.nodes.length - 1) { - continue; - } - - candidates.push({ - wayID: way.id, - index: j - }); - } - } - } + return result; } + } + } - return keeping ? candidates : candidates.slice(1); - }; + function actionAddMidpoint(midpoint, node) { + return function (graph) { + graph = graph.replace(node.move(midpoint.loc)); + var parents = utilArrayIntersection(graph.parentWays(graph.entity(midpoint.edge[0])), graph.parentWays(graph.entity(midpoint.edge[1]))); + parents.forEach(function (way) { + for (var i = 0; i < way.nodes.length - 1; i++) { + if (geoEdgeEqual([way.nodes[i], way.nodes[i + 1]], midpoint.edge)) { + graph = graph.replace(graph.entity(way.id).addNode(node.id, i + 1)); // Add only one midpoint on doubled-back segments, + // turning them into self-intersections. - action.disabled = function (graph) { - var connections = action.connections(graph); - if (connections.length === 0) return 'not_connected'; - var parentWays = graph.parentWays(graph.entity(nodeId)); - var seenRelationIds = {}; - var sharedRelation; - parentWays.forEach(function (way) { - var relations = graph.parentRelations(way); - relations.forEach(function (relation) { - if (relation.id in seenRelationIds) { - if (wayIds) { - if (wayIds.indexOf(way.id) !== -1 || wayIds.indexOf(seenRelationIds[relation.id]) !== -1) { - sharedRelation = relation; - } - } else { - sharedRelation = relation; - } - } else { - seenRelationIds[relation.id] = way.id; + return; } - }); + } }); - if (sharedRelation) return 'relation'; + return graph; }; + } - action.limitWays = function (val) { - if (!arguments.length) return wayIds; - wayIds = val; - return action; + // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/AddNodeToWayAction.as + function actionAddVertex(wayId, nodeId, index) { + return function (graph) { + return graph.replace(graph.entity(wayId).addNode(nodeId, index)); }; - - return action; } - function actionExtract(entityID, projection) { - var extractedNodeID; + function actionChangeMember(relationId, member, memberIndex) { + return function (graph) { + return graph.replace(graph.entity(relationId).updateMember(member, memberIndex)); + }; + } - var action = function action(graph) { + function actionChangePreset(entityID, oldPreset, newPreset, skipFieldDefaults) { + return function action(graph) { var entity = graph.entity(entityID); + var geometry = entity.geometry(graph); + var tags = entity.tags; // preserve tags that the new preset might care about, if any - if (entity.type === 'node') { - return extractFromNode(entity, graph); - } - - return extractFromWayOrRelation(entity, graph); + if (oldPreset) tags = oldPreset.unsetTags(tags, geometry, newPreset && newPreset.addTags ? Object.keys(newPreset.addTags) : null); + if (newPreset) tags = newPreset.setTags(tags, geometry, skipFieldDefaults); + return graph.replace(entity.update({ + tags: tags + })); }; + } - function extractFromNode(node, graph) { - extractedNodeID = node.id; // Create a new node to replace the one we will detach + function actionChangeTags(entityId, tags) { + return function (graph) { + var entity = graph.entity(entityId); + return graph.replace(entity.update({ + tags: tags + })); + }; + } - var replacement = osmNode({ - loc: node.loc + function osmNode() { + if (!(this instanceof osmNode)) { + return new osmNode().initialize(arguments); + } else if (arguments.length) { + this.initialize(arguments); + } + } + osmEntity.node = osmNode; + osmNode.prototype = Object.create(osmEntity.prototype); + Object.assign(osmNode.prototype, { + type: 'node', + loc: [9999, 9999], + extent: function extent() { + return new geoExtent(this.loc); + }, + geometry: function geometry(graph) { + return graph["transient"](this, 'geometry', function () { + return graph.isPoi(this) ? 'point' : 'vertex'; }); - graph = graph.replace(replacement); // Process each way in turn, updating the graph as we go - - graph = graph.parentWays(node).reduce(function (accGraph, parentWay) { - return accGraph.replace(parentWay.replaceNode(entityID, replacement.id)); - }, graph); // Process any relations too + }, + move: function move(loc) { + return this.update({ + loc: loc + }); + }, + isDegenerate: function isDegenerate() { + return !(Array.isArray(this.loc) && this.loc.length === 2 && this.loc[0] >= -180 && this.loc[0] <= 180 && this.loc[1] >= -90 && this.loc[1] <= 90); + }, + // Inspect tags and geometry to determine which direction(s) this node/vertex points + directions: function directions(resolver, projection) { + var val; + var i; // which tag to use? - return graph.parentRelations(node).reduce(function (accGraph, parentRel) { - return accGraph.replace(parentRel.replaceMember(node, replacement)); - }, graph); - } + if (this.isHighwayIntersection(resolver) && (this.tags.stop || '').toLowerCase() === 'all') { + // all-way stop tag on a highway intersection + val = 'all'; + } else { + // generic direction tag + val = (this.tags.direction || '').toLowerCase(); // better suffix-style direction tag - function extractFromWayOrRelation(entity, graph) { - var fromGeometry = entity.geometry(graph); - var keysToCopyAndRetain = ['source', 'wheelchair']; - var keysToRetain = ['area']; - var buildingKeysToRetain = ['architect', 'building', 'height', 'layer']; - var extractedLoc = d3_geoPath(projection).centroid(entity.asGeoJSON(graph)); - extractedLoc = extractedLoc && projection.invert(extractedLoc); + var re = /:direction$/i; + var keys = Object.keys(this.tags); - if (!extractedLoc || !isFinite(extractedLoc[0]) || !isFinite(extractedLoc[1])) { - extractedLoc = entity.extent(graph).center(); + for (i = 0; i < keys.length; i++) { + if (re.test(keys[i])) { + val = this.tags[keys[i]].toLowerCase(); + break; + } + } } - var indoorAreaValues = { - area: true, - corridor: true, - elevator: true, - level: true, - room: true + if (val === '') return []; + var cardinal = { + north: 0, + n: 0, + northnortheast: 22, + nne: 22, + northeast: 45, + ne: 45, + eastnortheast: 67, + ene: 67, + east: 90, + e: 90, + eastsoutheast: 112, + ese: 112, + southeast: 135, + se: 135, + southsoutheast: 157, + sse: 157, + south: 180, + s: 180, + southsouthwest: 202, + ssw: 202, + southwest: 225, + sw: 225, + westsouthwest: 247, + wsw: 247, + west: 270, + w: 270, + westnorthwest: 292, + wnw: 292, + northwest: 315, + nw: 315, + northnorthwest: 337, + nnw: 337 }; - var isBuilding = entity.tags.building && entity.tags.building !== 'no' || entity.tags['building:part'] && entity.tags['building:part'] !== 'no'; - var isIndoorArea = fromGeometry === 'area' && entity.tags.indoor && indoorAreaValues[entity.tags.indoor]; - var entityTags = Object.assign({}, entity.tags); // shallow copy - - var pointTags = {}; - - for (var key in entityTags) { - if (entity.type === 'relation' && key === 'type') { - continue; - } + var values = val.split(';'); + var results = []; + values.forEach(function (v) { + // swap cardinal for numeric directions + if (cardinal[v] !== undefined) { + v = cardinal[v]; + } // numeric direction - just add to results - if (keysToRetain.indexOf(key) !== -1) { - continue; - } - if (isBuilding) { - // don't transfer building-related tags - if (buildingKeysToRetain.indexOf(key) !== -1 || key.match(/^building:.{1,}/) || key.match(/^roof:.{1,}/)) continue; - } // leave `indoor` tag on the area + if (v !== '' && !isNaN(+v)) { + results.push(+v); + return; + } // string direction - inspect parent ways - if (isIndoorArea && key === 'indoor') { - continue; - } // copy the tag from the entity to the point + var lookBackward = this.tags['traffic_sign:backward'] || v === 'backward' || v === 'both' || v === 'all'; + var lookForward = this.tags['traffic_sign:forward'] || v === 'forward' || v === 'both' || v === 'all'; + if (!lookForward && !lookBackward) return; + var nodeIds = {}; + resolver.parentWays(this).forEach(function (parent) { + var nodes = parent.nodes; + for (i = 0; i < nodes.length; i++) { + if (nodes[i] === this.id) { + // match current entity + if (lookForward && i > 0) { + nodeIds[nodes[i - 1]] = true; // look back to prev node + } - pointTags[key] = entityTags[key]; // leave addresses and some other tags so they're on both features + if (lookBackward && i < nodes.length - 1) { + nodeIds[nodes[i + 1]] = true; // look ahead to next node + } + } + } + }, this); + Object.keys(nodeIds).forEach(function (nodeId) { + // +90 because geoAngle returns angle from X axis, not Y (north) + results.push(geoAngle(this, resolver.entity(nodeId), projection) * (180 / Math.PI) + 90); + }, this); + }, this); + return utilArrayUniq(results); + }, + isCrossing: function isCrossing() { + return this.tags.highway === 'crossing' || this.tags.railway && this.tags.railway.indexOf('crossing') !== -1; + }, + isEndpoint: function isEndpoint(resolver) { + return resolver["transient"](this, 'isEndpoint', function () { + var id = this.id; + return resolver.parentWays(this).filter(function (parent) { + return !parent.isClosed() && !!parent.affix(id); + }).length > 0; + }); + }, + isConnected: function isConnected(resolver) { + return resolver["transient"](this, 'isConnected', function () { + var parents = resolver.parentWays(this); - if (keysToCopyAndRetain.indexOf(key) !== -1 || key.match(/^addr:.{1,}/)) { - continue; - } else if (isIndoorArea && key === 'level') { - // leave `level` on both features - continue; - } // remove the tag from the entity + if (parents.length > 1) { + // vertex is connected to multiple parent ways + for (var i in parents) { + if (parents[i].geometry(resolver) === 'line' && parents[i].hasInterestingTags()) return true; + } + } else if (parents.length === 1) { + var way = parents[0]; + var nodes = way.nodes.slice(); + if (way.isClosed()) { + nodes.pop(); + } // ignore connecting node if closed + // return true if vertex appears multiple times (way is self intersecting) - delete entityTags[key]; - } - if (!isBuilding && !isIndoorArea && fromGeometry === 'area') { - // ensure that areas keep area geometry - entityTags.area = 'yes'; - } + return nodes.indexOf(this.id) !== nodes.lastIndexOf(this.id); + } - var replacement = osmNode({ - loc: extractedLoc, - tags: pointTags + return false; }); - graph = graph.replace(replacement); - extractedNodeID = replacement.id; - return graph.replace(entity.update({ - tags: entityTags - })); + }, + parentIntersectionWays: function parentIntersectionWays(resolver) { + return resolver["transient"](this, 'parentIntersectionWays', function () { + return resolver.parentWays(this).filter(function (parent) { + return (parent.tags.highway || parent.tags.waterway || parent.tags.railway || parent.tags.aeroway) && parent.geometry(resolver) === 'line'; + }); + }); + }, + isIntersection: function isIntersection(resolver) { + return this.parentIntersectionWays(resolver).length > 1; + }, + isHighwayIntersection: function isHighwayIntersection(resolver) { + return resolver["transient"](this, 'isHighwayIntersection', function () { + return resolver.parentWays(this).filter(function (parent) { + return parent.tags.highway && parent.geometry(resolver) === 'line'; + }).length > 1; + }); + }, + isOnAddressLine: function isOnAddressLine(resolver) { + return resolver["transient"](this, 'isOnAddressLine', function () { + return resolver.parentWays(this).filter(function (parent) { + return parent.tags.hasOwnProperty('addr:interpolation') && parent.geometry(resolver) === 'line'; + }).length > 0; + }); + }, + asJXON: function asJXON(changeset_id) { + var r = { + node: { + '@id': this.osmId(), + '@lon': this.loc[0], + '@lat': this.loc[1], + '@version': this.version || 0, + tag: Object.keys(this.tags).map(function (k) { + return { + keyAttributes: { + k: k, + v: this.tags[k] + } + }; + }, this) + } + }; + if (changeset_id) r.node['@changeset'] = changeset_id; + return r; + }, + asGeoJSON: function asGeoJSON() { + return { + type: 'Point', + coordinates: this.loc + }; } + }); - action.getExtractedNodeID = function () { - return extractedNodeID; - }; + function actionCircularize(wayId, projection, maxAngle) { + maxAngle = (maxAngle || 20) * Math.PI / 180; - return action; - } + var action = function action(graph, t) { + if (t === null || !isFinite(t)) t = 1; + t = Math.min(Math.max(+t, 0), 1); + var way = graph.entity(wayId); + var origNodes = {}; + graph.childNodes(way).forEach(function (node) { + if (!origNodes[node.id]) origNodes[node.id] = node; + }); - // - // This is the inverse of `iD.actionSplit`. - // - // Reference: - // https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeWaysAction.as - // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/CombineWayAction.java - // + if (!way.isConvex(graph)) { + graph = action.makeConvex(graph); + } - function actionJoin(ids) { - function groupEntitiesByGeometry(graph) { - var entities = ids.map(function (id) { - return graph.entity(id); + var nodes = utilArrayUniq(graph.childNodes(way)); + var keyNodes = nodes.filter(function (n) { + return graph.parentWays(n).length !== 1; }); - return Object.assign({ - line: [] - }, utilArrayGroupBy(entities, function (entity) { - return entity.geometry(graph); - })); - } + var points = nodes.map(function (n) { + return projection(n.loc); + }); + var keyPoints = keyNodes.map(function (n) { + return projection(n.loc); + }); + var centroid = points.length === 2 ? geoVecInterp(points[0], points[1], 0.5) : d3_polygonCentroid(points); + var radius = d3_median(points, function (p) { + return geoVecLength(centroid, p); + }); + var sign = d3_polygonArea(points) > 0 ? 1 : -1; + var ids, i, j, k; // we need at least two key nodes for the algorithm to work - var action = function action(graph) { - var ways = ids.map(graph.entity, graph); - var survivorID = ways[0].id; // if any of the ways are sided (e.g. coastline, cliff, kerb) - // sort them first so they establish the overall order - #6033 + if (!keyNodes.length) { + keyNodes = [nodes[0]]; + keyPoints = [points[0]]; + } - ways.sort(function (a, b) { - var aSided = a.isSided(); - var bSided = b.isSided(); - return aSided && !bSided ? -1 : bSided && !aSided ? 1 : 0; - }); // Prefer to keep an existing way. + if (keyNodes.length === 1) { + var index = nodes.indexOf(keyNodes[0]); + var oppositeIndex = Math.floor((index + nodes.length / 2) % nodes.length); + keyNodes.push(nodes[oppositeIndex]); + keyPoints.push(points[oppositeIndex]); + } // key points and nodes are those connected to the ways, + // they are projected onto the circle, in between nodes are moved + // to constant intervals between key nodes, extra in between nodes are + // added if necessary. - for (var i = 0; i < ways.length; i++) { - if (!ways[i].isNew()) { - survivorID = ways[i].id; - break; - } - } - var sequences = osmJoinWays(ways, graph); - var joined = sequences[0]; // We might need to reverse some of these ways before joining them. #4688 - // `joined.actions` property will contain any actions we need to apply. + for (i = 0; i < keyPoints.length; i++) { + var nextKeyNodeIndex = (i + 1) % keyNodes.length; + var startNode = keyNodes[i]; + var endNode = keyNodes[nextKeyNodeIndex]; + var startNodeIndex = nodes.indexOf(startNode); + var endNodeIndex = nodes.indexOf(endNode); + var numberNewPoints = -1; + var indexRange = endNodeIndex - startNodeIndex; + var nearNodes = {}; + var inBetweenNodes = []; + var startAngle, endAngle, totalAngle, eachAngle; + var angle, loc, node, origNode; - graph = sequences.actions.reduce(function (g, action) { - return action(g); - }, graph); - var survivor = graph.entity(survivorID); - survivor = survivor.update({ - nodes: joined.nodes.map(function (n) { - return n.id; - }) - }); - graph = graph.replace(survivor); - joined.forEach(function (way) { - if (way.id === survivorID) return; - graph.parentRelations(way).forEach(function (parent) { - graph = graph.replace(parent.replaceMember(way, survivor)); - }); - survivor = survivor.mergeTags(way.tags); - graph = graph.replace(survivor); - graph = actionDeleteWay(way.id)(graph); - }); // Finds if the join created a single-member multipolygon, - // and if so turns it into a basic area instead + if (indexRange < 0) { + indexRange += nodes.length; + } // position this key node - function checkForSimpleMultipolygon() { - if (!survivor.isClosed()) return; - var multipolygons = graph.parentMultipolygons(survivor).filter(function (multipolygon) { - // find multipolygons where the survivor is the only member - return multipolygon.members.length === 1; - }); // skip if this is the single member of multiple multipolygons - if (multipolygons.length !== 1) return; - var multipolygon = multipolygons[0]; + var distance = geoVecLength(centroid, keyPoints[i]) || 1e-4; + keyPoints[i] = [centroid[0] + (keyPoints[i][0] - centroid[0]) / distance * radius, centroid[1] + (keyPoints[i][1] - centroid[1]) / distance * radius]; + loc = projection.invert(keyPoints[i]); + node = keyNodes[i]; + origNode = origNodes[node.id]; + node = node.move(geoVecInterp(origNode.loc, loc, t)); + graph = graph.replace(node); // figure out the between delta angle we want to match to - for (var key in survivor.tags) { - if (multipolygon.tags[key] && // don't collapse if tags cannot be cleanly merged - multipolygon.tags[key] !== survivor.tags[key]) return; + startAngle = Math.atan2(keyPoints[i][1] - centroid[1], keyPoints[i][0] - centroid[0]); + endAngle = Math.atan2(keyPoints[nextKeyNodeIndex][1] - centroid[1], keyPoints[nextKeyNodeIndex][0] - centroid[0]); + totalAngle = endAngle - startAngle; // detects looping around -pi/pi + + if (totalAngle * sign > 0) { + totalAngle = -sign * (2 * Math.PI - Math.abs(totalAngle)); } - survivor = survivor.mergeTags(multipolygon.tags); - graph = graph.replace(survivor); - graph = actionDeleteRelation(multipolygon.id, true - /* allow untagged members */ - )(graph); - var tags = Object.assign({}, survivor.tags); + do { + numberNewPoints++; + eachAngle = totalAngle / (indexRange + numberNewPoints); + } while (Math.abs(eachAngle) > maxAngle); // move existing nodes - if (survivor.geometry(graph) !== 'area') { - // ensure the feature persists as an area - tags.area = 'yes'; - } - delete tags.type; // remove type=multipolygon + for (j = 1; j < indexRange; j++) { + angle = startAngle + j * eachAngle; + loc = projection.invert([centroid[0] + Math.cos(angle) * radius, centroid[1] + Math.sin(angle) * radius]); + node = nodes[(j + startNodeIndex) % nodes.length]; + origNode = origNodes[node.id]; + nearNodes[node.id] = angle; + node = node.move(geoVecInterp(origNode.loc, loc, t)); + graph = graph.replace(node); + } // add new in between nodes if necessary - survivor = survivor.update({ - tags: tags - }); - graph = graph.replace(survivor); - } - checkForSimpleMultipolygon(); - return graph; - }; // Returns the number of nodes the resultant way is expected to have + for (j = 0; j < numberNewPoints; j++) { + angle = startAngle + (indexRange + j) * eachAngle; + loc = projection.invert([centroid[0] + Math.cos(angle) * radius, centroid[1] + Math.sin(angle) * radius]); // choose a nearnode to use as the original + var min = Infinity; - action.resultingWayNodesLength = function (graph) { - return ids.reduce(function (count, id) { - return count + graph.entity(id).nodes.length; - }, 0) - ids.length - 1; - }; + for (var nodeId in nearNodes) { + var nearAngle = nearNodes[nodeId]; + var dist = Math.abs(nearAngle - angle); - action.disabled = function (graph) { - var geometries = groupEntitiesByGeometry(graph); + if (dist < min) { + min = dist; + origNode = origNodes[nodeId]; + } + } - if (ids.length < 2 || ids.length !== geometries.line.length) { - return 'not_eligible'; - } + node = osmNode({ + loc: geoVecInterp(origNode.loc, loc, t) + }); + graph = graph.replace(node); + nodes.splice(endNodeIndex + j, 0, node); + inBetweenNodes.push(node.id); + } // Check for other ways that share these keyNodes.. + // If keyNodes are adjacent in both ways, + // we can add inBetweenNodes to that shared way too.. - var joined = osmJoinWays(ids.map(graph.entity, graph), graph); - if (joined.length > 1) { - return 'not_adjacent'; - } // Loop through all combinations of path-pairs - // to check potential intersections between all pairs + if (indexRange === 1 && inBetweenNodes.length) { + var startIndex1 = way.nodes.lastIndexOf(startNode.id); + var endIndex1 = way.nodes.lastIndexOf(endNode.id); + var wayDirection1 = endIndex1 - startIndex1; + if (wayDirection1 < -1) { + wayDirection1 = 1; + } - for (var i = 0; i < ids.length - 1; i++) { - for (var j = i + 1; j < ids.length; j++) { - var path1 = graph.childNodes(graph.entity(ids[i])).map(function (e) { - return e.loc; - }); - var path2 = graph.childNodes(graph.entity(ids[j])).map(function (e) { - return e.loc; - }); - var intersections = geoPathIntersections(path1, path2); // Check if intersections are just nodes lying on top of - // each other/the line, as opposed to crossing it + var parentWays = graph.parentWays(keyNodes[i]); - var common = utilArrayIntersection(joined[0].nodes.map(function (n) { - return n.loc.toString(); - }), intersections.map(function (n) { - return n.toString(); - })); + for (j = 0; j < parentWays.length; j++) { + var sharedWay = parentWays[j]; + if (sharedWay === way) continue; - if (common.length !== intersections.length) { - return 'paths_intersect'; + if (sharedWay.areAdjacent(startNode.id, endNode.id)) { + var startIndex2 = sharedWay.nodes.lastIndexOf(startNode.id); + var endIndex2 = sharedWay.nodes.lastIndexOf(endNode.id); + var wayDirection2 = endIndex2 - startIndex2; + var insertAt = endIndex2; + + if (wayDirection2 < -1) { + wayDirection2 = 1; + } + + if (wayDirection1 !== wayDirection2) { + inBetweenNodes.reverse(); + insertAt = startIndex2; + } + + for (k = 0; k < inBetweenNodes.length; k++) { + sharedWay = sharedWay.addNode(inBetweenNodes[k], insertAt + k); + } + + graph = graph.replace(sharedWay); + } } } - } + } // update the way to have all the new nodes - var nodeIds = joined[0].nodes.map(function (n) { + + ids = nodes.map(function (n) { return n.id; - }).slice(1, -1); - var relation; - var tags = {}; - var conflicting = false; - joined[0].forEach(function (way) { - var parents = graph.parentRelations(way); - parents.forEach(function (parent) { - if (parent.isRestriction() && parent.members.some(function (m) { - return nodeIds.indexOf(m.id) >= 0; - })) { - relation = parent; - } - }); + }); + ids.push(ids[0]); + way = way.update({ + nodes: ids + }); + graph = graph.replace(way); + return graph; + }; - for (var k in way.tags) { - if (!(k in tags)) { - tags[k] = way.tags[k]; - } else if (tags[k] && osmIsInterestingTag(k) && tags[k] !== way.tags[k]) { - conflicting = true; - } - } + action.makeConvex = function (graph) { + var way = graph.entity(wayId); + var nodes = utilArrayUniq(graph.childNodes(way)); + var points = nodes.map(function (n) { + return projection(n.loc); }); + var sign = d3_polygonArea(points) > 0 ? 1 : -1; + var hull = d3_polygonHull(points); + var i, j; // D3 convex hulls go counterclockwise.. - if (relation) { - return 'restriction'; + if (sign === -1) { + nodes.reverse(); + points.reverse(); } - if (conflicting) { - return 'conflicting_tags'; + for (i = 0; i < hull.length - 1; i++) { + var startIndex = points.indexOf(hull[i]); + var endIndex = points.indexOf(hull[i + 1]); + var indexRange = endIndex - startIndex; + + if (indexRange < 0) { + indexRange += nodes.length; + } // move interior nodes to the surface of the convex hull.. + + + for (j = 1; j < indexRange; j++) { + var point = geoVecInterp(hull[i], hull[i + 1], j / indexRange); + var node = nodes[(j + startIndex) % nodes.length].move(projection.invert(point)); + graph = graph.replace(node); + } } + + return graph; }; - return action; - } + action.disabled = function (graph) { + if (!graph.entity(wayId).isClosed()) { + return 'not_closed'; + } //disable when already circular - function actionMerge(ids) { - function groupEntitiesByGeometry(graph) { - var entities = ids.map(function (id) { - return graph.entity(id); - }); - return Object.assign({ - point: [], - area: [], - line: [], - relation: [] - }, utilArrayGroupBy(entities, function (entity) { - return entity.geometry(graph); - })); - } - var action = function action(graph) { - var geometries = groupEntitiesByGeometry(graph); - var target = geometries.area[0] || geometries.line[0]; - var points = geometries.point; - points.forEach(function (point) { - target = target.mergeTags(point.tags); - graph = graph.replace(target); - graph.parentRelations(point).forEach(function (parent) { - graph = graph.replace(parent.replaceMember(point, target)); - }); - var nodes = utilArrayUniq(graph.childNodes(target)); - var removeNode = point; + var way = graph.entity(wayId); + var nodes = utilArrayUniq(graph.childNodes(way)); + var points = nodes.map(function (n) { + return projection(n.loc); + }); + var hull = d3_polygonHull(points); + var epsilonAngle = Math.PI / 180; - for (var i = 0; i < nodes.length; i++) { - var node = nodes[i]; + if (hull.length !== points.length || hull.length < 3) { + return false; + } - if (graph.parentWays(node).length > 1 || graph.parentRelations(node).length || node.hasInterestingTags()) { - continue; - } // Found an uninteresting child node on the target way. - // Move orig point into its place to preserve point's history. #3683 + var centroid = d3_polygonCentroid(points); + var radius = geoVecLengthSquare(centroid, points[0]); + var i, actualPoint; // compare distances between centroid and points + for (i = 0; i < hull.length; i++) { + actualPoint = hull[i]; + var actualDist = geoVecLengthSquare(actualPoint, centroid); + var diff = Math.abs(actualDist - radius); //compare distances with epsilon-error (5%) - graph = graph.replace(point.update({ - tags: {}, - loc: node.loc - })); - target = target.replaceNode(node.id, point.id); - graph = graph.replace(target); - removeNode = node; - break; + if (diff > 0.05 * radius) { + return false; } + } //check if central angles are smaller than maxAngle - graph = graph.remove(removeNode); - }); - - if (target.tags.area === 'yes') { - var tags = Object.assign({}, target.tags); // shallow copy - delete tags.area; + for (i = 0; i < hull.length; i++) { + actualPoint = hull[i]; + var nextPoint = hull[(i + 1) % hull.length]; + var startAngle = Math.atan2(actualPoint[1] - centroid[1], actualPoint[0] - centroid[0]); + var endAngle = Math.atan2(nextPoint[1] - centroid[1], nextPoint[0] - centroid[0]); + var angle = endAngle - startAngle; - if (osmTagSuggestingArea(tags)) { - // remove the `area` tag if area geometry is now implied - #3851 - target = target.update({ - tags: tags - }); - graph = graph.replace(target); + if (angle < 0) { + angle = -angle; } - } - - return graph; - }; - action.disabled = function (graph) { - var geometries = groupEntitiesByGeometry(graph); + if (angle > Math.PI) { + angle = 2 * Math.PI - angle; + } - if (geometries.point.length === 0 || geometries.area.length + geometries.line.length !== 1 || geometries.relation.length !== 0) { - return 'not_eligible'; + if (angle > maxAngle + epsilonAngle) { + return false; + } } + + return 'already_circular'; }; + action.transitionable = true; return action; } - // - // 1. move all the nodes to a common location - // 2. `actionConnect` them - - function actionMergeNodes(nodeIDs, loc) { - // If there is a single "interesting" node, use that as the location. - // Otherwise return the average location of all the nodes. - function chooseLoc(graph) { - if (!nodeIDs.length) return null; - var sum = [0, 0]; - var interestingCount = 0; - var interestingLoc; - - for (var i = 0; i < nodeIDs.length; i++) { - var node = graph.entity(nodeIDs[i]); + function actionDeleteWay(wayID) { + function canDeleteNode(node, graph) { + // don't delete nodes still attached to ways or relations + if (graph.parentWays(node).length || graph.parentRelations(node).length) return false; + var geometries = osmNodeGeometriesForTags(node.tags); // don't delete if this node can be a standalone point - if (node.hasInterestingTags()) { - interestingLoc = ++interestingCount === 1 ? node.loc : null; - } + if (geometries.point) return false; // delete if this node only be a vertex - sum = geoVecAdd(sum, node.loc); - } + if (geometries.vertex) return true; // iD doesn't know if this should be a point or vertex, + // so only delete if there are no interesting tags - return interestingLoc || geoVecScale(sum, 1 / nodeIDs.length); + return !node.hasInterestingTags(); } var action = function action(graph) { - if (nodeIDs.length < 2) return graph; - var toLoc = loc; - - if (!toLoc) { - toLoc = chooseLoc(graph); - } - - for (var i = 0; i < nodeIDs.length; i++) { - var node = graph.entity(nodeIDs[i]); + var way = graph.entity(wayID); + graph.parentRelations(way).forEach(function (parent) { + parent = parent.removeMembersWithID(wayID); + graph = graph.replace(parent); - if (node.loc !== toLoc) { - graph = graph.replace(node.move(toLoc)); + if (parent.isDegenerate()) { + graph = actionDeleteRelation(parent.id)(graph); } - } + }); + new Set(way.nodes).forEach(function (nodeID) { + graph = graph.replace(way.removeNode(nodeID)); + var node = graph.entity(nodeID); - return actionConnect(nodeIDs)(graph); + if (canDeleteNode(node, graph)) { + graph = graph.remove(node); + } + }); + return graph.remove(way); }; - action.disabled = function (graph) { - if (nodeIDs.length < 2) return 'not_eligible'; + return action; + } - for (var i = 0; i < nodeIDs.length; i++) { - var entity = graph.entity(nodeIDs[i]); - if (entity.type !== 'node') return 'not_eligible'; - } + function actionDeleteMultiple(ids) { + var actions = { + way: actionDeleteWay, + node: actionDeleteNode, + relation: actionDeleteRelation + }; - return actionConnect(nodeIDs).disabled(graph); + var action = function action(graph) { + ids.forEach(function (id) { + if (graph.hasEntity(id)) { + // It may have been deleted already. + graph = actions[graph.entity(id).type](id)(graph); + } + }); + return graph; }; return action; } - function osmChangeset() { - if (!(this instanceof osmChangeset)) { - return new osmChangeset().initialize(arguments); - } else if (arguments.length) { - this.initialize(arguments); + function actionDeleteRelation(relationID, allowUntaggedMembers) { + function canDeleteEntity(entity, graph) { + return !graph.parentWays(entity).length && !graph.parentRelations(entity).length && !entity.hasInterestingTags() && !allowUntaggedMembers; } - } - osmEntity.changeset = osmChangeset; - osmChangeset.prototype = Object.create(osmEntity.prototype); - Object.assign(osmChangeset.prototype, { - type: 'changeset', - extent: function extent() { - return new geoExtent(); - }, - geometry: function geometry() { - return 'changeset'; - }, - asJXON: function asJXON() { - return { - osm: { - changeset: { - tag: Object.keys(this.tags).map(function (k) { - return { - '@k': k, - '@v': this.tags[k] - }; - }, this), - '@version': 0.6, - '@generator': 'iD' - } - } - }; - }, - // Generate [osmChange](http://wiki.openstreetmap.org/wiki/OsmChange) - // XML. Returns a string. - osmChangeJXON: function osmChangeJXON(changes) { - var changeset_id = this.id; - function nest(x, order) { - var groups = {}; + var action = function action(graph) { + var relation = graph.entity(relationID); + graph.parentRelations(relation).forEach(function (parent) { + parent = parent.removeMembersWithID(relationID); + graph = graph.replace(parent); - for (var i = 0; i < x.length; i++) { - var tagName = Object.keys(x[i])[0]; - if (!groups[tagName]) groups[tagName] = []; - groups[tagName].push(x[i][tagName]); + if (parent.isDegenerate()) { + graph = actionDeleteRelation(parent.id)(graph); } + }); + var memberIDs = utilArrayUniq(relation.members.map(function (m) { + return m.id; + })); + memberIDs.forEach(function (memberID) { + graph = graph.replace(relation.removeMembersWithID(memberID)); + var entity = graph.entity(memberID); - var ordered = {}; - order.forEach(function (o) { - if (groups[o]) ordered[o] = groups[o]; - }); - return ordered; - } // sort relations in a changeset by dependencies + if (canDeleteEntity(entity, graph)) { + graph = actionDeleteMultiple([memberID])(graph); + } + }); + return graph.remove(relation); + }; + return action; + } - function sort(changes) { - // find a referenced relation in the current changeset - function resolve(item) { - return relations.find(function (relation) { - return item.keyAttributes.type === 'relation' && item.keyAttributes.ref === relation['@id']; - }); - } // a new item is an item that has not been already processed + function actionDeleteNode(nodeId) { + var action = function action(graph) { + var node = graph.entity(nodeId); + graph.parentWays(node).forEach(function (parent) { + parent = parent.removeNode(nodeId); + graph = graph.replace(parent); + if (parent.isDegenerate()) { + graph = actionDeleteWay(parent.id)(graph); + } + }); + graph.parentRelations(node).forEach(function (parent) { + parent = parent.removeMembersWithID(nodeId); + graph = graph.replace(parent); - function isNew(item) { - return !sorted[item['@id']] && !processing.find(function (proc) { - return proc['@id'] === item['@id']; - }); + if (parent.isDegenerate()) { + graph = actionDeleteRelation(parent.id)(graph); } + }); + return graph.remove(node); + }; - var processing = []; - var sorted = {}; - var relations = changes.relation; - if (!relations) return changes; + return action; + } - for (var i = 0; i < relations.length; i++) { - var relation = relations[i]; // skip relation if already sorted + // + // First choose a node to be the survivor, with preference given + // to the oldest existing (not new) and "interesting" node. + // + // Tags and relation memberships of of non-surviving nodes are merged + // to the survivor. + // + // This is the inverse of `iD.actionDisconnect`. + // + // Reference: + // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeNodesAction.as + // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/MergeNodesAction.java + // - if (!sorted[relation['@id']]) { - processing.push(relation); - } + function actionConnect(nodeIDs) { + var action = function action(graph) { + var survivor; + var node; + var parents; + var i, j; // Select the node with the ID passed as parameter if it is in the list, + // otherwise select the node with the oldest ID as the survivor, or the + // last one if there are only new nodes. - while (processing.length > 0) { - var next = processing[0], - deps = next.member.map(resolve).filter(Boolean).filter(isNew); + nodeIDs.reverse(); + var interestingIDs = []; - if (deps.length === 0) { - sorted[next['@id']] = next; - processing.shift(); - } else { - processing = deps.concat(processing); - } + for (i = 0; i < nodeIDs.length; i++) { + node = graph.entity(nodeIDs[i]); + + if (node.hasInterestingTags()) { + if (!node.isNew()) { + interestingIDs.push(node.id); } } - - changes.relation = Object.values(sorted); - return changes; } - function rep(entity) { - return entity.asJXON(changeset_id); - } + survivor = graph.entity(utilOldestID(interestingIDs.length > 0 ? interestingIDs : nodeIDs)); // Replace all non-surviving nodes with the survivor and merge tags. - return { - osmChange: { - '@version': 0.6, - '@generator': 'iD', - 'create': sort(nest(changes.created.map(rep), ['node', 'way', 'relation'])), - 'modify': nest(changes.modified.map(rep), ['node', 'way', 'relation']), - 'delete': Object.assign(nest(changes.deleted.map(rep), ['relation', 'way', 'node']), { - '@if-unused': true - }) + for (i = 0; i < nodeIDs.length; i++) { + node = graph.entity(nodeIDs[i]); + if (node.id === survivor.id) continue; + parents = graph.parentWays(node); + + for (j = 0; j < parents.length; j++) { + graph = graph.replace(parents[j].replaceNode(node.id, survivor.id)); } - }; - }, - asGeoJSON: function asGeoJSON() { - return {}; - } - }); - function osmNote() { - if (!(this instanceof osmNote)) { - return new osmNote().initialize(arguments); - } else if (arguments.length) { - this.initialize(arguments); - } - } + parents = graph.parentRelations(node); - osmNote.id = function () { - return osmNote.id.next--; - }; + for (j = 0; j < parents.length; j++) { + graph = graph.replace(parents[j].replaceMember(node, survivor)); + } - osmNote.id.next = -1; - Object.assign(osmNote.prototype, { - type: 'note', - initialize: function initialize(sources) { - for (var i = 0; i < sources.length; ++i) { - var source = sources[i]; + survivor = survivor.mergeTags(node.tags); + graph = actionDeleteNode(node.id)(graph); + } - for (var prop in source) { - if (Object.prototype.hasOwnProperty.call(source, prop)) { - if (source[prop] === undefined) { - delete this[prop]; - } else { - this[prop] = source[prop]; - } - } + graph = graph.replace(survivor); // find and delete any degenerate ways created by connecting adjacent vertices + + parents = graph.parentWays(survivor); + + for (i = 0; i < parents.length; i++) { + if (parents[i].isDegenerate()) { + graph = actionDeleteWay(parents[i].id)(graph); } } - if (!this.id) { - this.id = osmNote.id().toString(); - } + return graph; + }; - return this; - }, - extent: function extent() { - return new geoExtent(this.loc); - }, - update: function update(attrs) { - return osmNote(this, attrs); // {v: 1 + (this.v || 0)} - }, - isNew: function isNew() { - return this.id < 0; - }, - move: function move(loc) { - return this.update({ - loc: loc - }); - } - }); + action.disabled = function (graph) { + var seen = {}; + var restrictionIDs = []; + var survivor; + var node, way; + var relations, relation, role; + var i, j, k; // Select the node with the oldest ID as the survivor. - function osmRelation() { - if (!(this instanceof osmRelation)) { - return new osmRelation().initialize(arguments); - } else if (arguments.length) { - this.initialize(arguments); - } - } - osmEntity.relation = osmRelation; - osmRelation.prototype = Object.create(osmEntity.prototype); + survivor = graph.entity(utilOldestID(nodeIDs)); // 1. disable if the nodes being connected have conflicting relation roles - osmRelation.creationOrder = function (a, b) { - var aId = parseInt(osmEntity.id.toOSM(a.id), 10); - var bId = parseInt(osmEntity.id.toOSM(b.id), 10); - if (aId < 0 || bId < 0) return aId - bId; - return bId - aId; - }; + for (i = 0; i < nodeIDs.length; i++) { + node = graph.entity(nodeIDs[i]); + relations = graph.parentRelations(node); - Object.assign(osmRelation.prototype, { - type: 'relation', - members: [], - copy: function copy(resolver, copies) { - if (copies[this.id]) return copies[this.id]; - var copy = osmEntity.prototype.copy.call(this, resolver, copies); - var members = this.members.map(function (member) { - return Object.assign({}, member, { - id: resolver.entity(member.id).copy(resolver, copies).id - }); - }); - copy = copy.update({ - members: members - }); - copies[this.id] = copy; - return copy; - }, - extent: function extent(resolver, memo) { - return resolver["transient"](this, 'extent', function () { - if (memo && memo[this.id]) return geoExtent(); - memo = memo || {}; - memo[this.id] = true; - var extent = geoExtent(); + for (j = 0; j < relations.length; j++) { + relation = relations[j]; + role = relation.memberById(node.id).role || ''; // if this node is a via node in a restriction, remember for later - for (var i = 0; i < this.members.length; i++) { - var member = resolver.hasEntity(this.members[i].id); + if (relation.hasFromViaTo()) { + restrictionIDs.push(relation.id); + } - if (member) { - extent._extend(member.extent(resolver, memo)); + if (seen[relation.id] !== undefined && seen[relation.id] !== role) { + return 'relation'; + } else { + seen[relation.id] = role; } } + } // gather restrictions for parent ways - return extent; - }); - }, - geometry: function geometry(graph) { - return graph["transient"](this, 'geometry', function () { - return this.isMultipolygon() ? 'area' : 'relation'; - }); - }, - isDegenerate: function isDegenerate() { - return this.members.length === 0; - }, - // Return an array of members, each extended with an 'index' property whose value - // is the member index. - indexedMembers: function indexedMembers() { - var result = new Array(this.members.length); - for (var i = 0; i < this.members.length; i++) { - result[i] = Object.assign({}, this.members[i], { - index: i - }); - } + for (i = 0; i < nodeIDs.length; i++) { + node = graph.entity(nodeIDs[i]); + var parents = graph.parentWays(node); - return result; - }, - // Return the first member with the given role. A copy of the member object - // is returned, extended with an 'index' property whose value is the member index. - memberByRole: function memberByRole(role) { - for (var i = 0; i < this.members.length; i++) { - if (this.members[i].role === role) { - return Object.assign({}, this.members[i], { - index: i - }); - } - } - }, - // Same as memberByRole, but returns all members with the given role - membersByRole: function membersByRole(role) { - var result = []; + for (j = 0; j < parents.length; j++) { + var parent = parents[j]; + relations = graph.parentRelations(parent); - for (var i = 0; i < this.members.length; i++) { - if (this.members[i].role === role) { - result.push(Object.assign({}, this.members[i], { - index: i - })); - } - } + for (k = 0; k < relations.length; k++) { + relation = relations[k]; - return result; - }, - // Return the first member with the given id. A copy of the member object - // is returned, extended with an 'index' property whose value is the member index. - memberById: function memberById(id) { - for (var i = 0; i < this.members.length; i++) { - if (this.members[i].id === id) { - return Object.assign({}, this.members[i], { - index: i - }); + if (relation.hasFromViaTo()) { + restrictionIDs.push(relation.id); + } + } } - } - }, - // Return the first member with the given id and role. A copy of the member object - // is returned, extended with an 'index' property whose value is the member index. - memberByIdAndRole: function memberByIdAndRole(id, role) { - for (var i = 0; i < this.members.length; i++) { - if (this.members[i].id === id && this.members[i].role === role) { - return Object.assign({}, this.members[i], { - index: i - }); + } // test restrictions + + + restrictionIDs = utilArrayUniq(restrictionIDs); + + for (i = 0; i < restrictionIDs.length; i++) { + relation = graph.entity(restrictionIDs[i]); + if (!relation.isComplete(graph)) continue; + var memberWays = relation.members.filter(function (m) { + return m.type === 'way'; + }).map(function (m) { + return graph.entity(m.id); + }); + memberWays = utilArrayUniq(memberWays); + var f = relation.memberByRole('from'); + var t = relation.memberByRole('to'); + var isUturn = f.id === t.id; // 2a. disable if connection would damage a restriction + // (a key node is a node at the junction of ways) + + var nodes = { + from: [], + via: [], + to: [], + keyfrom: [], + keyto: [] + }; + + for (j = 0; j < relation.members.length; j++) { + collectNodes(relation.members[j], nodes); } - } - }, - addMember: function addMember(member, index) { - var members = this.members.slice(); - members.splice(index === undefined ? members.length : index, 0, member); - return this.update({ - members: members - }); - }, - updateMember: function updateMember(member, index) { - var members = this.members.slice(); - members.splice(index, 1, Object.assign({}, members[index], member)); - return this.update({ - members: members - }); - }, - removeMember: function removeMember(index) { - var members = this.members.slice(); - members.splice(index, 1); - return this.update({ - members: members - }); - }, - removeMembersWithID: function removeMembersWithID(id) { - var members = this.members.filter(function (m) { - return m.id !== id; - }); - return this.update({ - members: members - }); - }, - moveMember: function moveMember(fromIndex, toIndex) { - var members = this.members.slice(); - members.splice(toIndex, 0, members.splice(fromIndex, 1)[0]); - return this.update({ - members: members - }); - }, - // Wherever a member appears with id `needle.id`, replace it with a member - // with id `replacement.id`, type `replacement.type`, and the original role, - // By default, adding a duplicate member (by id and role) is prevented. - // Return an updated relation. - replaceMember: function replaceMember(needle, replacement, keepDuplicates) { - if (!this.memberById(needle.id)) return this; - var members = []; - for (var i = 0; i < this.members.length; i++) { - var member = this.members[i]; + nodes.keyfrom = utilArrayUniq(nodes.keyfrom.filter(hasDuplicates)); + nodes.keyto = utilArrayUniq(nodes.keyto.filter(hasDuplicates)); + var filter = keyNodeFilter(nodes.keyfrom, nodes.keyto); + nodes.from = nodes.from.filter(filter); + nodes.via = nodes.via.filter(filter); + nodes.to = nodes.to.filter(filter); + var connectFrom = false; + var connectVia = false; + var connectTo = false; + var connectKeyFrom = false; + var connectKeyTo = false; - if (member.id !== needle.id) { - members.push(member); - } else if (keepDuplicates || !this.memberByIdAndRole(replacement.id, member.role)) { - members.push({ - id: replacement.id, - type: replacement.type, - role: member.role - }); + for (j = 0; j < nodeIDs.length; j++) { + var n = nodeIDs[j]; + + if (nodes.from.indexOf(n) !== -1) { + connectFrom = true; + } + + if (nodes.via.indexOf(n) !== -1) { + connectVia = true; + } + + if (nodes.to.indexOf(n) !== -1) { + connectTo = true; + } + + if (nodes.keyfrom.indexOf(n) !== -1) { + connectKeyFrom = true; + } + + if (nodes.keyto.indexOf(n) !== -1) { + connectKeyTo = true; + } } - } - return this.update({ - members: members - }); - }, - asJXON: function asJXON(changeset_id) { - var r = { - relation: { - '@id': this.osmId(), - '@version': this.version || 0, - member: this.members.map(function (member) { - return { - keyAttributes: { - type: member.type, - role: member.role, - ref: osmEntity.id.toOSM(member.id) - } - }; - }, this), - tag: Object.keys(this.tags).map(function (k) { - return { - keyAttributes: { - k: k, - v: this.tags[k] + if (connectFrom && connectTo && !isUturn) { + return 'restriction'; + } + + if (connectFrom && connectVia) { + return 'restriction'; + } + + if (connectTo && connectVia) { + return 'restriction'; + } // connecting to a key node - + // if both nodes are on a member way (i.e. part of the turn restriction), + // the connecting node must be adjacent to the key node. + + + if (connectKeyFrom || connectKeyTo) { + if (nodeIDs.length !== 2) { + return 'restriction'; + } + + var n0 = null; + var n1 = null; + + for (j = 0; j < memberWays.length; j++) { + way = memberWays[j]; + + if (way.contains(nodeIDs[0])) { + n0 = nodeIDs[0]; + } + + if (way.contains(nodeIDs[1])) { + n1 = nodeIDs[1]; + } + } + + if (n0 && n1) { + // both nodes are part of the restriction + var ok = false; + + for (j = 0; j < memberWays.length; j++) { + way = memberWays[j]; + + if (way.areAdjacent(n0, n1)) { + ok = true; + break; } - }; - }, this) + } + + if (!ok) { + return 'restriction'; + } + } + } // 2b. disable if nodes being connected will destroy a member way in a restriction + // (to test, make a copy and try actually connecting the nodes) + + + for (j = 0; j < memberWays.length; j++) { + way = memberWays[j].update({}); // make copy + + for (k = 0; k < nodeIDs.length; k++) { + if (nodeIDs[k] === survivor.id) continue; + + if (way.areAdjacent(nodeIDs[k], survivor.id)) { + way = way.removeNode(nodeIDs[k]); + } else { + way = way.replaceNode(nodeIDs[k], survivor.id); + } + } + + if (way.isDegenerate()) { + return 'restriction'; + } } - }; + } - if (changeset_id) { - r.relation['@changeset'] = changeset_id; + return false; // if a key node appears multiple times (indexOf !== lastIndexOf) it's a FROM-VIA or TO-VIA junction + + function hasDuplicates(n, i, arr) { + return arr.indexOf(n) !== arr.lastIndexOf(n); } - return r; - }, - asGeoJSON: function asGeoJSON(resolver) { - return resolver["transient"](this, 'GeoJSON', function () { - if (this.isMultipolygon()) { - return { - type: 'MultiPolygon', - coordinates: this.multipolygon(resolver) - }; - } else { - return { - type: 'FeatureCollection', - properties: this.tags, - features: this.members.map(function (member) { - return Object.assign({ - role: member.role - }, resolver.entity(member.id).asGeoJSON(resolver)); - }) - }; + function keyNodeFilter(froms, tos) { + return function (n) { + return froms.indexOf(n) === -1 && tos.indexOf(n) === -1; + }; + } + + function collectNodes(member, collection) { + var entity = graph.hasEntity(member.id); + if (!entity) return; + var role = member.role || ''; + + if (!collection[role]) { + collection[role] = []; } - }); - }, - area: function area(resolver) { - return resolver["transient"](this, 'area', function () { - return d3_geoArea(this.asGeoJSON(resolver)); - }); - }, - isMultipolygon: function isMultipolygon() { - return this.tags.type === 'multipolygon'; - }, - isComplete: function isComplete(resolver) { - for (var i = 0; i < this.members.length; i++) { - if (!resolver.hasEntity(this.members[i].id)) { - return false; + + if (member.type === 'node') { + collection[role].push(member.id); + + if (role === 'via') { + collection.keyfrom.push(member.id); + collection.keyto.push(member.id); + } + } else if (member.type === 'way') { + collection[role].push.apply(collection[role], entity.nodes); + + if (role === 'from' || role === 'via') { + collection.keyfrom.push(entity.first()); + collection.keyfrom.push(entity.last()); + } + + if (role === 'to' || role === 'via') { + collection.keyto.push(entity.first()); + collection.keyto.push(entity.last()); + } } } + }; - return true; - }, - hasFromViaTo: function hasFromViaTo() { - return this.members.some(function (m) { - return m.role === 'from'; - }) && this.members.some(function (m) { - return m.role === 'via'; - }) && this.members.some(function (m) { - return m.role === 'to'; - }); - }, - isRestriction: function isRestriction() { - return !!(this.tags.type && this.tags.type.match(/^restriction:?/)); - }, - isValidRestriction: function isValidRestriction() { - if (!this.isRestriction()) return false; - var froms = this.members.filter(function (m) { - return m.role === 'from'; - }); - var vias = this.members.filter(function (m) { - return m.role === 'via'; - }); - var tos = this.members.filter(function (m) { - return m.role === 'to'; - }); - if (froms.length !== 1 && this.tags.restriction !== 'no_entry') return false; - if (froms.some(function (m) { - return m.type !== 'way'; - })) return false; - if (tos.length !== 1 && this.tags.restriction !== 'no_exit') return false; - if (tos.some(function (m) { - return m.type !== 'way'; - })) return false; - if (vias.length === 0) return false; - if (vias.length > 1 && vias.some(function (m) { - return m.type !== 'way'; - })) return false; - return true; - }, - // Returns an array [A0, ... An], each Ai being an array of node arrays [Nds0, ... Ndsm], - // where Nds0 is an outer ring and subsequent Ndsi's (if any i > 0) being inner rings. - // - // This corresponds to the structure needed for rendering a multipolygon path using a - // `evenodd` fill rule, as well as the structure of a GeoJSON MultiPolygon geometry. - // - // In the case of invalid geometries, this function will still return a result which - // includes the nodes of all way members, but some Nds may be unclosed and some inner - // rings not matched with the intended outer ring. - // - multipolygon: function multipolygon(resolver) { - var outers = this.members.filter(function (m) { - return 'outer' === (m.role || 'outer'); - }); - var inners = this.members.filter(function (m) { - return 'inner' === m.role; + return action; + } + + function actionCopyEntities(ids, fromGraph) { + var _copies = {}; + + var action = function action(graph) { + ids.forEach(function (id) { + fromGraph.entity(id).copy(fromGraph, _copies); }); - outers = osmJoinWays(outers, resolver); - inners = osmJoinWays(inners, resolver); - var sequenceToLineString = function sequenceToLineString(sequence) { - if (sequence.nodes.length > 2 && sequence.nodes[0] !== sequence.nodes[sequence.nodes.length - 1]) { - // close unclosed parts to ensure correct area rendering - #2945 - sequence.nodes.push(sequence.nodes[0]); + for (var id in _copies) { + graph = graph.replace(_copies[id]); + } + + return graph; + }; + + action.copies = function () { + return _copies; + }; + + return action; + } + + function actionDeleteMember(relationId, memberIndex) { + return function (graph) { + var relation = graph.entity(relationId).removeMember(memberIndex); + graph = graph.replace(relation); + + if (relation.isDegenerate()) { + graph = actionDeleteRelation(relation.id)(graph); + } + + return graph; + }; + } + + function actionDiscardTags(difference, discardTags) { + discardTags = discardTags || {}; + return function (graph) { + difference.modified().forEach(checkTags); + difference.created().forEach(checkTags); + return graph; + + function checkTags(entity) { + var keys = Object.keys(entity.tags); + var didDiscard = false; + var tags = {}; + + for (var i = 0; i < keys.length; i++) { + var k = keys[i]; + + if (discardTags[k] || !entity.tags[k]) { + didDiscard = true; + } else { + tags[k] = entity.tags[k]; + } } - return sequence.nodes.map(function (node) { - return node.loc; + if (didDiscard) { + graph = graph.replace(entity.update({ + tags: tags + })); + } + } + }; + } + + // + // Optionally, disconnect only the given ways. + // + // For testing convenience, accepts an ID to assign to the (first) new node. + // Normally, this will be undefined and the way will automatically + // be assigned a new ID. + // + // This is the inverse of `iD.actionConnect`. + // + // Reference: + // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/UnjoinNodeAction.as + // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/UnGlueAction.java + // + + function actionDisconnect(nodeId, newNodeId) { + var wayIds; + var disconnectableRelationTypes = { + 'associatedStreet': true, + 'enforcement': true, + 'site': true + }; + + var action = function action(graph) { + var node = graph.entity(nodeId); + var connections = action.connections(graph); + connections.forEach(function (connection) { + var way = graph.entity(connection.wayID); + var newNode = osmNode({ + id: newNodeId, + loc: node.loc, + tags: node.tags }); - }; + graph = graph.replace(newNode); - outers = outers.map(sequenceToLineString); - inners = inners.map(sequenceToLineString); - var result = outers.map(function (o) { - // Heuristic for detecting counterclockwise winding order. Assumes - // that OpenStreetMap polygons are not hemisphere-spanning. - return [d3_geoArea({ - type: 'Polygon', - coordinates: [o] - }) > 2 * Math.PI ? o.reverse() : o]; + if (connection.index === 0 && way.isArea()) { + // replace shared node with shared node.. + graph = graph.replace(way.replaceNode(way.nodes[0], newNode.id)); + } else if (way.isClosed() && connection.index === way.nodes.length - 1) { + // replace closing node with new new node.. + graph = graph.replace(way.unclose().addNode(newNode.id)); + } else { + // replace shared node with multiple new nodes.. + graph = graph.replace(way.updateNode(newNode.id, connection.index)); + } }); + return graph; + }; - function findOuter(inner) { - var o, outer; + action.connections = function (graph) { + var candidates = []; + var keeping = false; + var parentWays = graph.parentWays(graph.entity(nodeId)); + var way, waynode; - for (o = 0; o < outers.length; o++) { - outer = outers[o]; + for (var i = 0; i < parentWays.length; i++) { + way = parentWays[i]; - if (geoPolygonContainsPolygon(outer, inner)) { - return o; - } + if (wayIds && wayIds.indexOf(way.id) === -1) { + keeping = true; + continue; } - for (o = 0; o < outers.length; o++) { - outer = outers[o]; + if (way.isArea() && way.nodes[0] === nodeId) { + candidates.push({ + wayID: way.id, + index: 0 + }); + } else { + for (var j = 0; j < way.nodes.length; j++) { + waynode = way.nodes[j]; + + if (waynode === nodeId) { + if (way.isClosed() && parentWays.length > 1 && wayIds && wayIds.indexOf(way.id) !== -1 && j === way.nodes.length - 1) { + continue; + } + + candidates.push({ + wayID: way.id, + index: j + }); + } + } + } + } + + return keeping ? candidates : candidates.slice(1); + }; + + action.disabled = function (graph) { + var connections = action.connections(graph); + if (connections.length === 0) return 'not_connected'; + var parentWays = graph.parentWays(graph.entity(nodeId)); + var seenRelationIds = {}; + var sharedRelation; + parentWays.forEach(function (way) { + var relations = graph.parentRelations(way); + relations.filter(function (relation) { + return !disconnectableRelationTypes[relation.tags.type]; + }).forEach(function (relation) { + if (relation.id in seenRelationIds) { + if (wayIds) { + if (wayIds.indexOf(way.id) !== -1 || wayIds.indexOf(seenRelationIds[relation.id]) !== -1) { + sharedRelation = relation; + } + } else { + sharedRelation = relation; + } + } else { + seenRelationIds[relation.id] = way.id; + } + }); + }); + if (sharedRelation) return 'relation'; + }; + + action.limitWays = function (val) { + if (!arguments.length) return wayIds; + wayIds = val; + return action; + }; + + return action; + } + + function actionExtract(entityID, projection) { + var extractedNodeID; + + var action = function action(graph) { + var entity = graph.entity(entityID); + + if (entity.type === 'node') { + return extractFromNode(entity, graph); + } + + return extractFromWayOrRelation(entity, graph); + }; + + function extractFromNode(node, graph) { + extractedNodeID = node.id; // Create a new node to replace the one we will detach + + var replacement = osmNode({ + loc: node.loc + }); + graph = graph.replace(replacement); // Process each way in turn, updating the graph as we go + + graph = graph.parentWays(node).reduce(function (accGraph, parentWay) { + return accGraph.replace(parentWay.replaceNode(entityID, replacement.id)); + }, graph); // Process any relations too + + return graph.parentRelations(node).reduce(function (accGraph, parentRel) { + return accGraph.replace(parentRel.replaceMember(node, replacement)); + }, graph); + } + + function extractFromWayOrRelation(entity, graph) { + var fromGeometry = entity.geometry(graph); + var keysToCopyAndRetain = ['source', 'wheelchair']; + var keysToRetain = ['area']; + var buildingKeysToRetain = ['architect', 'building', 'height', 'layer']; + var extractedLoc = d3_geoPath(projection).centroid(entity.asGeoJSON(graph)); + extractedLoc = extractedLoc && projection.invert(extractedLoc); + + if (!extractedLoc || !isFinite(extractedLoc[0]) || !isFinite(extractedLoc[1])) { + extractedLoc = entity.extent(graph).center(); + } + + var indoorAreaValues = { + area: true, + corridor: true, + elevator: true, + level: true, + room: true + }; + var isBuilding = entity.tags.building && entity.tags.building !== 'no' || entity.tags['building:part'] && entity.tags['building:part'] !== 'no'; + var isIndoorArea = fromGeometry === 'area' && entity.tags.indoor && indoorAreaValues[entity.tags.indoor]; + var entityTags = Object.assign({}, entity.tags); // shallow copy + + var pointTags = {}; + + for (var key in entityTags) { + if (entity.type === 'relation' && key === 'type') { + continue; + } + + if (keysToRetain.indexOf(key) !== -1) { + continue; + } + + if (isBuilding) { + // don't transfer building-related tags + if (buildingKeysToRetain.indexOf(key) !== -1 || key.match(/^building:.{1,}/) || key.match(/^roof:.{1,}/)) continue; + } // leave `indoor` tag on the area + + + if (isIndoorArea && key === 'indoor') { + continue; + } // copy the tag from the entity to the point + + + pointTags[key] = entityTags[key]; // leave addresses and some other tags so they're on both features + + if (keysToCopyAndRetain.indexOf(key) !== -1 || key.match(/^addr:.{1,}/)) { + continue; + } else if (isIndoorArea && key === 'level') { + // leave `level` on both features + continue; + } // remove the tag from the entity + + + delete entityTags[key]; + } + + if (!isBuilding && !isIndoorArea && fromGeometry === 'area') { + // ensure that areas keep area geometry + entityTags.area = 'yes'; + } + + var replacement = osmNode({ + loc: extractedLoc, + tags: pointTags + }); + graph = graph.replace(replacement); + extractedNodeID = replacement.id; + return graph.replace(entity.update({ + tags: entityTags + })); + } + + action.getExtractedNodeID = function () { + return extractedNodeID; + }; + + return action; + } + + // + // This is the inverse of `iD.actionSplit`. + // + // Reference: + // https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeWaysAction.as + // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/CombineWayAction.java + // + + function actionJoin(ids) { + function groupEntitiesByGeometry(graph) { + var entities = ids.map(function (id) { + return graph.entity(id); + }); + return Object.assign({ + line: [] + }, utilArrayGroupBy(entities, function (entity) { + return entity.geometry(graph); + })); + } + + var action = function action(graph) { + var ways = ids.map(graph.entity, graph); // Prefer to keep an existing way. + // if there are multiple existing ways, keep the oldest one + // the oldest way is determined by the ID of the way. + + var survivorID = utilOldestID(ways.map(function (way) { + return way.id; + })); // if any of the ways are sided (e.g. coastline, cliff, kerb) + // sort them first so they establish the overall order - #6033 + + ways.sort(function (a, b) { + var aSided = a.isSided(); + var bSided = b.isSided(); + return aSided && !bSided ? -1 : bSided && !aSided ? 1 : 0; + }); + var sequences = osmJoinWays(ways, graph); + var joined = sequences[0]; // We might need to reverse some of these ways before joining them. #4688 + // `joined.actions` property will contain any actions we need to apply. + + graph = sequences.actions.reduce(function (g, action) { + return action(g); + }, graph); + var survivor = graph.entity(survivorID); + survivor = survivor.update({ + nodes: joined.nodes.map(function (n) { + return n.id; + }) + }); + graph = graph.replace(survivor); + joined.forEach(function (way) { + if (way.id === survivorID) return; + graph.parentRelations(way).forEach(function (parent) { + graph = graph.replace(parent.replaceMember(way, survivor)); + }); + survivor = survivor.mergeTags(way.tags); + graph = graph.replace(survivor); + graph = actionDeleteWay(way.id)(graph); + }); // Finds if the join created a single-member multipolygon, + // and if so turns it into a basic area instead + + function checkForSimpleMultipolygon() { + if (!survivor.isClosed()) return; + var multipolygons = graph.parentMultipolygons(survivor).filter(function (multipolygon) { + // find multipolygons where the survivor is the only member + return multipolygon.members.length === 1; + }); // skip if this is the single member of multiple multipolygons + + if (multipolygons.length !== 1) return; + var multipolygon = multipolygons[0]; + + for (var key in survivor.tags) { + if (multipolygon.tags[key] && // don't collapse if tags cannot be cleanly merged + multipolygon.tags[key] !== survivor.tags[key]) return; + } + + survivor = survivor.mergeTags(multipolygon.tags); + graph = graph.replace(survivor); + graph = actionDeleteRelation(multipolygon.id, true + /* allow untagged members */ + )(graph); + var tags = Object.assign({}, survivor.tags); + + if (survivor.geometry(graph) !== 'area') { + // ensure the feature persists as an area + tags.area = 'yes'; + } + + delete tags.type; // remove type=multipolygon + + survivor = survivor.update({ + tags: tags + }); + graph = graph.replace(survivor); + } + + checkForSimpleMultipolygon(); + return graph; + }; // Returns the number of nodes the resultant way is expected to have + + + action.resultingWayNodesLength = function (graph) { + return ids.reduce(function (count, id) { + return count + graph.entity(id).nodes.length; + }, 0) - ids.length - 1; + }; + + action.disabled = function (graph) { + var geometries = groupEntitiesByGeometry(graph); + + if (ids.length < 2 || ids.length !== geometries.line.length) { + return 'not_eligible'; + } + + var joined = osmJoinWays(ids.map(graph.entity, graph), graph); + + if (joined.length > 1) { + return 'not_adjacent'; + } + + var i; // All joined ways must belong to the same set of (non-restriction) relations. + // Restriction relations have different logic, below, which allows some cases + // this prohibits, and prohibits some cases this allows. + + var sortedParentRelations = function sortedParentRelations(id) { + return graph.parentRelations(graph.entity(id)).filter(function (rel) { + return !rel.isRestriction() && !rel.isConnectivity(); + }).sort(function (a, b) { + return a.id - b.id; + }); + }; + + var relsA = sortedParentRelations(ids[0]); + + for (i = 1; i < ids.length; i++) { + var relsB = sortedParentRelations(ids[i]); + + if (!utilArrayIdentical(relsA, relsB)) { + return 'conflicting_relations'; + } + } // Loop through all combinations of path-pairs + // to check potential intersections between all pairs + + + for (i = 0; i < ids.length - 1; i++) { + for (var j = i + 1; j < ids.length; j++) { + var path1 = graph.childNodes(graph.entity(ids[i])).map(function (e) { + return e.loc; + }); + var path2 = graph.childNodes(graph.entity(ids[j])).map(function (e) { + return e.loc; + }); + var intersections = geoPathIntersections(path1, path2); // Check if intersections are just nodes lying on top of + // each other/the line, as opposed to crossing it + + var common = utilArrayIntersection(joined[0].nodes.map(function (n) { + return n.loc.toString(); + }), intersections.map(function (n) { + return n.toString(); + })); + + if (common.length !== intersections.length) { + return 'paths_intersect'; + } + } + } + + var nodeIds = joined[0].nodes.map(function (n) { + return n.id; + }).slice(1, -1); + var relation; + var tags = {}; + var conflicting = false; + joined[0].forEach(function (way) { + var parents = graph.parentRelations(way); + parents.forEach(function (parent) { + if ((parent.isRestriction() || parent.isConnectivity()) && parent.members.some(function (m) { + return nodeIds.indexOf(m.id) >= 0; + })) { + relation = parent; + } + }); + + for (var k in way.tags) { + if (!(k in tags)) { + tags[k] = way.tags[k]; + } else if (tags[k] && osmIsInterestingTag(k) && tags[k] !== way.tags[k]) { + conflicting = true; + } + } + }); + + if (relation) { + return relation.isRestriction() ? 'restriction' : 'connectivity'; + } + + if (conflicting) { + return 'conflicting_tags'; + } + }; + + return action; + } + + function actionMerge(ids) { + function groupEntitiesByGeometry(graph) { + var entities = ids.map(function (id) { + return graph.entity(id); + }); + return Object.assign({ + point: [], + area: [], + line: [], + relation: [] + }, utilArrayGroupBy(entities, function (entity) { + return entity.geometry(graph); + })); + } + + var action = function action(graph) { + var geometries = groupEntitiesByGeometry(graph); + var target = geometries.area[0] || geometries.line[0]; + var points = geometries.point; + points.forEach(function (point) { + target = target.mergeTags(point.tags); + graph = graph.replace(target); + graph.parentRelations(point).forEach(function (parent) { + graph = graph.replace(parent.replaceMember(point, target)); + }); + var nodes = utilArrayUniq(graph.childNodes(target)); + var removeNode = point; + + if (!point.isNew()) { + // Try to preserve the original point if it already has + // an ID in the database. + var inserted = false; + + var canBeReplaced = function canBeReplaced(node) { + return !(graph.parentWays(node).length > 1 || graph.parentRelations(node).length); + }; + + var replaceNode = function replaceNode(node) { + graph = graph.replace(point.update({ + tags: node.tags, + loc: node.loc + })); + target = target.replaceNode(node.id, point.id); + graph = graph.replace(target); + removeNode = node; + inserted = true; + }; + + var i; + var node; // First, try to replace a new child node on the target way. + + for (i = 0; i < nodes.length; i++) { + node = nodes[i]; + + if (canBeReplaced(node) && node.isNew()) { + replaceNode(node); + break; + } + } + + if (!inserted && point.hasInterestingTags()) { + // No new child node found, try to find an existing, but + // uninteresting child node instead. + for (i = 0; i < nodes.length; i++) { + node = nodes[i]; + + if (canBeReplaced(node) && !node.hasInterestingTags()) { + replaceNode(node); + break; + } + } + + if (!inserted) { + // Still not inserted, try to find an existing, interesting, + // but more recent child node. + for (i = 0; i < nodes.length; i++) { + node = nodes[i]; + + if (canBeReplaced(node) && utilCompareIDs(point.id, node.id) < 0) { + replaceNode(node); + break; + } + } + } // If the point still hasn't been inserted, we give up. + // There are more interesting or older nodes on the way. + + } + } + + graph = graph.remove(removeNode); + }); + + if (target.tags.area === 'yes') { + var tags = Object.assign({}, target.tags); // shallow copy + + delete tags.area; + + if (osmTagSuggestingArea(tags)) { + // remove the `area` tag if area geometry is now implied - #3851 + target = target.update({ + tags: tags + }); + graph = graph.replace(target); + } + } + + return graph; + }; + + action.disabled = function (graph) { + var geometries = groupEntitiesByGeometry(graph); + + if (geometries.point.length === 0 || geometries.area.length + geometries.line.length !== 1 || geometries.relation.length !== 0) { + return 'not_eligible'; + } + }; + + return action; + } + + // + // 1. move all the nodes to a common location + // 2. `actionConnect` them + + function actionMergeNodes(nodeIDs, loc) { + // If there is a single "interesting" node, use that as the location. + // Otherwise return the average location of all the nodes. + function chooseLoc(graph) { + if (!nodeIDs.length) return null; + var sum = [0, 0]; + var interestingCount = 0; + var interestingLoc; + + for (var i = 0; i < nodeIDs.length; i++) { + var node = graph.entity(nodeIDs[i]); + + if (node.hasInterestingTags()) { + interestingLoc = ++interestingCount === 1 ? node.loc : null; + } + + sum = geoVecAdd(sum, node.loc); + } + + return interestingLoc || geoVecScale(sum, 1 / nodeIDs.length); + } + + var action = function action(graph) { + if (nodeIDs.length < 2) return graph; + var toLoc = loc; + + if (!toLoc) { + toLoc = chooseLoc(graph); + } + + for (var i = 0; i < nodeIDs.length; i++) { + var node = graph.entity(nodeIDs[i]); + + if (node.loc !== toLoc) { + graph = graph.replace(node.move(toLoc)); + } + } + + return actionConnect(nodeIDs)(graph); + }; + + action.disabled = function (graph) { + if (nodeIDs.length < 2) return 'not_eligible'; + + for (var i = 0; i < nodeIDs.length; i++) { + var entity = graph.entity(nodeIDs[i]); + if (entity.type !== 'node') return 'not_eligible'; + } + + return actionConnect(nodeIDs).disabled(graph); + }; + + return action; + } + + function osmChangeset() { + if (!(this instanceof osmChangeset)) { + return new osmChangeset().initialize(arguments); + } else if (arguments.length) { + this.initialize(arguments); + } + } + osmEntity.changeset = osmChangeset; + osmChangeset.prototype = Object.create(osmEntity.prototype); + Object.assign(osmChangeset.prototype, { + type: 'changeset', + extent: function extent() { + return new geoExtent(); + }, + geometry: function geometry() { + return 'changeset'; + }, + asJXON: function asJXON() { + return { + osm: { + changeset: { + tag: Object.keys(this.tags).map(function (k) { + return { + '@k': k, + '@v': this.tags[k] + }; + }, this), + '@version': 0.6, + '@generator': 'iD' + } + } + }; + }, + // Generate [osmChange](http://wiki.openstreetmap.org/wiki/OsmChange) + // XML. Returns a string. + osmChangeJXON: function osmChangeJXON(changes) { + var changeset_id = this.id; + + function nest(x, order) { + var groups = {}; + + for (var i = 0; i < x.length; i++) { + var tagName = Object.keys(x[i])[0]; + if (!groups[tagName]) groups[tagName] = []; + groups[tagName].push(x[i][tagName]); + } + + var ordered = {}; + order.forEach(function (o) { + if (groups[o]) ordered[o] = groups[o]; + }); + return ordered; + } // sort relations in a changeset by dependencies + + + function sort(changes) { + // find a referenced relation in the current changeset + function resolve(item) { + return relations.find(function (relation) { + return item.keyAttributes.type === 'relation' && item.keyAttributes.ref === relation['@id']; + }); + } // a new item is an item that has not been already processed + + + function isNew(item) { + return !sorted[item['@id']] && !processing.find(function (proc) { + return proc['@id'] === item['@id']; + }); + } + + var processing = []; + var sorted = {}; + var relations = changes.relation; + if (!relations) return changes; + + for (var i = 0; i < relations.length; i++) { + var relation = relations[i]; // skip relation if already sorted + + if (!sorted[relation['@id']]) { + processing.push(relation); + } + + while (processing.length > 0) { + var next = processing[0], + deps = next.member.map(resolve).filter(Boolean).filter(isNew); + + if (deps.length === 0) { + sorted[next['@id']] = next; + processing.shift(); + } else { + processing = deps.concat(processing); + } + } + } + + changes.relation = Object.values(sorted); + return changes; + } + + function rep(entity) { + return entity.asJXON(changeset_id); + } + + return { + osmChange: { + '@version': 0.6, + '@generator': 'iD', + 'create': sort(nest(changes.created.map(rep), ['node', 'way', 'relation'])), + 'modify': nest(changes.modified.map(rep), ['node', 'way', 'relation']), + 'delete': Object.assign(nest(changes.deleted.map(rep), ['relation', 'way', 'node']), { + '@if-unused': true + }) + } + }; + }, + asGeoJSON: function asGeoJSON() { + return {}; + } + }); + + function osmNote() { + if (!(this instanceof osmNote)) { + return new osmNote().initialize(arguments); + } else if (arguments.length) { + this.initialize(arguments); + } + } + + osmNote.id = function () { + return osmNote.id.next--; + }; + + osmNote.id.next = -1; + Object.assign(osmNote.prototype, { + type: 'note', + initialize: function initialize(sources) { + for (var i = 0; i < sources.length; ++i) { + var source = sources[i]; + + for (var prop in source) { + if (Object.prototype.hasOwnProperty.call(source, prop)) { + if (source[prop] === undefined) { + delete this[prop]; + } else { + this[prop] = source[prop]; + } + } + } + } + + if (!this.id) { + this.id = osmNote.id().toString(); + } + + return this; + }, + extent: function extent() { + return new geoExtent(this.loc); + }, + update: function update(attrs) { + return osmNote(this, attrs); // {v: 1 + (this.v || 0)} + }, + isNew: function isNew() { + return this.id < 0; + }, + move: function move(loc) { + return this.update({ + loc: loc + }); + } + }); + + function osmRelation() { + if (!(this instanceof osmRelation)) { + return new osmRelation().initialize(arguments); + } else if (arguments.length) { + this.initialize(arguments); + } + } + osmEntity.relation = osmRelation; + osmRelation.prototype = Object.create(osmEntity.prototype); + + osmRelation.creationOrder = function (a, b) { + var aId = parseInt(osmEntity.id.toOSM(a.id), 10); + var bId = parseInt(osmEntity.id.toOSM(b.id), 10); + if (aId < 0 || bId < 0) return aId - bId; + return bId - aId; + }; + + Object.assign(osmRelation.prototype, { + type: 'relation', + members: [], + copy: function copy(resolver, copies) { + if (copies[this.id]) return copies[this.id]; + var copy = osmEntity.prototype.copy.call(this, resolver, copies); + var members = this.members.map(function (member) { + return Object.assign({}, member, { + id: resolver.entity(member.id).copy(resolver, copies).id + }); + }); + copy = copy.update({ + members: members + }); + copies[this.id] = copy; + return copy; + }, + extent: function extent(resolver, memo) { + return resolver["transient"](this, 'extent', function () { + if (memo && memo[this.id]) return geoExtent(); + memo = memo || {}; + memo[this.id] = true; + var extent = geoExtent(); + + for (var i = 0; i < this.members.length; i++) { + var member = resolver.hasEntity(this.members[i].id); + + if (member) { + extent._extend(member.extent(resolver, memo)); + } + } + + return extent; + }); + }, + geometry: function geometry(graph) { + return graph["transient"](this, 'geometry', function () { + return this.isMultipolygon() ? 'area' : 'relation'; + }); + }, + isDegenerate: function isDegenerate() { + return this.members.length === 0; + }, + // Return an array of members, each extended with an 'index' property whose value + // is the member index. + indexedMembers: function indexedMembers() { + var result = new Array(this.members.length); + + for (var i = 0; i < this.members.length; i++) { + result[i] = Object.assign({}, this.members[i], { + index: i + }); + } + + return result; + }, + // Return the first member with the given role. A copy of the member object + // is returned, extended with an 'index' property whose value is the member index. + memberByRole: function memberByRole(role) { + for (var i = 0; i < this.members.length; i++) { + if (this.members[i].role === role) { + return Object.assign({}, this.members[i], { + index: i + }); + } + } + }, + // Same as memberByRole, but returns all members with the given role + membersByRole: function membersByRole(role) { + var result = []; + + for (var i = 0; i < this.members.length; i++) { + if (this.members[i].role === role) { + result.push(Object.assign({}, this.members[i], { + index: i + })); + } + } + + return result; + }, + // Return the first member with the given id. A copy of the member object + // is returned, extended with an 'index' property whose value is the member index. + memberById: function memberById(id) { + for (var i = 0; i < this.members.length; i++) { + if (this.members[i].id === id) { + return Object.assign({}, this.members[i], { + index: i + }); + } + } + }, + // Return the first member with the given id and role. A copy of the member object + // is returned, extended with an 'index' property whose value is the member index. + memberByIdAndRole: function memberByIdAndRole(id, role) { + for (var i = 0; i < this.members.length; i++) { + if (this.members[i].id === id && this.members[i].role === role) { + return Object.assign({}, this.members[i], { + index: i + }); + } + } + }, + addMember: function addMember(member, index) { + var members = this.members.slice(); + members.splice(index === undefined ? members.length : index, 0, member); + return this.update({ + members: members + }); + }, + updateMember: function updateMember(member, index) { + var members = this.members.slice(); + members.splice(index, 1, Object.assign({}, members[index], member)); + return this.update({ + members: members + }); + }, + removeMember: function removeMember(index) { + var members = this.members.slice(); + members.splice(index, 1); + return this.update({ + members: members + }); + }, + removeMembersWithID: function removeMembersWithID(id) { + var members = this.members.filter(function (m) { + return m.id !== id; + }); + return this.update({ + members: members + }); + }, + moveMember: function moveMember(fromIndex, toIndex) { + var members = this.members.slice(); + members.splice(toIndex, 0, members.splice(fromIndex, 1)[0]); + return this.update({ + members: members + }); + }, + // Wherever a member appears with id `needle.id`, replace it with a member + // with id `replacement.id`, type `replacement.type`, and the original role, + // By default, adding a duplicate member (by id and role) is prevented. + // Return an updated relation. + replaceMember: function replaceMember(needle, replacement, keepDuplicates) { + if (!this.memberById(needle.id)) return this; + var members = []; + + for (var i = 0; i < this.members.length; i++) { + var member = this.members[i]; + + if (member.id !== needle.id) { + members.push(member); + } else if (keepDuplicates || !this.memberByIdAndRole(replacement.id, member.role)) { + members.push({ + id: replacement.id, + type: replacement.type, + role: member.role + }); + } + } + + return this.update({ + members: members + }); + }, + asJXON: function asJXON(changeset_id) { + var r = { + relation: { + '@id': this.osmId(), + '@version': this.version || 0, + member: this.members.map(function (member) { + return { + keyAttributes: { + type: member.type, + role: member.role, + ref: osmEntity.id.toOSM(member.id) + } + }; + }, this), + tag: Object.keys(this.tags).map(function (k) { + return { + keyAttributes: { + k: k, + v: this.tags[k] + } + }; + }, this) + } + }; + + if (changeset_id) { + r.relation['@changeset'] = changeset_id; + } + + return r; + }, + asGeoJSON: function asGeoJSON(resolver) { + return resolver["transient"](this, 'GeoJSON', function () { + if (this.isMultipolygon()) { + return { + type: 'MultiPolygon', + coordinates: this.multipolygon(resolver) + }; + } else { + return { + type: 'FeatureCollection', + properties: this.tags, + features: this.members.map(function (member) { + return Object.assign({ + role: member.role + }, resolver.entity(member.id).asGeoJSON(resolver)); + }) + }; + } + }); + }, + area: function area(resolver) { + return resolver["transient"](this, 'area', function () { + return d3_geoArea(this.asGeoJSON(resolver)); + }); + }, + isMultipolygon: function isMultipolygon() { + return this.tags.type === 'multipolygon'; + }, + isComplete: function isComplete(resolver) { + for (var i = 0; i < this.members.length; i++) { + if (!resolver.hasEntity(this.members[i].id)) { + return false; + } + } + + return true; + }, + hasFromViaTo: function hasFromViaTo() { + return this.members.some(function (m) { + return m.role === 'from'; + }) && this.members.some(function (m) { + return m.role === 'via'; + }) && this.members.some(function (m) { + return m.role === 'to'; + }); + }, + isRestriction: function isRestriction() { + return !!(this.tags.type && this.tags.type.match(/^restriction:?/)); + }, + isValidRestriction: function isValidRestriction() { + if (!this.isRestriction()) return false; + var froms = this.members.filter(function (m) { + return m.role === 'from'; + }); + var vias = this.members.filter(function (m) { + return m.role === 'via'; + }); + var tos = this.members.filter(function (m) { + return m.role === 'to'; + }); + if (froms.length !== 1 && this.tags.restriction !== 'no_entry') return false; + if (froms.some(function (m) { + return m.type !== 'way'; + })) return false; + if (tos.length !== 1 && this.tags.restriction !== 'no_exit') return false; + if (tos.some(function (m) { + return m.type !== 'way'; + })) return false; + if (vias.length === 0) return false; + if (vias.length > 1 && vias.some(function (m) { + return m.type !== 'way'; + })) return false; + return true; + }, + isConnectivity: function isConnectivity() { + return !!(this.tags.type && this.tags.type.match(/^connectivity:?/)); + }, + // Returns an array [A0, ... An], each Ai being an array of node arrays [Nds0, ... Ndsm], + // where Nds0 is an outer ring and subsequent Ndsi's (if any i > 0) being inner rings. + // + // This corresponds to the structure needed for rendering a multipolygon path using a + // `evenodd` fill rule, as well as the structure of a GeoJSON MultiPolygon geometry. + // + // In the case of invalid geometries, this function will still return a result which + // includes the nodes of all way members, but some Nds may be unclosed and some inner + // rings not matched with the intended outer ring. + // + multipolygon: function multipolygon(resolver) { + var outers = this.members.filter(function (m) { + return 'outer' === (m.role || 'outer'); + }); + var inners = this.members.filter(function (m) { + return 'inner' === m.role; + }); + outers = osmJoinWays(outers, resolver); + inners = osmJoinWays(inners, resolver); + + var sequenceToLineString = function sequenceToLineString(sequence) { + if (sequence.nodes.length > 2 && sequence.nodes[0] !== sequence.nodes[sequence.nodes.length - 1]) { + // close unclosed parts to ensure correct area rendering - #2945 + sequence.nodes.push(sequence.nodes[0]); + } + + return sequence.nodes.map(function (node) { + return node.loc; + }); + }; + + outers = outers.map(sequenceToLineString); + inners = inners.map(sequenceToLineString); + var result = outers.map(function (o) { + // Heuristic for detecting counterclockwise winding order. Assumes + // that OpenStreetMap polygons are not hemisphere-spanning. + return [d3_geoArea({ + type: 'Polygon', + coordinates: [o] + }) > 2 * Math.PI ? o.reverse() : o]; + }); + + function findOuter(inner) { + var o, outer; + + for (o = 0; o < outers.length; o++) { + outer = outers[o]; + + if (geoPolygonContainsPolygon(outer, inner)) { + return o; + } + } + + for (o = 0; o < outers.length; o++) { + outer = outers[o]; + + if (geoPolygonIntersectsPolygon(outer, inner, false)) { + return o; + } + } + } + + for (var i = 0; i < inners.length; i++) { + var inner = inners[i]; + + if (d3_geoArea({ + type: 'Polygon', + coordinates: [inner] + }) < 2 * Math.PI) { + inner = inner.reverse(); + } + + var o = findOuter(inners[i]); + + if (o !== undefined) { + result[o].push(inners[i]); + } else { + result.push([inners[i]]); // Invalid geometry + } + } + + return result; + } + }); + + var QAItem = /*#__PURE__*/function () { + function QAItem(loc, service, itemType, id, props) { + _classCallCheck$1(this, QAItem); + + // Store required properties + this.loc = loc; + this.service = service.title; + this.itemType = itemType; // All issues must have an ID for selection, use generic if none specified + + this.id = id ? id : "".concat(QAItem.id()); + this.update(props); // Some QA services have marker icons to differentiate issues + + if (service && typeof service.getIcon === 'function') { + this.icon = service.getIcon(itemType); + } + } + + _createClass$1(QAItem, [{ + key: "update", + value: function update(props) { + var _this = this; + + // You can't override this initial information + var loc = this.loc, + service = this.service, + itemType = this.itemType, + id = this.id; + Object.keys(props).forEach(function (prop) { + return _this[prop] = props[prop]; + }); + this.loc = loc; + this.service = service; + this.itemType = itemType; + this.id = id; + return this; + } // Generic handling for newly created QAItems + + }], [{ + key: "id", + value: function id() { + return this.nextId--; + } + }]); + + return QAItem; + }(); + QAItem.nextId = -1; + + // + // Optionally, split only the given ways, if multiple ways share + // the given node. + // + // This is the inverse of `iD.actionJoin`. + // + // For testing convenience, accepts an ID to assign to the new way. + // Normally, this will be undefined and the way will automatically + // be assigned a new ID. + // + // Reference: + // https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/SplitWayAction.as + // + + function actionSplit(nodeIds, newWayIds) { + // accept single ID for backwards-compatiblity + if (typeof nodeIds === 'string') nodeIds = [nodeIds]; + + var _wayIDs; // the strategy for picking which way will have a new version and which way is newly created + + + var _keepHistoryOn = 'longest'; // 'longest', 'first' + // The IDs of the ways actually created by running this action + + var _createdWayIDs = []; + + function dist(graph, nA, nB) { + var locA = graph.entity(nA).loc; + var locB = graph.entity(nB).loc; + var epsilon = 1e-6; + return locA && locB ? geoSphericalDistance(locA, locB) : epsilon; + } // If the way is closed, we need to search for a partner node + // to split the way at. + // + // The following looks for a node that is both far away from + // the initial node in terms of way segment length and nearby + // in terms of beeline-distance. This assures that areas get + // split on the most "natural" points (independent of the number + // of nodes). + // For example: bone-shaped areas get split across their waist + // line, circles across the diameter. + + + function splitArea(nodes, idxA, graph) { + var lengths = new Array(nodes.length); + var length; + var i; + var best = 0; + var idxB; + + function wrap(index) { + return utilWrap(index, nodes.length); + } // calculate lengths + + + length = 0; + + for (i = wrap(idxA + 1); i !== idxA; i = wrap(i + 1)) { + length += dist(graph, nodes[i], nodes[wrap(i - 1)]); + lengths[i] = length; + } + + length = 0; + + for (i = wrap(idxA - 1); i !== idxA; i = wrap(i - 1)) { + length += dist(graph, nodes[i], nodes[wrap(i + 1)]); + + if (length < lengths[i]) { + lengths[i] = length; + } + } // determine best opposite node to split + + + for (i = 0; i < nodes.length; i++) { + var cost = lengths[i] / dist(graph, nodes[idxA], nodes[i]); + + if (cost > best) { + idxB = i; + best = cost; + } + } + + return idxB; + } + + function totalLengthBetweenNodes(graph, nodes) { + var totalLength = 0; + + for (var i = 0; i < nodes.length - 1; i++) { + totalLength += dist(graph, nodes[i], nodes[i + 1]); + } + + return totalLength; + } + + function split(graph, nodeId, wayA, newWayId) { + var wayB = osmWay({ + id: newWayId, + tags: wayA.tags + }); // `wayB` is the NEW way + + var origNodes = wayA.nodes.slice(); + var nodesA; + var nodesB; + var isArea = wayA.isArea(); + var isOuter = osmIsOldMultipolygonOuterMember(wayA, graph); + + if (wayA.isClosed()) { + var nodes = wayA.nodes.slice(0, -1); + var idxA = nodes.indexOf(nodeId); + var idxB = splitArea(nodes, idxA, graph); + + if (idxB < idxA) { + nodesA = nodes.slice(idxA).concat(nodes.slice(0, idxB + 1)); + nodesB = nodes.slice(idxB, idxA + 1); + } else { + nodesA = nodes.slice(idxA, idxB + 1); + nodesB = nodes.slice(idxB).concat(nodes.slice(0, idxA + 1)); + } + } else { + var idx = wayA.nodes.indexOf(nodeId, 1); + nodesA = wayA.nodes.slice(0, idx + 1); + nodesB = wayA.nodes.slice(idx); + } + + var lengthA = totalLengthBetweenNodes(graph, nodesA); + var lengthB = totalLengthBetweenNodes(graph, nodesB); + + if (_keepHistoryOn === 'longest' && lengthB > lengthA) { + // keep the history on the longer way, regardless of the node count + wayA = wayA.update({ + nodes: nodesB + }); + wayB = wayB.update({ + nodes: nodesA + }); + var temp = lengthA; + lengthA = lengthB; + lengthB = temp; + } else { + wayA = wayA.update({ + nodes: nodesA + }); + wayB = wayB.update({ + nodes: nodesB + }); + } + + if (wayA.tags.step_count) { + // divide up the the step count proportionally between the two ways + var stepCount = parseFloat(wayA.tags.step_count); + + if (stepCount && // ensure a number + isFinite(stepCount) && // ensure positive + stepCount > 0 && // ensure integer + Math.round(stepCount) === stepCount) { + var tagsA = Object.assign({}, wayA.tags); + var tagsB = Object.assign({}, wayB.tags); + var ratioA = lengthA / (lengthA + lengthB); + var countA = Math.round(stepCount * ratioA); + tagsA.step_count = countA.toString(); + tagsB.step_count = (stepCount - countA).toString(); + wayA = wayA.update({ + tags: tagsA + }); + wayB = wayB.update({ + tags: tagsB + }); + } + } + + graph = graph.replace(wayA); + graph = graph.replace(wayB); + graph.parentRelations(wayA).forEach(function (relation) { + var member; // Turn restrictions - make sure: + // 1. Splitting a FROM/TO way - only `wayA` OR `wayB` remains in relation + // (whichever one is connected to the VIA node/ways) + // 2. Splitting a VIA way - `wayB` remains in relation as a VIA way + + if (relation.hasFromViaTo()) { + var f = relation.memberByRole('from'); + var v = relation.membersByRole('via'); + var t = relation.memberByRole('to'); + var i; // 1. split a FROM/TO + + if (f.id === wayA.id || t.id === wayA.id) { + var keepB = false; + + if (v.length === 1 && v[0].type === 'node') { + // check via node + keepB = wayB.contains(v[0].id); + } else { + // check via way(s) + for (i = 0; i < v.length; i++) { + if (v[i].type === 'way') { + var wayVia = graph.hasEntity(v[i].id); + + if (wayVia && utilArrayIntersection(wayB.nodes, wayVia.nodes).length) { + keepB = true; + break; + } + } + } + } + + if (keepB) { + relation = relation.replaceMember(wayA, wayB); + graph = graph.replace(relation); + } // 2. split a VIA + + } else { + for (i = 0; i < v.length; i++) { + if (v[i].type === 'way' && v[i].id === wayA.id) { + member = { + id: wayB.id, + type: 'way', + role: 'via' + }; + graph = actionAddMember(relation.id, member, v[i].index + 1)(graph); + break; + } + } + } // All other relations (Routes, Multipolygons, etc): + // 1. Both `wayA` and `wayB` remain in the relation + // 2. But must be inserted as a pair (see `actionAddMember` for details) + + } else { + if (relation === isOuter) { + graph = graph.replace(relation.mergeTags(wayA.tags)); + graph = graph.replace(wayA.update({ + tags: {} + })); + graph = graph.replace(wayB.update({ + tags: {} + })); + } + + member = { + id: wayB.id, + type: 'way', + role: relation.memberById(wayA.id).role + }; + var insertPair = { + originalID: wayA.id, + insertedID: wayB.id, + nodes: origNodes + }; + graph = actionAddMember(relation.id, member, undefined, insertPair)(graph); + } + }); + + if (!isOuter && isArea) { + var multipolygon = osmRelation({ + tags: Object.assign({}, wayA.tags, { + type: 'multipolygon' + }), + members: [{ + id: wayA.id, + role: 'outer', + type: 'way' + }, { + id: wayB.id, + role: 'outer', + type: 'way' + }] + }); + graph = graph.replace(multipolygon); + graph = graph.replace(wayA.update({ + tags: {} + })); + graph = graph.replace(wayB.update({ + tags: {} + })); + } + + _createdWayIDs.push(wayB.id); + + return graph; + } + + var action = function action(graph) { + _createdWayIDs = []; + var newWayIndex = 0; + + for (var i = 0; i < nodeIds.length; i++) { + var nodeId = nodeIds[i]; + var candidates = action.waysForNode(nodeId, graph); + + for (var j = 0; j < candidates.length; j++) { + graph = split(graph, nodeId, candidates[j], newWayIds && newWayIds[newWayIndex]); + newWayIndex += 1; + } + } + + return graph; + }; + + action.getCreatedWayIDs = function () { + return _createdWayIDs; + }; + + action.waysForNode = function (nodeId, graph) { + var node = graph.entity(nodeId); + var splittableParents = graph.parentWays(node).filter(isSplittable); + + if (!_wayIDs) { + // If the ways to split aren't specified, only split the lines. + // If there are no lines to split, split the areas. + var hasLine = splittableParents.some(function (parent) { + return parent.geometry(graph) === 'line'; + }); + + if (hasLine) { + return splittableParents.filter(function (parent) { + return parent.geometry(graph) === 'line'; + }); + } + } + + return splittableParents; + + function isSplittable(parent) { + // If the ways to split are specified, ignore everything else. + if (_wayIDs && _wayIDs.indexOf(parent.id) === -1) return false; // We can fake splitting closed ways at their endpoints... + + if (parent.isClosed()) return true; // otherwise, we can't split nodes at their endpoints. + + for (var i = 1; i < parent.nodes.length - 1; i++) { + if (parent.nodes[i] === nodeId) return true; + } + + return false; + } + }; + + action.ways = function (graph) { + return utilArrayUniq([].concat.apply([], nodeIds.map(function (nodeId) { + return action.waysForNode(nodeId, graph); + }))); + }; + + action.disabled = function (graph) { + for (var i = 0; i < nodeIds.length; i++) { + var nodeId = nodeIds[i]; + var candidates = action.waysForNode(nodeId, graph); + + if (candidates.length === 0 || _wayIDs && _wayIDs.length !== candidates.length) { + return 'not_eligible'; + } + } + }; + + action.limitWays = function (val) { + if (!arguments.length) return _wayIDs; + _wayIDs = val; + return action; + }; + + action.keepHistoryOn = function (val) { + if (!arguments.length) return _keepHistoryOn; + _keepHistoryOn = val; + return action; + }; + + return action; + } + + function coreGraph(other, mutable) { + if (!(this instanceof coreGraph)) return new coreGraph(other, mutable); + + if (other instanceof coreGraph) { + var base = other.base(); + this.entities = Object.assign(Object.create(base.entities), other.entities); + this._parentWays = Object.assign(Object.create(base.parentWays), other._parentWays); + this._parentRels = Object.assign(Object.create(base.parentRels), other._parentRels); + } else { + this.entities = Object.create({}); + this._parentWays = Object.create({}); + this._parentRels = Object.create({}); + this.rebase(other || [], [this]); + } + + this.transients = {}; + this._childNodes = {}; + this.frozen = !mutable; + } + coreGraph.prototype = { + hasEntity: function hasEntity(id) { + return this.entities[id]; + }, + entity: function entity(id) { + var entity = this.entities[id]; //https://github.com/openstreetmap/iD/issues/3973#issuecomment-307052376 + + if (!entity) { + entity = this.entities.__proto__[id]; // eslint-disable-line no-proto + } + + if (!entity) { + throw new Error('entity ' + id + ' not found'); + } + + return entity; + }, + geometry: function geometry(id) { + return this.entity(id).geometry(this); + }, + "transient": function transient(entity, key, fn) { + var id = entity.id; + var transients = this.transients[id] || (this.transients[id] = {}); + + if (transients[key] !== undefined) { + return transients[key]; + } + + transients[key] = fn.call(entity); + return transients[key]; + }, + parentWays: function parentWays(entity) { + var parents = this._parentWays[entity.id]; + var result = []; + + if (parents) { + parents.forEach(function (id) { + result.push(this.entity(id)); + }, this); + } + + return result; + }, + isPoi: function isPoi(entity) { + var parents = this._parentWays[entity.id]; + return !parents || parents.size === 0; + }, + isShared: function isShared(entity) { + var parents = this._parentWays[entity.id]; + return parents && parents.size > 1; + }, + parentRelations: function parentRelations(entity) { + var parents = this._parentRels[entity.id]; + var result = []; + + if (parents) { + parents.forEach(function (id) { + result.push(this.entity(id)); + }, this); + } + + return result; + }, + parentMultipolygons: function parentMultipolygons(entity) { + return this.parentRelations(entity).filter(function (relation) { + return relation.isMultipolygon(); + }); + }, + childNodes: function childNodes(entity) { + if (this._childNodes[entity.id]) return this._childNodes[entity.id]; + if (!entity.nodes) return []; + var nodes = []; + + for (var i = 0; i < entity.nodes.length; i++) { + nodes[i] = this.entity(entity.nodes[i]); + } + this._childNodes[entity.id] = nodes; + return this._childNodes[entity.id]; + }, + base: function base() { + return { + 'entities': Object.getPrototypeOf(this.entities), + 'parentWays': Object.getPrototypeOf(this._parentWays), + 'parentRels': Object.getPrototypeOf(this._parentRels) + }; + }, + // Unlike other graph methods, rebase mutates in place. This is because it + // is used only during the history operation that merges newly downloaded + // data into each state. To external consumers, it should appear as if the + // graph always contained the newly downloaded data. + rebase: function rebase(entities, stack, force) { + var base = this.base(); + var i, j, k, id; + + for (i = 0; i < entities.length; i++) { + var entity = entities[i]; + if (!entity.visible || !force && base.entities[entity.id]) continue; // Merging data into the base graph + + base.entities[entity.id] = entity; + + this._updateCalculated(undefined, entity, base.parentWays, base.parentRels); // Restore provisionally-deleted nodes that are discovered to have an extant parent + + + if (entity.type === 'way') { + for (j = 0; j < entity.nodes.length; j++) { + id = entity.nodes[j]; + + for (k = 1; k < stack.length; k++) { + var ents = stack[k].entities; + + if (ents.hasOwnProperty(id) && ents[id] === undefined) { + delete ents[id]; + } + } + } + } + } + + for (i = 0; i < stack.length; i++) { + stack[i]._updateRebased(); + } + }, + _updateRebased: function _updateRebased() { + var base = this.base(); + Object.keys(this._parentWays).forEach(function (child) { + if (base.parentWays[child]) { + base.parentWays[child].forEach(function (id) { + if (!this.entities.hasOwnProperty(id)) { + this._parentWays[child].add(id); + } + }, this); + } + }, this); + Object.keys(this._parentRels).forEach(function (child) { + if (base.parentRels[child]) { + base.parentRels[child].forEach(function (id) { + if (!this.entities.hasOwnProperty(id)) { + this._parentRels[child].add(id); + } + }, this); + } + }, this); + this.transients = {}; // this._childNodes is not updated, under the assumption that + // ways are always downloaded with their child nodes. + }, + // Updates calculated properties (parentWays, parentRels) for the specified change + _updateCalculated: function _updateCalculated(oldentity, entity, parentWays, parentRels) { + parentWays = parentWays || this._parentWays; + parentRels = parentRels || this._parentRels; + var type = entity && entity.type || oldentity && oldentity.type; + var removed, added, i; + + if (type === 'way') { + // Update parentWays + if (oldentity && entity) { + removed = utilArrayDifference(oldentity.nodes, entity.nodes); + added = utilArrayDifference(entity.nodes, oldentity.nodes); + } else if (oldentity) { + removed = oldentity.nodes; + added = []; + } else if (entity) { + removed = []; + added = entity.nodes; + } + + for (i = 0; i < removed.length; i++) { + // make a copy of prototype property, store as own property, and update.. + parentWays[removed[i]] = new Set(parentWays[removed[i]]); + parentWays[removed[i]]["delete"](oldentity.id); + } + + for (i = 0; i < added.length; i++) { + // make a copy of prototype property, store as own property, and update.. + parentWays[added[i]] = new Set(parentWays[added[i]]); + parentWays[added[i]].add(entity.id); + } + } else if (type === 'relation') { + // Update parentRels + // diff only on the IDs since the same entity can be a member multiple times with different roles + var oldentityMemberIDs = oldentity ? oldentity.members.map(function (m) { + return m.id; + }) : []; + var entityMemberIDs = entity ? entity.members.map(function (m) { + return m.id; + }) : []; + + if (oldentity && entity) { + removed = utilArrayDifference(oldentityMemberIDs, entityMemberIDs); + added = utilArrayDifference(entityMemberIDs, oldentityMemberIDs); + } else if (oldentity) { + removed = oldentityMemberIDs; + added = []; + } else if (entity) { + removed = []; + added = entityMemberIDs; + } + + for (i = 0; i < removed.length; i++) { + // make a copy of prototype property, store as own property, and update.. + parentRels[removed[i]] = new Set(parentRels[removed[i]]); + parentRels[removed[i]]["delete"](oldentity.id); + } + + for (i = 0; i < added.length; i++) { + // make a copy of prototype property, store as own property, and update.. + parentRels[added[i]] = new Set(parentRels[added[i]]); + parentRels[added[i]].add(entity.id); + } + } + }, + replace: function replace(entity) { + if (this.entities[entity.id] === entity) return this; + return this.update(function () { + this._updateCalculated(this.entities[entity.id], entity); + + this.entities[entity.id] = entity; + }); + }, + remove: function remove(entity) { + return this.update(function () { + this._updateCalculated(entity, undefined); + + this.entities[entity.id] = undefined; + }); + }, + revert: function revert(id) { + var baseEntity = this.base().entities[id]; + var headEntity = this.entities[id]; + if (headEntity === baseEntity) return this; + return this.update(function () { + this._updateCalculated(headEntity, baseEntity); + + delete this.entities[id]; + }); + }, + update: function update() { + var graph = this.frozen ? coreGraph(this, true) : this; + + for (var i = 0; i < arguments.length; i++) { + arguments[i].call(graph, graph); + } + + if (this.frozen) graph.frozen = true; + return graph; + }, + // Obliterates any existing entities + load: function load(entities) { + var base = this.base(); + this.entities = Object.create(base.entities); + + for (var i in entities) { + this.entities[i] = entities[i]; + + this._updateCalculated(base.entities[i], this.entities[i]); + } + + return this; + } + }; + + function osmTurn(turn) { + if (!(this instanceof osmTurn)) { + return new osmTurn(turn); + } + + Object.assign(this, turn); + } + function osmIntersection(graph, startVertexId, maxDistance) { + maxDistance = maxDistance || 30; // in meters + + var vgraph = coreGraph(); // virtual graph + + var i, j, k; + + function memberOfRestriction(entity) { + return graph.parentRelations(entity).some(function (r) { + return r.isRestriction(); + }); + } + + function isRoad(way) { + if (way.isArea() || way.isDegenerate()) return false; + var roads = { + 'motorway': true, + 'motorway_link': true, + 'trunk': true, + 'trunk_link': true, + 'primary': true, + 'primary_link': true, + 'secondary': true, + 'secondary_link': true, + 'tertiary': true, + 'tertiary_link': true, + 'residential': true, + 'unclassified': true, + 'living_street': true, + 'service': true, + 'road': true, + 'track': true + }; + return roads[way.tags.highway]; + } + + var startNode = graph.entity(startVertexId); + var checkVertices = [startNode]; + var checkWays; + var vertices = []; + var vertexIds = []; + var vertex; + var ways = []; + var wayIds = []; + var way; + var nodes = []; + var node; + var parents = []; + var parent; // `actions` will store whatever actions must be performed to satisfy + // preconditions for adding a turn restriction to this intersection. + // - Remove any existing degenerate turn restrictions (missing from/to, etc) + // - Reverse oneways so that they are drawn in the forward direction + // - Split ways on key vertices + + var actions = []; // STEP 1: walk the graph outwards from starting vertex to search + // for more key vertices and ways to include in the intersection.. + + while (checkVertices.length) { + vertex = checkVertices.pop(); // check this vertex for parent ways that are roads + + checkWays = graph.parentWays(vertex); + var hasWays = false; + + for (i = 0; i < checkWays.length; i++) { + way = checkWays[i]; + if (!isRoad(way) && !memberOfRestriction(way)) continue; + ways.push(way); // it's a road, or it's already in a turn restriction + + hasWays = true; // check the way's children for more key vertices + + nodes = utilArrayUniq(graph.childNodes(way)); + + for (j = 0; j < nodes.length; j++) { + node = nodes[j]; + if (node === vertex) continue; // same thing + + if (vertices.indexOf(node) !== -1) continue; // seen it already + + if (geoSphericalDistance(node.loc, startNode.loc) > maxDistance) continue; // too far from start + // a key vertex will have parents that are also roads + + var hasParents = false; + parents = graph.parentWays(node); + + for (k = 0; k < parents.length; k++) { + parent = parents[k]; + if (parent === way) continue; // same thing + + if (ways.indexOf(parent) !== -1) continue; // seen it already + + if (!isRoad(parent)) continue; // not a road + + hasParents = true; + break; + } + + if (hasParents) { + checkVertices.push(node); + } + } + } + + if (hasWays) { + vertices.push(vertex); + } + } + + vertices = utilArrayUniq(vertices); + ways = utilArrayUniq(ways); // STEP 2: Build a virtual graph containing only the entities in the intersection.. + // Everything done after this step should act on the virtual graph + // Any actions that must be performed later to the main graph go in `actions` array + + ways.forEach(function (way) { + graph.childNodes(way).forEach(function (node) { + vgraph = vgraph.replace(node); + }); + vgraph = vgraph.replace(way); + graph.parentRelations(way).forEach(function (relation) { + if (relation.isRestriction()) { + if (relation.isValidRestriction(graph)) { + vgraph = vgraph.replace(relation); + } else if (relation.isComplete(graph)) { + actions.push(actionDeleteRelation(relation.id)); + } + } + }); + }); // STEP 3: Force all oneways to be drawn in the forward direction + + ways.forEach(function (w) { + var way = vgraph.entity(w.id); + + if (way.tags.oneway === '-1') { + var action = actionReverse(way.id, { + reverseOneway: true + }); + actions.push(action); + vgraph = action(vgraph); + } + }); // STEP 4: Split ways on key vertices + + var origCount = osmEntity.id.next.way; + vertices.forEach(function (v) { + // This is an odd way to do it, but we need to find all the ways that + // will be split here, then split them one at a time to ensure that these + // actions can be replayed on the main graph exactly in the same order. + // (It is unintuitive, but the order of ways returned from graph.parentWays() + // is arbitrary, depending on how the main graph and vgraph were built) + var splitAll = actionSplit([v.id]).keepHistoryOn('first'); + + if (!splitAll.disabled(vgraph)) { + splitAll.ways(vgraph).forEach(function (way) { + var splitOne = actionSplit([v.id]).limitWays([way.id]).keepHistoryOn('first'); + actions.push(splitOne); + vgraph = splitOne(vgraph); + }); + } + }); // In here is where we should also split the intersection at nearby junction. + // for https://github.com/mapbox/iD-internal/issues/31 + // nearbyVertices.forEach(function(v) { + // }); + // Reasons why we reset the way id count here: + // 1. Continuity with way ids created by the splits so that we can replay + // these actions later if the user decides to create a turn restriction + // 2. Avoids churning way ids just by hovering over a vertex + // and displaying the turn restriction editor + + osmEntity.id.next.way = origCount; // STEP 5: Update arrays to point to vgraph entities + + vertexIds = vertices.map(function (v) { + return v.id; + }); + vertices = []; + ways = []; + vertexIds.forEach(function (id) { + var vertex = vgraph.entity(id); + var parents = vgraph.parentWays(vertex); + vertices.push(vertex); + ways = ways.concat(parents); + }); + vertices = utilArrayUniq(vertices); + ways = utilArrayUniq(ways); + vertexIds = vertices.map(function (v) { + return v.id; + }); + wayIds = ways.map(function (w) { + return w.id; + }); // STEP 6: Update the ways with some metadata that will be useful for + // walking the intersection graph later and rendering turn arrows. + + function withMetadata(way, vertexIds) { + var __oneWay = way.isOneWay(); // which affixes are key vertices? + + + var __first = vertexIds.indexOf(way.first()) !== -1; + + var __last = vertexIds.indexOf(way.last()) !== -1; // what roles is this way eligible for? + + + var __via = __first && __last; + + var __from = __first && !__oneWay || __last; + + var __to = __first || __last && !__oneWay; + + return way.update({ + __first: __first, + __last: __last, + __from: __from, + __via: __via, + __to: __to, + __oneWay: __oneWay + }); + } + + ways = []; + wayIds.forEach(function (id) { + var way = withMetadata(vgraph.entity(id), vertexIds); + vgraph = vgraph.replace(way); + ways.push(way); + }); // STEP 7: Simplify - This is an iterative process where we: + // 1. Find trivial vertices with only 2 parents + // 2. trim off the leaf way from those vertices and remove from vgraph + + var keepGoing; + var removeWayIds = []; + var removeVertexIds = []; + + do { + keepGoing = false; + checkVertices = vertexIds.slice(); + + for (i = 0; i < checkVertices.length; i++) { + var vertexId = checkVertices[i]; + vertex = vgraph.hasEntity(vertexId); + + if (!vertex) { + if (vertexIds.indexOf(vertexId) !== -1) { + vertexIds.splice(vertexIds.indexOf(vertexId), 1); // stop checking this one + } + + removeVertexIds.push(vertexId); + continue; + } + + parents = vgraph.parentWays(vertex); + + if (parents.length < 3) { + if (vertexIds.indexOf(vertexId) !== -1) { + vertexIds.splice(vertexIds.indexOf(vertexId), 1); // stop checking this one + } + } + + if (parents.length === 2) { + // vertex with 2 parents is trivial + var a = parents[0]; + var b = parents[1]; + var aIsLeaf = a && !a.__via; + var bIsLeaf = b && !b.__via; + var leaf, survivor; + + if (aIsLeaf && !bIsLeaf) { + leaf = a; + survivor = b; + } else if (!aIsLeaf && bIsLeaf) { + leaf = b; + survivor = a; + } + + if (leaf && survivor) { + survivor = withMetadata(survivor, vertexIds); // update survivor way + + vgraph = vgraph.replace(survivor).remove(leaf); // update graph + + removeWayIds.push(leaf.id); + keepGoing = true; + } + } + + parents = vgraph.parentWays(vertex); + + if (parents.length < 2) { + // vertex is no longer a key vertex + if (vertexIds.indexOf(vertexId) !== -1) { + vertexIds.splice(vertexIds.indexOf(vertexId), 1); // stop checking this one + } + + removeVertexIds.push(vertexId); + keepGoing = true; + } + + if (parents.length < 1) { + // vertex is no longer attached to anything + vgraph = vgraph.remove(vertex); + } + } + } while (keepGoing); + + vertices = vertices.filter(function (vertex) { + return removeVertexIds.indexOf(vertex.id) === -1; + }).map(function (vertex) { + return vgraph.entity(vertex.id); + }); + ways = ways.filter(function (way) { + return removeWayIds.indexOf(way.id) === -1; + }).map(function (way) { + return vgraph.entity(way.id); + }); // OK! Here is our intersection.. + + var intersection = { + graph: vgraph, + actions: actions, + vertices: vertices, + ways: ways + }; // Get all the valid turns through this intersection given a starting way id. + // This operates on the virtual graph for everything. + // + // Basically, walk through all possible paths from starting way, + // honoring the existing turn restrictions as we go (watch out for loops!) + // + // For each path found, generate and return a `osmTurn` datastructure. + // + + intersection.turns = function (fromWayId, maxViaWay) { + if (!fromWayId) return []; + if (!maxViaWay) maxViaWay = 0; + var vgraph = intersection.graph; + var keyVertexIds = intersection.vertices.map(function (v) { + return v.id; + }); + var start = vgraph.entity(fromWayId); + if (!start || !(start.__from || start.__via)) return []; // maxViaWay=0 from-*-to (0 vias) + // maxViaWay=1 from-*-via-*-to (1 via max) + // maxViaWay=2 from-*-via-*-via-*-to (2 vias max) + + var maxPathLength = maxViaWay * 2 + 3; + var turns = []; + step(start); + return turns; // traverse the intersection graph and find all the valid paths + + function step(entity, currPath, currRestrictions, matchedRestriction) { + currPath = (currPath || []).slice(); // shallow copy + + if (currPath.length >= maxPathLength) return; + currPath.push(entity.id); + currRestrictions = (currRestrictions || []).slice(); // shallow copy + + var i, j; + + if (entity.type === 'node') { + var parents = vgraph.parentWays(entity); + var nextWays = []; // which ways can we step into? + + for (i = 0; i < parents.length; i++) { + var way = parents[i]; // if next way is a oneway incoming to this vertex, skip + + if (way.__oneWay && way.nodes[0] !== entity.id) continue; // if we have seen it before (allowing for an initial u-turn), skip + + if (currPath.indexOf(way.id) !== -1 && currPath.length >= 3) continue; // Check all "current" restrictions (where we've already walked the `FROM`) + + var restrict = null; + + for (j = 0; j < currRestrictions.length; j++) { + var restriction = currRestrictions[j]; + var f = restriction.memberByRole('from'); + var v = restriction.membersByRole('via'); + var t = restriction.memberByRole('to'); + var isOnly = /^only_/.test(restriction.tags.restriction); // Does the current path match this turn restriction? + + var matchesFrom = f.id === fromWayId; + var matchesViaTo = false; + var isAlongOnlyPath = false; + + if (t.id === way.id) { + // match TO + if (v.length === 1 && v[0].type === 'node') { + // match VIA node + matchesViaTo = v[0].id === entity.id && (matchesFrom && currPath.length === 2 || !matchesFrom && currPath.length > 2); + } else { + // match all VIA ways + var pathVias = []; + + for (k = 2; k < currPath.length; k += 2) { + // k = 2 skips FROM + pathVias.push(currPath[k]); // (path goes way-node-way...) + } + + var restrictionVias = []; + + for (k = 0; k < v.length; k++) { + if (v[k].type === 'way') { + restrictionVias.push(v[k].id); + } + } + + var diff = utilArrayDifference(pathVias, restrictionVias); + matchesViaTo = !diff.length; + } + } else if (isOnly) { + for (k = 0; k < v.length; k++) { + // way doesn't match TO, but is one of the via ways along the path of an "only" + if (v[k].type === 'way' && v[k].id === way.id) { + isAlongOnlyPath = true; + break; + } + } + } + + if (matchesViaTo) { + if (isOnly) { + restrict = { + id: restriction.id, + direct: matchesFrom, + from: f.id, + only: true, + end: true + }; + } else { + restrict = { + id: restriction.id, + direct: matchesFrom, + from: f.id, + no: true, + end: true + }; + } + } else { + // indirect - caused by a different nearby restriction + if (isAlongOnlyPath) { + restrict = { + id: restriction.id, + direct: false, + from: f.id, + only: true, + end: false + }; + } else if (isOnly) { + restrict = { + id: restriction.id, + direct: false, + from: f.id, + no: true, + end: true + }; + } + } // stop looking if we find a "direct" restriction (matching FROM, VIA, TO) + + + if (restrict && restrict.direct) break; + } + + nextWays.push({ + way: way, + restrict: restrict + }); + } + + nextWays.forEach(function (nextWay) { + step(nextWay.way, currPath, currRestrictions, nextWay.restrict); + }); + } else { + // entity.type === 'way' + if (currPath.length >= 3) { + // this is a "complete" path.. + var turnPath = currPath.slice(); // shallow copy + // an indirect restriction - only include the partial path (starting at FROM) + + if (matchedRestriction && matchedRestriction.direct === false) { + for (i = 0; i < turnPath.length; i++) { + if (turnPath[i] === matchedRestriction.from) { + turnPath = turnPath.slice(i); + break; + } + } + } + + var turn = pathToTurn(turnPath); + + if (turn) { + if (matchedRestriction) { + turn.restrictionID = matchedRestriction.id; + turn.no = matchedRestriction.no; + turn.only = matchedRestriction.only; + turn.direct = matchedRestriction.direct; + } + + turns.push(osmTurn(turn)); + } + + if (currPath[0] === currPath[2]) return; // if we made a u-turn - stop here + } + + if (matchedRestriction && matchedRestriction.end) return; // don't advance any further + // which nodes can we step into? + + var n1 = vgraph.entity(entity.first()); + var n2 = vgraph.entity(entity.last()); + var dist = geoSphericalDistance(n1.loc, n2.loc); + var nextNodes = []; + + if (currPath.length > 1) { + if (dist > maxDistance) return; // the next node is too far + + if (!entity.__via) return; // this way is a leaf / can't be a via + } + + if (!entity.__oneWay && // bidirectional.. + keyVertexIds.indexOf(n1.id) !== -1 && // key vertex.. + currPath.indexOf(n1.id) === -1) { + // haven't seen it yet.. + nextNodes.push(n1); // can advance to first node + } + + if (keyVertexIds.indexOf(n2.id) !== -1 && // key vertex.. + currPath.indexOf(n2.id) === -1) { + // haven't seen it yet.. + nextNodes.push(n2); // can advance to last node + } + + nextNodes.forEach(function (nextNode) { + // gather restrictions FROM this way + var fromRestrictions = vgraph.parentRelations(entity).filter(function (r) { + if (!r.isRestriction()) return false; + var f = r.memberByRole('from'); + if (!f || f.id !== entity.id) return false; + var isOnly = /^only_/.test(r.tags.restriction); + if (!isOnly) return true; // `only_` restrictions only matter along the direction of the VIA - #4849 + + var isOnlyVia = false; + var v = r.membersByRole('via'); + + if (v.length === 1 && v[0].type === 'node') { + // via node + isOnlyVia = v[0].id === nextNode.id; + } else { + // via way(s) + for (var i = 0; i < v.length; i++) { + if (v[i].type !== 'way') continue; + var viaWay = vgraph.entity(v[i].id); + + if (viaWay.first() === nextNode.id || viaWay.last() === nextNode.id) { + isOnlyVia = true; + break; + } + } + } + + return isOnlyVia; + }); + step(nextNode, currPath, currRestrictions.concat(fromRestrictions), false); + }); + } + } // assumes path is alternating way-node-way of odd length + + + function pathToTurn(path) { + if (path.length < 3) return; + var fromWayId, fromNodeId, fromVertexId; + var toWayId, toNodeId, toVertexId; + var viaWayIds, viaNodeId, isUturn; + fromWayId = path[0]; + toWayId = path[path.length - 1]; + + if (path.length === 3 && fromWayId === toWayId) { + // u turn + var way = vgraph.entity(fromWayId); + if (way.__oneWay) return null; + isUturn = true; + viaNodeId = fromVertexId = toVertexId = path[1]; + fromNodeId = toNodeId = adjacentNode(fromWayId, viaNodeId); + } else { + isUturn = false; + fromVertexId = path[1]; + fromNodeId = adjacentNode(fromWayId, fromVertexId); + toVertexId = path[path.length - 2]; + toNodeId = adjacentNode(toWayId, toVertexId); + + if (path.length === 3) { + viaNodeId = path[1]; + } else { + viaWayIds = path.filter(function (entityId) { + return entityId[0] === 'w'; + }); + viaWayIds = viaWayIds.slice(1, viaWayIds.length - 1); // remove first, last + } + } + + return { + key: path.join('_'), + path: path, + from: { + node: fromNodeId, + way: fromWayId, + vertex: fromVertexId + }, + via: { + node: viaNodeId, + ways: viaWayIds + }, + to: { + node: toNodeId, + way: toWayId, + vertex: toVertexId + }, + u: isUturn + }; + + function adjacentNode(wayId, affixId) { + var nodes = vgraph.entity(wayId).nodes; + return affixId === nodes[0] ? nodes[1] : nodes[nodes.length - 2]; + } + } + }; + + return intersection; + } + function osmInferRestriction(graph, turn, projection) { + var fromWay = graph.entity(turn.from.way); + var fromNode = graph.entity(turn.from.node); + var fromVertex = graph.entity(turn.from.vertex); + var toWay = graph.entity(turn.to.way); + var toNode = graph.entity(turn.to.node); + var toVertex = graph.entity(turn.to.vertex); + var fromOneWay = fromWay.tags.oneway === 'yes'; + var toOneWay = toWay.tags.oneway === 'yes'; + var angle = (geoAngle(fromVertex, fromNode, projection) - geoAngle(toVertex, toNode, projection)) * 180 / Math.PI; + + while (angle < 0) { + angle += 360; + } + + if (fromNode === toNode) { + return 'no_u_turn'; + } + + if ((angle < 23 || angle > 336) && fromOneWay && toOneWay) { + return 'no_u_turn'; // wider tolerance for u-turn if both ways are oneway + } + + if ((angle < 40 || angle > 319) && fromOneWay && toOneWay && turn.from.vertex !== turn.to.vertex) { + return 'no_u_turn'; // even wider tolerance for u-turn if there is a via way (from !== to) + } + + if (angle < 158) { + return 'no_right_turn'; + } + + if (angle > 202) { + return 'no_left_turn'; + } + + return 'no_straight_on'; + } + + function actionMergePolygon(ids, newRelationId) { + function groupEntities(graph) { + var entities = ids.map(function (id) { + return graph.entity(id); + }); + var geometryGroups = utilArrayGroupBy(entities, function (entity) { + if (entity.type === 'way' && entity.isClosed()) { + return 'closedWay'; + } else if (entity.type === 'relation' && entity.isMultipolygon()) { + return 'multipolygon'; + } else { + return 'other'; + } + }); + return Object.assign({ + closedWay: [], + multipolygon: [], + other: [] + }, geometryGroups); + } + + var action = function action(graph) { + var entities = groupEntities(graph); // An array representing all the polygons that are part of the multipolygon. + // + // Each element is itself an array of objects with an id property, and has a + // locs property which is an array of the locations forming the polygon. + + var polygons = entities.multipolygon.reduce(function (polygons, m) { + return polygons.concat(osmJoinWays(m.members, graph)); + }, []).concat(entities.closedWay.map(function (d) { + var member = [{ + id: d.id + }]; + member.nodes = graph.childNodes(d); + return member; + })); // contained is an array of arrays of boolean values, + // where contained[j][k] is true iff the jth way is + // contained by the kth way. + + var contained = polygons.map(function (w, i) { + return polygons.map(function (d, n) { + if (i === n) return null; + return geoPolygonContainsPolygon(d.nodes.map(function (n) { + return n.loc; + }), w.nodes.map(function (n) { + return n.loc; + })); + }); + }); // Sort all polygons as either outer or inner ways + + var members = []; + var outer = true; + + while (polygons.length) { + extractUncontained(polygons); + polygons = polygons.filter(isContained); + contained = contained.filter(isContained).map(filterContained); + } + + function isContained(d, i) { + return contained[i].some(function (val) { + return val; + }); + } + + function filterContained(d) { + return d.filter(isContained); + } + + function extractUncontained(polygons) { + polygons.forEach(function (d, i) { + if (!isContained(d, i)) { + d.forEach(function (member) { + members.push({ + type: 'way', + id: member.id, + role: outer ? 'outer' : 'inner' + }); + }); + } + }); + outer = !outer; + } // Move all tags to one relation. + // Keep the oldest multipolygon alive if it exists. + + + var relation; + + if (entities.multipolygon.length > 0) { + var oldestID = utilOldestID(entities.multipolygon.map(function (entity) { + return entity.id; + })); + relation = entities.multipolygon.find(function (entity) { + return entity.id === oldestID; + }); + } else { + relation = osmRelation({ + id: newRelationId, + tags: { + type: 'multipolygon' + } + }); + } + + entities.multipolygon.forEach(function (m) { + if (m.id !== relation.id) { + relation = relation.mergeTags(m.tags); + graph = graph.remove(m); + } + }); + entities.closedWay.forEach(function (way) { + function isThisOuter(m) { + return m.id === way.id && m.role !== 'inner'; + } + + if (members.some(isThisOuter)) { + relation = relation.mergeTags(way.tags); + graph = graph.replace(way.update({ + tags: {} + })); + } + }); + return graph.replace(relation.update({ + members: members, + tags: utilObjectOmit(relation.tags, ['area']) + })); + }; + + action.disabled = function (graph) { + var entities = groupEntities(graph); + + if (entities.other.length > 0 || entities.closedWay.length + entities.multipolygon.length < 2) { + return 'not_eligible'; + } + + if (!entities.multipolygon.every(function (r) { + return r.isComplete(graph); + })) { + return 'incomplete_relation'; + } + + if (!entities.multipolygon.length) { + var sharedMultipolygons = []; + entities.closedWay.forEach(function (way, i) { + if (i === 0) { + sharedMultipolygons = graph.parentMultipolygons(way); + } else { + sharedMultipolygons = utilArrayIntersection(sharedMultipolygons, graph.parentMultipolygons(way)); + } + }); + sharedMultipolygons = sharedMultipolygons.filter(function (relation) { + return relation.members.length === entities.closedWay.length; + }); + + if (sharedMultipolygons.length) { + // don't create a new multipolygon if it'd be redundant + return 'not_eligible'; + } + } else if (entities.closedWay.some(function (way) { + return utilArrayIntersection(graph.parentMultipolygons(way), entities.multipolygon).length; + })) { + // don't add a way to a multipolygon again if it's already a member + return 'not_eligible'; + } + }; + + return action; + } + + var DESCRIPTORS$1 = descriptors; + var objectDefinePropertyModule = objectDefineProperty; + var regExpFlags = regexpFlags$1; + var fails$4 = fails$V; + + var RegExpPrototype = RegExp.prototype; + + var FORCED$2 = DESCRIPTORS$1 && fails$4(function () { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return Object.getOwnPropertyDescriptor(RegExpPrototype, 'flags').get.call({ dotAll: true, sticky: true }) !== 'sy'; + }); + + // `RegExp.prototype.flags` getter + // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags + if (FORCED$2) objectDefinePropertyModule.f(RegExpPrototype, 'flags', { + configurable: true, + get: regExpFlags + }); + + var fastDeepEqual = function equal(a, b) { + if (a === b) return true; + + if (a && b && _typeof(a) == 'object' && _typeof(b) == 'object') { + if (a.constructor !== b.constructor) return false; + var length, i, keys; + + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + + for (i = length; i-- !== 0;) { + if (!equal(a[i], b[i])) return false; + } + + return true; + } + + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + + for (i = length; i-- !== 0;) { + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + } + + for (i = length; i-- !== 0;) { + var key = keys[i]; + if (!equal(a[key], b[key])) return false; + } + + return true; + } // true if both NaN, false otherwise + + + return a !== a && b !== b; + }; + + // J. W. Hunt and M. D. McIlroy, An algorithm for differential buffer + // comparison, Bell Telephone Laboratories CSTR #41 (1976) + // http://www.cs.dartmouth.edu/~doug/ + // https://en.wikipedia.org/wiki/Longest_common_subsequence_problem + // + // Expects two arrays, finds longest common sequence + + function LCS(buffer1, buffer2) { + var equivalenceClasses = {}; + + for (var j = 0; j < buffer2.length; j++) { + var item = buffer2[j]; + + if (equivalenceClasses[item]) { + equivalenceClasses[item].push(j); + } else { + equivalenceClasses[item] = [j]; + } + } + + var NULLRESULT = { + buffer1index: -1, + buffer2index: -1, + chain: null + }; + var candidates = [NULLRESULT]; + + for (var i = 0; i < buffer1.length; i++) { + var _item = buffer1[i]; + var buffer2indices = equivalenceClasses[_item] || []; + var r = 0; + var c = candidates[0]; + + for (var jx = 0; jx < buffer2indices.length; jx++) { + var _j = buffer2indices[jx]; + var s = void 0; + + for (s = r; s < candidates.length; s++) { + if (candidates[s].buffer2index < _j && (s === candidates.length - 1 || candidates[s + 1].buffer2index > _j)) { + break; + } + } + + if (s < candidates.length) { + var newCandidate = { + buffer1index: i, + buffer2index: _j, + chain: candidates[s] + }; + + if (r === candidates.length) { + candidates.push(c); + } else { + candidates[r] = c; + } + + r = s + 1; + c = newCandidate; + + if (r === candidates.length) { + break; // no point in examining further (j)s + } + } + } + + candidates[r] = c; + } // At this point, we know the LCS: it's in the reverse of the + // linked-list through .chain of candidates[candidates.length - 1]. + + + return candidates[candidates.length - 1]; + } // We apply the LCS to build a 'comm'-style picture of the + // offsets and lengths of mismatched chunks in the input + // buffers. This is used by diff3MergeRegions. + + + function diffIndices(buffer1, buffer2) { + var lcs = LCS(buffer1, buffer2); + var result = []; + var tail1 = buffer1.length; + var tail2 = buffer2.length; + + for (var candidate = lcs; candidate !== null; candidate = candidate.chain) { + var mismatchLength1 = tail1 - candidate.buffer1index - 1; + var mismatchLength2 = tail2 - candidate.buffer2index - 1; + tail1 = candidate.buffer1index; + tail2 = candidate.buffer2index; + + if (mismatchLength1 || mismatchLength2) { + result.push({ + buffer1: [tail1 + 1, mismatchLength1], + buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + mismatchLength1), + buffer2: [tail2 + 1, mismatchLength2], + buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + mismatchLength2) + }); + } + } + + result.reverse(); + return result; + } // We apply the LCS to build a JSON representation of a + // independently derived from O, returns a fairly complicated + // internal representation of merge decisions it's taken. The + // interested reader may wish to consult + // + // Sanjeev Khanna, Keshav Kunal, and Benjamin C. Pierce. + // 'A Formal Investigation of ' In Arvind and Prasad, + // editors, Foundations of Software Technology and Theoretical + // Computer Science (FSTTCS), December 2007. + // + // (http://www.cis.upenn.edu/~bcpierce/papers/diff3-short.pdf) + // + + + function diff3MergeRegions(a, o, b) { + // "hunks" are array subsets where `a` or `b` are different from `o` + // https://www.gnu.org/software/diffutils/manual/html_node/diff3-Hunks.html + var hunks = []; + + function addHunk(h, ab) { + hunks.push({ + ab: ab, + oStart: h.buffer1[0], + oLength: h.buffer1[1], + // length of o to remove + abStart: h.buffer2[0], + abLength: h.buffer2[1] // length of a/b to insert + // abContent: (ab === 'a' ? a : b).slice(h.buffer2[0], h.buffer2[0] + h.buffer2[1]) + + }); + } + + diffIndices(o, a).forEach(function (item) { + return addHunk(item, 'a'); + }); + diffIndices(o, b).forEach(function (item) { + return addHunk(item, 'b'); + }); + hunks.sort(function (x, y) { + return x.oStart - y.oStart; + }); + var results = []; + var currOffset = 0; + + function advanceTo(endOffset) { + if (endOffset > currOffset) { + results.push({ + stable: true, + buffer: 'o', + bufferStart: currOffset, + bufferLength: endOffset - currOffset, + bufferContent: o.slice(currOffset, endOffset) + }); + currOffset = endOffset; + } + } + + while (hunks.length) { + var hunk = hunks.shift(); + var regionStart = hunk.oStart; + var regionEnd = hunk.oStart + hunk.oLength; + var regionHunks = [hunk]; + advanceTo(regionStart); // Try to pull next overlapping hunk into this region + + while (hunks.length) { + var nextHunk = hunks[0]; + var nextHunkStart = nextHunk.oStart; + if (nextHunkStart > regionEnd) break; // no overlap + + regionEnd = Math.max(regionEnd, nextHunkStart + nextHunk.oLength); + regionHunks.push(hunks.shift()); + } + + if (regionHunks.length === 1) { + // Only one hunk touches this region, meaning that there is no conflict here. + // Either `a` or `b` is inserting into a region of `o` unchanged by the other. + if (hunk.abLength > 0) { + var buffer = hunk.ab === 'a' ? a : b; + results.push({ + stable: true, + buffer: hunk.ab, + bufferStart: hunk.abStart, + bufferLength: hunk.abLength, + bufferContent: buffer.slice(hunk.abStart, hunk.abStart + hunk.abLength) + }); + } + } else { + // A true a/b conflict. Determine the bounds involved from `a`, `o`, and `b`. + // Effectively merge all the `a` hunks into one giant hunk, then do the + // same for the `b` hunks; then, correct for skew in the regions of `o` + // that each side changed, and report appropriate spans for the three sides. + var bounds = { + a: [a.length, -1, o.length, -1], + b: [b.length, -1, o.length, -1] + }; + + while (regionHunks.length) { + hunk = regionHunks.shift(); + var oStart = hunk.oStart; + var oEnd = oStart + hunk.oLength; + var abStart = hunk.abStart; + var abEnd = abStart + hunk.abLength; + var _b = bounds[hunk.ab]; + _b[0] = Math.min(abStart, _b[0]); + _b[1] = Math.max(abEnd, _b[1]); + _b[2] = Math.min(oStart, _b[2]); + _b[3] = Math.max(oEnd, _b[3]); + } + + var aStart = bounds.a[0] + (regionStart - bounds.a[2]); + var aEnd = bounds.a[1] + (regionEnd - bounds.a[3]); + var bStart = bounds.b[0] + (regionStart - bounds.b[2]); + var bEnd = bounds.b[1] + (regionEnd - bounds.b[3]); + var result = { + stable: false, + aStart: aStart, + aLength: aEnd - aStart, + aContent: a.slice(aStart, aEnd), + oStart: regionStart, + oLength: regionEnd - regionStart, + oContent: o.slice(regionStart, regionEnd), + bStart: bStart, + bLength: bEnd - bStart, + bContent: b.slice(bStart, bEnd) + }; + results.push(result); + } + + currOffset = regionEnd; + } + + advanceTo(o.length); + return results; + } // Applies the output of diff3MergeRegions to actually + // construct the merged buffer; the returned result alternates + // between 'ok' and 'conflict' blocks. + // A "false conflict" is where `a` and `b` both change the same from `o` + + + function diff3Merge(a, o, b, options) { + var defaults = { + excludeFalseConflicts: true, + stringSeparator: /\s+/ + }; + options = Object.assign(defaults, options); + var aString = typeof a === 'string'; + var oString = typeof o === 'string'; + var bString = typeof b === 'string'; + if (aString) a = a.split(options.stringSeparator); + if (oString) o = o.split(options.stringSeparator); + if (bString) b = b.split(options.stringSeparator); + var results = []; + var regions = diff3MergeRegions(a, o, b); + var okBuffer = []; + + function flushOk() { + if (okBuffer.length) { + results.push({ + ok: okBuffer + }); + } + + okBuffer = []; + } + + function isFalseConflict(a, b) { + if (a.length !== b.length) return false; + + for (var i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false; + } + + return true; + } + + regions.forEach(function (region) { + if (region.stable) { + var _okBuffer; + + (_okBuffer = okBuffer).push.apply(_okBuffer, _toConsumableArray(region.bufferContent)); + } else { + if (options.excludeFalseConflicts && isFalseConflict(region.aContent, region.bContent)) { + var _okBuffer2; + + (_okBuffer2 = okBuffer).push.apply(_okBuffer2, _toConsumableArray(region.aContent)); + } else { + flushOk(); + results.push({ + conflict: { + a: region.aContent, + aIndex: region.aStart, + o: region.oContent, + oIndex: region.oStart, + b: region.bContent, + bIndex: region.bStart + } + }); + } + } + }); + flushOk(); + return results; + } + + var lodash = {exports: {}}; + + (function (module, exports) { + (function () { + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ + var undefined$1; + /** Used as the semantic version number. */ + + var VERSION = '4.17.21'; + /** Used as the size to enable large array optimizations. */ + + var LARGE_ARRAY_SIZE = 200; + /** Error message constants. */ + + var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.', + FUNC_ERROR_TEXT = 'Expected a function', + INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`'; + /** Used to stand-in for `undefined` hash values. */ + + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + /** Used as the maximum memoize cache size. */ + + var MAX_MEMOIZE_SIZE = 500; + /** Used as the internal argument placeholder. */ + + var PLACEHOLDER = '__lodash_placeholder__'; + /** Used to compose bitmasks for cloning. */ + + var CLONE_DEEP_FLAG = 1, + CLONE_FLAT_FLAG = 2, + CLONE_SYMBOLS_FLAG = 4; + /** Used to compose bitmasks for value comparisons. */ + + var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + /** Used to compose bitmasks for function metadata. */ + + var WRAP_BIND_FLAG = 1, + WRAP_BIND_KEY_FLAG = 2, + WRAP_CURRY_BOUND_FLAG = 4, + WRAP_CURRY_FLAG = 8, + WRAP_CURRY_RIGHT_FLAG = 16, + WRAP_PARTIAL_FLAG = 32, + WRAP_PARTIAL_RIGHT_FLAG = 64, + WRAP_ARY_FLAG = 128, + WRAP_REARG_FLAG = 256, + WRAP_FLIP_FLAG = 512; + /** Used as default options for `_.truncate`. */ + + var DEFAULT_TRUNC_LENGTH = 30, + DEFAULT_TRUNC_OMISSION = '...'; + /** Used to detect hot functions by number of calls within a span of milliseconds. */ + + var HOT_COUNT = 800, + HOT_SPAN = 16; + /** Used to indicate the type of lazy iteratees. */ + + var LAZY_FILTER_FLAG = 1, + LAZY_MAP_FLAG = 2, + LAZY_WHILE_FLAG = 3; + /** Used as references for various `Number` constants. */ + + var INFINITY = 1 / 0, + MAX_SAFE_INTEGER = 9007199254740991, + MAX_INTEGER = 1.7976931348623157e+308, + NAN = 0 / 0; + /** Used as references for the maximum length and index of an array. */ + + var MAX_ARRAY_LENGTH = 4294967295, + MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, + HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + /** Used to associate wrap methods with their bit flags. */ + + var wrapFlags = [['ary', WRAP_ARY_FLAG], ['bind', WRAP_BIND_FLAG], ['bindKey', WRAP_BIND_KEY_FLAG], ['curry', WRAP_CURRY_FLAG], ['curryRight', WRAP_CURRY_RIGHT_FLAG], ['flip', WRAP_FLIP_FLAG], ['partial', WRAP_PARTIAL_FLAG], ['partialRight', WRAP_PARTIAL_RIGHT_FLAG], ['rearg', WRAP_REARG_FLAG]]; + /** `Object#toString` result references. */ + + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + asyncTag = '[object AsyncFunction]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + domExcTag = '[object DOMException]', + errorTag = '[object Error]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + mapTag = '[object Map]', + numberTag = '[object Number]', + nullTag = '[object Null]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + proxyTag = '[object Proxy]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]', + undefinedTag = '[object Undefined]', + weakMapTag = '[object WeakMap]', + weakSetTag = '[object WeakSet]'; + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + /** Used to match empty string literals in compiled template source. */ + + var reEmptyStringLeading = /\b__p \+= '';/g, + reEmptyStringMiddle = /\b(__p \+=) '' \+/g, + reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; + /** Used to match HTML entities and HTML characters. */ + + var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, + reUnescapedHtml = /[&<>"']/g, + reHasEscapedHtml = RegExp(reEscapedHtml.source), + reHasUnescapedHtml = RegExp(reUnescapedHtml.source); + /** Used to match template delimiters. */ + + var reEscape = /<%-([\s\S]+?)%>/g, + reEvaluate = /<%([\s\S]+?)%>/g, + reInterpolate = /<%=([\s\S]+?)%>/g; + /** Used to match property names within property paths. */ + + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, + reHasRegExpChar = RegExp(reRegExpChar.source); + /** Used to match leading whitespace. */ + + var reTrimStart = /^\s+/; + /** Used to match a single whitespace character. */ + + var reWhitespace = /\s/; + /** Used to match wrap detail comments. */ + + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, + reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, + reSplitDetails = /,? & /; + /** Used to match words composed of alphanumeric characters. */ + + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + /** + * Used to validate the `validate` option in `_.template` variable. + * + * Forbids characters which could potentially change the meaning of the function argument definition: + * - "()," (modification of function parameters) + * - "=" (default value) + * - "[]{}" (destructuring of function parameters) + * - "/" (beginning of a comment) + * - whitespace + */ + + var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/; + /** Used to match backslashes in property paths. */ + + var reEscapeChar = /\\(\\)?/g; + /** + * Used to match + * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). + */ + + var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; + /** Used to match `RegExp` flags from their coerced string values. */ + + var reFlags = /\w*$/; + /** Used to detect bad signed hexadecimal string values. */ + + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + /** Used to detect binary string values. */ + + var reIsBinary = /^0b[01]+$/i; + /** Used to detect host constructors (Safari). */ + + var reIsHostCtor = /^\[object .+?Constructor\]$/; + /** Used to detect octal string values. */ + + var reIsOctal = /^0o[0-7]+$/i; + /** Used to detect unsigned integer values. */ + + var reIsUint = /^(?:0|[1-9]\d*)$/; + /** Used to match Latin Unicode letters (excluding mathematical operators). */ + + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + /** Used to ensure capturing order of template delimiters. */ + + var reNoMatch = /($^)/; + /** Used to match unescaped characters in compiled string literals. */ + + var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + /** Used to compose unicode character classes. */ + + var rsAstralRange = "\\ud800-\\udfff", + rsComboMarksRange = "\\u0300-\\u036f", + reComboHalfMarksRange = "\\ufe20-\\ufe2f", + rsComboSymbolsRange = "\\u20d0-\\u20ff", + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, + rsDingbatRange = "\\u2700-\\u27bf", + rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', + rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', + rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', + rsPunctuationRange = "\\u2000-\\u206f", + rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", + rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', + rsVarRange = "\\ufe0e\\ufe0f", + rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; + /** Used to compose unicode capture groups. */ + + var rsApos = "['\u2019]", + rsAstral = '[' + rsAstralRange + ']', + rsBreak = '[' + rsBreakRange + ']', + rsCombo = '[' + rsComboRange + ']', + rsDigits = '\\d+', + rsDingbat = '[' + rsDingbatRange + ']', + rsLower = '[' + rsLowerRange + ']', + rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', + rsFitz = "\\ud83c[\\udffb-\\udfff]", + rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', + rsNonAstral = '[^' + rsAstralRange + ']', + rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", + rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", + rsUpper = '[' + rsUpperRange + ']', + rsZWJ = "\\u200d"; + /** Used to compose unicode regexes. */ + + var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', + rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', + rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', + rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', + reOptMod = rsModifier + '?', + rsOptVar = '[' + rsVarRange + ']?', + rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', + rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', + rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, + rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; + /** Used to match apostrophes. */ + + var reApos = RegExp(rsApos, 'g'); + /** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */ + + var reComboMark = RegExp(rsCombo, 'g'); + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + + var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); + /** Used to match complex or compound words. */ + + var reUnicodeWord = RegExp([rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')', rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower, rsUpper + '+' + rsOptContrUpper, rsOrdUpper, rsOrdLower, rsDigits, rsEmoji].join('|'), 'g'); + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ + + var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); + /** Used to detect strings that need a more robust regexp to match words. */ + + var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + /** Used to assign default `context` object properties. */ + + var contextProps = ['Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array', 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object', 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout']; + /** Used to make template sourceURLs easier to identify. */ + + var templateCounter = -1; + /** Used to identify `toStringTag` values of typed arrays. */ + + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; + /** Used to identify `toStringTag` values supported by `_.clone`. */ + + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false; + /** Used to map Latin Unicode letters to basic Latin letters. */ + + var deburredLetters = { + // Latin-1 Supplement block. + '\xc0': 'A', + '\xc1': 'A', + '\xc2': 'A', + '\xc3': 'A', + '\xc4': 'A', + '\xc5': 'A', + '\xe0': 'a', + '\xe1': 'a', + '\xe2': 'a', + '\xe3': 'a', + '\xe4': 'a', + '\xe5': 'a', + '\xc7': 'C', + '\xe7': 'c', + '\xd0': 'D', + '\xf0': 'd', + '\xc8': 'E', + '\xc9': 'E', + '\xca': 'E', + '\xcb': 'E', + '\xe8': 'e', + '\xe9': 'e', + '\xea': 'e', + '\xeb': 'e', + '\xcc': 'I', + '\xcd': 'I', + '\xce': 'I', + '\xcf': 'I', + '\xec': 'i', + '\xed': 'i', + '\xee': 'i', + '\xef': 'i', + '\xd1': 'N', + '\xf1': 'n', + '\xd2': 'O', + '\xd3': 'O', + '\xd4': 'O', + '\xd5': 'O', + '\xd6': 'O', + '\xd8': 'O', + '\xf2': 'o', + '\xf3': 'o', + '\xf4': 'o', + '\xf5': 'o', + '\xf6': 'o', + '\xf8': 'o', + '\xd9': 'U', + '\xda': 'U', + '\xdb': 'U', + '\xdc': 'U', + '\xf9': 'u', + '\xfa': 'u', + '\xfb': 'u', + '\xfc': 'u', + '\xdd': 'Y', + '\xfd': 'y', + '\xff': 'y', + '\xc6': 'Ae', + '\xe6': 'ae', + '\xde': 'Th', + '\xfe': 'th', + '\xdf': 'ss', + // Latin Extended-A block. + "\u0100": 'A', + "\u0102": 'A', + "\u0104": 'A', + "\u0101": 'a', + "\u0103": 'a', + "\u0105": 'a', + "\u0106": 'C', + "\u0108": 'C', + "\u010A": 'C', + "\u010C": 'C', + "\u0107": 'c', + "\u0109": 'c', + "\u010B": 'c', + "\u010D": 'c', + "\u010E": 'D', + "\u0110": 'D', + "\u010F": 'd', + "\u0111": 'd', + "\u0112": 'E', + "\u0114": 'E', + "\u0116": 'E', + "\u0118": 'E', + "\u011A": 'E', + "\u0113": 'e', + "\u0115": 'e', + "\u0117": 'e', + "\u0119": 'e', + "\u011B": 'e', + "\u011C": 'G', + "\u011E": 'G', + "\u0120": 'G', + "\u0122": 'G', + "\u011D": 'g', + "\u011F": 'g', + "\u0121": 'g', + "\u0123": 'g', + "\u0124": 'H', + "\u0126": 'H', + "\u0125": 'h', + "\u0127": 'h', + "\u0128": 'I', + "\u012A": 'I', + "\u012C": 'I', + "\u012E": 'I', + "\u0130": 'I', + "\u0129": 'i', + "\u012B": 'i', + "\u012D": 'i', + "\u012F": 'i', + "\u0131": 'i', + "\u0134": 'J', + "\u0135": 'j', + "\u0136": 'K', + "\u0137": 'k', + "\u0138": 'k', + "\u0139": 'L', + "\u013B": 'L', + "\u013D": 'L', + "\u013F": 'L', + "\u0141": 'L', + "\u013A": 'l', + "\u013C": 'l', + "\u013E": 'l', + "\u0140": 'l', + "\u0142": 'l', + "\u0143": 'N', + "\u0145": 'N', + "\u0147": 'N', + "\u014A": 'N', + "\u0144": 'n', + "\u0146": 'n', + "\u0148": 'n', + "\u014B": 'n', + "\u014C": 'O', + "\u014E": 'O', + "\u0150": 'O', + "\u014D": 'o', + "\u014F": 'o', + "\u0151": 'o', + "\u0154": 'R', + "\u0156": 'R', + "\u0158": 'R', + "\u0155": 'r', + "\u0157": 'r', + "\u0159": 'r', + "\u015A": 'S', + "\u015C": 'S', + "\u015E": 'S', + "\u0160": 'S', + "\u015B": 's', + "\u015D": 's', + "\u015F": 's', + "\u0161": 's', + "\u0162": 'T', + "\u0164": 'T', + "\u0166": 'T', + "\u0163": 't', + "\u0165": 't', + "\u0167": 't', + "\u0168": 'U', + "\u016A": 'U', + "\u016C": 'U', + "\u016E": 'U', + "\u0170": 'U', + "\u0172": 'U', + "\u0169": 'u', + "\u016B": 'u', + "\u016D": 'u', + "\u016F": 'u', + "\u0171": 'u', + "\u0173": 'u', + "\u0174": 'W', + "\u0175": 'w', + "\u0176": 'Y', + "\u0177": 'y', + "\u0178": 'Y', + "\u0179": 'Z', + "\u017B": 'Z', + "\u017D": 'Z', + "\u017A": 'z', + "\u017C": 'z', + "\u017E": 'z', + "\u0132": 'IJ', + "\u0133": 'ij', + "\u0152": 'Oe', + "\u0153": 'oe', + "\u0149": "'n", + "\u017F": 's' + }; + /** Used to map characters to HTML entities. */ + + var htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + }; + /** Used to map HTML entities to characters. */ + + var htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'" + }; + /** Used to escape characters for inclusion in compiled string literals. */ + + var stringEscapes = { + '\\': '\\', + "'": "'", + '\n': 'n', + '\r': 'r', + "\u2028": 'u2028', + "\u2029": 'u2029' + }; + /** Built-in method references without a dependency on `root`. */ + + var freeParseFloat = parseFloat, + freeParseInt = parseInt; + /** Detect free variable `global` from Node.js. */ + + var freeGlobal = _typeof(commonjsGlobal) == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + /** Detect free variable `self`. */ + + var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' && self && self.Object === Object && self; + /** Used as a reference to the global object. */ + + var root = freeGlobal || freeSelf || Function('return this')(); + /** Detect free variable `exports`. */ + + var freeExports = exports && !exports.nodeType && exports; + /** Detect free variable `module`. */ + + var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module; + /** Detect the popular CommonJS extension `module.exports`. */ + + var moduleExports = freeModule && freeModule.exports === freeExports; + /** Detect free variable `process` from Node.js. */ + + var freeProcess = moduleExports && freeGlobal.process; + /** Used to access faster Node.js helpers. */ + + var nodeUtil = function () { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } // Legacy `process.binding('util')` for Node.js < 10. + + + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} + }(); + /* Node.js helper references. */ + + + var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, + nodeIsDate = nodeUtil && nodeUtil.isDate, + nodeIsMap = nodeUtil && nodeUtil.isMap, + nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, + nodeIsSet = nodeUtil && nodeUtil.isSet, + nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + /*--------------------------------------------------------------------------*/ + + /** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */ + + function apply(func, thisArg, args) { + switch (args.length) { + case 0: + return func.call(thisArg); + + case 1: + return func.call(thisArg, args[0]); + + case 2: + return func.call(thisArg, args[0], args[1]); + + case 3: + return func.call(thisArg, args[0], args[1], args[2]); + } + + return func.apply(thisArg, args); + } + /** + * A specialized version of `baseAggregator` for arrays. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + + + function arrayAggregator(array, setter, iteratee, accumulator) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + var value = array[index]; + setter(accumulator, value, iteratee(value), array); + } + + return accumulator; + } + /** + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + + + function arrayEach(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + + return array; + } + /** + * A specialized version of `_.forEachRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + + + function arrayEachRight(array, iteratee) { + var length = array == null ? 0 : array.length; + + while (length--) { + if (iteratee(array[length], length, array) === false) { + break; + } + } + + return array; + } + /** + * A specialized version of `_.every` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + */ + + + function arrayEvery(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (!predicate(array[index], index, array)) { + return false; + } + } + + return true; + } + /** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + + + function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + + return result; + } + /** + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ + + + function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return !!length && baseIndexOf(array, value, 0) > -1; + } + /** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ + + + function arrayIncludesWith(array, value, comparator) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (comparator(value, array[index])) { + return true; + } + } + + return false; + } + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + + + function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + + return result; + } + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + + + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + + return array; + } + /** + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + + + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array == null ? 0 : array.length; + + if (initAccum && length) { + accumulator = array[++index]; + } + + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + + return accumulator; + } + /** + * A specialized version of `_.reduceRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the last element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + + + function arrayReduceRight(array, iteratee, accumulator, initAccum) { + var length = array == null ? 0 : array.length; + + if (initAccum && length) { + accumulator = array[--length]; + } + + while (length--) { + accumulator = iteratee(accumulator, array[length], length, array); + } + + return accumulator; + } + /** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + + + function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + + return false; + } + /** + * Gets the size of an ASCII `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + + + var asciiSize = baseProperty('length'); + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + + function asciiToArray(string) { + return string.split(''); + } + /** + * Splits an ASCII `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + + + function asciiWords(string) { + return string.match(reAsciiWord) || []; + } + /** + * The base implementation of methods like `_.findKey` and `_.findLastKey`, + * without support for iteratee shorthands, which iterates over `collection` + * using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the found element or its key, else `undefined`. + */ + + + function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function (value, key, collection) { + if (predicate(value, key, collection)) { + result = key; + return false; + } + }); + return result; + } + /** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + + while (fromRight ? index-- : ++index < length) { + if (predicate(array[index], index, array)) { + return index; + } + } + + return -1; + } + /** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function baseIndexOf(array, value, fromIndex) { + return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex); + } + /** + * This function is like `baseIndexOf` except that it accepts a comparator. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @param {Function} comparator The comparator invoked per element. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function baseIndexOfWith(array, value, fromIndex, comparator) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (comparator(array[index], value)) { + return index; + } + } + + return -1; + } + /** + * The base implementation of `_.isNaN` without support for number objects. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + */ + + + function baseIsNaN(value) { + return value !== value; + } + /** + * The base implementation of `_.mean` and `_.meanBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the mean. + */ + + + function baseMean(array, iteratee) { + var length = array == null ? 0 : array.length; + return length ? baseSum(array, iteratee) / length : NAN; + } + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ + + + function baseProperty(key) { + return function (object) { + return object == null ? undefined$1 : object[key]; + }; + } + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ + + + function basePropertyOf(object) { + return function (key) { + return object == null ? undefined$1 : object[key]; + }; + } + /** + * The base implementation of `_.reduce` and `_.reduceRight`, without support + * for iteratee shorthands, which iterates over `collection` using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} accumulator The initial value. + * @param {boolean} initAccum Specify using the first or last element of + * `collection` as the initial value. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the accumulated value. + */ + + + function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection, function (value, index, collection) { + accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection); + }); + return accumulator; + } + /** + * The base implementation of `_.sortBy` which uses `comparer` to define the + * sort order of `array` and replaces criteria objects with their corresponding + * values. + * + * @private + * @param {Array} array The array to sort. + * @param {Function} comparer The function to define sort order. + * @returns {Array} Returns `array`. + */ + + + function baseSortBy(array, comparer) { + var length = array.length; + array.sort(comparer); + + while (length--) { + array[length] = array[length].value; + } + + return array; + } + /** + * The base implementation of `_.sum` and `_.sumBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the sum. + */ + + + function baseSum(array, iteratee) { + var result, + index = -1, + length = array.length; + + while (++index < length) { + var current = iteratee(array[index]); + + if (current !== undefined$1) { + result = result === undefined$1 ? current : result + current; + } + } + + return result; + } + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + + + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + + return result; + } + /** + * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array + * of key-value pairs for `object` corresponding to the property names of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the key-value pairs. + */ + + + function baseToPairs(object, props) { + return arrayMap(props, function (key) { + return [key, object[key]]; + }); + } + /** + * The base implementation of `_.trim`. + * + * @private + * @param {string} string The string to trim. + * @returns {string} Returns the trimmed string. + */ + + + function baseTrim(string) { + return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string; + } + /** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ + + + function baseUnary(func) { + return function (value) { + return func(value); + }; + } + /** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ + + + function baseValues(object, props) { + return arrayMap(props, function (key) { + return object[key]; + }); + } + /** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + + + function cacheHas(cache, key) { + return cache.has(key); + } + /** + * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the first unmatched string symbol. + */ + + + function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, + length = strSymbols.length; + + while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + + return index; + } + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the last unmatched string symbol. + */ + + + function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + + while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + + return index; + } + /** + * Gets the number of `placeholder` occurrences in `array`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} placeholder The placeholder to search for. + * @returns {number} Returns the placeholder count. + */ + + + function countHolders(array, placeholder) { + var length = array.length, + result = 0; + + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + + return result; + } + /** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */ + + + var deburrLetter = basePropertyOf(deburredLetters); + /** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + + var escapeHtmlChar = basePropertyOf(htmlEscapes); + /** + * Used by `_.template` to escape characters for inclusion in compiled string literals. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + + function escapeStringChar(chr) { + return '\\' + stringEscapes[chr]; + } + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + + + function getValue(object, key) { + return object == null ? undefined$1 : object[key]; + } + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */ + + + function hasUnicode(string) { + return reHasUnicode.test(string); + } + /** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a word is found, else `false`. + */ + + + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + /** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */ + + + function iteratorToArray(iterator) { + var data, + result = []; + + while (!(data = iterator.next()).done) { + result.push(data.value); + } + + return result; + } + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + + + function mapToArray(map) { + var index = -1, + result = Array(map.size); + map.forEach(function (value, key) { + result[++index] = [key, value]; + }); + return result; + } + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + + + function overArg(func, transform) { + return function (arg) { + return func(transform(arg)); + }; + } + /** + * Replaces all `placeholder` elements in `array` with an internal placeholder + * and returns an array of their indexes. + * + * @private + * @param {Array} array The array to modify. + * @param {*} placeholder The placeholder to replace. + * @returns {Array} Returns the new array of placeholder indexes. + */ + + + function replaceHolders(array, placeholder) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + + if (value === placeholder || value === PLACEHOLDER) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + + return result; + } + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + + + function setToArray(set) { + var index = -1, + result = Array(set.size); + set.forEach(function (value) { + result[++index] = value; + }); + return result; + } + /** + * Converts `set` to its value-value pairs. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the value-value pairs. + */ + + + function setToPairs(set) { + var index = -1, + result = Array(set.size); + set.forEach(function (value) { + result[++index] = [value, value]; + }); + return result; + } + /** + * A specialized version of `_.indexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } + } + + return -1; + } + /** + * A specialized version of `_.lastIndexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function strictLastIndexOf(array, value, fromIndex) { + var index = fromIndex + 1; + + while (index--) { + if (array[index] === value) { + return index; + } + } + + return index; + } + /** + * Gets the number of symbols in `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the string size. + */ + + + function stringSize(string) { + return hasUnicode(string) ? unicodeSize(string) : asciiSize(string); + } + /** + * Converts `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + + + function stringToArray(string) { + return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string); + } + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace + * character of `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the index of the last non-whitespace character. + */ + + + function trimmedEndIndex(string) { + var index = string.length; + + while (index-- && reWhitespace.test(string.charAt(index))) {} + + return index; + } + /** + * Used by `_.unescape` to convert HTML entities to characters. + * + * @private + * @param {string} chr The matched character to unescape. + * @returns {string} Returns the unescaped character. + */ + + + var unescapeHtmlChar = basePropertyOf(htmlUnescapes); + /** + * Gets the size of a Unicode `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + + function unicodeSize(string) { + var result = reUnicode.lastIndex = 0; + + while (reUnicode.test(string)) { + ++result; + } + + return result; + } + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + + + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + /** + * Splits a Unicode `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + + + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + /*--------------------------------------------------------------------------*/ + + /** + * Create a new pristine `lodash` function using the `context` object. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Util + * @param {Object} [context=root] The context object. + * @returns {Function} Returns a new `lodash` function. + * @example + * + * _.mixin({ 'foo': _.constant('foo') }); + * + * var lodash = _.runInContext(); + * lodash.mixin({ 'bar': lodash.constant('bar') }); + * + * _.isFunction(_.foo); + * // => true + * _.isFunction(_.bar); + * // => false + * + * lodash.isFunction(lodash.foo); + * // => false + * lodash.isFunction(lodash.bar); + * // => true + * + * // Create a suped-up `defer` in Node.js. + * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; + */ + + + var runInContext = function runInContext(context) { + context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps)); + /** Built-in constructor references. */ + + var Array = context.Array, + Date = context.Date, + Error = context.Error, + Function = context.Function, + Math = context.Math, + Object = context.Object, + RegExp = context.RegExp, + String = context.String, + TypeError = context.TypeError; + /** Used for built-in method references. */ + + var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + /** Used to detect overreaching core-js shims. */ + + var coreJsData = context['__core-js_shared__']; + /** Used to resolve the decompiled source of functions. */ + + var funcToString = funcProto.toString; + /** Used to check objects for own properties. */ + + var hasOwnProperty = objectProto.hasOwnProperty; + /** Used to generate unique IDs. */ + + var idCounter = 0; + /** Used to detect methods masquerading as native. */ + + var maskSrcKey = function () { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? 'Symbol(src)_1.' + uid : ''; + }(); + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + + + var nativeObjectToString = objectProto.toString; + /** Used to infer the `Object` constructor. */ + + var objectCtorString = funcToString.call(Object); + /** Used to restore the original `_` reference in `_.noConflict`. */ + + var oldDash = root._; + /** Used to detect if a method is native. */ + + var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'); + /** Built-in value references. */ + + var Buffer = moduleExports ? context.Buffer : undefined$1, + _Symbol = context.Symbol, + Uint8Array = context.Uint8Array, + allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1, + getPrototype = overArg(Object.getPrototypeOf, Object), + objectCreate = Object.create, + propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice, + spreadableSymbol = _Symbol ? _Symbol.isConcatSpreadable : undefined$1, + symIterator = _Symbol ? _Symbol.iterator : undefined$1, + symToStringTag = _Symbol ? _Symbol.toStringTag : undefined$1; + + var defineProperty = function () { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }(); + /** Mocked built-ins. */ + + + var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, + ctxNow = Date && Date.now !== root.Date.now && Date.now, + ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; + /* Built-in method references for those with the same name as other `lodash` methods. */ + + var nativeCeil = Math.ceil, + nativeFloor = Math.floor, + nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1, + nativeIsFinite = context.isFinite, + nativeJoin = arrayProto.join, + nativeKeys = overArg(Object.keys, Object), + nativeMax = Math.max, + nativeMin = Math.min, + nativeNow = Date.now, + nativeParseInt = context.parseInt, + nativeRandom = Math.random, + nativeReverse = arrayProto.reverse; + /* Built-in method references that are verified to be native. */ + + var DataView = getNative(context, 'DataView'), + Map = getNative(context, 'Map'), + Promise = getNative(context, 'Promise'), + Set = getNative(context, 'Set'), + WeakMap = getNative(context, 'WeakMap'), + nativeCreate = getNative(Object, 'create'); + /** Used to store function metadata. */ + + var metaMap = WeakMap && new WeakMap(); + /** Used to lookup unminified function names. */ + + var realNames = {}; + /** Used to detect maps, sets, and weakmaps. */ + + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + /** Used to convert symbols to primitives and strings. */ + + var symbolProto = _Symbol ? _Symbol.prototype : undefined$1, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1, + symbolToString = symbolProto ? symbolProto.toString : undefined$1; + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` object which wraps `value` to enable implicit method + * chain sequences. Methods that operate on and return arrays, collections, + * and functions can be chained together. Methods that retrieve a single value + * or may return a primitive value will automatically end the chain sequence + * and return the unwrapped value. Otherwise, the value must be unwrapped + * with `_#value`. + * + * Explicit chain sequences, which must be unwrapped with `_#value`, may be + * enabled using `_.chain`. + * + * The execution of chained methods is lazy, that is, it's deferred until + * `_#value` is implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. + * Shortcut fusion is an optimization to merge iteratee calls; this avoids + * the creation of intermediate arrays and can greatly reduce the number of + * iteratee executions. Sections of a chain sequence qualify for shortcut + * fusion if the section is applied to an array and iteratees accept only + * one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the `_#value` method is + * directly or indirectly included in the build. + * + * In addition to lodash methods, wrappers have `Array` and `String` methods. + * + * The wrapper `Array` methods are: + * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` + * + * The wrapper `String` methods are: + * `replace` and `split` + * + * The wrapper methods that support shortcut fusion are: + * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, + * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, + * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` + * + * The chainable wrapper methods are: + * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, + * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, + * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, + * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, + * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, + * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, + * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, + * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, + * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, + * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, + * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, + * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, + * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, + * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, + * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, + * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, + * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, + * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, + * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, + * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, + * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, + * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, + * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, + * `zipObject`, `zipObjectDeep`, and `zipWith` + * + * The wrapper methods that are **not** chainable by default are: + * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, + * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, + * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, + * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, + * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, + * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, + * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, + * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, + * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, + * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, + * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, + * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, + * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, + * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, + * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, + * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, + * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, + * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, + * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, + * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, + * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, + * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, + * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, + * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, + * `upperFirst`, `value`, and `words` + * + * @name _ + * @constructor + * @category Seq + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2, 3]); + * + * // Returns an unwrapped value. + * wrapped.reduce(_.add); + * // => 6 + * + * // Returns a wrapped value. + * var squares = wrapped.map(square); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */ + + function lodash(value) { + if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + + if (hasOwnProperty.call(value, '__wrapped__')) { + return wrapperClone(value); + } + } + + return new LodashWrapper(value); + } + /** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */ + + + var baseCreate = function () { + function object() {} + + return function (proto) { + if (!isObject(proto)) { + return {}; + } + + if (objectCreate) { + return objectCreate(proto); + } + + object.prototype = proto; + var result = new object(); + object.prototype = undefined$1; + return result; + }; + }(); + /** + * The function whose prototype chain sequence wrappers inherit from. + * + * @private + */ + + + function baseLodash() {// No operation performed. + } + /** + * The base constructor for creating `lodash` wrapper objects. + * + * @private + * @param {*} value The value to wrap. + * @param {boolean} [chainAll] Enable explicit method chain sequences. + */ + + + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = undefined$1; + } + /** + * By default, the template delimiters used by lodash are like those in + * embedded Ruby (ERB) as well as ES2015 template strings. Change the + * following template settings to use alternative delimiters. + * + * @static + * @memberOf _ + * @type {Object} + */ + + + lodash.templateSettings = { + /** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'escape': reEscape, + + /** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'evaluate': reEvaluate, + + /** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'interpolate': reInterpolate, + + /** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */ + 'variable': '', + + /** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */ + 'imports': { + /** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */ + '_': lodash + } + }; // Ensure wrappers are instances of `baseLodash`. + + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + /*------------------------------------------------------------------------*/ + + /** + * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. + * + * @private + * @constructor + * @param {*} value The value to wrap. + */ + + function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + /** + * Creates a clone of the lazy wrapper object. + * + * @private + * @name clone + * @memberOf LazyWrapper + * @returns {Object} Returns the cloned `LazyWrapper` object. + */ + + + function lazyClone() { + var result = new LazyWrapper(this.__wrapped__); + result.__actions__ = copyArray(this.__actions__); + result.__dir__ = this.__dir__; + result.__filtered__ = this.__filtered__; + result.__iteratees__ = copyArray(this.__iteratees__); + result.__takeCount__ = this.__takeCount__; + result.__views__ = copyArray(this.__views__); + return result; + } + /** + * Reverses the direction of lazy iteration. + * + * @private + * @name reverse + * @memberOf LazyWrapper + * @returns {Object} Returns the new reversed `LazyWrapper` object. + */ + + + function lazyReverse() { + if (this.__filtered__) { + var result = new LazyWrapper(this); + result.__dir__ = -1; + result.__filtered__ = true; + } else { + result = this.clone(); + result.__dir__ *= -1; + } + + return result; + } + /** + * Extracts the unwrapped value from its lazy wrapper. + * + * @private + * @name value + * @memberOf LazyWrapper + * @returns {*} Returns the unwrapped value. + */ + + + function lazyValue() { + var array = this.__wrapped__.value(), + dir = this.__dir__, + isArr = isArray(array), + isRight = dir < 0, + arrLength = isArr ? array.length : 0, + view = getView(0, arrLength, this.__views__), + start = view.start, + end = view.end, + length = end - start, + index = isRight ? end : start - 1, + iteratees = this.__iteratees__, + iterLength = iteratees.length, + resIndex = 0, + takeCount = nativeMin(length, this.__takeCount__); + + if (!isArr || !isRight && arrLength == length && takeCount == length) { + return baseWrapperValue(array, this.__actions__); + } + + var result = []; + + outer: while (length-- && resIndex < takeCount) { + index += dir; + var iterIndex = -1, + value = array[index]; + + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], + iteratee = data.iteratee, + type = data.type, + computed = iteratee(value); + + if (type == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + + result[resIndex++] = value; + } + + return result; + } // Ensure `LazyWrapper` is an instance of `baseLodash`. + + + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + /*------------------------------------------------------------------------*/ + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + + function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + this.clear(); + + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + + + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + + + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + + + function hashGet(key) { + var data = this.__data__; + + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined$1 : result; + } + + return hasOwnProperty.call(data, key) ? data[key] : undefined$1; + } + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + + + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined$1 : hasOwnProperty.call(data, key); + } + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + + + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = nativeCreate && value === undefined$1 ? HASH_UNDEFINED : value; + return this; + } // Add methods to `Hash`. + + + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + /*------------------------------------------------------------------------*/ + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + + function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + this.clear(); + + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + + + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + + + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + + var lastIndex = data.length - 1; + + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + + --this.size; + return true; + } + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + + + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + return index < 0 ? undefined$1 : data[index][1]; + } + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + + + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + + + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + + return this; + } // Add methods to `ListCache`. + + + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + /*------------------------------------------------------------------------*/ + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + + function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + this.clear(); + + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + + + function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash(), + 'map': new (Map || ListCache)(), + 'string': new Hash() + }; + } + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + + + function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; + } + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + + + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + + + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + + + function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; + } // Add methods to `MapCache`. + + + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + /*------------------------------------------------------------------------*/ + + /** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ + + function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + this.__data__ = new MapCache(); + + while (++index < length) { + this.add(values[index]); + } + } + /** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ + + + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + + return this; + } + /** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ + + + function setCacheHas(value) { + return this.__data__.has(value); + } // Add methods to `SetCache`. + + + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + /*------------------------------------------------------------------------*/ + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + + function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; + } + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ + + + function stackClear() { + this.__data__ = new ListCache(); + this.size = 0; + } + /** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + + + function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + this.size = data.size; + return result; + } + /** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + + + function stackGet(key) { + return this.__data__.get(key); + } + /** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + + + function stackHas(key) { + return this.__data__.has(key); + } + /** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ + + + function stackSet(key, value) { + var data = this.__data__; + + if (data instanceof ListCache) { + var pairs = data.__data__; + + if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + + data = this.__data__ = new MapCache(pairs); + } + + data.set(key, value); + this.size = data.size; + return this; + } // Add methods to `Stack`. + + + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + + function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && ( // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || // Node.js 0.10 has enumerable non-index properties on buffers. + isBuff && (key == 'offset' || key == 'parent') || // PhantomJS 2 has enumerable non-index properties on typed arrays. + isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') || // Skip index properties. + isIndex(key, length)))) { + result.push(key); + } + } + + return result; + } + /** + * A specialized version of `_.sample` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @returns {*} Returns the random element. + */ + + + function arraySample(array) { + var length = array.length; + return length ? array[baseRandom(0, length - 1)] : undefined$1; + } + /** + * A specialized version of `_.sampleSize` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + + + function arraySampleSize(array, n) { + return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); + } + /** + * A specialized version of `_.shuffle` for arrays. + * + * @private + * @param {Array} array The array to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + + + function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); + } + /** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + + + function assignMergeValue(object, key, value) { + if (value !== undefined$1 && !eq(object[key], value) || value === undefined$1 && !(key in object)) { + baseAssignValue(object, key, value); + } + } + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + + + function assignValue(object, key, value) { + var objValue = object[key]; + + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined$1 && !(key in object)) { + baseAssignValue(object, key, value); + } + } + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + + + function assocIndexOf(array, key) { + var length = array.length; + + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + + return -1; + } + /** + * Aggregates elements of `collection` on `accumulator` with keys transformed + * by `iteratee` and values set by `setter`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + + + function baseAggregator(collection, setter, iteratee, accumulator) { + baseEach(collection, function (value, key, collection) { + setter(accumulator, value, iteratee(value), collection); + }); + return accumulator; + } + /** + * The base implementation of `_.assign` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + + + function baseAssign(object, source) { + return object && copyObject(source, keys(source), object); + } + /** + * The base implementation of `_.assignIn` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + + + function baseAssignIn(object, source) { + return object && copyObject(source, keysIn(source), object); + } + /** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + + + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } + } + /** + * The base implementation of `_.at` without support for individual paths. + * + * @private + * @param {Object} object The object to iterate over. + * @param {string[]} paths The property paths to pick. + * @returns {Array} Returns the picked elements. + */ + + + function baseAt(object, paths) { + var index = -1, + length = paths.length, + result = Array(length), + skip = object == null; + + while (++index < length) { + result[index] = skip ? undefined$1 : get(object, paths[index]); + } + + return result; + } + /** + * The base implementation of `_.clamp` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + */ + + + function baseClamp(number, lower, upper) { + if (number === number) { + if (upper !== undefined$1) { + number = number <= upper ? number : upper; + } + + if (lower !== undefined$1) { + number = number >= lower ? number : lower; + } + } + + return number; + } + /** + * The base implementation of `_.clone` and `_.cloneDeep` which tracks + * traversed objects. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} bitmask The bitmask flags. + * 1 - Deep clone + * 2 - Flatten inherited properties + * 4 - Clone symbols + * @param {Function} [customizer] The function to customize cloning. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The parent object of `value`. + * @param {Object} [stack] Tracks traversed objects and their clone counterparts. + * @returns {*} Returns the cloned value. + */ + + + function baseClone(value, bitmask, customizer, key, object, stack) { + var result, + isDeep = bitmask & CLONE_DEEP_FLAG, + isFlat = bitmask & CLONE_FLAT_FLAG, + isFull = bitmask & CLONE_SYMBOLS_FLAG; + + if (customizer) { + result = object ? customizer(value, key, object, stack) : customizer(value); + } + + if (result !== undefined$1) { + return result; + } + + if (!isObject(value)) { + return value; + } + + var isArr = isArray(value); + + if (isArr) { + result = initCloneArray(value); + + if (!isDeep) { + return copyArray(value, result); + } + } else { + var tag = getTag(value), + isFunc = tag == funcTag || tag == genTag; + + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + + if (tag == objectTag || tag == argsTag || isFunc && !object) { + result = isFlat || isFunc ? {} : initCloneObject(value); + + if (!isDeep) { + return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value)); + } + } else { + if (!cloneableTags[tag]) { + return object ? value : {}; + } + + result = initCloneByTag(value, tag, isDeep); + } + } // Check for circular references and return its corresponding clone. + + + stack || (stack = new Stack()); + var stacked = stack.get(value); + + if (stacked) { + return stacked; + } + + stack.set(value, result); + + if (isSet(value)) { + value.forEach(function (subValue) { + result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); + }); + } else if (isMap(value)) { + value.forEach(function (subValue, key) { + result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + } + + var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys; + var props = isArr ? undefined$1 : keysFunc(value); + arrayEach(props || value, function (subValue, key) { + if (props) { + key = subValue; + subValue = value[key]; + } // Recursively populate clone (susceptible to call stack limits). + + + assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + return result; + } + /** + * The base implementation of `_.conforms` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property predicates to conform to. + * @returns {Function} Returns the new spec function. + */ + + + function baseConforms(source) { + var props = keys(source); + return function (object) { + return baseConformsTo(object, source, props); + }; + } + /** + * The base implementation of `_.conformsTo` which accepts `props` to check. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + */ + + + function baseConformsTo(object, source, props) { + var length = props.length; + + if (object == null) { + return !length; + } + + object = Object(object); + + while (length--) { + var key = props[length], + predicate = source[key], + value = object[key]; + + if (value === undefined$1 && !(key in object) || !predicate(value)) { + return false; + } + } + + return true; + } + /** + * The base implementation of `_.delay` and `_.defer` which accepts `args` + * to provide to `func`. + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {Array} args The arguments to provide to `func`. + * @returns {number|Object} Returns the timer id or timeout object. + */ + + + function baseDelay(func, wait, args) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + return setTimeout(function () { + func.apply(undefined$1, args); + }, wait); + } + /** + * The base implementation of methods like `_.difference` without support + * for excluding multiple arrays or iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + */ + + + function baseDifference(array, values, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + isCommon = true, + length = array.length, + result = [], + valuesLength = values.length; + + if (!length) { + return result; + } + + if (iteratee) { + values = arrayMap(values, baseUnary(iteratee)); + } + + if (comparator) { + includes = arrayIncludesWith; + isCommon = false; + } else if (values.length >= LARGE_ARRAY_SIZE) { + includes = cacheHas; + isCommon = false; + values = new SetCache(values); + } + + outer: while (++index < length) { + var value = array[index], + computed = iteratee == null ? value : iteratee(value); + value = comparator || value !== 0 ? value : 0; + + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + + while (valuesIndex--) { + if (values[valuesIndex] === computed) { + continue outer; + } + } + + result.push(value); + } else if (!includes(values, computed, comparator)) { + result.push(value); + } + } + + return result; + } + /** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + + + var baseEach = createBaseEach(baseForOwn); + /** + * The base implementation of `_.forEachRight` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + + var baseEachRight = createBaseEach(baseForOwnRight, true); + /** + * The base implementation of `_.every` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false` + */ + + function baseEvery(collection, predicate) { + var result = true; + baseEach(collection, function (value, index, collection) { + result = !!predicate(value, index, collection); + return result; + }); + return result; + } + /** + * The base implementation of methods like `_.max` and `_.min` which accepts a + * `comparator` to determine the extremum value. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The iteratee invoked per iteration. + * @param {Function} comparator The comparator used to compare values. + * @returns {*} Returns the extremum value. + */ + + + function baseExtremum(array, iteratee, comparator) { + var index = -1, + length = array.length; + + while (++index < length) { + var value = array[index], + current = iteratee(value); + + if (current != null && (computed === undefined$1 ? current === current && !isSymbol(current) : comparator(current, computed))) { + var computed = current, + result = value; + } + } + + return result; + } + /** + * The base implementation of `_.fill` without an iteratee call guard. + * + * @private + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + */ + + + function baseFill(array, value, start, end) { + var length = array.length; + start = toInteger(start); + + if (start < 0) { + start = -start > length ? 0 : length + start; + } + + end = end === undefined$1 || end > length ? length : toInteger(end); + + if (end < 0) { + end += length; + } + + end = start > end ? 0 : toLength(end); + + while (start < end) { + array[start++] = value; + } + + return array; + } + /** + * The base implementation of `_.filter` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + + + function baseFilter(collection, predicate) { + var result = []; + baseEach(collection, function (value, index, collection) { + if (predicate(value, index, collection)) { + result.push(value); + } + }); + return result; + } + /** + * The base implementation of `_.flatten` with support for restricting flattening. + * + * @private + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + + + function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + + return result; + } + /** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + + + var baseFor = createBaseFor(); + /** + * This function is like `baseFor` except that it iterates over properties + * in the opposite order. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + + var baseForRight = createBaseFor(true); + /** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + + function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + /** + * The base implementation of `_.forOwnRight` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + + + function baseForOwnRight(object, iteratee) { + return object && baseForRight(object, iteratee, keys); + } + /** + * The base implementation of `_.functions` which creates an array of + * `object` function property names filtered from `props`. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} props The property names to filter. + * @returns {Array} Returns the function names. + */ + + + function baseFunctions(object, props) { + return arrayFilter(props, function (key) { + return isFunction(object[key]); + }); + } + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + + + function baseGet(object, path) { + path = castPath(path, object); + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + + return index && index == length ? object : undefined$1; + } + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + + + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); + } + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + + + function baseGetTag(value) { + if (value == null) { + return value === undefined$1 ? undefinedTag : nullTag; + } + + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); + } + /** + * The base implementation of `_.gt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + */ + + + function baseGt(value, other) { + return value > other; + } + /** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + + + function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); + } + /** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + + + function baseHasIn(object, key) { + return object != null && key in Object(object); + } + /** + * The base implementation of `_.inRange` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to check. + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + */ + + + function baseInRange(number, start, end) { + return number >= nativeMin(start, end) && number < nativeMax(start, end); + } + /** + * The base implementation of methods like `_.intersection`, without support + * for iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of shared values. + */ + + + function baseIntersection(arrays, iteratee, comparator) { + var includes = comparator ? arrayIncludesWith : arrayIncludes, + length = arrays[0].length, + othLength = arrays.length, + othIndex = othLength, + caches = Array(othLength), + maxLength = Infinity, + result = []; + + while (othIndex--) { + var array = arrays[othIndex]; + + if (othIndex && iteratee) { + array = arrayMap(array, baseUnary(iteratee)); + } + + maxLength = nativeMin(array.length, maxLength); + caches[othIndex] = !comparator && (iteratee || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined$1; + } + + array = arrays[0]; + var index = -1, + seen = caches[0]; + + outer: while (++index < length && result.length < maxLength) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + value = comparator || value !== 0 ? value : 0; + + if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) { + othIndex = othLength; + + while (--othIndex) { + var cache = caches[othIndex]; + + if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) { + continue outer; + } + } + + if (seen) { + seen.push(computed); + } + + result.push(value); + } + } + + return result; + } + /** + * The base implementation of `_.invert` and `_.invertBy` which inverts + * `object` with values transformed by `iteratee` and set by `setter`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform values. + * @param {Object} accumulator The initial inverted object. + * @returns {Function} Returns `accumulator`. + */ + + + function baseInverter(object, setter, iteratee, accumulator) { + baseForOwn(object, function (value, key, object) { + setter(accumulator, iteratee(value), key, object); + }); + return accumulator; + } + /** + * The base implementation of `_.invoke` without support for individual + * method arguments. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {Array} args The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + */ + + + function baseInvoke(object, path, args) { + path = castPath(path, object); + object = parent(object, path); + var func = object == null ? object : object[toKey(last(path))]; + return func == null ? undefined$1 : apply(func, object, args); + } + /** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ + + + function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; + } + /** + * The base implementation of `_.isArrayBuffer` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + */ + + + function baseIsArrayBuffer(value) { + return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; + } + /** + * The base implementation of `_.isDate` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + */ + + + function baseIsDate(value) { + return isObjectLike(value) && baseGetTag(value) == dateTag; + } + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + + + function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + + if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) { + return value !== value && other !== other; + } + + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); + } + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + + + function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + + objIsArr = true; + objIsObj = false; + } + + if (isSameTag && !objIsObj) { + stack || (stack = new Stack()); + return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + stack || (stack = new Stack()); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + + if (!isSameTag) { + return false; + } + + stack || (stack = new Stack()); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); + } + /** + * The base implementation of `_.isMap` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + */ + + + function baseIsMap(value) { + return isObjectLike(value) && getTag(value) == mapTag; + } + /** + * The base implementation of `_.isMatch` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Array} matchData The property names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ + + + function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + + object = Object(object); + + while (index--) { + var data = matchData[index]; + + if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { + return false; + } + } + + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined$1 && !(key in object)) { + return false; + } + } else { + var stack = new Stack(); + + if (customizer) { + var result = customizer(objValue, srcValue, key, object, source, stack); + } + + if (!(result === undefined$1 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) { + return false; + } + } + } + + return true; + } + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + + + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + /** + * The base implementation of `_.isRegExp` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + */ + + + function baseIsRegExp(value) { + return isObjectLike(value) && baseGetTag(value) == regexpTag; + } + /** + * The base implementation of `_.isSet` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + */ + + + function baseIsSet(value) { + return isObjectLike(value) && getTag(value) == setTag; + } + /** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ + + + function baseIsTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; + } + /** + * The base implementation of `_.iteratee`. + * + * @private + * @param {*} [value=_.identity] The value to convert to an iteratee. + * @returns {Function} Returns the iteratee. + */ + + + function baseIteratee(value) { + // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. + // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. + if (typeof value == 'function') { + return value; + } + + if (value == null) { + return identity; + } + + if (_typeof(value) == 'object') { + return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); + } + + return property(value); + } + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + + + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + + var result = []; + + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + + return result; + } + /** + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + + + function baseKeysIn(object) { + if (!isObject(object)) { + return nativeKeysIn(object); + } + + var isProto = isPrototype(object), + result = []; + + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + + return result; + } + /** + * The base implementation of `_.lt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + */ + + + function baseLt(value, other) { + return value < other; + } + /** + * The base implementation of `_.map` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + + + function baseMap(collection, iteratee) { + var index = -1, + result = isArrayLike(collection) ? Array(collection.length) : []; + baseEach(collection, function (value, key, collection) { + result[++index] = iteratee(value, key, collection); + }); + return result; + } + /** + * The base implementation of `_.matches` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new spec function. + */ + + + function baseMatches(source) { + var matchData = getMatchData(source); + + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + + return function (object) { + return object === source || baseIsMatch(object, source, matchData); + }; + } + /** + * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + + + function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + + return function (object) { + var objValue = get(object, path); + return objValue === undefined$1 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; + } + /** + * The base implementation of `_.merge` without support for multiple sources. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {number} srcIndex The index of `source`. + * @param {Function} [customizer] The function to customize merged values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + + + function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + + baseFor(source, function (srcValue, key) { + stack || (stack = new Stack()); + + if (isObject(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } else { + var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack) : undefined$1; + + if (newValue === undefined$1) { + newValue = srcValue; + } + + assignMergeValue(object, key, newValue); + } + }, keysIn); + } + /** + * A specialized version of `baseMerge` for arrays and objects which performs + * deep merges and tracks traversed objects enabling objects with circular + * references to be merged. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {string} key The key of the value to merge. + * @param {number} srcIndex The index of `source`. + * @param {Function} mergeFunc The function to merge values. + * @param {Function} [customizer] The function to customize assigned values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + + + function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + + var newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined$1; + var isCommon = newValue === undefined$1; + + if (isCommon) { + var isArr = isArray(srcValue), + isBuff = !isArr && isBuffer(srcValue), + isTyped = !isArr && !isBuff && isTypedArray(srcValue); + newValue = srcValue; + + if (isArr || isBuff || isTyped) { + if (isArray(objValue)) { + newValue = objValue; + } else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } else { + newValue = []; + } + } else if (isPlainObject(srcValue) || isArguments(srcValue)) { + newValue = objValue; + + if (isArguments(objValue)) { + newValue = toPlainObject(objValue); + } else if (!isObject(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); + } + } else { + isCommon = false; + } + } + + if (isCommon) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack['delete'](srcValue); + } + + assignMergeValue(object, key, newValue); + } + /** + * The base implementation of `_.nth` which doesn't coerce arguments. + * + * @private + * @param {Array} array The array to query. + * @param {number} n The index of the element to return. + * @returns {*} Returns the nth element of `array`. + */ + + + function baseNth(array, n) { + var length = array.length; + + if (!length) { + return; + } + + n += n < 0 ? length : 0; + return isIndex(n, length) ? array[n] : undefined$1; + } + /** + * The base implementation of `_.orderBy` without param guards. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. + * @param {string[]} orders The sort orders of `iteratees`. + * @returns {Array} Returns the new sorted array. + */ + + + function baseOrderBy(collection, iteratees, orders) { + if (iteratees.length) { + iteratees = arrayMap(iteratees, function (iteratee) { + if (isArray(iteratee)) { + return function (value) { + return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee); + }; + } + + return iteratee; + }); + } else { + iteratees = [identity]; + } + + var index = -1; + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + var result = baseMap(collection, function (value, key, collection) { + var criteria = arrayMap(iteratees, function (iteratee) { + return iteratee(value); + }); + return { + 'criteria': criteria, + 'index': ++index, + 'value': value + }; + }); + return baseSortBy(result, function (object, other) { + return compareMultiple(object, other, orders); + }); + } + /** + * The base implementation of `_.pick` without support for individual + * property identifiers. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @returns {Object} Returns the new object. + */ + + + function basePick(object, paths) { + return basePickBy(object, paths, function (value, path) { + return hasIn(object, path); + }); + } + /** + * The base implementation of `_.pickBy` without support for iteratee shorthands. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @param {Function} predicate The function invoked per property. + * @returns {Object} Returns the new object. + */ + + + function basePickBy(object, paths, predicate) { + var index = -1, + length = paths.length, + result = {}; + + while (++index < length) { + var path = paths[index], + value = baseGet(object, path); + + if (predicate(value, path)) { + baseSet(result, castPath(path, object), value); + } + } + + return result; + } + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new accessor function. + */ + + + function basePropertyDeep(path) { + return function (object) { + return baseGet(object, path); + }; + } + /** + * The base implementation of `_.pullAllBy` without support for iteratee + * shorthands. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + */ + + + function basePullAll(array, values, iteratee, comparator) { + var indexOf = comparator ? baseIndexOfWith : baseIndexOf, + index = -1, + length = values.length, + seen = array; + + if (array === values) { + values = copyArray(values); + } + + if (iteratee) { + seen = arrayMap(array, baseUnary(iteratee)); + } + + while (++index < length) { + var fromIndex = 0, + value = values[index], + computed = iteratee ? iteratee(value) : value; + + while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { + if (seen !== array) { + splice.call(seen, fromIndex, 1); + } + + splice.call(array, fromIndex, 1); + } + } + + return array; + } + /** + * The base implementation of `_.pullAt` without support for individual + * indexes or capturing the removed elements. + * + * @private + * @param {Array} array The array to modify. + * @param {number[]} indexes The indexes of elements to remove. + * @returns {Array} Returns `array`. + */ + + + function basePullAt(array, indexes) { + var length = array ? indexes.length : 0, + lastIndex = length - 1; + + while (length--) { + var index = indexes[length]; + + if (length == lastIndex || index !== previous) { + var previous = index; + + if (isIndex(index)) { + splice.call(array, index, 1); + } else { + baseUnset(array, index); + } + } + } + + return array; + } + /** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {number} lower The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the random number. + */ + + + function baseRandom(lower, upper) { + return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); + } + /** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @param {number} step The value to increment or decrement by. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */ + + + function baseRange(start, end, step, fromRight) { + var index = -1, + length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), + result = Array(length); + + while (length--) { + result[fromRight ? length : ++index] = start; + start += step; + } + + return result; + } + /** + * The base implementation of `_.repeat` which doesn't coerce arguments. + * + * @private + * @param {string} string The string to repeat. + * @param {number} n The number of times to repeat the string. + * @returns {string} Returns the repeated string. + */ + + + function baseRepeat(string, n) { + var result = ''; + + if (!string || n < 1 || n > MAX_SAFE_INTEGER) { + return result; + } // Leverage the exponentiation by squaring algorithm for a faster repeat. + // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. + + + do { + if (n % 2) { + result += string; + } + + n = nativeFloor(n / 2); + + if (n) { + string += string; + } + } while (n); + + return result; + } + /** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ + + + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ''); + } + /** + * The base implementation of `_.sample`. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + */ + + + function baseSample(collection) { + return arraySample(values(collection)); + } + /** + * The base implementation of `_.sampleSize` without param guards. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + + + function baseSampleSize(collection, n) { + var array = values(collection); + return shuffleSelf(array, baseClamp(n, 0, array.length)); + } + /** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + + + function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + + path = castPath(path, object); + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (key === '__proto__' || key === 'constructor' || key === 'prototype') { + return object; + } + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined$1; + + if (newValue === undefined$1) { + newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {}; + } + } + + assignValue(nested, key, newValue); + nested = nested[key]; + } + + return object; + } + /** + * The base implementation of `setData` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + + + var baseSetData = !metaMap ? identity : function (func, data) { + metaMap.set(func, data); + return func; + }; + /** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + + var baseSetToString = !defineProperty ? identity : function (func, string) { + return defineProperty(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); + }; + /** + * The base implementation of `_.shuffle`. + * + * @private + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + + function baseShuffle(collection) { + return shuffleSelf(values(collection)); + } + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + + + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : length + start; + } + + end = end > length ? length : end; + + if (end < 0) { + end += length; + } + + length = start > end ? 0 : end - start >>> 0; + start >>>= 0; + var result = Array(length); + + while (++index < length) { + result[index] = array[index + start]; + } + + return result; + } + /** + * The base implementation of `_.some` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + + + function baseSome(collection, predicate) { + var result; + baseEach(collection, function (value, index, collection) { + result = predicate(value, index, collection); + return !result; + }); + return !!result; + } + /** + * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which + * performs a binary search of `array` to determine the index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + + + function baseSortedIndex(array, value, retHighest) { + var low = 0, + high = array == null ? low : array.length; + + if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { + while (low < high) { + var mid = low + high >>> 1, + computed = array[mid]; + + if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) { + low = mid + 1; + } else { + high = mid; + } + } + + return high; + } + + return baseSortedIndexBy(array, value, identity, retHighest); + } + /** + * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` + * which invokes `iteratee` for `value` and each element of `array` to compute + * their sort ranking. The iteratee is invoked with one argument; (value). + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} iteratee The iteratee invoked per element. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + + + function baseSortedIndexBy(array, value, iteratee, retHighest) { + var low = 0, + high = array == null ? 0 : array.length; + + if (high === 0) { + return 0; + } + + value = iteratee(value); + var valIsNaN = value !== value, + valIsNull = value === null, + valIsSymbol = isSymbol(value), + valIsUndefined = value === undefined$1; + + while (low < high) { + var mid = nativeFloor((low + high) / 2), + computed = iteratee(array[mid]), + othIsDefined = computed !== undefined$1, + othIsNull = computed === null, + othIsReflexive = computed === computed, + othIsSymbol = isSymbol(computed); + + if (valIsNaN) { + var setLow = retHighest || othIsReflexive; + } else if (valIsUndefined) { + setLow = othIsReflexive && (retHighest || othIsDefined); + } else if (valIsNull) { + setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); + } else if (valIsSymbol) { + setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); + } else if (othIsNull || othIsSymbol) { + setLow = false; + } else { + setLow = retHighest ? computed <= value : computed < value; + } + + if (setLow) { + low = mid + 1; + } else { + high = mid; + } + } + + return nativeMin(high, MAX_ARRAY_INDEX); + } + /** + * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + + + function baseSortedUniq(array, iteratee) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + if (!index || !eq(computed, seen)) { + var seen = computed; + result[resIndex++] = value === 0 ? 0 : value; + } + } + + return result; + } + /** + * The base implementation of `_.toNumber` which doesn't ensure correct + * conversions of binary, hexadecimal, or octal string values. + * + * @private + * @param {*} value The value to process. + * @returns {number} Returns the number. + */ + + + function baseToNumber(value) { + if (typeof value == 'number') { + return value; + } + + if (isSymbol(value)) { + return NAN; + } + + return +value; + } + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + + + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + + var result = value + ''; + return result == '0' && 1 / value == -INFINITY ? '-0' : result; + } + /** + * The base implementation of `_.uniqBy` without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + + + function baseUniq(array, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + length = array.length, + isCommon = true, + result = [], + seen = result; + + if (comparator) { + isCommon = false; + includes = arrayIncludesWith; + } else if (length >= LARGE_ARRAY_SIZE) { + var set = iteratee ? null : createSet(array); + + if (set) { + return setToArray(set); + } + + isCommon = false; + includes = cacheHas; + seen = new SetCache(); + } else { + seen = iteratee ? [] : result; + } + + outer: while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + value = comparator || value !== 0 ? value : 0; + + if (isCommon && computed === computed) { + var seenIndex = seen.length; + + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + + if (iteratee) { + seen.push(computed); + } + + result.push(value); + } else if (!includes(seen, computed, comparator)) { + if (seen !== result) { + seen.push(computed); + } + + result.push(value); + } + } + + return result; + } + /** + * The base implementation of `_.unset`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The property path to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + */ + + + function baseUnset(object, path) { + path = castPath(path, object); + object = parent(object, path); + return object == null || delete object[toKey(last(path))]; + } + /** + * The base implementation of `_.update`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to update. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + + + function baseUpdate(object, path, updater, customizer) { + return baseSet(object, path, updater(baseGet(object, path)), customizer); + } + /** + * The base implementation of methods like `_.dropWhile` and `_.takeWhile` + * without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to query. + * @param {Function} predicate The function invoked per iteration. + * @param {boolean} [isDrop] Specify dropping elements instead of taking them. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the slice of `array`. + */ + + + function baseWhile(array, predicate, isDrop, fromRight) { + var length = array.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {} + + return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index); + } + /** + * The base implementation of `wrapperValue` which returns the result of + * performing a sequence of actions on the unwrapped `value`, where each + * successive action is supplied the return value of the previous. + * + * @private + * @param {*} value The unwrapped value. + * @param {Array} actions Actions to perform to resolve the unwrapped value. + * @returns {*} Returns the resolved value. + */ + + + function baseWrapperValue(value, actions) { + var result = value; + + if (result instanceof LazyWrapper) { + result = result.value(); + } + + return arrayReduce(actions, function (result, action) { + return action.func.apply(action.thisArg, arrayPush([result], action.args)); + }, result); + } + /** + * The base implementation of methods like `_.xor`, without support for + * iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of values. + */ + + + function baseXor(arrays, iteratee, comparator) { + var length = arrays.length; + + if (length < 2) { + return length ? baseUniq(arrays[0]) : []; + } + + var index = -1, + result = Array(length); + + while (++index < length) { + var array = arrays[index], + othIndex = -1; + + while (++othIndex < length) { + if (othIndex != index) { + result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); + } + } + } + + return baseUniq(baseFlatten(result, 1), iteratee, comparator); + } + /** + * This base implementation of `_.zipObject` which assigns values using `assignFunc`. + * + * @private + * @param {Array} props The property identifiers. + * @param {Array} values The property values. + * @param {Function} assignFunc The function to assign values. + * @returns {Object} Returns the new object. + */ + + + function baseZipObject(props, values, assignFunc) { + var index = -1, + length = props.length, + valsLength = values.length, + result = {}; + + while (++index < length) { + var value = index < valsLength ? values[index] : undefined$1; + assignFunc(result, props[index], value); + } + + return result; + } + /** + * Casts `value` to an empty array if it's not an array like object. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array|Object} Returns the cast array-like object. + */ + + + function castArrayLikeObject(value) { + return isArrayLikeObject(value) ? value : []; + } + /** + * Casts `value` to `identity` if it's not a function. + * + * @private + * @param {*} value The value to inspect. + * @returns {Function} Returns cast function. + */ + + + function castFunction(value) { + return typeof value == 'function' ? value : identity; + } + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ + + + function castPath(value, object) { + if (isArray(value)) { + return value; + } + + return isKey(value, object) ? [value] : stringToPath(toString(value)); + } + /** + * A `baseRest` alias which can be replaced with `identity` by module + * replacement plugins. + * + * @private + * @type {Function} + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + + + var castRest = baseRest; + /** + * Casts `array` to a slice if it's needed. + * + * @private + * @param {Array} array The array to inspect. + * @param {number} start The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the cast slice. + */ + + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined$1 ? length : end; + return !start && end >= length ? array : baseSlice(array, start, end); + } + /** + * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). + * + * @private + * @param {number|Object} id The timer id or timeout object of the timer to clear. + */ + + + var clearTimeout = ctxClearTimeout || function (id) { + return root.clearTimeout(id); + }; + /** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ + + + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + buffer.copy(result); + return result; + } + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + + + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; + } + /** + * Creates a clone of `dataView`. + * + * @private + * @param {Object} dataView The data view to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned data view. + */ + + + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + /** + * Creates a clone of `regexp`. + * + * @private + * @param {Object} regexp The regexp to clone. + * @returns {Object} Returns the cloned regexp. + */ + + + function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; + } + /** + * Creates a clone of the `symbol` object. + * + * @private + * @param {Object} symbol The symbol object to clone. + * @returns {Object} Returns the cloned symbol object. + */ + + + function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + } + /** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ + + + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + /** + * Compares values to sort them in ascending order. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {number} Returns the sort order indicator for `value`. + */ + + + function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== undefined$1, + valIsNull = value === null, + valIsReflexive = value === value, + valIsSymbol = isSymbol(value); + var othIsDefined = other !== undefined$1, + othIsNull = other === null, + othIsReflexive = other === other, + othIsSymbol = isSymbol(other); + + if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) { + return 1; + } + + if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) { + return -1; + } + } + + return 0; + } + /** + * Used by `_.orderBy` to compare multiple properties of a value to another + * and stable sort them. + * + * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, + * specify an order of "desc" for descending or "asc" for ascending sort order + * of corresponding values. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {boolean[]|string[]} orders The order to sort by for each property. + * @returns {number} Returns the sort order indicator for `object`. + */ + + + function compareMultiple(object, other, orders) { + var index = -1, + objCriteria = object.criteria, + othCriteria = other.criteria, + length = objCriteria.length, + ordersLength = orders.length; + + while (++index < length) { + var result = compareAscending(objCriteria[index], othCriteria[index]); + + if (result) { + if (index >= ordersLength) { + return result; + } + + var order = orders[index]; + return result * (order == 'desc' ? -1 : 1); + } + } // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications + // that causes it, under certain circumstances, to provide the same value for + // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 + // for more details. + // + // This also ensures a stable sort in V8 and other engines. + // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. + + + return object.index - other.index; + } + /** + * Creates an array that is the composition of partially applied arguments, + * placeholders, and provided arguments into a single array of arguments. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to prepend to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + + + function composeArgs(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersLength = holders.length, + leftIndex = -1, + leftLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(leftLength + rangeLength), + isUncurried = !isCurried; + + while (++leftIndex < leftLength) { + result[leftIndex] = partials[leftIndex]; + } + + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[holders[argsIndex]] = args[argsIndex]; + } + } + + while (rangeLength--) { + result[leftIndex++] = args[argsIndex++]; + } + + return result; + } + /** + * This function is like `composeArgs` except that the arguments composition + * is tailored for `_.partialRight`. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to append to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + + + function composeArgsRight(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersIndex = -1, + holdersLength = holders.length, + rightIndex = -1, + rightLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(rangeLength + rightLength), + isUncurried = !isCurried; + + while (++argsIndex < rangeLength) { + result[argsIndex] = args[argsIndex]; + } + + var offset = argsIndex; + + while (++rightIndex < rightLength) { + result[offset + rightIndex] = partials[rightIndex]; + } + + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[offset + holders[holdersIndex]] = args[argsIndex++]; + } + } + + return result; + } + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + + + function copyArray(source, array) { + var index = -1, + length = source.length; + array || (array = Array(length)); + + while (++index < length) { + array[index] = source[index]; + } + + return array; + } + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + + + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined$1; + + if (newValue === undefined$1) { + newValue = source[key]; + } + + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + + return object; + } + /** + * Copies own symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + + + function copySymbols(source, object) { + return copyObject(source, getSymbols(source), object); + } + /** + * Copies own and inherited symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + + + function copySymbolsIn(source, object) { + return copyObject(source, getSymbolsIn(source), object); + } + /** + * Creates a function like `_.groupBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} [initializer] The accumulator object initializer. + * @returns {Function} Returns the new aggregator function. + */ + + + function createAggregator(setter, initializer) { + return function (collection, iteratee) { + var func = isArray(collection) ? arrayAggregator : baseAggregator, + accumulator = initializer ? initializer() : {}; + return func(collection, setter, getIteratee(iteratee, 2), accumulator); + }; + } + /** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ + + + function createAssigner(assigner) { + return baseRest(function (object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined$1, + guard = length > 2 ? sources[2] : undefined$1; + customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined$1; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined$1 : customizer; + length = 1; + } + + object = Object(object); + + while (++index < length) { + var source = sources[index]; + + if (source) { + assigner(object, source, index, customizer); + } + } + + return object; + }); + } + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + + + function createBaseEach(eachFunc, fromRight) { + return function (collection, iteratee) { + if (collection == null) { + return collection; + } + + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + + while (fromRight ? index-- : ++index < length) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + + return collection; + }; + } + /** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + + + function createBaseFor(fromRight) { + return function (object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + + return object; + }; + } + /** + * Creates a function that wraps `func` to invoke it with the optional `this` + * binding of `thisArg`. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @returns {Function} Returns the new wrapped function. + */ + + + function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return fn.apply(isBind ? thisArg : this, arguments); + } + + return wrapper; + } + /** + * Creates a function like `_.lowerFirst`. + * + * @private + * @param {string} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. + */ + + + function createCaseFirst(methodName) { + return function (string) { + string = toString(string); + var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined$1; + var chr = strSymbols ? strSymbols[0] : string.charAt(0); + var trailing = strSymbols ? castSlice(strSymbols, 1).join('') : string.slice(1); + return chr[methodName]() + trailing; + }; + } + /** + * Creates a function like `_.camelCase`. + * + * @private + * @param {Function} callback The function to combine each word. + * @returns {Function} Returns the new compounder function. + */ + + + function createCompounder(callback) { + return function (string) { + return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); + }; + } + /** + * Creates a function that produces an instance of `Ctor` regardless of + * whether it was invoked as part of a `new` expression or by `call` or `apply`. + * + * @private + * @param {Function} Ctor The constructor to wrap. + * @returns {Function} Returns the new wrapped function. + */ + + + function createCtor(Ctor) { + return function () { + // Use a `switch` statement to work with class constructors. See + // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist + // for more details. + var args = arguments; + + switch (args.length) { + case 0: + return new Ctor(); + + case 1: + return new Ctor(args[0]); + + case 2: + return new Ctor(args[0], args[1]); + + case 3: + return new Ctor(args[0], args[1], args[2]); + + case 4: + return new Ctor(args[0], args[1], args[2], args[3]); + + case 5: + return new Ctor(args[0], args[1], args[2], args[3], args[4]); + + case 6: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); + + case 7: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); + } + + var thisBinding = baseCreate(Ctor.prototype), + result = Ctor.apply(thisBinding, args); // Mimic the constructor's `return` behavior. + // See https://es5.github.io/#x13.2.2 for more details. + + return isObject(result) ? result : thisBinding; + }; + } + /** + * Creates a function that wraps `func` to enable currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {number} arity The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + + + function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length, + placeholder = getHolder(wrapper); + + while (index--) { + args[index] = arguments[index]; + } + + var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder); + length -= holders.length; + + if (length < arity) { + return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, undefined$1, args, holders, undefined$1, undefined$1, arity - length); + } + + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return apply(fn, this, args); + } + + return wrapper; + } + /** + * Creates a `_.find` or `_.findLast` function. + * + * @private + * @param {Function} findIndexFunc The function to find the collection index. + * @returns {Function} Returns the new find function. + */ + + + function createFind(findIndexFunc) { + return function (collection, predicate, fromIndex) { + var iterable = Object(collection); + + if (!isArrayLike(collection)) { + var iteratee = getIteratee(predicate, 3); + collection = keys(collection); + + predicate = function predicate(key) { + return iteratee(iterable[key], key, iterable); + }; + } + + var index = findIndexFunc(collection, predicate, fromIndex); + return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1; + }; + } + /** + * Creates a `_.flow` or `_.flowRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new flow function. + */ + + + function createFlow(fromRight) { + return flatRest(function (funcs) { + var length = funcs.length, + index = length, + prereq = LodashWrapper.prototype.thru; + + if (fromRight) { + funcs.reverse(); + } + + while (index--) { + var func = funcs[index]; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + if (prereq && !wrapper && getFuncName(func) == 'wrapper') { + var wrapper = new LodashWrapper([], true); + } + } + + index = wrapper ? index : length; + + while (++index < length) { + func = funcs[index]; + var funcName = getFuncName(func), + data = funcName == 'wrapper' ? getData(func) : undefined$1; + + if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) { + wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); + } else { + wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func); + } + } + + return function () { + var args = arguments, + value = args[0]; + + if (wrapper && args.length == 1 && isArray(value)) { + return wrapper.plant(value).value(); + } + + var index = 0, + result = length ? funcs[index].apply(this, args) : value; + + while (++index < length) { + result = funcs[index].call(this, result); + } + + return result; + }; + }); + } + /** + * Creates a function that wraps `func` to invoke it with optional `this` + * binding of `thisArg`, partial application, and currying. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [partialsRight] The arguments to append to those provided + * to the new function. + * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + + + function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { + var isAry = bitmask & WRAP_ARY_FLAG, + isBind = bitmask & WRAP_BIND_FLAG, + isBindKey = bitmask & WRAP_BIND_KEY_FLAG, + isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), + isFlip = bitmask & WRAP_FLIP_FLAG, + Ctor = isBindKey ? undefined$1 : createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length; + + while (index--) { + args[index] = arguments[index]; + } + + if (isCurried) { + var placeholder = getHolder(wrapper), + holdersCount = countHolders(args, placeholder); + } + + if (partials) { + args = composeArgs(args, partials, holders, isCurried); + } + + if (partialsRight) { + args = composeArgsRight(args, partialsRight, holdersRight, isCurried); + } + + length -= holdersCount; + + if (isCurried && length < arity) { + var newHolders = replaceHolders(args, placeholder); + return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary, arity - length); + } + + var thisBinding = isBind ? thisArg : this, + fn = isBindKey ? thisBinding[func] : func; + length = args.length; + + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + + if (isAry && ary < length) { + args.length = ary; + } + + if (this && this !== root && this instanceof wrapper) { + fn = Ctor || createCtor(fn); + } + + return fn.apply(thisBinding, args); + } + + return wrapper; + } + /** + * Creates a function like `_.invertBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} toIteratee The function to resolve iteratees. + * @returns {Function} Returns the new inverter function. + */ + + + function createInverter(setter, toIteratee) { + return function (object, iteratee) { + return baseInverter(object, setter, toIteratee(iteratee), {}); + }; + } + /** + * Creates a function that performs a mathematical operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @param {number} [defaultValue] The value used for `undefined` arguments. + * @returns {Function} Returns the new mathematical operation function. + */ + + + function createMathOperation(operator, defaultValue) { + return function (value, other) { + var result; + + if (value === undefined$1 && other === undefined$1) { + return defaultValue; + } + + if (value !== undefined$1) { + result = value; + } + + if (other !== undefined$1) { + if (result === undefined$1) { + return other; + } + + if (typeof value == 'string' || typeof other == 'string') { + value = baseToString(value); + other = baseToString(other); + } else { + value = baseToNumber(value); + other = baseToNumber(other); + } + + result = operator(value, other); + } + + return result; + }; + } + /** + * Creates a function like `_.over`. + * + * @private + * @param {Function} arrayFunc The function to iterate over iteratees. + * @returns {Function} Returns the new over function. + */ + + + function createOver(arrayFunc) { + return flatRest(function (iteratees) { + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + return baseRest(function (args) { + var thisArg = this; + return arrayFunc(iteratees, function (iteratee) { + return apply(iteratee, thisArg, args); + }); + }); + }); + } + /** + * Creates the padding for `string` based on `length`. The `chars` string + * is truncated if the number of characters exceeds `length`. + * + * @private + * @param {number} length The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padding for `string`. + */ + + + function createPadding(length, chars) { + chars = chars === undefined$1 ? ' ' : baseToString(chars); + var charsLength = chars.length; + + if (charsLength < 2) { + return charsLength ? baseRepeat(chars, length) : chars; + } + + var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); + return hasUnicode(chars) ? castSlice(stringToArray(result), 0, length).join('') : result.slice(0, length); + } + /** + * Creates a function that wraps `func` to invoke it with the `this` binding + * of `thisArg` and `partials` prepended to the arguments it receives. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} partials The arguments to prepend to those provided to + * the new function. + * @returns {Function} Returns the new wrapped function. + */ + + + function createPartial(func, bitmask, thisArg, partials) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var argsIndex = -1, + argsLength = arguments.length, + leftIndex = -1, + leftLength = partials.length, + args = Array(leftLength + argsLength), + fn = this && this !== root && this instanceof wrapper ? Ctor : func; + + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + + return apply(fn, isBind ? thisArg : this, args); + } + + return wrapper; + } + /** + * Creates a `_.range` or `_.rangeRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new range function. + */ + + + function createRange(fromRight) { + return function (start, end, step) { + if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { + end = step = undefined$1; + } // Ensure the sign of `-0` is preserved. + + + start = toFinite(start); + + if (end === undefined$1) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + + step = step === undefined$1 ? start < end ? 1 : -1 : toFinite(step); + return baseRange(start, end, step, fromRight); + }; + } + /** + * Creates a function that performs a relational operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @returns {Function} Returns the new relational operation function. + */ + + + function createRelationalOperation(operator) { + return function (value, other) { + if (!(typeof value == 'string' && typeof other == 'string')) { + value = toNumber(value); + other = toNumber(other); + } + + return operator(value, other); + }; + } + /** + * Creates a function that wraps `func` to continue currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {Function} wrapFunc The function to create the `func` wrapper. + * @param {*} placeholder The placeholder value. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + + + function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { + var isCurry = bitmask & WRAP_CURRY_FLAG, + newHolders = isCurry ? holders : undefined$1, + newHoldersRight = isCurry ? undefined$1 : holders, + newPartials = isCurry ? partials : undefined$1, + newPartialsRight = isCurry ? undefined$1 : partials; + bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG; + bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); + + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); + } + + var newData = [func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, newHoldersRight, argPos, ary, arity]; + var result = wrapFunc.apply(undefined$1, newData); + + if (isLaziable(func)) { + setData(result, newData); + } + + result.placeholder = placeholder; + return setWrapToString(result, func, bitmask); + } + /** + * Creates a function like `_.round`. + * + * @private + * @param {string} methodName The name of the `Math` method to use when rounding. + * @returns {Function} Returns the new round function. + */ + + + function createRound(methodName) { + var func = Math[methodName]; + return function (number, precision) { + number = toNumber(number); + precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); + + if (precision && nativeIsFinite(number)) { + // Shift with exponential notation to avoid floating-point issues. + // See [MDN](https://mdn.io/round#Examples) for more details. + var pair = (toString(number) + 'e').split('e'), + value = func(pair[0] + 'e' + (+pair[1] + precision)); + pair = (toString(value) + 'e').split('e'); + return +(pair[0] + 'e' + (+pair[1] - precision)); + } + + return func(number); + }; + } + /** + * Creates a set object of `values`. + * + * @private + * @param {Array} values The values to add to the set. + * @returns {Object} Returns the new set. + */ + + + var createSet = !(Set && 1 / setToArray(new Set([, -0]))[1] == INFINITY) ? noop : function (values) { + return new Set(values); + }; + /** + * Creates a `_.toPairs` or `_.toPairsIn` function. + * + * @private + * @param {Function} keysFunc The function to get the keys of a given object. + * @returns {Function} Returns the new pairs function. + */ + + function createToPairs(keysFunc) { + return function (object) { + var tag = getTag(object); + + if (tag == mapTag) { + return mapToArray(object); + } + + if (tag == setTag) { + return setToPairs(object); + } + + return baseToPairs(object, keysFunc(object)); + }; + } + /** + * Creates a function that either curries or invokes `func` with optional + * `this` binding and partially applied arguments. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. + * 1 - `_.bind` + * 2 - `_.bindKey` + * 4 - `_.curry` or `_.curryRight` of a bound function + * 8 - `_.curry` + * 16 - `_.curryRight` + * 32 - `_.partial` + * 64 - `_.partialRight` + * 128 - `_.rearg` + * 256 - `_.ary` + * 512 - `_.flip` + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to be partially applied. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + + + function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + + if (!isBindKey && typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + var length = partials ? partials.length : 0; + + if (!length) { + bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); + partials = holders = undefined$1; + } + + ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0); + arity = arity === undefined$1 ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, + holdersRight = holders; + partials = holders = undefined$1; + } + + var data = isBindKey ? undefined$1 : getData(func); + var newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity]; + + if (data) { + mergeData(newData, data); + } + + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = newData[9] === undefined$1 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0); + + if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { + bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); + } + + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result = createBind(func, bitmask, thisArg); + } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { + result = createCurry(func, bitmask, arity); + } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { + result = createPartial(func, bitmask, thisArg, partials); + } else { + result = createHybrid.apply(undefined$1, newData); + } + + var setter = data ? baseSetData : setData; + return setWrapToString(setter(result, newData), func, bitmask); + } + /** + * Used by `_.defaults` to customize its `_.assignIn` use to assign properties + * of source objects to the destination object for all destination properties + * that resolve to `undefined`. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to assign. + * @param {Object} object The parent object of `objValue`. + * @returns {*} Returns the value to assign. + */ + + + function customDefaultsAssignIn(objValue, srcValue, key, object) { + if (objValue === undefined$1 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key)) { + return srcValue; + } + + return objValue; + } + /** + * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source + * objects into destination objects that are passed thru. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to merge. + * @param {Object} object The parent object of `objValue`. + * @param {Object} source The parent object of `srcValue`. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + * @returns {*} Returns the value to assign. + */ + + + function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { + if (isObject(objValue) && isObject(srcValue)) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, objValue); + baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack); + stack['delete'](srcValue); + } + + return objValue; + } + /** + * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain + * objects. + * + * @private + * @param {*} value The value to inspect. + * @param {string} key The key of the property to inspect. + * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. + */ + + + function customOmitClone(value) { + return isPlainObject(value) ? undefined$1 : value; + } + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + + + function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } // Check that cyclic values are equal. + + + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + + var index = -1, + result = true, + seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined$1; + stack.set(array, other); + stack.set(other, array); // Ignore non-index properties. + + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); + } + + if (compared !== undefined$1) { + if (compared) { + continue; + } + + result = false; + break; + } // Recursively compare arrays (susceptible to call stack limits). + + + if (seen) { + if (!arraySome(other, function (othValue, othIndex) { + if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + result = false; + break; + } + } + + stack['delete'](array); + stack['delete'](other); + return result; + } + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + + + function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) { + return false; + } + + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) { + return false; + } + + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == other + ''; + + case mapTag: + var convert = mapToArray; + + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } // Assume cyclic values are equal. + + + var stacked = stack.get(object); + + if (stacked) { + return stacked == other; + } + + bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits). + + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + + } + + return false; + } + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + + + function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + + var index = objLength; + + while (index--) { + var key = objProps[index]; + + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } // Check that cyclic values are equal. + + + var objStacked = stack.get(object); + var othStacked = stack.get(other); + + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + + var result = true; + stack.set(object, other); + stack.set(other, object); + var skipCtor = isPartial; + + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); + } // Recursively compare objects (susceptible to call stack limits). + + + if (!(compared === undefined$1 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) { + result = false; + break; + } + + skipCtor || (skipCtor = key == 'constructor'); + } + + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal. + + if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + + stack['delete'](object); + stack['delete'](other); + return result; + } + /** + * A specialized version of `baseRest` which flattens the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + + + function flatRest(func) { + return setToString(overRest(func, undefined$1, flatten), func + ''); + } + /** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + + + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); + } + /** + * Creates an array of own and inherited enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + + + function getAllKeysIn(object) { + return baseGetAllKeys(object, keysIn, getSymbolsIn); + } + /** + * Gets metadata for `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {*} Returns the metadata for `func`. + */ + + + var getData = !metaMap ? noop : function (func) { + return metaMap.get(func); + }; + /** + * Gets the name of `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {string} Returns the function name. + */ + + function getFuncName(func) { + var result = func.name + '', + array = realNames[result], + length = hasOwnProperty.call(realNames, result) ? array.length : 0; + + while (length--) { + var data = array[length], + otherFunc = data.func; + + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + + return result; + } + /** + * Gets the argument placeholder value for `func`. + * + * @private + * @param {Function} func The function to inspect. + * @returns {*} Returns the placeholder value. + */ + + + function getHolder(func) { + var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; + return object.placeholder; + } + /** + * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, + * this function returns the custom method, otherwise it returns `baseIteratee`. + * If arguments are provided, the chosen function is invoked with them and + * its result is returned. + * + * @private + * @param {*} [value] The value to convert to an iteratee. + * @param {number} [arity] The arity of the created iteratee. + * @returns {Function} Returns the chosen function or its result. + */ + + + function getIteratee() { + var result = lodash.iteratee || iteratee; + result = result === iteratee ? baseIteratee : result; + return arguments.length ? result(arguments[0], arguments[1]) : result; + } + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + + + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map; + } + /** + * Gets the property names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ + + + function getMatchData(object) { + var result = keys(object), + length = result.length; + + while (length--) { + var key = result[length], + value = object[key]; + result[length] = [key, value, isStrictComparable(value)]; + } + + return result; + } + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + + + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined$1; + } + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ + + + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined$1; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + + return result; + } + /** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + + + var getSymbols = !nativeGetSymbols ? stubArray : function (object) { + if (object == null) { + return []; + } + + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function (symbol) { + return propertyIsEnumerable.call(object, symbol); + }); + }; + /** + * Creates an array of the own and inherited enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + + var getSymbolsIn = !nativeGetSymbols ? stubArray : function (object) { + var result = []; + + while (object) { + arrayPush(result, getSymbols(object)); + object = getPrototype(object); + } + + return result; + }; + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + + var getTag = baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. + + if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) { + getTag = function getTag(value) { + var result = baseGetTag(value), + Ctor = result == objectTag ? value.constructor : undefined$1, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag; + + case mapCtorString: + return mapTag; + + case promiseCtorString: + return promiseTag; + + case setCtorString: + return setTag; + + case weakMapCtorString: + return weakMapTag; + } + } + + return result; + }; + } + /** + * Gets the view, applying any `transforms` to the `start` and `end` positions. + * + * @private + * @param {number} start The start of the view. + * @param {number} end The end of the view. + * @param {Array} transforms The transformations to apply to the view. + * @returns {Object} Returns an object containing the `start` and `end` + * positions of the view. + */ + + + function getView(start, end, transforms) { + var index = -1, + length = transforms.length; + + while (++index < length) { + var data = transforms[index], + size = data.size; + + switch (data.type) { + case 'drop': + start += size; + break; + + case 'dropRight': + end -= size; + break; + + case 'take': + end = nativeMin(end, start + size); + break; + + case 'takeRight': + start = nativeMax(start, end - size); + break; + } + } + + return { + 'start': start, + 'end': end + }; + } + /** + * Extracts wrapper details from the `source` body comment. + * + * @private + * @param {string} source The source to inspect. + * @returns {Array} Returns the wrapper details. + */ + + + function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + /** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ + + + function hasPath(object, path, hasFunc) { + path = castPath(path, object); + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + + if (!(result = object != null && hasFunc(object, key))) { + break; + } + + object = object[key]; + } + + if (result || ++index != length) { + return result; + } + + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object)); + } + /** + * Initializes an array clone. + * + * @private + * @param {Array} array The array to clone. + * @returns {Array} Returns the initialized clone. + */ + + + function initCloneArray(array) { + var length = array.length, + result = new array.constructor(length); // Add properties assigned by `RegExp#exec`. + + if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { + result.index = array.index; + result.input = array.input; + } + + return result; + } + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + + + function initCloneObject(object) { + return typeof object.constructor == 'function' && !isPrototype(object) ? baseCreate(getPrototype(object)) : {}; + } + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + + + function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + + case boolTag: + case dateTag: + return new Ctor(+object); + + case dataViewTag: + return cloneDataView(object, isDeep); + + case float32Tag: + case float64Tag: + case int8Tag: + case int16Tag: + case int32Tag: + case uint8Tag: + case uint8ClampedTag: + case uint16Tag: + case uint32Tag: + return cloneTypedArray(object, isDeep); + + case mapTag: + return new Ctor(); + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + return cloneRegExp(object); + + case setTag: + return new Ctor(); + + case symbolTag: + return cloneSymbol(object); + } + } + /** + * Inserts wrapper `details` in a comment at the top of the `source` body. + * + * @private + * @param {string} source The source to modify. + * @returns {Array} details The details to insert. + * @returns {string} Returns the modified source. + */ + + + function insertWrapDetails(source, details) { + var length = details.length; + + if (!length) { + return source; + } + + var lastIndex = length - 1; + details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; + details = details.join(length > 2 ? ', ' : ' '); + return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); + } + /** + * Checks if `value` is a flattenable `arguments` object or array. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + */ + + + function isFlattenable(value) { + return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]); + } + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + + + function isIndex(value, length) { + var type = _typeof(value); + + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length; + } + /** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ + + + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + + var type = _typeof(index); + + if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) { + return eq(object[index], value); + } + + return false; + } + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + + + function isKey(value, object) { + if (isArray(value)) { + return false; + } + + var type = _typeof(value); + + if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol(value)) { + return true; + } + + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object); + } + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + + + function isKeyable(value) { + var type = _typeof(value); + + return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null; + } + /** + * Checks if `func` has a lazy counterpart. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` has a lazy counterpart, + * else `false`. + */ + + + function isLaziable(func) { + var funcName = getFuncName(func), + other = lodash[funcName]; + + if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { + return false; + } + + if (func === other) { + return true; + } + + var data = getData(other); + return !!data && func === data[0]; + } + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + + + function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; + } + /** + * Checks if `func` is capable of being masked. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `func` is maskable, else `false`. + */ + + + var isMaskable = coreJsData ? isFunction : stubFalse; + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = typeof Ctor == 'function' && Ctor.prototype || objectProto; + return value === proto; + } + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + + + function isStrictComparable(value) { + return value === value && !isObject(value); + } + /** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {string} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + + + function matchesStrictComparable(key, srcValue) { + return function (object) { + if (object == null) { + return false; + } + + return object[key] === srcValue && (srcValue !== undefined$1 || key in Object(object)); + }; + } + /** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ + + + function memoizeCapped(func) { + var result = memoize(func, function (key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + + return key; + }); + var cache = result.cache; + return result; + } + /** + * Merges the function metadata of `source` into `data`. + * + * Merging metadata reduces the number of wrappers used to invoke a function. + * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` + * may be applied regardless of execution order. Methods like `_.ary` and + * `_.rearg` modify function arguments, making the order in which they are + * executed important, preventing the merging of metadata. However, we make + * an exception for a safe combined case where curried functions have `_.ary` + * and or `_.rearg` applied. + * + * @private + * @param {Array} data The destination metadata. + * @param {Array} source The source metadata. + * @returns {Array} Returns `data`. + */ + + + function mergeData(data, source) { + var bitmask = data[1], + srcBitmask = source[1], + newBitmask = bitmask | srcBitmask, + isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); + var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG; // Exit early if metadata can't be merged. + + if (!(isCommon || isCombo)) { + return data; + } // Use source `thisArg` if available. + + + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; // Set when currying a bound function. + + newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; + } // Compose partial arguments. + + + var value = source[3]; + + if (value) { + var partials = data[3]; + data[3] = partials ? composeArgs(partials, value, source[4]) : value; + data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; + } // Compose partial right arguments. + + + value = source[5]; + + if (value) { + partials = data[5]; + data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; + data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; + } // Use source `argPos` if available. + + + value = source[7]; + + if (value) { + data[7] = value; + } // Use source `ary` if it's smaller. + + + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); + } // Use source `arity` if one is not provided. + + + if (data[9] == null) { + data[9] = source[9]; + } // Use source `func` and merge bitmasks. + + + data[0] = source[0]; + data[1] = newBitmask; + return data; + } + /** + * This function is like + * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * except that it includes inherited enumerable properties. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + + + function nativeKeysIn(object) { + var result = []; + + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + + return result; + } + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ + + + function objectToString(value) { + return nativeObjectToString.call(value); + } + /** + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. + */ + + + function overRest(func, start, transform) { + start = nativeMax(start === undefined$1 ? func.length - 1 : start, 0); + return function () { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + + index = -1; + var otherArgs = Array(start + 1); + + while (++index < start) { + otherArgs[index] = args[index]; + } + + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; + } + /** + * Gets the parent value at `path` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path to get the parent value of. + * @returns {*} Returns the parent value. + */ + + + function parent(object, path) { + return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); + } + /** + * Reorder `array` according to the specified indexes where the element at + * the first index is assigned as the first element, the element at + * the second index is assigned as the second element, and so on. + * + * @private + * @param {Array} array The array to reorder. + * @param {Array} indexes The arranged array indexes. + * @returns {Array} Returns `array`. + */ + + + function reorder(array, indexes) { + var arrLength = array.length, + length = nativeMin(indexes.length, arrLength), + oldArray = copyArray(array); + + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1; + } + + return array; + } + /** + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + + + function safeGet(object, key) { + if (key === 'constructor' && typeof object[key] === 'function') { + return; + } + + if (key == '__proto__') { + return; + } + + return object[key]; + } + /** + * Sets metadata for `func`. + * + * **Note:** If this function becomes hot, i.e. is invoked a lot in a short + * period of time, it will trip its breaker and transition to an identity + * function to avoid garbage collection pauses in V8. See + * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) + * for more details. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + + + var setData = shortOut(baseSetData); + /** + * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @returns {number|Object} Returns the timer id or timeout object. + */ + + var setTimeout = ctxSetTimeout || function (func, wait) { + return root.setTimeout(func, wait); + }; + /** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + + + var setToString = shortOut(baseSetToString); + /** + * Sets the `toString` method of `wrapper` to mimic the source of `reference` + * with wrapper details in a comment at the top of the source body. + * + * @private + * @param {Function} wrapper The function to modify. + * @param {Function} reference The reference function. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Function} Returns `wrapper`. + */ + + function setWrapToString(wrapper, reference, bitmask) { + var source = reference + ''; + return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); + } + /** + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. + * + * @private + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. + */ + + + function shortOut(func) { + var count = 0, + lastCalled = 0; + return function () { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); + lastCalled = stamp; + + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + + return func.apply(undefined$1, arguments); + }; + } + /** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */ + + + function shuffleSelf(array, size) { + var index = -1, + length = array.length, + lastIndex = length - 1; + size = size === undefined$1 ? length : size; + + while (++index < size) { + var rand = baseRandom(index, lastIndex), + value = array[rand]; + array[rand] = array[index]; + array[index] = value; + } + + array.length = size; + return array; + } + /** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ + + + var stringToPath = memoizeCapped(function (string) { + var result = []; + + if (string.charCodeAt(0) === 46 + /* . */ + ) { + result.push(''); + } + + string.replace(rePropName, function (match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match); + }); + return result; + }); + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + + var result = value + ''; + return result == '0' && 1 / value == -INFINITY ? '-0' : result; + } + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ + + + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + + try { + return func + ''; + } catch (e) {} + } + + return ''; + } + /** + * Updates wrapper `details` based on `bitmask` flags. + * + * @private + * @returns {Array} details The details to modify. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Array} Returns `details`. + */ + + + function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function (pair) { + var value = '_.' + pair[0]; + + if (bitmask & pair[1] && !arrayIncludes(details, value)) { + details.push(value); + } + }); + return details.sort(); + } + /** + * Creates a clone of `wrapper`. + * + * @private + * @param {Object} wrapper The wrapper to clone. + * @returns {Object} Returns the cloned wrapper. + */ + + + function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + + var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); + result.__actions__ = copyArray(wrapper.__actions__); + result.__index__ = wrapper.__index__; + result.__values__ = wrapper.__values__; + return result; + } + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of elements split into groups the length of `size`. + * If `array` can't be split evenly, the final chunk will be the remaining + * elements. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to process. + * @param {number} [size=1] The length of each chunk + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the new array of chunks. + * @example + * + * _.chunk(['a', 'b', 'c', 'd'], 2); + * // => [['a', 'b'], ['c', 'd']] + * + * _.chunk(['a', 'b', 'c', 'd'], 3); + * // => [['a', 'b', 'c'], ['d']] + */ + + + function chunk(array, size, guard) { + if (guard ? isIterateeCall(array, size, guard) : size === undefined$1) { + size = 1; + } else { + size = nativeMax(toInteger(size), 0); + } + + var length = array == null ? 0 : array.length; + + if (!length || size < 1) { + return []; + } + + var index = 0, + resIndex = 0, + result = Array(nativeCeil(length / size)); + + while (index < length) { + result[resIndex++] = baseSlice(array, index, index += size); + } + + return result; + } + /** + * Creates an array with all falsey values removed. The values `false`, `null`, + * `0`, `""`, `undefined`, and `NaN` are falsey. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to compact. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.compact([0, 1, false, 2, '', 3]); + * // => [1, 2, 3] + */ + + + function compact(array) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + + if (value) { + result[resIndex++] = value; + } + } + + return result; + } + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to concatenate. + * @param {...*} [values] The values to concatenate. + * @returns {Array} Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ + + + function concat() { + var length = arguments.length; + + if (!length) { + return []; + } + + var args = Array(length - 1), + array = arguments[0], + index = length; + + while (index--) { + args[index - 1] = arguments[index]; + } + + return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); + } + /** + * Creates an array of `array` values not included in the other given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * **Note:** Unlike `_.pullAll`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.without, _.xor + * @example + * + * _.difference([2, 1], [2, 3]); + * // => [1] + */ + + + var difference = baseRest(function (array, values) { + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : []; + }); + /** + * This method is like `_.difference` except that it accepts `iteratee` which + * is invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * **Note:** Unlike `_.pullAllBy`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2] + * + * // The `_.property` iteratee shorthand. + * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + + var differenceBy = baseRest(function (array, values) { + var iteratee = last(values); + + if (isArrayLikeObject(iteratee)) { + iteratee = undefined$1; + } + + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)) : []; + }); + /** + * This method is like `_.difference` except that it accepts `comparator` + * which is invoked to compare elements of `array` to `values`. The order and + * references of result values are determined by the first array. The comparator + * is invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.pullAllWith`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */ + + var differenceWith = baseRest(function (array, values) { + var comparator = last(values); + + if (isArrayLikeObject(comparator)) { + comparator = undefined$1; + } + + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined$1, comparator) : []; + }); + /** + * Creates a slice of `array` with `n` elements dropped from the beginning. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.drop([1, 2, 3]); + * // => [2, 3] + * + * _.drop([1, 2, 3], 2); + * // => [3] + * + * _.drop([1, 2, 3], 5); + * // => [] + * + * _.drop([1, 2, 3], 0); + * // => [1, 2, 3] + */ + + function drop(array, n, guard) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + n = guard || n === undefined$1 ? 1 : toInteger(n); + return baseSlice(array, n < 0 ? 0 : n, length); + } + /** + * Creates a slice of `array` with `n` elements dropped from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.dropRight([1, 2, 3]); + * // => [1, 2] + * + * _.dropRight([1, 2, 3], 2); + * // => [1] + * + * _.dropRight([1, 2, 3], 5); + * // => [] + * + * _.dropRight([1, 2, 3], 0); + * // => [1, 2, 3] + */ + + + function dropRight(array, n, guard) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + n = guard || n === undefined$1 ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, 0, n < 0 ? 0 : n); + } + /** + * Creates a slice of `array` excluding elements dropped from the end. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.dropRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney'] + * + * // The `_.matches` iteratee shorthand. + * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropRightWhile(users, ['active', false]); + * // => objects for ['barney'] + * + * // The `_.property` iteratee shorthand. + * _.dropRightWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + + + function dropRightWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : []; + } + /** + * Creates a slice of `array` excluding elements dropped from the beginning. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.dropWhile(users, function(o) { return !o.active; }); + * // => objects for ['pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.dropWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropWhile(users, ['active', false]); + * // => objects for ['pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.dropWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + + + function dropWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : []; + } + /** + * Fills elements of `array` with `value` from `start` up to, but not + * including, `end`. + * + * **Note:** This method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Array + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.fill(array, 'a'); + * console.log(array); + * // => ['a', 'a', 'a'] + * + * _.fill(Array(3), 2); + * // => [2, 2, 2] + * + * _.fill([4, 6, 8, 10], '*', 1, 3); + * // => [4, '*', '*', 10] + */ + + + function fill(array, value, start, end) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { + start = 0; + end = length; + } + + return baseFill(array, value, start, end); + } + /** + * This method is like `_.find` except that it returns the index of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.findIndex(users, function(o) { return o.user == 'barney'; }); + * // => 0 + * + * // The `_.matches` iteratee shorthand. + * _.findIndex(users, { 'user': 'fred', 'active': false }); + * // => 1 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findIndex(users, ['active', false]); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.findIndex(users, 'active'); + * // => 2 + */ + + + function findIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + + if (!length) { + return -1; + } + + var index = fromIndex == null ? 0 : toInteger(fromIndex); + + if (index < 0) { + index = nativeMax(length + index, 0); + } + + return baseFindIndex(array, getIteratee(predicate, 3), index); + } + /** + * This method is like `_.findIndex` except that it iterates over elements + * of `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); + * // => 2 + * + * // The `_.matches` iteratee shorthand. + * _.findLastIndex(users, { 'user': 'barney', 'active': true }); + * // => 0 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastIndex(users, ['active', false]); + * // => 2 + * + * // The `_.property` iteratee shorthand. + * _.findLastIndex(users, 'active'); + * // => 0 + */ + + + function findLastIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + + if (!length) { + return -1; + } + + var index = length - 1; + + if (fromIndex !== undefined$1) { + index = toInteger(fromIndex); + index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + + return baseFindIndex(array, getIteratee(predicate, 3), index, true); + } + /** + * Flattens `array` a single level deep. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flatten([1, [2, [3, [4]], 5]]); + * // => [1, 2, [3, [4]], 5] + */ + + + function flatten(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, 1) : []; + } + /** + * Recursively flattens `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ + + + function flattenDeep(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, INFINITY) : []; + } + /** + * Recursively flatten `array` up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Array + * @param {Array} array The array to flatten. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * var array = [1, [2, [3, [4]], 5]]; + * + * _.flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * _.flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ + + + function flattenDepth(array, depth) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + depth = depth === undefined$1 ? 1 : toInteger(depth); + return baseFlatten(array, depth); + } + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['a', 1], ['b', 2]]); + * // => { 'a': 1, 'b': 2 } + */ + + + function fromPairs(pairs) { + var index = -1, + length = pairs == null ? 0 : pairs.length, + result = {}; + + while (++index < length) { + var pair = pairs[index]; + result[pair[0]] = pair[1]; + } + + return result; + } + /** + * Gets the first element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias first + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the first element of `array`. + * @example + * + * _.head([1, 2, 3]); + * // => 1 + * + * _.head([]); + * // => undefined + */ + + + function head(array) { + return array && array.length ? array[0] : undefined$1; + } + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the + * offset from the end of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // Search from the `fromIndex`. + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ + + + function indexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + + if (!length) { + return -1; + } + + var index = fromIndex == null ? 0 : toInteger(fromIndex); + + if (index < 0) { + index = nativeMax(length + index, 0); + } + + return baseIndexOf(array, value, index); + } + /** + * Gets all but the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.initial([1, 2, 3]); + * // => [1, 2] + */ + + + function initial(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 0, -1) : []; + } + /** + * Creates an array of unique values that are included in all given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersection([2, 1], [2, 3]); + * // => [2] + */ + + + var intersection = baseRest(function (arrays) { + var mapped = arrayMap(arrays, castArrayLikeObject); + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : []; + }); + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + * + * // The `_.property` iteratee shorthand. + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ + + var intersectionBy = baseRest(function (arrays) { + var iteratee = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + + if (iteratee === last(mapped)) { + iteratee = undefined$1; + } else { + mapped.pop(); + } + + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee, 2)) : []; + }); + /** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The order and references + * of result values are determined by the first array. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ + + var intersectionWith = baseRest(function (arrays) { + var comparator = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + comparator = typeof comparator == 'function' ? comparator : undefined$1; + + if (comparator) { + mapped.pop(); + } + + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined$1, comparator) : []; + }); + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to convert. + * @param {string} [separator=','] The element separator. + * @returns {string} Returns the joined string. + * @example + * + * _.join(['a', 'b', 'c'], '~'); + * // => 'a~b~c' + */ + + function join(array, separator) { + return array == null ? '' : nativeJoin.call(array, separator); + } + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + + + function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined$1; + } + /** + * This method is like `_.indexOf` except that it iterates over elements of + * `array` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * // Search from the `fromIndex`. + * _.lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + */ + + + function lastIndexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + + if (!length) { + return -1; + } + + var index = length; + + if (fromIndex !== undefined$1) { + index = toInteger(fromIndex); + index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + + return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true); + } + /** + * Gets the element at index `n` of `array`. If `n` is negative, the nth + * element from the end is returned. + * + * @static + * @memberOf _ + * @since 4.11.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=0] The index of the element to return. + * @returns {*} Returns the nth element of `array`. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * + * _.nth(array, 1); + * // => 'b' + * + * _.nth(array, -2); + * // => 'c'; + */ + + + function nth(array, n) { + return array && array.length ? baseNth(array, toInteger(n)) : undefined$1; + } + /** + * Removes all given values from `array` using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` + * to remove elements from an array by predicate. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...*} [values] The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pull(array, 'a', 'c'); + * console.log(array); + * // => ['b', 'b'] + */ + + + var pull = baseRest(pullAll); + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pullAll(array, ['a', 'c']); + * console.log(array); + * // => ['b', 'b'] + */ + + function pullAll(array, values) { + return array && array.length && values && values.length ? basePullAll(array, values) : array; + } + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ + + + function pullAllBy(array, values, iteratee) { + return array && array.length && values && values.length ? basePullAll(array, values, getIteratee(iteratee, 2)) : array; + } + /** + * This method is like `_.pullAll` except that it accepts `comparator` which + * is invoked to compare elements of `array` to `values`. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ + + + function pullAllWith(array, values, comparator) { + return array && array.length && values && values.length ? basePullAll(array, values, undefined$1, comparator) : array; + } + /** + * Removes elements from `array` corresponding to `indexes` and returns an + * array of removed elements. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...(number|number[])} [indexes] The indexes of elements to remove. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * var pulled = _.pullAt(array, [1, 3]); + * + * console.log(array); + * // => ['a', 'c'] + * + * console.log(pulled); + * // => ['b', 'd'] + */ + + + var pullAt = flatRest(function (array, indexes) { + var length = array == null ? 0 : array.length, + result = baseAt(array, indexes); + basePullAt(array, arrayMap(indexes, function (index) { + return isIndex(index, length) ? +index : index; + }).sort(compareAscending)); + return result; + }); + /** + * Removes all elements from `array` that `predicate` returns truthy for + * and returns an array of the removed elements. The predicate is invoked + * with three arguments: (value, index, array). + * + * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` + * to pull elements from an array by value. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = [1, 2, 3, 4]; + * var evens = _.remove(array, function(n) { + * return n % 2 == 0; + * }); + * + * console.log(array); + * // => [1, 3] + * + * console.log(evens); + * // => [2, 4] + */ + + function remove(array, predicate) { + var result = []; + + if (!(array && array.length)) { + return result; + } + + var index = -1, + indexes = [], + length = array.length; + predicate = getIteratee(predicate, 3); + + while (++index < length) { + var value = array[index]; + + if (predicate(value, index, array)) { + result.push(value); + indexes.push(index); + } + } + + basePullAt(array, indexes); + return result; + } + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + + + function reverse(array) { + return array == null ? array : nativeReverse.call(array); + } + /** + * Creates a slice of `array` from `start` up to, but not including, `end`. + * + * **Note:** This method is used instead of + * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are + * returned. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + + + function slice(array, start, end) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { + start = 0; + end = length; + } else { + start = start == null ? 0 : toInteger(start); + end = end === undefined$1 ? length : toInteger(end); + } + + return baseSlice(array, start, end); + } + /** + * Uses a binary search to determine the lowest index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + */ + + + function sortedIndex(array, value) { + return baseSortedIndex(array, value); + } + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); + * // => 0 + */ + + + function sortedIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)); + } + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([4, 5, 5, 5, 6], 5); + * // => 1 + */ + + + function sortedIndexOf(array, value) { + var length = array == null ? 0 : array.length; + + if (length) { + var index = baseSortedIndex(array, value); + + if (index < length && eq(array[index], value)) { + return index; + } + } + + return -1; + } + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedLastIndex([4, 5, 5, 5, 6], 5); + * // => 4 + */ + + + function sortedLastIndex(array, value) { + return baseSortedIndex(array, value, true); + } + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 1 + * + * // The `_.property` iteratee shorthand. + * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); + * // => 1 + */ + + + function sortedLastIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true); + } + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); + * // => 3 + */ + + + function sortedLastIndexOf(array, value) { + var length = array == null ? 0 : array.length; + + if (length) { + var index = baseSortedIndex(array, value, true) - 1; + + if (eq(array[index], value)) { + return index; + } + } + + return -1; + } + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ + + + function sortedUniq(array) { + return array && array.length ? baseSortedUniq(array) : []; + } + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.3] + */ + + + function sortedUniqBy(array, iteratee) { + return array && array.length ? baseSortedUniq(array, getIteratee(iteratee, 2)) : []; + } + /** + * Gets all but the first element of `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.tail([1, 2, 3]); + * // => [2, 3] + */ + + + function tail(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 1, length) : []; + } + /** + * Creates a slice of `array` with `n` elements taken from the beginning. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.take([1, 2, 3]); + * // => [1] + * + * _.take([1, 2, 3], 2); + * // => [1, 2] + * + * _.take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.take([1, 2, 3], 0); + * // => [] + */ + + + function take(array, n, guard) { + if (!(array && array.length)) { + return []; + } + + n = guard || n === undefined$1 ? 1 : toInteger(n); + return baseSlice(array, 0, n < 0 ? 0 : n); + } + /** + * Creates a slice of `array` with `n` elements taken from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.takeRight([1, 2, 3]); + * // => [3] + * + * _.takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * _.takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.takeRight([1, 2, 3], 0); + * // => [] + */ + + + function takeRight(array, n, guard) { + var length = array == null ? 0 : array.length; + + if (!length) { + return []; + } + + n = guard || n === undefined$1 ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, n < 0 ? 0 : n, length); + } + /** + * Creates a slice of `array` with elements taken from the end. Elements are + * taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.takeRightWhile(users, 'active'); + * // => [] + */ + + + function takeRightWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : []; + } + /** + * Creates a slice of `array` with elements taken from the beginning. Elements + * are taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matches` iteratee shorthand. + * _.takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * // The `_.property` iteratee shorthand. + * _.takeWhile(users, 'active'); + * // => [] + */ + + + function takeWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : []; + } + /** + * Creates an array of unique values, in order, from all given arrays using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.union([2], [1, 2]); + * // => [2, 1] + */ + + + var union = baseRest(function (arrays) { + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); + }); + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which uniqueness is computed. Result values are chosen from the first + * array in which the value occurs. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + + var unionBy = baseRest(function (arrays) { + var iteratee = last(arrays); + + if (isArrayLikeObject(iteratee)) { + iteratee = undefined$1; + } + + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)); + }); + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. Result values are chosen from + * the first array in which the value occurs. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + + var unionWith = baseRest(function (arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined$1; + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator); + }); + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. The order of result values is determined by the order they occur + * in the array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ + + function uniq(array) { + return array && array.length ? baseUniq(array) : []; + } + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The order of result values is determined by the + * order they occur in the array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + + + function uniqBy(array, iteratee) { + return array && array.length ? baseUniq(array, getIteratee(iteratee, 2)) : []; + } + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The order of result values is + * determined by the order they occur in the array.The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ + + + function uniqWith(array, comparator) { + comparator = typeof comparator == 'function' ? comparator : undefined$1; + return array && array.length ? baseUniq(array, undefined$1, comparator) : []; + } + /** + * This method is like `_.zip` except that it accepts an array of grouped + * elements and creates an array regrouping the elements to their pre-zip + * configuration. + * + * @static + * @memberOf _ + * @since 1.2.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + * + * _.unzip(zipped); + * // => [['a', 'b'], [1, 2], [true, false]] + */ + + + function unzip(array) { + if (!(array && array.length)) { + return []; + } + + var length = 0; + array = arrayFilter(array, function (group) { + if (isArrayLikeObject(group)) { + length = nativeMax(group.length, length); + return true; + } + }); + return baseTimes(length, function (index) { + return arrayMap(array, baseProperty(index)); + }); + } + /** + * This method is like `_.unzip` except that it accepts `iteratee` to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @param {Function} [iteratee=_.identity] The function to combine + * regrouped values. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip([1, 2], [10, 20], [100, 200]); + * // => [[1, 10, 100], [2, 20, 200]] + * + * _.unzipWith(zipped, _.add); + * // => [3, 30, 300] + */ + + + function unzipWith(array, iteratee) { + if (!(array && array.length)) { + return []; + } + + var result = unzip(array); + + if (iteratee == null) { + return result; + } + + return arrayMap(result, function (group) { + return apply(iteratee, undefined$1, group); + }); + } + /** + * Creates an array excluding all given values using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.pull`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...*} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.xor + * @example + * + * _.without([2, 1, 2, 3], 1, 2); + * // => [3] + */ + + + var without = baseRest(function (array, values) { + return isArrayLikeObject(array) ? baseDifference(array, values) : []; + }); + /** + * Creates an array of unique values that is the + * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) + * of the given arrays. The order of result values is determined by the order + * they occur in the arrays. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.without + * @example + * + * _.xor([2, 1], [2, 3]); + * // => [1, 3] + */ + + var xor = baseRest(function (arrays) { + return baseXor(arrayFilter(arrays, isArrayLikeObject)); + }); + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which by which they're compared. The order of result values is determined + * by the order they occur in the arrays. The iteratee is invoked with one + * argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2, 3.4] + * + * // The `_.property` iteratee shorthand. + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + + var xorBy = baseRest(function (arrays) { + var iteratee = last(arrays); + + if (isArrayLikeObject(iteratee)) { + iteratee = undefined$1; + } + + return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); + }); + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The order of result values is + * determined by the order they occur in the arrays. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + + var xorWith = baseRest(function (arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined$1; + return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator); + }); + /** + * Creates an array of grouped elements, the first of which contains the + * first elements of the given arrays, the second of which contains the + * second elements of the given arrays, and so on. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + */ + + var zip = baseRest(unzip); + /** + * This method is like `_.fromPairs` except that it accepts two arrays, + * one of property identifiers and one of corresponding values. + * + * @static + * @memberOf _ + * @since 0.4.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObject(['a', 'b'], [1, 2]); + * // => { 'a': 1, 'b': 2 } + */ + + function zipObject(props, values) { + return baseZipObject(props || [], values || [], assignValue); + } + /** + * This method is like `_.zipObject` except that it supports property paths. + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); + * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ + + + function zipObjectDeep(props, values) { + return baseZipObject(props || [], values || [], baseSet); + } + /** + * This method is like `_.zip` except that it accepts `iteratee` to specify + * how grouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee=_.identity] The function to combine + * grouped values. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { + * return a + b + c; + * }); + * // => [111, 222] + */ + + + var zipWith = baseRest(function (arrays) { + var length = arrays.length, + iteratee = length > 1 ? arrays[length - 1] : undefined$1; + iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined$1; + return unzipWith(arrays, iteratee); + }); + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` wrapper instance that wraps `value` with explicit method + * chain sequences enabled. The result of such sequences must be unwrapped + * with `_#value`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Seq + * @param {*} value The value to wrap. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'pebbles', 'age': 1 } + * ]; + * + * var youngest = _ + * .chain(users) + * .sortBy('age') + * .map(function(o) { + * return o.user + ' is ' + o.age; + * }) + * .head() + * .value(); + * // => 'pebbles is 1' + */ + + function chain(value) { + var result = lodash(value); + result.__chain__ = true; + return result; + } + /** + * This method invokes `interceptor` and returns `value`. The interceptor + * is invoked with one argument; (value). The purpose of this method is to + * "tap into" a method chain sequence in order to modify intermediate results. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns `value`. + * @example + * + * _([1, 2, 3]) + * .tap(function(array) { + * // Mutate input array. + * array.pop(); + * }) + * .reverse() + * .value(); + * // => [2, 1] + */ + + + function tap(value, interceptor) { + interceptor(value); + return value; + } + /** + * This method is like `_.tap` except that it returns the result of `interceptor`. + * The purpose of this method is to "pass thru" values replacing intermediate + * results in a method chain sequence. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns the result of `interceptor`. + * @example + * + * _(' abc ') + * .chain() + * .trim() + * .thru(function(value) { + * return [value]; + * }) + * .value(); + * // => ['abc'] + */ + + + function thru(value, interceptor) { + return interceptor(value); + } + /** + * This method is the wrapper version of `_.at`. + * + * @name at + * @memberOf _ + * @since 1.0.0 + * @category Seq + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _(object).at(['a[0].b.c', 'a[1]']).value(); + * // => [3, 4] + */ + + + var wrapperAt = flatRest(function (paths) { + var length = paths.length, + start = length ? paths[0] : 0, + value = this.__wrapped__, + interceptor = function interceptor(object) { + return baseAt(object, paths); + }; + + if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) { + return this.thru(interceptor); + } + + value = value.slice(start, +start + (length ? 1 : 0)); + + value.__actions__.push({ + 'func': thru, + 'args': [interceptor], + 'thisArg': undefined$1 + }); + + return new LodashWrapper(value, this.__chain__).thru(function (array) { + if (length && !array.length) { + array.push(undefined$1); + } + + return array; + }); + }); + /** + * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. + * + * @name chain + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // A sequence without explicit chaining. + * _(users).head(); + * // => { 'user': 'barney', 'age': 36 } + * + * // A sequence with explicit chaining. + * _(users) + * .chain() + * .head() + * .pick('user') + * .value(); + * // => { 'user': 'barney' } + */ + + function wrapperChain() { + return chain(this); + } + /** + * Executes the chain sequence and returns the wrapped result. + * + * @name commit + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2]; + * var wrapped = _(array).push(3); + * + * console.log(array); + * // => [1, 2] + * + * wrapped = wrapped.commit(); + * console.log(array); + * // => [1, 2, 3] + * + * wrapped.last(); + * // => 3 + * + * console.log(array); + * // => [1, 2, 3] + */ + + + function wrapperCommit() { + return new LodashWrapper(this.value(), this.__chain__); + } + /** + * Gets the next value on a wrapped object following the + * [iterator protocol](https://mdn.io/iteration_protocols#iterator). + * + * @name next + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the next iterator value. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped.next(); + * // => { 'done': false, 'value': 1 } + * + * wrapped.next(); + * // => { 'done': false, 'value': 2 } + * + * wrapped.next(); + * // => { 'done': true, 'value': undefined } + */ + + + function wrapperNext() { + if (this.__values__ === undefined$1) { + this.__values__ = toArray(this.value()); + } + + var done = this.__index__ >= this.__values__.length, + value = done ? undefined$1 : this.__values__[this.__index__++]; + return { + 'done': done, + 'value': value + }; + } + /** + * Enables the wrapper to be iterable. + * + * @name Symbol.iterator + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the wrapper object. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped[Symbol.iterator]() === wrapped; + * // => true + * + * Array.from(wrapped); + * // => [1, 2] + */ + + + function wrapperToIterator() { + return this; + } + /** + * Creates a clone of the chain sequence planting `value` as the wrapped value. + * + * @name plant + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @param {*} value The value to plant. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2]).map(square); + * var other = wrapped.plant([3, 4]); + * + * other.value(); + * // => [9, 16] + * + * wrapped.value(); + * // => [1, 4] + */ + + + function wrapperPlant(value) { + var result, + parent = this; + + while (parent instanceof baseLodash) { + var clone = wrapperClone(parent); + clone.__index__ = 0; + clone.__values__ = undefined$1; + + if (result) { + previous.__wrapped__ = clone; + } else { + result = clone; + } + + var previous = clone; + parent = parent.__wrapped__; + } + + previous.__wrapped__ = value; + return result; + } + /** + * This method is the wrapper version of `_.reverse`. + * + * **Note:** This method mutates the wrapped array. + * + * @name reverse + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2, 3]; + * + * _(array).reverse().value() + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + + + function wrapperReverse() { + var value = this.__wrapped__; + + if (value instanceof LazyWrapper) { + var wrapped = value; + + if (this.__actions__.length) { + wrapped = new LazyWrapper(this); + } + + wrapped = wrapped.reverse(); + + wrapped.__actions__.push({ + 'func': thru, + 'args': [reverse], + 'thisArg': undefined$1 + }); + + return new LodashWrapper(wrapped, this.__chain__); + } + + return this.thru(reverse); + } + /** + * Executes the chain sequence to resolve the unwrapped value. + * + * @name value + * @memberOf _ + * @since 0.1.0 + * @alias toJSON, valueOf + * @category Seq + * @returns {*} Returns the resolved unwrapped value. + * @example + * + * _([1, 2, 3]).value(); + * // => [1, 2, 3] + */ + + + function wrapperValue() { + return baseWrapperValue(this.__wrapped__, this.__actions__); + } + /*------------------------------------------------------------------------*/ + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the number of times the key was returned by `iteratee`. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.countBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': 1, '6': 2 } + * + * // The `_.property` iteratee shorthand. + * _.countBy(['one', 'two', 'three'], 'length'); + * // => { '3': 2, '5': 1 } + */ + + + var countBy = createAggregator(function (result, value, key) { + if (hasOwnProperty.call(result, key)) { + ++result[key]; + } else { + baseAssignValue(result, key, 1); + } + }); + /** + * Checks if `predicate` returns truthy for **all** elements of `collection`. + * Iteration is stopped once `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * **Note:** This method returns `true` for + * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because + * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of + * elements of empty collections. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + * @example + * + * _.every([true, 1, null, 'yes'], Boolean); + * // => false + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.every(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.every(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.every(users, 'active'); + * // => false + */ + + function every(collection, predicate, guard) { + var func = isArray(collection) ? arrayEvery : baseEvery; + + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined$1; + } + + return func(collection, getIteratee(predicate, 3)); + } + /** + * Iterates over elements of `collection`, returning an array of all elements + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * **Note:** Unlike `_.remove`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.reject + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * _.filter(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.filter(users, { 'age': 36, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.filter(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.filter(users, 'active'); + * // => objects for ['barney'] + * + * // Combining several predicates using `_.overEvery` or `_.overSome`. + * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]])); + * // => objects for ['fred', 'barney'] + */ + + + function filter(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, getIteratee(predicate, 3)); + } + /** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.find(users, function(o) { return o.age < 40; }); + * // => object for 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.find(users, { 'age': 1, 'active': true }); + * // => object for 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.find(users, ['active', false]); + * // => object for 'fred' + * + * // The `_.property` iteratee shorthand. + * _.find(users, 'active'); + * // => object for 'barney' + */ + + + var find = createFind(findIndex); + /** + * This method is like `_.find` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=collection.length-1] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * _.findLast([1, 2, 3, 4], function(n) { + * return n % 2 == 1; + * }); + * // => 3 + */ + + var findLast = createFind(findLastIndex); + /** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + + function flatMap(collection, iteratee) { + return baseFlatten(map(collection, iteratee), 1); + } + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + + + function flatMapDeep(collection, iteratee) { + return baseFlatten(map(collection, iteratee), INFINITY); + } + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */ + + + function flatMapDepth(collection, iteratee, depth) { + depth = depth === undefined$1 ? 1 : toInteger(depth); + return baseFlatten(map(collection, iteratee), depth); + } + /** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + + + function forEach(collection, iteratee) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * This method is like `_.forEach` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @alias eachRight + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEach + * @example + * + * _.forEachRight([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `2` then `1`. + */ + + + function forEachRight(collection, iteratee) { + var func = isArray(collection) ? arrayEachRight : baseEachRight; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The order of grouped values + * is determined by the order they occur in `collection`. The corresponding + * value of each key is an array of elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.groupBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * // The `_.property` iteratee shorthand. + * _.groupBy(['one', 'two', 'three'], 'length'); + * // => { '3': ['one', 'two'], '5': ['three'] } + */ + + + var groupBy = createAggregator(function (result, value, key) { + if (hasOwnProperty.call(result, key)) { + result[key].push(value); + } else { + baseAssignValue(result, key, [value]); + } + }); + /** + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {boolean} Returns `true` if `value` is found, else `false`. + * @example + * + * _.includes([1, 2, 3], 1); + * // => true + * + * _.includes([1, 2, 3], 1, 2); + * // => false + * + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true + * + * _.includes('abcd', 'bc'); + * // => true + */ + + function includes(collection, value, fromIndex, guard) { + collection = isArrayLike(collection) ? collection : values(collection); + fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0; + var length = collection.length; + + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + + return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1; + } + /** + * Invokes the method at `path` of each element in `collection`, returning + * an array of the results of each invoked method. Any additional arguments + * are provided to each invoked method. If `path` is a function, it's invoked + * for, and `this` bound to, each element in `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array|Function|string} path The path of the method to invoke or + * the function invoked per iteration. + * @param {...*} [args] The arguments to invoke each method with. + * @returns {Array} Returns the array of results. + * @example + * + * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * _.invokeMap([123, 456], String.prototype.split, ''); + * // => [['1', '2', '3'], ['4', '5', '6']] + */ + + + var invokeMap = baseRest(function (collection, path, args) { + var index = -1, + isFunc = typeof path == 'function', + result = isArrayLike(collection) ? Array(collection.length) : []; + baseEach(collection, function (value) { + result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); + }); + return result; + }); + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the last element responsible for generating the key. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * var array = [ + * { 'dir': 'left', 'code': 97 }, + * { 'dir': 'right', 'code': 100 } + * ]; + * + * _.keyBy(array, function(o) { + * return String.fromCharCode(o.code); + * }); + * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * + * _.keyBy(array, 'dir'); + * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + */ + + var keyBy = createAggregator(function (result, value, key) { + baseAssignValue(result, key, value); + }); + /** + * Creates an array of values by running each element in `collection` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. + * + * The guarded methods are: + * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, + * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, + * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, + * `template`, `trim`, `trimEnd`, `trimStart`, and `words` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + * @example + * + * function square(n) { + * return n * n; + * } + * + * _.map([4, 8], square); + * // => [16, 64] + * + * _.map({ 'a': 4, 'b': 8 }, square); + * // => [16, 64] (iteration order is not guaranteed) + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * // The `_.property` iteratee shorthand. + * _.map(users, 'user'); + * // => ['barney', 'fred'] + */ + + function map(collection, iteratee) { + var func = isArray(collection) ? arrayMap : baseMap; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] + * The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // Sort by `user` in ascending order and by `age` in descending order. + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + */ + + + function orderBy(collection, iteratees, orders, guard) { + if (collection == null) { + return []; + } + + if (!isArray(iteratees)) { + iteratees = iteratees == null ? [] : [iteratees]; + } + + orders = guard ? undefined$1 : orders; + + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + + return baseOrderBy(collection, iteratees, orders); + } + /** + * Creates an array of elements split into two groups, the first of which + * contains elements `predicate` returns truthy for, the second of which + * contains elements `predicate` returns falsey for. The predicate is + * invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the array of grouped elements. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true }, + * { 'user': 'pebbles', 'age': 1, 'active': false } + * ]; + * + * _.partition(users, function(o) { return o.active; }); + * // => objects for [['fred'], ['barney', 'pebbles']] + * + * // The `_.matches` iteratee shorthand. + * _.partition(users, { 'age': 1, 'active': false }); + * // => objects for [['pebbles'], ['barney', 'fred']] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.partition(users, ['active', false]); + * // => objects for [['barney', 'pebbles'], ['fred']] + * + * // The `_.property` iteratee shorthand. + * _.partition(users, 'active'); + * // => objects for [['fred'], ['barney', 'pebbles']] + */ + + + var partition = createAggregator(function (result, value, key) { + result[key ? 0 : 1].push(value); + }, function () { + return [[], []]; + }); + /** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` thru `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not given, the first element of `collection` is used as the initial + * value. The iteratee is invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, + * and `sortBy` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduceRight + * @example + * + * _.reduce([1, 2], function(sum, n) { + * return sum + n; + * }, 0); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * return result; + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) + */ + + function reduce(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduce : baseReduce, + initAccum = arguments.length < 3; + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach); + } + /** + * This method is like `_.reduce` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduce + * @example + * + * var array = [[0, 1], [2, 3], [4, 5]]; + * + * _.reduceRight(array, function(flattened, other) { + * return flattened.concat(other); + * }, []); + * // => [4, 5, 2, 3, 0, 1] + */ + + + function reduceRight(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduceRight : baseReduce, + initAccum = arguments.length < 3; + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight); + } + /** + * The opposite of `_.filter`; this method returns the elements of `collection` + * that `predicate` does **not** return truthy for. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.filter + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true } + * ]; + * + * _.reject(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.reject(users, { 'age': 40, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.reject(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.reject(users, 'active'); + * // => objects for ['barney'] + */ + + + function reject(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, negate(getIteratee(predicate, 3))); + } + /** + * Gets a random element from `collection`. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + * @example + * + * _.sample([1, 2, 3, 4]); + * // => 2 + */ + + + function sample(collection) { + var func = isArray(collection) ? arraySample : baseSample; + return func(collection); + } + /** + * Gets `n` random elements at unique keys from `collection` up to the + * size of `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @param {number} [n=1] The number of elements to sample. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the random elements. + * @example + * + * _.sampleSize([1, 2, 3], 2); + * // => [3, 1] + * + * _.sampleSize([1, 2, 3], 4); + * // => [2, 3, 1] + */ + + + function sampleSize(collection, n, guard) { + if (guard ? isIterateeCall(collection, n, guard) : n === undefined$1) { + n = 1; + } else { + n = toInteger(n); + } + + var func = isArray(collection) ? arraySampleSize : baseSampleSize; + return func(collection, n); + } + /** + * Creates an array of shuffled values, using a version of the + * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + * @example + * + * _.shuffle([1, 2, 3, 4]); + * // => [4, 1, 3, 2] + */ + + + function shuffle(collection) { + var func = isArray(collection) ? arrayShuffle : baseShuffle; + return func(collection); + } + /** + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable string keyed properties for objects. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @returns {number} Returns the collection size. + * @example + * + * _.size([1, 2, 3]); + * // => 3 + * + * _.size({ 'a': 1, 'b': 2 }); + * // => 2 + * + * _.size('pebbles'); + * // => 7 + */ + + + function size(collection) { + if (collection == null) { + return 0; + } + + if (isArrayLike(collection)) { + return isString(collection) ? stringSize(collection) : collection.length; + } + + var tag = getTag(collection); + + if (tag == mapTag || tag == setTag) { + return collection.size; + } + + return baseKeys(collection).length; + } + /** + * Checks if `predicate` returns truthy for **any** element of `collection`. + * Iteration is stopped once `predicate` returns truthy. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.some(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.some(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.some(users, 'active'); + * // => true + */ + + + function some(collection, predicate, guard) { + var func = isArray(collection) ? arraySome : baseSome; + + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined$1; + } + + return func(collection, getIteratee(predicate, 3)); + } + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection thru each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[])} [iteratees=[_.identity]] + * The iteratees to sort by. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 30 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]] + */ + + + var sortBy = baseRest(function (collection, iteratees) { + if (collection == null) { + return []; + } + + var length = iteratees.length; + + if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + + return baseOrderBy(collection, baseFlatten(iteratees, 1), []); + }); + /*------------------------------------------------------------------------*/ + + /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ + + var now = ctxNow || function () { + return root.Date.now(); + }; + /*------------------------------------------------------------------------*/ + + /** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {number} n The number of calls before `func` is invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ + + + function after(n, func) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + n = toInteger(n); + return function () { + if (--n < 1) { + return func.apply(this, arguments); + } + }; + } + /** + * Creates a function that invokes `func`, with up to `n` arguments, + * ignoring any additional arguments. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @param {number} [n=func.length] The arity cap. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.ary(parseInt, 1)); + * // => [6, 8, 10] + */ + + + function ary(func, n, guard) { + n = guard ? undefined$1 : n; + n = func && n == null ? func.length : n; + return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n); + } + /** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */ + + + function before(n, func) { + var result; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + n = toInteger(n); + return function () { + if (--n > 0) { + result = func.apply(this, arguments); + } + + if (n <= 1) { + func = undefined$1; + } + + return result; + }; + } + /** + * Creates a function that invokes `func` with the `this` binding of `thisArg` + * and `partials` prepended to the arguments it receives. + * + * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for partially applied arguments. + * + * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" + * property of bound functions. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * + * var object = { 'user': 'fred' }; + * + * var bound = _.bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * // Bound with placeholders. + * var bound = _.bind(greet, object, _, '!'); + * bound('hi'); + * // => 'hi fred!' + */ + + + var bind = baseRest(function (func, thisArg, partials) { + var bitmask = WRAP_BIND_FLAG; + + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bind)); + bitmask |= WRAP_PARTIAL_FLAG; + } + + return createWrap(func, bitmask, thisArg, partials, holders); + }); + /** + * Creates a function that invokes the method at `object[key]` with `partials` + * prepended to the arguments it receives. + * + * This method differs from `_.bind` by allowing bound functions to reference + * methods that may be redefined or don't yet exist. See + * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) + * for more details. + * + * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Function + * @param {Object} object The object to invoke the method on. + * @param {string} key The key of the method. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'user': 'fred', + * 'greet': function(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * }; + * + * var bound = _.bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function(greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * var bound = _.bindKey(object, 'greet', _, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ + + var bindKey = baseRest(function (object, key, partials) { + var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; + + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bindKey)); + bitmask |= WRAP_PARTIAL_FLAG; + } + + return createWrap(key, bitmask, object, partials, holders); + }); + /** + * Creates a function that accepts arguments of `func` and either invokes + * `func` returning its result, if at least `arity` number of arguments have + * been provided, or returns a function that accepts the remaining `func` + * arguments, and so on. The arity of `func` may be specified if `func.length` + * is not sufficient. + * + * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curry(abc); + * + * curried(1)(2)(3); + * // => [1, 2, 3] + * + * curried(1, 2)(3); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(1)(_, 3)(2); + * // => [1, 2, 3] + */ + + function curry(func, arity, guard) { + arity = guard ? undefined$1 : arity; + var result = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity); + result.placeholder = curry.placeholder; + return result; + } + /** + * This method is like `_.curry` except that arguments are applied to `func` + * in the manner of `_.partialRight` instead of `_.partial`. + * + * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curryRight(abc); + * + * curried(3)(2)(1); + * // => [1, 2, 3] + * + * curried(2, 3)(1); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(3)(1, _)(2); + * // => [1, 2, 3] + */ + + + function curryRight(func, arity, guard) { + arity = guard ? undefined$1 : arity; + var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity); + result.placeholder = curryRight.placeholder; + return result; + } + /** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ + + + function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + wait = toNumber(wait) || 0; + + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + lastArgs = lastThis = undefined$1; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; // Start the timer for the trailing edge. + + timerId = setTimeout(timerExpired, wait); // Invoke the leading edge. + + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + + return lastCallTime === undefined$1 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; + } + + function timerExpired() { + var time = now(); + + if (shouldInvoke(time)) { + return trailingEdge(time); + } // Restart the timer. + + + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined$1; // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + + if (trailing && lastArgs) { + return invokeFunc(time); + } + + lastArgs = lastThis = undefined$1; + return result; + } + + function cancel() { + if (timerId !== undefined$1) { + clearTimeout(timerId); + } + + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined$1; + } + + function flush() { + return timerId === undefined$1 ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined$1) { + return leadingEdge(lastCallTime); + } + + if (maxing) { + // Handle invocations in a tight loop. + clearTimeout(timerId); + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + + if (timerId === undefined$1) { + timerId = setTimeout(timerExpired, wait); + } + + return result; + } + + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + /** + * Defers invoking the `func` until the current call stack has cleared. Any + * additional arguments are provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to defer. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { + * console.log(text); + * }, 'deferred'); + * // => Logs 'deferred' after one millisecond. + */ + + + var defer = baseRest(function (func, args) { + return baseDelay(func, 1, args); + }); + /** + * Invokes `func` after `wait` milliseconds. Any additional arguments are + * provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { + * console.log(text); + * }, 1000, 'later'); + * // => Logs 'later' after one second. + */ + + var delay = baseRest(function (func, wait, args) { + return baseDelay(func, toNumber(wait) || 0, args); + }); + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new flipped function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ + + function flip(func) { + return createWrap(func, WRAP_FLIP_FLAG); + } + /** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ + + + function memoize(func, resolver) { + if (typeof func != 'function' || resolver != null && typeof resolver != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + var memoized = function memoized() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + + memoized.cache = new (memoize.Cache || MapCache)(); + return memoized; + } // Expose `MapCache`. + + + memoize.Cache = MapCache; + /** + * Creates a function that negates the result of the predicate `func`. The + * `func` predicate is invoked with the `this` binding and arguments of the + * created function. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} predicate The predicate to negate. + * @returns {Function} Returns the new negated function. + * @example + * + * function isEven(n) { + * return n % 2 == 0; + * } + * + * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); + * // => [1, 3, 5] + */ + + function negate(predicate) { + if (typeof predicate != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + return function () { + var args = arguments; + + switch (args.length) { + case 0: + return !predicate.call(this); + + case 1: + return !predicate.call(this, args[0]); + + case 2: + return !predicate.call(this, args[0], args[1]); + + case 3: + return !predicate.call(this, args[0], args[1], args[2]); + } + + return !predicate.apply(this, args); + }; + } + /** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ + + + function once(func) { + return before(2, func); + } + /** + * Creates a function that invokes `func` with its arguments transformed. + * + * @static + * @since 4.0.0 + * @memberOf _ + * @category Function + * @param {Function} func The function to wrap. + * @param {...(Function|Function[])} [transforms=[_.identity]] + * The argument transforms. + * @returns {Function} Returns the new function. + * @example + * + * function doubled(n) { + * return n * 2; + * } + * + * function square(n) { + * return n * n; + * } + * + * var func = _.overArgs(function(x, y) { + * return [x, y]; + * }, [square, doubled]); + * + * func(9, 3); + * // => [81, 6] + * + * func(10, 5); + * // => [100, 10] + */ + + + var overArgs = castRest(function (func, transforms) { + transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); + var funcsLength = transforms.length; + return baseRest(function (args) { + var index = -1, + length = nativeMin(args.length, funcsLength); + + while (++index < length) { + args[index] = transforms[index].call(this, args[index]); + } + + return apply(func, this, args); + }); + }); + /** + * Creates a function that invokes `func` with `partials` prepended to the + * arguments it receives. This method is like `_.bind` except it does **not** + * alter the `this` binding. + * + * The `_.partial.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 0.2.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var sayHelloTo = _.partial(greet, 'hello'); + * sayHelloTo('fred'); + * // => 'hello fred' + * + * // Partially applied with placeholders. + * var greetFred = _.partial(greet, _, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + */ + + var partial = baseRest(function (func, partials) { + var holders = replaceHolders(partials, getHolder(partial)); + return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders); + }); + /** + * This method is like `_.partial` except that partially applied arguments + * are appended to the arguments it receives. + * + * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var greetFred = _.partialRight(greet, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + * + * // Partially applied with placeholders. + * var sayHelloTo = _.partialRight(greet, 'hello', _); + * sayHelloTo('fred'); + * // => 'hello fred' + */ + + var partialRight = baseRest(function (func, partials) { + var holders = replaceHolders(partials, getHolder(partialRight)); + return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders); + }); + /** + * Creates a function that invokes `func` with arguments arranged according + * to the specified `indexes` where the argument value at the first index is + * provided as the first argument, the argument value at the second index is + * provided as the second argument, and so on. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to rearrange arguments for. + * @param {...(number|number[])} indexes The arranged argument indexes. + * @returns {Function} Returns the new function. + * @example + * + * var rearged = _.rearg(function(a, b, c) { + * return [a, b, c]; + * }, [2, 0, 1]); + * + * rearged('b', 'c', 'a') + * // => ['a', 'b', 'c'] + */ + + var rearg = flatRest(function (func, indexes) { + return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes); + }); + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + + function rest(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + start = start === undefined$1 ? start : toInteger(start); + return baseRest(func, start); + } + /** + * Creates a function that invokes `func` with the `this` binding of the + * create function and an array of arguments much like + * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). + * + * **Note:** This method is based on the + * [spread operator](https://mdn.io/spread_operator). + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Function + * @param {Function} func The function to spread arguments over. + * @param {number} [start=0] The start position of the spread. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.spread(function(who, what) { + * return who + ' says ' + what; + * }); + * + * say(['fred', 'hello']); + * // => 'fred says hello' + * + * var numbers = Promise.all([ + * Promise.resolve(40), + * Promise.resolve(36) + * ]); + * + * numbers.then(_.spread(function(x, y) { + * return x + y; + * })); + * // => a Promise of 76 + */ + + + function spread(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + start = start == null ? 0 : nativeMax(toInteger(start), 0); + return baseRest(function (args) { + var array = args[start], + otherArgs = castSlice(args, 0, start); + + if (array) { + arrayPush(otherArgs, array); + } + + return apply(func, this, otherArgs); + }); + } + /** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */ + + + function throttle(func, wait, options) { + var leading = true, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + + if (isObject(options)) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + return debounce(func, wait, { + 'leading': leading, + 'maxWait': wait, + 'trailing': trailing + }); + } + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ + + + function unary(func) { + return ary(func, 1); + } + /** + * Creates a function that provides `value` to `wrapper` as its first + * argument. Any additional arguments provided to the function are appended + * to those provided to the `wrapper`. The wrapper is invoked with the `this` + * binding of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {*} value The value to wrap. + * @param {Function} [wrapper=identity] The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '

' + func(text) + '

'; + * }); + * + * p('fred, barney, & pebbles'); + * // => '

fred, barney, & pebbles

' + */ + + + function wrap(value, wrapper) { + return partial(castFunction(wrapper), value); + } + /*------------------------------------------------------------------------*/ + + /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ + + + function castArray() { + if (!arguments.length) { + return []; + } + + var value = arguments[0]; + return isArray(value) ? value : [value]; + } + /** + * Creates a shallow clone of `value`. + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) + * and supports cloning arrays, array buffers, booleans, date objects, maps, + * numbers, `Object` objects, regexes, sets, strings, symbols, and typed + * arrays. The own enumerable properties of `arguments` objects are cloned + * as plain objects. An empty object is returned for uncloneable values such + * as error objects, functions, DOM nodes, and WeakMaps. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to clone. + * @returns {*} Returns the cloned value. + * @see _.cloneDeep + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var shallow = _.clone(objects); + * console.log(shallow[0] === objects[0]); + * // => true + */ + + + function clone(value) { + return baseClone(value, CLONE_SYMBOLS_FLAG); + } + /** + * This method is like `_.clone` except that it accepts `customizer` which + * is invoked to produce the cloned value. If `customizer` returns `undefined`, + * cloning is handled by the method instead. The `customizer` is invoked with + * up to four arguments; (value [, index|key, object, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the cloned value. + * @see _.cloneDeepWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * } + * + * var el = _.cloneWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 0 + */ + + + function cloneWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); + } + /** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */ + + + function cloneDeep(value) { + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); + } + /** + * This method is like `_.cloneWith` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the deep cloned value. + * @see _.cloneWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(true); + * } + * } + * + * var el = _.cloneDeepWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 20 + */ + + + function cloneDeepWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); + } + /** + * Checks if `object` conforms to `source` by invoking the predicate + * properties of `source` with the corresponding property values of `object`. + * + * **Note:** This method is equivalent to `_.conforms` when `source` is + * partially applied. + * + * @static + * @memberOf _ + * @since 4.14.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); + * // => true + * + * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); + * // => false + */ + + + function conformsTo(object, source) { + return source == null || baseConformsTo(object, source, keys(source)); + } + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + + + function eq(value, other) { + return value === other || value !== value && other !== other; + } + /** + * Checks if `value` is greater than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false + */ + + + var gt = createRelationalOperation(baseGt); + /** + * Checks if `value` is greater than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than or equal to + * `other`, else `false`. + * @see _.lte + * @example + * + * _.gte(3, 1); + * // => true + * + * _.gte(3, 3); + * // => true + * + * _.gte(1, 3); + * // => false + */ + + var gte = createRelationalOperation(function (value, other) { + return value >= other; + }); + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + + var isArguments = baseIsArguments(function () { + return arguments; + }()) ? baseIsArguments : function (value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee'); + }; + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + + var isArray = Array.isArray; + /** + * Checks if `value` is classified as an `ArrayBuffer` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + * @example + * + * _.isArrayBuffer(new ArrayBuffer(2)); + * // => true + * + * _.isArrayBuffer(new Array(2)); + * // => false + */ + + var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + + + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + /** + * Checks if `value` is classified as a boolean primitive or object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. + * @example + * + * _.isBoolean(false); + * // => true + * + * _.isBoolean(null); + * // => false + */ + + + function isBoolean(value) { + return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag; + } + /** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + + + var isBuffer = nativeIsBuffer || stubFalse; + /** + * Checks if `value` is classified as a `Date` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + * @example + * + * _.isDate(new Date); + * // => true + * + * _.isDate('Mon April 23 2012'); + * // => false + */ + + var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; + /** + * Checks if `value` is likely a DOM element. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * @example + * + * _.isElement(document.body); + * // => true + * + * _.isElement(''); + * // => false + */ + + function isElement(value) { + return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); + } + /** + * Checks if `value` is an empty object, collection, map, or set. + * + * Objects are considered empty if they have no own enumerable string keyed + * properties. + * + * Array-like values such as `arguments` objects, arrays, buffers, strings, or + * jQuery-like collections are considered empty if they have a `length` of `0`. + * Similarly, maps and sets are considered empty if they have a `size` of `0`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is empty, else `false`. + * @example + * + * _.isEmpty(null); + * // => true + * + * _.isEmpty(true); + * // => true + * + * _.isEmpty(1); + * // => true + * + * _.isEmpty([1, 2, 3]); + * // => false + * + * _.isEmpty({ 'a': 1 }); + * // => false + */ + + + function isEmpty(value) { + if (value == null) { + return true; + } + + if (isArrayLike(value) && (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || isBuffer(value) || isTypedArray(value) || isArguments(value))) { + return !value.length; + } + + var tag = getTag(value); + + if (tag == mapTag || tag == setTag) { + return !value.size; + } + + if (isPrototype(value)) { + return !baseKeys(value).length; + } + + for (var key in value) { + if (hasOwnProperty.call(value, key)) { + return false; + } + } + + return true; + } + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + + + function isEqual(value, other) { + return baseIsEqual(value, other); + } + /** + * This method is like `_.isEqual` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with up to + * six arguments: (objValue, othValue [, index|key, object, other, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */ + + + function isEqualWith(value, other, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + var result = customizer ? customizer(value, other) : undefined$1; + return result === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result; + } + /** + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an error object, else `false`. + * @example + * + * _.isError(new Error); + * // => true + * + * _.isError(Error); + * // => false + */ + + + function isError(value) { + if (!isObjectLike(value)) { + return false; + } + + var tag = baseGetTag(value); + return tag == errorTag || tag == domExcTag || typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value); + } + /** + * Checks if `value` is a finite primitive number. + * + * **Note:** This method is based on + * [`Number.isFinite`](https://mdn.io/Number/isFinite). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. + * @example + * + * _.isFinite(3); + * // => true + * + * _.isFinite(Number.MIN_VALUE); + * // => true + * + * _.isFinite(Infinity); + * // => false + * + * _.isFinite('3'); + * // => false + */ + + + function isFinite(value) { + return typeof value == 'number' && nativeIsFinite(value); + } + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + + + function isFunction(value) { + if (!isObject(value)) { + return false; + } // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + + + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + /** + * Checks if `value` is an integer. + * + * **Note:** This method is based on + * [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ + + + function isInteger(value) { + return typeof value == 'number' && value == toInteger(value); + } + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + + + function isLength(value) { + return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + + + function isObject(value) { + var type = _typeof(value); + + return value != null && (type == 'object' || type == 'function'); + } + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + + + function isObjectLike(value) { + return value != null && _typeof(value) == 'object'; + } + /** + * Checks if `value` is classified as a `Map` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + * @example + * + * _.isMap(new Map); + * // => true + * + * _.isMap(new WeakMap); + * // => false + */ + + + var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; + /** + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. + * + * **Note:** This method is equivalent to `_.matches` when `source` is + * partially applied. + * + * Partial comparisons will match empty array and empty object `source` + * values against any array or object value, respectively. See `_.isEqual` + * for a list of supported value comparisons. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.isMatch(object, { 'b': 2 }); + * // => true + * + * _.isMatch(object, { 'b': 1 }); + * // => false + */ + + function isMatch(object, source) { + return object === source || baseIsMatch(object, source, getMatchData(source)); + } + /** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with five + * arguments: (objValue, srcValue, index|key, object, source). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */ + + + function isMatchWith(object, source, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + return baseIsMatch(object, source, getMatchData(source), customizer); + } + /** + * Checks if `value` is `NaN`. + * + * **Note:** This method is based on + * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as + * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for + * `undefined` and other non-number values. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + * @example + * + * _.isNaN(NaN); + * // => true + * + * _.isNaN(new Number(NaN)); + * // => true + * + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false + */ + + + function isNaN(value) { + // An `NaN` primitive is the only value that is not equal to itself. + // Perform the `toStringTag` check first to avoid errors with some + // ActiveX objects in IE. + return isNumber(value) && value != +value; + } + /** + * Checks if `value` is a pristine native function. + * + * **Note:** This method can't reliably detect native functions in the presence + * of the core-js package because core-js circumvents this kind of detection. + * Despite multiple requests, the core-js maintainer has made it clear: any + * attempt to fix the detection will be obstructed. As a result, we're left + * with little choice but to throw an error. Unfortunately, this also affects + * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), + * which rely on core-js. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */ + + + function isNative(value) { + if (isMaskable(value)) { + throw new Error(CORE_ERROR_TEXT); + } + + return baseIsNative(value); + } + /** + * Checks if `value` is `null`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `null`, else `false`. + * @example + * + * _.isNull(null); + * // => true + * + * _.isNull(void 0); + * // => false + */ + + + function isNull(value) { + return value === null; + } + /** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ + + + function isNil(value) { + return value == null; + } + /** + * Checks if `value` is classified as a `Number` primitive or object. + * + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a number, else `false`. + * @example + * + * _.isNumber(3); + * // => true + * + * _.isNumber(Number.MIN_VALUE); + * // => true + * + * _.isNumber(Infinity); + * // => true + * + * _.isNumber('3'); + * // => false + */ + + + function isNumber(value) { + return typeof value == 'number' || isObjectLike(value) && baseGetTag(value) == numberTag; + } + /** + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. + * + * @static + * @memberOf _ + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */ + + + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag) { + return false; + } + + var proto = getPrototype(value); + + if (proto === null) { + return true; + } + + var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; + return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString; + } + /** + * Checks if `value` is classified as a `RegExp` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + * @example + * + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false + */ + + + var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; + /** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ + + function isSafeInteger(value) { + return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; + } + /** + * Checks if `value` is classified as a `Set` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + * @example + * + * _.isSet(new Set); + * // => true + * + * _.isSet(new WeakSet); + * // => false + */ + + + var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + + function isString(value) { + return typeof value == 'string' || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag; + } + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + + + function isSymbol(value) { + return _typeof(value) == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag; + } + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + + + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + /** + * Checks if `value` is `undefined`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */ + + function isUndefined(value) { + return value === undefined$1; + } + /** + * Checks if `value` is classified as a `WeakMap` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. + * @example + * + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false + */ + + + function isWeakMap(value) { + return isObjectLike(value) && getTag(value) == weakMapTag; + } + /** + * Checks if `value` is classified as a `WeakSet` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. + * @example + * + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false + */ + + + function isWeakSet(value) { + return isObjectLike(value) && baseGetTag(value) == weakSetTag; + } + /** + * Checks if `value` is less than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + * @see _.gt + * @example + * + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false + */ + + + var lt = createRelationalOperation(baseLt); + /** + * Checks if `value` is less than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than or equal to + * `other`, else `false`. + * @see _.gte + * @example + * + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); + * // => true + * + * _.lte(3, 1); + * // => false + */ + + var lte = createRelationalOperation(function (value, other) { + return value <= other; + }); + /** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */ + + function toArray(value) { + if (!value) { + return []; + } + + if (isArrayLike(value)) { + return isString(value) ? stringToArray(value) : copyArray(value); + } + + if (symIterator && value[symIterator]) { + return iteratorToArray(value[symIterator]()); + } + + var tag = getTag(value), + func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values; + return func(value); + } + /** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ + + + function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + + value = toNumber(value); + + if (value === INFINITY || value === -INFINITY) { + var sign = value < 0 ? -1 : 1; + return sign * MAX_INTEGER; + } + + return value === value ? value : 0; + } + /** + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */ + + + function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + return result === result ? remainder ? result - remainder : result : 0; + } + /** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 + */ + + + function toLength(value) { + return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; + } + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ + + + function toNumber(value) { + if (typeof value == 'number') { + return value; + } + + if (isSymbol(value)) { + return NAN; + } + + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? other + '' : other; + } + + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; + } + /** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */ + + + function toPlainObject(value) { + return copyObject(value, keysIn(value)); + } + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3.2); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3.2'); + * // => 3 + */ + + + function toSafeInteger(value) { + return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0; + } + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + + + function toString(value) { + return value == null ? '' : baseToString(value); + } + /*------------------------------------------------------------------------*/ + + /** + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */ + + + var assign = createAssigner(function (object, source) { + if (isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } + }); + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assign + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } + */ + + var assignIn = createAssigner(function (object, source) { + copyObject(source, keysIn(source), object); + }); + /** + * This method is like `_.assignIn` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + + var assignInWith = createAssigner(function (object, source, srcIndex, customizer) { + copyObject(source, keysIn(source), object, customizer); + }); + /** + * This method is like `_.assign` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignInWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + + var assignWith = createAssigner(function (object, source, srcIndex, customizer) { + copyObject(source, keys(source), object, customizer); + }); + /** + * Creates an array of values corresponding to `paths` of `object`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Array} Returns the picked values. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _.at(object, ['a[0].b.c', 'a[1]']); + * // => [3, 4] + */ + + var at = flatRest(baseAt); + /** + * Creates an object that inherits from the `prototype` object. If a + * `properties` object is given, its own enumerable string keyed properties + * are assigned to the created object. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Object + * @param {Object} prototype The object to inherit from. + * @param {Object} [properties] The properties to assign to the object. + * @returns {Object} Returns the new object. + * @example + * + * function Shape() { + * this.x = 0; + * this.y = 0; + * } + * + * function Circle() { + * Shape.call(this); + * } + * + * Circle.prototype = _.create(Shape.prototype, { + * 'constructor': Circle + * }); + * + * var circle = new Circle; + * circle instanceof Circle; + * // => true + * + * circle instanceof Shape; + * // => true + */ + + function create(prototype, properties) { + var result = baseCreate(prototype); + return properties == null ? result : baseAssign(result, properties); + } + /** + * Assigns own and inherited enumerable string keyed properties of source + * objects to the destination object for all destination properties that + * resolve to `undefined`. Source objects are applied from left to right. + * Once a property is set, additional values of the same property are ignored. + * + * **Note:** This method mutates `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep + * @example + * + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + + + var defaults = baseRest(function (object, sources) { + object = Object(object); + var index = -1; + var length = sources.length; + var guard = length > 2 ? sources[2] : undefined$1; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + + while (++index < length) { + var source = sources[index]; + var props = keysIn(source); + var propsIndex = -1; + var propsLength = props.length; + + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value = object[key]; + + if (value === undefined$1 || eq(value, objectProto[key]) && !hasOwnProperty.call(object, key)) { + object[key] = source[key]; + } + } + } + + return object; + }); + /** + * This method is like `_.defaults` except that it recursively assigns + * default properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaults + * @example + * + * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); + * // => { 'a': { 'b': 2, 'c': 3 } } + */ + + var defaultsDeep = baseRest(function (args) { + args.push(undefined$1, customDefaultsMerge); + return apply(mergeWith, undefined$1, args); + }); + /** + * This method is like `_.find` except that it returns the key of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findKey(users, function(o) { return o.age < 40; }); + * // => 'barney' (iteration order is not guaranteed) + * + * // The `_.matches` iteratee shorthand. + * _.findKey(users, { 'age': 1, 'active': true }); + * // => 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findKey(users, 'active'); + * // => 'barney' + */ + + function findKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); + } + /** + * This method is like `_.findKey` except that it iterates over elements of + * a collection in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findLastKey(users, function(o) { return o.age < 40; }); + * // => returns 'pebbles' assuming `_.findKey` returns 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.findLastKey(users, { 'age': 36, 'active': true }); + * // => 'barney' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findLastKey(users, 'active'); + * // => 'pebbles' + */ + + + function findLastKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); + } + /** + * Iterates over own and inherited enumerable string keyed properties of an + * object and invokes `iteratee` for each property. The iteratee is invoked + * with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forInRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forIn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). + */ + + + function forIn(object, iteratee) { + return object == null ? object : baseFor(object, getIteratee(iteratee, 3), keysIn); + } + /** + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forIn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forInRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. + */ + + + function forInRight(object, iteratee) { + return object == null ? object : baseForRight(object, getIteratee(iteratee, 3), keysIn); + } + /** + * Iterates over own enumerable string keyed properties of an object and + * invokes `iteratee` for each property. The iteratee is invoked with three + * arguments: (value, key, object). Iteratee functions may exit iteration + * early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwnRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + + + function forOwn(object, iteratee) { + return object && baseForOwn(object, getIteratee(iteratee, 3)); + } + /** + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. + */ + + + function forOwnRight(object, iteratee) { + return object && baseForOwnRight(object, getIteratee(iteratee, 3)); + } + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ + + + function functions(object) { + return object == null ? [] : baseFunctions(object, keys(object)); + } + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functions + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ + + + function functionsIn(object) { + return object == null ? [] : baseFunctions(object, keysIn(object)); + } + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ + + + function get(object, path, defaultValue) { + var result = object == null ? undefined$1 : baseGet(object, path); + return result === undefined$1 ? defaultValue : result; + } + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ + + + function has(object, path) { + return object != null && hasPath(object, path, baseHas); + } + /** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); + * // => true + * + * _.hasIn(object, ['a', 'b']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ + + + function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); + } + /** + * Creates an object composed of the inverted keys and values of `object`. + * If `object` contains duplicate values, subsequent values overwrite + * property assignments of previous values. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Object + * @param {Object} object The object to invert. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invert(object); + * // => { '1': 'c', '2': 'b' } + */ + + + var invert = createInverter(function (result, value, key) { + if (value != null && typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + result[value] = key; + }, constant(identity)); + /** + * This method is like `_.invert` except that the inverted object is generated + * from the results of running each element of `object` thru `iteratee`. The + * corresponding inverted value of each inverted key is an array of keys + * responsible for generating the inverted value. The iteratee is invoked + * with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Object + * @param {Object} object The object to invert. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } + * + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ + + var invertBy = createInverter(function (result, value, key) { + if (value != null && typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + if (hasOwnProperty.call(result, value)) { + result[value].push(key); + } else { + result[value] = [key]; + } + }, getIteratee); + /** + * Invokes the method at `path` of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {...*} [args] The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + * @example + * + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; + * + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] + */ + + var invoke = baseRest(baseInvoke); + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + - if (geoPolygonIntersectsPolygon(outer, inner, false)) { - return o; - } + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); } - } + /** + * The opposite of `_.mapValues`; this method creates an object with the + * same values as `object` and keys generated by running each own enumerable + * string keyed property of `object` thru `iteratee`. The iteratee is invoked + * with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapValues + * @example + * + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; + * }); + * // => { 'a1': 1, 'b2': 2 } + */ - for (var i = 0; i < inners.length; i++) { - var inner = inners[i]; - if (d3_geoArea({ - type: 'Polygon', - coordinates: [inner] - }) < 2 * Math.PI) { - inner = inner.reverse(); + function mapKeys(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + baseForOwn(object, function (value, key, object) { + baseAssignValue(result, iteratee(value, key, object), value); + }); + return result; } + /** + * Creates an object with the same keys as `object` and values generated + * by running each own enumerable string keyed property of `object` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, key, object). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapKeys + * @example + * + * var users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * + * _.mapValues(users, function(o) { return o.age; }); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + * + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + */ - var o = findOuter(inners[i]); - if (o !== undefined) { - result[o].push(inners[i]); - } else { - result.push([inners[i]]); // Invalid geometry + function mapValues(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + baseForOwn(object, function (value, key, object) { + baseAssignValue(result, key, iteratee(value, key, object)); + }); + return result; } - } - - return result; - } - }); + /** + * This method is like `_.assign` except that it recursively merges own and + * inherited enumerable string keyed properties of source objects into the + * destination object. Source properties that resolve to `undefined` are + * skipped if a destination value exists. Array and plain object properties + * are merged recursively. Other objects and value types are overridden by + * assignment. Source objects are applied from left to right. Subsequent + * sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * var object = { + * 'a': [{ 'b': 2 }, { 'd': 4 }] + * }; + * + * var other = { + * 'a': [{ 'c': 3 }, { 'e': 5 }] + * }; + * + * _.merge(object, other); + * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } + */ - var QAItem = /*#__PURE__*/function () { - function QAItem(loc, service, itemType, id, props) { - _classCallCheck$1(this, QAItem); - // Store required properties - this.loc = loc; - this.service = service.title; - this.itemType = itemType; // All issues must have an ID for selection, use generic if none specified + var merge = createAssigner(function (object, source, srcIndex) { + baseMerge(object, source, srcIndex); + }); + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ - this.id = id ? id : "".concat(QAItem.id()); - this.update(props); // Some QA services have marker icons to differentiate issues + var mergeWith = createAssigner(function (object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); + }); + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable property paths of `object` that are not omitted. + * + * **Note:** This method is considerably slower than `_.pick`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to omit. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */ - if (service && typeof service.getIcon === 'function') { - this.icon = service.getIcon(itemType); - } - } + var omit = flatRest(function (object, paths) { + var result = {}; - _createClass$1(QAItem, [{ - key: "update", - value: function update(props) { - var _this = this; + if (object == null) { + return result; + } - // You can't override this initial information - var loc = this.loc, - service = this.service, - itemType = this.itemType, - id = this.id; - Object.keys(props).forEach(function (prop) { - return _this[prop] = props[prop]; - }); - this.loc = loc; - this.service = service; - this.itemType = itemType; - this.id = id; - return this; - } // Generic handling for newly created QAItems + var isDeep = false; + paths = arrayMap(paths, function (path) { + path = castPath(path, object); + isDeep || (isDeep = path.length > 1); + return path; + }); + copyObject(object, getAllKeysIn(object), result); - }], [{ - key: "id", - value: function id() { - return this.nextId--; - } - }]); + if (isDeep) { + result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); + } - return QAItem; - }(); - QAItem.nextId = -1; + var length = paths.length; - // - // Optionally, split only the given ways, if multiple ways share - // the given node. - // - // This is the inverse of `iD.actionJoin`. - // - // For testing convenience, accepts an ID to assign to the new way. - // Normally, this will be undefined and the way will automatically - // be assigned a new ID. - // - // Reference: - // https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/SplitWayAction.as - // + while (length--) { + baseUnset(result, paths[length]); + } - function actionSplit(nodeIds, newWayIds) { - // accept single ID for backwards-compatiblity - if (typeof nodeIds === 'string') nodeIds = [nodeIds]; + return result; + }); + /** + * The opposite of `_.pickBy`; this method creates an object composed of + * the own and inherited enumerable string keyed properties of `object` that + * `predicate` doesn't return truthy for. The predicate is invoked with two + * arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ - var _wayIDs; // the strategy for picking which way will have a new version and which way is newly created + function omitBy(object, predicate) { + return pickBy(object, negate(getIteratee(predicate))); + } + /** + * Creates an object composed of the picked `object` properties. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ - var _keepHistoryOn = 'longest'; // 'longest', 'first' - // The IDs of the ways actually created by running this action + var pick = flatRest(function (object, paths) { + return object == null ? {} : basePick(object, paths); + }); + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ - var _createdWayIDs = []; + function pickBy(object, predicate) { + if (object == null) { + return {}; + } - function dist(graph, nA, nB) { - var locA = graph.entity(nA).loc; - var locB = graph.entity(nB).loc; - var epsilon = 1e-6; - return locA && locB ? geoSphericalDistance(locA, locB) : epsilon; - } // If the way is closed, we need to search for a partner node - // to split the way at. - // - // The following looks for a node that is both far away from - // the initial node in terms of way segment length and nearby - // in terms of beeline-distance. This assures that areas get - // split on the most "natural" points (independent of the number - // of nodes). - // For example: bone-shaped areas get split across their waist - // line, circles across the diameter. + var props = arrayMap(getAllKeysIn(object), function (prop) { + return [prop]; + }); + predicate = getIteratee(predicate); + return basePickBy(object, props, function (value, path) { + return predicate(value, path[0]); + }); + } + /** + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */ - function splitArea(nodes, idxA, graph) { - var lengths = new Array(nodes.length); - var length; - var i; - var best = 0; - var idxB; + function result(object, path, defaultValue) { + path = castPath(path, object); + var index = -1, + length = path.length; // Ensure the loop is entered when path is empty. - function wrap(index) { - return utilWrap(index, nodes.length); - } // calculate lengths + if (!length) { + length = 1; + object = undefined$1; + } + while (++index < length) { + var value = object == null ? undefined$1 : object[toKey(path[index])]; - length = 0; + if (value === undefined$1) { + index = length; + value = defaultValue; + } - for (i = wrap(idxA + 1); i !== idxA; i = wrap(i + 1)) { - length += dist(graph, nodes[i], nodes[wrap(i - 1)]); - lengths[i] = length; - } + object = isFunction(value) ? value.call(object) : value; + } - length = 0; + return object; + } + /** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ - for (i = wrap(idxA - 1); i !== idxA; i = wrap(i - 1)) { - length += dist(graph, nodes[i], nodes[wrap(i + 1)]); - if (length < lengths[i]) { - lengths[i] = length; + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); } - } // determine best opposite node to split - + /** + * This method is like `_.set` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.setWith(object, '[0][1]', 'a', Object); + * // => { '0': { '1': 'a' } } + */ - for (i = 0; i < nodes.length; i++) { - var cost = lengths[i] / dist(graph, nodes[idxA], nodes[i]); - if (cost > best) { - idxB = i; - best = cost; + function setWith(object, path, value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + return object == null ? object : baseSet(object, path, value, customizer); } - } - - return idxB; - } + /** + * Creates an array of own enumerable string keyed-value pairs for `object` + * which can be consumed by `_.fromPairs`. If `object` is a map or set, its + * entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entries + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) + */ - function totalLengthBetweenNodes(graph, nodes) { - var totalLength = 0; - for (var i = 0; i < nodes.length - 1; i++) { - totalLength += dist(graph, nodes[i], nodes[i + 1]); - } + var toPairs = createToPairs(keys); + /** + * Creates an array of own and inherited enumerable string keyed-value pairs + * for `object` which can be consumed by `_.fromPairs`. If `object` is a map + * or set, its entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entriesIn + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) + */ - return totalLength; - } + var toPairsIn = createToPairs(keysIn); + /** + * An alternative to `_.reduce`; this method transforms `object` to a new + * `accumulator` object which is the result of running each of its own + * enumerable string keyed properties thru `iteratee`, with each invocation + * potentially mutating the `accumulator` object. If `accumulator` is not + * provided, a new object with the same `[[Prototype]]` will be used. The + * iteratee is invoked with four arguments: (accumulator, value, key, object). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The custom accumulator value. + * @returns {*} Returns the accumulated value. + * @example + * + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] + * + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ - function split(graph, nodeId, wayA, newWayId) { - var wayB = osmWay({ - id: newWayId, - tags: wayA.tags - }); // `wayB` is the NEW way + function transform(object, iteratee, accumulator) { + var isArr = isArray(object), + isArrLike = isArr || isBuffer(object) || isTypedArray(object); + iteratee = getIteratee(iteratee, 4); - var origNodes = wayA.nodes.slice(); - var nodesA; - var nodesB; - var isArea = wayA.isArea(); - var isOuter = osmIsOldMultipolygonOuterMember(wayA, graph); + if (accumulator == null) { + var Ctor = object && object.constructor; - if (wayA.isClosed()) { - var nodes = wayA.nodes.slice(0, -1); - var idxA = nodes.indexOf(nodeId); - var idxB = splitArea(nodes, idxA, graph); + if (isArrLike) { + accumulator = isArr ? new Ctor() : []; + } else if (isObject(object)) { + accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; + } else { + accumulator = {}; + } + } - if (idxB < idxA) { - nodesA = nodes.slice(idxA).concat(nodes.slice(0, idxB + 1)); - nodesB = nodes.slice(idxB, idxA + 1); - } else { - nodesA = nodes.slice(idxA, idxB + 1); - nodesB = nodes.slice(idxB).concat(nodes.slice(0, idxA + 1)); + (isArrLike ? arrayEach : baseForOwn)(object, function (value, index, object) { + return iteratee(accumulator, value, index, object); + }); + return accumulator; } - } else { - var idx = wayA.nodes.indexOf(nodeId, 1); - nodesA = wayA.nodes.slice(0, idx + 1); - nodesB = wayA.nodes.slice(idx); - } + /** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */ - var lengthA = totalLengthBetweenNodes(graph, nodesA); - var lengthB = totalLengthBetweenNodes(graph, nodesB); - if (_keepHistoryOn === 'longest' && lengthB > lengthA) { - // keep the history on the longer way, regardless of the node count - wayA = wayA.update({ - nodes: nodesB - }); - wayB = wayB.update({ - nodes: nodesA - }); - var temp = lengthA; - lengthA = lengthB; - lengthB = temp; - } else { - wayA = wayA.update({ - nodes: nodesA - }); - wayB = wayB.update({ - nodes: nodesB - }); - } + function unset(object, path) { + return object == null ? true : baseUnset(object, path); + } + /** + * This method is like `_.set` except that accepts `updater` to produce the + * value to set. Use `_.updateWith` to customize `path` creation. The `updater` + * is invoked with one argument: (value). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 + * + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 + */ - if (wayA.tags.step_count) { - // divide up the the step count proportionally between the two ways - var stepCount = parseFloat(wayA.tags.step_count); - if (stepCount && // ensure a number - isFinite(stepCount) && // ensure positive - stepCount > 0 && // ensure integer - Math.round(stepCount) === stepCount) { - var tagsA = Object.assign({}, wayA.tags); - var tagsB = Object.assign({}, wayB.tags); - var ratioA = lengthA / (lengthA + lengthB); - var countA = Math.round(stepCount * ratioA); - tagsA.step_count = countA.toString(); - tagsB.step_count = (stepCount - countA).toString(); - wayA = wayA.update({ - tags: tagsA - }); - wayB = wayB.update({ - tags: tagsB - }); + function update(object, path, updater) { + return object == null ? object : baseUpdate(object, path, castFunction(updater)); } - } + /** + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */ - graph = graph.replace(wayA); - graph = graph.replace(wayB); - graph.parentRelations(wayA).forEach(function (relation) { - var member; // Turn restrictions - make sure: - // 1. Splitting a FROM/TO way - only `wayA` OR `wayB` remains in relation - // (whichever one is connected to the VIA node/ways) - // 2. Splitting a VIA way - `wayB` remains in relation as a VIA way - if (relation.hasFromViaTo()) { - var f = relation.memberByRole('from'); - var v = relation.membersByRole('via'); - var t = relation.memberByRole('to'); - var i; // 1. split a FROM/TO + function updateWith(object, path, updater, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined$1; + return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); + } + /** + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] + */ - if (f.id === wayA.id || t.id === wayA.id) { - var keepB = false; - if (v.length === 1 && v[0].type === 'node') { - // check via node - keepB = wayB.contains(v[0].id); - } else { - // check via way(s) - for (i = 0; i < v.length; i++) { - if (v[i].type === 'way') { - var wayVia = graph.hasEntity(v[i].id); + function values(object) { + return object == null ? [] : baseValues(object, keys(object)); + } + /** + * Creates an array of the own and inherited enumerable string keyed property + * values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) + */ - if (wayVia && utilArrayIntersection(wayB.nodes, wayVia.nodes).length) { - keepB = true; - break; - } - } - } - } - if (keepB) { - relation = relation.replaceMember(wayA, wayB); - graph = graph.replace(relation); - } // 2. split a VIA + function valuesIn(object) { + return object == null ? [] : baseValues(object, keysIn(object)); + } + /*------------------------------------------------------------------------*/ - } else { - for (i = 0; i < v.length; i++) { - if (v[i].type === 'way' && v[i].id === wayA.id) { - member = { - id: wayB.id, - type: 'way', - role: 'via' - }; - graph = actionAddMember(relation.id, member, v[i].index + 1)(graph); - break; - } - } - } // All other relations (Routes, Multipolygons, etc): - // 1. Both `wayA` and `wayB` remain in the relation - // 2. But must be inserted as a pair (see `actionAddMember` for details) + /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Number + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + */ - } else { - if (relation === isOuter) { - graph = graph.replace(relation.mergeTags(wayA.tags)); - graph = graph.replace(wayA.update({ - tags: {} - })); - graph = graph.replace(wayB.update({ - tags: {} - })); + + function clamp(number, lower, upper) { + if (upper === undefined$1) { + upper = lower; + lower = undefined$1; } - member = { - id: wayB.id, - type: 'way', - role: relation.memberById(wayA.id).role - }; - var insertPair = { - originalID: wayA.id, - insertedID: wayB.id, - nodes: origNodes - }; - graph = actionAddMember(relation.id, member, undefined, insertPair)(graph); - } - }); + if (upper !== undefined$1) { + upper = toNumber(upper); + upper = upper === upper ? upper : 0; + } - if (!isOuter && isArea) { - var multipolygon = osmRelation({ - tags: Object.assign({}, wayA.tags, { - type: 'multipolygon' - }), - members: [{ - id: wayA.id, - role: 'outer', - type: 'way' - }, { - id: wayB.id, - role: 'outer', - type: 'way' - }] - }); - graph = graph.replace(multipolygon); - graph = graph.replace(wayA.update({ - tags: {} - })); - graph = graph.replace(wayB.update({ - tags: {} - })); - } + if (lower !== undefined$1) { + lower = toNumber(lower); + lower = lower === lower ? lower : 0; + } - _createdWayIDs.push(wayB.id); + return baseClamp(toNumber(number), lower, upper); + } + /** + * Checks if `n` is between `start` and up to, but not including, `end`. If + * `end` is not specified, it's set to `start` with `start` then set to `0`. + * If `start` is greater than `end` the params are swapped to support + * negative ranges. + * + * @static + * @memberOf _ + * @since 3.3.0 + * @category Number + * @param {number} number The number to check. + * @param {number} [start=0] The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + * @see _.range, _.rangeRight + * @example + * + * _.inRange(3, 2, 4); + * // => true + * + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false + * + * _.inRange(1.2, 2); + * // => true + * + * _.inRange(5.2, 4); + * // => false + * + * _.inRange(-3, -2, -6); + * // => true + */ - return graph; - } - var action = function action(graph) { - _createdWayIDs = []; - var newWayIndex = 0; + function inRange(number, start, end) { + start = toFinite(start); - for (var i = 0; i < nodeIds.length; i++) { - var nodeId = nodeIds[i]; - var candidates = action.waysForNode(nodeId, graph); + if (end === undefined$1) { + end = start; + start = 0; + } else { + end = toFinite(end); + } - for (var j = 0; j < candidates.length; j++) { - graph = split(graph, nodeId, candidates[j], newWayIds && newWayIds[newWayIndex]); - newWayIndex += 1; + number = toNumber(number); + return baseInRange(number, start, end); } - } - - return graph; - }; + /** + * Produces a random number between the inclusive `lower` and `upper` bounds. + * If only one argument is provided a number between `0` and the given number + * is returned. If `floating` is `true`, or either `lower` or `upper` are + * floats, a floating-point number is returned instead of an integer. + * + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Number + * @param {number} [lower=0] The lower bound. + * @param {number} [upper=1] The upper bound. + * @param {boolean} [floating] Specify returning a floating-point number. + * @returns {number} Returns the random number. + * @example + * + * _.random(0, 5); + * // => an integer between 0 and 5 + * + * _.random(5); + * // => also an integer between 0 and 5 + * + * _.random(5, true); + * // => a floating-point number between 0 and 5 + * + * _.random(1.2, 5.2); + * // => a floating-point number between 1.2 and 5.2 + */ - action.getCreatedWayIDs = function () { - return _createdWayIDs; - }; - action.waysForNode = function (nodeId, graph) { - var node = graph.entity(nodeId); - var splittableParents = graph.parentWays(node).filter(isSplittable); + function random(lower, upper, floating) { + if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) { + upper = floating = undefined$1; + } - if (!_wayIDs) { - // If the ways to split aren't specified, only split the lines. - // If there are no lines to split, split the areas. - var hasLine = splittableParents.some(function (parent) { - return parent.geometry(graph) === 'line'; - }); + if (floating === undefined$1) { + if (typeof upper == 'boolean') { + floating = upper; + upper = undefined$1; + } else if (typeof lower == 'boolean') { + floating = lower; + lower = undefined$1; + } + } - if (hasLine) { - return splittableParents.filter(function (parent) { - return parent.geometry(graph) === 'line'; - }); - } - } + if (lower === undefined$1 && upper === undefined$1) { + lower = 0; + upper = 1; + } else { + lower = toFinite(lower); - return splittableParents; + if (upper === undefined$1) { + upper = lower; + lower = 0; + } else { + upper = toFinite(upper); + } + } - function isSplittable(parent) { - // If the ways to split are specified, ignore everything else. - if (_wayIDs && _wayIDs.indexOf(parent.id) === -1) return false; // We can fake splitting closed ways at their endpoints... + if (lower > upper) { + var temp = lower; + lower = upper; + upper = temp; + } - if (parent.isClosed()) return true; // otherwise, we can't split nodes at their endpoints. + if (floating || lower % 1 || upper % 1) { + var rand = nativeRandom(); + return nativeMin(lower + rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1))), upper); + } - for (var i = 1; i < parent.nodes.length - 1; i++) { - if (parent.nodes[i] === nodeId) return true; + return baseRandom(lower, upper); } + /*------------------------------------------------------------------------*/ - return false; - } - }; + /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */ - action.ways = function (graph) { - return utilArrayUniq([].concat.apply([], nodeIds.map(function (nodeId) { - return action.waysForNode(nodeId, graph); - }))); - }; - action.disabled = function (graph) { - for (var i = 0; i < nodeIds.length; i++) { - var nodeId = nodeIds[i]; - var candidates = action.waysForNode(nodeId, graph); + var camelCase = createCompounder(function (result, word, index) { + word = word.toLowerCase(); + return result + (index ? capitalize(word) : word); + }); + /** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */ - if (candidates.length === 0 || _wayIDs && _wayIDs.length !== candidates.length) { - return 'not_eligible'; + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); } - } - }; + /** + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */ - action.limitWays = function (val) { - if (!arguments.length) return _wayIDs; - _wayIDs = val; - return action; - }; - action.keepHistoryOn = function (val) { - if (!arguments.length) return _keepHistoryOn; - _keepHistoryOn = val; - return action; - }; + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); + } + /** + * Checks if `string` ends with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=string.length] The position to search up to. + * @returns {boolean} Returns `true` if `string` ends with `target`, + * else `false`. + * @example + * + * _.endsWith('abc', 'c'); + * // => true + * + * _.endsWith('abc', 'b'); + * // => false + * + * _.endsWith('abc', 'b', 2); + * // => true + */ - return action; - } - function coreGraph(other, mutable) { - if (!(this instanceof coreGraph)) return new coreGraph(other, mutable); + function endsWith(string, target, position) { + string = toString(string); + target = baseToString(target); + var length = string.length; + position = position === undefined$1 ? length : baseClamp(toInteger(position), 0, length); + var end = position; + position -= target.length; + return position >= 0 && string.slice(position, end) == target; + } + /** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. + * + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ - if (other instanceof coreGraph) { - var base = other.base(); - this.entities = Object.assign(Object.create(base.entities), other.entities); - this._parentWays = Object.assign(Object.create(base.parentWays), other._parentWays); - this._parentRels = Object.assign(Object.create(base.parentRels), other._parentRels); - } else { - this.entities = Object.create({}); - this._parentWays = Object.create({}); - this._parentRels = Object.create({}); - this.rebase(other || [], [this]); - } - this.transients = {}; - this._childNodes = {}; - this.frozen = !mutable; - } - coreGraph.prototype = { - hasEntity: function hasEntity(id) { - return this.entities[id]; - }, - entity: function entity(id) { - var entity = this.entities[id]; //https://github.com/openstreetmap/iD/issues/3973#issuecomment-307052376 + function escape(string) { + string = toString(string); + return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string; + } + /** + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]\(https://lodash\.com/\)' + */ - if (!entity) { - entity = this.entities.__proto__[id]; // eslint-disable-line no-proto - } - if (!entity) { - throw new Error('entity ' + id + ' not found'); - } + function escapeRegExp(string) { + string = toString(string); + return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, '\\$&') : string; + } + /** + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. + * @example + * + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' + * + * _.kebabCase('fooBar'); + * // => 'foo-bar' + * + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' + */ - return entity; - }, - geometry: function geometry(id) { - return this.entity(id).geometry(this); - }, - "transient": function transient(entity, key, fn) { - var id = entity.id; - var transients = this.transients[id] || (this.transients[id] = {}); - if (transients[key] !== undefined) { - return transients[key]; - } + var kebabCase = createCompounder(function (result, word, index) { + return result + (index ? '-' : '') + word.toLowerCase(); + }); + /** + * Converts `string`, as space separated words, to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' + * + * _.lowerCase('fooBar'); + * // => 'foo bar' + * + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' + */ - transients[key] = fn.call(entity); - return transients[key]; - }, - parentWays: function parentWays(entity) { - var parents = this._parentWays[entity.id]; - var result = []; + var lowerCase = createCompounder(function (result, word, index) { + return result + (index ? ' ' : '') + word.toLowerCase(); + }); + /** + * Converts the first character of `string` to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' + */ - if (parents) { - parents.forEach(function (id) { - result.push(this.entity(id)); - }, this); - } + var lowerFirst = createCaseFirst('toLowerCase'); + /** + * Pads `string` on the left and right sides if it's shorter than `length`. + * Padding characters are truncated if they can't be evenly divided by `length`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.pad('abc', 8); + * // => ' abc ' + * + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' + * + * _.pad('abc', 3); + * // => 'abc' + */ - return result; - }, - isPoi: function isPoi(entity) { - var parents = this._parentWays[entity.id]; - return !parents || parents.size === 0; - }, - isShared: function isShared(entity) { - var parents = this._parentWays[entity.id]; - return parents && parents.size > 1; - }, - parentRelations: function parentRelations(entity) { - var parents = this._parentRels[entity.id]; - var result = []; + function pad(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; - if (parents) { - parents.forEach(function (id) { - result.push(this.entity(id)); - }, this); - } + if (!length || strLength >= length) { + return string; + } - return result; - }, - parentMultipolygons: function parentMultipolygons(entity) { - return this.parentRelations(entity).filter(function (relation) { - return relation.isMultipolygon(); - }); - }, - childNodes: function childNodes(entity) { - if (this._childNodes[entity.id]) return this._childNodes[entity.id]; - if (!entity.nodes) return []; - var nodes = []; + var mid = (length - strLength) / 2; + return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars); + } + /** + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.padEnd('abc', 6); + * // => 'abc ' + * + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' + */ - for (var i = 0; i < entity.nodes.length; i++) { - nodes[i] = this.entity(entity.nodes[i]); - } - this._childNodes[entity.id] = nodes; - return this._childNodes[entity.id]; - }, - base: function base() { - return { - 'entities': Object.getPrototypeOf(this.entities), - 'parentWays': Object.getPrototypeOf(this._parentWays), - 'parentRels': Object.getPrototypeOf(this._parentRels) - }; - }, - // Unlike other graph methods, rebase mutates in place. This is because it - // is used only during the history operation that merges newly downloaded - // data into each state. To external consumers, it should appear as if the - // graph always contained the newly downloaded data. - rebase: function rebase(entities, stack, force) { - var base = this.base(); - var i, j, k, id; - for (i = 0; i < entities.length; i++) { - var entity = entities[i]; - if (!entity.visible || !force && base.entities[entity.id]) continue; // Merging data into the base graph + function padEnd(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length ? string + createPadding(length - strLength, chars) : string; + } + /** + * Pads `string` on the left side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.padStart('abc', 6); + * // => ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' + */ - base.entities[entity.id] = entity; - this._updateCalculated(undefined, entity, base.parentWays, base.parentRels); // Restore provisionally-deleted nodes that are discovered to have an extant parent + function padStart(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length ? createPadding(length - strLength, chars) + string : string; + } + /** + * Converts `string` to an integer of the specified radix. If `radix` is + * `undefined` or `0`, a `radix` of `10` is used unless `value` is a + * hexadecimal, in which case a `radix` of `16` is used. + * + * **Note:** This method aligns with the + * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category String + * @param {string} string The string to convert. + * @param {number} [radix=10] The radix to interpret `value` by. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {number} Returns the converted integer. + * @example + * + * _.parseInt('08'); + * // => 8 + * + * _.map(['6', '08', '10'], _.parseInt); + * // => [6, 8, 10] + */ - if (entity.type === 'way') { - for (j = 0; j < entity.nodes.length; j++) { - id = entity.nodes[j]; + function parseInt(string, radix, guard) { + if (guard || radix == null) { + radix = 0; + } else if (radix) { + radix = +radix; + } - for (k = 1; k < stack.length; k++) { - var ents = stack[k].entities; + return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0); + } + /** + * Repeats the given string `n` times. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to repeat. + * @param {number} [n=1] The number of times to repeat the string. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {string} Returns the repeated string. + * @example + * + * _.repeat('*', 3); + * // => '***' + * + * _.repeat('abc', 2); + * // => 'abcabc' + * + * _.repeat('abc', 0); + * // => '' + */ - if (ents.hasOwnProperty(id) && ents[id] === undefined) { - delete ents[id]; - } - } + + function repeat(string, n, guard) { + if (guard ? isIterateeCall(string, n, guard) : n === undefined$1) { + n = 1; + } else { + n = toInteger(n); } - } - } - for (i = 0; i < stack.length; i++) { - stack[i]._updateRebased(); - } - }, - _updateRebased: function _updateRebased() { - var base = this.base(); - Object.keys(this._parentWays).forEach(function (child) { - if (base.parentWays[child]) { - base.parentWays[child].forEach(function (id) { - if (!this.entities.hasOwnProperty(id)) { - this._parentWays[child].add(id); - } - }, this); - } - }, this); - Object.keys(this._parentRels).forEach(function (child) { - if (base.parentRels[child]) { - base.parentRels[child].forEach(function (id) { - if (!this.entities.hasOwnProperty(id)) { - this._parentRels[child].add(id); - } - }, this); + return baseRepeat(toString(string), n); } - }, this); - this.transients = {}; // this._childNodes is not updated, under the assumption that - // ways are always downloaded with their child nodes. - }, - // Updates calculated properties (parentWays, parentRels) for the specified change - _updateCalculated: function _updateCalculated(oldentity, entity, parentWays, parentRels) { - parentWays = parentWays || this._parentWays; - parentRels = parentRels || this._parentRels; - var type = entity && entity.type || oldentity && oldentity.type; - var removed, added, i; + /** + * Replaces matches for `pattern` in `string` with `replacement`. + * + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to modify. + * @param {RegExp|string} pattern The pattern to replace. + * @param {Function|string} replacement The match replacement. + * @returns {string} Returns the modified string. + * @example + * + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' + */ - if (type === 'way') { - // Update parentWays - if (oldentity && entity) { - removed = utilArrayDifference(oldentity.nodes, entity.nodes); - added = utilArrayDifference(entity.nodes, oldentity.nodes); - } else if (oldentity) { - removed = oldentity.nodes; - added = []; - } else if (entity) { - removed = []; - added = entity.nodes; - } - for (i = 0; i < removed.length; i++) { - // make a copy of prototype property, store as own property, and update.. - parentWays[removed[i]] = new Set(parentWays[removed[i]]); - parentWays[removed[i]]["delete"](oldentity.id); + function replace() { + var args = arguments, + string = toString(args[0]); + return args.length < 3 ? string : string.replace(args[1], args[2]); } + /** + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. + * @example + * + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' + * + * _.snakeCase('fooBar'); + * // => 'foo_bar' + * + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */ - for (i = 0; i < added.length; i++) { - // make a copy of prototype property, store as own property, and update.. - parentWays[added[i]] = new Set(parentWays[added[i]]); - parentWays[added[i]].add(entity.id); - } - } else if (type === 'relation') { - // Update parentRels - // diff only on the IDs since the same entity can be a member multiple times with different roles - var oldentityMemberIDs = oldentity ? oldentity.members.map(function (m) { - return m.id; - }) : []; - var entityMemberIDs = entity ? entity.members.map(function (m) { - return m.id; - }) : []; - if (oldentity && entity) { - removed = utilArrayDifference(oldentityMemberIDs, entityMemberIDs); - added = utilArrayDifference(entityMemberIDs, oldentityMemberIDs); - } else if (oldentity) { - removed = oldentityMemberIDs; - added = []; - } else if (entity) { - removed = []; - added = entityMemberIDs; - } + var snakeCase = createCompounder(function (result, word, index) { + return result + (index ? '_' : '') + word.toLowerCase(); + }); + /** + * Splits `string` by `separator`. + * + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to split. + * @param {RegExp|string} separator The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * @example + * + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ - for (i = 0; i < removed.length; i++) { - // make a copy of prototype property, store as own property, and update.. - parentRels[removed[i]] = new Set(parentRels[removed[i]]); - parentRels[removed[i]]["delete"](oldentity.id); - } + function split(string, separator, limit) { + if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) { + separator = limit = undefined$1; + } - for (i = 0; i < added.length; i++) { - // make a copy of prototype property, store as own property, and update.. - parentRels[added[i]] = new Set(parentRels[added[i]]); - parentRels[added[i]].add(entity.id); - } - } - }, - replace: function replace(entity) { - if (this.entities[entity.id] === entity) return this; - return this.update(function () { - this._updateCalculated(this.entities[entity.id], entity); + limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0; - this.entities[entity.id] = entity; - }); - }, - remove: function remove(entity) { - return this.update(function () { - this._updateCalculated(entity, undefined); + if (!limit) { + return []; + } - this.entities[entity.id] = undefined; - }); - }, - revert: function revert(id) { - var baseEntity = this.base().entities[id]; - var headEntity = this.entities[id]; - if (headEntity === baseEntity) return this; - return this.update(function () { - this._updateCalculated(headEntity, baseEntity); + string = toString(string); - delete this.entities[id]; - }); - }, - update: function update() { - var graph = this.frozen ? coreGraph(this, true) : this; + if (string && (typeof separator == 'string' || separator != null && !isRegExp(separator))) { + separator = baseToString(separator); - for (var i = 0; i < arguments.length; i++) { - arguments[i].call(graph, graph); - } + if (!separator && hasUnicode(string)) { + return castSlice(stringToArray(string), 0, limit); + } + } - if (this.frozen) graph.frozen = true; - return graph; - }, - // Obliterates any existing entities - load: function load(entities) { - var base = this.base(); - this.entities = Object.create(base.entities); + return string.split(separator, limit); + } + /** + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). + * + * @static + * @memberOf _ + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. + * @example + * + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' + * + * _.startCase('fooBar'); + * // => 'Foo Bar' + * + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' + */ - for (var i in entities) { - this.entities[i] = entities[i]; - this._updateCalculated(base.entities[i], this.entities[i]); - } + var startCase = createCompounder(function (result, word, index) { + return result + (index ? ' ' : '') + upperFirst(word); + }); + /** + * Checks if `string` starts with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=0] The position to search from. + * @returns {boolean} Returns `true` if `string` starts with `target`, + * else `false`. + * @example + * + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => true + */ - return this; - } - }; + function startsWith(string, target, position) { + string = toString(string); + position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length); + target = baseToString(target); + return string.slice(position, position + target.length) == target; + } + /** + * Creates a compiled template function that can interpolate data properties + * in "interpolate" delimiters, HTML-escape interpolated data properties in + * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data + * properties may be accessed as free variables in the template. If a setting + * object is given, it takes precedence over `_.templateSettings` values. + * + * **Note:** In the development build `_.template` utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * for easier debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The template string. + * @param {Object} [options={}] The options object. + * @param {RegExp} [options.escape=_.templateSettings.escape] + * The HTML "escape" delimiter. + * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] + * The "evaluate" delimiter. + * @param {Object} [options.imports=_.templateSettings.imports] + * An object to import into the template as free variables. + * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] + * The "interpolate" delimiter. + * @param {string} [options.sourceURL='lodash.templateSources[n]'] + * The sourceURL of the compiled template. + * @param {string} [options.variable='obj'] + * The data object variable name. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the compiled template function. + * @example + * + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' + * + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': '