diff --git a/ajax/libs/immutable/3.1.0/immutable.js b/ajax/libs/immutable/3.1.0/immutable.js new file mode 100644 index 000000000..92327220c --- /dev/null +++ b/ajax/libs/immutable/3.1.0/immutable.js @@ -0,0 +1,3782 @@ +/** + * Copyright (c) 2014, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +function universalModule() { + var $Object = Object; + +function createClass(ctor, methods, staticMethods, superClass) { + var proto; + if (superClass) { + var superProto = superClass.prototype; + proto = $Object.create(superProto); + } else { + proto = ctor.prototype; + } + $Object.keys(methods).forEach(function (key) { + proto[key] = methods[key]; + }); + $Object.keys(staticMethods).forEach(function (key) { + ctor[key] = staticMethods[key]; + }); + proto.constructor = ctor; + ctor.prototype = proto; + return ctor; +} + +function superCall(self, proto, name, args) { + return $Object.getPrototypeOf(proto)[name].apply(self, args); +} + +function defaultSuperCall(self, proto, args) { + superCall(self, proto, 'constructor', args); +} + +var $traceurRuntime = {}; +$traceurRuntime.createClass = createClass; +$traceurRuntime.superCall = superCall; +$traceurRuntime.defaultSuperCall = defaultSuperCall; +"use strict"; +function is(first, second) { + if (first === second) { + return first !== 0 || second !== 0 || 1 / first === 1 / second; + } + if (first !== first) { + return second !== second; + } + if (first && typeof first.equals === 'function') { + return first.equals(second); + } + return false; +} +function invariant(condition, error) { + if (!condition) + throw new Error(error); +} +var DELETE = 'delete'; +var SHIFT = 5; +var SIZE = 1 << SHIFT; +var MASK = SIZE - 1; +var NOT_SET = {}; +var CHANGE_LENGTH = {value: false}; +var DID_ALTER = {value: false}; +function MakeRef(ref) { + ref.value = false; + return ref; +} +function SetRef(ref) { + ref && (ref.value = true); +} +function OwnerID() {} +function arrCopy(arr, offset) { + offset = offset || 0; + var len = Math.max(0, arr.length - offset); + var newArr = new Array(len); + for (var ii = 0; ii < len; ii++) { + newArr[ii] = arr[ii + offset]; + } + return newArr; +} +function assertNotInfinite(size) { + invariant(size !== Infinity, 'Cannot perform this action with an infinite size.'); +} +function ensureSize(iter) { + if (iter.size === undefined) { + iter.size = iter.__iterate(returnTrue); + } + return iter.size; +} +function wrapIndex(iter, index) { + return index >= 0 ? (+index) : ensureSize(iter) + (+index); +} +function returnTrue() { + return true; +} +function wholeSlice(begin, end, size) { + return (begin === 0 || (size !== undefined && begin <= -size)) && (end === undefined || (size !== undefined && end >= size)); +} +function resolveBegin(begin, size) { + return resolveIndex(begin, size, 0); +} +function resolveEnd(end, size) { + return resolveIndex(end, size, size); +} +function resolveIndex(index, size, defaultIndex) { + return index === undefined ? defaultIndex : index < 0 ? Math.max(0, size + index) : size === undefined ? index : Math.min(size, index); +} +function hash(o) { + if (!o) { + return 0; + } + if (o === true) { + return 1; + } + var type = typeof o; + if (type === 'number') { + if ((o | 0) === o) { + return o & HASH_MAX_VAL; + } + o = '' + o; + type = 'string'; + } + if (type === 'string') { + return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o); + } + if (o.hashCode) { + return hash(typeof o.hashCode === 'function' ? o.hashCode() : o.hashCode); + } + return hashJSObj(o); +} +function cachedHashString(string) { + var hash = stringHashCache[string]; + if (hash === undefined) { + hash = hashString(string); + if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) { + STRING_HASH_CACHE_SIZE = 0; + stringHashCache = {}; + } + STRING_HASH_CACHE_SIZE++; + stringHashCache[string] = hash; + } + return hash; +} +function hashString(string) { + var hash = 0; + for (var ii = 0; ii < string.length; ii++) { + hash = (31 * hash + string.charCodeAt(ii)) & HASH_MAX_VAL; + } + return hash; +} +function hashJSObj(obj) { + var hash = weakMap && weakMap.get(obj); + if (hash) + return hash; + hash = obj[UID_HASH_KEY]; + if (hash) + return hash; + if (!canDefineProperty) { + hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY]; + if (hash) + return hash; + hash = getIENodeHash(obj); + if (hash) + return hash; + } + if (Object.isExtensible && !Object.isExtensible(obj)) { + throw new Error('Non-extensible objects are not allowed as keys.'); + } + hash = ++objHashUID & HASH_MAX_VAL; + if (weakMap) { + weakMap.set(obj, hash); + } else if (canDefineProperty) { + Object.defineProperty(obj, UID_HASH_KEY, { + 'enumerable': false, + 'configurable': false, + 'writable': false, + 'value': hash + }); + } else if (obj.propertyIsEnumerable && obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) { + obj.propertyIsEnumerable = function() { + return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments); + }; + obj.propertyIsEnumerable[UID_HASH_KEY] = hash; + } else if (obj.nodeType) { + obj[UID_HASH_KEY] = hash; + } else { + throw new Error('Unable to set a non-enumerable property on object.'); + } + return hash; +} +var canDefineProperty = (function() { + try { + Object.defineProperty({}, 'x', {}); + return true; + } catch (e) { + return false; + } +}()); +function getIENodeHash(node) { + if (node && node.nodeType > 0) { + switch (node.nodeType) { + case 1: + return node.uniqueID; + case 9: + return node.documentElement && node.documentElement.uniqueID; + } + } +} +var weakMap = typeof WeakMap === 'function' && new WeakMap(); +var HASH_MAX_VAL = 0x7FFFFFFF; +var objHashUID = 0; +var UID_HASH_KEY = '__immutablehash__'; +if (typeof Symbol === 'function') { + UID_HASH_KEY = Symbol(UID_HASH_KEY); +} +var STRING_HASH_CACHE_MIN_STRLEN = 16; +var STRING_HASH_CACHE_MAX_SIZE = 255; +var STRING_HASH_CACHE_SIZE = 0; +var stringHashCache = {}; +var ITERATE_KEYS = 0; +var ITERATE_VALUES = 1; +var ITERATE_ENTRIES = 2; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; +var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; +var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL; +var Iterator = function Iterator(next) { + this.next = next; +}; +($traceurRuntime.createClass)(Iterator, {toString: function() { + return '[Iterator]'; + }}, {}); +Iterator.KEYS = ITERATE_KEYS; +Iterator.VALUES = ITERATE_VALUES; +Iterator.ENTRIES = ITERATE_ENTRIES; +var IteratorPrototype = Iterator.prototype; +IteratorPrototype.inspect = IteratorPrototype.toSource = function() { + return this.toString(); +}; +IteratorPrototype[ITERATOR_SYMBOL] = function() { + return this; +}; +function iteratorValue(type, k, v, iteratorResult) { + var value = type === 0 ? k : type === 1 ? v : [k, v]; + iteratorResult ? (iteratorResult.value = value) : (iteratorResult = { + value: value, + done: false + }); + return iteratorResult; +} +function iteratorDone() { + return { + value: undefined, + done: true + }; +} +function hasIterator(maybeIterable) { + return !!_iteratorFn(maybeIterable); +} +function isIterator(maybeIterator) { + return maybeIterator && typeof maybeIterator.next === 'function'; +} +function getIterator(iterable) { + var iteratorFn = _iteratorFn(iterable); + return iteratorFn && iteratorFn.call(iterable); +} +function _iteratorFn(iterable) { + var iteratorFn = iterable && ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) || iterable[FAUX_ITERATOR_SYMBOL]); + if (typeof iteratorFn === 'function') { + return iteratorFn; + } +} +var Iterable = function Iterable(value) { + return isIterable(value) ? value : Seq(value); +}; +var $Iterable = Iterable; +($traceurRuntime.createClass)(Iterable, { + toArray: function() { + assertNotInfinite(this.size); + var array = new Array(this.size || 0); + this.valueSeq().__iterate((function(v, i) { + array[i] = v; + })); + return array; + }, + toIndexedSeq: function() { + return new ToIndexedSequence(this); + }, + toJS: function() { + return this.toSeq().map((function(value) { + return value && typeof value.toJS === 'function' ? value.toJS() : value; + })).__toJS(); + }, + toKeyedSeq: function() { + return new ToKeyedSequence(this, true); + }, + toMap: function() { + assertNotInfinite(this.size); + return Map(this.toKeyedSeq()); + }, + toObject: function() { + assertNotInfinite(this.size); + var object = {}; + this.__iterate((function(v, k) { + object[k] = v; + })); + return object; + }, + toOrderedMap: function() { + assertNotInfinite(this.size); + return OrderedMap(this.toKeyedSeq()); + }, + toOrderedSet: function() { + assertNotInfinite(this.size); + return OrderedSet(isKeyed(this) ? this.valueSeq() : this); + }, + toSet: function() { + assertNotInfinite(this.size); + return Set(isKeyed(this) ? this.valueSeq() : this); + }, + toSetSeq: function() { + return new ToSetSequence(this); + }, + toSeq: function() { + return isIndexed(this) ? this.toIndexedSeq() : isKeyed(this) ? this.toKeyedSeq() : this.toSetSeq(); + }, + toStack: function() { + assertNotInfinite(this.size); + return Stack(isKeyed(this) ? this.valueSeq() : this); + }, + toList: function() { + assertNotInfinite(this.size); + return List(isKeyed(this) ? this.valueSeq() : this); + }, + toString: function() { + return '[Iterable]'; + }, + __toString: function(head, tail) { + if (this.size === 0) { + return head + tail; + } + return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail; + }, + concat: function() { + for (var values = [], + $__2 = 0; $__2 < arguments.length; $__2++) + values[$__2] = arguments[$__2]; + return reify(this, concatFactory(this, values)); + }, + contains: function(searchValue) { + return this.some((function(value) { + return is(value, searchValue); + })); + }, + entries: function() { + return this.__iterator(ITERATE_ENTRIES); + }, + every: function(predicate, context) { + var returnValue = true; + this.__iterate((function(v, k, c) { + if (!predicate.call(context, v, k, c)) { + returnValue = false; + return false; + } + })); + return returnValue; + }, + filter: function(predicate, context) { + return reify(this, filterFactory(this, predicate, context, true)); + }, + find: function(predicate, context, notSetValue) { + var foundValue = notSetValue; + this.__iterate((function(v, k, c) { + if (predicate.call(context, v, k, c)) { + foundValue = v; + return false; + } + })); + return foundValue; + }, + forEach: function(sideEffect, context) { + return this.__iterate(context ? sideEffect.bind(context) : sideEffect); + }, + join: function(separator) { + separator = separator !== undefined ? '' + separator : ','; + var joined = ''; + var isFirst = true; + this.__iterate((function(v) { + isFirst ? (isFirst = false) : (joined += separator); + joined += v !== null && v !== undefined ? v : ''; + })); + return joined; + }, + keys: function() { + return this.__iterator(ITERATE_KEYS); + }, + map: function(mapper, context) { + return reify(this, mapFactory(this, mapper, context)); + }, + reduce: function(reducer, initialReduction, context) { + var reduction; + var useFirst; + if (arguments.length < 2) { + useFirst = true; + } else { + reduction = initialReduction; + } + this.__iterate((function(v, k, c) { + if (useFirst) { + useFirst = false; + reduction = v; + } else { + reduction = reducer.call(context, reduction, v, k, c); + } + })); + return reduction; + }, + reduceRight: function(reducer, initialReduction, context) { + var reversed = this.toKeyedSeq().reverse(); + return reversed.reduce.apply(reversed, arguments); + }, + reverse: function() { + return reify(this, reverseFactory(this, true)); + }, + slice: function(begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + var resolvedBegin = resolveBegin(begin, this.size); + var resolvedEnd = resolveEnd(end, this.size); + if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) { + return this.toSeq().cacheResult().slice(begin, end); + } + var skipped = resolvedBegin === 0 ? this : this.skip(resolvedBegin); + return reify(this, resolvedEnd === undefined || resolvedEnd === this.size ? skipped : skipped.take(resolvedEnd - resolvedBegin)); + }, + some: function(predicate, context) { + return !this.every(not(predicate), context); + }, + sort: function(comparator) { + return reify(this, sortFactory(this, comparator)); + }, + values: function() { + return this.__iterator(ITERATE_VALUES); + }, + butLast: function() { + return this.slice(0, -1); + }, + count: function(predicate, context) { + return ensureSize(predicate ? this.toSeq().filter(predicate, context) : this); + }, + countBy: function(grouper, context) { + return countByFactory(this, grouper, context); + }, + equals: function(other) { + if (this === other) { + return true; + } + if (!other || typeof other.equals !== 'function') { + return false; + } + if (this.size !== undefined && other.size !== undefined) { + if (this.size !== other.size) { + return false; + } + if (this.size === 0 && other.size === 0) { + return true; + } + } + if (this.__hash !== undefined && other.__hash !== undefined && this.__hash !== other.__hash) { + return false; + } + return this.__deepEquals(other); + }, + __deepEquals: function(other) { + var entries = this.entries(); + return typeof other.every === 'function' && other.every((function(v, k) { + var entry = entries.next().value; + return entry && is(entry[0], k) && is(entry[1], v); + })) && entries.next().done; + }, + entrySeq: function() { + var iterable = this; + if (iterable._cache) { + return new ArraySeq(iterable._cache); + } + var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq(); + entriesSequence.fromEntrySeq = (function() { + return iterable.toSeq(); + }); + return entriesSequence; + }, + filterNot: function(predicate, context) { + return this.filter(not(predicate), context); + }, + findLast: function(predicate, context, notSetValue) { + return this.toKeyedSeq().reverse().find(predicate, context, notSetValue); + }, + first: function() { + return this.find(returnTrue); + }, + flatMap: function(mapper, context) { + return reify(this, flatMapFactory(this, mapper, context)); + }, + flatten: function(depth) { + return reify(this, flattenFactory(this, depth, true)); + }, + fromEntrySeq: function() { + return new FromEntriesSequence(this); + }, + get: function(searchKey, notSetValue) { + return this.find((function(_, key) { + return is(key, searchKey); + }), undefined, notSetValue); + }, + getIn: function(searchKeyPath, notSetValue) { + var nested = this; + if (searchKeyPath) { + for (var ii = 0; ii < searchKeyPath.length; ii++) { + nested = nested && nested.get ? nested.get(searchKeyPath[ii], NOT_SET) : NOT_SET; + if (nested === NOT_SET) { + return notSetValue; + } + } + } + return nested; + }, + groupBy: function(grouper, context) { + return groupByFactory(this, grouper, context); + }, + has: function(searchKey) { + return this.get(searchKey, NOT_SET) !== NOT_SET; + }, + isSubset: function(iter) { + iter = typeof iter.contains === 'function' ? iter : $Iterable(iter); + return this.every((function(value) { + return iter.contains(value); + })); + }, + isSuperset: function(iter) { + return iter.isSubset(this); + }, + keySeq: function() { + return this.toSeq().map(keyMapper).toIndexedSeq(); + }, + last: function() { + return this.toSeq().reverse().first(); + }, + max: function(comparator) { + return maxFactory(this, comparator); + }, + maxBy: function(mapper, comparator) { + return maxFactory(this, comparator, mapper); + }, + min: function(comparator) { + return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator); + }, + minBy: function(mapper, comparator) { + return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper); + }, + rest: function() { + return this.slice(1); + }, + skip: function(amount) { + return reify(this, skipFactory(this, amount, true)); + }, + skipLast: function(amount) { + return reify(this, this.toSeq().reverse().skip(amount).reverse()); + }, + skipWhile: function(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, true)); + }, + skipUntil: function(predicate, context) { + return this.skipWhile(not(predicate), context); + }, + sortBy: function(mapper, comparator) { + return reify(this, sortFactory(this, comparator, mapper)); + }, + take: function(amount) { + return reify(this, takeFactory(this, amount)); + }, + takeLast: function(amount) { + return reify(this, this.toSeq().reverse().take(amount).reverse()); + }, + takeWhile: function(predicate, context) { + return reify(this, takeWhileFactory(this, predicate, context)); + }, + takeUntil: function(predicate, context) { + return this.takeWhile(not(predicate), context); + }, + valueSeq: function() { + return this.toIndexedSeq(); + }, + hashCode: function() { + return this.__hash || (this.__hash = this.size === Infinity ? 0 : this.reduce((function(h, v, k) { + return (h + (hash(v) ^ (v === k ? 0 : hash(k)))) & HASH_MAX_VAL; + }), 0)); + } +}, {}); +var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@'; +var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; +var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@'; +var IterablePrototype = Iterable.prototype; +IterablePrototype[IS_ITERABLE_SENTINEL] = true; +IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values; +IterablePrototype.toJSON = IterablePrototype.toJS; +IterablePrototype.__toJS = IterablePrototype.toArray; +IterablePrototype.__toStringMapper = quoteString; +IterablePrototype.inspect = IterablePrototype.toSource = function() { + return this.toString(); +}; +IterablePrototype.chain = IterablePrototype.flatMap; +(function() { + try { + Object.defineProperty(IterablePrototype, 'length', {get: function() { + if (!Iterable.noLengthWarning) { + var stack; + try { + throw new Error(); + } catch (error) { + stack = error.stack; + } + if (stack.indexOf('_wrapObject') === -1) { + console && console.warn && console.warn('iterable.length has been deprecated, ' + 'use iterable.size or iterable.count(). ' + 'This warning will become a silent error in a future version. ' + stack); + return this.size; + } + } + }}); + } catch (e) {} +})(); +var KeyedIterable = function KeyedIterable(value) { + return isKeyed(value) ? value : KeyedSeq(value); +}; +($traceurRuntime.createClass)(KeyedIterable, { + flip: function() { + return reify(this, flipFactory(this)); + }, + findKey: function(predicate, context) { + var foundKey; + this.__iterate((function(v, k, c) { + if (predicate.call(context, v, k, c)) { + foundKey = k; + return false; + } + })); + return foundKey; + }, + findLastKey: function(predicate, context) { + return this.toSeq().reverse().findKey(predicate, context); + }, + keyOf: function(searchValue) { + return this.findKey((function(value) { + return is(value, searchValue); + })); + }, + lastKeyOf: function(searchValue) { + return this.toSeq().reverse().keyOf(searchValue); + }, + mapEntries: function(mapper, context) { + var $__0 = this; + var iterations = 0; + return reify(this, this.toSeq().map((function(v, k) { + return mapper.call(context, [k, v], iterations++, $__0); + })).fromEntrySeq()); + }, + mapKeys: function(mapper, context) { + var $__0 = this; + return reify(this, this.toSeq().flip().map((function(k, v) { + return mapper.call(context, k, v, $__0); + })).flip()); + } +}, {}, Iterable); +var KeyedIterablePrototype = KeyedIterable.prototype; +KeyedIterablePrototype[IS_KEYED_SENTINEL] = true; +KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries; +KeyedIterablePrototype.__toJS = IterablePrototype.toObject; +KeyedIterablePrototype.__toStringMapper = (function(v, k) { + return k + ': ' + quoteString(v); +}); +var IndexedIterable = function IndexedIterable(value) { + return isIndexed(value) ? value : IndexedSeq(value); +}; +($traceurRuntime.createClass)(IndexedIterable, { + toKeyedSeq: function() { + return new ToKeyedSequence(this, false); + }, + filter: function(predicate, context) { + return reify(this, filterFactory(this, predicate, context, false)); + }, + findIndex: function(predicate, context) { + var key = this.toKeyedSeq().findKey(predicate, context); + return key === undefined ? -1 : key; + }, + indexOf: function(searchValue) { + var key = this.toKeyedSeq().keyOf(searchValue); + return key === undefined ? -1 : key; + }, + lastIndexOf: function(searchValue) { + var key = this.toKeyedSeq().lastKeyOf(searchValue); + return key === undefined ? -1 : key; + }, + reverse: function() { + return reify(this, reverseFactory(this, false)); + }, + splice: function(index, removeNum) { + var numArgs = arguments.length; + removeNum = Math.max(removeNum | 0, 0); + if (numArgs === 0 || (numArgs === 2 && !removeNum)) { + return this; + } + index = resolveBegin(index, this.size); + var spliced = this.slice(0, index); + return reify(this, numArgs === 1 ? spliced : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))); + }, + findLastIndex: function(predicate, context) { + var key = this.toKeyedSeq().findLastKey(predicate, context); + return key === undefined ? -1 : key; + }, + first: function() { + return this.get(0); + }, + flatten: function(depth) { + return reify(this, flattenFactory(this, depth, false)); + }, + get: function(index, notSetValue) { + index = wrapIndex(this, index); + return (index < 0 || (this.size === Infinity || (this.size !== undefined && index > this.size))) ? notSetValue : this.find((function(_, key) { + return key === index; + }), undefined, notSetValue); + }, + has: function(index) { + index = wrapIndex(this, index); + return index >= 0 && (this.size !== undefined ? this.size === Infinity || index < this.size : this.indexOf(index) !== -1); + }, + interpose: function(separator) { + return reify(this, interposeFactory(this, separator)); + }, + last: function() { + return this.get(-1); + }, + skip: function(amount) { + var iter = this; + var skipSeq = skipFactory(iter, amount, false); + if (isSeq(iter) && skipSeq !== iter) { + skipSeq.get = function(index, notSetValue) { + index = wrapIndex(this, index); + return index >= 0 ? iter.get(index + amount, notSetValue) : notSetValue; + }; + } + return reify(this, skipSeq); + }, + skipWhile: function(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, false)); + }, + take: function(amount) { + var iter = this; + var takeSeq = takeFactory(iter, amount); + if (isSeq(iter) && takeSeq !== iter) { + takeSeq.get = function(index, notSetValue) { + index = wrapIndex(this, index); + return index >= 0 && index < amount ? iter.get(index, notSetValue) : notSetValue; + }; + } + return reify(this, takeSeq); + } +}, {}, Iterable); +IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true; +var SetIterable = function SetIterable(value) { + return isIterable(value) && !isAssociative(value) ? value : SetSeq(value); +}; +($traceurRuntime.createClass)(SetIterable, { + get: function(value, notSetValue) { + return this.has(value) ? value : notSetValue; + }, + contains: function(value) { + return this.has(value); + }, + keySeq: function() { + return this.valueSeq(); + } +}, {}, Iterable); +SetIterable.prototype.has = IterablePrototype.contains; +function isIterable(maybeIterable) { + return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]); +} +function isKeyed(maybeKeyed) { + return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]); +} +function isIndexed(maybeIndexed) { + return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]); +} +function isAssociative(maybeAssociative) { + return isKeyed(maybeAssociative) || isIndexed(maybeAssociative); +} +Iterable.isIterable = isIterable; +Iterable.isKeyed = isKeyed; +Iterable.isIndexed = isIndexed; +Iterable.isAssociative = isAssociative; +Iterable.Keyed = KeyedIterable; +Iterable.Indexed = IndexedIterable; +Iterable.Set = SetIterable; +Iterable.Iterator = Iterator; +function keyMapper(v, k) { + return k; +} +function entryMapper(v, k) { + return [k, v]; +} +function not(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; +} +function neg(predicate) { + return function() { + return -predicate.apply(this, arguments); + }; +} +function quoteString(value) { + return typeof value === 'string' ? JSON.stringify(value) : value; +} +function defaultNegComparator(a, b) { + return a > b ? -1 : a < b ? 1 : 0; +} +function mixin(ctor, methods) { + var proto = ctor.prototype; + var keyCopier = (function(key) { + proto[key] = methods[key]; + }); + Object.keys(methods).forEach(keyCopier); + Object.getOwnPropertySymbols && Object.getOwnPropertySymbols(methods).forEach(keyCopier); + return ctor; +} +var Seq = function Seq(value) { + return value === null || value === undefined ? emptySequence() : isIterable(value) ? value.toSeq() : seqFromValue(value); +}; +var $Seq = Seq; +($traceurRuntime.createClass)(Seq, { + toSeq: function() { + return this; + }, + toString: function() { + return this.__toString('Seq {', '}'); + }, + cacheResult: function() { + if (!this._cache && this.__iterateUncached) { + this._cache = this.entrySeq().toArray(); + this.size = this._cache.length; + } + return this; + }, + __iterate: function(fn, reverse) { + return seqIterate(this, fn, reverse, true); + }, + __iterator: function(type, reverse) { + return seqIterator(this, type, reverse, true); + } +}, {of: function() { + return $Seq(arguments); + }}, Iterable); +var KeyedSeq = function KeyedSeq(value) { + return value === null || value === undefined ? emptySequence().toKeyedSeq() : isIterable(value) ? (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) : keyedSeqFromValue(value); +}; +var $KeyedSeq = KeyedSeq; +($traceurRuntime.createClass)(KeyedSeq, { + toKeyedSeq: function() { + return this; + }, + toSeq: function() { + return this; + } +}, {of: function() { + return $KeyedSeq(arguments); + }}, Seq); +mixin(KeyedSeq, KeyedIterable.prototype); +var IndexedSeq = function IndexedSeq(value) { + return value === null || value === undefined ? emptySequence() : !isIterable(value) ? indexedSeqFromValue(value) : isKeyed(value) ? value.entrySeq() : value.toIndexedSeq(); +}; +var $IndexedSeq = IndexedSeq; +($traceurRuntime.createClass)(IndexedSeq, { + toIndexedSeq: function() { + return this; + }, + toString: function() { + return this.__toString('Seq [', ']'); + }, + __iterate: function(fn, reverse) { + return seqIterate(this, fn, reverse, false); + }, + __iterator: function(type, reverse) { + return seqIterator(this, type, reverse, false); + } +}, {of: function() { + return $IndexedSeq(arguments); + }}, Seq); +mixin(IndexedSeq, IndexedIterable.prototype); +var SetSeq = function SetSeq(value) { + return (value === null || value === undefined ? emptySequence() : !isIterable(value) ? indexedSeqFromValue(value) : isKeyed(value) ? value.entrySeq() : value).toSetSeq(); +}; +var $SetSeq = SetSeq; +($traceurRuntime.createClass)(SetSeq, {toSetSeq: function() { + return this; + }}, {of: function() { + return $SetSeq(arguments); + }}, Seq); +mixin(SetSeq, SetIterable.prototype); +Seq.isSeq = isSeq; +Seq.Keyed = KeyedSeq; +Seq.Set = SetSeq; +Seq.Indexed = IndexedSeq; +var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@'; +Seq.prototype[IS_SEQ_SENTINEL] = true; +var ArraySeq = function ArraySeq(array) { + this._array = array; + this.size = array.length; +}; +($traceurRuntime.createClass)(ArraySeq, { + get: function(index, notSetValue) { + return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue; + }, + __iterate: function(fn, reverse) { + var array = this._array; + var maxIndex = array.length - 1; + for (var ii = 0; ii <= maxIndex; ii++) { + if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) { + return ii + 1; + } + } + return ii; + }, + __iterator: function(type, reverse) { + var array = this._array; + var maxIndex = array.length - 1; + var ii = 0; + return new Iterator((function() { + return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++]); + })); + } +}, {}, IndexedSeq); +var ObjectSeq = function ObjectSeq(object) { + var keys = Object.keys(object); + this._object = object; + this._keys = keys; + this.size = keys.length; +}; +($traceurRuntime.createClass)(ObjectSeq, { + get: function(key, notSetValue) { + if (notSetValue !== undefined && !this.has(key)) { + return notSetValue; + } + return this._object[key]; + }, + has: function(key) { + return this._object.hasOwnProperty(key); + }, + __iterate: function(fn, reverse) { + var object = this._object; + var keys = this._keys; + var maxIndex = keys.length - 1; + for (var ii = 0; ii <= maxIndex; ii++) { + var key = keys[reverse ? maxIndex - ii : ii]; + if (fn(object[key], key, this) === false) { + return ii + 1; + } + } + return ii; + }, + __iterator: function(type, reverse) { + var object = this._object; + var keys = this._keys; + var maxIndex = keys.length - 1; + var ii = 0; + return new Iterator((function() { + var key = keys[reverse ? maxIndex - ii : ii]; + return ii++ > maxIndex ? iteratorDone() : iteratorValue(type, key, object[key]); + })); + } +}, {}, KeyedSeq); +var IterableSeq = function IterableSeq(iterable) { + this._iterable = iterable; + this.size = iterable.length || iterable.size; +}; +($traceurRuntime.createClass)(IterableSeq, { + __iterateUncached: function(fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterable = this._iterable; + var iterator = getIterator(iterable); + var iterations = 0; + if (isIterator(iterator)) { + var step; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + } + return iterations; + }, + __iteratorUncached: function(type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterable = this._iterable; + var iterator = getIterator(iterable); + if (!isIterator(iterator)) { + return new Iterator(iteratorDone); + } + var iterations = 0; + return new Iterator((function() { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, iterations++, step.value); + })); + } +}, {}, IndexedSeq); +var IteratorSeq = function IteratorSeq(iterator) { + this._iterator = iterator; + this._iteratorCache = []; +}; +($traceurRuntime.createClass)(IteratorSeq, { + __iterateUncached: function(fn, reverse) { + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterator = this._iterator; + var cache = this._iteratorCache; + var iterations = 0; + while (iterations < cache.length) { + if (fn(cache[iterations], iterations++, this) === false) { + return iterations; + } + } + var step; + while (!(step = iterator.next()).done) { + var val = step.value; + cache[iterations] = val; + if (fn(val, iterations++, this) === false) { + break; + } + } + return iterations; + }, + __iteratorUncached: function(type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = this._iterator; + var cache = this._iteratorCache; + var iterations = 0; + return new Iterator((function() { + if (iterations >= cache.length) { + var step = iterator.next(); + if (step.done) { + return step; + } + cache[iterations] = step.value; + } + return iteratorValue(type, iterations, cache[iterations++]); + })); + } +}, {}, IndexedSeq); +function isSeq(maybeSeq) { + return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]); +} +var EMPTY_SEQ; +function emptySequence() { + return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([])); +} +function keyedSeqFromValue(value) { + var seq = Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() : isIterator(value) ? new IteratorSeq(value).fromEntrySeq() : hasIterator(value) ? new IterableSeq(value).fromEntrySeq() : typeof value === 'object' ? new ObjectSeq(value) : undefined; + if (!seq) { + throw new TypeError('Expected Array or iterable object of [k, v] entries, ' + 'or keyed object: ' + value); + } + return seq; +} +function indexedSeqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value); + if (!seq) { + throw new TypeError('Expected Array or iterable object of values: ' + value); + } + return seq; +} +function seqFromValue(value) { + var seq = maybeIndexedSeqFromValue(value) || (typeof value === 'object' && new ObjectSeq(value)); + if (!seq) { + throw new TypeError('Expected Array or iterable object of values, or keyed object: ' + value); + } + return seq; +} +function maybeIndexedSeqFromValue(value) { + return (isArrayLike(value) ? new ArraySeq(value) : isIterator(value) ? new IteratorSeq(value) : hasIterator(value) ? new IterableSeq(value) : undefined); +} +function isArrayLike(value) { + return value && typeof value.length === 'number'; +} +function seqIterate(seq, fn, reverse, useKeys) { + assertNotInfinite(seq.size); + var cache = seq._cache; + if (cache) { + var maxIndex = cache.length - 1; + for (var ii = 0; ii <= maxIndex; ii++) { + var entry = cache[reverse ? maxIndex - ii : ii]; + if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) { + return ii + 1; + } + } + return ii; + } + return seq.__iterateUncached(fn, reverse); +} +function seqIterator(seq, type, reverse, useKeys) { + var cache = seq._cache; + if (cache) { + var maxIndex = cache.length - 1; + var ii = 0; + return new Iterator((function() { + var entry = cache[reverse ? maxIndex - ii : ii]; + return ii++ > maxIndex ? iteratorDone() : iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]); + })); + } + return seq.__iteratorUncached(type, reverse); +} +function fromJS(json, converter) { + return converter ? _fromJSWith(converter, json, '', {'': json}) : _fromJSDefault(json); +} +function _fromJSWith(converter, json, key, parentJSON) { + if (Array.isArray(json)) { + return converter.call(parentJSON, key, IndexedSeq(json).map((function(v, k) { + return _fromJSWith(converter, v, k, json); + }))); + } + if (isPlainObj(json)) { + return converter.call(parentJSON, key, KeyedSeq(json).map((function(v, k) { + return _fromJSWith(converter, v, k, json); + }))); + } + return json; +} +function _fromJSDefault(json) { + if (Array.isArray(json)) { + return IndexedSeq(json).map(_fromJSDefault).toList(); + } + if (isPlainObj(json)) { + return KeyedSeq(json).map(_fromJSDefault).toMap(); + } + return json; +} +function isPlainObj(value) { + return value && value.constructor === Object; +} +var Collection = function Collection() { + throw TypeError('Abstract'); +}; +($traceurRuntime.createClass)(Collection, {}, {}, Iterable); +var KeyedCollection = function KeyedCollection() { + $traceurRuntime.defaultSuperCall(this, $KeyedCollection.prototype, arguments); +}; +var $KeyedCollection = KeyedCollection; +($traceurRuntime.createClass)(KeyedCollection, {}, {}, Collection); +mixin(KeyedCollection, KeyedIterable.prototype); +var IndexedCollection = function IndexedCollection() { + $traceurRuntime.defaultSuperCall(this, $IndexedCollection.prototype, arguments); +}; +var $IndexedCollection = IndexedCollection; +($traceurRuntime.createClass)(IndexedCollection, {}, {}, Collection); +mixin(IndexedCollection, IndexedIterable.prototype); +var SetCollection = function SetCollection() { + $traceurRuntime.defaultSuperCall(this, $SetCollection.prototype, arguments); +}; +var $SetCollection = SetCollection; +($traceurRuntime.createClass)(SetCollection, {}, {}, Collection); +mixin(SetCollection, SetIterable.prototype); +Collection.Keyed = KeyedCollection; +Collection.Indexed = IndexedCollection; +Collection.Set = SetCollection; +var Map = function Map(value) { + return value === null || value === undefined ? emptyMap() : isMap(value) ? value : emptyMap().merge(KeyedIterable(value)); +}; +($traceurRuntime.createClass)(Map, { + toString: function() { + return this.__toString('Map {', '}'); + }, + get: function(k, notSetValue) { + return this._root ? this._root.get(0, undefined, k, notSetValue) : notSetValue; + }, + set: function(k, v) { + return updateMap(this, k, v); + }, + setIn: function(keyPath, v) { + invariant(keyPath.length > 0, 'Requires non-empty key path.'); + return this.updateIn(keyPath, (function() { + return v; + })); + }, + remove: function(k) { + return updateMap(this, k, NOT_SET); + }, + removeIn: function(keyPath) { + invariant(keyPath.length > 0, 'Requires non-empty key path.'); + return this.updateIn(keyPath, (function() { + return NOT_SET; + })); + }, + update: function(k, notSetValue, updater) { + return arguments.length === 1 ? k(this) : this.updateIn([k], notSetValue, updater); + }, + updateIn: function(keyPath, notSetValue, updater) { + if (!updater) { + updater = notSetValue; + notSetValue = undefined; + } + return keyPath.length === 0 ? updater(this) : updateInDeepMap(this, keyPath, notSetValue, updater, 0); + }, + clear: function() { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._root = null; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyMap(); + }, + merge: function() { + return mergeIntoMapWith(this, undefined, arguments); + }, + mergeWith: function(merger) { + for (var iters = [], + $__3 = 1; $__3 < arguments.length; $__3++) + iters[$__3 - 1] = arguments[$__3]; + return mergeIntoMapWith(this, merger, iters); + }, + mergeDeep: function() { + return mergeIntoMapWith(this, deepMerger(undefined), arguments); + }, + mergeDeepWith: function(merger) { + for (var iters = [], + $__4 = 1; $__4 < arguments.length; $__4++) + iters[$__4 - 1] = arguments[$__4]; + return mergeIntoMapWith(this, deepMerger(merger), iters); + }, + sort: function(comparator) { + return OrderedMap(sortFactory(this, comparator)); + }, + sortBy: function(mapper, comparator) { + return OrderedMap(sortFactory(this, comparator, mapper)); + }, + withMutations: function(fn) { + var mutable = this.asMutable(); + fn(mutable); + return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this; + }, + asMutable: function() { + return this.__ownerID ? this : this.__ensureOwner(new OwnerID()); + }, + asImmutable: function() { + return this.__ensureOwner(); + }, + wasAltered: function() { + return this.__altered; + }, + __iterator: function(type, reverse) { + return new MapIterator(this, type, reverse); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + var iterations = 0; + this._root && this._root.iterate((function(entry) { + iterations++; + return fn(entry[1], entry[0], $__0); + }), reverse); + return iterations; + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeMap(this.size, this._root, ownerID, this.__hash); + } +}, {}, KeyedCollection); +function isMap(maybeMap) { + return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]); +} +Map.isMap = isMap; +var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@'; +var MapPrototype = Map.prototype; +MapPrototype[IS_MAP_SENTINEL] = true; +MapPrototype[DELETE] = MapPrototype.remove; +var ArrayMapNode = function ArrayMapNode(ownerID, entries) { + this.ownerID = ownerID; + this.entries = entries; +}; +var $ArrayMapNode = ArrayMapNode; +($traceurRuntime.createClass)(ArrayMapNode, { + get: function(shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, + len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; + }, + update: function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + var entries = this.entries; + var idx = 0; + for (var len = entries.length; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + if (exists ? entries[idx][1] === value : removed) { + return this; + } + SetRef(didAlter); + (removed || !exists) && SetRef(didChangeSize); + if (removed && entries.length === 1) { + return; + } + if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) { + return createNodes(ownerID, entries, key, value); + } + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + if (exists) { + if (removed) { + idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + if (isEditable) { + this.entries = newEntries; + return this; + } + return new $ArrayMapNode(ownerID, newEntries); + } +}, {}); +var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) { + this.ownerID = ownerID; + this.bitmap = bitmap; + this.nodes = nodes; +}; +var $BitmapIndexedNode = BitmapIndexedNode; +($traceurRuntime.createClass)(BitmapIndexedNode, { + get: function(shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK)); + var bitmap = this.bitmap; + return (bitmap & bit) === 0 ? notSetValue : this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue); + }, + update: function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var bit = 1 << keyHashFrag; + var bitmap = this.bitmap; + var exists = (bitmap & bit) !== 0; + if (!exists && value === NOT_SET) { + return this; + } + var idx = popCount(bitmap & (bit - 1)); + var nodes = this.nodes; + var node = exists ? nodes[idx] : undefined; + var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter); + if (newNode === node) { + return this; + } + if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) { + return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode); + } + if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) { + return nodes[idx ^ 1]; + } + if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) { + return newNode; + } + var isEditable = ownerID && ownerID === this.ownerID; + var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit; + var newNodes = exists ? newNode ? setIn(nodes, idx, newNode, isEditable) : spliceOut(nodes, idx, isEditable) : spliceIn(nodes, idx, newNode, isEditable); + if (isEditable) { + this.bitmap = newBitmap; + this.nodes = newNodes; + return this; + } + return new $BitmapIndexedNode(ownerID, newBitmap, newNodes); + } +}, {}); +var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) { + this.ownerID = ownerID; + this.count = count; + this.nodes = nodes; +}; +var $HashArrayMapNode = HashArrayMapNode; +($traceurRuntime.createClass)(HashArrayMapNode, { + get: function(shift, keyHash, key, notSetValue) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var node = this.nodes[idx]; + return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue; + }, + update: function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var removed = value === NOT_SET; + var nodes = this.nodes; + var node = nodes[idx]; + if (removed && !node) { + return this; + } + var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter); + if (newNode === node) { + return this; + } + var newCount = this.count; + if (!node) { + newCount++; + } else if (!newNode) { + newCount--; + if (newCount < MIN_HASH_ARRAY_MAP_SIZE) { + return packNodes(ownerID, nodes, newCount, idx); + } + } + var isEditable = ownerID && ownerID === this.ownerID; + var newNodes = setIn(nodes, idx, newNode, isEditable); + if (isEditable) { + this.count = newCount; + this.nodes = newNodes; + return this; + } + return new $HashArrayMapNode(ownerID, newCount, newNodes); + } +}, {}); +var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entries = entries; +}; +var $HashCollisionNode = HashCollisionNode; +($traceurRuntime.createClass)(HashCollisionNode, { + get: function(shift, keyHash, key, notSetValue) { + var entries = this.entries; + for (var ii = 0, + len = entries.length; ii < len; ii++) { + if (is(key, entries[ii][0])) { + return entries[ii][1]; + } + } + return notSetValue; + }, + update: function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (keyHash === undefined) { + keyHash = hash(key); + } + var removed = value === NOT_SET; + if (keyHash !== this.keyHash) { + if (removed) { + return this; + } + SetRef(didAlter); + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]); + } + var entries = this.entries; + var idx = 0; + for (var len = entries.length; idx < len; idx++) { + if (is(key, entries[idx][0])) { + break; + } + } + var exists = idx < len; + if (exists ? entries[idx][1] === value : removed) { + return this; + } + SetRef(didAlter); + (removed || !exists) && SetRef(didChangeSize); + if (removed && len === 2) { + return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]); + } + var isEditable = ownerID && ownerID === this.ownerID; + var newEntries = isEditable ? entries : arrCopy(entries); + if (exists) { + if (removed) { + idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop()); + } else { + newEntries[idx] = [key, value]; + } + } else { + newEntries.push([key, value]); + } + if (isEditable) { + this.entries = newEntries; + return this; + } + return new $HashCollisionNode(ownerID, this.keyHash, newEntries); + } +}, {}); +var ValueNode = function ValueNode(ownerID, keyHash, entry) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entry = entry; +}; +var $ValueNode = ValueNode; +($traceurRuntime.createClass)(ValueNode, { + get: function(shift, keyHash, key, notSetValue) { + return is(key, this.entry[0]) ? this.entry[1] : notSetValue; + }, + update: function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + var removed = value === NOT_SET; + var keyMatch = is(key, this.entry[0]); + if (keyMatch ? value === this.entry[1] : removed) { + return this; + } + SetRef(didAlter); + if (removed) { + SetRef(didChangeSize); + return; + } + if (keyMatch) { + if (ownerID && ownerID === this.ownerID) { + this.entry[1] = value; + return this; + } + return new $ValueNode(ownerID, this.keyHash, [key, value]); + } + SetRef(didChangeSize); + return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]); + } +}, {}); +ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(fn, reverse) { + var entries = this.entries; + for (var ii = 0, + maxIndex = entries.length - 1; ii <= maxIndex; ii++) { + if (fn(entries[reverse ? maxIndex - ii : ii]) === false) { + return false; + } + } +}; +BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(fn, reverse) { + var nodes = this.nodes; + for (var ii = 0, + maxIndex = nodes.length - 1; ii <= maxIndex; ii++) { + var node = nodes[reverse ? maxIndex - ii : ii]; + if (node && node.iterate(fn, reverse) === false) { + return false; + } + } +}; +ValueNode.prototype.iterate = function(fn, reverse) { + return fn(this.entry); +}; +var MapIterator = function MapIterator(map, type, reverse) { + this._type = type; + this._reverse = reverse; + this._stack = map._root && mapIteratorFrame(map._root); +}; +($traceurRuntime.createClass)(MapIterator, {next: function() { + var type = this._type; + var stack = this._stack; + while (stack) { + var node = stack.node; + var index = stack.index++; + var maxIndex; + if (node.entry) { + if (index === 0) { + return mapIteratorValue(type, node.entry); + } + } else if (node.entries) { + maxIndex = node.entries.length - 1; + if (index <= maxIndex) { + return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]); + } + } else { + maxIndex = node.nodes.length - 1; + if (index <= maxIndex) { + var subNode = node.nodes[this._reverse ? maxIndex - index : index]; + if (subNode) { + if (subNode.entry) { + return mapIteratorValue(type, subNode.entry); + } + stack = this._stack = mapIteratorFrame(subNode, stack); + } + continue; + } + } + stack = this._stack = this._stack.__prev; + } + return iteratorDone(); + }}, {}, Iterator); +function mapIteratorValue(type, entry) { + return iteratorValue(type, entry[0], entry[1]); +} +function mapIteratorFrame(node, prev) { + return { + node: node, + index: 0, + __prev: prev + }; +} +function makeMap(size, root, ownerID, hash) { + var map = Object.create(MapPrototype); + map.size = size; + map._root = root; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; +} +var EMPTY_MAP; +function emptyMap() { + return EMPTY_MAP || (EMPTY_MAP = makeMap(0)); +} +function updateMap(map, k, v) { + var newRoot; + var newSize; + if (!map._root) { + if (v === NOT_SET) { + return map; + } + newSize = 1; + newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]); + } else { + var didChangeSize = MakeRef(CHANGE_LENGTH); + var didAlter = MakeRef(DID_ALTER); + newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter); + if (!didAlter.value) { + return map; + } + newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0); + } + if (map.__ownerID) { + map.size = newSize; + map._root = newRoot; + map.__hash = undefined; + map.__altered = true; + return map; + } + return newRoot ? makeMap(newSize, newRoot) : emptyMap(); +} +function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) { + if (!node) { + if (value === NOT_SET) { + return node; + } + SetRef(didAlter); + SetRef(didChangeSize); + return new ValueNode(ownerID, keyHash, [key, value]); + } + return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter); +} +function isLeafNode(node) { + return node.constructor === ValueNode || node.constructor === HashCollisionNode; +} +function mergeIntoNode(node, ownerID, shift, keyHash, entry) { + if (node.keyHash === keyHash) { + return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]); + } + var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK; + var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK; + var newNode; + var nodes = idx1 === idx2 ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] : ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]); + return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes); +} +function createNodes(ownerID, entries, key, value) { + if (!ownerID) { + ownerID = new OwnerID(); + } + var node = new ValueNode(ownerID, hash(key), [key, value]); + for (var ii = 0; ii < entries.length; ii++) { + var entry = entries[ii]; + node = node.update(ownerID, 0, undefined, entry[0], entry[1]); + } + return node; +} +function packNodes(ownerID, nodes, count, excluding) { + var bitmap = 0; + var packedII = 0; + var packedNodes = new Array(count); + for (var ii = 0, + bit = 1, + len = nodes.length; ii < len; ii++, bit <<= 1) { + var node = nodes[ii]; + if (node !== undefined && ii !== excluding) { + bitmap |= bit; + packedNodes[packedII++] = node; + } + } + return new BitmapIndexedNode(ownerID, bitmap, packedNodes); +} +function expandNodes(ownerID, nodes, bitmap, including, node) { + var count = 0; + var expandedNodes = new Array(SIZE); + for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) { + expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined; + } + expandedNodes[including] = node; + return new HashArrayMapNode(ownerID, count + 1, expandedNodes); +} +function mergeIntoMapWith(map, merger, iterables) { + var iters = []; + for (var ii = 0; ii < iterables.length; ii++) { + var value = iterables[ii]; + var iter = KeyedIterable(value); + if (!isIterable(value)) { + iter = iter.map((function(v) { + return fromJS(v); + })); + } + iters.push(iter); + } + return mergeIntoCollectionWith(map, merger, iters); +} +function deepMerger(merger) { + return (function(existing, value) { + return existing && existing.mergeDeepWith && isIterable(value) ? existing.mergeDeepWith(merger, value) : merger ? merger(existing, value) : value; + }); +} +function mergeIntoCollectionWith(collection, merger, iters) { + if (iters.length === 0) { + return collection; + } + return collection.withMutations((function(collection) { + var mergeIntoMap = merger ? (function(value, key) { + collection.update(key, NOT_SET, (function(existing) { + return existing === NOT_SET ? value : merger(existing, value); + })); + }) : (function(value, key) { + collection.set(key, value); + }); + for (var ii = 0; ii < iters.length; ii++) { + iters[ii].forEach(mergeIntoMap); + } + })); +} +function updateInDeepMap(collection, keyPath, notSetValue, updater, offset) { + invariant(!collection || collection.set, 'updateIn with invalid keyPath'); + var key = keyPath[offset]; + var existing = collection ? collection.get(key, NOT_SET) : NOT_SET; + var existingValue = existing === NOT_SET ? undefined : existing; + var value = offset === keyPath.length - 1 ? updater(existing === NOT_SET ? notSetValue : existing) : updateInDeepMap(existingValue, keyPath, notSetValue, updater, offset + 1); + return value === existingValue ? collection : value === NOT_SET ? collection && collection.remove(key) : (collection || emptyMap()).set(key, value); +} +function popCount(x) { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0f0f0f0f; + x = x + (x >> 8); + x = x + (x >> 16); + return x & 0x7f; +} +function setIn(array, idx, val, canEdit) { + var newArray = canEdit ? array : arrCopy(array); + newArray[idx] = val; + return newArray; +} +function spliceIn(array, idx, val, canEdit) { + var newLen = array.length + 1; + if (canEdit && idx + 1 === newLen) { + array[idx] = val; + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + newArray[ii] = val; + after = -1; + } else { + newArray[ii] = array[ii + after]; + } + } + return newArray; +} +function spliceOut(array, idx, canEdit) { + var newLen = array.length - 1; + if (canEdit && idx === newLen) { + array.pop(); + return array; + } + var newArray = new Array(newLen); + var after = 0; + for (var ii = 0; ii < newLen; ii++) { + if (ii === idx) { + after = 1; + } + newArray[ii] = array[ii + after]; + } + return newArray; +} +var MAX_ARRAY_MAP_SIZE = SIZE / 4; +var MAX_BITMAP_INDEXED_SIZE = SIZE / 2; +var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4; +var ToKeyedSequence = function ToKeyedSequence(indexed, useKeys) { + this._iter = indexed; + this._useKeys = useKeys; + this.size = indexed.size; +}; +($traceurRuntime.createClass)(ToKeyedSequence, { + get: function(key, notSetValue) { + return this._iter.get(key, notSetValue); + }, + has: function(key) { + return this._iter.has(key); + }, + valueSeq: function() { + return this._iter.valueSeq(); + }, + reverse: function() { + var $__0 = this; + var reversedSequence = reverseFactory(this, true); + if (!this._useKeys) { + reversedSequence.valueSeq = (function() { + return $__0._iter.toSeq().reverse(); + }); + } + return reversedSequence; + }, + map: function(mapper, context) { + var $__0 = this; + var mappedSequence = mapFactory(this, mapper, context); + if (!this._useKeys) { + mappedSequence.valueSeq = (function() { + return $__0._iter.toSeq().map(mapper, context); + }); + } + return mappedSequence; + }, + __iterate: function(fn, reverse) { + var $__0 = this; + var ii; + return this._iter.__iterate(this._useKeys ? (function(v, k) { + return fn(v, k, $__0); + }) : ((ii = reverse ? resolveSize(this) : 0), (function(v) { + return fn(v, reverse ? --ii : ii++, $__0); + })), reverse); + }, + __iterator: function(type, reverse) { + if (this._useKeys) { + return this._iter.__iterator(type, reverse); + } + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + var ii = reverse ? resolveSize(this) : 0; + return new Iterator((function() { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, reverse ? --ii : ii++, step.value, step); + })); + } +}, {}, KeyedSeq); +var ToIndexedSequence = function ToIndexedSequence(iter) { + this._iter = iter; + this.size = iter.size; +}; +($traceurRuntime.createClass)(ToIndexedSequence, { + contains: function(value) { + return this._iter.contains(value); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + var iterations = 0; + return this._iter.__iterate((function(v) { + return fn(v, iterations++, $__0); + }), reverse); + }, + __iterator: function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + return new Iterator((function() { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, iterations++, step.value, step); + })); + } +}, {}, IndexedSeq); +var ToSetSequence = function ToSetSequence(iter) { + this._iter = iter; + this.size = iter.size; +}; +($traceurRuntime.createClass)(ToSetSequence, { + has: function(key) { + return this._iter.contains(key); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + return this._iter.__iterate((function(v) { + return fn(v, v, $__0); + }), reverse); + }, + __iterator: function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator((function() { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, step.value, step.value, step); + })); + } +}, {}, SetSeq); +var FromEntriesSequence = function FromEntriesSequence(entries) { + this._iter = entries; + this.size = entries.size; +}; +($traceurRuntime.createClass)(FromEntriesSequence, { + entrySeq: function() { + return this._iter.toSeq(); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + return this._iter.__iterate((function(entry) { + if (entry) { + validateEntry(entry); + return fn(entry[1], entry[0], $__0); + } + }), reverse); + }, + __iterator: function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new Iterator((function() { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + if (entry) { + validateEntry(entry); + return type === ITERATE_ENTRIES ? step : iteratorValue(type, entry[0], entry[1], step); + } + } + })); + } +}, {}, KeyedSeq); +ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough; +function flipFactory(iterable) { + var flipSequence = makeSequence(iterable); + flipSequence._iter = iterable; + flipSequence.size = iterable.size; + flipSequence.flip = (function() { + return iterable; + }); + flipSequence.reverse = function() { + var reversedSequence = iterable.reverse.apply(this); + reversedSequence.flip = (function() { + return iterable.reverse(); + }); + return reversedSequence; + }; + flipSequence.has = (function(key) { + return iterable.contains(key); + }); + flipSequence.contains = (function(key) { + return iterable.has(key); + }); + flipSequence.cacheResult = cacheResultThrough; + flipSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + return iterable.__iterate((function(v, k) { + return fn(k, v, $__0) !== false; + }), reverse); + }; + flipSequence.__iteratorUncached = function(type, reverse) { + if (type === ITERATE_ENTRIES) { + var iterator = iterable.__iterator(type, reverse); + return new Iterator((function() { + var step = iterator.next(); + if (!step.done) { + var k = step.value[0]; + step.value[0] = step.value[1]; + step.value[1] = k; + } + return step; + })); + } + return iterable.__iterator(type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES, reverse); + }; + return flipSequence; +} +function mapFactory(iterable, mapper, context) { + var mappedSequence = makeSequence(iterable); + mappedSequence.size = iterable.size; + mappedSequence.has = (function(key) { + return iterable.has(key); + }); + mappedSequence.get = (function(key, notSetValue) { + var v = iterable.get(key, NOT_SET); + return v === NOT_SET ? notSetValue : mapper.call(context, v, key, iterable); + }); + mappedSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + return iterable.__iterate((function(v, k, c) { + return fn(mapper.call(context, v, k, c), k, $__0) !== false; + }), reverse); + }; + mappedSequence.__iteratorUncached = function(type, reverse) { + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + return new Iterator((function() { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + return iteratorValue(type, key, mapper.call(context, entry[1], key, iterable), step); + })); + }; + return mappedSequence; +} +function reverseFactory(iterable, useKeys) { + var reversedSequence = makeSequence(iterable); + reversedSequence._iter = iterable; + reversedSequence.size = iterable.size; + reversedSequence.reverse = (function() { + return iterable; + }); + if (iterable.flip) { + reversedSequence.flip = function() { + var flipSequence = flipFactory(iterable); + flipSequence.reverse = (function() { + return iterable.flip(); + }); + return flipSequence; + }; + } + reversedSequence.get = (function(key, notSetValue) { + return iterable.get(useKeys ? key : -1 - key, notSetValue); + }); + reversedSequence.has = (function(key) { + return iterable.has(useKeys ? key : -1 - key); + }); + reversedSequence.contains = (function(value) { + return iterable.contains(value); + }); + reversedSequence.cacheResult = cacheResultThrough; + reversedSequence.__iterate = function(fn, reverse) { + var $__0 = this; + return iterable.__iterate((function(v, k) { + return fn(v, k, $__0); + }), !reverse); + }; + reversedSequence.__iterator = (function(type, reverse) { + return iterable.__iterator(type, !reverse); + }); + return reversedSequence; +} +function filterFactory(iterable, predicate, context, useKeys) { + var filterSequence = makeSequence(iterable); + if (useKeys) { + filterSequence.has = (function(key) { + var v = iterable.get(key, NOT_SET); + return v !== NOT_SET && !!predicate.call(context, v, key, iterable); + }); + filterSequence.get = (function(key, notSetValue) { + var v = iterable.get(key, NOT_SET); + return v !== NOT_SET && predicate.call(context, v, key, iterable) ? v : notSetValue; + }); + } + filterSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + var iterations = 0; + iterable.__iterate((function(v, k, c) { + if (predicate.call(context, v, k, c)) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, $__0); + } + }), reverse); + return iterations; + }; + filterSequence.__iteratorUncached = function(type, reverse) { + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + var iterations = 0; + return new Iterator((function() { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var key = entry[0]; + var value = entry[1]; + if (predicate.call(context, value, key, iterable)) { + return iteratorValue(type, useKeys ? key : iterations++, value, step); + } + } + })); + }; + return filterSequence; +} +function countByFactory(iterable, grouper, context) { + var groups = Map().asMutable(); + iterable.__iterate((function(v, k) { + groups.update(grouper.call(context, v, k, iterable), 0, (function(a) { + return a + 1; + })); + })); + return groups.asImmutable(); +} +function groupByFactory(iterable, grouper, context) { + var isKeyedIter = isKeyed(iterable); + var groups = Map().asMutable(); + iterable.__iterate((function(v, k) { + groups.update(grouper.call(context, v, k, iterable), [], (function(a) { + return (a.push(isKeyedIter ? [k, v] : v), a); + })); + })); + var coerce = iterableClass(iterable); + return groups.map((function(arr) { + return reify(iterable, coerce(arr)); + })); +} +function takeFactory(iterable, amount) { + if (amount > iterable.size) { + return iterable; + } + if (amount < 0) { + amount = 0; + } + var takeSequence = makeSequence(iterable); + takeSequence.size = iterable.size && Math.min(iterable.size, amount); + takeSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + if (amount === 0) { + return 0; + } + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + iterable.__iterate((function(v, k) { + return ++iterations && fn(v, k, $__0) !== false && iterations < amount; + })); + return iterations; + }; + takeSequence.__iteratorUncached = function(type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = amount && iterable.__iterator(type, reverse); + var iterations = 0; + return new Iterator((function() { + if (iterations++ > amount) { + return iteratorDone(); + } + return iterator.next(); + })); + }; + return takeSequence; +} +function takeWhileFactory(iterable, predicate, context) { + var takeSequence = makeSequence(iterable); + takeSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var iterations = 0; + iterable.__iterate((function(v, k, c) { + return predicate.call(context, v, k, c) && ++iterations && fn(v, k, $__0); + })); + return iterations; + }; + takeSequence.__iteratorUncached = function(type, reverse) { + var $__0 = this; + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + var iterating = true; + return new Iterator((function() { + if (!iterating) { + return iteratorDone(); + } + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + var k = entry[0]; + var v = entry[1]; + if (!predicate.call(context, v, k, $__0)) { + iterating = false; + return iteratorDone(); + } + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + })); + }; + return takeSequence; +} +function skipFactory(iterable, amount, useKeys) { + if (amount <= 0) { + return iterable; + } + var skipSequence = makeSequence(iterable); + skipSequence.size = iterable.size && Math.max(0, iterable.size - amount); + skipSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var skipped = 0; + var isSkipping = true; + var iterations = 0; + iterable.__iterate((function(v, k) { + if (!(isSkipping && (isSkipping = skipped++ < amount))) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, $__0); + } + })); + return iterations; + }; + skipSequence.__iteratorUncached = function(type, reverse) { + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = amount && iterable.__iterator(type, reverse); + var skipped = 0; + var iterations = 0; + return new Iterator((function() { + while (skipped < amount) { + skipped++; + iterator.next(); + } + var step = iterator.next(); + if (useKeys || type === ITERATE_VALUES) { + return step; + } else if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations++, undefined, step); + } else { + return iteratorValue(type, iterations++, step.value[1], step); + } + })); + }; + return skipSequence; +} +function skipWhileFactory(iterable, predicate, context, useKeys) { + var skipSequence = makeSequence(iterable); + skipSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + if (reverse) { + return this.cacheResult().__iterate(fn, reverse); + } + var isSkipping = true; + var iterations = 0; + iterable.__iterate((function(v, k, c) { + if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, $__0); + } + })); + return iterations; + }; + skipSequence.__iteratorUncached = function(type, reverse) { + var $__0 = this; + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + var skipping = true; + var iterations = 0; + return new Iterator((function() { + var step, + k, + v; + do { + step = iterator.next(); + if (step.done) { + if (useKeys || type === ITERATE_VALUES) { + return step; + } else if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations++, undefined, step); + } else { + return iteratorValue(type, iterations++, step.value[1], step); + } + } + var entry = step.value; + k = entry[0]; + v = entry[1]; + skipping && (skipping = predicate.call(context, v, k, $__0)); + } while (skipping); + return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step); + })); + }; + return skipSequence; +} +function concatFactory(iterable, values) { + var isKeyedIterable = isKeyed(iterable); + var iters = new ArraySeq([iterable].concat(values)).map((function(v) { + if (!isIterable(v)) { + v = isKeyedIterable ? keyedSeqFromValue(v) : indexedSeqFromValue(Array.isArray(v) ? v : [v]); + } else if (isKeyedIterable) { + v = KeyedIterable(v); + } + return v; + })); + if (isKeyedIterable) { + iters = iters.toKeyedSeq(); + } else if (!isIndexed(iterable)) { + iters = iters.toSetSeq(); + } + var flat = iters.flatten(true); + flat.size = iters.reduce((function(sum, seq) { + if (sum !== undefined) { + var size = seq.size; + if (size !== undefined) { + return sum + size; + } + } + }), 0); + return flat; +} +function flattenFactory(iterable, depth, useKeys) { + var flatSequence = makeSequence(iterable); + flatSequence.__iterateUncached = function(fn, reverse) { + var iterations = 0; + var stopped = false; + function flatDeep(iter, currentDepth) { + var $__0 = this; + iter.__iterate((function(v, k) { + if ((!depth || currentDepth < depth) && isIterable(v)) { + flatDeep(v, currentDepth + 1); + } else if (fn(v, useKeys ? k : iterations++, $__0) === false) { + stopped = true; + } + return !stopped; + }), reverse); + } + flatDeep(iterable, 0); + return iterations; + }; + flatSequence.__iteratorUncached = function(type, reverse) { + var iterator = iterable.__iterator(type, reverse); + var stack = []; + var iterations = 0; + return new Iterator((function() { + while (iterator) { + var step = iterator.next(); + if (step.done !== false) { + iterator = stack.pop(); + continue; + } + var v = step.value; + if (type === ITERATE_ENTRIES) { + v = v[1]; + } + if ((!depth || stack.length < depth) && isIterable(v)) { + stack.push(iterator); + iterator = v.__iterator(type, reverse); + } else { + return useKeys ? step : iteratorValue(type, iterations++, v, step); + } + } + return iteratorDone(); + })); + }; + return flatSequence; +} +function flatMapFactory(iterable, mapper, context) { + var coerce = iterableClass(iterable); + return iterable.toSeq().map((function(v, k) { + return coerce(mapper.call(context, v, k, iterable)); + })).flatten(true); +} +function interposeFactory(iterable, separator) { + var interposedSequence = makeSequence(iterable); + interposedSequence.size = iterable.size && iterable.size * 2 - 1; + interposedSequence.__iterateUncached = function(fn, reverse) { + var $__0 = this; + var iterations = 0; + iterable.__iterate((function(v, k) { + return (!iterations || fn(separator, iterations++, $__0) !== false) && fn(v, iterations++, $__0) !== false; + }), reverse); + return iterations; + }; + interposedSequence.__iteratorUncached = function(type, reverse) { + var iterator = iterable.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + var step; + return new Iterator((function() { + if (!step || iterations % 2) { + step = iterator.next(); + if (step.done) { + return step; + } + } + return iterations % 2 ? iteratorValue(type, iterations++, separator) : iteratorValue(type, iterations++, step.value, step); + })); + }; + return interposedSequence; +} +function sortFactory(iterable, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + var isKeyedIterable = isKeyed(iterable); + var index = 0; + var entries = iterable.toSeq().map((function(v, k) { + return [k, v, index++, mapper ? mapper(v, k, iterable) : v]; + })).toArray(); + entries.sort((function(a, b) { + return comparator(a[3], b[3]) || a[2] - b[2]; + })).forEach(isKeyedIterable ? (function(v, i) { + entries[i].length = 2; + }) : (function(v, i) { + entries[i] = v[1]; + })); + return isKeyedIterable ? KeyedSeq(entries) : isIndexed(iterable) ? IndexedSeq(entries) : SetSeq(entries); +} +function maxFactory(iterable, comparator, mapper) { + if (!comparator) { + comparator = defaultComparator; + } + if (mapper) { + var entry = iterable.toSeq().map((function(v, k) { + return [v, mapper(v, k, iterable)]; + })).reduce((function(max, next) { + return comparator(next[1], max[1]) > 0 ? next : max; + })); + return entry && entry[0]; + } else { + return iterable.reduce((function(max, next) { + return comparator(next, max) > 0 ? next : max; + })); + } +} +function reify(iter, seq) { + return isSeq(iter) ? seq : iter.constructor(seq); +} +function validateEntry(entry) { + if (entry !== Object(entry)) { + throw new TypeError('Expected [K, V] tuple: ' + entry); + } +} +function resolveSize(iter) { + assertNotInfinite(iter.size); + return ensureSize(iter); +} +function iterableClass(iterable) { + return isKeyed(iterable) ? KeyedIterable : isIndexed(iterable) ? IndexedIterable : SetIterable; +} +function makeSequence(iterable) { + return Object.create((isKeyed(iterable) ? KeyedSeq : isIndexed(iterable) ? IndexedSeq : SetSeq).prototype); +} +function cacheResultThrough() { + if (this._iter.cacheResult) { + this._iter.cacheResult(); + this.size = this._iter.size; + return this; + } else { + return Seq.prototype.cacheResult.call(this); + } +} +function defaultComparator(a, b) { + return a > b ? 1 : a < b ? -1 : 0; +} +var List = function List(value) { + var empty = emptyList(); + if (value === null || value === undefined) { + return empty; + } + if (isList(value)) { + return value; + } + value = IndexedIterable(value); + var size = value.size; + if (size === 0) { + return empty; + } + if (size > 0 && size < SIZE) { + return makeList(0, size, SHIFT, null, new VNode(value.toArray())); + } + return empty.merge(value); +}; +($traceurRuntime.createClass)(List, { + toString: function() { + return this.__toString('List [', ']'); + }, + get: function(index, notSetValue) { + index = wrapIndex(this, index); + if (index < 0 || index >= this.size) { + return notSetValue; + } + index += this._origin; + var node = listNodeFor(this, index); + return node && node.array[index & MASK]; + }, + set: function(index, value) { + return updateList(this, index, value); + }, + remove: function(index) { + return !this.has(index) ? this : index === 0 ? this.shift() : index === this.size - 1 ? this.pop() : this.splice(index, 1); + }, + clear: function() { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = this._origin = this._capacity = 0; + this._level = SHIFT; + this._root = this._tail = null; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyList(); + }, + push: function() { + var values = arguments; + var oldSize = this.size; + return this.withMutations((function(list) { + setListBounds(list, 0, oldSize + values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(oldSize + ii, values[ii]); + } + })); + }, + pop: function() { + return setListBounds(this, 0, -1); + }, + unshift: function() { + var values = arguments; + return this.withMutations((function(list) { + setListBounds(list, -values.length); + for (var ii = 0; ii < values.length; ii++) { + list.set(ii, values[ii]); + } + })); + }, + shift: function() { + return setListBounds(this, 1); + }, + merge: function() { + return mergeIntoListWith(this, undefined, arguments); + }, + mergeWith: function(merger) { + for (var iters = [], + $__5 = 1; $__5 < arguments.length; $__5++) + iters[$__5 - 1] = arguments[$__5]; + return mergeIntoListWith(this, merger, iters); + }, + mergeDeep: function() { + return mergeIntoListWith(this, deepMerger(undefined), arguments); + }, + mergeDeepWith: function(merger) { + for (var iters = [], + $__6 = 1; $__6 < arguments.length; $__6++) + iters[$__6 - 1] = arguments[$__6]; + return mergeIntoListWith(this, deepMerger(merger), iters); + }, + setSize: function(size) { + return setListBounds(this, 0, size); + }, + slice: function(begin, end) { + var size = this.size; + if (wholeSlice(begin, end, size)) { + return this; + } + return setListBounds(this, resolveBegin(begin, size), resolveEnd(end, size)); + }, + __iterator: function(type, reverse) { + return new ListIterator(this, type, reverse); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + var iterations = 0; + var eachFn = (function(v) { + return fn(v, iterations++, $__0); + }); + var tailOffset = getTailOffset(this._capacity); + if (reverse) { + iterateVNode(this._tail, 0, tailOffset - this._origin, this._capacity - this._origin, eachFn, reverse) && iterateVNode(this._root, this._level, -this._origin, tailOffset - this._origin, eachFn, reverse); + } else { + iterateVNode(this._root, this._level, -this._origin, tailOffset - this._origin, eachFn, reverse) && iterateVNode(this._tail, 0, tailOffset - this._origin, this._capacity - this._origin, eachFn, reverse); + } + return iterations; + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + this.__ownerID = ownerID; + return this; + } + return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash); + } +}, {of: function() { + return this(arguments); + }}, IndexedCollection); +function isList(maybeList) { + return !!(maybeList && maybeList[IS_LIST_SENTINEL]); +} +List.isList = isList; +var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@'; +var ListPrototype = List.prototype; +ListPrototype[IS_LIST_SENTINEL] = true; +ListPrototype[DELETE] = ListPrototype.remove; +ListPrototype.setIn = MapPrototype.setIn; +ListPrototype.removeIn = MapPrototype.removeIn; +ListPrototype.update = MapPrototype.update; +ListPrototype.updateIn = MapPrototype.updateIn; +ListPrototype.withMutations = MapPrototype.withMutations; +ListPrototype.asMutable = MapPrototype.asMutable; +ListPrototype.asImmutable = MapPrototype.asImmutable; +ListPrototype.wasAltered = MapPrototype.wasAltered; +var VNode = function VNode(array, ownerID) { + this.array = array; + this.ownerID = ownerID; +}; +var $VNode = VNode; +($traceurRuntime.createClass)(VNode, { + removeBefore: function(ownerID, level, index) { + if (index === level ? 1 << level : 0 || this.array.length === 0) { + return this; + } + var originIndex = (index >>> level) & MASK; + if (originIndex >= this.array.length) { + return new $VNode([], ownerID); + } + var removingFirst = originIndex === 0; + var newChild; + if (level > 0) { + var oldChild = this.array[originIndex]; + newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index); + if (newChild === oldChild && removingFirst) { + return this; + } + } + if (removingFirst && !newChild) { + return this; + } + var editable = editableVNode(this, ownerID); + if (!removingFirst) { + for (var ii = 0; ii < originIndex; ii++) { + editable.array[ii] = undefined; + } + } + if (newChild) { + editable.array[originIndex] = newChild; + } + return editable; + }, + removeAfter: function(ownerID, level, index) { + if (index === level ? 1 << level : 0 || this.array.length === 0) { + return this; + } + var sizeIndex = ((index - 1) >>> level) & MASK; + if (sizeIndex >= this.array.length) { + return this; + } + var removingLast = sizeIndex === this.array.length - 1; + var newChild; + if (level > 0) { + var oldChild = this.array[sizeIndex]; + newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index); + if (newChild === oldChild && removingLast) { + return this; + } + } + if (removingLast && !newChild) { + return this; + } + var editable = editableVNode(this, ownerID); + if (!removingLast) { + editable.array.pop(); + } + if (newChild) { + editable.array[sizeIndex] = newChild; + } + return editable; + } +}, {}); +function iterateVNode(node, level, offset, max, fn, reverse) { + var ii; + var array = node && node.array; + if (level === 0) { + var from = offset < 0 ? -offset : 0; + var to = max - offset; + if (to > SIZE) { + to = SIZE; + } + for (ii = from; ii < to; ii++) { + if (fn(array && array[reverse ? from + to - 1 - ii : ii]) === false) { + return false; + } + } + } else { + var step = 1 << level; + var newLevel = level - SHIFT; + for (ii = 0; ii <= MASK; ii++) { + var levelIndex = reverse ? MASK - ii : ii; + var newOffset = offset + (levelIndex << level); + if (newOffset < max && newOffset + step > 0) { + var nextNode = array && array[levelIndex]; + if (!iterateVNode(nextNode, newLevel, newOffset, max, fn, reverse)) { + return false; + } + } + } + } + return true; +} +var ListIterator = function ListIterator(list, type, reverse) { + this._type = type; + this._reverse = !!reverse; + this._maxIndex = list.size - 1; + var tailOffset = getTailOffset(list._capacity); + var rootStack = listIteratorFrame(list._root && list._root.array, list._level, -list._origin, tailOffset - list._origin - 1); + var tailStack = listIteratorFrame(list._tail && list._tail.array, 0, tailOffset - list._origin, list._capacity - list._origin - 1); + this._stack = reverse ? tailStack : rootStack; + this._stack.__prev = reverse ? rootStack : tailStack; +}; +($traceurRuntime.createClass)(ListIterator, {next: function() { + var stack = this._stack; + while (stack) { + var array = stack.array; + var rawIndex = stack.index++; + if (this._reverse) { + rawIndex = MASK - rawIndex; + if (rawIndex > stack.rawMax) { + rawIndex = stack.rawMax; + stack.index = SIZE - rawIndex; + } + } + if (rawIndex >= 0 && rawIndex < SIZE && rawIndex <= stack.rawMax) { + var value = array && array[rawIndex]; + if (stack.level === 0) { + var type = this._type; + var index; + if (type !== 1) { + index = stack.offset + (rawIndex << stack.level); + if (this._reverse) { + index = this._maxIndex - index; + } + } + return iteratorValue(type, index, value); + } else { + this._stack = stack = listIteratorFrame(value && value.array, stack.level - SHIFT, stack.offset + (rawIndex << stack.level), stack.max, stack); + } + continue; + } + stack = this._stack = this._stack.__prev; + } + return iteratorDone(); + }}, {}, Iterator); +function listIteratorFrame(array, level, offset, max, prevFrame) { + return { + array: array, + level: level, + offset: offset, + max: max, + rawMax: ((max - offset) >> level), + index: 0, + __prev: prevFrame + }; +} +function makeList(origin, capacity, level, root, tail, ownerID, hash) { + var list = Object.create(ListPrototype); + list.size = capacity - origin; + list._origin = origin; + list._capacity = capacity; + list._level = level; + list._root = root; + list._tail = tail; + list.__ownerID = ownerID; + list.__hash = hash; + list.__altered = false; + return list; +} +var EMPTY_LIST; +function emptyList() { + return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT)); +} +function updateList(list, index, value) { + index = wrapIndex(list, index); + if (index >= list.size || index < 0) { + return list.withMutations((function(list) { + index < 0 ? setListBounds(list, index).set(0, value) : setListBounds(list, 0, index + 1).set(index, value); + })); + } + index += list._origin; + var newTail = list._tail; + var newRoot = list._root; + var didAlter = MakeRef(DID_ALTER); + if (index >= getTailOffset(list._capacity)) { + newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter); + } else { + newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter); + } + if (!didAlter.value) { + return list; + } + if (list.__ownerID) { + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(list._origin, list._capacity, list._level, newRoot, newTail); +} +function updateVNode(node, ownerID, level, index, value, didAlter) { + var idx = (index >>> level) & MASK; + var nodeHas = node && idx < node.array.length; + if (!nodeHas && value === undefined) { + return node; + } + var newNode; + if (level > 0) { + var lowerNode = node && node.array[idx]; + var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter); + if (newLowerNode === lowerNode) { + return node; + } + newNode = editableVNode(node, ownerID); + newNode.array[idx] = newLowerNode; + return newNode; + } + if (nodeHas && node.array[idx] === value) { + return node; + } + SetRef(didAlter); + newNode = editableVNode(node, ownerID); + if (value === undefined && idx === newNode.array.length - 1) { + newNode.array.pop(); + } else { + newNode.array[idx] = value; + } + return newNode; +} +function editableVNode(node, ownerID) { + if (ownerID && node && ownerID === node.ownerID) { + return node; + } + return new VNode(node ? node.array.slice() : [], ownerID); +} +function listNodeFor(list, rawIndex) { + if (rawIndex >= getTailOffset(list._capacity)) { + return list._tail; + } + if (rawIndex < 1 << (list._level + SHIFT)) { + var node = list._root; + var level = list._level; + while (node && level > 0) { + node = node.array[(rawIndex >>> level) & MASK]; + level -= SHIFT; + } + return node; + } +} +function setListBounds(list, begin, end) { + var owner = list.__ownerID || new OwnerID(); + var oldOrigin = list._origin; + var oldCapacity = list._capacity; + var newOrigin = oldOrigin + begin; + var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end; + if (newOrigin === oldOrigin && newCapacity === oldCapacity) { + return list; + } + if (newOrigin >= newCapacity) { + return list.clear(); + } + var newLevel = list._level; + var newRoot = list._root; + var offsetShift = 0; + while (newOrigin + offsetShift < 0) { + newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner); + newLevel += SHIFT; + offsetShift += 1 << newLevel; + } + if (offsetShift) { + newOrigin += offsetShift; + oldOrigin += offsetShift; + newCapacity += offsetShift; + oldCapacity += offsetShift; + } + var oldTailOffset = getTailOffset(oldCapacity); + var newTailOffset = getTailOffset(newCapacity); + while (newTailOffset >= 1 << (newLevel + SHIFT)) { + newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner); + newLevel += SHIFT; + } + var oldTail = list._tail; + var newTail = newTailOffset < oldTailOffset ? listNodeFor(list, newCapacity - 1) : newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail; + if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) { + newRoot = editableVNode(newRoot, owner); + var node = newRoot; + for (var level = newLevel; level > SHIFT; level -= SHIFT) { + var idx = (oldTailOffset >>> level) & MASK; + node = node.array[idx] = editableVNode(node.array[idx], owner); + } + node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail; + } + if (newCapacity < oldCapacity) { + newTail = newTail && newTail.removeAfter(owner, 0, newCapacity); + } + if (newOrigin >= newTailOffset) { + newOrigin -= newTailOffset; + newCapacity -= newTailOffset; + newLevel = SHIFT; + newRoot = null; + newTail = newTail && newTail.removeBefore(owner, 0, newOrigin); + } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) { + offsetShift = 0; + while (newRoot) { + var beginIndex = (newOrigin >>> newLevel) & MASK; + if (beginIndex !== (newTailOffset >>> newLevel) & MASK) { + break; + } + if (beginIndex) { + offsetShift += (1 << newLevel) * beginIndex; + } + newLevel -= SHIFT; + newRoot = newRoot.array[beginIndex]; + } + if (newRoot && newOrigin > oldOrigin) { + newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift); + } + if (newRoot && newTailOffset < oldTailOffset) { + newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift); + } + if (offsetShift) { + newOrigin -= offsetShift; + newCapacity -= offsetShift; + } + } + if (list.__ownerID) { + list.size = newCapacity - newOrigin; + list._origin = newOrigin; + list._capacity = newCapacity; + list._level = newLevel; + list._root = newRoot; + list._tail = newTail; + list.__hash = undefined; + list.__altered = true; + return list; + } + return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail); +} +function mergeIntoListWith(list, merger, iterables) { + var iters = []; + var maxSize = 0; + for (var ii = 0; ii < iterables.length; ii++) { + var value = iterables[ii]; + var iter = IndexedIterable(value); + if (iter.size > maxSize) { + maxSize = iter.size; + } + if (!isIterable(value)) { + iter = iter.map((function(v) { + return fromJS(v); + })); + } + iters.push(iter); + } + if (maxSize > list.size) { + list = list.setSize(maxSize); + } + return mergeIntoCollectionWith(list, merger, iters); +} +function getTailOffset(size) { + return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT); +} +var OrderedMap = function OrderedMap(value) { + return value === null || value === undefined ? emptyOrderedMap() : isOrderedMap(value) ? value : emptyOrderedMap().merge(KeyedIterable(value)); +}; +($traceurRuntime.createClass)(OrderedMap, { + toString: function() { + return this.__toString('OrderedMap {', '}'); + }, + get: function(k, notSetValue) { + var index = this._map.get(k); + return index !== undefined ? this._list.get(index)[1] : notSetValue; + }, + clear: function() { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._map.clear(); + this._list.clear(); + return this; + } + return emptyOrderedMap(); + }, + set: function(k, v) { + return updateOrderedMap(this, k, v); + }, + remove: function(k) { + return updateOrderedMap(this, k, NOT_SET); + }, + wasAltered: function() { + return this._map.wasAltered() || this._list.wasAltered(); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + return this._list.__iterate((function(entry) { + return entry && fn(entry[1], entry[0], $__0); + }), reverse); + }, + __iterator: function(type, reverse) { + return this._list.fromEntrySeq().__iterator(type, reverse); + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + var newList = this._list.__ensureOwner(ownerID); + if (!ownerID) { + this.__ownerID = ownerID; + this._map = newMap; + this._list = newList; + return this; + } + return makeOrderedMap(newMap, newList, ownerID, this.__hash); + } +}, {of: function() { + return this(arguments); + }}, Map); +function isOrderedMap(maybeOrderedMap) { + return !!(maybeOrderedMap && maybeOrderedMap[IS_ORDERED_MAP_SENTINEL]); +} +OrderedMap.isOrderedMap = isOrderedMap; +var IS_ORDERED_MAP_SENTINEL = '@@__IMMUTABLE_ORDERED_MAP__@@'; +OrderedMap.prototype[IS_ORDERED_MAP_SENTINEL] = true; +OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove; +function makeOrderedMap(map, list, ownerID, hash) { + var omap = Object.create(OrderedMap.prototype); + omap.size = map ? map.size : 0; + omap._map = map; + omap._list = list; + omap.__ownerID = ownerID; + omap.__hash = hash; + return omap; +} +var EMPTY_ORDERED_MAP; +function emptyOrderedMap() { + return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList())); +} +function updateOrderedMap(omap, k, v) { + var map = omap._map; + var list = omap._list; + var i = map.get(k); + var has = i !== undefined; + var newMap; + var newList; + if (v === NOT_SET) { + if (!has) { + return omap; + } + if (list.size >= SIZE && list.size >= map.size * 2) { + newList = list.filter((function(entry, idx) { + return entry !== undefined && i !== idx; + })); + newMap = newList.toKeyedSeq().map((function(entry) { + return entry[0]; + })).flip().toMap(); + if (omap.__ownerID) { + newMap.__ownerID = newList.__ownerID = omap.__ownerID; + } + } else { + newMap = map.remove(k); + newList = i === list.size - 1 ? list.pop() : list.set(i, undefined); + } + } else { + if (has) { + if (v === list.get(i)[1]) { + return omap; + } + newMap = map; + newList = list.set(i, [k, v]); + } else { + newMap = map.set(k, list.size); + newList = list.set(list.size, [k, v]); + } + } + if (omap.__ownerID) { + omap.size = newMap.size; + omap._map = newMap; + omap._list = newList; + omap.__hash = undefined; + return omap; + } + return makeOrderedMap(newMap, newList); +} +var Stack = function Stack(value) { + return value === null || value === undefined ? emptyStack() : isStack(value) ? value : emptyStack().unshiftAll(value); +}; +var $Stack = Stack; +($traceurRuntime.createClass)(Stack, { + toString: function() { + return this.__toString('Stack [', ']'); + }, + get: function(index, notSetValue) { + var head = this._head; + while (head && index--) { + head = head.next; + } + return head ? head.value : notSetValue; + }, + peek: function() { + return this._head && this._head.value; + }, + push: function() { + if (arguments.length === 0) { + return this; + } + var newSize = this.size + arguments.length; + var head = this._head; + for (var ii = arguments.length - 1; ii >= 0; ii--) { + head = { + value: arguments[ii], + next: head + }; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }, + pushAll: function(iter) { + iter = IndexedIterable(iter); + if (iter.size === 0) { + return this; + } + var newSize = this.size; + var head = this._head; + iter.reverse().forEach((function(value) { + newSize++; + head = { + value: value, + next: head + }; + })); + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }, + pop: function() { + return this.slice(1); + }, + unshift: function() { + return this.push.apply(this, arguments); + }, + unshiftAll: function(iter) { + return this.pushAll(iter); + }, + shift: function() { + return this.pop.apply(this, arguments); + }, + clear: function() { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._head = undefined; + this.__hash = undefined; + this.__altered = true; + return this; + } + return emptyStack(); + }, + slice: function(begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + var resolvedBegin = resolveBegin(begin, this.size); + var resolvedEnd = resolveEnd(end, this.size); + if (resolvedEnd !== this.size) { + return $traceurRuntime.superCall(this, $Stack.prototype, "slice", [begin, end]); + } + var newSize = this.size - resolvedBegin; + var head = this._head; + while (resolvedBegin--) { + head = head.next; + } + if (this.__ownerID) { + this.size = newSize; + this._head = head; + this.__hash = undefined; + this.__altered = true; + return this; + } + return makeStack(newSize, head); + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + if (!ownerID) { + this.__ownerID = ownerID; + this.__altered = false; + return this; + } + return makeStack(this.size, this._head, ownerID, this.__hash); + }, + __iterate: function(fn, reverse) { + if (reverse) { + return this.toSeq().cacheResult.__iterate(fn, reverse); + } + var iterations = 0; + var node = this._head; + while (node) { + if (fn(node.value, iterations++, this) === false) { + break; + } + node = node.next; + } + return iterations; + }, + __iterator: function(type, reverse) { + if (reverse) { + return this.toSeq().cacheResult().__iterator(type, reverse); + } + var iterations = 0; + var node = this._head; + return new Iterator((function() { + if (node) { + var value = node.value; + node = node.next; + return iteratorValue(type, iterations++, value); + } + return iteratorDone(); + })); + } +}, {of: function() { + return this(arguments); + }}, IndexedCollection); +function isStack(maybeStack) { + return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]); +} +Stack.isStack = isStack; +var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@'; +var StackPrototype = Stack.prototype; +StackPrototype[IS_STACK_SENTINEL] = true; +StackPrototype.withMutations = MapPrototype.withMutations; +StackPrototype.asMutable = MapPrototype.asMutable; +StackPrototype.asImmutable = MapPrototype.asImmutable; +StackPrototype.wasAltered = MapPrototype.wasAltered; +function makeStack(size, head, ownerID, hash) { + var map = Object.create(StackPrototype); + map.size = size; + map._head = head; + map.__ownerID = ownerID; + map.__hash = hash; + map.__altered = false; + return map; +} +var EMPTY_STACK; +function emptyStack() { + return EMPTY_STACK || (EMPTY_STACK = makeStack(0)); +} +var Set = function Set(value) { + return value === null || value === undefined ? emptySet() : isSet(value) ? value : emptySet().union(SetIterable(value)); +}; +($traceurRuntime.createClass)(Set, { + toString: function() { + return this.__toString('Set {', '}'); + }, + has: function(value) { + return this._map.has(value); + }, + add: function(value) { + return updateSet(this, this._map.set(value, true)); + }, + remove: function(value) { + return updateSet(this, this._map.remove(value)); + }, + clear: function() { + return updateSet(this, this._map.clear()); + }, + union: function() { + var iters = arguments; + if (iters.length === 0) { + return this; + } + return this.withMutations((function(set) { + for (var ii = 0; ii < iters.length; ii++) { + SetIterable(iters[ii]).forEach((function(value) { + return set.add(value); + })); + } + })); + }, + intersect: function() { + for (var iters = [], + $__7 = 0; $__7 < arguments.length; $__7++) + iters[$__7] = arguments[$__7]; + if (iters.length === 0) { + return this; + } + iters = iters.map((function(iter) { + return SetIterable(iter); + })); + var originalSet = this; + return this.withMutations((function(set) { + originalSet.forEach((function(value) { + if (!iters.every((function(iter) { + return iter.contains(value); + }))) { + set.remove(value); + } + })); + })); + }, + subtract: function() { + for (var iters = [], + $__8 = 0; $__8 < arguments.length; $__8++) + iters[$__8] = arguments[$__8]; + if (iters.length === 0) { + return this; + } + iters = iters.map((function(iter) { + return SetIterable(iter); + })); + var originalSet = this; + return this.withMutations((function(set) { + originalSet.forEach((function(value) { + if (iters.some((function(iter) { + return iter.contains(value); + }))) { + set.remove(value); + } + })); + })); + }, + merge: function() { + return this.union.apply(this, arguments); + }, + mergeWith: function(merger) { + for (var iters = [], + $__9 = 1; $__9 < arguments.length; $__9++) + iters[$__9 - 1] = arguments[$__9]; + return this.union.apply(this, iters); + }, + sort: function(comparator) { + return OrderedSet(sortFactory(this, comparator)); + }, + sortBy: function(mapper, comparator) { + return OrderedSet(sortFactory(this, comparator, mapper)); + }, + wasAltered: function() { + return this._map.wasAltered(); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + return this._map.__iterate((function(_, k) { + return fn(k, k, $__0); + }), reverse); + }, + __iterator: function(type, reverse) { + return this._map.map((function(_, k) { + return k; + })).__iterator(type, reverse); + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map.__ensureOwner(ownerID); + if (!ownerID) { + this.__ownerID = ownerID; + this._map = newMap; + return this; + } + return this.__make(newMap, ownerID); + } +}, { + of: function() { + return this(arguments); + }, + fromKeys: function(value) { + return this(KeyedIterable(value).keySeq()); + } +}, SetCollection); +function isSet(maybeSet) { + return !!(maybeSet && maybeSet[IS_SET_SENTINEL]); +} +Set.isSet = isSet; +var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@'; +var SetPrototype = Set.prototype; +SetPrototype[IS_SET_SENTINEL] = true; +SetPrototype[DELETE] = SetPrototype.remove; +SetPrototype.mergeDeep = SetPrototype.merge; +SetPrototype.mergeDeepWith = SetPrototype.mergeWith; +SetPrototype.withMutations = MapPrototype.withMutations; +SetPrototype.asMutable = MapPrototype.asMutable; +SetPrototype.asImmutable = MapPrototype.asImmutable; +SetPrototype.__empty = emptySet; +SetPrototype.__make = makeSet; +function updateSet(set, newMap) { + if (set.__ownerID) { + set.size = newMap.size; + set._map = newMap; + return set; + } + return newMap === set._map ? set : newMap.size === 0 ? set.__empty() : set.__make(newMap); +} +function makeSet(map, ownerID) { + var set = Object.create(SetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; +} +var EMPTY_SET; +function emptySet() { + return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap())); +} +var OrderedSet = function OrderedSet(value) { + return value === null || value === undefined ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().union(SetIterable(value)); +}; +($traceurRuntime.createClass)(OrderedSet, {toString: function() { + return this.__toString('OrderedSet {', '}'); + }}, { + of: function() { + return this(arguments); + }, + fromKeys: function(value) { + return this(KeyedIterable(value).keySeq()); + } +}, Set); +function isOrderedSet(maybeOrderedSet) { + return !!(maybeOrderedSet && maybeOrderedSet[IS_ORDERED_SET_SENTINEL]); +} +OrderedSet.isOrderedSet = isOrderedSet; +var IS_ORDERED_SET_SENTINEL = '@@__IMMUTABLE_ORDERED_SET__@@'; +var OrderedSetPrototype = OrderedSet.prototype; +OrderedSetPrototype[IS_ORDERED_SET_SENTINEL] = true; +OrderedSetPrototype.__empty = emptyOrderedSet; +OrderedSetPrototype.__make = makeOrderedSet; +function makeOrderedSet(map, ownerID) { + var set = Object.create(OrderedSetPrototype); + set.size = map ? map.size : 0; + set._map = map; + set.__ownerID = ownerID; + return set; +} +var EMPTY_ORDERED_SET; +function emptyOrderedSet() { + return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap())); +} +var Record = function Record(defaultValues, name) { + var RecordType = function Record(values) { + if (!(this instanceof RecordType)) { + return new RecordType(values); + } + this._map = Map(values); + }; + var keys = Object.keys(defaultValues); + var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype); + RecordTypePrototype.constructor = RecordType; + name && (RecordTypePrototype._name = name); + RecordTypePrototype._defaultValues = defaultValues; + RecordTypePrototype._keys = keys; + RecordTypePrototype.size = keys.length; + try { + keys.forEach((function(key) { + Object.defineProperty(RecordType.prototype, key, { + get: function() { + return this.get(key); + }, + set: function(value) { + invariant(this.__ownerID, 'Cannot set on an immutable record.'); + this.set(key, value); + } + }); + })); + } catch (error) {} + return RecordType; +}; +($traceurRuntime.createClass)(Record, { + toString: function() { + return this.__toString(recordName(this) + ' {', '}'); + }, + has: function(k) { + return this._defaultValues.hasOwnProperty(k); + }, + get: function(k, notSetValue) { + if (!this.has(k)) { + return notSetValue; + } + var defaultVal = this._defaultValues[k]; + return this._map ? this._map.get(k, defaultVal) : defaultVal; + }, + clear: function() { + if (this.__ownerID) { + this._map && this._map.clear(); + return this; + } + var SuperRecord = Object.getPrototypeOf(this).constructor; + return SuperRecord._empty || (SuperRecord._empty = makeRecord(this, emptyMap())); + }, + set: function(k, v) { + if (!this.has(k)) { + throw new Error('Cannot set unknown key "' + k + '" on ' + recordName(this)); + } + var newMap = this._map && this._map.set(k, v); + if (this.__ownerID || newMap === this._map) { + return this; + } + return makeRecord(this, newMap); + }, + remove: function(k) { + if (!this.has(k)) { + return this; + } + var newMap = this._map && this._map.remove(k); + if (this.__ownerID || newMap === this._map) { + return this; + } + return makeRecord(this, newMap); + }, + wasAltered: function() { + return this._map.wasAltered(); + }, + __iterator: function(type, reverse) { + var $__0 = this; + return KeyedIterable(this._defaultValues).map((function(_, k) { + return $__0.get(k); + })).__iterator(type, reverse); + }, + __iterate: function(fn, reverse) { + var $__0 = this; + return KeyedIterable(this._defaultValues).map((function(_, k) { + return $__0.get(k); + })).__iterate(fn, reverse); + }, + __ensureOwner: function(ownerID) { + if (ownerID === this.__ownerID) { + return this; + } + var newMap = this._map && this._map.__ensureOwner(ownerID); + if (!ownerID) { + this.__ownerID = ownerID; + this._map = newMap; + return this; + } + return makeRecord(this, newMap, ownerID); + } +}, {}, KeyedCollection); +var RecordPrototype = Record.prototype; +RecordPrototype[DELETE] = RecordPrototype.remove; +RecordPrototype.merge = MapPrototype.merge; +RecordPrototype.mergeWith = MapPrototype.mergeWith; +RecordPrototype.mergeDeep = MapPrototype.mergeDeep; +RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith; +RecordPrototype.update = MapPrototype.update; +RecordPrototype.updateIn = MapPrototype.updateIn; +RecordPrototype.withMutations = MapPrototype.withMutations; +RecordPrototype.asMutable = MapPrototype.asMutable; +RecordPrototype.asImmutable = MapPrototype.asImmutable; +function makeRecord(likeRecord, map, ownerID) { + var record = Object.create(Object.getPrototypeOf(likeRecord)); + record._map = map; + record.__ownerID = ownerID; + return record; +} +function recordName(record) { + return record._name || record.constructor.name; +} +var Range = function Range(start, end, step) { + if (!(this instanceof $Range)) { + return new $Range(start, end, step); + } + invariant(step !== 0, 'Cannot step a Range by 0'); + start = start || 0; + if (end === undefined) { + end = Infinity; + } + if (start === end && __EMPTY_RANGE) { + return __EMPTY_RANGE; + } + step = step === undefined ? 1 : Math.abs(step); + if (end < start) { + step = -step; + } + this._start = start; + this._end = end; + this._step = step; + this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1); +}; +var $Range = Range; +($traceurRuntime.createClass)(Range, { + toString: function() { + if (this.size === 0) { + return 'Range []'; + } + return 'Range [ ' + this._start + '...' + this._end + (this._step > 1 ? ' by ' + this._step : '') + ' ]'; + }, + get: function(index, notSetValue) { + return this.has(index) ? this._start + wrapIndex(this, index) * this._step : notSetValue; + }, + contains: function(searchValue) { + var possibleIndex = (searchValue - this._start) / this._step; + return possibleIndex >= 0 && possibleIndex < this.size && possibleIndex === Math.floor(possibleIndex); + }, + slice: function(begin, end) { + if (wholeSlice(begin, end, this.size)) { + return this; + } + begin = resolveBegin(begin, this.size); + end = resolveEnd(end, this.size); + if (end <= begin) { + return __EMPTY_RANGE; + } + return new $Range(this.get(begin, this._end), this.get(end, this._end), this._step); + }, + indexOf: function(searchValue) { + var offsetValue = searchValue - this._start; + if (offsetValue % this._step === 0) { + var index = offsetValue / this._step; + if (index >= 0 && index < this.size) { + return index; + } + } + return -1; + }, + lastIndexOf: function(searchValue) { + return this.indexOf(searchValue); + }, + take: function(amount) { + return this.slice(0, Math.max(0, amount)); + }, + skip: function(amount) { + return this.slice(Math.max(0, amount)); + }, + __iterate: function(fn, reverse) { + var maxIndex = this.size - 1; + var step = this._step; + var value = reverse ? this._start + maxIndex * step : this._start; + for (var ii = 0; ii <= maxIndex; ii++) { + if (fn(value, ii, this) === false) { + return ii + 1; + } + value += reverse ? -step : step; + } + return ii; + }, + __iterator: function(type, reverse) { + var maxIndex = this.size - 1; + var step = this._step; + var value = reverse ? this._start + maxIndex * step : this._start; + var ii = 0; + return new Iterator((function() { + var v = value; + value += reverse ? -step : step; + return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v); + })); + }, + __deepEquals: function(other) { + return other instanceof $Range ? this._start === other._start && this._end === other._end && this._step === other._step : $traceurRuntime.superCall(this, $Range.prototype, "__deepEquals", [other]); + } +}, {}, IndexedSeq); +var RangePrototype = Range.prototype; +RangePrototype.__toJS = RangePrototype.toArray; +RangePrototype.first = ListPrototype.first; +RangePrototype.last = ListPrototype.last; +var __EMPTY_RANGE = Range(0, 0); +var Repeat = function Repeat(value, times) { + if (times <= 0 && EMPTY_REPEAT) { + return EMPTY_REPEAT; + } + if (!(this instanceof $Repeat)) { + return new $Repeat(value, times); + } + this._value = value; + this.size = times === undefined ? Infinity : Math.max(0, times); + if (this.size === 0) { + EMPTY_REPEAT = this; + } +}; +var $Repeat = Repeat; +($traceurRuntime.createClass)(Repeat, { + toString: function() { + if (this.size === 0) { + return 'Repeat []'; + } + return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]'; + }, + get: function(index, notSetValue) { + return this.has(index) ? this._value : notSetValue; + }, + contains: function(searchValue) { + return is(this._value, searchValue); + }, + slice: function(begin, end) { + var size = this.size; + return wholeSlice(begin, end, size) ? this : new $Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size)); + }, + reverse: function() { + return this; + }, + indexOf: function(searchValue) { + if (is(this._value, searchValue)) { + return 0; + } + return -1; + }, + lastIndexOf: function(searchValue) { + if (is(this._value, searchValue)) { + return this.size; + } + return -1; + }, + __iterate: function(fn, reverse) { + for (var ii = 0; ii < this.size; ii++) { + if (fn(this._value, ii, this) === false) { + return ii + 1; + } + } + return ii; + }, + __iterator: function(type, reverse) { + var $__0 = this; + var ii = 0; + return new Iterator((function() { + return ii < $__0.size ? iteratorValue(type, ii++, $__0._value) : iteratorDone(); + })); + }, + __deepEquals: function(other) { + return other instanceof $Repeat ? is(this._value, other._value) : $traceurRuntime.superCall(this, $Repeat.prototype, "__deepEquals", [other]); + } +}, {}, IndexedSeq); +var RepeatPrototype = Repeat.prototype; +RepeatPrototype.last = RepeatPrototype.first; +RepeatPrototype.has = RangePrototype.has; +RepeatPrototype.take = RangePrototype.take; +RepeatPrototype.skip = RangePrototype.skip; +RepeatPrototype.__toJS = RangePrototype.__toJS; +var EMPTY_REPEAT; +var Immutable = { + Iterable: Iterable, + Seq: Seq, + Collection: Collection, + Map: Map, + OrderedMap: OrderedMap, + List: List, + Stack: Stack, + Set: Set, + OrderedSet: OrderedSet, + Record: Record, + Range: Range, + Repeat: Repeat, + is: is, + fromJS: fromJS +}; + + return Immutable; +} +typeof exports === 'object' ? module.exports = universalModule() : + typeof define === 'function' && define.amd ? define(universalModule) : + Immutable = universalModule(); diff --git a/ajax/libs/immutable/3.1.0/immutable.min.js b/ajax/libs/immutable/3.1.0/immutable.min.js new file mode 100644 index 000000000..58a9e8145 --- /dev/null +++ b/ajax/libs/immutable/3.1.0/immutable.min.js @@ -0,0 +1,34 @@ +/** + * Copyright (c) 2014, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +function t(){function t(t,e,r,n){var i;if(n){var u=n.prototype;i=pr.create(u)}else i=t.prototype;return pr.keys(e).forEach(function(t){i[t]=e[t]}),pr.keys(r).forEach(function(e){t[e]=r[e]}),i.constructor=t,t.prototype=i,t}function e(t,e,r,n){return pr.getPrototypeOf(e)[r].apply(t,n)}function r(t,r,n){e(t,r,"constructor",n)}function n(t,e){return t===e?0!==t||0!==e||1/t===1/e:t!==t?e!==e:t&&"function"==typeof t.equals?t.equals(e):!1}function i(t,e){if(!t)throw Error(e)}function u(t){return t.value=!1,t}function s(t){t&&(t.value=!0)}function o(){}function a(t,e){e=e||0;for(var r=Math.max(0,t.length-e),n=Array(r),i=0;r>i;i++)n[i]=t[i+e];return n}function h(t){i(1/0!==t,"Cannot perform this action with an infinite size.")}function c(t){return void 0===t.size&&(t.size=t.__iterate(_)),t.size}function f(t,e){return e>=0?+e:c(t)+ +e}function _(){return!0}function l(t,e,r){return(0===t||void 0!==r&&-r>=t)&&(void 0===e||void 0!==r&&e>=r)}function v(t,e){return d(t,e,0)}function p(t,e){return d(t,e,e)}function d(t,e,r){return void 0===t?r:0>t?Math.max(0,e+t):void 0===e?t:Math.min(e,t)}function y(t){if(!t)return 0;if(t===!0)return 1;var e=typeof t;if("number"===e){if((0|t)===t)return t&Mr;t=""+t,e="string"}return"string"===e?t.length>Er?g(t):m(t):t.hashCode?y("function"==typeof t.hashCode?t.hashCode():t.hashCode):w(t)}function g(t){var e=Ar[t];return void 0===e&&(e=m(t),Or===Dr&&(Or=0,Ar={}),Or++,Ar[t]=e),e}function m(t){for(var e=0,r=0;t.length>r;r++)e=31*e+t.charCodeAt(r)&Mr;return e}function w(t){var e=qr&&qr.get(t);if(e)return e;if(e=t[kr])return e;if(!br){if(e=t.propertyIsEnumerable&&t.propertyIsEnumerable[kr])return e;if(e=S(t))return e}if(Object.isExtensible&&!Object.isExtensible(t))throw Error("Non-extensible objects are not allowed as keys.");if(e=++xr&Mr,qr)qr.set(t,e);else if(br)Object.defineProperty(t,kr,{enumerable:!1,configurable:!1,writable:!1,value:e});else if(t.propertyIsEnumerable&&t.propertyIsEnumerable===t.constructor.prototype.propertyIsEnumerable)t.propertyIsEnumerable=function(){return this.constructor.prototype.propertyIsEnumerable.apply(this,arguments) +},t.propertyIsEnumerable[kr]=e;else{if(!t.nodeType)throw Error("Unable to set a non-enumerable property on object.");t[kr]=e}return e}function S(t){if(t&&t.nodeType>0)switch(t.nodeType){case 1:return t.uniqueID;case 9:return t.documentElement&&t.documentElement.uniqueID}}function z(t,e,r,n){var i=0===t?e:1===t?r:[e,r];return n?n.value=i:n={value:i,done:!1},n}function I(){return{value:void 0,done:!0}}function b(t){return!!x(t)}function q(t){return t&&"function"==typeof t.next}function M(t){var e=x(t);return e&&e.call(t)}function x(t){var e=t&&(Ur&&t[Ur]||t[Kr]);return"function"==typeof e?e:void 0}function k(t){return!(!t||!t[Jr])}function E(t){return!(!t||!t[Hr])}function D(t){return!(!t||!t[Vr])}function O(t){return E(t)||D(t)}function A(t,e){return e}function C(t,e){return[e,t]}function j(t){return function(){return!t.apply(this,arguments)}}function R(t){return function(){return-t.apply(this,arguments)}}function K(t){return"string"==typeof t?JSON.stringify(t):t}function U(t,e){return t>e?-1:e>t?1:0}function L(t,e){var r=t.prototype,n=function(t){r[t]=e[t]};return Object.keys(e).forEach(n),Object.getOwnPropertySymbols&&Object.getOwnPropertySymbols(e).forEach(n),t}function T(t){return!(!t||!t[sn])}function B(){return fn||(fn=new on([]))}function W(t){var e=Array.isArray(t)?new on(t).fromEntrySeq():q(t)?new cn(t).fromEntrySeq():b(t)?new hn(t).fromEntrySeq():"object"==typeof t?new an(t):void 0;if(!e)throw new TypeError("Expected Array or iterable object of [k, v] entries, or keyed object: "+t);return e}function P(t){var e=H(t);if(!e)throw new TypeError("Expected Array or iterable object of values: "+t);return e}function J(t){var e=H(t)||"object"==typeof t&&new an(t);if(!e)throw new TypeError("Expected Array or iterable object of values, or keyed object: "+t);return e}function H(t){return V(t)?new on(t):q(t)?new cn(t):b(t)?new hn(t):void 0}function V(t){return t&&"number"==typeof t.length}function N(t,e,r,n){h(t.size);var i=t._cache;if(i){for(var u=i.length-1,s=0;u>=s;s++){var o=i[r?u-s:s];if(e(o[1],n?o[0]:s,t)===!1)return s+1 +}return s}return t.__iterateUncached(e,r)}function Y(t,e,r,n){var i=t._cache;if(i){var u=i.length-1,s=0;return new Tr(function(){var t=i[r?u-s:s];return s++>u?I():z(e,n?t[0]:s-1,t[1])})}return t.__iteratorUncached(e,r)}function Q(t,e){return e?X(e,t,"",{"":t}):F(t)}function X(t,e,r,n){return Array.isArray(e)?t.call(n,r,en(e).map(function(r,n){return X(t,r,n,e)})):G(e)?t.call(n,r,$r(e).map(function(r,n){return X(t,r,n,e)})):e}function F(t){return Array.isArray(t)?en(t).map(F).toList():G(t)?$r(t).map(F).toMap():t}function G(t){return t&&t.constructor===Object}function Z(t){return!(!t||!t[wn])}function $(t,e){return z(t,e[0],e[1])}function te(t,e){return{node:t,index:0,__prev:e}}function ee(t,e,r,n){var i=Object.create(Sn);return i.size=t,i._root=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function re(){return Cn||(Cn=ee(0))}function ne(t,e,r){var n,i;if(t._root){var s=u(zr),o=u(Ir);if(n=ie(t._root,t.__ownerID,0,void 0,e,r,s,o),!o.value)return t;i=t.size+(s.value?r===Sr?-1:1:0)}else{if(r===Sr)return t;i=1,n=new zn(t.__ownerID,[[e,r]])}return t.__ownerID?(t.size=i,t._root=n,t.__hash=void 0,t.__altered=!0,t):n?ee(i,n):re()}function ie(t,e,r,n,i,u,o,a){return t?t.update(e,r,n,i,u,o,a):u===Sr?t:(s(a),s(o),new Dn(e,n,[i,u]))}function ue(t){return t.constructor===Dn||t.constructor===kn}function se(t,e,r,n,i){if(t.keyHash===n)return new kn(e,n,[t.entry,i]);var u,s=(0===r?t.keyHash:t.keyHash>>>r)&wr,o=(0===r?n:n>>>r)&wr,a=s===o?[se(t,e,r+gr,n,i)]:(u=new Dn(e,n,i),o>s?[t,u]:[u,t]);return new bn(e,1<u;u++){var s=e[u];i=i.update(t,0,void 0,s[0],s[1])}return i}function ae(t,e,r,n){for(var i=0,u=0,s=Array(r),o=0,a=1,h=e.length;h>o;o++,a<<=1){var c=e[o];void 0!==c&&o!==n&&(i|=a,s[u++]=c)}return new bn(t,i,s)}function he(t,e,r,n,i){for(var u=0,s=Array(mr),o=0;0!==r;o++,r>>>=1)s[o]=1&r?e[u++]:void 0;return s[n]=i,new Mn(t,u+1,s)}function ce(t,e,r){for(var n=[],i=0;r.length>i;i++){var u=r[i],s=Yr(u);k(u)||(s=s.map(function(t){return Q(t)})),n.push(s) +}return _e(t,e,n)}function fe(t){return function(e,r){return e&&e.mergeDeepWith&&k(r)?e.mergeDeepWith(t,r):t?t(e,r):r}}function _e(t,e,r){return 0===r.length?t:t.withMutations(function(t){for(var n=e?function(r,n){t.update(n,Sr,function(t){return t===Sr?r:e(t,r)})}:function(e,r){t.set(r,e)},i=0;r.length>i;i++)r[i].forEach(n)})}function le(t,e,r,n,u){i(!t||t.set,"updateIn with invalid keyPath");var s=e[u],o=t?t.get(s,Sr):Sr,a=o===Sr?void 0:o,h=u===e.length-1?n(o===Sr?r:o):le(a,e,r,n,u+1);return h===a?t:h===Sr?t&&t.remove(s):(t||re()).set(s,h)}function ve(t){return t-=t>>1&1431655765,t=(858993459&t)+(t>>2&858993459),t=t+(t>>4)&252645135,t+=t>>8,t+=t>>16,127&t}function pe(t,e,r,n){var i=n?t:a(t);return i[e]=r,i}function de(t,e,r,n){var i=t.length+1;if(n&&e+1===i)return t[e]=r,t;for(var u=Array(i),s=0,o=0;i>o;o++)o===e?(u[o]=r,s=-1):u[o]=t[o+s];return u}function ye(t,e,r){var n=t.length-1;if(r&&e===n)return t.pop(),t;for(var i=Array(n),u=0,s=0;n>s;s++)s===e&&(u=1),i[s]=t[s+u];return i}function ge(t){var e=Le(t);return e._iter=t,e.size=t.size,e.flip=function(){return t},e.reverse=function(){var e=t.reverse.apply(this);return e.flip=function(){return t.reverse()},e},e.has=function(e){return t.contains(e)},e.contains=function(e){return t.has(e)},e.cacheResult=Te,e.__iterateUncached=function(e,r){var n=this;return t.__iterate(function(t,r){return e(r,t,n)!==!1},r)},e.__iteratorUncached=function(e,r){if(e===Rr){var n=t.__iterator(e,r);return new Tr(function(){var t=n.next();if(!t.done){var e=t.value[0];t.value[0]=t.value[1],t.value[1]=e}return t})}return t.__iterator(e===jr?Cr:jr,r)},e}function me(t,e,r){var n=Le(t);return n.size=t.size,n.has=function(e){return t.has(e)},n.get=function(n,i){var u=t.get(n,Sr);return u===Sr?i:e.call(r,u,n,t)},n.__iterateUncached=function(n,i){var u=this;return t.__iterate(function(t,i,s){return n(e.call(r,t,i,s),i,u)!==!1},i)},n.__iteratorUncached=function(n,i){var u=t.__iterator(Rr,i);return new Tr(function(){var i=u.next();if(i.done)return i;var s=i.value,o=s[0];return z(n,o,e.call(r,s[1],o,t),i) +})},n}function we(t,e){var r=Le(t);return r._iter=t,r.size=t.size,r.reverse=function(){return t},t.flip&&(r.flip=function(){var e=ge(t);return e.reverse=function(){return t.flip()},e}),r.get=function(r,n){return t.get(e?r:-1-r,n)},r.has=function(r){return t.has(e?r:-1-r)},r.contains=function(e){return t.contains(e)},r.cacheResult=Te,r.__iterate=function(e,r){var n=this;return t.__iterate(function(t,r){return e(t,r,n)},!r)},r.__iterator=function(e,r){return t.__iterator(e,!r)},r}function Se(t,e,r,n){var i=Le(t);return n&&(i.has=function(n){var i=t.get(n,Sr);return i!==Sr&&!!e.call(r,i,n,t)},i.get=function(n,i){var u=t.get(n,Sr);return u!==Sr&&e.call(r,u,n,t)?u:i}),i.__iterateUncached=function(i,u){var s=this,o=0;return t.__iterate(function(t,u,a){return e.call(r,t,u,a)?(o++,i(t,n?u:o-1,s)):void 0},u),o},i.__iteratorUncached=function(i,u){var s=t.__iterator(Rr,u),o=0;return new Tr(function(){for(;;){var u=s.next();if(u.done)return u;var a=u.value,h=a[0],c=a[1];if(e.call(r,c,h,t))return z(i,n?h:o++,c,u)}})},i}function ze(t,e,r){var n=mn().asMutable();return t.__iterate(function(i,u){n.update(e.call(r,i,u,t),0,function(t){return t+1})}),n.asImmutable()}function Ie(t,e,r){var n=E(t),i=mn().asMutable();t.__iterate(function(u,s){i.update(e.call(r,u,s,t),[],function(t){return t.push(n?[s,u]:u),t})});var u=Ue(t);return i.map(function(e){return je(t,u(e))})}function be(t,e){if(e>t.size)return t;0>e&&(e=0);var r=Le(t);return r.size=t.size&&Math.min(t.size,e),r.__iterateUncached=function(r,n){var i=this;if(0===e)return 0;if(n)return this.cacheResult().__iterate(r,n);var u=0;return t.__iterate(function(t,n){return++u&&r(t,n,i)!==!1&&e>u}),u},r.__iteratorUncached=function(r,n){if(n)return this.cacheResult().__iterator(r,n);var i=e&&t.__iterator(r,n),u=0;return new Tr(function(){return u++>e?I():i.next()})},r}function qe(t,e,r){var n=Le(t);return n.__iterateUncached=function(n,i){var u=this;if(i)return this.cacheResult().__iterate(n,i);var s=0;return t.__iterate(function(t,i,o){return e.call(r,t,i,o)&&++s&&n(t,i,u)}),s},n.__iteratorUncached=function(n,i){var u=this; +if(i)return this.cacheResult().__iterator(n,i);var s=t.__iterator(Rr,i),o=!0;return new Tr(function(){if(!o)return I();var t=s.next();if(t.done)return t;var i=t.value,a=i[0],h=i[1];return e.call(r,h,a,u)?n===Rr?t:z(n,a,h,t):(o=!1,I())})},n}function Me(t,e,r){if(0>=e)return t;var n=Le(t);return n.size=t.size&&Math.max(0,t.size-e),n.__iterateUncached=function(n,i){var u=this;if(i)return this.cacheResult().__iterate(n,i);var s=0,o=!0,a=0;return t.__iterate(function(t,i){return o&&(o=s++s;)s++,u.next();var t=u.next();return r||n===jr?t:n===Cr?z(n,o++,void 0,t):z(n,o++,t.value[1],t)})},n}function xe(t,e,r,n){var i=Le(t);return i.__iterateUncached=function(i,u){var s=this;if(u)return this.cacheResult().__iterate(i,u);var o=!0,a=0;return t.__iterate(function(t,u,h){return o&&(o=e.call(r,t,u,h))?void 0:(a++,i(t,n?u:a-1,s))}),a},i.__iteratorUncached=function(i,u){var s=this;if(u)return this.cacheResult().__iterator(i,u);var o=t.__iterator(Rr,u),a=!0,h=0;return new Tr(function(){var t,u,c;do{if(t=o.next(),t.done)return n||i===jr?t:i===Cr?z(i,h++,void 0,t):z(i,h++,t.value[1],t);var f=t.value;u=f[0],c=f[1],a&&(a=e.call(r,c,u,s))}while(a);return i===Rr?t:z(i,u,c,t)})},i}function ke(t,e){var r=E(t),n=new on([t].concat(e)).map(function(t){return k(t)?r&&(t=Yr(t)):t=r?W(t):P(Array.isArray(t)?t:[t]),t});r?n=n.toKeyedSeq():D(t)||(n=n.toSetSeq());var i=n.flatten(!0);return i.size=n.reduce(function(t,e){if(void 0!==t){var r=e.size;if(void 0!==r)return t+r}},0),i}function Ee(t,e,r){var n=Le(t);return n.__iterateUncached=function(n,i){function u(t,a){var h=this;t.__iterate(function(t,i){return(!e||e>a)&&k(t)?u(t,a+1):n(t,r?i:s++,h)===!1&&(o=!0),!o},i)}var s=0,o=!1;return u(t,0),s},n.__iteratorUncached=function(n,i){var u=t.__iterator(n,i),s=[],o=0;return new Tr(function(){for(;u;){var t=u.next();if(t.done===!1){var a=t.value;if(n===Rr&&(a=a[1]),e&&!(e>s.length)||!k(a))return r?t:z(n,o++,a,t); +s.push(u),u=a.__iterator(n,i)}else u=s.pop()}return I()})},n}function De(t,e,r){var n=Ue(t);return t.toSeq().map(function(i,u){return n(e.call(r,i,u,t))}).flatten(!0)}function Oe(t,e){var r=Le(t);return r.size=t.size&&2*t.size-1,r.__iterateUncached=function(r,n){var i=this,u=0;return t.__iterate(function(t){return(!u||r(e,u++,i)!==!1)&&r(t,u++,i)!==!1},n),u},r.__iteratorUncached=function(r,n){var i,u=t.__iterator(jr,n),s=0;return new Tr(function(){return(!i||s%2)&&(i=u.next(),i.done)?i:s%2?z(r,s++,e):z(r,s++,i.value,i)})},r}function Ae(t,e,r){e||(e=Be);var n=E(t),i=0,u=t.toSeq().map(function(e,n){return[n,e,i++,r?r(e,n,t):e]}).toArray();return u.sort(function(t,r){return e(t[3],r[3])||t[2]-r[2]}).forEach(n?function(t,e){u[e].length=2}:function(t,e){u[e]=t[1]}),n?$r(u):D(t)?en(u):nn(u)}function Ce(t,e,r){if(e||(e=Be),r){var n=t.toSeq().map(function(e,n){return[e,r(e,n,t)]}).reduce(function(t,r){return e(r[1],t[1])>0?r:t});return n&&n[0]}return t.reduce(function(t,r){return e(r,t)>0?r:t})}function je(t,e){return T(t)?e:t.constructor(e)}function Re(t){if(t!==Object(t))throw new TypeError("Expected [K, V] tuple: "+t)}function Ke(t){return h(t.size),c(t)}function Ue(t){return E(t)?Yr:D(t)?Xr:Fr}function Le(t){return Object.create((E(t)?$r:D(t)?en:nn).prototype)}function Te(){return this._iter.cacheResult?(this._iter.cacheResult(),this.size=this._iter.size,this):Gr.prototype.cacheResult.call(this)}function Be(t,e){return t>e?1:e>t?-1:0}function We(t){return!(!t||!t[Pn])}function Pe(t,e,r,n,i,u){var s,o=t&&t.array;if(0===e){var a=0>r?-r:0,h=n-r;for(h>mr&&(h=mr),s=a;h>s;s++)if(i(o&&o[u?a+h-1-s:s])===!1)return!1}else{var c=1<=s;s++){var _=u?wr-s:s,l=r+(_<l&&l+c>0){var v=o&&o[_];if(!Pe(v,f,l,n,i,u))return!1}}}return!0}function Je(t,e,r,n,i){return{array:t,level:e,offset:r,max:n,rawMax:n-r>>e,index:0,__prev:i}}function He(t,e,r,n,i,u,s){var o=Object.create(Jn);return o.size=e-t,o._origin=t,o._capacity=e,o._level=r,o._root=n,o._tail=i,o.__ownerID=u,o.__hash=s,o.__altered=!1,o}function Ve(){return Yn||(Yn=He(0,0,gr)) +}function Ne(t,e,r){if(e=f(t,e),e>=t.size||0>e)return t.withMutations(function(t){0>e?Fe(t,e).set(0,r):Fe(t,0,e+1).set(e,r)});e+=t._origin;var n=t._tail,i=t._root,s=u(Ir);return e>=Ze(t._capacity)?n=Ye(n,t.__ownerID,0,e,r,s):i=Ye(i,t.__ownerID,t._level,e,r,s),s.value?t.__ownerID?(t._root=i,t._tail=n,t.__hash=void 0,t.__altered=!0,t):He(t._origin,t._capacity,t._level,i,n):t}function Ye(t,e,r,n,i,u){var o=n>>>r&wr,a=t&&t.array.length>o;if(!a&&void 0===i)return t;var h;if(r>0){var c=t&&t.array[o],f=Ye(c,e,r-gr,n,i,u);return f===c?t:(h=Qe(t,e),h.array[o]=f,h)}return a&&t.array[o]===i?t:(s(u),h=Qe(t,e),void 0===i&&o===h.array.length-1?h.array.pop():h.array[o]=i,h)}function Qe(t,e){return e&&t&&e===t.ownerID?t:new Hn(t?t.array.slice():[],e)}function Xe(t,e){if(e>=Ze(t._capacity))return t._tail;if(1<e){for(var r=t._root,n=t._level;r&&n>0;)r=r.array[e>>>n&wr],n-=gr;return r}}function Fe(t,e,r){var n=t.__ownerID||new o,i=t._origin,u=t._capacity,s=i+e,a=void 0===r?u:0>r?u+r:i+r;if(s===i&&a===u)return t;if(s>=a)return t.clear();for(var h=t._level,c=t._root,f=0;0>s+f;)c=new Hn(c&&c.array.length?[void 0,c]:[],n),h+=gr,f+=1<=1<l?Xe(t,a-1):l>_?new Hn([],n):v;if(v&&l>_&&u>s&&v.array.length){c=Qe(c,n);for(var d=c,y=h;y>gr;y-=gr){var g=_>>>y≀d=d.array[g]=Qe(d.array[g],n)}d.array[_>>>gr&wr]=v}if(u>a&&(p=p&&p.removeAfter(n,0,a)),s>=l)s-=l,a-=l,h=gr,c=null,p=p&&p.removeBefore(n,0,s);else if(s>i||_>l){for(f=0;c;){var m=s>>>h≀if(m!==l>>>h&wr)break;m&&(f+=(1<i&&(c=c.removeBefore(n,h,s-f)),c&&_>l&&(c=c.removeAfter(n,h,l-f)),f&&(s-=f,a-=f)}return t.__ownerID?(t.size=a-s,t._origin=s,t._capacity=a,t._level=h,t._root=c,t._tail=p,t.__hash=void 0,t.__altered=!0,t):He(s,a,h,c,p)}function Ge(t,e,r){for(var n=[],i=0,u=0;r.length>u;u++){var s=r[u],o=Xr(s);o.size>i&&(i=o.size),k(s)||(o=o.map(function(t){return Q(t)})),n.push(o)}return i>t.size&&(t=t.setSize(i)),_e(t,e,n)}function Ze(t){return mr>t?0:t-1>>>gr<=mr&&s.size>=2*u.size?(i=s.filter(function(t,e){return void 0!==t&&o!==e}),n=i.toKeyedSeq().map(function(t){return t[0]}).flip().toMap(),t.__ownerID&&(n.__ownerID=i.__ownerID=t.__ownerID)):(n=u.remove(e),i=o===s.size-1?s.pop():s.set(o,void 0))}else if(a){if(r===s.get(o)[1])return t;n=u,i=s.set(o,[e,r])}else n=u.set(e,s.size),i=s.set(s.size,[e,r]);return t.__ownerID?(t.size=n.size,t._map=n,t._list=i,t.__hash=void 0,t):tr(n,i)}function nr(t){return!(!t||!t[$n])}function ir(t,e,r,n){var i=Object.create(ti);return i.size=t,i._head=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function ur(){return ei||(ei=ir(0))}function sr(t){return!(!t||!t[ni])}function or(t,e){return t.__ownerID?(t.size=e.size,t._map=e,t):e===t._map?t:0===e.size?t.__empty():t.__make(e)}function ar(t,e){var r=Object.create(ii);return r.size=t?t.size:0,r._map=t,r.__ownerID=e,r}function hr(){return ui||(ui=ar(re()))}function cr(t){return!(!t||!t[oi])}function fr(t,e){var r=Object.create(ai);return r.size=t?t.size:0,r._map=t,r.__ownerID=e,r}function _r(){return hi||(hi=fr(er()))}function lr(t,e,r){var n=Object.create(Object.getPrototypeOf(t));return n._map=e,n.__ownerID=r,n}function vr(t){return t._name||t.constructor.name}var pr=Object,dr={};dr.createClass=t,dr.superCall=e,dr.defaultSuperCall=r;var yr="delete",gr=5,mr=1<e;e++)t[e]=arguments[e];return je(this,ke(this,t))},contains:function(t){return this.some(function(e){return n(e,t)})},entries:function(){return this.__iterator(Rr)},every:function(t,e){var r=!0;return this.__iterate(function(n,i,u){return t.call(e,n,i,u)?void 0:(r=!1,!1)}),r},filter:function(t,e){return je(this,Se(this,t,e,!0))},find:function(t,e,r){var n=r;return this.__iterate(function(r,i,u){return t.call(e,r,i,u)?(n=r,!1):void 0}),n},forEach:function(t,e){return this.__iterate(e?t.bind(e):t)},join:function(t){t=void 0!==t?""+t:",";var e="",r=!0;return this.__iterate(function(n){r?r=!1:e+=t,e+=null!==n&&void 0!==n?n:""}),e},keys:function(){return this.__iterator(Cr) +},map:function(t,e){return je(this,me(this,t,e))},reduce:function(t,e,r){var n,i;return 2>arguments.length?i=!0:n=e,this.__iterate(function(e,u,s){i?(i=!1,n=e):n=t.call(r,n,e,u,s)}),n},reduceRight:function(){var t=this.toKeyedSeq().reverse();return t.reduce.apply(t,arguments)},reverse:function(){return je(this,we(this,!0))},slice:function(t,e){if(l(t,e,this.size))return this;var r=v(t,this.size),n=p(e,this.size);if(r!==r||n!==n)return this.toSeq().cacheResult().slice(t,e);var i=0===r?this:this.skip(r);return je(this,void 0===n||n===this.size?i:i.take(n-r))},some:function(t,e){return!this.every(j(t),e)},sort:function(t){return je(this,Ae(this,t))},values:function(){return this.__iterator(jr)},butLast:function(){return this.slice(0,-1)},count:function(t,e){return c(t?this.toSeq().filter(t,e):this)},countBy:function(t,e){return ze(this,t,e)},equals:function(t){if(this===t)return!0;if(!t||"function"!=typeof t.equals)return!1;if(void 0!==this.size&&void 0!==t.size){if(this.size!==t.size)return!1;if(0===this.size&&0===t.size)return!0}return void 0!==this.__hash&&void 0!==t.__hash&&this.__hash!==t.__hash?!1:this.__deepEquals(t)},__deepEquals:function(t){var e=this.entries();return"function"==typeof t.every&&t.every(function(t,r){var i=e.next().value;return i&&n(i[0],r)&&n(i[1],t)})&&e.next().done},entrySeq:function(){var t=this;if(t._cache)return new on(t._cache);var e=t.toSeq().map(C).toIndexedSeq();return e.fromEntrySeq=function(){return t.toSeq()},e},filterNot:function(t,e){return this.filter(j(t),e)},findLast:function(t,e,r){return this.toKeyedSeq().reverse().find(t,e,r)},first:function(){return this.find(_)},flatMap:function(t,e){return je(this,De(this,t,e))},flatten:function(t){return je(this,Ee(this,t,!0))},fromEntrySeq:function(){return new Bn(this)},get:function(t,e){return this.find(function(e,r){return n(r,t)},void 0,e)},getIn:function(t,e){var r=this;if(t)for(var n=0;t.length>n;n++)if(r=r&&r.get?r.get(t[n],Sr):Sr,r===Sr)return e;return r},groupBy:function(t,e){return Ie(this,t,e)},has:function(t){return this.get(t,Sr)!==Sr +},isSubset:function(t){return t="function"==typeof t.contains?t:Pr(t),this.every(function(e){return t.contains(e)})},isSuperset:function(t){return t.isSubset(this)},keySeq:function(){return this.toSeq().map(A).toIndexedSeq()},last:function(){return this.toSeq().reverse().first()},max:function(t){return Ce(this,t)},maxBy:function(t,e){return Ce(this,e,t)},min:function(t){return Ce(this,t?R(t):U)},minBy:function(t,e){return Ce(this,e?R(e):U,t)},rest:function(){return this.slice(1)},skip:function(t){return je(this,Me(this,t,!0))},skipLast:function(t){return je(this,this.toSeq().reverse().skip(t).reverse())},skipWhile:function(t,e){return je(this,xe(this,t,e,!0))},skipUntil:function(t,e){return this.skipWhile(j(t),e)},sortBy:function(t,e){return je(this,Ae(this,e,t))},take:function(t){return je(this,be(this,t))},takeLast:function(t){return je(this,this.toSeq().reverse().take(t).reverse())},takeWhile:function(t,e){return je(this,qe(this,t,e))},takeUntil:function(t,e){return this.takeWhile(j(t),e)},valueSeq:function(){return this.toIndexedSeq()},hashCode:function(){return this.__hash||(this.__hash=1/0===this.size?0:this.reduce(function(t,e,r){return t+(y(e)^(e===r?0:y(r)))&Mr},0))}},{});var Jr="@@__IMMUTABLE_ITERABLE__@@",Hr="@@__IMMUTABLE_KEYED__@@",Vr="@@__IMMUTABLE_INDEXED__@@",Nr=Wr.prototype;Nr[Jr]=!0,Nr[Lr]=Nr.values,Nr.toJSON=Nr.toJS,Nr.__toJS=Nr.toArray,Nr.__toStringMapper=K,Nr.inspect=Nr.toSource=function(){return""+this},Nr.chain=Nr.flatMap,function(){try{Object.defineProperty(Nr,"length",{get:function(){if(!Wr.noLengthWarning){var t;try{throw Error()}catch(e){t=e.stack}if(-1===t.indexOf("_wrapObject"))return console&&console.warn&&console.warn("iterable.length has been deprecated, use iterable.size or iterable.count(). This warning will become a silent error in a future version. "+t),this.size}}})}catch(t){}}();var Yr=function(t){return E(t)?t:$r(t)};dr.createClass(Yr,{flip:function(){return je(this,ge(this))},findKey:function(t,e){var r;return this.__iterate(function(n,i,u){return t.call(e,n,i,u)?(r=i,!1):void 0 +}),r},findLastKey:function(t,e){return this.toSeq().reverse().findKey(t,e)},keyOf:function(t){return this.findKey(function(e){return n(e,t)})},lastKeyOf:function(t){return this.toSeq().reverse().keyOf(t)},mapEntries:function(t,e){var r=this,n=0;return je(this,this.toSeq().map(function(i,u){return t.call(e,[u,i],n++,r)}).fromEntrySeq())},mapKeys:function(t,e){var r=this;return je(this,this.toSeq().flip().map(function(n,i){return t.call(e,n,i,r)}).flip())}},{},Wr);var Qr=Yr.prototype;Qr[Hr]=!0,Qr[Lr]=Nr.entries,Qr.__toJS=Nr.toObject,Qr.__toStringMapper=function(t,e){return e+": "+K(t)};var Xr=function(t){return D(t)?t:en(t)};dr.createClass(Xr,{toKeyedSeq:function(){return new Un(this,!1)},filter:function(t,e){return je(this,Se(this,t,e,!1))},findIndex:function(t,e){var r=this.toKeyedSeq().findKey(t,e);return void 0===r?-1:r},indexOf:function(t){var e=this.toKeyedSeq().keyOf(t);return void 0===e?-1:e},lastIndexOf:function(t){var e=this.toKeyedSeq().lastKeyOf(t);return void 0===e?-1:e},reverse:function(){return je(this,we(this,!1))},splice:function(t,e){var r=arguments.length;if(e=Math.max(0|e,0),0===r||2===r&&!e)return this;t=v(t,this.size);var n=this.slice(0,t);return je(this,1===r?n:n.concat(a(arguments,2),this.slice(t+e)))},findLastIndex:function(t,e){var r=this.toKeyedSeq().findLastKey(t,e);return void 0===r?-1:r},first:function(){return this.get(0)},flatten:function(t){return je(this,Ee(this,t,!1))},get:function(t,e){return t=f(this,t),0>t||1/0===this.size||void 0!==this.size&&t>this.size?e:this.find(function(e,r){return r===t},void 0,e)},has:function(t){return t=f(this,t),t>=0&&(void 0!==this.size?1/0===this.size||this.size>t:-1!==this.indexOf(t))},interpose:function(t){return je(this,Oe(this,t))},last:function(){return this.get(-1)},skip:function(t){var e=this,r=Me(e,t,!1);return T(e)&&r!==e&&(r.get=function(r,n){return r=f(this,r),r>=0?e.get(r+t,n):n}),je(this,r)},skipWhile:function(t,e){return je(this,xe(this,t,e,!1))},take:function(t){var e=this,r=be(e,t);return T(e)&&r!==e&&(r.get=function(r,n){return r=f(this,r),r>=0&&t>r?e.get(r,n):n +}),je(this,r)}},{},Wr),Xr.prototype[Vr]=!0;var Fr=function(t){return k(t)&&!O(t)?t:nn(t)};dr.createClass(Fr,{get:function(t,e){return this.has(t)?t:e},contains:function(t){return this.has(t)},keySeq:function(){return this.valueSeq()}},{},Wr),Fr.prototype.has=Nr.contains,Wr.isIterable=k,Wr.isKeyed=E,Wr.isIndexed=D,Wr.isAssociative=O,Wr.Keyed=Yr,Wr.Indexed=Xr,Wr.Set=Fr,Wr.Iterator=Tr;var Gr=function(t){return null===t||void 0===t?B():k(t)?t.toSeq():J(t)},Zr=Gr;dr.createClass(Gr,{toSeq:function(){return this},toString:function(){return this.__toString("Seq {","}")},cacheResult:function(){return!this._cache&&this.__iterateUncached&&(this._cache=this.entrySeq().toArray(),this.size=this._cache.length),this},__iterate:function(t,e){return N(this,t,e,!0)},__iterator:function(t,e){return Y(this,t,e,!0)}},{of:function(){return Zr(arguments)}},Wr);var $r=function(t){return null===t||void 0===t?B().toKeyedSeq():k(t)?E(t)?t.toSeq():t.fromEntrySeq():W(t)},tn=$r;dr.createClass($r,{toKeyedSeq:function(){return this},toSeq:function(){return this}},{of:function(){return tn(arguments)}},Gr),L($r,Yr.prototype);var en=function(t){return null===t||void 0===t?B():k(t)?E(t)?t.entrySeq():t.toIndexedSeq():P(t)},rn=en;dr.createClass(en,{toIndexedSeq:function(){return this},toString:function(){return this.__toString("Seq [","]")},__iterate:function(t,e){return N(this,t,e,!1)},__iterator:function(t,e){return Y(this,t,e,!1)}},{of:function(){return rn(arguments)}},Gr),L(en,Xr.prototype);var nn=function(t){return(null===t||void 0===t?B():k(t)?E(t)?t.entrySeq():t:P(t)).toSetSeq()},un=nn;dr.createClass(nn,{toSetSeq:function(){return this}},{of:function(){return un(arguments)}},Gr),L(nn,Fr.prototype),Gr.isSeq=T,Gr.Keyed=$r,Gr.Set=nn,Gr.Indexed=en;var sn="@@__IMMUTABLE_SEQ__@@";Gr.prototype[sn]=!0;var on=function(t){this._array=t,this.size=t.length};dr.createClass(on,{get:function(t,e){return this.has(t)?this._array[f(this,t)]:e},__iterate:function(t,e){for(var r=this._array,n=r.length-1,i=0;n>=i;i++)if(t(r[e?n-i:i],i,this)===!1)return i+1;return i},__iterator:function(t,e){var r=this._array,n=r.length-1,i=0; +return new Tr(function(){return i>n?I():z(t,i,r[e?n-i++:i++])})}},{},en);var an=function(t){var e=Object.keys(t);this._object=t,this._keys=e,this.size=e.length};dr.createClass(an,{get:function(t,e){return void 0===e||this.has(t)?this._object[t]:e},has:function(t){return this._object.hasOwnProperty(t)},__iterate:function(t,e){for(var r=this._object,n=this._keys,i=n.length-1,u=0;i>=u;u++){var s=n[e?i-u:u];if(t(r[s],s,this)===!1)return u+1}return u},__iterator:function(t,e){var r=this._object,n=this._keys,i=n.length-1,u=0;return new Tr(function(){var s=n[e?i-u:u];return u++>i?I():z(t,s,r[s])})}},{},$r);var hn=function(t){this._iterable=t,this.size=t.length||t.size};dr.createClass(hn,{__iterateUncached:function(t,e){if(e)return this.cacheResult().__iterate(t,e);var r=this._iterable,n=M(r),i=0;if(q(n))for(var u;!(u=n.next()).done&&t(u.value,i++,this)!==!1;);return i},__iteratorUncached:function(t,e){if(e)return this.cacheResult().__iterator(t,e);var r=this._iterable,n=M(r);if(!q(n))return new Tr(I);var i=0;return new Tr(function(){var e=n.next();return e.done?e:z(t,i++,e.value)})}},{},en);var cn=function(t){this._iterator=t,this._iteratorCache=[]};dr.createClass(cn,{__iterateUncached:function(t,e){if(e)return this.cacheResult().__iterate(t,e);for(var r=this._iterator,n=this._iteratorCache,i=0;n.length>i;)if(t(n[i],i++,this)===!1)return i;for(var u;!(u=r.next()).done;){var s=u.value;if(n[i]=s,t(s,i++,this)===!1)break}return i},__iteratorUncached:function(t,e){if(e)return this.cacheResult().__iterator(t,e);var r=this._iterator,n=this._iteratorCache,i=0;return new Tr(function(){if(i>=n.length){var e=r.next();if(e.done)return e;n[i]=e.value}return z(t,i,n[i++])})}},{},en);var fn,_n=function(){throw TypeError("Abstract")};dr.createClass(_n,{},{},Wr);var ln=function(){dr.defaultSuperCall(this,vn.prototype,arguments)},vn=ln;dr.createClass(ln,{},{},_n),L(ln,Yr.prototype);var pn=function(){dr.defaultSuperCall(this,dn.prototype,arguments)},dn=pn;dr.createClass(pn,{},{},_n),L(pn,Xr.prototype);var yn=function(){dr.defaultSuperCall(this,gn.prototype,arguments) +},gn=yn;dr.createClass(yn,{},{},_n),L(yn,Fr.prototype),_n.Keyed=ln,_n.Indexed=pn,_n.Set=yn;var mn=function(t){return null===t||void 0===t?re():Z(t)?t:re().merge(Yr(t))};dr.createClass(mn,{toString:function(){return this.__toString("Map {","}")},get:function(t,e){return this._root?this._root.get(0,void 0,t,e):e},set:function(t,e){return ne(this,t,e)},setIn:function(t,e){return i(t.length>0,"Requires non-empty key path."),this.updateIn(t,function(){return e})},remove:function(t){return ne(this,t,Sr)},removeIn:function(t){return i(t.length>0,"Requires non-empty key path."),this.updateIn(t,function(){return Sr})},update:function(t,e,r){return 1===arguments.length?t(this):this.updateIn([t],e,r)},updateIn:function(t,e,r){return r||(r=e,e=void 0),0===t.length?r(this):le(this,t,e,r,0)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):re()},merge:function(){return ce(this,void 0,arguments)},mergeWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return ce(this,t,e)},mergeDeep:function(){return ce(this,fe(void 0),arguments)},mergeDeepWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return ce(this,fe(t),e)},sort:function(t){return Qn(Ae(this,t))},sortBy:function(t,e){return Qn(Ae(this,e,t))},withMutations:function(t){var e=this.asMutable();return t(e),e.wasAltered()?e.__ensureOwner(this.__ownerID):this},asMutable:function(){return this.__ownerID?this:this.__ensureOwner(new o)},asImmutable:function(){return this.__ensureOwner()},wasAltered:function(){return this.__altered},__iterator:function(t,e){return new An(this,t,e)},__iterate:function(t,e){var r=this,n=0;return this._root&&this._root.iterate(function(e){return n++,t(e[1],e[0],r)},e),n},__ensureOwner:function(t){return t===this.__ownerID?this:t?ee(this.size,this._root,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)}},{},ln),mn.isMap=Z;var wn="@@__IMMUTABLE_MAP__@@",Sn=mn.prototype;Sn[wn]=!0,Sn[yr]=Sn.remove;var zn=function(t,e){this.ownerID=t,this.entries=e +},In=zn;dr.createClass(zn,{get:function(t,e,r,i){for(var u=this.entries,s=0,o=u.length;o>s;s++)if(n(r,u[s][0]))return u[s][1];return i},update:function(t,e,r,i,u,o,h){for(var c=u===Sr,f=this.entries,_=0,l=f.length;l>_&&!n(i,f[_][0]);_++);var v=l>_;if(v?f[_][1]===u:c)return this;if(s(h),(c||!v)&&s(o),!c||1!==f.length){if(!v&&!c&&f.length>=jn)return oe(t,f,i,u);var p=t&&t===this.ownerID,d=p?f:a(f);return v?c?_===l-1?d.pop():d[_]=d.pop():d[_]=[i,u]:d.push([i,u]),p?(this.entries=d,this):new In(t,d)}}},{});var bn=function(t,e,r){this.ownerID=t,this.bitmap=e,this.nodes=r},qn=bn;dr.createClass(bn,{get:function(t,e,r,n){void 0===e&&(e=y(r));var i=1<<((0===t?e:e>>>t)&wr),u=this.bitmap;return 0===(u&i)?n:this.nodes[ve(u&i-1)].get(t+gr,e,r,n)},update:function(t,e,r,n,i,u,s){void 0===r&&(r=y(n));var o=(0===e?r:r>>>e)&wr,a=1<=Rn)return he(t,_,h,o,v);if(c&&!v&&2===_.length&&ue(_[1^f]))return _[1^f];if(c&&v&&1===_.length&&ue(v))return v;var p=t&&t===this.ownerID,d=c?v?h:h^a:h|a,g=c?v?pe(_,f,v,p):ye(_,f,p):de(_,f,v,p);return p?(this.bitmap=d,this.nodes=g,this):new qn(t,d,g)}},{});var Mn=function(t,e,r){this.ownerID=t,this.count=e,this.nodes=r},xn=Mn;dr.createClass(Mn,{get:function(t,e,r,n){void 0===e&&(e=y(r));var i=(0===t?e:e>>>t)&wr,u=this.nodes[i];return u?u.get(t+gr,e,r,n):n},update:function(t,e,r,n,i,u,s){void 0===r&&(r=y(n));var o=(0===e?r:r>>>e)&wr,a=i===Sr,h=this.nodes,c=h[o];if(a&&!c)return this;var f=ie(c,t,e+gr,r,n,i,u,s);if(f===c)return this;var _=this.count;if(c){if(!f&&(_--,Kn>_))return ae(t,h,_,o)}else _++;var l=t&&t===this.ownerID,v=pe(h,o,f,l);return l?(this.count=_,this.nodes=v,this):new xn(t,_,v)}},{});var kn=function(t,e,r){this.ownerID=t,this.keyHash=e,this.entries=r},En=kn;dr.createClass(kn,{get:function(t,e,r,i){for(var u=this.entries,s=0,o=u.length;o>s;s++)if(n(r,u[s][0]))return u[s][1];return i},update:function(t,e,r,i,u,o,h){void 0===r&&(r=y(i)); +var c=u===Sr;if(r!==this.keyHash)return c?this:(s(h),s(o),se(this,t,e,r,[i,u]));for(var f=this.entries,_=0,l=f.length;l>_&&!n(i,f[_][0]);_++);var v=l>_;if(v?f[_][1]===u:c)return this;if(s(h),(c||!v)&&s(o),c&&2===l)return new Dn(t,this.keyHash,f[1^_]);var p=t&&t===this.ownerID,d=p?f:a(f);return v?c?_===l-1?d.pop():d[_]=d.pop():d[_]=[i,u]:d.push([i,u]),p?(this.entries=d,this):new En(t,this.keyHash,d)}},{});var Dn=function(t,e,r){this.ownerID=t,this.keyHash=e,this.entry=r},On=Dn;dr.createClass(Dn,{get:function(t,e,r,i){return n(r,this.entry[0])?this.entry[1]:i},update:function(t,e,r,i,u,o,a){var h=u===Sr,c=n(i,this.entry[0]);return(c?u===this.entry[1]:h)?this:(s(a),h?void s(o):c?t&&t===this.ownerID?(this.entry[1]=u,this):new On(t,this.keyHash,[i,u]):(s(o),se(this,t,e,y(i),[i,u])))}},{}),zn.prototype.iterate=kn.prototype.iterate=function(t,e){for(var r=this.entries,n=0,i=r.length-1;i>=n;n++)if(t(r[e?i-n:n])===!1)return!1},bn.prototype.iterate=Mn.prototype.iterate=function(t,e){for(var r=this.nodes,n=0,i=r.length-1;i>=n;n++){var u=r[e?i-n:n];if(u&&u.iterate(t,e)===!1)return!1}},Dn.prototype.iterate=function(t){return t(this.entry)};var An=function(t,e,r){this._type=e,this._reverse=r,this._stack=t._root&&te(t._root)};dr.createClass(An,{next:function(){for(var t=this._type,e=this._stack;e;){var r,n=e.node,i=e.index++;if(n.entry){if(0===i)return $(t,n.entry)}else if(n.entries){if(r=n.entries.length-1,r>=i)return $(t,n.entries[this._reverse?r-i:i])}else if(r=n.nodes.length-1,r>=i){var u=n.nodes[this._reverse?r-i:i];if(u){if(u.entry)return $(t,u.entry);e=this._stack=te(u,e)}continue}e=this._stack=this._stack.__prev}return I()}},{},Tr);var Cn,jn=mr/4,Rn=mr/2,Kn=mr/4,Un=function(t,e){this._iter=t,this._useKeys=e,this.size=t.size};dr.createClass(Un,{get:function(t,e){return this._iter.get(t,e)},has:function(t){return this._iter.has(t)},valueSeq:function(){return this._iter.valueSeq()},reverse:function(){var t=this,e=we(this,!0);return this._useKeys||(e.valueSeq=function(){return t._iter.toSeq().reverse()}),e},map:function(t,e){var r=this,n=me(this,t,e); +return this._useKeys||(n.valueSeq=function(){return r._iter.toSeq().map(t,e)}),n},__iterate:function(t,e){var r,n=this;return this._iter.__iterate(this._useKeys?function(e,r){return t(e,r,n)}:(r=e?Ke(this):0,function(i){return t(i,e?--r:r++,n)}),e)},__iterator:function(t,e){if(this._useKeys)return this._iter.__iterator(t,e);var r=this._iter.__iterator(jr,e),n=e?Ke(this):0;return new Tr(function(){var i=r.next();return i.done?i:z(t,e?--n:n++,i.value,i)})}},{},$r);var Ln=function(t){this._iter=t,this.size=t.size};dr.createClass(Ln,{contains:function(t){return this._iter.contains(t)},__iterate:function(t,e){var r=this,n=0;return this._iter.__iterate(function(e){return t(e,n++,r)},e)},__iterator:function(t,e){var r=this._iter.__iterator(jr,e),n=0;return new Tr(function(){var e=r.next();return e.done?e:z(t,n++,e.value,e)})}},{},en);var Tn=function(t){this._iter=t,this.size=t.size};dr.createClass(Tn,{has:function(t){return this._iter.contains(t)},__iterate:function(t,e){var r=this;return this._iter.__iterate(function(e){return t(e,e,r)},e)},__iterator:function(t,e){var r=this._iter.__iterator(jr,e);return new Tr(function(){var e=r.next();return e.done?e:z(t,e.value,e.value,e)})}},{},nn);var Bn=function(t){this._iter=t,this.size=t.size};dr.createClass(Bn,{entrySeq:function(){return this._iter.toSeq()},__iterate:function(t,e){var r=this;return this._iter.__iterate(function(e){return e?(Re(e),t(e[1],e[0],r)):void 0},e)},__iterator:function(t,e){var r=this._iter.__iterator(jr,e);return new Tr(function(){for(;;){var e=r.next();if(e.done)return e;var n=e.value;if(n)return Re(n),t===Rr?e:z(t,n[0],n[1],e)}})}},{},$r),Ln.prototype.cacheResult=Un.prototype.cacheResult=Tn.prototype.cacheResult=Bn.prototype.cacheResult=Te;var Wn=function(t){var e=Ve();if(null===t||void 0===t)return e;if(We(t))return t;t=Xr(t);var r=t.size;return 0===r?e:r>0&&mr>r?He(0,r,gr,null,new Hn(t.toArray())):e.merge(t)};dr.createClass(Wn,{toString:function(){return this.__toString("List [","]")},get:function(t,e){if(t=f(this,t),0>t||t>=this.size)return e;t+=this._origin; +var r=Xe(this,t);return r&&r.array[t&wr]},set:function(t,e){return Ne(this,t,e)},remove:function(t){return this.has(t)?0===t?this.shift():t===this.size-1?this.pop():this.splice(t,1):this},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=this._origin=this._capacity=0,this._level=gr,this._root=this._tail=null,this.__hash=void 0,this.__altered=!0,this):Ve()},push:function(){var t=arguments,e=this.size;return this.withMutations(function(r){Fe(r,0,e+t.length);for(var n=0;t.length>n;n++)r.set(e+n,t[n])})},pop:function(){return Fe(this,0,-1)},unshift:function(){var t=arguments;return this.withMutations(function(e){Fe(e,-t.length);for(var r=0;t.length>r;r++)e.set(r,t[r])})},shift:function(){return Fe(this,1)},merge:function(){return Ge(this,void 0,arguments)},mergeWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ge(this,t,e)},mergeDeep:function(){return Ge(this,fe(void 0),arguments)},mergeDeepWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ge(this,fe(t),e)},setSize:function(t){return Fe(this,0,t)},slice:function(t,e){var r=this.size;return l(t,e,r)?this:Fe(this,v(t,r),p(e,r))},__iterator:function(t,e){return new Nn(this,t,e)},__iterate:function(t,e){var r=this,n=0,i=function(e){return t(e,n++,r)},u=Ze(this._capacity);return e?Pe(this._tail,0,u-this._origin,this._capacity-this._origin,i,e)&&Pe(this._root,this._level,-this._origin,u-this._origin,i,e):Pe(this._root,this._level,-this._origin,u-this._origin,i,e)&&Pe(this._tail,0,u-this._origin,this._capacity-this._origin,i,e),n},__ensureOwner:function(t){return t===this.__ownerID?this:t?He(this._origin,this._capacity,this._level,this._root,this._tail,t,this.__hash):(this.__ownerID=t,this)}},{of:function(){return this(arguments)}},pn),Wn.isList=We;var Pn="@@__IMMUTABLE_LIST__@@",Jn=Wn.prototype;Jn[Pn]=!0,Jn[yr]=Jn.remove,Jn.setIn=Sn.setIn,Jn.removeIn=Sn.removeIn,Jn.update=Sn.update,Jn.updateIn=Sn.updateIn,Jn.withMutations=Sn.withMutations,Jn.asMutable=Sn.asMutable,Jn.asImmutable=Sn.asImmutable,Jn.wasAltered=Sn.wasAltered; +var Hn=function(t,e){this.array=t,this.ownerID=e},Vn=Hn;dr.createClass(Hn,{removeBefore:function(t,e,r){if(r===e?1<>>e≀if(n>=this.array.length)return new Vn([],t);var i,u=0===n;if(e>0){var s=this.array[n];if(i=s&&s.removeBefore(t,e-gr,r),i===s&&u)return this}if(u&&!i)return this;var o=Qe(this,t);if(!u)for(var a=0;n>a;a++)o.array[a]=void 0;return i&&(o.array[n]=i),o},removeAfter:function(t,e,r){if(r===e?1<>>e≀if(n>=this.array.length)return this;var i,u=n===this.array.length-1;if(e>0){var s=this.array[n];if(i=s&&s.removeAfter(t,e-gr,r),i===s&&u)return this}if(u&&!i)return this;var o=Qe(this,t);return u||o.array.pop(),i&&(o.array[n]=i),o}},{});var Nn=function(t,e,r){this._type=e,this._reverse=!!r,this._maxIndex=t.size-1;var n=Ze(t._capacity),i=Je(t._root&&t._root.array,t._level,-t._origin,n-t._origin-1),u=Je(t._tail&&t._tail.array,0,n-t._origin,t._capacity-t._origin-1);this._stack=r?u:i,this._stack.__prev=r?i:u};dr.createClass(Nn,{next:function(){for(var t=this._stack;t;){var e=t.array,r=t.index++;if(this._reverse&&(r=wr-r,r>t.rawMax&&(r=t.rawMax,t.index=mr-r)),r>=0&&mr>r&&t.rawMax>=r){var n=e&&e[r];if(0===t.level){var i,u=this._type;return 1!==u&&(i=t.offset+(r<=0;r--)e={value:arguments[r],next:e};return this.__ownerID?(this.size=t,this._head=e,this.__hash=void 0,this.__altered=!0,this):ir(t,e)},pushAll:function(t){if(t=Xr(t),0===t.size)return this;var e=this.size,r=this._head;return t.reverse().forEach(function(t){e++,r={value:t,next:r}}),this.__ownerID?(this.size=e,this._head=r,this.__hash=void 0,this.__altered=!0,this):ir(e,r)},pop:function(){return this.slice(1)},unshift:function(){return this.push.apply(this,arguments)},unshiftAll:function(t){return this.pushAll(t)},shift:function(){return this.pop.apply(this,arguments)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):ur()},slice:function(t,e){if(l(t,e,this.size))return this;var r=v(t,this.size),n=p(e,this.size);if(n!==this.size)return dr.superCall(this,Zn.prototype,"slice",[t,e]);for(var i=this.size-r,u=this._head;r--;)u=u.next;return this.__ownerID?(this.size=i,this._head=u,this.__hash=void 0,this.__altered=!0,this):ir(i,u)},__ensureOwner:function(t){return t===this.__ownerID?this:t?ir(this.size,this._head,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)},__iterate:function(t,e){if(e)return this.toSeq().cacheResult.__iterate(t,e); +for(var r=0,n=this._head;n&&t(n.value,r++,this)!==!1;)n=n.next;return r},__iterator:function(t,e){if(e)return this.toSeq().cacheResult().__iterator(t,e);var r=0,n=this._head;return new Tr(function(){if(n){var e=n.value;return n=n.next,z(t,r++,e)}return I()})}},{of:function(){return this(arguments)}},pn),Gn.isStack=nr;var $n="@@__IMMUTABLE_STACK__@@",ti=Gn.prototype;ti[$n]=!0,ti.withMutations=Sn.withMutations,ti.asMutable=Sn.asMutable,ti.asImmutable=Sn.asImmutable,ti.wasAltered=Sn.wasAltered;var ei,ri=function(t){return null===t||void 0===t?hr():sr(t)?t:hr().union(Fr(t))};dr.createClass(ri,{toString:function(){return this.__toString("Set {","}")},has:function(t){return this._map.has(t)},add:function(t){return or(this,this._map.set(t,!0))},remove:function(t){return or(this,this._map.remove(t))},clear:function(){return or(this,this._map.clear())},union:function(){var t=arguments;return 0===t.length?this:this.withMutations(function(e){for(var r=0;t.length>r;r++)Fr(t[r]).forEach(function(t){return e.add(t)})})},intersect:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return Fr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.every(function(t){return t.contains(r)})||e.remove(r)})})},subtract:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return Fr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.some(function(t){return t.contains(r)})&&e.remove(r)})})},merge:function(){return this.union.apply(this,arguments)},mergeWith:function(){for(var t=[],e=1;arguments.length>e;e++)t[e-1]=arguments[e];return this.union.apply(this,t)},sort:function(t){return si(Ae(this,t))},sortBy:function(t,e){return si(Ae(this,e,t))},wasAltered:function(){return this._map.wasAltered()},__iterate:function(t,e){var r=this;return this._map.__iterate(function(e,n){return t(n,n,r)},e)},__iterator:function(t,e){return this._map.map(function(t,e){return e}).__iterator(t,e) +},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t);return t?this.__make(e,t):(this.__ownerID=t,this._map=e,this)}},{of:function(){return this(arguments)},fromKeys:function(t){return this(Yr(t).keySeq())}},yn),ri.isSet=sr;var ni="@@__IMMUTABLE_SET__@@",ii=ri.prototype;ii[ni]=!0,ii[yr]=ii.remove,ii.mergeDeep=ii.merge,ii.mergeDeepWith=ii.mergeWith,ii.withMutations=Sn.withMutations,ii.asMutable=Sn.asMutable,ii.asImmutable=Sn.asImmutable,ii.__empty=hr,ii.__make=ar;var ui,si=function(t){return null===t||void 0===t?_r():cr(t)?t:_r().union(Fr(t))};dr.createClass(si,{toString:function(){return this.__toString("OrderedSet {","}")}},{of:function(){return this(arguments)},fromKeys:function(t){return this(Yr(t).keySeq())}},ri),si.isOrderedSet=cr;var oi="@@__IMMUTABLE_ORDERED_SET__@@",ai=si.prototype;ai[oi]=!0,ai.__empty=_r,ai.__make=fr;var hi,ci=function(t,e){var r=function(t){return this instanceof r?void(this._map=mn(t)):new r(t)},n=Object.keys(t),u=r.prototype=Object.create(fi);u.constructor=r,e&&(u._name=e),u._defaultValues=t,u._keys=n,u.size=n.length;try{n.forEach(function(t){Object.defineProperty(r.prototype,t,{get:function(){return this.get(t)},set:function(e){i(this.__ownerID,"Cannot set on an immutable record."),this.set(t,e)}})})}catch(s){}return r};dr.createClass(ci,{toString:function(){return this.__toString(vr(this)+" {","}")},has:function(t){return this._defaultValues.hasOwnProperty(t)},get:function(t,e){if(!this.has(t))return e;var r=this._defaultValues[t];return this._map?this._map.get(t,r):r},clear:function(){if(this.__ownerID)return this._map&&this._map.clear(),this;var t=Object.getPrototypeOf(this).constructor;return t._empty||(t._empty=lr(this,re()))},set:function(t,e){if(!this.has(t))throw Error('Cannot set unknown key "'+t+'" on '+vr(this));var r=this._map&&this._map.set(t,e);return this.__ownerID||r===this._map?this:lr(this,r)},remove:function(t){if(!this.has(t))return this;var e=this._map&&this._map.remove(t);return this.__ownerID||e===this._map?this:lr(this,e) +},wasAltered:function(){return this._map.wasAltered()},__iterator:function(t,e){var r=this;return Yr(this._defaultValues).map(function(t,e){return r.get(e)}).__iterator(t,e)},__iterate:function(t,e){var r=this;return Yr(this._defaultValues).map(function(t,e){return r.get(e)}).__iterate(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map&&this._map.__ensureOwner(t);return t?lr(this,e,t):(this.__ownerID=t,this._map=e,this)}},{},ln);var fi=ci.prototype;fi[yr]=fi.remove,fi.merge=Sn.merge,fi.mergeWith=Sn.mergeWith,fi.mergeDeep=Sn.mergeDeep,fi.mergeDeepWith=Sn.mergeDeepWith,fi.update=Sn.update,fi.updateIn=Sn.updateIn,fi.withMutations=Sn.withMutations,fi.asMutable=Sn.asMutable,fi.asImmutable=Sn.asImmutable;var _i=function(t,e,r){return this instanceof li?(i(0!==r,"Cannot step a Range by 0"),t=t||0,void 0===e&&(e=1/0),t===e&&pi?pi:(r=void 0===r?1:Math.abs(r),t>e&&(r=-r),this._start=t,this._end=e,this._step=r,void(this.size=Math.max(0,Math.ceil((e-t)/r-1)+1)))):new li(t,e,r)},li=_i;dr.createClass(_i,{toString:function(){return 0===this.size?"Range []":"Range [ "+this._start+"..."+this._end+(this._step>1?" by "+this._step:"")+" ]"},get:function(t,e){return this.has(t)?this._start+f(this,t)*this._step:e},contains:function(t){var e=(t-this._start)/this._step;return e>=0&&this.size>e&&e===Math.floor(e)},slice:function(t,e){return l(t,e,this.size)?this:(t=v(t,this.size),e=p(e,this.size),t>=e?pi:new li(this.get(t,this._end),this.get(e,this._end),this._step))},indexOf:function(t){var e=t-this._start;if(e%this._step===0){var r=e/this._step;if(r>=0&&this.size>r)return r}return-1},lastIndexOf:function(t){return this.indexOf(t)},take:function(t){return this.slice(0,Math.max(0,t))},skip:function(t){return this.slice(Math.max(0,t))},__iterate:function(t,e){for(var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;r>=u;u++){if(t(i,u,this)===!1)return u+1;i+=e?-n:n}return u},__iterator:function(t,e){var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;return new Tr(function(){var s=i; +return i+=e?-n:n,u>r?I():z(t,u++,s)})},__deepEquals:function(t){return t instanceof li?this._start===t._start&&this._end===t._end&&this._step===t._step:dr.superCall(this,li.prototype,"__deepEquals",[t])}},{},en);var vi=_i.prototype;vi.__toJS=vi.toArray,vi.first=Jn.first,vi.last=Jn.last;var pi=_i(0,0),di=function(t,e){return 0>=e&&mi?mi:this instanceof yi?(this._value=t,this.size=void 0===e?1/0:Math.max(0,e),void(0===this.size&&(mi=this))):new yi(t,e)},yi=di;dr.createClass(di,{toString:function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},get:function(t,e){return this.has(t)?this._value:e},contains:function(t){return n(this._value,t)},slice:function(t,e){var r=this.size;return l(t,e,r)?this:new yi(this._value,p(e,r)-v(t,r))},reverse:function(){return this},indexOf:function(t){return n(this._value,t)?0:-1},lastIndexOf:function(t){return n(this._value,t)?this.size:-1},__iterate:function(t){for(var e=0;this.size>e;e++)if(t(this._value,e,this)===!1)return e+1;return e},__iterator:function(t){var e=this,r=0;return new Tr(function(){return e.size>r?z(t,r++,e._value):I()})},__deepEquals:function(t){return t instanceof yi?n(this._value,t._value):dr.superCall(this,yi.prototype,"__deepEquals",[t])}},{},en);var gi=di.prototype;gi.last=gi.first,gi.has=vi.has,gi.take=vi.take,gi.skip=vi.skip,gi.__toJS=vi.__toJS;var mi,wi={Iterable:Wr,Seq:Gr,Collection:_n,Map:mn,OrderedMap:Qn,List:Wn,Stack:Gn,Set:ri,OrderedSet:si,Record:ci,Range:_i,Repeat:di,is:n,fromJS:Q};return wi}"object"==typeof exports?module.exports=t():"function"==typeof define&&define.amd?define(t):Immutable=t(); \ No newline at end of file diff --git a/ajax/libs/immutable/package.json b/ajax/libs/immutable/package.json index dc8d718f5..f28521f4a 100644 --- a/ajax/libs/immutable/package.json +++ b/ajax/libs/immutable/package.json @@ -1,7 +1,7 @@ { "name": "immutable", "filename": "immutable.min.js", - "version": "3.0.3", + "version": "3.1.0", "description": "Immutable Data Collections", "keywords": [ "immutable",