From 7f6884cea8f74b96f9097d922729de8c110e2376 Mon Sep 17 00:00:00 2001 From: Mahdi Dibaiee Date: Sun, 6 Sep 2015 15:53:48 +0430 Subject: [PATCH] feat search: search files, depth-first feat files.view: Open files using Web Activities feat copy/paste: Copy and Paste/Move files fix filters: add "all" filter which clears filters out --- README.md | 11 +- build/img/Search.png | Bin 0 -> 690 bytes build/img/Search.svg | 14 + build/index.html | 2 +- build/main.js | 13678 ++++++++++++++++---------- build/style.css | 171 +- design/userinterface.sketch | Bin 2277376 -> 2293760 bytes package.json | 2 + src/img/Search.png | Bin 0 -> 690 bytes src/img/Search.svg | 14 + src/index.html | 2 +- src/js/actions/file.js | 19 +- src/js/actions/files-view.js | 16 +- src/js/actions/list-files.js | 8 - src/js/actions/spinner.js | 22 + src/js/actions/types.js | 4 + src/js/api/files.js | 16 +- src/js/components/breadcrumb.js | 4 +- src/js/components/directory.js | 30 +- src/js/components/file-list.js | 20 +- src/js/components/file.js | 35 +- src/js/components/header.js | 24 +- src/js/components/menu.js | 5 +- src/js/components/mixins/entry.js | 26 + src/js/components/navigation.js | 72 +- src/js/components/root.js | 35 +- src/js/components/spinner.js | 28 + src/js/components/toolbar.js | 2 +- src/js/dialogs.js | 26 +- src/js/menus.js | 58 +- src/js/reducers/all.js | 5 + src/js/reducers/cwd.js | 2 +- src/js/reducers/files.js | 64 +- src/js/reducers/search.js | 50 + src/js/reducers/spinner.js | 21 + src/js/store.js | 3 +- src/less/components/all.less | 1 + src/less/components/breadcrumb.less | 12 +- src/less/components/dialog.less | 7 +- src/less/components/entries.less | 4 + src/less/components/file-list.less | 2 +- src/less/components/header.less | 6 + src/less/components/menu.less | 8 +- src/less/components/navigation.less | 39 +- src/less/components/spinner.less | 56 + src/less/icons.less | 15 + src/less/main.less | 6 + src/less/styles/all.less | 34 + src/less/styles/forms.less | 11 +- src/less/variables.less | 1 + 50 files changed, 9157 insertions(+), 5534 deletions(-) create mode 100644 build/img/Search.png create mode 100644 build/img/Search.svg create mode 100644 src/img/Search.png create mode 100644 src/img/Search.svg delete mode 100644 src/js/actions/list-files.js create mode 100644 src/js/actions/spinner.js create mode 100644 src/js/components/mixins/entry.js create mode 100644 src/js/components/spinner.js create mode 100644 src/js/reducers/search.js create mode 100644 src/js/reducers/spinner.js create mode 100644 src/less/components/spinner.less diff --git a/README.md b/README.md index 36931be..9482849 100644 --- a/README.md +++ b/README.md @@ -18,14 +18,15 @@ Please read the Features section below and issues to make sure your issue is not - [x] File Size - [x] Directory Child Count - [x] Actions on multiple files (selection) -- [ ] Copy/Cut and Paste files -- [ ] File Preview -- [ ] Filter Files -- [ ] Search +- [x] Copy and Paste/Move files +- [x] File Preview +- [x] Filter Files +- [x] Swipe Gestures (Up directory by swiping right) +- [x] Search +- [ ] Intro - [ ] Different views (List, Icons, etc) - [ ] Share Files - [ ] Preferences - [ ] FTP Browser - [ ] File Type Icons -- [ ] Swipe Gestures - [ ] Wi-Fi File Transfer (is this possible?) diff --git a/build/img/Search.png b/build/img/Search.png new file mode 100644 index 0000000000000000000000000000000000000000..f2dc1174886916c8e407e29c8918d5e1958e33c6 GIT binary patch literal 690 zcmV;j0!{siP)Px%Y)M2xR7ef2ls$+OQ4q)Tr3pz9u{jljl@^I!6;DMhatIcJjR%5-Ac(DngUMDT;4Tc{8PTOv zg+kl7!a-cMS}mT*WEP2M!{PAm;c)l^d0(kiUKI+3UqN}E@AY~;)$Mj~^?JQEWH>>- zyRLh+TrS5vi8!9hI-Sn`NF=gCC5QdM3H}T4=hEr4BQZ_ZXf$>ulgYOb9grZ$va#PF zt4J0(L3}S-)@$0an9JpQ@?oSo+C$?=F8=jmu^2T$wrwZC+(G(+1$WcLgy_LR6M%im z1MoTHo=QL09mh#)2*De&6Z*Lh1Q?cO?I7oq8 zw|PdIiEiQRS<@iHU|3IrGsi>C;O0{E#En!9LaW_wXC!WFaEB0Eu-JbtLV)a6h(@Do zEM!pE=*8`RzyFdOUL}^LpQkv|H84BJc}*}2@p$~R^7Zee9Co{cx{pXN)#sq)vdK~+ zk$4&e2vOl>NC$F^Nm{j})oLB_ll)ZyM^Vi;D^}O;aGWnl5jkHfmF82a)H^?!$5(F@ zyM8mP!C&%#rga#JvnCPt&uX + + + Search + Created with Sketch. + + + + + + + + + \ No newline at end of file diff --git a/build/index.html b/build/index.html index cb32db8..24a51e6 100644 --- a/build/index.html +++ b/build/index.html @@ -3,7 +3,7 @@ Hawk - + diff --git a/build/main.js b/build/main.js index 16c3b63..0e24922 100644 --- a/build/main.js +++ b/build/main.js @@ -91,6 +91,7432 @@ process.chdir = function (dir) { process.umask = function() { return 0; }; },{}],2:[function(require,module,exports){ +/*! Hammer.JS - v2.0.4 - 2014-09-28 + * http://hammerjs.github.io/ + * + * Copyright (c) 2014 Jorik Tangelder; + * Licensed under the MIT license */ +(function(window, document, exportName, undefined) { + 'use strict'; + +var VENDOR_PREFIXES = ['', 'webkit', 'moz', 'MS', 'ms', 'o']; +var TEST_ELEMENT = document.createElement('div'); + +var TYPE_FUNCTION = 'function'; + +var round = Math.round; +var abs = Math.abs; +var now = Date.now; + +/** + * set a timeout with a given scope + * @param {Function} fn + * @param {Number} timeout + * @param {Object} context + * @returns {number} + */ +function setTimeoutContext(fn, timeout, context) { + return setTimeout(bindFn(fn, context), timeout); +} + +/** + * if the argument is an array, we want to execute the fn on each entry + * if it aint an array we don't want to do a thing. + * this is used by all the methods that accept a single and array argument. + * @param {*|Array} arg + * @param {String} fn + * @param {Object} [context] + * @returns {Boolean} + */ +function invokeArrayArg(arg, fn, context) { + if (Array.isArray(arg)) { + each(arg, context[fn], context); + return true; + } + return false; +} + +/** + * walk objects and arrays + * @param {Object} obj + * @param {Function} iterator + * @param {Object} context + */ +function each(obj, iterator, context) { + var i; + + if (!obj) { + return; + } + + if (obj.forEach) { + obj.forEach(iterator, context); + } else if (obj.length !== undefined) { + i = 0; + while (i < obj.length) { + iterator.call(context, obj[i], i, obj); + i++; + } + } else { + for (i in obj) { + obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj); + } + } +} + +/** + * extend object. + * means that properties in dest will be overwritten by the ones in src. + * @param {Object} dest + * @param {Object} src + * @param {Boolean} [merge] + * @returns {Object} dest + */ +function extend(dest, src, merge) { + var keys = Object.keys(src); + var i = 0; + while (i < keys.length) { + if (!merge || (merge && dest[keys[i]] === undefined)) { + dest[keys[i]] = src[keys[i]]; + } + i++; + } + return dest; +} + +/** + * merge the values from src in the dest. + * means that properties that exist in dest will not be overwritten by src + * @param {Object} dest + * @param {Object} src + * @returns {Object} dest + */ +function merge(dest, src) { + return extend(dest, src, true); +} + +/** + * simple class inheritance + * @param {Function} child + * @param {Function} base + * @param {Object} [properties] + */ +function inherit(child, base, properties) { + var baseP = base.prototype, + childP; + + childP = child.prototype = Object.create(baseP); + childP.constructor = child; + childP._super = baseP; + + if (properties) { + extend(childP, properties); + } +} + +/** + * simple function bind + * @param {Function} fn + * @param {Object} context + * @returns {Function} + */ +function bindFn(fn, context) { + return function boundFn() { + return fn.apply(context, arguments); + }; +} + +/** + * let a boolean value also be a function that must return a boolean + * this first item in args will be used as the context + * @param {Boolean|Function} val + * @param {Array} [args] + * @returns {Boolean} + */ +function boolOrFn(val, args) { + if (typeof val == TYPE_FUNCTION) { + return val.apply(args ? args[0] || undefined : undefined, args); + } + return val; +} + +/** + * use the val2 when val1 is undefined + * @param {*} val1 + * @param {*} val2 + * @returns {*} + */ +function ifUndefined(val1, val2) { + return (val1 === undefined) ? val2 : val1; +} + +/** + * addEventListener with multiple events at once + * @param {EventTarget} target + * @param {String} types + * @param {Function} handler + */ +function addEventListeners(target, types, handler) { + each(splitStr(types), function(type) { + target.addEventListener(type, handler, false); + }); +} + +/** + * removeEventListener with multiple events at once + * @param {EventTarget} target + * @param {String} types + * @param {Function} handler + */ +function removeEventListeners(target, types, handler) { + each(splitStr(types), function(type) { + target.removeEventListener(type, handler, false); + }); +} + +/** + * find if a node is in the given parent + * @method hasParent + * @param {HTMLElement} node + * @param {HTMLElement} parent + * @return {Boolean} found + */ +function hasParent(node, parent) { + while (node) { + if (node == parent) { + return true; + } + node = node.parentNode; + } + return false; +} + +/** + * small indexOf wrapper + * @param {String} str + * @param {String} find + * @returns {Boolean} found + */ +function inStr(str, find) { + return str.indexOf(find) > -1; +} + +/** + * split string on whitespace + * @param {String} str + * @returns {Array} words + */ +function splitStr(str) { + return str.trim().split(/\s+/g); +} + +/** + * find if a array contains the object using indexOf or a simple polyFill + * @param {Array} src + * @param {String} find + * @param {String} [findByKey] + * @return {Boolean|Number} false when not found, or the index + */ +function inArray(src, find, findByKey) { + if (src.indexOf && !findByKey) { + return src.indexOf(find); + } else { + var i = 0; + while (i < src.length) { + if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) { + return i; + } + i++; + } + return -1; + } +} + +/** + * convert array-like objects to real arrays + * @param {Object} obj + * @returns {Array} + */ +function toArray(obj) { + return Array.prototype.slice.call(obj, 0); +} + +/** + * unique array with objects based on a key (like 'id') or just by the array's value + * @param {Array} src [{id:1},{id:2},{id:1}] + * @param {String} [key] + * @param {Boolean} [sort=False] + * @returns {Array} [{id:1},{id:2}] + */ +function uniqueArray(src, key, sort) { + var results = []; + var values = []; + var i = 0; + + while (i < src.length) { + var val = key ? src[i][key] : src[i]; + if (inArray(values, val) < 0) { + results.push(src[i]); + } + values[i] = val; + i++; + } + + if (sort) { + if (!key) { + results = results.sort(); + } else { + results = results.sort(function sortUniqueArray(a, b) { + return a[key] > b[key]; + }); + } + } + + return results; +} + +/** + * get the prefixed property + * @param {Object} obj + * @param {String} property + * @returns {String|Undefined} prefixed + */ +function prefixed(obj, property) { + var prefix, prop; + var camelProp = property[0].toUpperCase() + property.slice(1); + + var i = 0; + while (i < VENDOR_PREFIXES.length) { + prefix = VENDOR_PREFIXES[i]; + prop = (prefix) ? prefix + camelProp : property; + + if (prop in obj) { + return prop; + } + i++; + } + return undefined; +} + +/** + * get a unique id + * @returns {number} uniqueId + */ +var _uniqueId = 1; +function uniqueId() { + return _uniqueId++; +} + +/** + * get the window object of an element + * @param {HTMLElement} element + * @returns {DocumentView|Window} + */ +function getWindowForElement(element) { + var doc = element.ownerDocument; + return (doc.defaultView || doc.parentWindow); +} + +var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i; + +var SUPPORT_TOUCH = ('ontouchstart' in window); +var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined; +var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent); + +var INPUT_TYPE_TOUCH = 'touch'; +var INPUT_TYPE_PEN = 'pen'; +var INPUT_TYPE_MOUSE = 'mouse'; +var INPUT_TYPE_KINECT = 'kinect'; + +var COMPUTE_INTERVAL = 25; + +var INPUT_START = 1; +var INPUT_MOVE = 2; +var INPUT_END = 4; +var INPUT_CANCEL = 8; + +var DIRECTION_NONE = 1; +var DIRECTION_LEFT = 2; +var DIRECTION_RIGHT = 4; +var DIRECTION_UP = 8; +var DIRECTION_DOWN = 16; + +var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT; +var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN; +var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL; + +var PROPS_XY = ['x', 'y']; +var PROPS_CLIENT_XY = ['clientX', 'clientY']; + +/** + * create new input type manager + * @param {Manager} manager + * @param {Function} callback + * @returns {Input} + * @constructor + */ +function Input(manager, callback) { + var self = this; + this.manager = manager; + this.callback = callback; + this.element = manager.element; + this.target = manager.options.inputTarget; + + // smaller wrapper around the handler, for the scope and the enabled state of the manager, + // so when disabled the input events are completely bypassed. + this.domHandler = function(ev) { + if (boolOrFn(manager.options.enable, [manager])) { + self.handler(ev); + } + }; + + this.init(); + +} + +Input.prototype = { + /** + * should handle the inputEvent data and trigger the callback + * @virtual + */ + handler: function() { }, + + /** + * bind the events + */ + init: function() { + this.evEl && addEventListeners(this.element, this.evEl, this.domHandler); + this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler); + this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); + }, + + /** + * unbind the events + */ + destroy: function() { + this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler); + this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler); + this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); + } +}; + +/** + * create new input type manager + * called by the Manager constructor + * @param {Hammer} manager + * @returns {Input} + */ +function createInputInstance(manager) { + var Type; + var inputClass = manager.options.inputClass; + + if (inputClass) { + Type = inputClass; + } else if (SUPPORT_POINTER_EVENTS) { + Type = PointerEventInput; + } else if (SUPPORT_ONLY_TOUCH) { + Type = TouchInput; + } else if (!SUPPORT_TOUCH) { + Type = MouseInput; + } else { + Type = TouchMouseInput; + } + return new (Type)(manager, inputHandler); +} + +/** + * handle input events + * @param {Manager} manager + * @param {String} eventType + * @param {Object} input + */ +function inputHandler(manager, eventType, input) { + var pointersLen = input.pointers.length; + var changedPointersLen = input.changedPointers.length; + var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0)); + var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0)); + + input.isFirst = !!isFirst; + input.isFinal = !!isFinal; + + if (isFirst) { + manager.session = {}; + } + + // source event is the normalized value of the domEvents + // like 'touchstart, mouseup, pointerdown' + input.eventType = eventType; + + // compute scale, rotation etc + computeInputData(manager, input); + + // emit secret event + manager.emit('hammer.input', input); + + manager.recognize(input); + manager.session.prevInput = input; +} + +/** + * extend the data with some usable properties like scale, rotate, velocity etc + * @param {Object} manager + * @param {Object} input + */ +function computeInputData(manager, input) { + var session = manager.session; + var pointers = input.pointers; + var pointersLength = pointers.length; + + // store the first input to calculate the distance and direction + if (!session.firstInput) { + session.firstInput = simpleCloneInputData(input); + } + + // to compute scale and rotation we need to store the multiple touches + if (pointersLength > 1 && !session.firstMultiple) { + session.firstMultiple = simpleCloneInputData(input); + } else if (pointersLength === 1) { + session.firstMultiple = false; + } + + var firstInput = session.firstInput; + var firstMultiple = session.firstMultiple; + var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center; + + var center = input.center = getCenter(pointers); + input.timeStamp = now(); + input.deltaTime = input.timeStamp - firstInput.timeStamp; + + input.angle = getAngle(offsetCenter, center); + input.distance = getDistance(offsetCenter, center); + + computeDeltaXY(session, input); + input.offsetDirection = getDirection(input.deltaX, input.deltaY); + + input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1; + input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0; + + computeIntervalInputData(session, input); + + // find the correct target + var target = manager.element; + if (hasParent(input.srcEvent.target, target)) { + target = input.srcEvent.target; + } + input.target = target; +} + +function computeDeltaXY(session, input) { + var center = input.center; + var offset = session.offsetDelta || {}; + var prevDelta = session.prevDelta || {}; + var prevInput = session.prevInput || {}; + + if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) { + prevDelta = session.prevDelta = { + x: prevInput.deltaX || 0, + y: prevInput.deltaY || 0 + }; + + offset = session.offsetDelta = { + x: center.x, + y: center.y + }; + } + + input.deltaX = prevDelta.x + (center.x - offset.x); + input.deltaY = prevDelta.y + (center.y - offset.y); +} + +/** + * velocity is calculated every x ms + * @param {Object} session + * @param {Object} input + */ +function computeIntervalInputData(session, input) { + var last = session.lastInterval || input, + deltaTime = input.timeStamp - last.timeStamp, + velocity, velocityX, velocityY, direction; + + if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) { + var deltaX = last.deltaX - input.deltaX; + var deltaY = last.deltaY - input.deltaY; + + var v = getVelocity(deltaTime, deltaX, deltaY); + velocityX = v.x; + velocityY = v.y; + velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y; + direction = getDirection(deltaX, deltaY); + + session.lastInterval = input; + } else { + // use latest velocity info if it doesn't overtake a minimum period + velocity = last.velocity; + velocityX = last.velocityX; + velocityY = last.velocityY; + direction = last.direction; + } + + input.velocity = velocity; + input.velocityX = velocityX; + input.velocityY = velocityY; + input.direction = direction; +} + +/** + * create a simple clone from the input used for storage of firstInput and firstMultiple + * @param {Object} input + * @returns {Object} clonedInputData + */ +function simpleCloneInputData(input) { + // make a simple copy of the pointers because we will get a reference if we don't + // we only need clientXY for the calculations + var pointers = []; + var i = 0; + while (i < input.pointers.length) { + pointers[i] = { + clientX: round(input.pointers[i].clientX), + clientY: round(input.pointers[i].clientY) + }; + i++; + } + + return { + timeStamp: now(), + pointers: pointers, + center: getCenter(pointers), + deltaX: input.deltaX, + deltaY: input.deltaY + }; +} + +/** + * get the center of all the pointers + * @param {Array} pointers + * @return {Object} center contains `x` and `y` properties + */ +function getCenter(pointers) { + var pointersLength = pointers.length; + + // no need to loop when only one touch + if (pointersLength === 1) { + return { + x: round(pointers[0].clientX), + y: round(pointers[0].clientY) + }; + } + + var x = 0, y = 0, i = 0; + while (i < pointersLength) { + x += pointers[i].clientX; + y += pointers[i].clientY; + i++; + } + + return { + x: round(x / pointersLength), + y: round(y / pointersLength) + }; +} + +/** + * calculate the velocity between two points. unit is in px per ms. + * @param {Number} deltaTime + * @param {Number} x + * @param {Number} y + * @return {Object} velocity `x` and `y` + */ +function getVelocity(deltaTime, x, y) { + return { + x: x / deltaTime || 0, + y: y / deltaTime || 0 + }; +} + +/** + * get the direction between two points + * @param {Number} x + * @param {Number} y + * @return {Number} direction + */ +function getDirection(x, y) { + if (x === y) { + return DIRECTION_NONE; + } + + if (abs(x) >= abs(y)) { + return x > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT; + } + return y > 0 ? DIRECTION_UP : DIRECTION_DOWN; +} + +/** + * calculate the absolute distance between two points + * @param {Object} p1 {x, y} + * @param {Object} p2 {x, y} + * @param {Array} [props] containing x and y keys + * @return {Number} distance + */ +function getDistance(p1, p2, props) { + if (!props) { + props = PROPS_XY; + } + var x = p2[props[0]] - p1[props[0]], + y = p2[props[1]] - p1[props[1]]; + + return Math.sqrt((x * x) + (y * y)); +} + +/** + * calculate the angle between two coordinates + * @param {Object} p1 + * @param {Object} p2 + * @param {Array} [props] containing x and y keys + * @return {Number} angle + */ +function getAngle(p1, p2, props) { + if (!props) { + props = PROPS_XY; + } + var x = p2[props[0]] - p1[props[0]], + y = p2[props[1]] - p1[props[1]]; + return Math.atan2(y, x) * 180 / Math.PI; +} + +/** + * calculate the rotation degrees between two pointersets + * @param {Array} start array of pointers + * @param {Array} end array of pointers + * @return {Number} rotation + */ +function getRotation(start, end) { + return getAngle(end[1], end[0], PROPS_CLIENT_XY) - getAngle(start[1], start[0], PROPS_CLIENT_XY); +} + +/** + * calculate the scale factor between two pointersets + * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out + * @param {Array} start array of pointers + * @param {Array} end array of pointers + * @return {Number} scale + */ +function getScale(start, end) { + return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY); +} + +var MOUSE_INPUT_MAP = { + mousedown: INPUT_START, + mousemove: INPUT_MOVE, + mouseup: INPUT_END +}; + +var MOUSE_ELEMENT_EVENTS = 'mousedown'; +var MOUSE_WINDOW_EVENTS = 'mousemove mouseup'; + +/** + * Mouse events input + * @constructor + * @extends Input + */ +function MouseInput() { + this.evEl = MOUSE_ELEMENT_EVENTS; + this.evWin = MOUSE_WINDOW_EVENTS; + + this.allow = true; // used by Input.TouchMouse to disable mouse events + this.pressed = false; // mousedown state + + Input.apply(this, arguments); +} + +inherit(MouseInput, Input, { + /** + * handle mouse events + * @param {Object} ev + */ + handler: function MEhandler(ev) { + var eventType = MOUSE_INPUT_MAP[ev.type]; + + // on start we want to have the left mouse button down + if (eventType & INPUT_START && ev.button === 0) { + this.pressed = true; + } + + if (eventType & INPUT_MOVE && ev.which !== 1) { + eventType = INPUT_END; + } + + // mouse must be down, and mouse events are allowed (see the TouchMouse input) + if (!this.pressed || !this.allow) { + return; + } + + if (eventType & INPUT_END) { + this.pressed = false; + } + + this.callback(this.manager, eventType, { + pointers: [ev], + changedPointers: [ev], + pointerType: INPUT_TYPE_MOUSE, + srcEvent: ev + }); + } +}); + +var POINTER_INPUT_MAP = { + pointerdown: INPUT_START, + pointermove: INPUT_MOVE, + pointerup: INPUT_END, + pointercancel: INPUT_CANCEL, + pointerout: INPUT_CANCEL +}; + +// in IE10 the pointer types is defined as an enum +var IE10_POINTER_TYPE_ENUM = { + 2: INPUT_TYPE_TOUCH, + 3: INPUT_TYPE_PEN, + 4: INPUT_TYPE_MOUSE, + 5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816 +}; + +var POINTER_ELEMENT_EVENTS = 'pointerdown'; +var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel'; + +// IE10 has prefixed support, and case-sensitive +if (window.MSPointerEvent) { + POINTER_ELEMENT_EVENTS = 'MSPointerDown'; + POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel'; +} + +/** + * Pointer events input + * @constructor + * @extends Input + */ +function PointerEventInput() { + this.evEl = POINTER_ELEMENT_EVENTS; + this.evWin = POINTER_WINDOW_EVENTS; + + Input.apply(this, arguments); + + this.store = (this.manager.session.pointerEvents = []); +} + +inherit(PointerEventInput, Input, { + /** + * handle mouse events + * @param {Object} ev + */ + handler: function PEhandler(ev) { + var store = this.store; + var removePointer = false; + + var eventTypeNormalized = ev.type.toLowerCase().replace('ms', ''); + var eventType = POINTER_INPUT_MAP[eventTypeNormalized]; + var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType; + + var isTouch = (pointerType == INPUT_TYPE_TOUCH); + + // get index of the event in the store + var storeIndex = inArray(store, ev.pointerId, 'pointerId'); + + // start and mouse must be down + if (eventType & INPUT_START && (ev.button === 0 || isTouch)) { + if (storeIndex < 0) { + store.push(ev); + storeIndex = store.length - 1; + } + } else if (eventType & (INPUT_END | INPUT_CANCEL)) { + removePointer = true; + } + + // it not found, so the pointer hasn't been down (so it's probably a hover) + if (storeIndex < 0) { + return; + } + + // update the event in the store + store[storeIndex] = ev; + + this.callback(this.manager, eventType, { + pointers: store, + changedPointers: [ev], + pointerType: pointerType, + srcEvent: ev + }); + + if (removePointer) { + // remove from the store + store.splice(storeIndex, 1); + } + } +}); + +var SINGLE_TOUCH_INPUT_MAP = { + touchstart: INPUT_START, + touchmove: INPUT_MOVE, + touchend: INPUT_END, + touchcancel: INPUT_CANCEL +}; + +var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart'; +var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel'; + +/** + * Touch events input + * @constructor + * @extends Input + */ +function SingleTouchInput() { + this.evTarget = SINGLE_TOUCH_TARGET_EVENTS; + this.evWin = SINGLE_TOUCH_WINDOW_EVENTS; + this.started = false; + + Input.apply(this, arguments); +} + +inherit(SingleTouchInput, Input, { + handler: function TEhandler(ev) { + var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; + + // should we handle the touch events? + if (type === INPUT_START) { + this.started = true; + } + + if (!this.started) { + return; + } + + var touches = normalizeSingleTouches.call(this, ev, type); + + // when done, reset the started state + if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) { + this.started = false; + } + + this.callback(this.manager, type, { + pointers: touches[0], + changedPointers: touches[1], + pointerType: INPUT_TYPE_TOUCH, + srcEvent: ev + }); + } +}); + +/** + * @this {TouchInput} + * @param {Object} ev + * @param {Number} type flag + * @returns {undefined|Array} [all, changed] + */ +function normalizeSingleTouches(ev, type) { + var all = toArray(ev.touches); + var changed = toArray(ev.changedTouches); + + if (type & (INPUT_END | INPUT_CANCEL)) { + all = uniqueArray(all.concat(changed), 'identifier', true); + } + + return [all, changed]; +} + +var TOUCH_INPUT_MAP = { + touchstart: INPUT_START, + touchmove: INPUT_MOVE, + touchend: INPUT_END, + touchcancel: INPUT_CANCEL +}; + +var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel'; + +/** + * Multi-user touch events input + * @constructor + * @extends Input + */ +function TouchInput() { + this.evTarget = TOUCH_TARGET_EVENTS; + this.targetIds = {}; + + Input.apply(this, arguments); +} + +inherit(TouchInput, Input, { + handler: function MTEhandler(ev) { + var type = TOUCH_INPUT_MAP[ev.type]; + var touches = getTouches.call(this, ev, type); + if (!touches) { + return; + } + + this.callback(this.manager, type, { + pointers: touches[0], + changedPointers: touches[1], + pointerType: INPUT_TYPE_TOUCH, + srcEvent: ev + }); + } +}); + +/** + * @this {TouchInput} + * @param {Object} ev + * @param {Number} type flag + * @returns {undefined|Array} [all, changed] + */ +function getTouches(ev, type) { + var allTouches = toArray(ev.touches); + var targetIds = this.targetIds; + + // when there is only one touch, the process can be simplified + if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) { + targetIds[allTouches[0].identifier] = true; + return [allTouches, allTouches]; + } + + var i, + targetTouches, + changedTouches = toArray(ev.changedTouches), + changedTargetTouches = [], + target = this.target; + + // get target touches from touches + targetTouches = allTouches.filter(function(touch) { + return hasParent(touch.target, target); + }); + + // collect touches + if (type === INPUT_START) { + i = 0; + while (i < targetTouches.length) { + targetIds[targetTouches[i].identifier] = true; + i++; + } + } + + // filter changed touches to only contain touches that exist in the collected target ids + i = 0; + while (i < changedTouches.length) { + if (targetIds[changedTouches[i].identifier]) { + changedTargetTouches.push(changedTouches[i]); + } + + // cleanup removed touches + if (type & (INPUT_END | INPUT_CANCEL)) { + delete targetIds[changedTouches[i].identifier]; + } + i++; + } + + if (!changedTargetTouches.length) { + return; + } + + return [ + // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel' + uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), + changedTargetTouches + ]; +} + +/** + * Combined touch and mouse input + * + * Touch has a higher priority then mouse, and while touching no mouse events are allowed. + * This because touch devices also emit mouse events while doing a touch. + * + * @constructor + * @extends Input + */ +function TouchMouseInput() { + Input.apply(this, arguments); + + var handler = bindFn(this.handler, this); + this.touch = new TouchInput(this.manager, handler); + this.mouse = new MouseInput(this.manager, handler); +} + +inherit(TouchMouseInput, Input, { + /** + * handle mouse and touch events + * @param {Hammer} manager + * @param {String} inputEvent + * @param {Object} inputData + */ + handler: function TMEhandler(manager, inputEvent, inputData) { + var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH), + isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE); + + // when we're in a touch event, so block all upcoming mouse events + // most mobile browser also emit mouseevents, right after touchstart + if (isTouch) { + this.mouse.allow = false; + } else if (isMouse && !this.mouse.allow) { + return; + } + + // reset the allowMouse when we're done + if (inputEvent & (INPUT_END | INPUT_CANCEL)) { + this.mouse.allow = true; + } + + this.callback(manager, inputEvent, inputData); + }, + + /** + * remove the event listeners + */ + destroy: function destroy() { + this.touch.destroy(); + this.mouse.destroy(); + } +}); + +var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction'); +var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined; + +// magical touchAction value +var TOUCH_ACTION_COMPUTE = 'compute'; +var TOUCH_ACTION_AUTO = 'auto'; +var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented +var TOUCH_ACTION_NONE = 'none'; +var TOUCH_ACTION_PAN_X = 'pan-x'; +var TOUCH_ACTION_PAN_Y = 'pan-y'; + +/** + * Touch Action + * sets the touchAction property or uses the js alternative + * @param {Manager} manager + * @param {String} value + * @constructor + */ +function TouchAction(manager, value) { + this.manager = manager; + this.set(value); +} + +TouchAction.prototype = { + /** + * set the touchAction value on the element or enable the polyfill + * @param {String} value + */ + set: function(value) { + // find out the touch-action by the event handlers + if (value == TOUCH_ACTION_COMPUTE) { + value = this.compute(); + } + + if (NATIVE_TOUCH_ACTION) { + this.manager.element.style[PREFIXED_TOUCH_ACTION] = value; + } + this.actions = value.toLowerCase().trim(); + }, + + /** + * just re-set the touchAction value + */ + update: function() { + this.set(this.manager.options.touchAction); + }, + + /** + * compute the value for the touchAction property based on the recognizer's settings + * @returns {String} value + */ + compute: function() { + var actions = []; + each(this.manager.recognizers, function(recognizer) { + if (boolOrFn(recognizer.options.enable, [recognizer])) { + actions = actions.concat(recognizer.getTouchAction()); + } + }); + return cleanTouchActions(actions.join(' ')); + }, + + /** + * this method is called on each input cycle and provides the preventing of the browser behavior + * @param {Object} input + */ + preventDefaults: function(input) { + // not needed with native support for the touchAction property + if (NATIVE_TOUCH_ACTION) { + return; + } + + var srcEvent = input.srcEvent; + var direction = input.offsetDirection; + + // if the touch action did prevented once this session + if (this.manager.session.prevented) { + srcEvent.preventDefault(); + return; + } + + var actions = this.actions; + var hasNone = inStr(actions, TOUCH_ACTION_NONE); + var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); + var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X); + + if (hasNone || + (hasPanY && direction & DIRECTION_HORIZONTAL) || + (hasPanX && direction & DIRECTION_VERTICAL)) { + return this.preventSrc(srcEvent); + } + }, + + /** + * call preventDefault to prevent the browser's default behavior (scrolling in most cases) + * @param {Object} srcEvent + */ + preventSrc: function(srcEvent) { + this.manager.session.prevented = true; + srcEvent.preventDefault(); + } +}; + +/** + * when the touchActions are collected they are not a valid value, so we need to clean things up. * + * @param {String} actions + * @returns {*} + */ +function cleanTouchActions(actions) { + // none + if (inStr(actions, TOUCH_ACTION_NONE)) { + return TOUCH_ACTION_NONE; + } + + var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X); + var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); + + // pan-x and pan-y can be combined + if (hasPanX && hasPanY) { + return TOUCH_ACTION_PAN_X + ' ' + TOUCH_ACTION_PAN_Y; + } + + // pan-x OR pan-y + if (hasPanX || hasPanY) { + return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y; + } + + // manipulation + if (inStr(actions, TOUCH_ACTION_MANIPULATION)) { + return TOUCH_ACTION_MANIPULATION; + } + + return TOUCH_ACTION_AUTO; +} + +/** + * Recognizer flow explained; * + * All recognizers have the initial state of POSSIBLE when a input session starts. + * The definition of a input session is from the first input until the last input, with all it's movement in it. * + * Example session for mouse-input: mousedown -> mousemove -> mouseup + * + * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed + * which determines with state it should be. + * + * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to + * POSSIBLE to give it another change on the next cycle. + * + * Possible + * | + * +-----+---------------+ + * | | + * +-----+-----+ | + * | | | + * Failed Cancelled | + * +-------+------+ + * | | + * Recognized Began + * | + * Changed + * | + * Ended/Recognized + */ +var STATE_POSSIBLE = 1; +var STATE_BEGAN = 2; +var STATE_CHANGED = 4; +var STATE_ENDED = 8; +var STATE_RECOGNIZED = STATE_ENDED; +var STATE_CANCELLED = 16; +var STATE_FAILED = 32; + +/** + * Recognizer + * Every recognizer needs to extend from this class. + * @constructor + * @param {Object} options + */ +function Recognizer(options) { + this.id = uniqueId(); + + this.manager = null; + this.options = merge(options || {}, this.defaults); + + // default is enable true + this.options.enable = ifUndefined(this.options.enable, true); + + this.state = STATE_POSSIBLE; + + this.simultaneous = {}; + this.requireFail = []; +} + +Recognizer.prototype = { + /** + * @virtual + * @type {Object} + */ + defaults: {}, + + /** + * set options + * @param {Object} options + * @return {Recognizer} + */ + set: function(options) { + extend(this.options, options); + + // also update the touchAction, in case something changed about the directions/enabled state + this.manager && this.manager.touchAction.update(); + return this; + }, + + /** + * recognize simultaneous with an other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + recognizeWith: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) { + return this; + } + + var simultaneous = this.simultaneous; + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + if (!simultaneous[otherRecognizer.id]) { + simultaneous[otherRecognizer.id] = otherRecognizer; + otherRecognizer.recognizeWith(this); + } + return this; + }, + + /** + * drop the simultaneous link. it doesnt remove the link on the other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + dropRecognizeWith: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) { + return this; + } + + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + delete this.simultaneous[otherRecognizer.id]; + return this; + }, + + /** + * recognizer can only run when an other is failing + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + requireFailure: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) { + return this; + } + + var requireFail = this.requireFail; + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + if (inArray(requireFail, otherRecognizer) === -1) { + requireFail.push(otherRecognizer); + otherRecognizer.requireFailure(this); + } + return this; + }, + + /** + * drop the requireFailure link. it does not remove the link on the other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + dropRequireFailure: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) { + return this; + } + + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + var index = inArray(this.requireFail, otherRecognizer); + if (index > -1) { + this.requireFail.splice(index, 1); + } + return this; + }, + + /** + * has require failures boolean + * @returns {boolean} + */ + hasRequireFailures: function() { + return this.requireFail.length > 0; + }, + + /** + * if the recognizer can recognize simultaneous with an other recognizer + * @param {Recognizer} otherRecognizer + * @returns {Boolean} + */ + canRecognizeWith: function(otherRecognizer) { + return !!this.simultaneous[otherRecognizer.id]; + }, + + /** + * You should use `tryEmit` instead of `emit` directly to check + * that all the needed recognizers has failed before emitting. + * @param {Object} input + */ + emit: function(input) { + var self = this; + var state = this.state; + + function emit(withState) { + self.manager.emit(self.options.event + (withState ? stateStr(state) : ''), input); + } + + // 'panstart' and 'panmove' + if (state < STATE_ENDED) { + emit(true); + } + + emit(); // simple 'eventName' events + + // panend and pancancel + if (state >= STATE_ENDED) { + emit(true); + } + }, + + /** + * Check that all the require failure recognizers has failed, + * if true, it emits a gesture event, + * otherwise, setup the state to FAILED. + * @param {Object} input + */ + tryEmit: function(input) { + if (this.canEmit()) { + return this.emit(input); + } + // it's failing anyway + this.state = STATE_FAILED; + }, + + /** + * can we emit? + * @returns {boolean} + */ + canEmit: function() { + var i = 0; + while (i < this.requireFail.length) { + if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) { + return false; + } + i++; + } + return true; + }, + + /** + * update the recognizer + * @param {Object} inputData + */ + recognize: function(inputData) { + // make a new copy of the inputData + // so we can change the inputData without messing up the other recognizers + var inputDataClone = extend({}, inputData); + + // is is enabled and allow recognizing? + if (!boolOrFn(this.options.enable, [this, inputDataClone])) { + this.reset(); + this.state = STATE_FAILED; + return; + } + + // reset when we've reached the end + if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) { + this.state = STATE_POSSIBLE; + } + + this.state = this.process(inputDataClone); + + // the recognizer has recognized a gesture + // so trigger an event + if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) { + this.tryEmit(inputDataClone); + } + }, + + /** + * return the state of the recognizer + * the actual recognizing happens in this method + * @virtual + * @param {Object} inputData + * @returns {Const} STATE + */ + process: function(inputData) { }, // jshint ignore:line + + /** + * return the preferred touch-action + * @virtual + * @returns {Array} + */ + getTouchAction: function() { }, + + /** + * called when the gesture isn't allowed to recognize + * like when another is being recognized or it is disabled + * @virtual + */ + reset: function() { } +}; + +/** + * get a usable string, used as event postfix + * @param {Const} state + * @returns {String} state + */ +function stateStr(state) { + if (state & STATE_CANCELLED) { + return 'cancel'; + } else if (state & STATE_ENDED) { + return 'end'; + } else if (state & STATE_CHANGED) { + return 'move'; + } else if (state & STATE_BEGAN) { + return 'start'; + } + return ''; +} + +/** + * direction cons to string + * @param {Const} direction + * @returns {String} + */ +function directionStr(direction) { + if (direction == DIRECTION_DOWN) { + return 'down'; + } else if (direction == DIRECTION_UP) { + return 'up'; + } else if (direction == DIRECTION_LEFT) { + return 'left'; + } else if (direction == DIRECTION_RIGHT) { + return 'right'; + } + return ''; +} + +/** + * get a recognizer by name if it is bound to a manager + * @param {Recognizer|String} otherRecognizer + * @param {Recognizer} recognizer + * @returns {Recognizer} + */ +function getRecognizerByNameIfManager(otherRecognizer, recognizer) { + var manager = recognizer.manager; + if (manager) { + return manager.get(otherRecognizer); + } + return otherRecognizer; +} + +/** + * This recognizer is just used as a base for the simple attribute recognizers. + * @constructor + * @extends Recognizer + */ +function AttrRecognizer() { + Recognizer.apply(this, arguments); +} + +inherit(AttrRecognizer, Recognizer, { + /** + * @namespace + * @memberof AttrRecognizer + */ + defaults: { + /** + * @type {Number} + * @default 1 + */ + pointers: 1 + }, + + /** + * Used to check if it the recognizer receives valid input, like input.distance > 10. + * @memberof AttrRecognizer + * @param {Object} input + * @returns {Boolean} recognized + */ + attrTest: function(input) { + var optionPointers = this.options.pointers; + return optionPointers === 0 || input.pointers.length === optionPointers; + }, + + /** + * Process the input and return the state for the recognizer + * @memberof AttrRecognizer + * @param {Object} input + * @returns {*} State + */ + process: function(input) { + var state = this.state; + var eventType = input.eventType; + + var isRecognized = state & (STATE_BEGAN | STATE_CHANGED); + var isValid = this.attrTest(input); + + // on cancel input and we've recognized before, return STATE_CANCELLED + if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) { + return state | STATE_CANCELLED; + } else if (isRecognized || isValid) { + if (eventType & INPUT_END) { + return state | STATE_ENDED; + } else if (!(state & STATE_BEGAN)) { + return STATE_BEGAN; + } + return state | STATE_CHANGED; + } + return STATE_FAILED; + } +}); + +/** + * Pan + * Recognized when the pointer is down and moved in the allowed direction. + * @constructor + * @extends AttrRecognizer + */ +function PanRecognizer() { + AttrRecognizer.apply(this, arguments); + + this.pX = null; + this.pY = null; +} + +inherit(PanRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof PanRecognizer + */ + defaults: { + event: 'pan', + threshold: 10, + pointers: 1, + direction: DIRECTION_ALL + }, + + getTouchAction: function() { + var direction = this.options.direction; + var actions = []; + if (direction & DIRECTION_HORIZONTAL) { + actions.push(TOUCH_ACTION_PAN_Y); + } + if (direction & DIRECTION_VERTICAL) { + actions.push(TOUCH_ACTION_PAN_X); + } + return actions; + }, + + directionTest: function(input) { + var options = this.options; + var hasMoved = true; + var distance = input.distance; + var direction = input.direction; + var x = input.deltaX; + var y = input.deltaY; + + // lock to axis? + if (!(direction & options.direction)) { + if (options.direction & DIRECTION_HORIZONTAL) { + direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT; + hasMoved = x != this.pX; + distance = Math.abs(input.deltaX); + } else { + direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN; + hasMoved = y != this.pY; + distance = Math.abs(input.deltaY); + } + } + input.direction = direction; + return hasMoved && distance > options.threshold && direction & options.direction; + }, + + attrTest: function(input) { + return AttrRecognizer.prototype.attrTest.call(this, input) && + (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input))); + }, + + emit: function(input) { + this.pX = input.deltaX; + this.pY = input.deltaY; + + var direction = directionStr(input.direction); + if (direction) { + this.manager.emit(this.options.event + direction, input); + } + + this._super.emit.call(this, input); + } +}); + +/** + * Pinch + * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out). + * @constructor + * @extends AttrRecognizer + */ +function PinchRecognizer() { + AttrRecognizer.apply(this, arguments); +} + +inherit(PinchRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof PinchRecognizer + */ + defaults: { + event: 'pinch', + threshold: 0, + pointers: 2 + }, + + getTouchAction: function() { + return [TOUCH_ACTION_NONE]; + }, + + attrTest: function(input) { + return this._super.attrTest.call(this, input) && + (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN); + }, + + emit: function(input) { + this._super.emit.call(this, input); + if (input.scale !== 1) { + var inOut = input.scale < 1 ? 'in' : 'out'; + this.manager.emit(this.options.event + inOut, input); + } + } +}); + +/** + * Press + * Recognized when the pointer is down for x ms without any movement. + * @constructor + * @extends Recognizer + */ +function PressRecognizer() { + Recognizer.apply(this, arguments); + + this._timer = null; + this._input = null; +} + +inherit(PressRecognizer, Recognizer, { + /** + * @namespace + * @memberof PressRecognizer + */ + defaults: { + event: 'press', + pointers: 1, + time: 500, // minimal time of the pointer to be pressed + threshold: 5 // a minimal movement is ok, but keep it low + }, + + getTouchAction: function() { + return [TOUCH_ACTION_AUTO]; + }, + + process: function(input) { + var options = this.options; + var validPointers = input.pointers.length === options.pointers; + var validMovement = input.distance < options.threshold; + var validTime = input.deltaTime > options.time; + + this._input = input; + + // we only allow little movement + // and we've reached an end event, so a tap is possible + if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) { + this.reset(); + } else if (input.eventType & INPUT_START) { + this.reset(); + this._timer = setTimeoutContext(function() { + this.state = STATE_RECOGNIZED; + this.tryEmit(); + }, options.time, this); + } else if (input.eventType & INPUT_END) { + return STATE_RECOGNIZED; + } + return STATE_FAILED; + }, + + reset: function() { + clearTimeout(this._timer); + }, + + emit: function(input) { + if (this.state !== STATE_RECOGNIZED) { + return; + } + + if (input && (input.eventType & INPUT_END)) { + this.manager.emit(this.options.event + 'up', input); + } else { + this._input.timeStamp = now(); + this.manager.emit(this.options.event, this._input); + } + } +}); + +/** + * Rotate + * Recognized when two or more pointer are moving in a circular motion. + * @constructor + * @extends AttrRecognizer + */ +function RotateRecognizer() { + AttrRecognizer.apply(this, arguments); +} + +inherit(RotateRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof RotateRecognizer + */ + defaults: { + event: 'rotate', + threshold: 0, + pointers: 2 + }, + + getTouchAction: function() { + return [TOUCH_ACTION_NONE]; + }, + + attrTest: function(input) { + return this._super.attrTest.call(this, input) && + (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN); + } +}); + +/** + * Swipe + * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction. + * @constructor + * @extends AttrRecognizer + */ +function SwipeRecognizer() { + AttrRecognizer.apply(this, arguments); +} + +inherit(SwipeRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof SwipeRecognizer + */ + defaults: { + event: 'swipe', + threshold: 10, + velocity: 0.65, + direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL, + pointers: 1 + }, + + getTouchAction: function() { + return PanRecognizer.prototype.getTouchAction.call(this); + }, + + attrTest: function(input) { + var direction = this.options.direction; + var velocity; + + if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) { + velocity = input.velocity; + } else if (direction & DIRECTION_HORIZONTAL) { + velocity = input.velocityX; + } else if (direction & DIRECTION_VERTICAL) { + velocity = input.velocityY; + } + + return this._super.attrTest.call(this, input) && + direction & input.direction && + input.distance > this.options.threshold && + abs(velocity) > this.options.velocity && input.eventType & INPUT_END; + }, + + emit: function(input) { + var direction = directionStr(input.direction); + if (direction) { + this.manager.emit(this.options.event + direction, input); + } + + this.manager.emit(this.options.event, input); + } +}); + +/** + * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur + * between the given interval and position. The delay option can be used to recognize multi-taps without firing + * a single tap. + * + * The eventData from the emitted event contains the property `tapCount`, which contains the amount of + * multi-taps being recognized. + * @constructor + * @extends Recognizer + */ +function TapRecognizer() { + Recognizer.apply(this, arguments); + + // previous time and center, + // used for tap counting + this.pTime = false; + this.pCenter = false; + + this._timer = null; + this._input = null; + this.count = 0; +} + +inherit(TapRecognizer, Recognizer, { + /** + * @namespace + * @memberof PinchRecognizer + */ + defaults: { + event: 'tap', + pointers: 1, + taps: 1, + interval: 300, // max time between the multi-tap taps + time: 250, // max time of the pointer to be down (like finger on the screen) + threshold: 2, // a minimal movement is ok, but keep it low + posThreshold: 10 // a multi-tap can be a bit off the initial position + }, + + getTouchAction: function() { + return [TOUCH_ACTION_MANIPULATION]; + }, + + process: function(input) { + var options = this.options; + + var validPointers = input.pointers.length === options.pointers; + var validMovement = input.distance < options.threshold; + var validTouchTime = input.deltaTime < options.time; + + this.reset(); + + if ((input.eventType & INPUT_START) && (this.count === 0)) { + return this.failTimeout(); + } + + // we only allow little movement + // and we've reached an end event, so a tap is possible + if (validMovement && validTouchTime && validPointers) { + if (input.eventType != INPUT_END) { + return this.failTimeout(); + } + + var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true; + var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold; + + this.pTime = input.timeStamp; + this.pCenter = input.center; + + if (!validMultiTap || !validInterval) { + this.count = 1; + } else { + this.count += 1; + } + + this._input = input; + + // if tap count matches we have recognized it, + // else it has began recognizing... + var tapCount = this.count % options.taps; + if (tapCount === 0) { + // no failing requirements, immediately trigger the tap event + // or wait as long as the multitap interval to trigger + if (!this.hasRequireFailures()) { + return STATE_RECOGNIZED; + } else { + this._timer = setTimeoutContext(function() { + this.state = STATE_RECOGNIZED; + this.tryEmit(); + }, options.interval, this); + return STATE_BEGAN; + } + } + } + return STATE_FAILED; + }, + + failTimeout: function() { + this._timer = setTimeoutContext(function() { + this.state = STATE_FAILED; + }, this.options.interval, this); + return STATE_FAILED; + }, + + reset: function() { + clearTimeout(this._timer); + }, + + emit: function() { + if (this.state == STATE_RECOGNIZED ) { + this._input.tapCount = this.count; + this.manager.emit(this.options.event, this._input); + } + } +}); + +/** + * Simple way to create an manager with a default set of recognizers. + * @param {HTMLElement} element + * @param {Object} [options] + * @constructor + */ +function Hammer(element, options) { + options = options || {}; + options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset); + return new Manager(element, options); +} + +/** + * @const {string} + */ +Hammer.VERSION = '2.0.4'; + +/** + * default settings + * @namespace + */ +Hammer.defaults = { + /** + * set if DOM events are being triggered. + * But this is slower and unused by simple implementations, so disabled by default. + * @type {Boolean} + * @default false + */ + domEvents: false, + + /** + * The value for the touchAction property/fallback. + * When set to `compute` it will magically set the correct value based on the added recognizers. + * @type {String} + * @default compute + */ + touchAction: TOUCH_ACTION_COMPUTE, + + /** + * @type {Boolean} + * @default true + */ + enable: true, + + /** + * EXPERIMENTAL FEATURE -- can be removed/changed + * Change the parent input target element. + * If Null, then it is being set the to main element. + * @type {Null|EventTarget} + * @default null + */ + inputTarget: null, + + /** + * force an input class + * @type {Null|Function} + * @default null + */ + inputClass: null, + + /** + * Default recognizer setup when calling `Hammer()` + * When creating a new Manager these will be skipped. + * @type {Array} + */ + preset: [ + // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...] + [RotateRecognizer, { enable: false }], + [PinchRecognizer, { enable: false }, ['rotate']], + [SwipeRecognizer,{ direction: DIRECTION_HORIZONTAL }], + [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ['swipe']], + [TapRecognizer], + [TapRecognizer, { event: 'doubletap', taps: 2 }, ['tap']], + [PressRecognizer] + ], + + /** + * Some CSS properties can be used to improve the working of Hammer. + * Add them to this method and they will be set when creating a new Manager. + * @namespace + */ + cssProps: { + /** + * Disables text selection to improve the dragging gesture. Mainly for desktop browsers. + * @type {String} + * @default 'none' + */ + userSelect: 'none', + + /** + * Disable the Windows Phone grippers when pressing an element. + * @type {String} + * @default 'none' + */ + touchSelect: 'none', + + /** + * Disables the default callout shown when you touch and hold a touch target. + * On iOS, when you touch and hold a touch target such as a link, Safari displays + * a callout containing information about the link. This property allows you to disable that callout. + * @type {String} + * @default 'none' + */ + touchCallout: 'none', + + /** + * Specifies whether zooming is enabled. Used by IE10> + * @type {String} + * @default 'none' + */ + contentZooming: 'none', + + /** + * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers. + * @type {String} + * @default 'none' + */ + userDrag: 'none', + + /** + * Overrides the highlight color shown when the user taps a link or a JavaScript + * clickable element in iOS. This property obeys the alpha value, if specified. + * @type {String} + * @default 'rgba(0,0,0,0)' + */ + tapHighlightColor: 'rgba(0,0,0,0)' + } +}; + +var STOP = 1; +var FORCED_STOP = 2; + +/** + * Manager + * @param {HTMLElement} element + * @param {Object} [options] + * @constructor + */ +function Manager(element, options) { + options = options || {}; + + this.options = merge(options, Hammer.defaults); + this.options.inputTarget = this.options.inputTarget || element; + + this.handlers = {}; + this.session = {}; + this.recognizers = []; + + this.element = element; + this.input = createInputInstance(this); + this.touchAction = new TouchAction(this, this.options.touchAction); + + toggleCssProps(this, true); + + each(options.recognizers, function(item) { + var recognizer = this.add(new (item[0])(item[1])); + item[2] && recognizer.recognizeWith(item[2]); + item[3] && recognizer.requireFailure(item[3]); + }, this); +} + +Manager.prototype = { + /** + * set options + * @param {Object} options + * @returns {Manager} + */ + set: function(options) { + extend(this.options, options); + + // Options that need a little more setup + if (options.touchAction) { + this.touchAction.update(); + } + if (options.inputTarget) { + // Clean up existing event listeners and reinitialize + this.input.destroy(); + this.input.target = options.inputTarget; + this.input.init(); + } + return this; + }, + + /** + * stop recognizing for this session. + * This session will be discarded, when a new [input]start event is fired. + * When forced, the recognizer cycle is stopped immediately. + * @param {Boolean} [force] + */ + stop: function(force) { + this.session.stopped = force ? FORCED_STOP : STOP; + }, + + /** + * run the recognizers! + * called by the inputHandler function on every movement of the pointers (touches) + * it walks through all the recognizers and tries to detect the gesture that is being made + * @param {Object} inputData + */ + recognize: function(inputData) { + var session = this.session; + if (session.stopped) { + return; + } + + // run the touch-action polyfill + this.touchAction.preventDefaults(inputData); + + var recognizer; + var recognizers = this.recognizers; + + // this holds the recognizer that is being recognized. + // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED + // if no recognizer is detecting a thing, it is set to `null` + var curRecognizer = session.curRecognizer; + + // reset when the last recognizer is recognized + // or when we're in a new session + if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) { + curRecognizer = session.curRecognizer = null; + } + + var i = 0; + while (i < recognizers.length) { + recognizer = recognizers[i]; + + // find out if we are allowed try to recognize the input for this one. + // 1. allow if the session is NOT forced stopped (see the .stop() method) + // 2. allow if we still haven't recognized a gesture in this session, or the this recognizer is the one + // that is being recognized. + // 3. allow if the recognizer is allowed to run simultaneous with the current recognized recognizer. + // this can be setup with the `recognizeWith()` method on the recognizer. + if (session.stopped !== FORCED_STOP && ( // 1 + !curRecognizer || recognizer == curRecognizer || // 2 + recognizer.canRecognizeWith(curRecognizer))) { // 3 + recognizer.recognize(inputData); + } else { + recognizer.reset(); + } + + // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the + // current active recognizer. but only if we don't already have an active recognizer + if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) { + curRecognizer = session.curRecognizer = recognizer; + } + i++; + } + }, + + /** + * get a recognizer by its event name. + * @param {Recognizer|String} recognizer + * @returns {Recognizer|Null} + */ + get: function(recognizer) { + if (recognizer instanceof Recognizer) { + return recognizer; + } + + var recognizers = this.recognizers; + for (var i = 0; i < recognizers.length; i++) { + if (recognizers[i].options.event == recognizer) { + return recognizers[i]; + } + } + return null; + }, + + /** + * add a recognizer to the manager + * existing recognizers with the same event name will be removed + * @param {Recognizer} recognizer + * @returns {Recognizer|Manager} + */ + add: function(recognizer) { + if (invokeArrayArg(recognizer, 'add', this)) { + return this; + } + + // remove existing + var existing = this.get(recognizer.options.event); + if (existing) { + this.remove(existing); + } + + this.recognizers.push(recognizer); + recognizer.manager = this; + + this.touchAction.update(); + return recognizer; + }, + + /** + * remove a recognizer by name or instance + * @param {Recognizer|String} recognizer + * @returns {Manager} + */ + remove: function(recognizer) { + if (invokeArrayArg(recognizer, 'remove', this)) { + return this; + } + + var recognizers = this.recognizers; + recognizer = this.get(recognizer); + recognizers.splice(inArray(recognizers, recognizer), 1); + + this.touchAction.update(); + return this; + }, + + /** + * bind event + * @param {String} events + * @param {Function} handler + * @returns {EventEmitter} this + */ + on: function(events, handler) { + var handlers = this.handlers; + each(splitStr(events), function(event) { + handlers[event] = handlers[event] || []; + handlers[event].push(handler); + }); + return this; + }, + + /** + * unbind event, leave emit blank to remove all handlers + * @param {String} events + * @param {Function} [handler] + * @returns {EventEmitter} this + */ + off: function(events, handler) { + var handlers = this.handlers; + each(splitStr(events), function(event) { + if (!handler) { + delete handlers[event]; + } else { + handlers[event].splice(inArray(handlers[event], handler), 1); + } + }); + return this; + }, + + /** + * emit event to the listeners + * @param {String} event + * @param {Object} data + */ + emit: function(event, data) { + // we also want to trigger dom events + if (this.options.domEvents) { + triggerDomEvent(event, data); + } + + // no handlers, so skip it all + var handlers = this.handlers[event] && this.handlers[event].slice(); + if (!handlers || !handlers.length) { + return; + } + + data.type = event; + data.preventDefault = function() { + data.srcEvent.preventDefault(); + }; + + var i = 0; + while (i < handlers.length) { + handlers[i](data); + i++; + } + }, + + /** + * destroy the manager and unbinds all events + * it doesn't unbind dom events, that is the user own responsibility + */ + destroy: function() { + this.element && toggleCssProps(this, false); + + this.handlers = {}; + this.session = {}; + this.input.destroy(); + this.element = null; + } +}; + +/** + * add/remove the css properties as defined in manager.options.cssProps + * @param {Manager} manager + * @param {Boolean} add + */ +function toggleCssProps(manager, add) { + var element = manager.element; + each(manager.options.cssProps, function(value, name) { + element.style[prefixed(element.style, name)] = add ? value : ''; + }); +} + +/** + * trigger dom event + * @param {String} event + * @param {Object} data + */ +function triggerDomEvent(event, data) { + var gestureEvent = document.createEvent('Event'); + gestureEvent.initEvent(event, true, true); + gestureEvent.gesture = data; + data.target.dispatchEvent(gestureEvent); +} + +extend(Hammer, { + INPUT_START: INPUT_START, + INPUT_MOVE: INPUT_MOVE, + INPUT_END: INPUT_END, + INPUT_CANCEL: INPUT_CANCEL, + + STATE_POSSIBLE: STATE_POSSIBLE, + STATE_BEGAN: STATE_BEGAN, + STATE_CHANGED: STATE_CHANGED, + STATE_ENDED: STATE_ENDED, + STATE_RECOGNIZED: STATE_RECOGNIZED, + STATE_CANCELLED: STATE_CANCELLED, + STATE_FAILED: STATE_FAILED, + + DIRECTION_NONE: DIRECTION_NONE, + DIRECTION_LEFT: DIRECTION_LEFT, + DIRECTION_RIGHT: DIRECTION_RIGHT, + DIRECTION_UP: DIRECTION_UP, + DIRECTION_DOWN: DIRECTION_DOWN, + DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL, + DIRECTION_VERTICAL: DIRECTION_VERTICAL, + DIRECTION_ALL: DIRECTION_ALL, + + Manager: Manager, + Input: Input, + TouchAction: TouchAction, + + TouchInput: TouchInput, + MouseInput: MouseInput, + PointerEventInput: PointerEventInput, + TouchMouseInput: TouchMouseInput, + SingleTouchInput: SingleTouchInput, + + Recognizer: Recognizer, + AttrRecognizer: AttrRecognizer, + Tap: TapRecognizer, + Pan: PanRecognizer, + Swipe: SwipeRecognizer, + Pinch: PinchRecognizer, + Rotate: RotateRecognizer, + Press: PressRecognizer, + + on: addEventListeners, + off: removeEventListeners, + each: each, + merge: merge, + extend: extend, + inherit: inherit, + bindFn: bindFn, + prefixed: prefixed +}); + +if (typeof define == TYPE_FUNCTION && define.amd) { + define(function() { + return Hammer; + }); +} else if (typeof module != 'undefined' && module.exports) { + module.exports = Hammer; +} else { + window[exportName] = Hammer; +} + +})(window, document, 'Hammer'); + +},{}],3:[function(require,module,exports){ +/** + * Copyright (c) 2014-2015, 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 (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + global.Immutable = factory() +}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice; + + function createClass(ctor, superClass) { + if (superClass) { + ctor.prototype = Object.create(superClass.prototype); + } + ctor.prototype.constructor = ctor; + } + + // Used for setting prototype methods that IE8 chokes on. + var DELETE = 'delete'; + + // Constants describing the size of trie nodes. + var SHIFT = 5; // Resulted in best performance after ______? + var SIZE = 1 << SHIFT; + var MASK = SIZE - 1; + + // A consistent shared value representing "not set" which equals nothing other + // than itself, and nothing that could be provided externally. + var NOT_SET = {}; + + // Boolean references, Rough equivalent of `bool &`. + 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); + } + + // A function which returns a value representing an "owner" for transient writes + // to tries. The return value will only ever equal itself, and will not equal + // the return of any subsequent call of this function. + function OwnerID() {} + + // http://jsperf.com/copy-array-inline + 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 ensureSize(iter) { + if (iter.size === undefined) { + iter.size = iter.__iterate(returnTrue); + } + return iter.size; + } + + function wrapIndex(iter, index) { + // This implements "is array index" which the ECMAString spec defines as: + // A String property name P is an array index if and only if + // ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal + // to 2^32−1. + // However note that we're currently calling ToNumber() instead of ToUint32() + // which should be improved in the future, as floating point numbers should + // not be accepted as an array index. + if (typeof index !== 'number') { + var numIndex = +index; + if ('' + numIndex !== index) { + return NaN; + } + index = numIndex; + } + return index < 0 ? ensureSize(iter) + index : 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 Iterable(value) { + return isIterable(value) ? value : Seq(value); + } + + + createClass(KeyedIterable, Iterable); + function KeyedIterable(value) { + return isKeyed(value) ? value : KeyedSeq(value); + } + + + createClass(IndexedIterable, Iterable); + function IndexedIterable(value) { + return isIndexed(value) ? value : IndexedSeq(value); + } + + + createClass(SetIterable, Iterable); + function SetIterable(value) { + return isIterable(value) && !isAssociative(value) ? value : SetSeq(value); + } + + + + 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); + } + + function isOrdered(maybeOrdered) { + return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]); + } + + Iterable.isIterable = isIterable; + Iterable.isKeyed = isKeyed; + Iterable.isIndexed = isIndexed; + Iterable.isAssociative = isAssociative; + Iterable.isOrdered = isOrdered; + + Iterable.Keyed = KeyedIterable; + Iterable.Indexed = IndexedIterable; + Iterable.Set = SetIterable; + + + var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@'; + var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; + var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@'; + var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@'; + + /* global Symbol */ + + var ITERATE_KEYS = 0; + var ITERATE_VALUES = 1; + var ITERATE_ENTRIES = 2; + + var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = '@@iterator'; + + var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL; + + + function src_Iterator__Iterator(next) { + this.next = next; + } + + src_Iterator__Iterator.prototype.toString = function() { + return '[Iterator]'; + }; + + + src_Iterator__Iterator.KEYS = ITERATE_KEYS; + src_Iterator__Iterator.VALUES = ITERATE_VALUES; + src_Iterator__Iterator.ENTRIES = ITERATE_ENTRIES; + + src_Iterator__Iterator.prototype.inspect = + src_Iterator__Iterator.prototype.toSource = function () { return this.toString(); } + src_Iterator__Iterator.prototype[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 !!getIteratorFn(maybeIterable); + } + + function isIterator(maybeIterator) { + return maybeIterator && typeof maybeIterator.next === 'function'; + } + + function getIterator(iterable) { + var iteratorFn = getIteratorFn(iterable); + return iteratorFn && iteratorFn.call(iterable); + } + + function getIteratorFn(iterable) { + var iteratorFn = iterable && ( + (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) || + iterable[FAUX_ITERATOR_SYMBOL] + ); + if (typeof iteratorFn === 'function') { + return iteratorFn; + } + } + + function isArrayLike(value) { + return value && typeof value.length === 'number'; + } + + createClass(Seq, Iterable); + function Seq(value) { + return value === null || value === undefined ? emptySequence() : + isIterable(value) ? value.toSeq() : seqFromValue(value); + } + + Seq.of = function(/*...values*/) { + return Seq(arguments); + }; + + Seq.prototype.toSeq = function() { + return this; + }; + + Seq.prototype.toString = function() { + return this.__toString('Seq {', '}'); + }; + + Seq.prototype.cacheResult = function() { + if (!this._cache && this.__iterateUncached) { + this._cache = this.entrySeq().toArray(); + this.size = this._cache.length; + } + return this; + }; + + // abstract __iterateUncached(fn, reverse) + + Seq.prototype.__iterate = function(fn, reverse) { + return seqIterate(this, fn, reverse, true); + }; + + // abstract __iteratorUncached(type, reverse) + + Seq.prototype.__iterator = function(type, reverse) { + return seqIterator(this, type, reverse, true); + }; + + + + createClass(KeyedSeq, Seq); + function KeyedSeq(value) { + return value === null || value === undefined ? + emptySequence().toKeyedSeq() : + isIterable(value) ? + (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) : + keyedSeqFromValue(value); + } + + KeyedSeq.prototype.toKeyedSeq = function() { + return this; + }; + + + + createClass(IndexedSeq, Seq); + function IndexedSeq(value) { + return value === null || value === undefined ? emptySequence() : + !isIterable(value) ? indexedSeqFromValue(value) : + isKeyed(value) ? value.entrySeq() : value.toIndexedSeq(); + } + + IndexedSeq.of = function(/*...values*/) { + return IndexedSeq(arguments); + }; + + IndexedSeq.prototype.toIndexedSeq = function() { + return this; + }; + + IndexedSeq.prototype.toString = function() { + return this.__toString('Seq [', ']'); + }; + + IndexedSeq.prototype.__iterate = function(fn, reverse) { + return seqIterate(this, fn, reverse, false); + }; + + IndexedSeq.prototype.__iterator = function(type, reverse) { + return seqIterator(this, type, reverse, false); + }; + + + + createClass(SetSeq, Seq); + function SetSeq(value) { + return ( + value === null || value === undefined ? emptySequence() : + !isIterable(value) ? indexedSeqFromValue(value) : + isKeyed(value) ? value.entrySeq() : value + ).toSetSeq(); + } + + SetSeq.of = function(/*...values*/) { + return SetSeq(arguments); + }; + + SetSeq.prototype.toSetSeq = function() { + return this; + }; + + + + Seq.isSeq = isSeq; + Seq.Keyed = KeyedSeq; + Seq.Set = SetSeq; + Seq.Indexed = IndexedSeq; + + var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@'; + + Seq.prototype[IS_SEQ_SENTINEL] = true; + + + + // #pragma Root Sequences + + createClass(ArraySeq, IndexedSeq); + function ArraySeq(array) { + this._array = array; + this.size = array.length; + } + + ArraySeq.prototype.get = function(index, notSetValue) { + return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue; + }; + + ArraySeq.prototype.__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; + }; + + ArraySeq.prototype.__iterator = function(type, reverse) { + var array = this._array; + var maxIndex = array.length - 1; + var ii = 0; + return new src_Iterator__Iterator(function() + {return ii > maxIndex ? + iteratorDone() : + iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])} + ); + }; + + + + createClass(ObjectSeq, KeyedSeq); + function ObjectSeq(object) { + var keys = Object.keys(object); + this._object = object; + this._keys = keys; + this.size = keys.length; + } + + ObjectSeq.prototype.get = function(key, notSetValue) { + if (notSetValue !== undefined && !this.has(key)) { + return notSetValue; + } + return this._object[key]; + }; + + ObjectSeq.prototype.has = function(key) { + return this._object.hasOwnProperty(key); + }; + + ObjectSeq.prototype.__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; + }; + + ObjectSeq.prototype.__iterator = function(type, reverse) { + var object = this._object; + var keys = this._keys; + var maxIndex = keys.length - 1; + var ii = 0; + return new src_Iterator__Iterator(function() { + var key = keys[reverse ? maxIndex - ii : ii]; + return ii++ > maxIndex ? + iteratorDone() : + iteratorValue(type, key, object[key]); + }); + }; + + ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true; + + + createClass(IterableSeq, IndexedSeq); + function IterableSeq(iterable) { + this._iterable = iterable; + this.size = iterable.length || iterable.size; + } + + IterableSeq.prototype.__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; + }; + + IterableSeq.prototype.__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 src_Iterator__Iterator(iteratorDone); + } + var iterations = 0; + return new src_Iterator__Iterator(function() { + var step = iterator.next(); + return step.done ? step : iteratorValue(type, iterations++, step.value); + }); + }; + + + + createClass(IteratorSeq, IndexedSeq); + function IteratorSeq(iterator) { + this._iterator = iterator; + this._iteratorCache = []; + } + + IteratorSeq.prototype.__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; + }; + + IteratorSeq.prototype.__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 src_Iterator__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++]); + }); + }; + + + + + // # pragma Helper functions + + 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 seqIterate(seq, fn, reverse, useKeys) { + 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 src_Iterator__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); + } + + createClass(Collection, Iterable); + function Collection() { + throw TypeError('Abstract'); + } + + + createClass(KeyedCollection, Collection);function KeyedCollection() {} + + createClass(IndexedCollection, Collection);function IndexedCollection() {} + + createClass(SetCollection, Collection);function SetCollection() {} + + + Collection.Keyed = KeyedCollection; + Collection.Indexed = IndexedCollection; + Collection.Set = SetCollection; + + /** + * An extension of the "same-value" algorithm as [described for use by ES6 Map + * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality) + * + * NaN is considered the same as NaN, however -0 and 0 are considered the same + * value, which is different from the algorithm described by + * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). + * + * This is extended further to allow Objects to describe the values they + * represent, by way of `valueOf` or `equals` (and `hashCode`). + * + * Note: because of this extension, the key equality of Immutable.Map and the + * value equality of Immutable.Set will differ from ES6 Map and Set. + * + * ### Defining custom values + * + * The easiest way to describe the value an object represents is by implementing + * `valueOf`. For example, `Date` represents a value by returning a unix + * timestamp for `valueOf`: + * + * var date1 = new Date(1234567890000); // Fri Feb 13 2009 ... + * var date2 = new Date(1234567890000); + * date1.valueOf(); // 1234567890000 + * assert( date1 !== date2 ); + * assert( Immutable.is( date1, date2 ) ); + * + * Note: overriding `valueOf` may have other implications if you use this object + * where JavaScript expects a primitive, such as implicit string coercion. + * + * For more complex types, especially collections, implementing `valueOf` may + * not be performant. An alternative is to implement `equals` and `hashCode`. + * + * `equals` takes another object, presumably of similar type, and returns true + * if the it is equal. Equality is symmetrical, so the same result should be + * returned if this and the argument are flipped. + * + * assert( a.equals(b) === b.equals(a) ); + * + * `hashCode` returns a 32bit integer number representing the object which will + * be used to determine how to store the value object in a Map or Set. You must + * provide both or neither methods, one must not exist without the other. + * + * Also, an important relationship between these methods must be upheld: if two + * values are equal, they *must* return the same hashCode. If the values are not + * equal, they might have the same hashCode; this is called a hash collision, + * and while undesirable for performance reasons, it is acceptable. + * + * if (a.equals(b)) { + * assert( a.hashCode() === b.hashCode() ); + * } + * + * All Immutable collections implement `equals` and `hashCode`. + * + */ + function is(valueA, valueB) { + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + if (typeof valueA.valueOf === 'function' && + typeof valueB.valueOf === 'function') { + valueA = valueA.valueOf(); + valueB = valueB.valueOf(); + if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { + return true; + } + if (!valueA || !valueB) { + return false; + } + } + if (typeof valueA.equals === 'function' && + typeof valueB.equals === 'function' && + valueA.equals(valueB)) { + return true; + } + return false; + } + + 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 || value.constructor === undefined); + } + + var src_Math__imul = + typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ? + Math.imul : + function imul(a, b) { + a = a | 0; // int + b = b | 0; // int + var c = a & 0xffff; + var d = b & 0xffff; + // Shift by 0 fixes the sign on the high part. + return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int + }; + + // v8 has an optimization for storing 31-bit signed numbers. + // Values which have either 00 or 11 as the high order bits qualify. + // This function drops the highest order bit in a signed number, maintaining + // the sign bit. + function smi(i32) { + return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF); + } + + function hash(o) { + if (o === false || o === null || o === undefined) { + return 0; + } + if (typeof o.valueOf === 'function') { + o = o.valueOf(); + if (o === false || o === null || o === undefined) { + return 0; + } + } + if (o === true) { + return 1; + } + var type = typeof o; + if (type === 'number') { + var h = o | 0; + if (h !== o) { + h ^= o * 0xFFFFFFFF; + } + while (o > 0xFFFFFFFF) { + o /= 0xFFFFFFFF; + h ^= o; + } + return smi(h); + } + if (type === 'string') { + return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o); + } + if (typeof o.hashCode === 'function') { + return 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; + } + + // http://jsperf.com/hashing-strings + function hashString(string) { + // This is the hash from JVM + // The hash code for a string is computed as + // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1], + // where s[i] is the ith character of the string and n is the length of + // the string. We "mod" the result to make it between 0 (inclusive) and 2^31 + // (exclusive) by dropping high bits. + var hash = 0; + for (var ii = 0; ii < string.length; ii++) { + hash = 31 * hash + string.charCodeAt(ii) | 0; + } + return smi(hash); + } + + function hashJSObj(obj) { + var hash; + if (usingWeakMap) { + hash = weakMap.get(obj); + if (hash !== undefined) { + return hash; + } + } + + hash = obj[UID_HASH_KEY]; + if (hash !== undefined) { + return hash; + } + + if (!canDefineProperty) { + hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY]; + if (hash !== undefined) { + return hash; + } + + hash = getIENodeHash(obj); + if (hash !== undefined) { + return hash; + } + } + + hash = ++objHashUID; + if (objHashUID & 0x40000000) { + objHashUID = 0; + } + + if (usingWeakMap) { + weakMap.set(obj, hash); + } else if (isExtensible !== undefined && isExtensible(obj) === false) { + throw new Error('Non-extensible objects are not allowed as keys.'); + } else if (canDefineProperty) { + Object.defineProperty(obj, UID_HASH_KEY, { + 'enumerable': false, + 'configurable': false, + 'writable': false, + 'value': hash + }); + } else if (obj.propertyIsEnumerable !== undefined && + obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) { + // Since we can't define a non-enumerable property on the object + // we'll hijack one of the less-used non-enumerable properties to + // save our hash on it. Since this is a function it will not show up in + // `JSON.stringify` which is what we want. + obj.propertyIsEnumerable = function() { + return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments); + }; + obj.propertyIsEnumerable[UID_HASH_KEY] = hash; + } else if (obj.nodeType !== undefined) { + // At this point we couldn't get the IE `uniqueID` to use as a hash + // and we couldn't use a non-enumerable property to exploit the + // dontEnum bug so we simply add the `UID_HASH_KEY` on the node + // itself. + obj[UID_HASH_KEY] = hash; + } else { + throw new Error('Unable to set a non-enumerable property on object.'); + } + + return hash; + } + + // Get references to ES5 object methods. + var isExtensible = Object.isExtensible; + + // True if Object.defineProperty works as expected. IE8 fails this test. + var canDefineProperty = (function() { + try { + Object.defineProperty({}, '@', {}); + return true; + } catch (e) { + return false; + } + }()); + + // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it + // and avoid memory leaks from the IE cloneNode bug. + function getIENodeHash(node) { + if (node && node.nodeType > 0) { + switch (node.nodeType) { + case 1: // Element + return node.uniqueID; + case 9: // Document + return node.documentElement && node.documentElement.uniqueID; + } + } + } + + // If possible, use a WeakMap. + var usingWeakMap = typeof WeakMap === 'function'; + var weakMap; + if (usingWeakMap) { + weakMap = new WeakMap(); + } + + 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 = {}; + + function invariant(condition, error) { + if (!condition) throw new Error(error); + } + + function assertNotInfinite(size) { + invariant( + size !== Infinity, + 'Cannot perform this action with an infinite size.' + ); + } + + createClass(ToKeyedSequence, KeyedSeq); + function ToKeyedSequence(indexed, useKeys) { + this._iter = indexed; + this._useKeys = useKeys; + this.size = indexed.size; + } + + ToKeyedSequence.prototype.get = function(key, notSetValue) { + return this._iter.get(key, notSetValue); + }; + + ToKeyedSequence.prototype.has = function(key) { + return this._iter.has(key); + }; + + ToKeyedSequence.prototype.valueSeq = function() { + return this._iter.valueSeq(); + }; + + ToKeyedSequence.prototype.reverse = function() {var this$0 = this; + var reversedSequence = reverseFactory(this, true); + if (!this._useKeys) { + reversedSequence.valueSeq = function() {return this$0._iter.toSeq().reverse()}; + } + return reversedSequence; + }; + + ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this; + var mappedSequence = mapFactory(this, mapper, context); + if (!this._useKeys) { + mappedSequence.valueSeq = function() {return this$0._iter.toSeq().map(mapper, context)}; + } + return mappedSequence; + }; + + ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; + var ii; + return this._iter.__iterate( + this._useKeys ? + function(v, k) {return fn(v, k, this$0)} : + ((ii = reverse ? resolveSize(this) : 0), + function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}), + reverse + ); + }; + + ToKeyedSequence.prototype.__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 src_Iterator__Iterator(function() { + var step = iterator.next(); + return step.done ? step : + iteratorValue(type, reverse ? --ii : ii++, step.value, step); + }); + }; + + ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true; + + + createClass(ToIndexedSequence, IndexedSeq); + function ToIndexedSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + ToIndexedSequence.prototype.includes = function(value) { + return this._iter.includes(value); + }; + + ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; + var iterations = 0; + return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse); + }; + + ToIndexedSequence.prototype.__iterator = function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + return new src_Iterator__Iterator(function() { + var step = iterator.next(); + return step.done ? step : + iteratorValue(type, iterations++, step.value, step) + }); + }; + + + + createClass(ToSetSequence, SetSeq); + function ToSetSequence(iter) { + this._iter = iter; + this.size = iter.size; + } + + ToSetSequence.prototype.has = function(key) { + return this._iter.includes(key); + }; + + ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; + return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse); + }; + + ToSetSequence.prototype.__iterator = function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new src_Iterator__Iterator(function() { + var step = iterator.next(); + return step.done ? step : + iteratorValue(type, step.value, step.value, step); + }); + }; + + + + createClass(FromEntriesSequence, KeyedSeq); + function FromEntriesSequence(entries) { + this._iter = entries; + this.size = entries.size; + } + + FromEntriesSequence.prototype.entrySeq = function() { + return this._iter.toSeq(); + }; + + FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; + return this._iter.__iterate(function(entry ) { + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedIterable = isIterable(entry); + return fn( + indexedIterable ? entry.get(1) : entry[1], + indexedIterable ? entry.get(0) : entry[0], + this$0 + ); + } + }, reverse); + }; + + FromEntriesSequence.prototype.__iterator = function(type, reverse) { + var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); + return new src_Iterator__Iterator(function() { + while (true) { + var step = iterator.next(); + if (step.done) { + return step; + } + var entry = step.value; + // Check if entry exists first so array access doesn't throw for holes + // in the parent iteration. + if (entry) { + validateEntry(entry); + var indexedIterable = isIterable(entry); + return iteratorValue( + type, + indexedIterable ? entry.get(0) : entry[0], + indexedIterable ? entry.get(1) : entry[1], + step + ); + } + } + }); + }; + + + 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); // super.reverse() + reversedSequence.flip = function() {return iterable.reverse()}; + return reversedSequence; + }; + flipSequence.has = function(key ) {return iterable.includes(key)}; + flipSequence.includes = function(key ) {return iterable.has(key)}; + flipSequence.cacheResult = cacheResultThrough; + flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this; + return iterable.__iterate(function(v, k) {return fn(k, v, this$0) !== false}, reverse); + } + flipSequence.__iteratorUncached = function(type, reverse) { + if (type === ITERATE_ENTRIES) { + var iterator = iterable.__iterator(type, reverse); + return new src_Iterator__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 this$0 = this; + return iterable.__iterate( + function(v, k, c) {return fn(mapper.call(context, v, k, c), k, this$0) !== false}, + reverse + ); + } + mappedSequence.__iteratorUncached = function (type, reverse) { + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + return new src_Iterator__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.includes = function(value ) {return iterable.includes(value)}; + reversedSequence.cacheResult = cacheResultThrough; + reversedSequence.__iterate = function (fn, reverse) {var this$0 = this; + return iterable.__iterate(function(v, k) {return fn(v, k, this$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 this$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, this$0); + } + }, reverse); + return iterations; + }; + filterSequence.__iteratorUncached = function (type, reverse) { + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + var iterations = 0; + return new src_Iterator__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 = src_Map__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 = (isOrdered(iterable) ? OrderedMap() : src_Map__Map()).asMutable(); + iterable.__iterate(function(v, k) { + groups.update( + grouper.call(context, v, k, iterable), + function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)} + ); + }); + var coerce = iterableClass(iterable); + return groups.map(function(arr ) {return reify(iterable, coerce(arr))}); + } + + + function sliceFactory(iterable, begin, end, useKeys) { + var originalSize = iterable.size; + + // Sanitize begin & end using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + if (begin !== undefined) { + begin = begin | 0; + } + if (end !== undefined) { + end = end | 0; + } + + if (wholeSlice(begin, end, originalSize)) { + return iterable; + } + + var resolvedBegin = resolveBegin(begin, originalSize); + var resolvedEnd = resolveEnd(end, originalSize); + + // begin or end will be NaN if they were provided as negative numbers and + // this iterable's size is unknown. In that case, cache first so there is + // a known size and these do not resolve to NaN. + if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) { + return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys); + } + + // Note: resolvedEnd is undefined when the original sequence's length is + // unknown and this slice did not supply an end and should contain all + // elements after resolvedBegin. + // In that case, resolvedSize will be NaN and sliceSize will remain undefined. + var resolvedSize = resolvedEnd - resolvedBegin; + var sliceSize; + if (resolvedSize === resolvedSize) { + sliceSize = resolvedSize < 0 ? 0 : resolvedSize; + } + + var sliceSeq = makeSequence(iterable); + + // If iterable.size is undefined, the size of the realized sliceSeq is + // unknown at this point unless the number of items to slice is 0 + sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined; + + if (!useKeys && isSeq(iterable) && sliceSize >= 0) { + sliceSeq.get = function (index, notSetValue) { + index = wrapIndex(this, index); + return index >= 0 && index < sliceSize ? + iterable.get(index + resolvedBegin, notSetValue) : + notSetValue; + } + } + + sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this; + if (sliceSize === 0) { + return 0; + } + 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++ < resolvedBegin))) { + iterations++; + return fn(v, useKeys ? k : iterations - 1, this$0) !== false && + iterations !== sliceSize; + } + }); + return iterations; + }; + + sliceSeq.__iteratorUncached = function(type, reverse) { + if (sliceSize !== 0 && reverse) { + return this.cacheResult().__iterator(type, reverse); + } + // Don't bother instantiating parent iterator if taking 0. + var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse); + var skipped = 0; + var iterations = 0; + return new src_Iterator__Iterator(function() { + while (skipped++ < resolvedBegin) { + iterator.next(); + } + if (++iterations > sliceSize) { + return iteratorDone(); + } + var step = iterator.next(); + if (useKeys || type === ITERATE_VALUES) { + return step; + } else if (type === ITERATE_KEYS) { + return iteratorValue(type, iterations - 1, undefined, step); + } else { + return iteratorValue(type, iterations - 1, step.value[1], step); + } + }); + } + + return sliceSeq; + } + + + function takeWhileFactory(iterable, predicate, context) { + var takeSequence = makeSequence(iterable); + takeSequence.__iterateUncached = function(fn, reverse) {var this$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, this$0)} + ); + return iterations; + }; + takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this; + if (reverse) { + return this.cacheResult().__iterator(type, reverse); + } + var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); + var iterating = true; + return new src_Iterator__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, this$0)) { + iterating = false; + return iteratorDone(); + } + return type === ITERATE_ENTRIES ? step : + iteratorValue(type, k, v, step); + }); + }; + return takeSequence; + } + + + function skipWhileFactory(iterable, predicate, context, useKeys) { + var skipSequence = makeSequence(iterable); + skipSequence.__iterateUncached = function (fn, reverse) {var this$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, this$0); + } + }); + return iterations; + }; + skipSequence.__iteratorUncached = function(type, reverse) {var this$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 src_Iterator__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, this$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 = [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; + }).filter(function(v ) {return v.size !== 0}); + + if (iters.length === 0) { + return iterable; + } + + if (iters.length === 1) { + var singleton = iters[0]; + if (singleton === iterable || + isKeyedIterable && isKeyed(singleton) || + isIndexed(iterable) && isIndexed(singleton)) { + return singleton; + } + } + + var concatSeq = new ArraySeq(iters); + if (isKeyedIterable) { + concatSeq = concatSeq.toKeyedSeq(); + } else if (!isIndexed(iterable)) { + concatSeq = concatSeq.toSetSeq(); + } + concatSeq = concatSeq.flatten(true); + concatSeq.size = iters.reduce( + function(sum, seq) { + if (sum !== undefined) { + var size = seq.size; + if (size !== undefined) { + return sum + size; + } + } + }, + 0 + ); + return concatSeq; + } + + + 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 this$0 = this; + iter.__iterate(function(v, k) { + if ((!depth || currentDepth < depth) && isIterable(v)) { + flatDeep(v, currentDepth + 1); + } else if (fn(v, useKeys ? k : iterations++, this$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 src_Iterator__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 this$0 = this; + var iterations = 0; + iterable.__iterate(function(v, k) + {return (!iterations || fn(separator, iterations++, this$0) !== false) && + fn(v, iterations++, this$0) !== false}, + reverse + ); + return iterations; + }; + interposedSequence.__iteratorUncached = function(type, reverse) { + var iterator = iterable.__iterator(ITERATE_VALUES, reverse); + var iterations = 0; + var step; + return new src_Iterator__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(a, b) {return maxCompare(comparator, a[1], b[1]) ? b : a}); + return entry && entry[0]; + } else { + return iterable.reduce(function(a, b) {return maxCompare(comparator, a, b) ? b : a}); + } + } + + function maxCompare(comparator, a, b) { + var comp = comparator(b, a); + // b is considered the new max if the comparator declares them equal, but + // they are not equal and b is in fact a nullish value. + return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0; + } + + + function zipWithFactory(keyIter, zipper, iters) { + var zipSequence = makeSequence(keyIter); + zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min(); + // Note: this a generic base implementation of __iterate in terms of + // __iterator which may be more generically useful in the future. + zipSequence.__iterate = function(fn, reverse) { + /* generic: + var iterator = this.__iterator(ITERATE_ENTRIES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + iterations++; + if (fn(step.value[1], step.value[0], this) === false) { + break; + } + } + return iterations; + */ + // indexed: + var iterator = this.__iterator(ITERATE_VALUES, reverse); + var step; + var iterations = 0; + while (!(step = iterator.next()).done) { + if (fn(step.value, iterations++, this) === false) { + break; + } + } + return iterations; + }; + zipSequence.__iteratorUncached = function(type, reverse) { + var iterators = iters.map(function(i ) + {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))} + ); + var iterations = 0; + var isDone = false; + return new src_Iterator__Iterator(function() { + var steps; + if (!isDone) { + steps = iterators.map(function(i ) {return i.next()}); + isDone = steps.some(function(s ) {return s.done}); + } + if (isDone) { + return iteratorDone(); + } + return iteratorValue( + type, + iterations++, + zipper.apply(null, steps.map(function(s ) {return s.value})) + ); + }); + }; + return zipSequence + } + + + // #pragma Helper Functions + + 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; + } + + function forceIterator(keyPath) { + var iter = getIterator(keyPath); + if (!iter) { + // Array might not be iterable in this environment, so we need a fallback + // to our wrapped type. + if (!isArrayLike(keyPath)) { + throw new TypeError('Expected iterable or array-like: ' + keyPath); + } + iter = getIterator(Iterable(keyPath)); + } + return iter; + } + + createClass(src_Map__Map, KeyedCollection); + + // @pragma Construction + + function src_Map__Map(value) { + return value === null || value === undefined ? emptyMap() : + isMap(value) && !isOrdered(value) ? value : + emptyMap().withMutations(function(map ) { + var iter = KeyedIterable(value); + assertNotInfinite(iter.size); + iter.forEach(function(v, k) {return map.set(k, v)}); + }); + } + + src_Map__Map.prototype.toString = function() { + return this.__toString('Map {', '}'); + }; + + // @pragma Access + + src_Map__Map.prototype.get = function(k, notSetValue) { + return this._root ? + this._root.get(0, undefined, k, notSetValue) : + notSetValue; + }; + + // @pragma Modification + + src_Map__Map.prototype.set = function(k, v) { + return updateMap(this, k, v); + }; + + src_Map__Map.prototype.setIn = function(keyPath, v) { + return this.updateIn(keyPath, NOT_SET, function() {return v}); + }; + + src_Map__Map.prototype.remove = function(k) { + return updateMap(this, k, NOT_SET); + }; + + src_Map__Map.prototype.deleteIn = function(keyPath) { + return this.updateIn(keyPath, function() {return NOT_SET}); + }; + + src_Map__Map.prototype.update = function(k, notSetValue, updater) { + return arguments.length === 1 ? + k(this) : + this.updateIn([k], notSetValue, updater); + }; + + src_Map__Map.prototype.updateIn = function(keyPath, notSetValue, updater) { + if (!updater) { + updater = notSetValue; + notSetValue = undefined; + } + var updatedValue = updateInDeepMap( + this, + forceIterator(keyPath), + notSetValue, + updater + ); + return updatedValue === NOT_SET ? undefined : updatedValue; + }; + + src_Map__Map.prototype.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(); + }; + + // @pragma Composition + + src_Map__Map.prototype.merge = function(/*...iters*/) { + return mergeIntoMapWith(this, undefined, arguments); + }; + + src_Map__Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); + return mergeIntoMapWith(this, merger, iters); + }; + + src_Map__Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1); + return this.updateIn( + keyPath, + emptyMap(), + function(m ) {return typeof m.merge === 'function' ? + m.merge.apply(m, iters) : + iters[iters.length - 1]} + ); + }; + + src_Map__Map.prototype.mergeDeep = function(/*...iters*/) { + return mergeIntoMapWith(this, deepMerger(undefined), arguments); + }; + + src_Map__Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1); + return mergeIntoMapWith(this, deepMerger(merger), iters); + }; + + src_Map__Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1); + return this.updateIn( + keyPath, + emptyMap(), + function(m ) {return typeof m.mergeDeep === 'function' ? + m.mergeDeep.apply(m, iters) : + iters[iters.length - 1]} + ); + }; + + src_Map__Map.prototype.sort = function(comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator)); + }; + + src_Map__Map.prototype.sortBy = function(mapper, comparator) { + // Late binding + return OrderedMap(sortFactory(this, comparator, mapper)); + }; + + // @pragma Mutability + + src_Map__Map.prototype.withMutations = function(fn) { + var mutable = this.asMutable(); + fn(mutable); + return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this; + }; + + src_Map__Map.prototype.asMutable = function() { + return this.__ownerID ? this : this.__ensureOwner(new OwnerID()); + }; + + src_Map__Map.prototype.asImmutable = function() { + return this.__ensureOwner(); + }; + + src_Map__Map.prototype.wasAltered = function() { + return this.__altered; + }; + + src_Map__Map.prototype.__iterator = function(type, reverse) { + return new MapIterator(this, type, reverse); + }; + + src_Map__Map.prototype.__iterate = function(fn, reverse) {var this$0 = this; + var iterations = 0; + this._root && this._root.iterate(function(entry ) { + iterations++; + return fn(entry[1], entry[0], this$0); + }, reverse); + return iterations; + }; + + src_Map__Map.prototype.__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); + }; + + + function isMap(maybeMap) { + return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]); + } + + src_Map__Map.isMap = isMap; + + var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@'; + + var MapPrototype = src_Map__Map.prototype; + MapPrototype[IS_MAP_SENTINEL] = true; + MapPrototype[DELETE] = MapPrototype.remove; + MapPrototype.removeIn = MapPrototype.deleteIn; + + + // #pragma Trie Nodes + + + + function ArrayMapNode(ownerID, entries) { + this.ownerID = ownerID; + this.entries = entries; + } + + ArrayMapNode.prototype.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; + }; + + ArrayMapNode.prototype.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; // undefined + } + + 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); + }; + + + + + function BitmapIndexedNode(ownerID, bitmap, nodes) { + this.ownerID = ownerID; + this.bitmap = bitmap; + this.nodes = nodes; + } + + BitmapIndexedNode.prototype.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); + }; + + BitmapIndexedNode.prototype.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); + }; + + + + + function HashArrayMapNode(ownerID, count, nodes) { + this.ownerID = ownerID; + this.count = count; + this.nodes = nodes; + } + + HashArrayMapNode.prototype.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; + }; + + HashArrayMapNode.prototype.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); + }; + + + + + function HashCollisionNode(ownerID, keyHash, entries) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entries = entries; + } + + HashCollisionNode.prototype.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; + }; + + HashCollisionNode.prototype.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); + }; + + + + + function ValueNode(ownerID, keyHash, entry) { + this.ownerID = ownerID; + this.keyHash = keyHash; + this.entry = entry; + } + + ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) { + return is(key, this.entry[0]) ? this.entry[1] : notSetValue; + }; + + ValueNode.prototype.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; // undefined + } + + 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]); + }; + + + + // #pragma Iterators + + 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); + } + + createClass(MapIterator, src_Iterator__Iterator); + + function MapIterator(map, type, reverse) { + this._type = type; + this._reverse = reverse; + this._stack = map._root && mapIteratorFrame(map._root); + } + + MapIterator.prototype.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(); + }; + + + 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, key) + {return existing && existing.mergeDeepWith && isIterable(value) ? + existing.mergeDeepWith(merger, value) : + merger ? merger(existing, value, key) : value}; + } + + function mergeIntoCollectionWith(collection, merger, iters) { + iters = iters.filter(function(x ) {return x.size !== 0}); + if (iters.length === 0) { + return collection; + } + if (collection.size === 0 && !collection.__ownerID && iters.length === 1) { + return collection.constructor(iters[0]); + } + 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, key)} + ); + } : + function(value, key) { + collection.set(key, value); + } + for (var ii = 0; ii < iters.length; ii++) { + iters[ii].forEach(mergeIntoMap); + } + }); + } + + function updateInDeepMap(existing, keyPathIter, notSetValue, updater) { + var isNotSet = existing === NOT_SET; + var step = keyPathIter.next(); + if (step.done) { + var existingValue = isNotSet ? notSetValue : existing; + var newValue = updater(existingValue); + return newValue === existingValue ? existing : newValue; + } + invariant( + isNotSet || (existing && existing.set), + 'invalid keyPath' + ); + var key = step.value; + var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET); + var nextUpdated = updateInDeepMap( + nextExisting, + keyPathIter, + notSetValue, + updater + ); + return nextUpdated === nextExisting ? existing : + nextUpdated === NOT_SET ? existing.remove(key) : + (isNotSet ? emptyMap() : existing).set(key, nextUpdated); + } + + 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; + + createClass(List, IndexedCollection); + + // @pragma Construction + + function List(value) { + var empty = emptyList(); + if (value === null || value === undefined) { + return empty; + } + if (isList(value)) { + return value; + } + var iter = IndexedIterable(value); + var size = iter.size; + if (size === 0) { + return empty; + } + assertNotInfinite(size); + if (size > 0 && size < SIZE) { + return makeList(0, size, SHIFT, null, new VNode(iter.toArray())); + } + return empty.withMutations(function(list ) { + list.setSize(size); + iter.forEach(function(v, i) {return list.set(i, v)}); + }); + } + + List.of = function(/*...values*/) { + return this(arguments); + }; + + List.prototype.toString = function() { + return this.__toString('List [', ']'); + }; + + // @pragma Access + + List.prototype.get = function(index, notSetValue) { + index = wrapIndex(this, index); + if (index >= 0 && index < this.size) { + index += this._origin; + var node = listNodeFor(this, index); + return node && node.array[index & MASK]; + } + return notSetValue; + }; + + // @pragma Modification + + List.prototype.set = function(index, value) { + return updateList(this, index, value); + }; + + List.prototype.remove = function(index) { + return !this.has(index) ? this : + index === 0 ? this.shift() : + index === this.size - 1 ? this.pop() : + this.splice(index, 1); + }; + + List.prototype.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(); + }; + + List.prototype.push = function(/*...values*/) { + 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]); + } + }); + }; + + List.prototype.pop = function() { + return setListBounds(this, 0, -1); + }; + + List.prototype.unshift = function(/*...values*/) { + 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]); + } + }); + }; + + List.prototype.shift = function() { + return setListBounds(this, 1); + }; + + // @pragma Composition + + List.prototype.merge = function(/*...iters*/) { + return mergeIntoListWith(this, undefined, arguments); + }; + + List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); + return mergeIntoListWith(this, merger, iters); + }; + + List.prototype.mergeDeep = function(/*...iters*/) { + return mergeIntoListWith(this, deepMerger(undefined), arguments); + }; + + List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1); + return mergeIntoListWith(this, deepMerger(merger), iters); + }; + + List.prototype.setSize = function(size) { + return setListBounds(this, 0, size); + }; + + // @pragma Iteration + + List.prototype.slice = function(begin, end) { + var size = this.size; + if (wholeSlice(begin, end, size)) { + return this; + } + return setListBounds( + this, + resolveBegin(begin, size), + resolveEnd(end, size) + ); + }; + + List.prototype.__iterator = function(type, reverse) { + var index = 0; + var values = iterateList(this, reverse); + return new src_Iterator__Iterator(function() { + var value = values(); + return value === DONE ? + iteratorDone() : + iteratorValue(type, index++, value); + }); + }; + + List.prototype.__iterate = function(fn, reverse) { + var index = 0; + var values = iterateList(this, reverse); + var value; + while ((value = values()) !== DONE) { + if (fn(value, index++, this) === false) { + break; + } + } + return index; + }; + + List.prototype.__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); + }; + + + 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.deleteIn = + ListPrototype.removeIn = MapPrototype.removeIn; + ListPrototype.update = MapPrototype.update; + ListPrototype.updateIn = MapPrototype.updateIn; + ListPrototype.mergeIn = MapPrototype.mergeIn; + ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn; + ListPrototype.withMutations = MapPrototype.withMutations; + ListPrototype.asMutable = MapPrototype.asMutable; + ListPrototype.asImmutable = MapPrototype.asImmutable; + ListPrototype.wasAltered = MapPrototype.wasAltered; + + + + function VNode(array, ownerID) { + this.array = array; + this.ownerID = ownerID; + } + + // TODO: seems like these methods are very similar + + VNode.prototype.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; + }; + + VNode.prototype.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 newChild; + if (level > 0) { + var oldChild = this.array[sizeIndex]; + newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index); + if (newChild === oldChild && sizeIndex === this.array.length - 1) { + return this; + } + } + + var editable = editableVNode(this, ownerID); + editable.array.splice(sizeIndex + 1); + if (newChild) { + editable.array[sizeIndex] = newChild; + } + return editable; + }; + + + + var DONE = {}; + + function iterateList(list, reverse) { + var left = list._origin; + var right = list._capacity; + var tailPos = getTailOffset(right); + var tail = list._tail; + + return iterateNodeOrLeaf(list._root, list._level, 0); + + function iterateNodeOrLeaf(node, level, offset) { + return level === 0 ? + iterateLeaf(node, offset) : + iterateNode(node, level, offset); + } + + function iterateLeaf(node, offset) { + var array = offset === tailPos ? tail && tail.array : node && node.array; + var from = offset > left ? 0 : left - offset; + var to = right - offset; + if (to > SIZE) { + to = SIZE; + } + return function() { + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + return array && array[idx]; + }; + } + + function iterateNode(node, level, offset) { + var values; + var array = node && node.array; + var from = offset > left ? 0 : (left - offset) >> level; + var to = ((right - offset) >> level) + 1; + if (to > SIZE) { + to = SIZE; + } + return function() { + do { + if (values) { + var value = values(); + if (value !== DONE) { + return value; + } + values = null; + } + if (from === to) { + return DONE; + } + var idx = reverse ? --to : from++; + values = iterateNodeOrLeaf( + array && array[idx], level - SHIFT, offset + (idx << level) + ); + } while (true); + }; + } + } + + 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 !== index) { + return list; + } + + 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) { + // Sanitize begin & end using this shorthand for ToInt32(argument) + // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32 + if (begin !== undefined) { + begin = begin | 0; + } + if (end !== undefined) { + end = end | 0; + } + 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 it's going to end after it starts, it's empty. + if (newOrigin >= newCapacity) { + return list.clear(); + } + + var newLevel = list._level; + var newRoot = list._root; + + // New origin might need creating a higher 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); + + // New size might need creating a higher root. + while (newTailOffset >= 1 << (newLevel + SHIFT)) { + newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner); + newLevel += SHIFT; + } + + // Locate or create the new tail. + var oldTail = list._tail; + var newTail = newTailOffset < oldTailOffset ? + listNodeFor(list, newCapacity - 1) : + newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail; + + // Merge Tail into tree. + 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 the size has been reduced, there's a chance the tail needs to be trimmed. + if (newCapacity < oldCapacity) { + newTail = newTail && newTail.removeAfter(owner, 0, newCapacity); + } + + // If the new origin is within the tail, then we do not need a root. + if (newOrigin >= newTailOffset) { + newOrigin -= newTailOffset; + newCapacity -= newTailOffset; + newLevel = SHIFT; + newRoot = null; + newTail = newTail && newTail.removeBefore(owner, 0, newOrigin); + + // Otherwise, if the root has been trimmed, garbage collect. + } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) { + offsetShift = 0; + + // Identify the new top root node of the subtree of the old root. + 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]; + } + + // Trim the new sides of the new root. + 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); + } + + createClass(OrderedMap, src_Map__Map); + + // @pragma Construction + + function OrderedMap(value) { + return value === null || value === undefined ? emptyOrderedMap() : + isOrderedMap(value) ? value : + emptyOrderedMap().withMutations(function(map ) { + var iter = KeyedIterable(value); + assertNotInfinite(iter.size); + iter.forEach(function(v, k) {return map.set(k, v)}); + }); + } + + OrderedMap.of = function(/*...values*/) { + return this(arguments); + }; + + OrderedMap.prototype.toString = function() { + return this.__toString('OrderedMap {', '}'); + }; + + // @pragma Access + + OrderedMap.prototype.get = function(k, notSetValue) { + var index = this._map.get(k); + return index !== undefined ? this._list.get(index)[1] : notSetValue; + }; + + // @pragma Modification + + OrderedMap.prototype.clear = function() { + if (this.size === 0) { + return this; + } + if (this.__ownerID) { + this.size = 0; + this._map.clear(); + this._list.clear(); + return this; + } + return emptyOrderedMap(); + }; + + OrderedMap.prototype.set = function(k, v) { + return updateOrderedMap(this, k, v); + }; + + OrderedMap.prototype.remove = function(k) { + return updateOrderedMap(this, k, NOT_SET); + }; + + OrderedMap.prototype.wasAltered = function() { + return this._map.wasAltered() || this._list.wasAltered(); + }; + + OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this; + return this._list.__iterate( + function(entry ) {return entry && fn(entry[1], entry[0], this$0)}, + reverse + ); + }; + + OrderedMap.prototype.__iterator = function(type, reverse) { + return this._list.fromEntrySeq().__iterator(type, reverse); + }; + + OrderedMap.prototype.__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); + }; + + + function isOrderedMap(maybeOrderedMap) { + return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap); + } + + OrderedMap.isOrderedMap = isOrderedMap; + + OrderedMap.prototype[IS_ORDERED_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) { // removed + 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); + } + + createClass(Stack, IndexedCollection); + + // @pragma Construction + + function Stack(value) { + return value === null || value === undefined ? emptyStack() : + isStack(value) ? value : + emptyStack().unshiftAll(value); + } + + Stack.of = function(/*...values*/) { + return this(arguments); + }; + + Stack.prototype.toString = function() { + return this.__toString('Stack [', ']'); + }; + + // @pragma Access + + Stack.prototype.get = function(index, notSetValue) { + var head = this._head; + index = wrapIndex(this, index); + while (head && index--) { + head = head.next; + } + return head ? head.value : notSetValue; + }; + + Stack.prototype.peek = function() { + return this._head && this._head.value; + }; + + // @pragma Modification + + Stack.prototype.push = function(/*...values*/) { + 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); + }; + + Stack.prototype.pushAll = function(iter) { + iter = IndexedIterable(iter); + if (iter.size === 0) { + return this; + } + assertNotInfinite(iter.size); + 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); + }; + + Stack.prototype.pop = function() { + return this.slice(1); + }; + + Stack.prototype.unshift = function(/*...values*/) { + return this.push.apply(this, arguments); + }; + + Stack.prototype.unshiftAll = function(iter) { + return this.pushAll(iter); + }; + + Stack.prototype.shift = function() { + return this.pop.apply(this, arguments); + }; + + Stack.prototype.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(); + }; + + Stack.prototype.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) { + // super.slice(begin, end); + return IndexedCollection.prototype.slice.call(this, 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); + }; + + // @pragma Mutability + + Stack.prototype.__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); + }; + + // @pragma Iteration + + Stack.prototype.__iterate = function(fn, reverse) { + if (reverse) { + return this.reverse().__iterate(fn); + } + var iterations = 0; + var node = this._head; + while (node) { + if (fn(node.value, iterations++, this) === false) { + break; + } + node = node.next; + } + return iterations; + }; + + Stack.prototype.__iterator = function(type, reverse) { + if (reverse) { + return this.reverse().__iterator(type); + } + var iterations = 0; + var node = this._head; + return new src_Iterator__Iterator(function() { + if (node) { + var value = node.value; + node = node.next; + return iteratorValue(type, iterations++, value); + } + return iteratorDone(); + }); + }; + + + 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)); + } + + createClass(src_Set__Set, SetCollection); + + // @pragma Construction + + function src_Set__Set(value) { + return value === null || value === undefined ? emptySet() : + isSet(value) && !isOrdered(value) ? value : + emptySet().withMutations(function(set ) { + var iter = SetIterable(value); + assertNotInfinite(iter.size); + iter.forEach(function(v ) {return set.add(v)}); + }); + } + + src_Set__Set.of = function(/*...values*/) { + return this(arguments); + }; + + src_Set__Set.fromKeys = function(value) { + return this(KeyedIterable(value).keySeq()); + }; + + src_Set__Set.prototype.toString = function() { + return this.__toString('Set {', '}'); + }; + + // @pragma Access + + src_Set__Set.prototype.has = function(value) { + return this._map.has(value); + }; + + // @pragma Modification + + src_Set__Set.prototype.add = function(value) { + return updateSet(this, this._map.set(value, true)); + }; + + src_Set__Set.prototype.remove = function(value) { + return updateSet(this, this._map.remove(value)); + }; + + src_Set__Set.prototype.clear = function() { + return updateSet(this, this._map.clear()); + }; + + // @pragma Composition + + src_Set__Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0); + iters = iters.filter(function(x ) {return x.size !== 0}); + if (iters.length === 0) { + return this; + } + if (this.size === 0 && !this.__ownerID && iters.length === 1) { + return this.constructor(iters[0]); + } + return this.withMutations(function(set ) { + for (var ii = 0; ii < iters.length; ii++) { + SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)}); + } + }); + }; + + src_Set__Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0); + 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.includes(value)})) { + set.remove(value); + } + }); + }); + }; + + src_Set__Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0); + 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.includes(value)})) { + set.remove(value); + } + }); + }); + }; + + src_Set__Set.prototype.merge = function() { + return this.union.apply(this, arguments); + }; + + src_Set__Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); + return this.union.apply(this, iters); + }; + + src_Set__Set.prototype.sort = function(comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator)); + }; + + src_Set__Set.prototype.sortBy = function(mapper, comparator) { + // Late binding + return OrderedSet(sortFactory(this, comparator, mapper)); + }; + + src_Set__Set.prototype.wasAltered = function() { + return this._map.wasAltered(); + }; + + src_Set__Set.prototype.__iterate = function(fn, reverse) {var this$0 = this; + return this._map.__iterate(function(_, k) {return fn(k, k, this$0)}, reverse); + }; + + src_Set__Set.prototype.__iterator = function(type, reverse) { + return this._map.map(function(_, k) {return k}).__iterator(type, reverse); + }; + + src_Set__Set.prototype.__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); + }; + + + function isSet(maybeSet) { + return !!(maybeSet && maybeSet[IS_SET_SENTINEL]); + } + + src_Set__Set.isSet = isSet; + + var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@'; + + var SetPrototype = src_Set__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())); + } + + createClass(OrderedSet, src_Set__Set); + + // @pragma Construction + + function OrderedSet(value) { + return value === null || value === undefined ? emptyOrderedSet() : + isOrderedSet(value) ? value : + emptyOrderedSet().withMutations(function(set ) { + var iter = SetIterable(value); + assertNotInfinite(iter.size); + iter.forEach(function(v ) {return set.add(v)}); + }); + } + + OrderedSet.of = function(/*...values*/) { + return this(arguments); + }; + + OrderedSet.fromKeys = function(value) { + return this(KeyedIterable(value).keySeq()); + }; + + OrderedSet.prototype.toString = function() { + return this.__toString('OrderedSet {', '}'); + }; + + + function isOrderedSet(maybeOrderedSet) { + return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet); + } + + OrderedSet.isOrderedSet = isOrderedSet; + + var OrderedSetPrototype = OrderedSet.prototype; + OrderedSetPrototype[IS_ORDERED_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())); + } + + createClass(Record, KeyedCollection); + + function Record(defaultValues, name) { + var hasInitialized; + + var RecordType = function Record(values) { + if (values instanceof RecordType) { + return values; + } + if (!(this instanceof RecordType)) { + return new RecordType(values); + } + if (!hasInitialized) { + hasInitialized = true; + var keys = Object.keys(defaultValues); + setProps(RecordTypePrototype, keys); + RecordTypePrototype.size = keys.length; + RecordTypePrototype._name = name; + RecordTypePrototype._keys = keys; + RecordTypePrototype._defaultValues = defaultValues; + } + this._map = src_Map__Map(values); + }; + + var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype); + RecordTypePrototype.constructor = RecordType; + + return RecordType; + } + + Record.prototype.toString = function() { + return this.__toString(recordName(this) + ' {', '}'); + }; + + // @pragma Access + + Record.prototype.has = function(k) { + return this._defaultValues.hasOwnProperty(k); + }; + + Record.prototype.get = function(k, notSetValue) { + if (!this.has(k)) { + return notSetValue; + } + var defaultVal = this._defaultValues[k]; + return this._map ? this._map.get(k, defaultVal) : defaultVal; + }; + + // @pragma Modification + + Record.prototype.clear = function() { + if (this.__ownerID) { + this._map && this._map.clear(); + return this; + } + var RecordType = this.constructor; + return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap())); + }; + + Record.prototype.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); + }; + + Record.prototype.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); + }; + + Record.prototype.wasAltered = function() { + return this._map.wasAltered(); + }; + + Record.prototype.__iterator = function(type, reverse) {var this$0 = this; + return KeyedIterable(this._defaultValues).map(function(_, k) {return this$0.get(k)}).__iterator(type, reverse); + }; + + Record.prototype.__iterate = function(fn, reverse) {var this$0 = this; + return KeyedIterable(this._defaultValues).map(function(_, k) {return this$0.get(k)}).__iterate(fn, reverse); + }; + + Record.prototype.__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); + }; + + + var RecordPrototype = Record.prototype; + RecordPrototype[DELETE] = RecordPrototype.remove; + RecordPrototype.deleteIn = + RecordPrototype.removeIn = MapPrototype.removeIn; + RecordPrototype.merge = MapPrototype.merge; + RecordPrototype.mergeWith = MapPrototype.mergeWith; + RecordPrototype.mergeIn = MapPrototype.mergeIn; + RecordPrototype.mergeDeep = MapPrototype.mergeDeep; + RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith; + RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn; + RecordPrototype.setIn = MapPrototype.setIn; + 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 || 'Record'; + } + + function setProps(prototype, names) { + try { + names.forEach(setProp.bind(undefined, prototype)); + } catch (error) { + // Object.defineProperty failed. Probably IE8. + } + } + + function setProp(prototype, name) { + Object.defineProperty(prototype, name, { + get: function() { + return this.get(name); + }, + set: function(value) { + invariant(this.__ownerID, 'Cannot set on an immutable record.'); + this.set(name, value); + } + }); + } + + function deepEqual(a, b) { + if (a === b) { + return true; + } + + if ( + !isIterable(b) || + a.size !== undefined && b.size !== undefined && a.size !== b.size || + a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash || + isKeyed(a) !== isKeyed(b) || + isIndexed(a) !== isIndexed(b) || + isOrdered(a) !== isOrdered(b) + ) { + return false; + } + + if (a.size === 0 && b.size === 0) { + return true; + } + + var notAssociative = !isAssociative(a); + + if (isOrdered(a)) { + var entries = a.entries(); + return b.every(function(v, k) { + var entry = entries.next().value; + return entry && is(entry[1], v) && (notAssociative || is(entry[0], k)); + }) && entries.next().done; + } + + var flipped = false; + + if (a.size === undefined) { + if (b.size === undefined) { + if (typeof a.cacheResult === 'function') { + a.cacheResult(); + } + } else { + flipped = true; + var _ = a; + a = b; + b = _; + } + } + + var allEqual = true; + var bSize = b.__iterate(function(v, k) { + if (notAssociative ? !a.has(v) : + flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) { + allEqual = false; + return false; + } + }); + + return allEqual && a.size === bSize; + } + + createClass(Range, IndexedSeq); + + 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; + } + 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); + if (this.size === 0) { + if (EMPTY_RANGE) { + return EMPTY_RANGE; + } + EMPTY_RANGE = this; + } + } + + Range.prototype.toString = function() { + if (this.size === 0) { + return 'Range []'; + } + return 'Range [ ' + + this._start + '...' + this._end + + (this._step > 1 ? ' by ' + this._step : '') + + ' ]'; + }; + + Range.prototype.get = function(index, notSetValue) { + return this.has(index) ? + this._start + wrapIndex(this, index) * this._step : + notSetValue; + }; + + Range.prototype.includes = function(searchValue) { + var possibleIndex = (searchValue - this._start) / this._step; + return possibleIndex >= 0 && + possibleIndex < this.size && + possibleIndex === Math.floor(possibleIndex); + }; + + Range.prototype.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 new Range(0, 0); + } + return new Range(this.get(begin, this._end), this.get(end, this._end), this._step); + }; + + Range.prototype.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; + }; + + Range.prototype.lastIndexOf = function(searchValue) { + return this.indexOf(searchValue); + }; + + Range.prototype.__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; + }; + + Range.prototype.__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 src_Iterator__Iterator(function() { + var v = value; + value += reverse ? -step : step; + return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v); + }); + }; + + Range.prototype.equals = function(other) { + return other instanceof Range ? + this._start === other._start && + this._end === other._end && + this._step === other._step : + deepEqual(this, other); + }; + + + var EMPTY_RANGE; + + createClass(Repeat, IndexedSeq); + + function Repeat(value, times) { + 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) { + if (EMPTY_REPEAT) { + return EMPTY_REPEAT; + } + EMPTY_REPEAT = this; + } + } + + Repeat.prototype.toString = function() { + if (this.size === 0) { + return 'Repeat []'; + } + return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]'; + }; + + Repeat.prototype.get = function(index, notSetValue) { + return this.has(index) ? this._value : notSetValue; + }; + + Repeat.prototype.includes = function(searchValue) { + return is(this._value, searchValue); + }; + + Repeat.prototype.slice = function(begin, end) { + var size = this.size; + return wholeSlice(begin, end, size) ? this : + new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size)); + }; + + Repeat.prototype.reverse = function() { + return this; + }; + + Repeat.prototype.indexOf = function(searchValue) { + if (is(this._value, searchValue)) { + return 0; + } + return -1; + }; + + Repeat.prototype.lastIndexOf = function(searchValue) { + if (is(this._value, searchValue)) { + return this.size; + } + return -1; + }; + + Repeat.prototype.__iterate = function(fn, reverse) { + for (var ii = 0; ii < this.size; ii++) { + if (fn(this._value, ii, this) === false) { + return ii + 1; + } + } + return ii; + }; + + Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this; + var ii = 0; + return new src_Iterator__Iterator(function() + {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()} + ); + }; + + Repeat.prototype.equals = function(other) { + return other instanceof Repeat ? + is(this._value, other._value) : + deepEqual(other); + }; + + + var EMPTY_REPEAT; + + /** + * Contributes additional methods to a constructor + */ + function mixin(ctor, methods) { + var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; }; + Object.keys(methods).forEach(keyCopier); + Object.getOwnPropertySymbols && + Object.getOwnPropertySymbols(methods).forEach(keyCopier); + return ctor; + } + + Iterable.Iterator = src_Iterator__Iterator; + + mixin(Iterable, { + + // ### Conversion to other types + + 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(); + }, + + toJSON: function() { + return this.toSeq().map( + function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value} + ).__toJS(); + }, + + toKeyedSeq: function() { + return new ToKeyedSequence(this, true); + }, + + toMap: function() { + // Use Late Binding here to solve the circular dependency. + return src_Map__Map(this.toKeyedSeq()); + }, + + toObject: function() { + assertNotInfinite(this.size); + var object = {}; + this.__iterate(function(v, k) { object[k] = v; }); + return object; + }, + + toOrderedMap: function() { + // Use Late Binding here to solve the circular dependency. + return OrderedMap(this.toKeyedSeq()); + }, + + toOrderedSet: function() { + // Use Late Binding here to solve the circular dependency. + return OrderedSet(isKeyed(this) ? this.valueSeq() : this); + }, + + toSet: function() { + // Use Late Binding here to solve the circular dependency. + return src_Set__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() { + // Use Late Binding here to solve the circular dependency. + return Stack(isKeyed(this) ? this.valueSeq() : this); + }, + + toList: function() { + // Use Late Binding here to solve the circular dependency. + return List(isKeyed(this) ? this.valueSeq() : this); + }, + + + // ### Common JavaScript methods and properties + + toString: function() { + return '[Iterable]'; + }, + + __toString: function(head, tail) { + if (this.size === 0) { + return head + tail; + } + return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail; + }, + + + // ### ES6 Collection methods (ES6 Array and Map) + + concat: function() {var values = SLICE$0.call(arguments, 0); + return reify(this, concatFactory(this, values)); + }, + + includes: function(searchValue) { + return this.some(function(value ) {return is(value, searchValue)}); + }, + + entries: function() { + return this.__iterator(ITERATE_ENTRIES); + }, + + every: function(predicate, context) { + assertNotInfinite(this.size); + 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 entry = this.findEntry(predicate, context); + return entry ? entry[1] : notSetValue; + }, + + findEntry: function(predicate, context) { + var found; + this.__iterate(function(v, k, c) { + if (predicate.call(context, v, k, c)) { + found = [k, v]; + return false; + } + }); + return found; + }, + + findLastEntry: function(predicate, context) { + return this.toSeq().reverse().findEntry(predicate, context); + }, + + forEach: function(sideEffect, context) { + assertNotInfinite(this.size); + return this.__iterate(context ? sideEffect.bind(context) : sideEffect); + }, + + join: function(separator) { + assertNotInfinite(this.size); + separator = separator !== undefined ? '' + separator : ','; + var joined = ''; + var isFirst = true; + this.__iterate(function(v ) { + isFirst ? (isFirst = false) : (joined += separator); + joined += v !== null && v !== undefined ? v.toString() : ''; + }); + 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) { + assertNotInfinite(this.size); + 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) { + return reify(this, sliceFactory(this, begin, end, true)); + }, + + 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); + }, + + + // ### More sequential methods + + butLast: function() { + return this.slice(0, -1); + }, + + isEmpty: function() { + return this.size !== undefined ? this.size === 0 : !this.some(function() {return true}); + }, + + 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) { + return deepEqual(this, other); + }, + + entrySeq: function() { + var iterable = this; + if (iterable._cache) { + // We cache as an entries array, so we can just return the 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; + // Note: in an ES6 environment, we would prefer: + // for (var key of searchKeyPath) { + var iter = forceIterator(searchKeyPath); + var step; + while (!(step = iter.next()).done) { + var key = step.value; + nested = nested && nested.get ? nested.get(key, 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; + }, + + hasIn: function(searchKeyPath) { + return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET; + }, + + isSubset: function(iter) { + iter = typeof iter.includes === 'function' ? iter : Iterable(iter); + return this.every(function(value ) {return iter.includes(value)}); + }, + + isSuperset: function(iter) { + iter = typeof iter.isSubset === 'function' ? iter : Iterable(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 this.slice(Math.max(0, amount)); + }, + + 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 this.slice(0, Math.max(0, 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(); + }, + + + // ### Hashable Object + + hashCode: function() { + return this.__hash || (this.__hash = hashIterable(this)); + } + + + // ### Internal + + // abstract __iterate(fn, reverse) + + // abstract __iterator(type, reverse) + }); + + // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@'; + // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; + // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@'; + // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@'; + + var IterablePrototype = Iterable.prototype; + IterablePrototype[IS_ITERABLE_SENTINEL] = true; + IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values; + IterablePrototype.__toJS = IterablePrototype.toArray; + IterablePrototype.__toStringMapper = quoteString; + IterablePrototype.inspect = + IterablePrototype.toSource = function() { return this.toString(); }; + IterablePrototype.chain = IterablePrototype.flatMap; + IterablePrototype.contains = IterablePrototype.includes; + + // Temporary warning about using length + (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) {} + })(); + + + + mixin(KeyedIterable, { + + // ### More sequential methods + + flip: function() { + return reify(this, flipFactory(this)); + }, + + findKey: function(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry && entry[0]; + }, + + 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.findLastKey(function(value ) {return is(value, searchValue)}); + }, + + mapEntries: function(mapper, context) {var this$0 = this; + var iterations = 0; + return reify(this, + this.toSeq().map( + function(v, k) {return mapper.call(context, [k, v], iterations++, this$0)} + ).fromEntrySeq() + ); + }, + + mapKeys: function(mapper, context) {var this$0 = this; + return reify(this, + this.toSeq().flip().map( + function(k, v) {return mapper.call(context, k, v, this$0)} + ).flip() + ); + } + + }); + + var KeyedIterablePrototype = KeyedIterable.prototype; + KeyedIterablePrototype[IS_KEYED_SENTINEL] = true; + KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries; + KeyedIterablePrototype.__toJS = IterablePrototype.toObject; + KeyedIterablePrototype.__toStringMapper = function(v, k) {return JSON.stringify(k) + ': ' + quoteString(v)}; + + + + mixin(IndexedIterable, { + + // ### Conversion to other types + + toKeyedSeq: function() { + return new ToKeyedSequence(this, false); + }, + + + // ### ES6 Collection methods (ES6 Array and Map) + + filter: function(predicate, context) { + return reify(this, filterFactory(this, predicate, context, false)); + }, + + findIndex: function(predicate, context) { + var entry = this.findEntry(predicate, context); + return entry ? entry[0] : -1; + }, + + indexOf: function(searchValue) { + var key = this.toKeyedSeq().keyOf(searchValue); + return key === undefined ? -1 : key; + }, + + lastIndexOf: function(searchValue) { + return this.toSeq().reverse().indexOf(searchValue); + }, + + reverse: function() { + return reify(this, reverseFactory(this, false)); + }, + + slice: function(begin, end) { + return reify(this, sliceFactory(this, begin, end, false)); + }, + + splice: function(index, removeNum /*, ...values*/) { + var numArgs = arguments.length; + removeNum = Math.max(removeNum | 0, 0); + if (numArgs === 0 || (numArgs === 2 && !removeNum)) { + return this; + } + // If index is negative, it should resolve relative to the size of the + // collection. However size may be expensive to compute if not cached, so + // only call count() if the number is in fact negative. + index = resolveBegin(index, index < 0 ? this.count() : this.size); + var spliced = this.slice(0, index); + return reify( + this, + numArgs === 1 ? + spliced : + spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum)) + ); + }, + + + // ### More collection methods + + 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)); + }, + + interleave: function(/*...iterables*/) { + var iterables = [this].concat(arrCopy(arguments)); + var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables); + var interleaved = zipped.flatten(true); + if (zipped.size) { + interleaved.size = zipped.size * iterables.length; + } + return reify(this, interleaved); + }, + + last: function() { + return this.get(-1); + }, + + skipWhile: function(predicate, context) { + return reify(this, skipWhileFactory(this, predicate, context, false)); + }, + + zip: function(/*, ...iterables */) { + var iterables = [this].concat(arrCopy(arguments)); + return reify(this, zipWithFactory(this, defaultZipper, iterables)); + }, + + zipWith: function(zipper/*, ...iterables */) { + var iterables = arrCopy(arguments); + iterables[0] = this; + return reify(this, zipWithFactory(this, zipper, iterables)); + } + + }); + + IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true; + IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true; + + + + mixin(SetIterable, { + + // ### ES6 Collection methods (ES6 Array and Map) + + get: function(value, notSetValue) { + return this.has(value) ? value : notSetValue; + }, + + includes: function(value) { + return this.has(value); + }, + + + // ### More sequential methods + + keySeq: function() { + return this.valueSeq(); + } + + }); + + SetIterable.prototype.has = IterablePrototype.includes; + + + // Mixin subclasses + + mixin(KeyedSeq, KeyedIterable.prototype); + mixin(IndexedSeq, IndexedIterable.prototype); + mixin(SetSeq, SetIterable.prototype); + + mixin(KeyedCollection, KeyedIterable.prototype); + mixin(IndexedCollection, IndexedIterable.prototype); + mixin(SetCollection, SetIterable.prototype); + + + // #pragma Helper functions + + 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 defaultZipper() { + return arrCopy(arguments); + } + + function defaultNegComparator(a, b) { + return a < b ? 1 : a > b ? -1 : 0; + } + + function hashIterable(iterable) { + if (iterable.size === Infinity) { + return 0; + } + var ordered = isOrdered(iterable); + var keyed = isKeyed(iterable); + var h = ordered ? 1 : 0; + var size = iterable.__iterate( + keyed ? + ordered ? + function(v, k) { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } : + function(v, k) { h = h + hashMerge(hash(v), hash(k)) | 0; } : + ordered ? + function(v ) { h = 31 * h + hash(v) | 0; } : + function(v ) { h = h + hash(v) | 0; } + ); + return murmurHashOfSize(size, h); + } + + function murmurHashOfSize(size, h) { + h = src_Math__imul(h, 0xCC9E2D51); + h = src_Math__imul(h << 15 | h >>> -15, 0x1B873593); + h = src_Math__imul(h << 13 | h >>> -13, 5); + h = (h + 0xE6546B64 | 0) ^ size; + h = src_Math__imul(h ^ h >>> 16, 0x85EBCA6B); + h = src_Math__imul(h ^ h >>> 13, 0xC2B2AE35); + h = smi(h ^ h >>> 16); + return h; + } + + function hashMerge(a, b) { + return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int + } + + var Immutable = { + + Iterable: Iterable, + + Seq: Seq, + Collection: Collection, + Map: src_Map__Map, + OrderedMap: OrderedMap, + List: List, + Stack: Stack, + Set: src_Set__Set, + OrderedSet: OrderedSet, + + Record: Record, + Range: Range, + Repeat: Repeat, + + is: is, + fromJS: fromJS + + }; + + return Immutable; + +})); +},{}],4:[function(require,module,exports){ /** Used as the `TypeError` message for "Functions" methods. */ var FUNC_ERROR_TEXT = 'Expected a function'; @@ -150,7 +7576,7 @@ function restParam(func, start) { module.exports = restParam; -},{}],3:[function(require,module,exports){ +},{}],5:[function(require,module,exports){ (function (global){ var cachePush = require('./cachePush'), getNative = require('./getNative'); @@ -183,7 +7609,7 @@ SetCache.prototype.push = cachePush; module.exports = SetCache; }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"./cachePush":15,"./getNative":21}],4:[function(require,module,exports){ +},{"./cachePush":17,"./getNative":23}],6:[function(require,module,exports){ /** * A specialized version of `_.map` for arrays without support for callback * shorthands and `this` binding. @@ -206,7 +7632,7 @@ function arrayMap(array, iteratee) { module.exports = arrayMap; -},{}],5:[function(require,module,exports){ +},{}],7:[function(require,module,exports){ /** * Appends the elements of `values` to `array`. * @@ -228,7 +7654,7 @@ function arrayPush(array, values) { module.exports = arrayPush; -},{}],6:[function(require,module,exports){ +},{}],8:[function(require,module,exports){ var baseIndexOf = require('./baseIndexOf'), cacheIndexOf = require('./cacheIndexOf'), createCache = require('./createCache'); @@ -285,7 +7711,7 @@ function baseDifference(array, values) { module.exports = baseDifference; -},{"./baseIndexOf":10,"./cacheIndexOf":14,"./createCache":17}],7:[function(require,module,exports){ +},{"./baseIndexOf":12,"./cacheIndexOf":16,"./createCache":19}],9:[function(require,module,exports){ var arrayPush = require('./arrayPush'), isArguments = require('../lang/isArguments'), isArray = require('../lang/isArray'), @@ -328,7 +7754,7 @@ function baseFlatten(array, isDeep, isStrict, result) { module.exports = baseFlatten; -},{"../lang/isArguments":31,"../lang/isArray":32,"./arrayPush":5,"./isArrayLike":23,"./isObjectLike":27}],8:[function(require,module,exports){ +},{"../lang/isArguments":33,"../lang/isArray":34,"./arrayPush":7,"./isArrayLike":25,"./isObjectLike":29}],10:[function(require,module,exports){ var createBaseFor = require('./createBaseFor'); /** @@ -347,7 +7773,7 @@ var baseFor = createBaseFor(); module.exports = baseFor; -},{"./createBaseFor":16}],9:[function(require,module,exports){ +},{"./createBaseFor":18}],11:[function(require,module,exports){ var baseFor = require('./baseFor'), keysIn = require('../object/keysIn'); @@ -366,7 +7792,7 @@ function baseForIn(object, iteratee) { module.exports = baseForIn; -},{"../object/keysIn":36,"./baseFor":8}],10:[function(require,module,exports){ +},{"../object/keysIn":38,"./baseFor":10}],12:[function(require,module,exports){ var indexOfNaN = require('./indexOfNaN'); /** @@ -395,7 +7821,7 @@ function baseIndexOf(array, value, fromIndex) { module.exports = baseIndexOf; -},{"./indexOfNaN":22}],11:[function(require,module,exports){ +},{"./indexOfNaN":24}],13:[function(require,module,exports){ /** * The base implementation of `_.property` without support for deep paths. * @@ -411,7 +7837,7 @@ function baseProperty(key) { module.exports = baseProperty; -},{}],12:[function(require,module,exports){ +},{}],14:[function(require,module,exports){ /** * Converts `value` to a string if it's not one. An empty string is returned * for `null` or `undefined` values. @@ -426,7 +7852,7 @@ function baseToString(value) { module.exports = baseToString; -},{}],13:[function(require,module,exports){ +},{}],15:[function(require,module,exports){ var identity = require('../utility/identity'); /** @@ -467,7 +7893,7 @@ function bindCallback(func, thisArg, argCount) { module.exports = bindCallback; -},{"../utility/identity":41}],14:[function(require,module,exports){ +},{"../utility/identity":43}],16:[function(require,module,exports){ var isObject = require('../lang/isObject'); /** @@ -488,7 +7914,7 @@ function cacheIndexOf(cache, value) { module.exports = cacheIndexOf; -},{"../lang/isObject":35}],15:[function(require,module,exports){ +},{"../lang/isObject":37}],17:[function(require,module,exports){ var isObject = require('../lang/isObject'); /** @@ -510,7 +7936,7 @@ function cachePush(value) { module.exports = cachePush; -},{"../lang/isObject":35}],16:[function(require,module,exports){ +},{"../lang/isObject":37}],18:[function(require,module,exports){ var toObject = require('./toObject'); /** @@ -539,7 +7965,7 @@ function createBaseFor(fromRight) { module.exports = createBaseFor; -},{"./toObject":30}],17:[function(require,module,exports){ +},{"./toObject":32}],19:[function(require,module,exports){ (function (global){ var SetCache = require('./SetCache'), getNative = require('./getNative'); @@ -564,7 +7990,7 @@ function createCache(values) { module.exports = createCache; }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"./SetCache":3,"./getNative":21}],18:[function(require,module,exports){ +},{"./SetCache":5,"./getNative":23}],20:[function(require,module,exports){ var deburr = require('../string/deburr'), words = require('../string/words'); @@ -592,7 +8018,7 @@ function createCompounder(callback) { module.exports = createCompounder; -},{"../string/deburr":39,"../string/words":40}],19:[function(require,module,exports){ +},{"../string/deburr":41,"../string/words":42}],21:[function(require,module,exports){ /** Used to map latin-1 supplementary letters to basic latin letters. */ var deburredLetters = { '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', @@ -627,7 +8053,7 @@ function deburrLetter(letter) { module.exports = deburrLetter; -},{}],20:[function(require,module,exports){ +},{}],22:[function(require,module,exports){ var baseProperty = require('./baseProperty'); /** @@ -644,7 +8070,7 @@ var getLength = baseProperty('length'); module.exports = getLength; -},{"./baseProperty":11}],21:[function(require,module,exports){ +},{"./baseProperty":13}],23:[function(require,module,exports){ var isNative = require('../lang/isNative'); /** @@ -662,7 +8088,7 @@ function getNative(object, key) { module.exports = getNative; -},{"../lang/isNative":34}],22:[function(require,module,exports){ +},{"../lang/isNative":36}],24:[function(require,module,exports){ /** * Gets the index at which the first occurrence of `NaN` is found in `array`. * @@ -687,7 +8113,7 @@ function indexOfNaN(array, fromIndex, fromRight) { module.exports = indexOfNaN; -},{}],23:[function(require,module,exports){ +},{}],25:[function(require,module,exports){ var getLength = require('./getLength'), isLength = require('./isLength'); @@ -704,7 +8130,7 @@ function isArrayLike(value) { module.exports = isArrayLike; -},{"./getLength":20,"./isLength":26}],24:[function(require,module,exports){ +},{"./getLength":22,"./isLength":28}],26:[function(require,module,exports){ /** Used to detect unsigned integer values. */ var reIsUint = /^\d+$/; @@ -730,7 +8156,7 @@ function isIndex(value, length) { module.exports = isIndex; -},{}],25:[function(require,module,exports){ +},{}],27:[function(require,module,exports){ var isArrayLike = require('./isArrayLike'), isIndex = require('./isIndex'), isObject = require('../lang/isObject'); @@ -760,7 +8186,7 @@ function isIterateeCall(value, index, object) { module.exports = isIterateeCall; -},{"../lang/isObject":35,"./isArrayLike":23,"./isIndex":24}],26:[function(require,module,exports){ +},{"../lang/isObject":37,"./isArrayLike":25,"./isIndex":26}],28:[function(require,module,exports){ /** * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) * of an array-like value. @@ -782,7 +8208,7 @@ function isLength(value) { module.exports = isLength; -},{}],27:[function(require,module,exports){ +},{}],29:[function(require,module,exports){ /** * Checks if `value` is object-like. * @@ -796,7 +8222,7 @@ function isObjectLike(value) { module.exports = isObjectLike; -},{}],28:[function(require,module,exports){ +},{}],30:[function(require,module,exports){ var toObject = require('./toObject'); /** @@ -826,7 +8252,7 @@ function pickByArray(object, props) { module.exports = pickByArray; -},{"./toObject":30}],29:[function(require,module,exports){ +},{"./toObject":32}],31:[function(require,module,exports){ var baseForIn = require('./baseForIn'); /** @@ -850,7 +8276,7 @@ function pickByCallback(object, predicate) { module.exports = pickByCallback; -},{"./baseForIn":9}],30:[function(require,module,exports){ +},{"./baseForIn":11}],32:[function(require,module,exports){ var isObject = require('../lang/isObject'); /** @@ -866,7 +8292,7 @@ function toObject(value) { module.exports = toObject; -},{"../lang/isObject":35}],31:[function(require,module,exports){ +},{"../lang/isObject":37}],33:[function(require,module,exports){ var isArrayLike = require('../internal/isArrayLike'), isObjectLike = require('../internal/isObjectLike'); @@ -902,7 +8328,7 @@ function isArguments(value) { module.exports = isArguments; -},{"../internal/isArrayLike":23,"../internal/isObjectLike":27}],32:[function(require,module,exports){ +},{"../internal/isArrayLike":25,"../internal/isObjectLike":29}],34:[function(require,module,exports){ var getNative = require('../internal/getNative'), isLength = require('../internal/isLength'), isObjectLike = require('../internal/isObjectLike'); @@ -944,7 +8370,7 @@ var isArray = nativeIsArray || function(value) { module.exports = isArray; -},{"../internal/getNative":21,"../internal/isLength":26,"../internal/isObjectLike":27}],33:[function(require,module,exports){ +},{"../internal/getNative":23,"../internal/isLength":28,"../internal/isObjectLike":29}],35:[function(require,module,exports){ var isObject = require('./isObject'); /** `Object#toString` result references. */ @@ -984,7 +8410,7 @@ function isFunction(value) { module.exports = isFunction; -},{"./isObject":35}],34:[function(require,module,exports){ +},{"./isObject":37}],36:[function(require,module,exports){ var isFunction = require('./isFunction'), isObjectLike = require('../internal/isObjectLike'); @@ -1034,7 +8460,7 @@ function isNative(value) { module.exports = isNative; -},{"../internal/isObjectLike":27,"./isFunction":33}],35:[function(require,module,exports){ +},{"../internal/isObjectLike":29,"./isFunction":35}],37:[function(require,module,exports){ /** * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) @@ -1064,7 +8490,7 @@ function isObject(value) { module.exports = isObject; -},{}],36:[function(require,module,exports){ +},{}],38:[function(require,module,exports){ var isArguments = require('../lang/isArguments'), isArray = require('../lang/isArray'), isIndex = require('../internal/isIndex'), @@ -1130,7 +8556,7 @@ function keysIn(object) { module.exports = keysIn; -},{"../internal/isIndex":24,"../internal/isLength":26,"../lang/isArguments":31,"../lang/isArray":32,"../lang/isObject":35}],37:[function(require,module,exports){ +},{"../internal/isIndex":26,"../internal/isLength":28,"../lang/isArguments":33,"../lang/isArray":34,"../lang/isObject":37}],39:[function(require,module,exports){ var arrayMap = require('../internal/arrayMap'), baseDifference = require('../internal/baseDifference'), baseFlatten = require('../internal/baseFlatten'), @@ -1179,7 +8605,7 @@ var omit = restParam(function(object, props) { module.exports = omit; -},{"../function/restParam":2,"../internal/arrayMap":4,"../internal/baseDifference":6,"../internal/baseFlatten":7,"../internal/bindCallback":13,"../internal/pickByArray":28,"../internal/pickByCallback":29,"./keysIn":36}],38:[function(require,module,exports){ +},{"../function/restParam":4,"../internal/arrayMap":6,"../internal/baseDifference":8,"../internal/baseFlatten":9,"../internal/bindCallback":15,"../internal/pickByArray":30,"../internal/pickByCallback":31,"./keysIn":38}],40:[function(require,module,exports){ var createCompounder = require('../internal/createCompounder'); /** @@ -1208,7 +8634,7 @@ var camelCase = createCompounder(function(result, word, index) { module.exports = camelCase; -},{"../internal/createCompounder":18}],39:[function(require,module,exports){ +},{"../internal/createCompounder":20}],41:[function(require,module,exports){ var baseToString = require('../internal/baseToString'), deburrLetter = require('../internal/deburrLetter'); @@ -1239,7 +8665,7 @@ function deburr(string) { module.exports = deburr; -},{"../internal/baseToString":12,"../internal/deburrLetter":19}],40:[function(require,module,exports){ +},{"../internal/baseToString":14,"../internal/deburrLetter":21}],42:[function(require,module,exports){ var baseToString = require('../internal/baseToString'), isIterateeCall = require('../internal/isIterateeCall'); @@ -1279,7 +8705,7 @@ function words(string, pattern, guard) { module.exports = words; -},{"../internal/baseToString":12,"../internal/isIterateeCall":25}],41:[function(require,module,exports){ +},{"../internal/baseToString":14,"../internal/isIterateeCall":27}],43:[function(require,module,exports){ /** * This method returns the first argument provided to it. * @@ -1301,7 +8727,7 @@ function identity(value) { module.exports = identity; -},{}],42:[function(require,module,exports){ +},{}],44:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -1325,7 +8751,7 @@ function createAll(React) { } module.exports = exports['default']; -},{"./createConnect":43,"./createProvider":44}],43:[function(require,module,exports){ +},{"./createConnect":45,"./createProvider":46}],45:[function(require,module,exports){ (function (process){ 'use strict'; @@ -1594,7 +9020,7 @@ function createConnect(React) { module.exports = exports['default']; }).call(this,require('_process')) -},{"../utils/createStoreShape":46,"../utils/isPlainObject":47,"../utils/shallowEqual":48,"../utils/wrapActionCreators":49,"_process":1,"invariant":50}],44:[function(require,module,exports){ +},{"../utils/createStoreShape":48,"../utils/isPlainObject":49,"../utils/shallowEqual":50,"../utils/wrapActionCreators":51,"_process":1,"invariant":52}],46:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -1712,7 +9138,7 @@ function createProvider(React) { } module.exports = exports['default']; -},{"../utils/createStoreShape":46}],45:[function(require,module,exports){ +},{"../utils/createStoreShape":48}],47:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -1733,7 +9159,7 @@ var Provider = _createAll.Provider; var connect = _createAll.connect; exports.Provider = Provider; exports.connect = connect; -},{"./components/createAll":42,"react":205}],46:[function(require,module,exports){ +},{"./components/createAll":44,"react":207}],48:[function(require,module,exports){ "use strict"; exports.__esModule = true; @@ -1748,7 +9174,7 @@ function createStoreShape(PropTypes) { } module.exports = exports["default"]; -},{}],47:[function(require,module,exports){ +},{}],49:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -1779,7 +9205,7 @@ function isPlainObject(obj) { } module.exports = exports['default']; -},{}],48:[function(require,module,exports){ +},{}],50:[function(require,module,exports){ "use strict"; exports.__esModule = true; @@ -1809,7 +9235,7 @@ function shallowEqual(objA, objB) { } module.exports = exports["default"]; -},{}],49:[function(require,module,exports){ +},{}],51:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -1824,7 +9250,7 @@ function wrapActionCreators(actionCreators) { } module.exports = exports['default']; -},{"redux":207}],50:[function(require,module,exports){ +},{"redux":209}],52:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -1881,7 +9307,7 @@ var invariant = function(condition, format, a, b, c, d, e, f) { module.exports = invariant; }).call(this,require('_process')) -},{"_process":1}],51:[function(require,module,exports){ +},{"_process":1}],53:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -1908,7 +9334,7 @@ var AutoFocusMixin = { module.exports = AutoFocusMixin; -},{"./focusNode":169}],52:[function(require,module,exports){ +},{"./focusNode":171}],54:[function(require,module,exports){ /** * Copyright 2013-2015 Facebook, Inc. * All rights reserved. @@ -2403,7 +9829,7 @@ var BeforeInputEventPlugin = { module.exports = BeforeInputEventPlugin; -},{"./EventConstants":64,"./EventPropagators":69,"./ExecutionEnvironment":70,"./FallbackCompositionState":71,"./SyntheticCompositionEvent":143,"./SyntheticInputEvent":147,"./keyOf":191}],53:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPropagators":71,"./ExecutionEnvironment":72,"./FallbackCompositionState":73,"./SyntheticCompositionEvent":145,"./SyntheticInputEvent":149,"./keyOf":193}],55:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -2528,7 +9954,7 @@ var CSSProperty = { module.exports = CSSProperty; -},{}],54:[function(require,module,exports){ +},{}],56:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -2710,7 +10136,7 @@ var CSSPropertyOperations = { module.exports = CSSPropertyOperations; }).call(this,require('_process')) -},{"./CSSProperty":53,"./ExecutionEnvironment":70,"./camelizeStyleName":158,"./dangerousStyleValue":163,"./hyphenateStyleName":183,"./memoizeStringOnly":193,"./warning":204,"_process":1}],55:[function(require,module,exports){ +},{"./CSSProperty":55,"./ExecutionEnvironment":72,"./camelizeStyleName":160,"./dangerousStyleValue":165,"./hyphenateStyleName":185,"./memoizeStringOnly":195,"./warning":206,"_process":1}],57:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -2810,7 +10236,7 @@ PooledClass.addPoolingTo(CallbackQueue); module.exports = CallbackQueue; }).call(this,require('_process')) -},{"./Object.assign":76,"./PooledClass":77,"./invariant":185,"_process":1}],56:[function(require,module,exports){ +},{"./Object.assign":78,"./PooledClass":79,"./invariant":187,"_process":1}],58:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -3192,7 +10618,7 @@ var ChangeEventPlugin = { module.exports = ChangeEventPlugin; -},{"./EventConstants":64,"./EventPluginHub":66,"./EventPropagators":69,"./ExecutionEnvironment":70,"./ReactUpdates":137,"./SyntheticEvent":145,"./isEventSupported":186,"./isTextInputElement":188,"./keyOf":191}],57:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPluginHub":68,"./EventPropagators":71,"./ExecutionEnvironment":72,"./ReactUpdates":139,"./SyntheticEvent":147,"./isEventSupported":188,"./isTextInputElement":190,"./keyOf":193}],59:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -3217,7 +10643,7 @@ var ClientReactRootIndex = { module.exports = ClientReactRootIndex; -},{}],58:[function(require,module,exports){ +},{}],60:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -3355,7 +10781,7 @@ var DOMChildrenOperations = { module.exports = DOMChildrenOperations; }).call(this,require('_process')) -},{"./Danger":61,"./ReactMultiChildUpdateTypes":122,"./invariant":185,"./setTextContent":199,"_process":1}],59:[function(require,module,exports){ +},{"./Danger":63,"./ReactMultiChildUpdateTypes":124,"./invariant":187,"./setTextContent":201,"_process":1}],61:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -3654,7 +11080,7 @@ var DOMProperty = { module.exports = DOMProperty; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],60:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],62:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -3846,7 +11272,7 @@ var DOMPropertyOperations = { module.exports = DOMPropertyOperations; }).call(this,require('_process')) -},{"./DOMProperty":59,"./quoteAttributeValueForBrowser":197,"./warning":204,"_process":1}],61:[function(require,module,exports){ +},{"./DOMProperty":61,"./quoteAttributeValueForBrowser":199,"./warning":206,"_process":1}],63:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -4033,7 +11459,7 @@ var Danger = { module.exports = Danger; }).call(this,require('_process')) -},{"./ExecutionEnvironment":70,"./createNodesFromMarkup":162,"./emptyFunction":164,"./getMarkupWrap":177,"./invariant":185,"_process":1}],62:[function(require,module,exports){ +},{"./ExecutionEnvironment":72,"./createNodesFromMarkup":164,"./emptyFunction":166,"./getMarkupWrap":179,"./invariant":187,"_process":1}],64:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -4072,7 +11498,7 @@ var DefaultEventPluginOrder = [ module.exports = DefaultEventPluginOrder; -},{"./keyOf":191}],63:[function(require,module,exports){ +},{"./keyOf":193}],65:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -4212,7 +11638,7 @@ var EnterLeaveEventPlugin = { module.exports = EnterLeaveEventPlugin; -},{"./EventConstants":64,"./EventPropagators":69,"./ReactMount":120,"./SyntheticMouseEvent":149,"./keyOf":191}],64:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPropagators":71,"./ReactMount":122,"./SyntheticMouseEvent":151,"./keyOf":193}],66:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -4284,7 +11710,7 @@ var EventConstants = { module.exports = EventConstants; -},{"./keyMirror":190}],65:[function(require,module,exports){ +},{"./keyMirror":192}],67:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -4374,7 +11800,7 @@ var EventListener = { module.exports = EventListener; }).call(this,require('_process')) -},{"./emptyFunction":164,"_process":1}],66:[function(require,module,exports){ +},{"./emptyFunction":166,"_process":1}],68:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -4652,7 +12078,7 @@ var EventPluginHub = { module.exports = EventPluginHub; }).call(this,require('_process')) -},{"./EventPluginRegistry":67,"./EventPluginUtils":68,"./accumulateInto":155,"./forEachAccumulated":170,"./invariant":185,"_process":1}],67:[function(require,module,exports){ +},{"./EventPluginRegistry":69,"./EventPluginUtils":70,"./accumulateInto":157,"./forEachAccumulated":172,"./invariant":187,"_process":1}],69:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -4932,7 +12358,7 @@ var EventPluginRegistry = { module.exports = EventPluginRegistry; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],68:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],70:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -5153,7 +12579,7 @@ var EventPluginUtils = { module.exports = EventPluginUtils; }).call(this,require('_process')) -},{"./EventConstants":64,"./invariant":185,"_process":1}],69:[function(require,module,exports){ +},{"./EventConstants":66,"./invariant":187,"_process":1}],71:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -5295,7 +12721,7 @@ var EventPropagators = { module.exports = EventPropagators; }).call(this,require('_process')) -},{"./EventConstants":64,"./EventPluginHub":66,"./accumulateInto":155,"./forEachAccumulated":170,"_process":1}],70:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPluginHub":68,"./accumulateInto":157,"./forEachAccumulated":172,"_process":1}],72:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -5339,7 +12765,7 @@ var ExecutionEnvironment = { module.exports = ExecutionEnvironment; -},{}],71:[function(require,module,exports){ +},{}],73:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -5430,7 +12856,7 @@ PooledClass.addPoolingTo(FallbackCompositionState); module.exports = FallbackCompositionState; -},{"./Object.assign":76,"./PooledClass":77,"./getTextContentAccessor":180}],72:[function(require,module,exports){ +},{"./Object.assign":78,"./PooledClass":79,"./getTextContentAccessor":182}],74:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -5641,7 +13067,7 @@ var HTMLDOMPropertyConfig = { module.exports = HTMLDOMPropertyConfig; -},{"./DOMProperty":59,"./ExecutionEnvironment":70}],73:[function(require,module,exports){ +},{"./DOMProperty":61,"./ExecutionEnvironment":72}],75:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -5797,7 +13223,7 @@ var LinkedValueUtils = { module.exports = LinkedValueUtils; }).call(this,require('_process')) -},{"./ReactPropTypes":128,"./invariant":185,"_process":1}],74:[function(require,module,exports){ +},{"./ReactPropTypes":130,"./invariant":187,"_process":1}],76:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -5854,7 +13280,7 @@ var LocalEventTrapMixin = { module.exports = LocalEventTrapMixin; }).call(this,require('_process')) -},{"./ReactBrowserEventEmitter":80,"./accumulateInto":155,"./forEachAccumulated":170,"./invariant":185,"_process":1}],75:[function(require,module,exports){ +},{"./ReactBrowserEventEmitter":82,"./accumulateInto":157,"./forEachAccumulated":172,"./invariant":187,"_process":1}],77:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -5912,7 +13338,7 @@ var MobileSafariClickEventPlugin = { module.exports = MobileSafariClickEventPlugin; -},{"./EventConstants":64,"./emptyFunction":164}],76:[function(require,module,exports){ +},{"./EventConstants":66,"./emptyFunction":166}],78:[function(require,module,exports){ /** * Copyright 2014-2015, Facebook, Inc. * All rights reserved. @@ -5961,7 +13387,7 @@ function assign(target, sources) { module.exports = assign; -},{}],77:[function(require,module,exports){ +},{}],79:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -6077,7 +13503,7 @@ var PooledClass = { module.exports = PooledClass; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],78:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],80:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -6229,7 +13655,7 @@ React.version = '0.13.3'; module.exports = React; }).call(this,require('_process')) -},{"./EventPluginUtils":68,"./ExecutionEnvironment":70,"./Object.assign":76,"./ReactChildren":82,"./ReactClass":83,"./ReactComponent":84,"./ReactContext":88,"./ReactCurrentOwner":89,"./ReactDOM":90,"./ReactDOMTextComponent":101,"./ReactDefaultInjection":104,"./ReactElement":107,"./ReactElementValidator":108,"./ReactInstanceHandles":116,"./ReactMount":120,"./ReactPerf":125,"./ReactPropTypes":128,"./ReactReconciler":131,"./ReactServerRendering":134,"./findDOMNode":167,"./onlyChild":194,"_process":1}],79:[function(require,module,exports){ +},{"./EventPluginUtils":70,"./ExecutionEnvironment":72,"./Object.assign":78,"./ReactChildren":84,"./ReactClass":85,"./ReactComponent":86,"./ReactContext":90,"./ReactCurrentOwner":91,"./ReactDOM":92,"./ReactDOMTextComponent":103,"./ReactDefaultInjection":106,"./ReactElement":109,"./ReactElementValidator":110,"./ReactInstanceHandles":118,"./ReactMount":122,"./ReactPerf":127,"./ReactPropTypes":130,"./ReactReconciler":133,"./ReactServerRendering":136,"./findDOMNode":169,"./onlyChild":196,"_process":1}],81:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -6260,7 +13686,7 @@ var ReactBrowserComponentMixin = { module.exports = ReactBrowserComponentMixin; -},{"./findDOMNode":167}],80:[function(require,module,exports){ +},{"./findDOMNode":169}],82:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -6613,7 +14039,7 @@ var ReactBrowserEventEmitter = assign({}, ReactEventEmitterMixin, { module.exports = ReactBrowserEventEmitter; -},{"./EventConstants":64,"./EventPluginHub":66,"./EventPluginRegistry":67,"./Object.assign":76,"./ReactEventEmitterMixin":111,"./ViewportMetrics":154,"./isEventSupported":186}],81:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPluginHub":68,"./EventPluginRegistry":69,"./Object.assign":78,"./ReactEventEmitterMixin":113,"./ViewportMetrics":156,"./isEventSupported":188}],83:[function(require,module,exports){ /** * Copyright 2014-2015, Facebook, Inc. * All rights reserved. @@ -6740,7 +14166,7 @@ var ReactChildReconciler = { module.exports = ReactChildReconciler; -},{"./ReactReconciler":131,"./flattenChildren":168,"./instantiateReactComponent":184,"./shouldUpdateReactComponent":201}],82:[function(require,module,exports){ +},{"./ReactReconciler":133,"./flattenChildren":170,"./instantiateReactComponent":186,"./shouldUpdateReactComponent":203}],84:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -6893,7 +14319,7 @@ var ReactChildren = { module.exports = ReactChildren; }).call(this,require('_process')) -},{"./PooledClass":77,"./ReactFragment":113,"./traverseAllChildren":203,"./warning":204,"_process":1}],83:[function(require,module,exports){ +},{"./PooledClass":79,"./ReactFragment":115,"./traverseAllChildren":205,"./warning":206,"_process":1}],85:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -7839,7 +15265,7 @@ var ReactClass = { module.exports = ReactClass; }).call(this,require('_process')) -},{"./Object.assign":76,"./ReactComponent":84,"./ReactCurrentOwner":89,"./ReactElement":107,"./ReactErrorUtils":110,"./ReactInstanceMap":117,"./ReactLifeCycle":118,"./ReactPropTypeLocationNames":126,"./ReactPropTypeLocations":127,"./ReactUpdateQueue":136,"./invariant":185,"./keyMirror":190,"./keyOf":191,"./warning":204,"_process":1}],84:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactComponent":86,"./ReactCurrentOwner":91,"./ReactElement":109,"./ReactErrorUtils":112,"./ReactInstanceMap":119,"./ReactLifeCycle":120,"./ReactPropTypeLocationNames":128,"./ReactPropTypeLocations":129,"./ReactUpdateQueue":138,"./invariant":187,"./keyMirror":192,"./keyOf":193,"./warning":206,"_process":1}],86:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -7993,7 +15419,7 @@ if ("production" !== process.env.NODE_ENV) { module.exports = ReactComponent; }).call(this,require('_process')) -},{"./ReactUpdateQueue":136,"./invariant":185,"./warning":204,"_process":1}],85:[function(require,module,exports){ +},{"./ReactUpdateQueue":138,"./invariant":187,"./warning":206,"_process":1}],87:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -8040,7 +15466,7 @@ var ReactComponentBrowserEnvironment = { module.exports = ReactComponentBrowserEnvironment; -},{"./ReactDOMIDOperations":94,"./ReactMount":120}],86:[function(require,module,exports){ +},{"./ReactDOMIDOperations":96,"./ReactMount":122}],88:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -8101,7 +15527,7 @@ var ReactComponentEnvironment = { module.exports = ReactComponentEnvironment; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],87:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],89:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -9014,7 +16440,7 @@ var ReactCompositeComponent = { module.exports = ReactCompositeComponent; }).call(this,require('_process')) -},{"./Object.assign":76,"./ReactComponentEnvironment":86,"./ReactContext":88,"./ReactCurrentOwner":89,"./ReactElement":107,"./ReactElementValidator":108,"./ReactInstanceMap":117,"./ReactLifeCycle":118,"./ReactNativeComponent":123,"./ReactPerf":125,"./ReactPropTypeLocationNames":126,"./ReactPropTypeLocations":127,"./ReactReconciler":131,"./ReactUpdates":137,"./emptyObject":165,"./invariant":185,"./shouldUpdateReactComponent":201,"./warning":204,"_process":1}],88:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactComponentEnvironment":88,"./ReactContext":90,"./ReactCurrentOwner":91,"./ReactElement":109,"./ReactElementValidator":110,"./ReactInstanceMap":119,"./ReactLifeCycle":120,"./ReactNativeComponent":125,"./ReactPerf":127,"./ReactPropTypeLocationNames":128,"./ReactPropTypeLocations":129,"./ReactReconciler":133,"./ReactUpdates":139,"./emptyObject":167,"./invariant":187,"./shouldUpdateReactComponent":203,"./warning":206,"_process":1}],90:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -9092,7 +16518,7 @@ var ReactContext = { module.exports = ReactContext; }).call(this,require('_process')) -},{"./Object.assign":76,"./emptyObject":165,"./warning":204,"_process":1}],89:[function(require,module,exports){ +},{"./Object.assign":78,"./emptyObject":167,"./warning":206,"_process":1}],91:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -9126,7 +16552,7 @@ var ReactCurrentOwner = { module.exports = ReactCurrentOwner; -},{}],90:[function(require,module,exports){ +},{}],92:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -9305,7 +16731,7 @@ var ReactDOM = mapObject({ module.exports = ReactDOM; }).call(this,require('_process')) -},{"./ReactElement":107,"./ReactElementValidator":108,"./mapObject":192,"_process":1}],91:[function(require,module,exports){ +},{"./ReactElement":109,"./ReactElementValidator":110,"./mapObject":194,"_process":1}],93:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -9369,7 +16795,7 @@ var ReactDOMButton = ReactClass.createClass({ module.exports = ReactDOMButton; -},{"./AutoFocusMixin":51,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107,"./keyMirror":190}],92:[function(require,module,exports){ +},{"./AutoFocusMixin":53,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109,"./keyMirror":192}],94:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -9879,7 +17305,7 @@ ReactDOMComponent.injection = { module.exports = ReactDOMComponent; }).call(this,require('_process')) -},{"./CSSPropertyOperations":54,"./DOMProperty":59,"./DOMPropertyOperations":60,"./Object.assign":76,"./ReactBrowserEventEmitter":80,"./ReactComponentBrowserEnvironment":85,"./ReactMount":120,"./ReactMultiChild":121,"./ReactPerf":125,"./escapeTextContentForBrowser":166,"./invariant":185,"./isEventSupported":186,"./keyOf":191,"./warning":204,"_process":1}],93:[function(require,module,exports){ +},{"./CSSPropertyOperations":56,"./DOMProperty":61,"./DOMPropertyOperations":62,"./Object.assign":78,"./ReactBrowserEventEmitter":82,"./ReactComponentBrowserEnvironment":87,"./ReactMount":122,"./ReactMultiChild":123,"./ReactPerf":127,"./escapeTextContentForBrowser":168,"./invariant":187,"./isEventSupported":188,"./keyOf":193,"./warning":206,"_process":1}],95:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -9928,7 +17354,7 @@ var ReactDOMForm = ReactClass.createClass({ module.exports = ReactDOMForm; -},{"./EventConstants":64,"./LocalEventTrapMixin":74,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107}],94:[function(require,module,exports){ +},{"./EventConstants":66,"./LocalEventTrapMixin":76,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109}],96:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -10096,7 +17522,7 @@ ReactPerf.measureMethods(ReactDOMIDOperations, 'ReactDOMIDOperations', { module.exports = ReactDOMIDOperations; }).call(this,require('_process')) -},{"./CSSPropertyOperations":54,"./DOMChildrenOperations":58,"./DOMPropertyOperations":60,"./ReactMount":120,"./ReactPerf":125,"./invariant":185,"./setInnerHTML":198,"_process":1}],95:[function(require,module,exports){ +},{"./CSSPropertyOperations":56,"./DOMChildrenOperations":60,"./DOMPropertyOperations":62,"./ReactMount":122,"./ReactPerf":127,"./invariant":187,"./setInnerHTML":200,"_process":1}],97:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -10141,7 +17567,7 @@ var ReactDOMIframe = ReactClass.createClass({ module.exports = ReactDOMIframe; -},{"./EventConstants":64,"./LocalEventTrapMixin":74,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107}],96:[function(require,module,exports){ +},{"./EventConstants":66,"./LocalEventTrapMixin":76,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109}],98:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -10187,7 +17613,7 @@ var ReactDOMImg = ReactClass.createClass({ module.exports = ReactDOMImg; -},{"./EventConstants":64,"./LocalEventTrapMixin":74,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107}],97:[function(require,module,exports){ +},{"./EventConstants":66,"./LocalEventTrapMixin":76,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109}],99:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -10364,7 +17790,7 @@ var ReactDOMInput = ReactClass.createClass({ module.exports = ReactDOMInput; }).call(this,require('_process')) -},{"./AutoFocusMixin":51,"./DOMPropertyOperations":60,"./LinkedValueUtils":73,"./Object.assign":76,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107,"./ReactMount":120,"./ReactUpdates":137,"./invariant":185,"_process":1}],98:[function(require,module,exports){ +},{"./AutoFocusMixin":53,"./DOMPropertyOperations":62,"./LinkedValueUtils":75,"./Object.assign":78,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109,"./ReactMount":122,"./ReactUpdates":139,"./invariant":187,"_process":1}],100:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -10416,7 +17842,7 @@ var ReactDOMOption = ReactClass.createClass({ module.exports = ReactDOMOption; }).call(this,require('_process')) -},{"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107,"./warning":204,"_process":1}],99:[function(require,module,exports){ +},{"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109,"./warning":206,"_process":1}],101:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -10594,7 +18020,7 @@ var ReactDOMSelect = ReactClass.createClass({ module.exports = ReactDOMSelect; -},{"./AutoFocusMixin":51,"./LinkedValueUtils":73,"./Object.assign":76,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107,"./ReactUpdates":137}],100:[function(require,module,exports){ +},{"./AutoFocusMixin":53,"./LinkedValueUtils":75,"./Object.assign":78,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109,"./ReactUpdates":139}],102:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -10807,7 +18233,7 @@ var ReactDOMSelection = { module.exports = ReactDOMSelection; -},{"./ExecutionEnvironment":70,"./getNodeForCharacterOffset":178,"./getTextContentAccessor":180}],101:[function(require,module,exports){ +},{"./ExecutionEnvironment":72,"./getNodeForCharacterOffset":180,"./getTextContentAccessor":182}],103:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -10924,7 +18350,7 @@ assign(ReactDOMTextComponent.prototype, { module.exports = ReactDOMTextComponent; -},{"./DOMPropertyOperations":60,"./Object.assign":76,"./ReactComponentBrowserEnvironment":85,"./ReactDOMComponent":92,"./escapeTextContentForBrowser":166}],102:[function(require,module,exports){ +},{"./DOMPropertyOperations":62,"./Object.assign":78,"./ReactComponentBrowserEnvironment":87,"./ReactDOMComponent":94,"./escapeTextContentForBrowser":168}],104:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -11064,7 +18490,7 @@ var ReactDOMTextarea = ReactClass.createClass({ module.exports = ReactDOMTextarea; }).call(this,require('_process')) -},{"./AutoFocusMixin":51,"./DOMPropertyOperations":60,"./LinkedValueUtils":73,"./Object.assign":76,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactElement":107,"./ReactUpdates":137,"./invariant":185,"./warning":204,"_process":1}],103:[function(require,module,exports){ +},{"./AutoFocusMixin":53,"./DOMPropertyOperations":62,"./LinkedValueUtils":75,"./Object.assign":78,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactElement":109,"./ReactUpdates":139,"./invariant":187,"./warning":206,"_process":1}],105:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -11137,7 +18563,7 @@ var ReactDefaultBatchingStrategy = { module.exports = ReactDefaultBatchingStrategy; -},{"./Object.assign":76,"./ReactUpdates":137,"./Transaction":153,"./emptyFunction":164}],104:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactUpdates":139,"./Transaction":155,"./emptyFunction":166}],106:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -11296,7 +18722,7 @@ module.exports = { }; }).call(this,require('_process')) -},{"./BeforeInputEventPlugin":52,"./ChangeEventPlugin":56,"./ClientReactRootIndex":57,"./DefaultEventPluginOrder":62,"./EnterLeaveEventPlugin":63,"./ExecutionEnvironment":70,"./HTMLDOMPropertyConfig":72,"./MobileSafariClickEventPlugin":75,"./ReactBrowserComponentMixin":79,"./ReactClass":83,"./ReactComponentBrowserEnvironment":85,"./ReactDOMButton":91,"./ReactDOMComponent":92,"./ReactDOMForm":93,"./ReactDOMIDOperations":94,"./ReactDOMIframe":95,"./ReactDOMImg":96,"./ReactDOMInput":97,"./ReactDOMOption":98,"./ReactDOMSelect":99,"./ReactDOMTextComponent":101,"./ReactDOMTextarea":102,"./ReactDefaultBatchingStrategy":103,"./ReactDefaultPerf":105,"./ReactElement":107,"./ReactEventListener":112,"./ReactInjection":114,"./ReactInstanceHandles":116,"./ReactMount":120,"./ReactReconcileTransaction":130,"./SVGDOMPropertyConfig":138,"./SelectEventPlugin":139,"./ServerReactRootIndex":140,"./SimpleEventPlugin":141,"./createFullPageComponent":161,"_process":1}],105:[function(require,module,exports){ +},{"./BeforeInputEventPlugin":54,"./ChangeEventPlugin":58,"./ClientReactRootIndex":59,"./DefaultEventPluginOrder":64,"./EnterLeaveEventPlugin":65,"./ExecutionEnvironment":72,"./HTMLDOMPropertyConfig":74,"./MobileSafariClickEventPlugin":77,"./ReactBrowserComponentMixin":81,"./ReactClass":85,"./ReactComponentBrowserEnvironment":87,"./ReactDOMButton":93,"./ReactDOMComponent":94,"./ReactDOMForm":95,"./ReactDOMIDOperations":96,"./ReactDOMIframe":97,"./ReactDOMImg":98,"./ReactDOMInput":99,"./ReactDOMOption":100,"./ReactDOMSelect":101,"./ReactDOMTextComponent":103,"./ReactDOMTextarea":104,"./ReactDefaultBatchingStrategy":105,"./ReactDefaultPerf":107,"./ReactElement":109,"./ReactEventListener":114,"./ReactInjection":116,"./ReactInstanceHandles":118,"./ReactMount":122,"./ReactReconcileTransaction":132,"./SVGDOMPropertyConfig":140,"./SelectEventPlugin":141,"./ServerReactRootIndex":142,"./SimpleEventPlugin":143,"./createFullPageComponent":163,"_process":1}],107:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -11562,7 +18988,7 @@ var ReactDefaultPerf = { module.exports = ReactDefaultPerf; -},{"./DOMProperty":59,"./ReactDefaultPerfAnalysis":106,"./ReactMount":120,"./ReactPerf":125,"./performanceNow":196}],106:[function(require,module,exports){ +},{"./DOMProperty":61,"./ReactDefaultPerfAnalysis":108,"./ReactMount":122,"./ReactPerf":127,"./performanceNow":198}],108:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -11768,7 +19194,7 @@ var ReactDefaultPerfAnalysis = { module.exports = ReactDefaultPerfAnalysis; -},{"./Object.assign":76}],107:[function(require,module,exports){ +},{"./Object.assign":78}],109:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -12076,7 +19502,7 @@ ReactElement.isValidElement = function(object) { module.exports = ReactElement; }).call(this,require('_process')) -},{"./Object.assign":76,"./ReactContext":88,"./ReactCurrentOwner":89,"./warning":204,"_process":1}],108:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactContext":90,"./ReactCurrentOwner":91,"./warning":206,"_process":1}],110:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -12541,7 +19967,7 @@ var ReactElementValidator = { module.exports = ReactElementValidator; }).call(this,require('_process')) -},{"./ReactCurrentOwner":89,"./ReactElement":107,"./ReactFragment":113,"./ReactNativeComponent":123,"./ReactPropTypeLocationNames":126,"./ReactPropTypeLocations":127,"./getIteratorFn":176,"./invariant":185,"./warning":204,"_process":1}],109:[function(require,module,exports){ +},{"./ReactCurrentOwner":91,"./ReactElement":109,"./ReactFragment":115,"./ReactNativeComponent":125,"./ReactPropTypeLocationNames":128,"./ReactPropTypeLocations":129,"./getIteratorFn":178,"./invariant":187,"./warning":206,"_process":1}],111:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -12636,7 +20062,7 @@ var ReactEmptyComponent = { module.exports = ReactEmptyComponent; }).call(this,require('_process')) -},{"./ReactElement":107,"./ReactInstanceMap":117,"./invariant":185,"_process":1}],110:[function(require,module,exports){ +},{"./ReactElement":109,"./ReactInstanceMap":119,"./invariant":187,"_process":1}],112:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -12668,7 +20094,7 @@ var ReactErrorUtils = { module.exports = ReactErrorUtils; -},{}],111:[function(require,module,exports){ +},{}],113:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -12718,7 +20144,7 @@ var ReactEventEmitterMixin = { module.exports = ReactEventEmitterMixin; -},{"./EventPluginHub":66}],112:[function(require,module,exports){ +},{"./EventPluginHub":68}],114:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -12901,7 +20327,7 @@ var ReactEventListener = { module.exports = ReactEventListener; -},{"./EventListener":65,"./ExecutionEnvironment":70,"./Object.assign":76,"./PooledClass":77,"./ReactInstanceHandles":116,"./ReactMount":120,"./ReactUpdates":137,"./getEventTarget":175,"./getUnboundedScrollPosition":181}],113:[function(require,module,exports){ +},{"./EventListener":67,"./ExecutionEnvironment":72,"./Object.assign":78,"./PooledClass":79,"./ReactInstanceHandles":118,"./ReactMount":122,"./ReactUpdates":139,"./getEventTarget":177,"./getUnboundedScrollPosition":183}],115:[function(require,module,exports){ (function (process){ /** * Copyright 2015, Facebook, Inc. @@ -13086,7 +20512,7 @@ var ReactFragment = { module.exports = ReactFragment; }).call(this,require('_process')) -},{"./ReactElement":107,"./warning":204,"_process":1}],114:[function(require,module,exports){ +},{"./ReactElement":109,"./warning":206,"_process":1}],116:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -13128,7 +20554,7 @@ var ReactInjection = { module.exports = ReactInjection; -},{"./DOMProperty":59,"./EventPluginHub":66,"./ReactBrowserEventEmitter":80,"./ReactClass":83,"./ReactComponentEnvironment":86,"./ReactDOMComponent":92,"./ReactEmptyComponent":109,"./ReactNativeComponent":123,"./ReactPerf":125,"./ReactRootIndex":133,"./ReactUpdates":137}],115:[function(require,module,exports){ +},{"./DOMProperty":61,"./EventPluginHub":68,"./ReactBrowserEventEmitter":82,"./ReactClass":85,"./ReactComponentEnvironment":88,"./ReactDOMComponent":94,"./ReactEmptyComponent":111,"./ReactNativeComponent":125,"./ReactPerf":127,"./ReactRootIndex":135,"./ReactUpdates":139}],117:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -13263,7 +20689,7 @@ var ReactInputSelection = { module.exports = ReactInputSelection; -},{"./ReactDOMSelection":100,"./containsNode":159,"./focusNode":169,"./getActiveElement":171}],116:[function(require,module,exports){ +},{"./ReactDOMSelection":102,"./containsNode":161,"./focusNode":171,"./getActiveElement":173}],118:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -13599,7 +21025,7 @@ var ReactInstanceHandles = { module.exports = ReactInstanceHandles; }).call(this,require('_process')) -},{"./ReactRootIndex":133,"./invariant":185,"_process":1}],117:[function(require,module,exports){ +},{"./ReactRootIndex":135,"./invariant":187,"_process":1}],119:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -13648,7 +21074,7 @@ var ReactInstanceMap = { module.exports = ReactInstanceMap; -},{}],118:[function(require,module,exports){ +},{}],120:[function(require,module,exports){ /** * Copyright 2015, Facebook, Inc. * All rights reserved. @@ -13685,7 +21111,7 @@ var ReactLifeCycle = { module.exports = ReactLifeCycle; -},{}],119:[function(require,module,exports){ +},{}],121:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -13733,7 +21159,7 @@ var ReactMarkupChecksum = { module.exports = ReactMarkupChecksum; -},{"./adler32":156}],120:[function(require,module,exports){ +},{"./adler32":158}],122:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -14624,7 +22050,7 @@ ReactPerf.measureMethods(ReactMount, 'ReactMount', { module.exports = ReactMount; }).call(this,require('_process')) -},{"./DOMProperty":59,"./ReactBrowserEventEmitter":80,"./ReactCurrentOwner":89,"./ReactElement":107,"./ReactElementValidator":108,"./ReactEmptyComponent":109,"./ReactInstanceHandles":116,"./ReactInstanceMap":117,"./ReactMarkupChecksum":119,"./ReactPerf":125,"./ReactReconciler":131,"./ReactUpdateQueue":136,"./ReactUpdates":137,"./containsNode":159,"./emptyObject":165,"./getReactRootElementInContainer":179,"./instantiateReactComponent":184,"./invariant":185,"./setInnerHTML":198,"./shouldUpdateReactComponent":201,"./warning":204,"_process":1}],121:[function(require,module,exports){ +},{"./DOMProperty":61,"./ReactBrowserEventEmitter":82,"./ReactCurrentOwner":91,"./ReactElement":109,"./ReactElementValidator":110,"./ReactEmptyComponent":111,"./ReactInstanceHandles":118,"./ReactInstanceMap":119,"./ReactMarkupChecksum":121,"./ReactPerf":127,"./ReactReconciler":133,"./ReactUpdateQueue":138,"./ReactUpdates":139,"./containsNode":161,"./emptyObject":167,"./getReactRootElementInContainer":181,"./instantiateReactComponent":186,"./invariant":187,"./setInnerHTML":200,"./shouldUpdateReactComponent":203,"./warning":206,"_process":1}],123:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -15054,7 +22480,7 @@ var ReactMultiChild = { module.exports = ReactMultiChild; -},{"./ReactChildReconciler":81,"./ReactComponentEnvironment":86,"./ReactMultiChildUpdateTypes":122,"./ReactReconciler":131}],122:[function(require,module,exports){ +},{"./ReactChildReconciler":83,"./ReactComponentEnvironment":88,"./ReactMultiChildUpdateTypes":124,"./ReactReconciler":133}],124:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -15087,7 +22513,7 @@ var ReactMultiChildUpdateTypes = keyMirror({ module.exports = ReactMultiChildUpdateTypes; -},{"./keyMirror":190}],123:[function(require,module,exports){ +},{"./keyMirror":192}],125:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -15194,7 +22620,7 @@ var ReactNativeComponent = { module.exports = ReactNativeComponent; }).call(this,require('_process')) -},{"./Object.assign":76,"./invariant":185,"_process":1}],124:[function(require,module,exports){ +},{"./Object.assign":78,"./invariant":187,"_process":1}],126:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -15306,7 +22732,7 @@ var ReactOwner = { module.exports = ReactOwner; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],125:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],127:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -15410,7 +22836,7 @@ function _noMeasure(objName, fnName, func) { module.exports = ReactPerf; }).call(this,require('_process')) -},{"_process":1}],126:[function(require,module,exports){ +},{"_process":1}],128:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -15438,7 +22864,7 @@ if ("production" !== process.env.NODE_ENV) { module.exports = ReactPropTypeLocationNames; }).call(this,require('_process')) -},{"_process":1}],127:[function(require,module,exports){ +},{"_process":1}],129:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -15462,7 +22888,7 @@ var ReactPropTypeLocations = keyMirror({ module.exports = ReactPropTypeLocations; -},{"./keyMirror":190}],128:[function(require,module,exports){ +},{"./keyMirror":192}],130:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -15811,7 +23237,7 @@ function getPreciseType(propValue) { module.exports = ReactPropTypes; -},{"./ReactElement":107,"./ReactFragment":113,"./ReactPropTypeLocationNames":126,"./emptyFunction":164}],129:[function(require,module,exports){ +},{"./ReactElement":109,"./ReactFragment":115,"./ReactPropTypeLocationNames":128,"./emptyFunction":166}],131:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -15867,7 +23293,7 @@ PooledClass.addPoolingTo(ReactPutListenerQueue); module.exports = ReactPutListenerQueue; -},{"./Object.assign":76,"./PooledClass":77,"./ReactBrowserEventEmitter":80}],130:[function(require,module,exports){ +},{"./Object.assign":78,"./PooledClass":79,"./ReactBrowserEventEmitter":82}],132:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -16043,7 +23469,7 @@ PooledClass.addPoolingTo(ReactReconcileTransaction); module.exports = ReactReconcileTransaction; -},{"./CallbackQueue":55,"./Object.assign":76,"./PooledClass":77,"./ReactBrowserEventEmitter":80,"./ReactInputSelection":115,"./ReactPutListenerQueue":129,"./Transaction":153}],131:[function(require,module,exports){ +},{"./CallbackQueue":57,"./Object.assign":78,"./PooledClass":79,"./ReactBrowserEventEmitter":82,"./ReactInputSelection":117,"./ReactPutListenerQueue":131,"./Transaction":155}],133:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -16167,7 +23593,7 @@ var ReactReconciler = { module.exports = ReactReconciler; }).call(this,require('_process')) -},{"./ReactElementValidator":108,"./ReactRef":132,"_process":1}],132:[function(require,module,exports){ +},{"./ReactElementValidator":110,"./ReactRef":134,"_process":1}],134:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -16238,7 +23664,7 @@ ReactRef.detachRefs = function(instance, element) { module.exports = ReactRef; -},{"./ReactOwner":124}],133:[function(require,module,exports){ +},{"./ReactOwner":126}],135:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -16269,7 +23695,7 @@ var ReactRootIndex = { module.exports = ReactRootIndex; -},{}],134:[function(require,module,exports){ +},{}],136:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -16351,7 +23777,7 @@ module.exports = { }; }).call(this,require('_process')) -},{"./ReactElement":107,"./ReactInstanceHandles":116,"./ReactMarkupChecksum":119,"./ReactServerRenderingTransaction":135,"./emptyObject":165,"./instantiateReactComponent":184,"./invariant":185,"_process":1}],135:[function(require,module,exports){ +},{"./ReactElement":109,"./ReactInstanceHandles":118,"./ReactMarkupChecksum":121,"./ReactServerRenderingTransaction":137,"./emptyObject":167,"./instantiateReactComponent":186,"./invariant":187,"_process":1}],137:[function(require,module,exports){ /** * Copyright 2014-2015, Facebook, Inc. * All rights reserved. @@ -16464,7 +23890,7 @@ PooledClass.addPoolingTo(ReactServerRenderingTransaction); module.exports = ReactServerRenderingTransaction; -},{"./CallbackQueue":55,"./Object.assign":76,"./PooledClass":77,"./ReactPutListenerQueue":129,"./Transaction":153,"./emptyFunction":164}],136:[function(require,module,exports){ +},{"./CallbackQueue":57,"./Object.assign":78,"./PooledClass":79,"./ReactPutListenerQueue":131,"./Transaction":155,"./emptyFunction":166}],138:[function(require,module,exports){ (function (process){ /** * Copyright 2015, Facebook, Inc. @@ -16763,7 +24189,7 @@ var ReactUpdateQueue = { module.exports = ReactUpdateQueue; }).call(this,require('_process')) -},{"./Object.assign":76,"./ReactCurrentOwner":89,"./ReactElement":107,"./ReactInstanceMap":117,"./ReactLifeCycle":118,"./ReactUpdates":137,"./invariant":185,"./warning":204,"_process":1}],137:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactCurrentOwner":91,"./ReactElement":109,"./ReactInstanceMap":119,"./ReactLifeCycle":120,"./ReactUpdates":139,"./invariant":187,"./warning":206,"_process":1}],139:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -17045,7 +24471,7 @@ var ReactUpdates = { module.exports = ReactUpdates; }).call(this,require('_process')) -},{"./CallbackQueue":55,"./Object.assign":76,"./PooledClass":77,"./ReactCurrentOwner":89,"./ReactPerf":125,"./ReactReconciler":131,"./Transaction":153,"./invariant":185,"./warning":204,"_process":1}],138:[function(require,module,exports){ +},{"./CallbackQueue":57,"./Object.assign":78,"./PooledClass":79,"./ReactCurrentOwner":91,"./ReactPerf":127,"./ReactReconciler":133,"./Transaction":155,"./invariant":187,"./warning":206,"_process":1}],140:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17139,7 +24565,7 @@ var SVGDOMPropertyConfig = { module.exports = SVGDOMPropertyConfig; -},{"./DOMProperty":59}],139:[function(require,module,exports){ +},{"./DOMProperty":61}],141:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17334,7 +24760,7 @@ var SelectEventPlugin = { module.exports = SelectEventPlugin; -},{"./EventConstants":64,"./EventPropagators":69,"./ReactInputSelection":115,"./SyntheticEvent":145,"./getActiveElement":171,"./isTextInputElement":188,"./keyOf":191,"./shallowEqual":200}],140:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPropagators":71,"./ReactInputSelection":117,"./SyntheticEvent":147,"./getActiveElement":173,"./isTextInputElement":190,"./keyOf":193,"./shallowEqual":202}],142:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17365,7 +24791,7 @@ var ServerReactRootIndex = { module.exports = ServerReactRootIndex; -},{}],141:[function(require,module,exports){ +},{}],143:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -17793,7 +25219,7 @@ var SimpleEventPlugin = { module.exports = SimpleEventPlugin; }).call(this,require('_process')) -},{"./EventConstants":64,"./EventPluginUtils":68,"./EventPropagators":69,"./SyntheticClipboardEvent":142,"./SyntheticDragEvent":144,"./SyntheticEvent":145,"./SyntheticFocusEvent":146,"./SyntheticKeyboardEvent":148,"./SyntheticMouseEvent":149,"./SyntheticTouchEvent":150,"./SyntheticUIEvent":151,"./SyntheticWheelEvent":152,"./getEventCharCode":172,"./invariant":185,"./keyOf":191,"./warning":204,"_process":1}],142:[function(require,module,exports){ +},{"./EventConstants":66,"./EventPluginUtils":70,"./EventPropagators":71,"./SyntheticClipboardEvent":144,"./SyntheticDragEvent":146,"./SyntheticEvent":147,"./SyntheticFocusEvent":148,"./SyntheticKeyboardEvent":150,"./SyntheticMouseEvent":151,"./SyntheticTouchEvent":152,"./SyntheticUIEvent":153,"./SyntheticWheelEvent":154,"./getEventCharCode":174,"./invariant":187,"./keyOf":193,"./warning":206,"_process":1}],144:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17838,7 +25264,7 @@ SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface); module.exports = SyntheticClipboardEvent; -},{"./SyntheticEvent":145}],143:[function(require,module,exports){ +},{"./SyntheticEvent":147}],145:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17883,7 +25309,7 @@ SyntheticEvent.augmentClass( module.exports = SyntheticCompositionEvent; -},{"./SyntheticEvent":145}],144:[function(require,module,exports){ +},{"./SyntheticEvent":147}],146:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -17922,7 +25348,7 @@ SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface); module.exports = SyntheticDragEvent; -},{"./SyntheticMouseEvent":149}],145:[function(require,module,exports){ +},{"./SyntheticMouseEvent":151}],147:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18088,7 +25514,7 @@ PooledClass.addPoolingTo(SyntheticEvent, PooledClass.threeArgumentPooler); module.exports = SyntheticEvent; -},{"./Object.assign":76,"./PooledClass":77,"./emptyFunction":164,"./getEventTarget":175}],146:[function(require,module,exports){ +},{"./Object.assign":78,"./PooledClass":79,"./emptyFunction":166,"./getEventTarget":177}],148:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18127,7 +25553,7 @@ SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface); module.exports = SyntheticFocusEvent; -},{"./SyntheticUIEvent":151}],147:[function(require,module,exports){ +},{"./SyntheticUIEvent":153}],149:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18173,7 +25599,7 @@ SyntheticEvent.augmentClass( module.exports = SyntheticInputEvent; -},{"./SyntheticEvent":145}],148:[function(require,module,exports){ +},{"./SyntheticEvent":147}],150:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18260,7 +25686,7 @@ SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface); module.exports = SyntheticKeyboardEvent; -},{"./SyntheticUIEvent":151,"./getEventCharCode":172,"./getEventKey":173,"./getEventModifierState":174}],149:[function(require,module,exports){ +},{"./SyntheticUIEvent":153,"./getEventCharCode":174,"./getEventKey":175,"./getEventModifierState":176}],151:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18341,7 +25767,7 @@ SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface); module.exports = SyntheticMouseEvent; -},{"./SyntheticUIEvent":151,"./ViewportMetrics":154,"./getEventModifierState":174}],150:[function(require,module,exports){ +},{"./SyntheticUIEvent":153,"./ViewportMetrics":156,"./getEventModifierState":176}],152:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18389,7 +25815,7 @@ SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface); module.exports = SyntheticTouchEvent; -},{"./SyntheticUIEvent":151,"./getEventModifierState":174}],151:[function(require,module,exports){ +},{"./SyntheticUIEvent":153,"./getEventModifierState":176}],153:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18451,7 +25877,7 @@ SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface); module.exports = SyntheticUIEvent; -},{"./SyntheticEvent":145,"./getEventTarget":175}],152:[function(require,module,exports){ +},{"./SyntheticEvent":147,"./getEventTarget":177}],154:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18512,7 +25938,7 @@ SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface); module.exports = SyntheticWheelEvent; -},{"./SyntheticMouseEvent":149}],153:[function(require,module,exports){ +},{"./SyntheticMouseEvent":151}],155:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -18753,7 +26179,7 @@ var Transaction = { module.exports = Transaction; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],154:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],156:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18782,7 +26208,7 @@ var ViewportMetrics = { module.exports = ViewportMetrics; -},{}],155:[function(require,module,exports){ +},{}],157:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -18848,7 +26274,7 @@ function accumulateInto(current, next) { module.exports = accumulateInto; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],156:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],158:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18882,7 +26308,7 @@ function adler32(data) { module.exports = adler32; -},{}],157:[function(require,module,exports){ +},{}],159:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -18914,7 +26340,7 @@ function camelize(string) { module.exports = camelize; -},{}],158:[function(require,module,exports){ +},{}],160:[function(require,module,exports){ /** * Copyright 2014-2015, Facebook, Inc. * All rights reserved. @@ -18956,7 +26382,7 @@ function camelizeStyleName(string) { module.exports = camelizeStyleName; -},{"./camelize":157}],159:[function(require,module,exports){ +},{"./camelize":159}],161:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19000,7 +26426,7 @@ function containsNode(outerNode, innerNode) { module.exports = containsNode; -},{"./isTextNode":189}],160:[function(require,module,exports){ +},{"./isTextNode":191}],162:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19086,7 +26512,7 @@ function createArrayFromMixed(obj) { module.exports = createArrayFromMixed; -},{"./toArray":202}],161:[function(require,module,exports){ +},{"./toArray":204}],163:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -19148,7 +26574,7 @@ function createFullPageComponent(tag) { module.exports = createFullPageComponent; }).call(this,require('_process')) -},{"./ReactClass":83,"./ReactElement":107,"./invariant":185,"_process":1}],162:[function(require,module,exports){ +},{"./ReactClass":85,"./ReactElement":109,"./invariant":187,"_process":1}],164:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -19238,7 +26664,7 @@ function createNodesFromMarkup(markup, handleScript) { module.exports = createNodesFromMarkup; }).call(this,require('_process')) -},{"./ExecutionEnvironment":70,"./createArrayFromMixed":160,"./getMarkupWrap":177,"./invariant":185,"_process":1}],163:[function(require,module,exports){ +},{"./ExecutionEnvironment":72,"./createArrayFromMixed":162,"./getMarkupWrap":179,"./invariant":187,"_process":1}],165:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19296,7 +26722,7 @@ function dangerousStyleValue(name, value) { module.exports = dangerousStyleValue; -},{"./CSSProperty":53}],164:[function(require,module,exports){ +},{"./CSSProperty":55}],166:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19330,7 +26756,7 @@ emptyFunction.thatReturnsArgument = function(arg) { return arg; }; module.exports = emptyFunction; -},{}],165:[function(require,module,exports){ +},{}],167:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -19354,7 +26780,7 @@ if ("production" !== process.env.NODE_ENV) { module.exports = emptyObject; }).call(this,require('_process')) -},{"_process":1}],166:[function(require,module,exports){ +},{"_process":1}],168:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19394,7 +26820,7 @@ function escapeTextContentForBrowser(text) { module.exports = escapeTextContentForBrowser; -},{}],167:[function(require,module,exports){ +},{}],169:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -19467,7 +26893,7 @@ function findDOMNode(componentOrElement) { module.exports = findDOMNode; }).call(this,require('_process')) -},{"./ReactCurrentOwner":89,"./ReactInstanceMap":117,"./ReactMount":120,"./invariant":185,"./isNode":187,"./warning":204,"_process":1}],168:[function(require,module,exports){ +},{"./ReactCurrentOwner":91,"./ReactInstanceMap":119,"./ReactMount":122,"./invariant":187,"./isNode":189,"./warning":206,"_process":1}],170:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -19525,7 +26951,7 @@ function flattenChildren(children) { module.exports = flattenChildren; }).call(this,require('_process')) -},{"./traverseAllChildren":203,"./warning":204,"_process":1}],169:[function(require,module,exports){ +},{"./traverseAllChildren":205,"./warning":206,"_process":1}],171:[function(require,module,exports){ /** * Copyright 2014-2015, Facebook, Inc. * All rights reserved. @@ -19554,7 +26980,7 @@ function focusNode(node) { module.exports = focusNode; -},{}],170:[function(require,module,exports){ +},{}],172:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19585,7 +27011,7 @@ var forEachAccumulated = function(arr, cb, scope) { module.exports = forEachAccumulated; -},{}],171:[function(require,module,exports){ +},{}],173:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19614,7 +27040,7 @@ function getActiveElement() /*?DOMElement*/ { module.exports = getActiveElement; -},{}],172:[function(require,module,exports){ +},{}],174:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19666,7 +27092,7 @@ function getEventCharCode(nativeEvent) { module.exports = getEventCharCode; -},{}],173:[function(require,module,exports){ +},{}],175:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19771,7 +27197,7 @@ function getEventKey(nativeEvent) { module.exports = getEventKey; -},{"./getEventCharCode":172}],174:[function(require,module,exports){ +},{"./getEventCharCode":174}],176:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19818,7 +27244,7 @@ function getEventModifierState(nativeEvent) { module.exports = getEventModifierState; -},{}],175:[function(require,module,exports){ +},{}],177:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19849,7 +27275,7 @@ function getEventTarget(nativeEvent) { module.exports = getEventTarget; -},{}],176:[function(require,module,exports){ +},{}],178:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -19893,7 +27319,7 @@ function getIteratorFn(maybeIterable) { module.exports = getIteratorFn; -},{}],177:[function(require,module,exports){ +},{}],179:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -20012,7 +27438,7 @@ function getMarkupWrap(nodeName) { module.exports = getMarkupWrap; }).call(this,require('_process')) -},{"./ExecutionEnvironment":70,"./invariant":185,"_process":1}],178:[function(require,module,exports){ +},{"./ExecutionEnvironment":72,"./invariant":187,"_process":1}],180:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20087,7 +27513,7 @@ function getNodeForCharacterOffset(root, offset) { module.exports = getNodeForCharacterOffset; -},{}],179:[function(require,module,exports){ +},{}],181:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20122,7 +27548,7 @@ function getReactRootElementInContainer(container) { module.exports = getReactRootElementInContainer; -},{}],180:[function(require,module,exports){ +},{}],182:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20159,7 +27585,7 @@ function getTextContentAccessor() { module.exports = getTextContentAccessor; -},{"./ExecutionEnvironment":70}],181:[function(require,module,exports){ +},{"./ExecutionEnvironment":72}],183:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20199,7 +27625,7 @@ function getUnboundedScrollPosition(scrollable) { module.exports = getUnboundedScrollPosition; -},{}],182:[function(require,module,exports){ +},{}],184:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20232,7 +27658,7 @@ function hyphenate(string) { module.exports = hyphenate; -},{}],183:[function(require,module,exports){ +},{}],185:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20273,7 +27699,7 @@ function hyphenateStyleName(string) { module.exports = hyphenateStyleName; -},{"./hyphenate":182}],184:[function(require,module,exports){ +},{"./hyphenate":184}],186:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -20411,7 +27837,7 @@ function instantiateReactComponent(node, parentCompositeType) { module.exports = instantiateReactComponent; }).call(this,require('_process')) -},{"./Object.assign":76,"./ReactCompositeComponent":87,"./ReactEmptyComponent":109,"./ReactNativeComponent":123,"./invariant":185,"./warning":204,"_process":1}],185:[function(require,module,exports){ +},{"./Object.assign":78,"./ReactCompositeComponent":89,"./ReactEmptyComponent":111,"./ReactNativeComponent":125,"./invariant":187,"./warning":206,"_process":1}],187:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -20468,7 +27894,7 @@ var invariant = function(condition, format, a, b, c, d, e, f) { module.exports = invariant; }).call(this,require('_process')) -},{"_process":1}],186:[function(require,module,exports){ +},{"_process":1}],188:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20533,7 +27959,7 @@ function isEventSupported(eventNameSuffix, capture) { module.exports = isEventSupported; -},{"./ExecutionEnvironment":70}],187:[function(require,module,exports){ +},{"./ExecutionEnvironment":72}],189:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20560,7 +27986,7 @@ function isNode(object) { module.exports = isNode; -},{}],188:[function(require,module,exports){ +},{}],190:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20603,7 +28029,7 @@ function isTextInputElement(elem) { module.exports = isTextInputElement; -},{}],189:[function(require,module,exports){ +},{}],191:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20628,7 +28054,7 @@ function isTextNode(object) { module.exports = isTextNode; -},{"./isNode":187}],190:[function(require,module,exports){ +},{"./isNode":189}],192:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -20683,7 +28109,7 @@ var keyMirror = function(obj) { module.exports = keyMirror; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],191:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],193:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20719,7 +28145,7 @@ var keyOf = function(oneKeyObj) { module.exports = keyOf; -},{}],192:[function(require,module,exports){ +},{}],194:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20772,7 +28198,7 @@ function mapObject(object, callback, context) { module.exports = mapObject; -},{}],193:[function(require,module,exports){ +},{}],195:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20805,7 +28231,7 @@ function memoizeStringOnly(callback) { module.exports = memoizeStringOnly; -},{}],194:[function(require,module,exports){ +},{}],196:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -20845,7 +28271,7 @@ function onlyChild(children) { module.exports = onlyChild; }).call(this,require('_process')) -},{"./ReactElement":107,"./invariant":185,"_process":1}],195:[function(require,module,exports){ +},{"./ReactElement":109,"./invariant":187,"_process":1}],197:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20873,7 +28299,7 @@ if (ExecutionEnvironment.canUseDOM) { module.exports = performance || {}; -},{"./ExecutionEnvironment":70}],196:[function(require,module,exports){ +},{"./ExecutionEnvironment":72}],198:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20901,7 +28327,7 @@ var performanceNow = performance.now.bind(performance); module.exports = performanceNow; -},{"./performance":195}],197:[function(require,module,exports){ +},{"./performance":197}],199:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -20929,7 +28355,7 @@ function quoteAttributeValueForBrowser(value) { module.exports = quoteAttributeValueForBrowser; -},{"./escapeTextContentForBrowser":166}],198:[function(require,module,exports){ +},{"./escapeTextContentForBrowser":168}],200:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -21018,7 +28444,7 @@ if (ExecutionEnvironment.canUseDOM) { module.exports = setInnerHTML; -},{"./ExecutionEnvironment":70}],199:[function(require,module,exports){ +},{"./ExecutionEnvironment":72}],201:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -21060,7 +28486,7 @@ if (ExecutionEnvironment.canUseDOM) { module.exports = setTextContent; -},{"./ExecutionEnvironment":70,"./escapeTextContentForBrowser":166,"./setInnerHTML":198}],200:[function(require,module,exports){ +},{"./ExecutionEnvironment":72,"./escapeTextContentForBrowser":168,"./setInnerHTML":200}],202:[function(require,module,exports){ /** * Copyright 2013-2015, Facebook, Inc. * All rights reserved. @@ -21104,7 +28530,7 @@ function shallowEqual(objA, objB) { module.exports = shallowEqual; -},{}],201:[function(require,module,exports){ +},{}],203:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -21208,7 +28634,7 @@ function shouldUpdateReactComponent(prevElement, nextElement) { module.exports = shouldUpdateReactComponent; }).call(this,require('_process')) -},{"./warning":204,"_process":1}],202:[function(require,module,exports){ +},{"./warning":206,"_process":1}],204:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -21280,7 +28706,7 @@ function toArray(obj) { module.exports = toArray; }).call(this,require('_process')) -},{"./invariant":185,"_process":1}],203:[function(require,module,exports){ +},{"./invariant":187,"_process":1}],205:[function(require,module,exports){ (function (process){ /** * Copyright 2013-2015, Facebook, Inc. @@ -21533,7 +28959,7 @@ function traverseAllChildren(children, callback, traverseContext) { module.exports = traverseAllChildren; }).call(this,require('_process')) -},{"./ReactElement":107,"./ReactFragment":113,"./ReactInstanceHandles":116,"./getIteratorFn":176,"./invariant":185,"./warning":204,"_process":1}],204:[function(require,module,exports){ +},{"./ReactElement":109,"./ReactFragment":115,"./ReactInstanceHandles":118,"./getIteratorFn":178,"./invariant":187,"./warning":206,"_process":1}],206:[function(require,module,exports){ (function (process){ /** * Copyright 2014-2015, Facebook, Inc. @@ -21596,10 +29022,10 @@ if ("production" !== process.env.NODE_ENV) { module.exports = warning; }).call(this,require('_process')) -},{"./emptyFunction":164,"_process":1}],205:[function(require,module,exports){ +},{"./emptyFunction":166,"_process":1}],207:[function(require,module,exports){ module.exports = require('./lib/React'); -},{"./lib/React":78}],206:[function(require,module,exports){ +},{"./lib/React":80}],208:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -21764,7 +29190,7 @@ function createStore(reducer, initialState) { replaceReducer: replaceReducer }; } -},{"./utils/isPlainObject":212}],207:[function(require,module,exports){ +},{"./utils/isPlainObject":214}],209:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -21796,7 +29222,7 @@ exports.combineReducers = _utilsCombineReducers2['default']; exports.bindActionCreators = _utilsBindActionCreators2['default']; exports.applyMiddleware = _utilsApplyMiddleware2['default']; exports.compose = _utilsCompose2['default']; -},{"./createStore":206,"./utils/applyMiddleware":208,"./utils/bindActionCreators":209,"./utils/combineReducers":210,"./utils/compose":211}],208:[function(require,module,exports){ +},{"./createStore":208,"./utils/applyMiddleware":210,"./utils/bindActionCreators":211,"./utils/combineReducers":212,"./utils/compose":213}],210:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -21858,7 +29284,7 @@ function applyMiddleware() { } module.exports = exports['default']; -},{"./compose":211}],209:[function(require,module,exports){ +},{"./compose":213}],211:[function(require,module,exports){ 'use strict'; exports.__esModule = true; @@ -21913,7 +29339,7 @@ function bindActionCreators(actionCreators, dispatch) { } module.exports = exports['default']; -},{"../utils/mapValues":213}],210:[function(require,module,exports){ +},{"../utils/mapValues":215}],212:[function(require,module,exports){ (function (process){ 'use strict'; @@ -22033,7 +29459,7 @@ function combineReducers(reducers) { module.exports = exports['default']; }).call(this,require('_process')) -},{"../createStore":206,"../utils/isPlainObject":212,"../utils/mapValues":213,"../utils/pick":214,"_process":1}],211:[function(require,module,exports){ +},{"../createStore":208,"../utils/isPlainObject":214,"../utils/mapValues":215,"../utils/pick":216,"_process":1}],213:[function(require,module,exports){ /** * Composes functions from left to right. * @@ -22058,9 +29484,9 @@ function compose() { } module.exports = exports["default"]; -},{}],212:[function(require,module,exports){ -arguments[4][47][0].apply(exports,arguments) -},{"dup":47}],213:[function(require,module,exports){ +},{}],214:[function(require,module,exports){ +arguments[4][49][0].apply(exports,arguments) +},{"dup":49}],215:[function(require,module,exports){ /** * Applies a function to every key-value pair inside an object. * @@ -22081,7 +29507,7 @@ function mapValues(obj, fn) { } module.exports = exports["default"]; -},{}],214:[function(require,module,exports){ +},{}],216:[function(require,module,exports){ /** * Picks key-value pairs from an object where values satisfy a predicate. * @@ -22104,7 +29530,7 @@ function pick(obj, fn) { } module.exports = exports["default"]; -},{}],215:[function(require,module,exports){ +},{}],217:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22124,7 +29550,7 @@ function changedir(dir) { module.exports = exports['default']; -},{"actions/types":223}],216:[function(require,module,exports){ +},{"actions/types":225}],218:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22176,7 +29602,7 @@ function hideAll() { }, props); } -},{"actions/types":223}],217:[function(require,module,exports){ +},{"actions/types":225}],219:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22185,8 +29611,10 @@ Object.defineProperty(exports, '__esModule', { exports.create = create; exports.share = share; exports.rename = rename; +exports.move = move; +exports.copy = copy; exports.active = active; -exports.deleteFile = deleteFile; +exports.remove = remove; var _actionsTypes = require('actions/types'); @@ -22213,6 +29641,20 @@ function rename(file, name) { }; } +function move(file, newPath) { + return { + type: _actionsTypes.MOVE_FILE, + file: file, newPath: newPath + }; +} + +function copy(file, newPath) { + return { + type: _actionsTypes.COPY_FILE, + file: file, newPath: newPath + }; +} + function active() { var file = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0]; @@ -22222,25 +29664,26 @@ function active() { }; } -function deleteFile(file) { - console.log('constructing deleteFile action', file); +function remove(file) { return { type: _actionsTypes.DELETE_FILE, file: file }; } -},{"actions/types":223}],218:[function(require,module,exports){ +},{"actions/types":225}],220:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); +exports.listFiles = listFiles; exports.refresh = refresh; exports.toggle = toggle; exports.details = details; exports.list = list; exports.selectView = selectView; +exports.search = search; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } @@ -22250,6 +29693,13 @@ var _store = require('store'); var _store2 = _interopRequireDefault(_store); +function listFiles(files) { + return { + type: _actionsTypes.LIST_FILES, + files: files + }; +} + function refresh() { return { type: _actionsTypes.REFRESH @@ -22286,26 +29736,14 @@ function selectView() { }; } -},{"actions/types":223,"store":"store"}],219:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); -exports['default'] = listFiles; - -var _actionsTypes = require('actions/types'); - -function listFiles(files) { +function search(keywords) { return { - type: _actionsTypes.LIST_FILES, - files: files + type: _actionsTypes.SEARCH, + keywords: keywords }; } -module.exports = exports['default']; - -},{"actions/types":223}],220:[function(require,module,exports){ +},{"actions/types":225,"store":"store"}],221:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22357,7 +29795,7 @@ function hideAll() { }, props); } -},{"actions/types":223}],221:[function(require,module,exports){ +},{"actions/types":225}],222:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22390,7 +29828,7 @@ function toggle() { }; } -},{"actions/types":223}],222:[function(require,module,exports){ +},{"actions/types":225}],223:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22409,7 +29847,40 @@ exports['default'] = function (props) { module.exports = exports['default']; -},{"actions/types":223}],223:[function(require,module,exports){ +},{"actions/types":225}],224:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.show = show; +exports.hide = hide; +exports.toggle = toggle; + +var _actionsTypes = require('actions/types'); + +function show() { + return { + type: _actionsTypes.SPINNER, + active: true + }; +} + +function hide() { + return { + type: _actionsTypes.SPINNER, + active: false + }; +} + +function toggle() { + return { + type: _actionsTypes.SPINNER, + active: 'toggle' + }; +} + +},{"actions/types":225}],225:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22433,11 +29904,15 @@ var TYPES = { RENAME_FILE: Symbol('RENAME_FILE'), ACTIVE_FILE: Symbol('ACTIVE_FILE'), DELETE_FILE: Symbol('DELETE_FILE'), + COPY_FILE: Symbol('COPY_FILE'), + MOVE_FILE: Symbol('MOVE_FILE'), MENU: Symbol('MENU'), DIALOG: Symbol('DIALOG'), + SPINNER: Symbol('SPINNER'), + SETTINGS: Symbol('SETTINGS'), SEARCH: Symbol('SEARCH') @@ -22446,7 +29921,7 @@ var TYPES = { exports['default'] = TYPES; module.exports = exports['default']; -},{}],224:[function(require,module,exports){ +},{}],226:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22554,10 +30029,11 @@ var createDirectory = _asyncToGenerator(function* () { exports.createDirectory = createDirectory; -var remove = _asyncToGenerator(function* (file) { +var remove = _asyncToGenerator(function* (file, deep) { var parent = yield root(); - return parent.remove(file); + console.log(deep); + return parent[deep ? 'removeDeep' : 'remove'](file); }); exports.remove = remove; @@ -22566,6 +30042,16 @@ var move = _asyncToGenerator(function* (file, newPath) { var path = (file.path || '').replace(/^\//, ''); // remove starting slash var oldPath = path + file.name; + var process = yield copy(file, newPath); + return remove(oldPath, true); +}); + +exports.move = move; + +var copy = _asyncToGenerator(function* (file, newPath) { + var path = (file.path || '').replace(/^\//, ''); // remove starting slash + var oldPath = path + file.name; + newPath = newPath.replace(/^\//, ''); var target = yield getFile(oldPath); @@ -22604,7 +30090,6 @@ var move = _asyncToGenerator(function* (file, newPath) { } } - yield parent.remove(oldPath); return; } else { var _ret = yield* (function* () { @@ -22618,8 +30103,6 @@ var move = _asyncToGenerator(function* (file, newPath) { request.onsuccess = resolve; request.onerror = reject; request.onabort = reject; - }).then(function () { - return sdcard()['delete'](oldPath); }) }; })(); @@ -22628,7 +30111,7 @@ var move = _asyncToGenerator(function* (file, newPath) { } }); -exports.move = move; +exports.copy = copy; function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { var callNext = step.bind(null, 'next'); var callThrow = step.bind(null, 'throw'); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(callNext, callThrow); } } callNext(); }); }; } @@ -22646,7 +30129,7 @@ function sdcard() { var ROOT_CACHE = undefined; -},{"utils":"utils"}],225:[function(require,module,exports){ +},{"utils":"utils"}],227:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22737,7 +30220,11 @@ var Breadcrumb = (function (_Component) { return _react2['default'].createElement( 'div', { className: 'breadcrumb' }, - els + _react2['default'].createElement( + 'div', + null, + els + ) ); } }]); @@ -22757,7 +30244,7 @@ function props(state) { } module.exports = exports['default']; -},{"actions/changedir":215,"react":205,"react-redux":45,"store":"store"}],226:[function(require,module,exports){ +},{"actions/changedir":217,"react":207,"react-redux":47,"store":"store"}],228:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22842,7 +30329,7 @@ var Dialog = (function (_Component) { exports['default'] = Dialog; module.exports = exports['default']; -},{"react":205,"utils":"utils"}],227:[function(require,module,exports){ +},{"react":207,"utils":"utils"}],229:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -22877,6 +30364,10 @@ var _store = require('store'); var _store2 = _interopRequireDefault(_store); +var _mixinsEntry = require('./mixins/entry'); + +var _mixinsEntry2 = _interopRequireDefault(_mixinsEntry); + var MENU_TOP_SPACE = 20; var Directory = (function (_Component) { @@ -22885,7 +30376,8 @@ var Directory = (function (_Component) { function Directory() { _classCallCheck(this, Directory); - _get(Object.getPrototypeOf(Directory.prototype), 'constructor', this).apply(this, arguments); + _get(Object.getPrototypeOf(Directory.prototype), 'constructor', this).call(this); + Object.assign(this, _mixinsEntry2['default']); } _createClass(Directory, [{ @@ -22930,35 +30422,6 @@ var Directory = (function (_Component) { _store2['default'].dispatch((0, _actionsChangedir2['default'])(file.path.slice(1) + file.name)); } - }, { - key: 'contextMenu', - value: function contextMenu(e) { - e.preventDefault(); - - var rect = _react2['default'].findDOMNode(this.refs.container).getBoundingClientRect(); - var x = rect.x; - var y = rect.y; - var width = rect.width; - var height = rect.height; - - var left = x + width / 2 - _menu.MENU_WIDTH / 2, - top = y + height / 2 + MENU_TOP_SPACE; - _store2['default'].dispatch((0, _actionsMenu.show)('directoryMenu', { style: { left: left, top: top } })); - _store2['default'].dispatch((0, _actionsFile.active)(this.props.index)); - } - }, { - key: 'select', - value: function select() { - var current = (_store2['default'].getState().get('activeFile') || []).slice(0); - var index = this.props.index; - - if (current.indexOf(index) > -1) { - current.splice(current.indexOf(index), 1); - } else { - current.push(index); - } - _store2['default'].dispatch((0, _actionsFile.active)(current)); - } }]); return Directory; @@ -22967,7 +30430,7 @@ var Directory = (function (_Component) { exports['default'] = Directory; module.exports = exports['default']; -},{"./menu":231,"actions/changedir":215,"actions/file":217,"actions/menu":220,"react":205,"store":"store"}],228:[function(require,module,exports){ +},{"./menu":233,"./mixins/entry":234,"actions/changedir":217,"actions/file":219,"actions/menu":221,"react":207,"store":"store"}],230:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23013,6 +30476,14 @@ var _store2 = _interopRequireDefault(_store); var _utils = require('utils'); +var _hammerjs = require('hammerjs'); + +var _hammerjs2 = _interopRequireDefault(_hammerjs); + +var _actionsChangedir = require('actions/changedir'); + +var _actionsChangedir2 = _interopRequireDefault(_actionsChangedir); + var FileList = (function (_Component) { _inherits(FileList, _Component); @@ -23034,7 +30505,7 @@ var FileList = (function (_Component) { var settings = _store2['default'].getState().get('settings'); var els = files.map(function (file, index) { - var selected = activeFile.indexOf(index) > -1; + var selected = activeFile.length && activeFile.indexOf(file) > -1; if ((0, _utils.type)(file) === 'File') { return _react2['default'].createElement(_file2['default'], { selectView: selectView, selected: selected, key: index, index: index, name: file.name, size: file.size }); } else { @@ -23044,10 +30515,25 @@ var FileList = (function (_Component) { return _react2['default'].createElement( 'div', - { className: 'file-list' }, + { className: 'file-list', ref: 'container' }, els ); } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + var container = _react2['default'].findDOMNode(this.refs.container); + var touch = (0, _hammerjs2['default'])(container); + + touch.on('swipe', function (e) { + var current = _store2['default'].getState().get('cwd'); + var up = current.split('/').slice(0, -1).join('/'); + + if (up === current) return; + + _store2['default'].dispatch((0, _actionsChangedir2['default'])(up)); + }).set({ direction: _hammerjs2['default'].DIRECTION_RIGHT }); + } }]); var _FileList = FileList; @@ -23067,7 +30553,7 @@ function props(state) { module.exports = exports['default']; -},{"./directory":227,"./file":229,"react":205,"react-redux":45,"store":"store","utils":"utils"}],229:[function(require,module,exports){ +},{"./directory":229,"./file":231,"actions/changedir":217,"hammerjs":2,"react":207,"react-redux":47,"store":"store","utils":"utils"}],231:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23100,6 +30586,10 @@ var _store2 = _interopRequireDefault(_store); var _utils = require('utils'); +var _mixinsEntry = require('./mixins/entry'); + +var _mixinsEntry2 = _interopRequireDefault(_mixinsEntry); + var MENU_TOP_SPACE = 20; var File = (function (_Component) { @@ -23109,6 +30599,7 @@ var File = (function (_Component) { _classCallCheck(this, File); _get(Object.getPrototypeOf(File.prototype), 'constructor', this).call(this); + Object.assign(this, _mixinsEntry2['default']); } _createClass(File, [{ @@ -23123,7 +30614,7 @@ var File = (function (_Component) { label = _react2['default'].createElement('label', { htmlFor: checkId }); } - var clickHandler = this.props.selectView ? this.select.bind(this) : null; + var clickHandler = this.props.selectView ? this.select.bind(this) : this.open.bind(this); return _react2['default'].createElement( 'div', @@ -23146,33 +30637,18 @@ var File = (function (_Component) { ); } }, { - key: 'contextMenu', - value: function contextMenu(e) { - e.preventDefault(); + key: 'open', + value: function open(e) { + var file = _store2['default'].getState().get('files')[this.props.index]; - var rect = _react2['default'].findDOMNode(this.refs.container).getBoundingClientRect(); - var x = rect.x; - var y = rect.y; - var width = rect.width; - var height = rect.height; - - var left = x + width / 2 - _menu.MENU_WIDTH / 2, - top = y + height / 2 + MENU_TOP_SPACE; - _store2['default'].dispatch((0, _actionsMenu.show)('fileMenu', { style: { left: left, top: top } })); - _store2['default'].dispatch((0, _actionsFile.active)(this.props.index)); - } - }, { - key: 'select', - value: function select() { - var current = (_store2['default'].getState().get('activeFile') || []).slice(0); - var index = this.props.index; - - if (current.indexOf(index) > -1) { - current.splice(current.indexOf(index), 1); - } else { - current.push(index); - } - _store2['default'].dispatch((0, _actionsFile.active)(current)); + var name = file.type === 'application/pdf' ? 'view' : 'open'; + new MozActivity({ + name: name, + data: { + type: file.type, + blob: file + } + }); } }]); @@ -23182,7 +30658,7 @@ var File = (function (_Component) { exports['default'] = File; module.exports = exports['default']; -},{"./menu":231,"actions/file":217,"actions/menu":220,"react":205,"store":"store","utils":"utils"}],230:[function(require,module,exports){ +},{"./menu":233,"./mixins/entry":234,"actions/file":219,"actions/menu":221,"react":207,"store":"store","utils":"utils"}],232:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23205,47 +30681,63 @@ var _react2 = _interopRequireDefault(_react); var _actionsNavigation = require('actions/navigation'); +var _actionsDialog = require('actions/dialog'); + +var _actionsFilesView = require('actions/files-view'); + var _store = require('store'); -var _store2 = _interopRequireDefault(_store); +var _reactRedux = require('react-redux'); var Header = (function (_Component) { _inherits(Header, _Component); function Header() { - _classCallCheck(this, Header); + _classCallCheck(this, _Header); - _get(Object.getPrototypeOf(Header.prototype), 'constructor', this).apply(this, arguments); + _get(Object.getPrototypeOf(_Header.prototype), 'constructor', this).apply(this, arguments); } _createClass(Header, [{ key: 'render', value: function render() { + var i = undefined; + + if (this.props.search) { + i = _react2['default'].createElement('i', { className: 'icon-cross', onClick: (0, _store.bind)((0, _actionsFilesView.search)()) }); + } else { + i = _react2['default'].createElement('i', { className: 'icon-search', onClick: (0, _store.bind)((0, _actionsDialog.show)('searchDialog')) }); + } + return _react2['default'].createElement( 'header', null, - _react2['default'].createElement('button', { className: 'drawer', onClick: this.toggleNavigation.bind(this) }), + _react2['default'].createElement('button', { className: 'drawer', onTouchStart: (0, _store.bind)((0, _actionsNavigation.toggle)()) }), _react2['default'].createElement( 'h1', { className: 'regular-medium' }, 'Hawk' - ) + ), + i ); } - }, { - key: 'toggleNavigation', - value: function toggleNavigation() { - _store2['default'].dispatch((0, _actionsNavigation.toggle)()); - } }]); + var _Header = Header; + Header = (0, _reactRedux.connect)(props)(Header) || Header; return Header; })(_react.Component); exports['default'] = Header; + +function props(state) { + return { + search: state.get('search') + }; +} module.exports = exports['default']; -},{"actions/navigation":221,"react":205,"store":"store"}],231:[function(require,module,exports){ +},{"actions/dialog":218,"actions/files-view":220,"actions/navigation":222,"react":207,"react-redux":47,"store":"store"}],233:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23292,9 +30784,12 @@ var Menu = (function (_Component) { items = items || []; var els = items.map(function (item, index) { + var disabled = !(typeof item.enabled === 'function' ? item.enabled() : true); + var className = disabled ? 'disabled' : ''; + return _react2['default'].createElement( 'li', - { key: index, onClick: item.action.bind(_this) }, + { key: index, className: className, onClick: item.action.bind(_this) }, item.name ); }); @@ -23317,7 +30812,44 @@ var Menu = (function (_Component) { exports['default'] = Menu; -},{"react":205}],232:[function(require,module,exports){ +},{"react":207}],234:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports['default'] = { + contextMenu: function contextMenu(e) { + e.preventDefault(); + + var file = store.getState().get('files')[this.props.index]; + var rect = React.findDOMNode(this.refs.container).getBoundingClientRect(); + var x = rect.x; + var y = rect.y; + var width = rect.width; + var height = rect.height; + + var left = x + width / 2 - MENU_WIDTH / 2, + top = y + height / 2 + MENU_TOP_SPACE; + store.dispatch(show('fileMenu', { style: { left: left, top: top } })); + store.dispatch(active([file])); + }, + + select: function select() { + var current = store.getState().get('activeFile').slice(0); + var file = store.getState().get('files')[this.props.index]; + + if (current.indexOf(file) > -1) { + current.splice(current.indexOf(file), 1); + } else { + current.push(file); + } + store.dispatch(active(current)); + } +}; +module.exports = exports['default']; + +},{}],235:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23372,8 +30904,8 @@ var Navigation = (function (_Component) { return _react2['default'].createElement( 'nav', - { className: this.props.active ? 'active' : '' }, - _react2['default'].createElement('i', { onClick: this.hide.bind(this) }), + { className: this.props.active ? 'active' : '', onChange: this.onChange.bind(this) }, + _react2['default'].createElement('i', { onTouchStart: this.hide }), _react2['default'].createElement( 'p', null, @@ -23385,17 +30917,42 @@ var Navigation = (function (_Component) { _react2['default'].createElement( 'li', null, - 'Picture' + _react2['default'].createElement('input', { id: 'filter-all', name: 'filter', value: '', type: 'radio', defaultChecked: !settings.filter }), + _react2['default'].createElement( + 'label', + { htmlFor: 'filter-all' }, + 'All' + ) ), _react2['default'].createElement( 'li', null, - 'Video' + _react2['default'].createElement('input', { id: 'filter-image', name: 'filter', value: 'image', type: 'radio', defaultChecked: settings.filter === 'image' }), + _react2['default'].createElement( + 'label', + { htmlFor: 'filter-image' }, + 'Image' + ) ), _react2['default'].createElement( 'li', null, - 'Audio' + _react2['default'].createElement('input', { id: 'filter-video', name: 'filter', value: 'video', type: 'radio', defaultChecked: settings.filter === 'video' }), + _react2['default'].createElement( + 'label', + { htmlFor: 'filter-video' }, + 'Video' + ) + ), + _react2['default'].createElement( + 'li', + null, + _react2['default'].createElement('input', { id: 'filter-audio', name: 'filter', value: 'audio', type: 'radio', defaultChecked: settings.filter === 'audio' }), + _react2['default'].createElement( + 'label', + { htmlFor: 'filter-audio' }, + 'Audio' + ) ) ), _react2['default'].createElement( @@ -23408,8 +30965,12 @@ var Navigation = (function (_Component) { null, _react2['default'].createElement( 'li', - null, - 'FTP Browser' + { className: 'coming-soon' }, + _react2['default'].createElement( + 'label', + null, + 'FTP Browser' + ) ) ), _react2['default'].createElement( @@ -23419,7 +30980,7 @@ var Navigation = (function (_Component) { ), _react2['default'].createElement( 'ul', - { onChange: this.onChange.bind(this) }, + null, _react2['default'].createElement( 'li', null, @@ -23440,31 +31001,97 @@ var Navigation = (function (_Component) { 'Show Directories First' ) ), + _react2['default'].createElement( + 'li', + { className: 'coming-soon' }, + _react2['default'].createElement( + 'label', + null, + 'Advanced Preferences' + ) + ) + ), + _react2['default'].createElement( + 'p', + null, + 'External' + ), + _react2['default'].createElement( + 'ul', + null, _react2['default'].createElement( 'li', null, - 'Advanced Preferences' + _react2['default'].createElement( + 'label', + null, + _react2['default'].createElement( + 'a', + { href: 'https://github.com/mdibaiee/Hawk' }, + 'GitHub' + ) + ) + ), + _react2['default'].createElement( + 'li', + null, + _react2['default'].createElement( + 'label', + null, + _react2['default'].createElement( + 'a', + { href: 'https://github.com/mdibaiee/Hawk/issues' }, + 'Report Bugs' + ) + ) + ), + _react2['default'].createElement( + 'li', + null, + _react2['default'].createElement( + 'label', + null, + _react2['default'].createElement( + 'a', + { href: 'http://dibaiee.ir/Hawk' }, + 'Website' + ) + ) + ), + _react2['default'].createElement( + 'li', + null, + _react2['default'].createElement( + 'label', + null, + _react2['default'].createElement( + 'a', + { href: 'http://dibaiee.ir' }, + 'Mahdi Dibaiee' + ) + ) ) ) ); } - }, { - key: 'hide', - value: function hide() { - this.props.dispatch((0, _actionsNavigation.hide)()); - } }, { key: 'onChange', value: function onChange(e) { - if (e.target.nodeName.toLowerCase() !== 'input') return; + var key = e.target.name || e.target.id; + var value = e.target.value === undefined ? e.target.checked : e.target.value; - var key = e.target.id; - var value = this.props.settings[key]; - - var action = (0, _actionsSettings2['default'])(_defineProperty({}, key, e.target.checked)); + var action = (0, _actionsSettings2['default'])(_defineProperty({}, key, value)); _store2['default'].dispatch(action); } + }, { + key: 'hide', + value: function hide(e) { + e.preventDefault(); + e.stopPropagation(); + + _store2['default'].dispatch((0, _actionsNavigation.hide)()); + } }]); var _Navigation = Navigation; @@ -23482,7 +31109,7 @@ function props(store) { } module.exports = exports['default']; -},{"actions/navigation":221,"actions/settings":222,"lodash/string/camelCase":38,"react":205,"react-redux":45,"store":"store"}],233:[function(require,module,exports){ +},{"actions/navigation":222,"actions/settings":223,"lodash/string/camelCase":40,"react":207,"react-redux":47,"store":"store"}],236:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23531,6 +31158,10 @@ var _componentsDialog = require('components/dialog'); var _componentsDialog2 = _interopRequireDefault(_componentsDialog); +var _componentsSpinner = require('components/spinner'); + +var _componentsSpinner2 = _interopRequireDefault(_componentsSpinner); + var _reactRedux = require('react-redux'); var _actionsMenu = require('actions/menu'); @@ -23570,6 +31201,9 @@ var ErrorDialog = (0, _reactRedux.connect)(function (state) { var CreateDialog = (0, _reactRedux.connect)(function (state) { return state.get('createDialog'); })(_componentsDialog2['default']); +var SearchDialog = (0, _reactRedux.connect)(function (state) { + return state.get('searchDialog'); +})(_componentsDialog2['default']); var Root = (function (_Component) { _inherits(Root, _Component); @@ -23585,7 +31219,7 @@ var Root = (function (_Component) { value: function render() { return _react2['default'].createElement( 'div', - { onTouchStart: this.touchStart.bind(this) }, + { onTouchStart: this.touchStart.bind(this), onClick: this.onClick.bind(this) }, _react2['default'].createElement(_componentsHeader2['default'], null), _react2['default'].createElement(_componentsBreadcrumb2['default'], null), _react2['default'].createElement(_componentsNavigation2['default'], null), @@ -23597,21 +31231,48 @@ var Root = (function (_Component) { _react2['default'].createElement(RenameDialog, null), _react2['default'].createElement(DeleteDialog, null), _react2['default'].createElement(ErrorDialog, null), - _react2['default'].createElement(CreateDialog, null) + _react2['default'].createElement(CreateDialog, null), + _react2['default'].createElement(SearchDialog, null), + _react2['default'].createElement(_componentsSpinner2['default'], null) ); } }, { key: 'touchStart', value: function touchStart(e) { var active = document.querySelector('.active'); - var inside = e.target.closest('.menu') || e.target.closest('.dialog'); - if (!inside && active) { + var inside = e.target.closest('.active'); + if (active && !inside) { e.preventDefault(); e.stopPropagation(); _store2['default'].dispatch((0, _actionsMenu.hideAll)()); _store2['default'].dispatch((0, _actionsDialog.hideAll)()); } + + if (document.querySelector('.sk-cube-grid.show')) { + e.preventDefault(); + e.stopPropagation(); + } + } + }, { + key: 'onClick', + value: function onClick(e) { + var tag = e.target.nodeName.toLowerCase(); + if (tag === 'a') { + var url = new URL(e.target.href); + + if (url.origin !== location.origin) { + e.preventDefault(); + new MozActivity({ + name: 'view', + + data: { + type: 'url', + url: e.target.href + } + }); + } + } } }]); @@ -23621,7 +31282,73 @@ var Root = (function (_Component) { exports['default'] = Root; module.exports = exports['default']; -},{"actions/changedir":215,"actions/dialog":216,"actions/menu":220,"components/breadcrumb":225,"components/dialog":226,"components/file-list":228,"components/header":230,"components/menu":231,"components/navigation":232,"components/toolbar":234,"react":205,"react-redux":45,"store":"store"}],234:[function(require,module,exports){ +},{"actions/changedir":217,"actions/dialog":218,"actions/menu":221,"components/breadcrumb":227,"components/dialog":228,"components/file-list":230,"components/header":232,"components/menu":233,"components/navigation":235,"components/spinner":237,"components/toolbar":238,"react":207,"react-redux":47,"store":"store"}],237:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _reactRedux = require('react-redux'); + +var Spinner = (function (_Component) { + _inherits(Spinner, _Component); + + function Spinner() { + _classCallCheck(this, _Spinner); + + _get(Object.getPrototypeOf(_Spinner.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Spinner, [{ + key: 'render', + value: function render() { + var className = 'sk-cube-grid ' + (this.props.active ? ' show' : ''); + return _react2['default'].createElement( + 'div', + { className: className }, + _react2['default'].createElement('div', { className: 'sk-cube sk-cube1' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube2' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube3' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube4' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube5' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube6' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube7' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube8' }), + _react2['default'].createElement('div', { className: 'sk-cube sk-cube9' }) + ); + } + }]); + + var _Spinner = Spinner; + Spinner = (0, _reactRedux.connect)(props)(Spinner) || Spinner; + return Spinner; +})(_react.Component); + +exports['default'] = Spinner; + +function props(state) { + return { + active: state.get('spinner') + }; +} +module.exports = exports['default']; + +},{"react":207,"react-redux":47}],238:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23670,7 +31397,7 @@ var Toolbar = (function (_Component) { 'div', { className: 'toolbar' }, _react2['default'].createElement('button', { className: 'icon-plus', onClick: this.newFile }), - _react2['default'].createElement('button', { className: 'icon-view', onClick: (0, _store.bind)((0, _actionsFilesView.toggle)()) }), + _react2['default'].createElement('button', { className: 'icon-view coming-soon', onClick: (0, _store.bind)((0, _actionsFilesView.toggle)()) }), _react2['default'].createElement('button', { className: 'icon-refresh', onClick: (0, _store.bind)((0, _actionsFilesView.refresh)()) }), _react2['default'].createElement('button', { className: 'icon-select', onClick: (0, _store.bind)((0, _actionsFilesView.selectView)('toggle')) }), _react2['default'].createElement('button', { className: 'icon-more', onClick: this.showMore.bind(this), ref: 'more' }) @@ -23708,7 +31435,7 @@ var Toolbar = (function (_Component) { exports['default'] = Toolbar; module.exports = exports['default']; -},{"./menu":231,"actions/dialog":216,"actions/files-view":218,"actions/menu":220,"react":205,"store":"store"}],235:[function(require,module,exports){ +},{"./menu":233,"actions/dialog":218,"actions/files-view":220,"actions/menu":221,"react":207,"store":"store"}],239:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23725,6 +31452,8 @@ var _actionsDialog = require('actions/dialog'); var _actionsFile = require('actions/file'); +var _actionsFilesView = require('actions/files-view'); + var _store = require('store'); var _store2 = _interopRequireDefault(_store); @@ -23788,7 +31517,7 @@ exports['default'] = { text: 'Yes', action: function action() { var activeFile = _store2['default'].getState().get('activeFile'); - this.props.dispatch((0, _actionsFile.deleteFile)(activeFile)); + this.props.dispatch((0, _actionsFile.remove)(activeFile)); this.props.dispatch((0, _actionsDialog.hideAll)()); this.props.dispatch((0, _actionsFile.active)()); }, @@ -23801,11 +31530,29 @@ exports['default'] = { text: 'Continue', action: (0, _store.bind)((0, _actionsDialog.hideAll)()) }] + }, + searchDialog: { + title: 'Search', + description: 'Enter keywords to search for', + input: true, + buttons: [{ + text: 'Cancel', + action: (0, _store.bind)((0, _actionsDialog.hideAll)()) + }, { + text: 'Search', + action: function action() { + var input = _react2['default'].findDOMNode(this.refs.input); + + var action = (0, _actionsFilesView.search)(input.value); + this.props.dispatch(action); + this.props.dispatch((0, _actionsDialog.hideAll)()); + } + }] } }; module.exports = exports['default']; -},{"actions/dialog":216,"actions/file":217,"react":205,"store":"store"}],236:[function(require,module,exports){ +},{"actions/dialog":218,"actions/file":219,"actions/files-view":220,"react":207,"store":"store"}],240:[function(require,module,exports){ 'use strict'; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } @@ -23833,7 +31580,7 @@ _react2['default'].render(_react2['default'].createElement( } ), wrapper); -},{"components/root":233,"react":205,"react-redux":45,"store":"store"}],237:[function(require,module,exports){ +},{"components/root":236,"react":207,"react-redux":47,"store":"store"}],241:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23846,6 +31593,10 @@ var _actionsMenu = require('actions/menu'); var _actionsDialog = require('actions/dialog'); +var _actionsFilesView = require('actions/files-view'); + +var _actionsFile = require('actions/file'); + var _store = require('store'); var _store2 = _interopRequireDefault(_store); @@ -23856,8 +31607,7 @@ var entryMenu = { action: function action() { var files = _store2['default'].getState().get('files'); var active = _store2['default'].getState().get('activeFile'); - var name = files[active].name; - var description = 'Are you sure you want to remove ' + name + '?'; + var description = 'Enter the new name for ' + active[0].name + '?'; _store2['default'].dispatch((0, _actionsMenu.hideAll)()); _store2['default'].dispatch((0, _actionsDialog.show)('renameDialog', { description: description })); @@ -23867,11 +31617,16 @@ var entryMenu = { action: function action() { var files = _store2['default'].getState().get('files'); var active = _store2['default'].getState().get('activeFile'); - var name = files[active].name; - var description = 'Are you sure you want to remove ' + name + '?'; + var description = 'Are you sure you want to remove ' + active[0].name + '?'; _store2['default'].dispatch((0, _actionsMenu.hideAll)()); _store2['default'].dispatch((0, _actionsDialog.show)('deleteDialog', { description: description })); } + }, { + name: 'Copy', + action: function action() { + _store2['default'].dispatch((0, _actionsFilesView.selectView)(false)); + _store2['default'].dispatch((0, _actionsMenu.hideAll)()); + } }] }; @@ -23883,16 +31638,52 @@ var moreMenu = { var active = _store2['default'].getState().get('activeFile'); var description = undefined; - if (active.length) { + if (active.length > 1) { var count = active.length; description = 'Are you sure you want to remove ' + count + ' files?'; } else { - var _name = files[active].name; + var _name = active[0].name; description = 'Are you sure you want to remove ' + _name + '?'; } _store2['default'].dispatch((0, _actionsMenu.hideAll)()); _store2['default'].dispatch((0, _actionsDialog.show)('deleteDialog', { description: description })); + }, + enabled: function enabled() { + return _store2['default'].getState().get('activeFile'); + } + }, { + name: 'Copy', + action: function action() { + _store2['default'].dispatch((0, _actionsFilesView.selectView)(false)); + _store2['default'].dispatch((0, _actionsMenu.hideAll)()); + }, + enabled: function enabled() { + return _store2['default'].getState().get('activeFile'); + } + }, { + name: 'Paste', + enabled: function enabled() { + return _store2['default'].getState().get('activeFile'); + }, + action: function action() { + var active = _store2['default'].getState().get('activeFile'); + var cwd = _store2['default'].getState().get('cwd'); + + _store2['default'].dispatch((0, _actionsFile.copy)(active, cwd)); + _store2['default'].dispatch((0, _actionsMenu.hideAll)()); + } + }, { + name: 'Move', + enabled: function enabled() { + return _store2['default'].getState().get('activeFile'); + }, + action: function action() { + var active = _store2['default'].getState().get('activeFile'); + var cwd = _store2['default'].getState().get('cwd'); + + _store2['default'].dispatch((0, _actionsFile.move)(active, cwd)); + _store2['default'].dispatch((0, _actionsMenu.hideAll)()); } }] }; @@ -23904,7 +31695,7 @@ exports['default'] = { }; module.exports = exports['default']; -},{"actions/dialog":216,"actions/menu":220,"store":"store"}],238:[function(require,module,exports){ +},{"actions/dialog":218,"actions/file":219,"actions/files-view":220,"actions/menu":221,"store":"store"}],242:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23925,7 +31716,7 @@ exports['default'] = function (state, action) { module.exports = exports['default']; -},{"actions/types":223}],239:[function(require,module,exports){ +},{"actions/types":225}],243:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -23974,6 +31765,14 @@ var _selectView = require('./select-view'); var _selectView2 = _interopRequireDefault(_selectView); +var _spinner = require('./spinner'); + +var _spinner2 = _interopRequireDefault(_spinner); + +var _search = require('./search'); + +var _search2 = _interopRequireDefault(_search); + exports['default'] = function (state, action) { if (state === undefined) state = new _immutable2['default'].Map(); @@ -23982,6 +31781,8 @@ exports['default'] = function (state, action) { lwd: (0, _lwd2['default'])(state, action), // last working directory cwd: (0, _cwd2['default'])(state.get('cwd'), action), files: (0, _files2['default'])(state.get('files'), action), + search: (0, _search2['default'])(state.get('search'), action), + spinner: (0, _spinner2['default'])(state.get('spinner'), action), selectView: (0, _selectView2['default'])(state.get('selectView'), action), activeFile: (0, _activeFile2['default'])(state.get('activeFile'), action), navigation: (0, _navigation2['default'])(state.get('navigation'), action), @@ -23992,13 +31793,14 @@ exports['default'] = function (state, action) { renameDialog: (0, _dialog2['default'])(state, action, 'renameDialog'), deleteDialog: (0, _dialog2['default'])(state, action, 'deleteDialog'), errorDialog: (0, _dialog2['default'])(state, action, 'errorDialog'), - createDialog: (0, _dialog2['default'])(state, action, 'createDialog') + createDialog: (0, _dialog2['default'])(state, action, 'createDialog'), + searchDialog: (0, _dialog2['default'])(state, action, 'searchDialog') }); }; module.exports = exports['default']; -},{"./active-file":238,"./cwd":240,"./dialog":241,"./files":242,"./lwd":243,"./menu":244,"./navigation":245,"./select-view":246,"./settings":247,"immutable":248}],240:[function(require,module,exports){ +},{"./active-file":242,"./cwd":244,"./dialog":245,"./files":246,"./lwd":247,"./menu":248,"./navigation":249,"./search":250,"./select-view":251,"./settings":252,"./spinner":253,"immutable":3}],244:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24009,10 +31811,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'd var _actionsTypes = require('actions/types'); -var _actionsListFiles = require('actions/list-files'); - -var _actionsListFiles2 = _interopRequireDefault(_actionsListFiles); - var _apiFiles = require('api/files'); var _store = require('store'); @@ -24021,6 +31819,8 @@ var _store2 = _interopRequireDefault(_store); var _utils = require('utils'); +var _actionsFilesView = require('actions/files-view'); + exports['default'] = function (state, action) { if (state === undefined) state = ''; @@ -24041,12 +31841,12 @@ exports['default'] = function (state, action) { function changeTo(dir) { (0, _apiFiles.children)(dir, true).then(function (files) { - _store2['default'].dispatch((0, _actionsListFiles2['default'])(files)); + _store2['default'].dispatch((0, _actionsFilesView.listFiles)(files)); }, _utils.reportError); } module.exports = exports['default']; -},{"actions/list-files":219,"actions/types":223,"api/files":224,"store":"store","utils":"utils"}],241:[function(require,module,exports){ +},{"actions/files-view":220,"actions/types":225,"api/files":226,"store":"store","utils":"utils"}],245:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24088,7 +31888,7 @@ exports['default'] = function (state, action, id) { module.exports = exports['default']; -},{"actions/types":223,"immutable":248,"lodash/object/omit":37}],242:[function(require,module,exports){ +},{"actions/types":225,"immutable":3,"lodash/object/omit":39}],246:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24117,23 +31917,37 @@ exports['default'] = function (state, action) { if (state === undefined) state = []; if (action.type === _actionsTypes.LIST_FILES) { + var _ret = (function () { + var settings = _store2['default'].getState().get('settings'); - var settings = _store2['default'].getState().get('settings'); + if (settings.showDirectoriesFirst) { + action.files = action.files.sort(function (a, b) { + if ((0, _utils.type)(a) === 'Directory') return -1; + if ((0, _utils.type)(a) === 'File') return 1; + }); + } - if (settings.showDirectoriesFirst) { - action.files = action.files.sort(function (a, b) { - if ((0, _utils.type)(a) === 'Directory') return -1; - if ((0, _utils.type)(a) === 'File') return 1; - }); - } + if (!settings.showHiddenFiles) { + action.files = action.files.filter(function (file) { + return file.name[0] !== '.'; + }); + } - if (!settings.showHiddenFiles) { - action.files = action.files.filter(function (file) { - return file.name[0] !== '.'; - }); - } + if (settings.filter) { + action.files = action.files.filter(function (file) { + if ((0, _utils.type)(file) === 'Directory') return true; - return action.files; + var fileType = file.type.slice(0, file.type.indexOf('/')); + return fileType === settings.filter; + }); + } + + return { + v: action.files + }; + })(); + + if (typeof _ret === 'object') return _ret.v; } if (action.type === _actionsTypes.CREATE_FILE) { @@ -24144,63 +31958,51 @@ exports['default'] = function (state, action) { } if (action.type === _actionsTypes.RENAME_FILE) { - var file = state[action.file]; + var all = Promise.all(action.file.map(function (file) { + return (0, _apiFiles.move)(file, (file.path || '') + action.name); + })); - (0, _apiFiles.move)(file, (file.path || '') + action.name).then(boundRefresh, _utils.reportError); + all.then(boundRefresh, _utils.reportError); + return state; + } + if (action.type === _actionsTypes.MOVE_FILE) { + var all = Promise.all(action.file.map(function (file) { + return (0, _apiFiles.move)(file, action.newPath + '/' + file.name); + })); + + all.then(boundRefresh, _utils.reportError); + return state; + } + + if (action.type === _actionsTypes.COPY_FILE) { + var all = Promise.all(action.file.map(function (file) { + return (0, _apiFiles.copy)(file, action.newPath + '/' + file.name); + })); + + all.then(boundRefresh, _utils.reportError); return state; } if (action.type === _actionsTypes.DELETE_FILE) { - var copy = state.slice(0); + var all = Promise.all(action.file.map(function (file) { + var path = ((file.path || '') + file.name).replace(/^\//, ''); + return (0, _apiFiles.remove)(path, true); + })); - if (action.file.length) { - var _iteratorNormalCompletion = true; - var _didIteratorError = false; - var _iteratorError = undefined; - - try { - for (var _iterator = action.file[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { - var index = _step.value; - - del(state, index); - } - } catch (err) { - _didIteratorError = true; - _iteratorError = err; - } finally { - try { - if (!_iteratorNormalCompletion && _iterator['return']) { - _iterator['return'](); - } - } finally { - if (_didIteratorError) { - throw _iteratorError; - } - } - } - - copy = copy.filter(function (a, i) { - return action.file.indexOf(i) === -1; - }); - } else { - del(state, action.file); - copy.splice(action.file, 1); - } - - return copy; + all.then(boundRefresh, _utils.reportError); + return state; } return state; }; -function del(state, index) { - var file = state[index]; - return (0, _apiFiles.remove)((file.path || '') + '/' + file.name)['catch'](_utils.reportError); +function mov(file, newPath) { + return; } module.exports = exports['default']; -},{"actions/dialog":216,"actions/files-view":218,"actions/types":223,"api/files":224,"store":"store","utils":"utils"}],243:[function(require,module,exports){ +},{"actions/dialog":218,"actions/files-view":220,"actions/types":225,"api/files":226,"store":"store","utils":"utils"}],247:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24220,7 +32022,7 @@ exports['default'] = function (state, action) { module.exports = exports['default']; -},{"actions/types":223}],244:[function(require,module,exports){ +},{"actions/types":225}],248:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24262,7 +32064,7 @@ exports['default'] = function (state, action, id) { module.exports = exports['default']; -},{"actions/types":223,"immutable":248,"lodash/object/omit":37}],245:[function(require,module,exports){ +},{"actions/types":225,"immutable":3,"lodash/object/omit":39}],249:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24283,7 +32085,75 @@ exports['default'] = function (state, action) { module.exports = exports['default']; -},{"actions/types":223}],246:[function(require,module,exports){ +},{"actions/types":225}],250:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var _actionsTypes = require('actions/types'); + +var _store = require('store'); + +var _store2 = _interopRequireDefault(_store); + +var _utils = require('utils'); + +var _actionsFilesView = require('actions/files-view'); + +var _apiFiles = require('api/files'); + +exports['default'] = function (state, action) { + if (state === undefined) state = ''; + + if (action.type === _actionsTypes.SEARCH) { + search(action.keywords); + + return action.keywords; + } + + return state; +}; + +function search(keywords) { + if (!keywords) { + var cwd = _store2['default'].getState().get('cwd'); + console.log(cwd); + (0, _apiFiles.children)(cwd, true).then(function (files) { + _store2['default'].dispatch((0, _actionsFilesView.listFiles)(files)); + }, _utils.reportError); + return ''; + } + var keys = keywords.split(' '); + + // We don't want to show all the currently visible files from the + // first iteration + var once = true; + (0, _apiFiles.children)('/', true).then(function showResults(files) { + if (!_store2['default'].getState().get('search')) return; + + var current = once ? [] : _store2['default'].getState().get('files'); + once = false; + + var filtered = files.filter(function (file) { + if ((0, _utils.type)(file) === 'Directory') { + var path = (file.path + file.name).replace(/^\//, ''); + (0, _apiFiles.children)(path, true).then(showResults, _utils.reportError); + } + return keys.some(function (key) { + return file.name.indexOf(key) > -1; + }); + }); + + _store2['default'].dispatch((0, _actionsFilesView.listFiles)(current.concat(filtered))); + }, _utils.reportError); +} +module.exports = exports['default']; + +},{"actions/files-view":220,"actions/types":225,"api/files":226,"store":"store","utils":"utils"}],251:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24304,7 +32174,7 @@ exports['default'] = function (state, action) { module.exports = exports['default']; -},{"actions/types":223}],247:[function(require,module,exports){ +},{"actions/types":225}],252:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -24336,4935 +32206,40 @@ exports['default'] = function (state, action) { module.exports = exports['default']; -},{"actions/types":223,"lodash/object/omit":37}],248:[function(require,module,exports){ -/** - * Copyright (c) 2014-2015, 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 (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : - typeof define === 'function' && define.amd ? define(factory) : - global.Immutable = factory() -}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice; +},{"actions/types":225,"lodash/object/omit":39}],253:[function(require,module,exports){ +'use strict'; - function createClass(ctor, superClass) { - if (superClass) { - ctor.prototype = Object.create(superClass.prototype); - } - ctor.prototype.constructor = ctor; +Object.defineProperty(exports, '__esModule', { + value: true +}); + +var _actionsTypes = require('actions/types'); + +exports['default'] = function (state, action) { + if (state === undefined) state = false; + + if (action.type === _actionsTypes.SPINNER) { + return action.active === 'toggle' ? !state : action.active; } - // Used for setting prototype methods that IE8 chokes on. - var DELETE = 'delete'; - - // Constants describing the size of trie nodes. - var SHIFT = 5; // Resulted in best performance after ______? - var SIZE = 1 << SHIFT; - var MASK = SIZE - 1; - - // A consistent shared value representing "not set" which equals nothing other - // than itself, and nothing that could be provided externally. - var NOT_SET = {}; - - // Boolean references, Rough equivalent of `bool &`. - 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); - } - - // A function which returns a value representing an "owner" for transient writes - // to tries. The return value will only ever equal itself, and will not equal - // the return of any subsequent call of this function. - function OwnerID() {} - - // http://jsperf.com/copy-array-inline - 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 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 Iterable(value) { - return isIterable(value) ? value : Seq(value); - } - - - createClass(KeyedIterable, Iterable); - function KeyedIterable(value) { - return isKeyed(value) ? value : KeyedSeq(value); - } - - - createClass(IndexedIterable, Iterable); - function IndexedIterable(value) { - return isIndexed(value) ? value : IndexedSeq(value); - } - - - createClass(SetIterable, Iterable); - function SetIterable(value) { - return isIterable(value) && !isAssociative(value) ? value : SetSeq(value); - } - - - - 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); - } - - function isOrdered(maybeOrdered) { - return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]); - } - - Iterable.isIterable = isIterable; - Iterable.isKeyed = isKeyed; - Iterable.isIndexed = isIndexed; - Iterable.isAssociative = isAssociative; - Iterable.isOrdered = isOrdered; - - Iterable.Keyed = KeyedIterable; - Iterable.Indexed = IndexedIterable; - Iterable.Set = SetIterable; - - - var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@'; - var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; - var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@'; - var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@'; - - /* global Symbol */ - - var ITERATE_KEYS = 0; - var ITERATE_VALUES = 1; - var ITERATE_ENTRIES = 2; - - var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; - var FAUX_ITERATOR_SYMBOL = '@@iterator'; - - var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL; - - - function src_Iterator__Iterator(next) { - this.next = next; - } - - src_Iterator__Iterator.prototype.toString = function() { - return '[Iterator]'; - }; - - - src_Iterator__Iterator.KEYS = ITERATE_KEYS; - src_Iterator__Iterator.VALUES = ITERATE_VALUES; - src_Iterator__Iterator.ENTRIES = ITERATE_ENTRIES; - - src_Iterator__Iterator.prototype.inspect = - src_Iterator__Iterator.prototype.toSource = function () { return this.toString(); } - src_Iterator__Iterator.prototype[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 !!getIteratorFn(maybeIterable); - } - - function isIterator(maybeIterator) { - return maybeIterator && typeof maybeIterator.next === 'function'; - } - - function getIterator(iterable) { - var iteratorFn = getIteratorFn(iterable); - return iteratorFn && iteratorFn.call(iterable); - } - - function getIteratorFn(iterable) { - var iteratorFn = iterable && ( - (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) || - iterable[FAUX_ITERATOR_SYMBOL] - ); - if (typeof iteratorFn === 'function') { - return iteratorFn; - } - } - - function isArrayLike(value) { - return value && typeof value.length === 'number'; - } - - createClass(Seq, Iterable); - function Seq(value) { - return value === null || value === undefined ? emptySequence() : - isIterable(value) ? value.toSeq() : seqFromValue(value); - } - - Seq.of = function(/*...values*/) { - return Seq(arguments); - }; - - Seq.prototype.toSeq = function() { - return this; - }; - - Seq.prototype.toString = function() { - return this.__toString('Seq {', '}'); - }; - - Seq.prototype.cacheResult = function() { - if (!this._cache && this.__iterateUncached) { - this._cache = this.entrySeq().toArray(); - this.size = this._cache.length; - } - return this; - }; - - // abstract __iterateUncached(fn, reverse) - - Seq.prototype.__iterate = function(fn, reverse) { - return seqIterate(this, fn, reverse, true); - }; - - // abstract __iteratorUncached(type, reverse) - - Seq.prototype.__iterator = function(type, reverse) { - return seqIterator(this, type, reverse, true); - }; - - - - createClass(KeyedSeq, Seq); - function KeyedSeq(value) { - return value === null || value === undefined ? - emptySequence().toKeyedSeq() : - isIterable(value) ? - (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) : - keyedSeqFromValue(value); - } - - KeyedSeq.prototype.toKeyedSeq = function() { - return this; - }; - - - - createClass(IndexedSeq, Seq); - function IndexedSeq(value) { - return value === null || value === undefined ? emptySequence() : - !isIterable(value) ? indexedSeqFromValue(value) : - isKeyed(value) ? value.entrySeq() : value.toIndexedSeq(); - } - - IndexedSeq.of = function(/*...values*/) { - return IndexedSeq(arguments); - }; - - IndexedSeq.prototype.toIndexedSeq = function() { - return this; - }; - - IndexedSeq.prototype.toString = function() { - return this.__toString('Seq [', ']'); - }; - - IndexedSeq.prototype.__iterate = function(fn, reverse) { - return seqIterate(this, fn, reverse, false); - }; - - IndexedSeq.prototype.__iterator = function(type, reverse) { - return seqIterator(this, type, reverse, false); - }; - - - - createClass(SetSeq, Seq); - function SetSeq(value) { - return ( - value === null || value === undefined ? emptySequence() : - !isIterable(value) ? indexedSeqFromValue(value) : - isKeyed(value) ? value.entrySeq() : value - ).toSetSeq(); - } - - SetSeq.of = function(/*...values*/) { - return SetSeq(arguments); - }; - - SetSeq.prototype.toSetSeq = function() { - return this; - }; - - - - Seq.isSeq = isSeq; - Seq.Keyed = KeyedSeq; - Seq.Set = SetSeq; - Seq.Indexed = IndexedSeq; - - var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@'; - - Seq.prototype[IS_SEQ_SENTINEL] = true; - - - - // #pragma Root Sequences - - createClass(ArraySeq, IndexedSeq); - function ArraySeq(array) { - this._array = array; - this.size = array.length; - } - - ArraySeq.prototype.get = function(index, notSetValue) { - return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue; - }; - - ArraySeq.prototype.__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; - }; - - ArraySeq.prototype.__iterator = function(type, reverse) { - var array = this._array; - var maxIndex = array.length - 1; - var ii = 0; - return new src_Iterator__Iterator(function() - {return ii > maxIndex ? - iteratorDone() : - iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])} - ); - }; - - - - createClass(ObjectSeq, KeyedSeq); - function ObjectSeq(object) { - var keys = Object.keys(object); - this._object = object; - this._keys = keys; - this.size = keys.length; - } - - ObjectSeq.prototype.get = function(key, notSetValue) { - if (notSetValue !== undefined && !this.has(key)) { - return notSetValue; - } - return this._object[key]; - }; - - ObjectSeq.prototype.has = function(key) { - return this._object.hasOwnProperty(key); - }; - - ObjectSeq.prototype.__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; - }; - - ObjectSeq.prototype.__iterator = function(type, reverse) { - var object = this._object; - var keys = this._keys; - var maxIndex = keys.length - 1; - var ii = 0; - return new src_Iterator__Iterator(function() { - var key = keys[reverse ? maxIndex - ii : ii]; - return ii++ > maxIndex ? - iteratorDone() : - iteratorValue(type, key, object[key]); - }); - }; - - ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true; - - - createClass(IterableSeq, IndexedSeq); - function IterableSeq(iterable) { - this._iterable = iterable; - this.size = iterable.length || iterable.size; - } - - IterableSeq.prototype.__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; - }; - - IterableSeq.prototype.__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 src_Iterator__Iterator(iteratorDone); - } - var iterations = 0; - return new src_Iterator__Iterator(function() { - var step = iterator.next(); - return step.done ? step : iteratorValue(type, iterations++, step.value); - }); - }; - - - - createClass(IteratorSeq, IndexedSeq); - function IteratorSeq(iterator) { - this._iterator = iterator; - this._iteratorCache = []; - } - - IteratorSeq.prototype.__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; - }; - - IteratorSeq.prototype.__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 src_Iterator__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++]); - }); - }; - - - - - // # pragma Helper functions - - 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 seqIterate(seq, fn, reverse, useKeys) { - 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 src_Iterator__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); - } - - createClass(Collection, Iterable); - function Collection() { - throw TypeError('Abstract'); - } - - - createClass(KeyedCollection, Collection);function KeyedCollection() {} - - createClass(IndexedCollection, Collection);function IndexedCollection() {} - - createClass(SetCollection, Collection);function SetCollection() {} - - - Collection.Keyed = KeyedCollection; - Collection.Indexed = IndexedCollection; - Collection.Set = SetCollection; - - /** - * An extension of the "same-value" algorithm as [described for use by ES6 Map - * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality) - * - * NaN is considered the same as NaN, however -0 and 0 are considered the same - * value, which is different from the algorithm described by - * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). - * - * This is extended further to allow Objects to describe the values they - * represent, by way of `valueOf` or `equals` (and `hashCode`). - * - * Note: because of this extension, the key equality of Immutable.Map and the - * value equality of Immutable.Set will differ from ES6 Map and Set. - * - * ### Defining custom values - * - * The easiest way to describe the value an object represents is by implementing - * `valueOf`. For example, `Date` represents a value by returning a unix - * timestamp for `valueOf`: - * - * var date1 = new Date(1234567890000); // Fri Feb 13 2009 ... - * var date2 = new Date(1234567890000); - * date1.valueOf(); // 1234567890000 - * assert( date1 !== date2 ); - * assert( Immutable.is( date1, date2 ) ); - * - * Note: overriding `valueOf` may have other implications if you use this object - * where JavaScript expects a primitive, such as implicit string coercion. - * - * For more complex types, especially collections, implementing `valueOf` may - * not be performant. An alternative is to implement `equals` and `hashCode`. - * - * `equals` takes another object, presumably of similar type, and returns true - * if the it is equal. Equality is symmetrical, so the same result should be - * returned if this and the argument are flipped. - * - * assert( a.equals(b) === b.equals(a) ); - * - * `hashCode` returns a 32bit integer number representing the object which will - * be used to determine how to store the value object in a Map or Set. You must - * provide both or neither methods, one must not exist without the other. - * - * Also, an important relationship between these methods must be upheld: if two - * values are equal, they *must* return the same hashCode. If the values are not - * equal, they might have the same hashCode; this is called a hash collision, - * and while undesirable for performance reasons, it is acceptable. - * - * if (a.equals(b)) { - * assert( a.hashCode() === b.hashCode() ); - * } - * - * All Immutable collections implement `equals` and `hashCode`. - * - */ - function is(valueA, valueB) { - if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { - return true; - } - if (!valueA || !valueB) { - return false; - } - if (typeof valueA.valueOf === 'function' && - typeof valueB.valueOf === 'function') { - valueA = valueA.valueOf(); - valueB = valueB.valueOf(); - if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) { - return true; - } - if (!valueA || !valueB) { - return false; - } - } - if (typeof valueA.equals === 'function' && - typeof valueB.equals === 'function' && - valueA.equals(valueB)) { - return true; - } + if (action.type === _actionsTypes.DIALOG && action.id === 'errorDialog') { return false; } - 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 || value.constructor === undefined); - } - - var src_Math__imul = - typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ? - Math.imul : - function src_Math__imul(a, b) { - a = a | 0; // int - b = b | 0; // int - var c = a & 0xffff; - var d = b & 0xffff; - // Shift by 0 fixes the sign on the high part. - return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int - }; - - // v8 has an optimization for storing 31-bit signed numbers. - // Values which have either 00 or 11 as the high order bits qualify. - // This function drops the highest order bit in a signed number, maintaining - // the sign bit. - function smi(i32) { - return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF); - } - - function hash(o) { - if (o === false || o === null || o === undefined) { - return 0; - } - if (typeof o.valueOf === 'function') { - o = o.valueOf(); - if (o === false || o === null || o === undefined) { - return 0; - } - } - if (o === true) { - return 1; - } - var type = typeof o; - if (type === 'number') { - var h = o | 0; - if (h !== o) { - h ^= o * 0xFFFFFFFF; - } - while (o > 0xFFFFFFFF) { - o /= 0xFFFFFFFF; - h ^= o; - } - return smi(h); - } - if (type === 'string') { - return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o); - } - if (typeof o.hashCode === 'function') { - return 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; - } - - // http://jsperf.com/hashing-strings - function hashString(string) { - // This is the hash from JVM - // The hash code for a string is computed as - // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1], - // where s[i] is the ith character of the string and n is the length of - // the string. We "mod" the result to make it between 0 (inclusive) and 2^31 - // (exclusive) by dropping high bits. - var hash = 0; - for (var ii = 0; ii < string.length; ii++) { - hash = 31 * hash + string.charCodeAt(ii) | 0; - } - return smi(hash); - } - - function hashJSObj(obj) { - var hash; - if (usingWeakMap) { - hash = weakMap.get(obj); - if (hash !== undefined) { - return hash; - } - } - - hash = obj[UID_HASH_KEY]; - if (hash !== undefined) { - return hash; - } - - if (!canDefineProperty) { - hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY]; - if (hash !== undefined) { - return hash; - } - - hash = getIENodeHash(obj); - if (hash !== undefined) { - return hash; - } - } - - hash = ++objHashUID; - if (objHashUID & 0x40000000) { - objHashUID = 0; - } - - if (usingWeakMap) { - weakMap.set(obj, hash); - } else if (isExtensible !== undefined && isExtensible(obj) === false) { - throw new Error('Non-extensible objects are not allowed as keys.'); - } else if (canDefineProperty) { - Object.defineProperty(obj, UID_HASH_KEY, { - 'enumerable': false, - 'configurable': false, - 'writable': false, - 'value': hash - }); - } else if (obj.propertyIsEnumerable !== undefined && - obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) { - // Since we can't define a non-enumerable property on the object - // we'll hijack one of the less-used non-enumerable properties to - // save our hash on it. Since this is a function it will not show up in - // `JSON.stringify` which is what we want. - obj.propertyIsEnumerable = function() { - return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments); - }; - obj.propertyIsEnumerable[UID_HASH_KEY] = hash; - } else if (obj.nodeType !== undefined) { - // At this point we couldn't get the IE `uniqueID` to use as a hash - // and we couldn't use a non-enumerable property to exploit the - // dontEnum bug so we simply add the `UID_HASH_KEY` on the node - // itself. - obj[UID_HASH_KEY] = hash; - } else { - throw new Error('Unable to set a non-enumerable property on object.'); - } - - return hash; - } - - // Get references to ES5 object methods. - var isExtensible = Object.isExtensible; - - // True if Object.defineProperty works as expected. IE8 fails this test. - var canDefineProperty = (function() { - try { - Object.defineProperty({}, '@', {}); + switch (action.type) { + case _actionsTypes.CHANGE_DIRECTORY: + case _actionsTypes.REFRESH: return true; - } catch (e) { + case _actionsTypes.LIST_FILES: return false; - } - }()); - - // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it - // and avoid memory leaks from the IE cloneNode bug. - function getIENodeHash(node) { - if (node && node.nodeType > 0) { - switch (node.nodeType) { - case 1: // Element - return node.uniqueID; - case 9: // Document - return node.documentElement && node.documentElement.uniqueID; - } - } - } - - // If possible, use a WeakMap. - var usingWeakMap = typeof WeakMap === 'function'; - var weakMap; - if (usingWeakMap) { - weakMap = new WeakMap(); - } - - 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 = {}; - - function invariant(condition, error) { - if (!condition) throw new Error(error); - } - - function assertNotInfinite(size) { - invariant( - size !== Infinity, - 'Cannot perform this action with an infinite size.' - ); - } - - createClass(ToKeyedSequence, KeyedSeq); - function ToKeyedSequence(indexed, useKeys) { - this._iter = indexed; - this._useKeys = useKeys; - this.size = indexed.size; - } - - ToKeyedSequence.prototype.get = function(key, notSetValue) { - return this._iter.get(key, notSetValue); - }; - - ToKeyedSequence.prototype.has = function(key) { - return this._iter.has(key); - }; - - ToKeyedSequence.prototype.valueSeq = function() { - return this._iter.valueSeq(); - }; - - ToKeyedSequence.prototype.reverse = function() {var this$0 = this; - var reversedSequence = reverseFactory(this, true); - if (!this._useKeys) { - reversedSequence.valueSeq = function() {return this$0._iter.toSeq().reverse()}; - } - return reversedSequence; - }; - - ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this; - var mappedSequence = mapFactory(this, mapper, context); - if (!this._useKeys) { - mappedSequence.valueSeq = function() {return this$0._iter.toSeq().map(mapper, context)}; - } - return mappedSequence; - }; - - ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; - var ii; - return this._iter.__iterate( - this._useKeys ? - function(v, k) {return fn(v, k, this$0)} : - ((ii = reverse ? resolveSize(this) : 0), - function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}), - reverse - ); - }; - - ToKeyedSequence.prototype.__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 src_Iterator__Iterator(function() { - var step = iterator.next(); - return step.done ? step : - iteratorValue(type, reverse ? --ii : ii++, step.value, step); - }); - }; - - ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true; - - - createClass(ToIndexedSequence, IndexedSeq); - function ToIndexedSequence(iter) { - this._iter = iter; - this.size = iter.size; - } - - ToIndexedSequence.prototype.includes = function(value) { - return this._iter.includes(value); - }; - - ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; - var iterations = 0; - return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse); - }; - - ToIndexedSequence.prototype.__iterator = function(type, reverse) { - var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); - var iterations = 0; - return new src_Iterator__Iterator(function() { - var step = iterator.next(); - return step.done ? step : - iteratorValue(type, iterations++, step.value, step) - }); - }; - - - - createClass(ToSetSequence, SetSeq); - function ToSetSequence(iter) { - this._iter = iter; - this.size = iter.size; - } - - ToSetSequence.prototype.has = function(key) { - return this._iter.includes(key); - }; - - ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; - return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse); - }; - - ToSetSequence.prototype.__iterator = function(type, reverse) { - var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); - return new src_Iterator__Iterator(function() { - var step = iterator.next(); - return step.done ? step : - iteratorValue(type, step.value, step.value, step); - }); - }; - - - - createClass(FromEntriesSequence, KeyedSeq); - function FromEntriesSequence(entries) { - this._iter = entries; - this.size = entries.size; - } - - FromEntriesSequence.prototype.entrySeq = function() { - return this._iter.toSeq(); - }; - - FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this; - return this._iter.__iterate(function(entry ) { - // Check if entry exists first so array access doesn't throw for holes - // in the parent iteration. - if (entry) { - validateEntry(entry); - var indexedIterable = isIterable(entry); - return fn( - indexedIterable ? entry.get(1) : entry[1], - indexedIterable ? entry.get(0) : entry[0], - this$0 - ); - } - }, reverse); - }; - - FromEntriesSequence.prototype.__iterator = function(type, reverse) { - var iterator = this._iter.__iterator(ITERATE_VALUES, reverse); - return new src_Iterator__Iterator(function() { - while (true) { - var step = iterator.next(); - if (step.done) { - return step; - } - var entry = step.value; - // Check if entry exists first so array access doesn't throw for holes - // in the parent iteration. - if (entry) { - validateEntry(entry); - var indexedIterable = isIterable(entry); - return iteratorValue( - type, - indexedIterable ? entry.get(0) : entry[0], - indexedIterable ? entry.get(1) : entry[1], - step - ); - } - } - }); - }; - - - 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); // super.reverse() - reversedSequence.flip = function() {return iterable.reverse()}; - return reversedSequence; - }; - flipSequence.has = function(key ) {return iterable.includes(key)}; - flipSequence.includes = function(key ) {return iterable.has(key)}; - flipSequence.cacheResult = cacheResultThrough; - flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this; - return iterable.__iterate(function(v, k) {return fn(k, v, this$0) !== false}, reverse); - } - flipSequence.__iteratorUncached = function(type, reverse) { - if (type === ITERATE_ENTRIES) { - var iterator = iterable.__iterator(type, reverse); - return new src_Iterator__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 this$0 = this; - return iterable.__iterate( - function(v, k, c) {return fn(mapper.call(context, v, k, c), k, this$0) !== false}, - reverse - ); - } - mappedSequence.__iteratorUncached = function (type, reverse) { - var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); - return new src_Iterator__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.includes = function(value ) {return iterable.includes(value)}; - reversedSequence.cacheResult = cacheResultThrough; - reversedSequence.__iterate = function (fn, reverse) {var this$0 = this; - return iterable.__iterate(function(v, k) {return fn(v, k, this$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 this$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, this$0); - } - }, reverse); - return iterations; - }; - filterSequence.__iteratorUncached = function (type, reverse) { - var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); - var iterations = 0; - return new src_Iterator__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 = src_Map__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 = (isOrdered(iterable) ? OrderedMap() : src_Map__Map()).asMutable(); - iterable.__iterate(function(v, k) { - groups.update( - grouper.call(context, v, k, iterable), - function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)} - ); - }); - var coerce = iterableClass(iterable); - return groups.map(function(arr ) {return reify(iterable, coerce(arr))}); - } - - - function sliceFactory(iterable, begin, end, useKeys) { - var originalSize = iterable.size; - - if (wholeSlice(begin, end, originalSize)) { - return iterable; - } - - var resolvedBegin = resolveBegin(begin, originalSize); - var resolvedEnd = resolveEnd(end, originalSize); - - // begin or end will be NaN if they were provided as negative numbers and - // this iterable's size is unknown. In that case, cache first so there is - // a known size and these do not resolve to NaN. - if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) { - return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys); - } - - // Note: resolvedEnd is undefined when the original sequence's length is - // unknown and this slice did not supply an end and should contain all - // elements after resolvedBegin. - // In that case, resolvedSize will be NaN and sliceSize will remain undefined. - var resolvedSize = resolvedEnd - resolvedBegin; - var sliceSize; - if (resolvedSize === resolvedSize) { - sliceSize = resolvedSize < 0 ? 0 : resolvedSize; - } - - var sliceSeq = makeSequence(iterable); - - sliceSeq.size = sliceSize; - - if (!useKeys && isSeq(iterable) && sliceSize >= 0) { - sliceSeq.get = function (index, notSetValue) { - index = wrapIndex(this, index); - return index >= 0 && index < sliceSize ? - iterable.get(index + resolvedBegin, notSetValue) : - notSetValue; - } - } - - sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this; - if (sliceSize === 0) { - return 0; - } - 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++ < resolvedBegin))) { - iterations++; - return fn(v, useKeys ? k : iterations - 1, this$0) !== false && - iterations !== sliceSize; - } - }); - return iterations; - }; - - sliceSeq.__iteratorUncached = function(type, reverse) { - if (sliceSize !== 0 && reverse) { - return this.cacheResult().__iterator(type, reverse); - } - // Don't bother instantiating parent iterator if taking 0. - var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse); - var skipped = 0; - var iterations = 0; - return new src_Iterator__Iterator(function() { - while (skipped++ < resolvedBegin) { - iterator.next(); - } - if (++iterations > sliceSize) { - return iteratorDone(); - } - var step = iterator.next(); - if (useKeys || type === ITERATE_VALUES) { - return step; - } else if (type === ITERATE_KEYS) { - return iteratorValue(type, iterations - 1, undefined, step); - } else { - return iteratorValue(type, iterations - 1, step.value[1], step); - } - }); - } - - return sliceSeq; - } - - - function takeWhileFactory(iterable, predicate, context) { - var takeSequence = makeSequence(iterable); - takeSequence.__iterateUncached = function(fn, reverse) {var this$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, this$0)} - ); - return iterations; - }; - takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this; - if (reverse) { - return this.cacheResult().__iterator(type, reverse); - } - var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse); - var iterating = true; - return new src_Iterator__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, this$0)) { - iterating = false; - return iteratorDone(); - } - return type === ITERATE_ENTRIES ? step : - iteratorValue(type, k, v, step); - }); - }; - return takeSequence; - } - - - function skipWhileFactory(iterable, predicate, context, useKeys) { - var skipSequence = makeSequence(iterable); - skipSequence.__iterateUncached = function (fn, reverse) {var this$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, this$0); - } - }); - return iterations; - }; - skipSequence.__iteratorUncached = function(type, reverse) {var this$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 src_Iterator__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, this$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 = [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; - }).filter(function(v ) {return v.size !== 0}); - - if (iters.length === 0) { - return iterable; - } - - if (iters.length === 1) { - var singleton = iters[0]; - if (singleton === iterable || - isKeyedIterable && isKeyed(singleton) || - isIndexed(iterable) && isIndexed(singleton)) { - return singleton; - } - } - - var concatSeq = new ArraySeq(iters); - if (isKeyedIterable) { - concatSeq = concatSeq.toKeyedSeq(); - } else if (!isIndexed(iterable)) { - concatSeq = concatSeq.toSetSeq(); - } - concatSeq = concatSeq.flatten(true); - concatSeq.size = iters.reduce( - function(sum, seq) { - if (sum !== undefined) { - var size = seq.size; - if (size !== undefined) { - return sum + size; - } - } - }, - 0 - ); - return concatSeq; - } - - - 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 this$0 = this; - iter.__iterate(function(v, k) { - if ((!depth || currentDepth < depth) && isIterable(v)) { - flatDeep(v, currentDepth + 1); - } else if (fn(v, useKeys ? k : iterations++, this$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 src_Iterator__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 this$0 = this; - var iterations = 0; - iterable.__iterate(function(v, k) - {return (!iterations || fn(separator, iterations++, this$0) !== false) && - fn(v, iterations++, this$0) !== false}, - reverse - ); - return iterations; - }; - interposedSequence.__iteratorUncached = function(type, reverse) { - var iterator = iterable.__iterator(ITERATE_VALUES, reverse); - var iterations = 0; - var step; - return new src_Iterator__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(a, b) {return maxCompare(comparator, a[1], b[1]) ? b : a}); - return entry && entry[0]; - } else { - return iterable.reduce(function(a, b) {return maxCompare(comparator, a, b) ? b : a}); - } - } - - function maxCompare(comparator, a, b) { - var comp = comparator(b, a); - // b is considered the new max if the comparator declares them equal, but - // they are not equal and b is in fact a nullish value. - return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0; - } - - - function zipWithFactory(keyIter, zipper, iters) { - var zipSequence = makeSequence(keyIter); - zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min(); - // Note: this a generic base implementation of __iterate in terms of - // __iterator which may be more generically useful in the future. - zipSequence.__iterate = function(fn, reverse) { - /* generic: - var iterator = this.__iterator(ITERATE_ENTRIES, reverse); - var step; - var iterations = 0; - while (!(step = iterator.next()).done) { - iterations++; - if (fn(step.value[1], step.value[0], this) === false) { - break; - } - } - return iterations; - */ - // indexed: - var iterator = this.__iterator(ITERATE_VALUES, reverse); - var step; - var iterations = 0; - while (!(step = iterator.next()).done) { - if (fn(step.value, iterations++, this) === false) { - break; - } - } - return iterations; - }; - zipSequence.__iteratorUncached = function(type, reverse) { - var iterators = iters.map(function(i ) - {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))} - ); - var iterations = 0; - var isDone = false; - return new src_Iterator__Iterator(function() { - var steps; - if (!isDone) { - steps = iterators.map(function(i ) {return i.next()}); - isDone = steps.some(function(s ) {return s.done}); - } - if (isDone) { - return iteratorDone(); - } - return iteratorValue( - type, - iterations++, - zipper.apply(null, steps.map(function(s ) {return s.value})) - ); - }); - }; - return zipSequence - } - - - // #pragma Helper Functions - - 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; - } - - function forceIterator(keyPath) { - var iter = getIterator(keyPath); - if (!iter) { - // Array might not be iterable in this environment, so we need a fallback - // to our wrapped type. - if (!isArrayLike(keyPath)) { - throw new TypeError('Expected iterable or array-like: ' + keyPath); - } - iter = getIterator(Iterable(keyPath)); - } - return iter; - } - - createClass(src_Map__Map, KeyedCollection); - - // @pragma Construction - - function src_Map__Map(value) { - return value === null || value === undefined ? emptyMap() : - isMap(value) ? value : - emptyMap().withMutations(function(map ) { - var iter = KeyedIterable(value); - assertNotInfinite(iter.size); - iter.forEach(function(v, k) {return map.set(k, v)}); - }); - } - - src_Map__Map.prototype.toString = function() { - return this.__toString('Map {', '}'); - }; - - // @pragma Access - - src_Map__Map.prototype.get = function(k, notSetValue) { - return this._root ? - this._root.get(0, undefined, k, notSetValue) : - notSetValue; - }; - - // @pragma Modification - - src_Map__Map.prototype.set = function(k, v) { - return updateMap(this, k, v); - }; - - src_Map__Map.prototype.setIn = function(keyPath, v) { - return this.updateIn(keyPath, NOT_SET, function() {return v}); - }; - - src_Map__Map.prototype.remove = function(k) { - return updateMap(this, k, NOT_SET); - }; - - src_Map__Map.prototype.deleteIn = function(keyPath) { - return this.updateIn(keyPath, function() {return NOT_SET}); - }; - - src_Map__Map.prototype.update = function(k, notSetValue, updater) { - return arguments.length === 1 ? - k(this) : - this.updateIn([k], notSetValue, updater); - }; - - src_Map__Map.prototype.updateIn = function(keyPath, notSetValue, updater) { - if (!updater) { - updater = notSetValue; - notSetValue = undefined; - } - var updatedValue = updateInDeepMap( - this, - forceIterator(keyPath), - notSetValue, - updater - ); - return updatedValue === NOT_SET ? undefined : updatedValue; - }; - - src_Map__Map.prototype.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(); - }; - - // @pragma Composition - - src_Map__Map.prototype.merge = function(/*...iters*/) { - return mergeIntoMapWith(this, undefined, arguments); - }; - - src_Map__Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); - return mergeIntoMapWith(this, merger, iters); - }; - - src_Map__Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1); - return this.updateIn( - keyPath, - emptyMap(), - function(m ) {return typeof m.merge === 'function' ? - m.merge.apply(m, iters) : - iters[iters.length - 1]} - ); - }; - - src_Map__Map.prototype.mergeDeep = function(/*...iters*/) { - return mergeIntoMapWith(this, deepMerger(undefined), arguments); - }; - - src_Map__Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1); - return mergeIntoMapWith(this, deepMerger(merger), iters); - }; - - src_Map__Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1); - return this.updateIn( - keyPath, - emptyMap(), - function(m ) {return typeof m.mergeDeep === 'function' ? - m.mergeDeep.apply(m, iters) : - iters[iters.length - 1]} - ); - }; - - src_Map__Map.prototype.sort = function(comparator) { - // Late binding - return OrderedMap(sortFactory(this, comparator)); - }; - - src_Map__Map.prototype.sortBy = function(mapper, comparator) { - // Late binding - return OrderedMap(sortFactory(this, comparator, mapper)); - }; - - // @pragma Mutability - - src_Map__Map.prototype.withMutations = function(fn) { - var mutable = this.asMutable(); - fn(mutable); - return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this; - }; - - src_Map__Map.prototype.asMutable = function() { - return this.__ownerID ? this : this.__ensureOwner(new OwnerID()); - }; - - src_Map__Map.prototype.asImmutable = function() { - return this.__ensureOwner(); - }; - - src_Map__Map.prototype.wasAltered = function() { - return this.__altered; - }; - - src_Map__Map.prototype.__iterator = function(type, reverse) { - return new MapIterator(this, type, reverse); - }; - - src_Map__Map.prototype.__iterate = function(fn, reverse) {var this$0 = this; - var iterations = 0; - this._root && this._root.iterate(function(entry ) { - iterations++; - return fn(entry[1], entry[0], this$0); - }, reverse); - return iterations; - }; - - src_Map__Map.prototype.__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); - }; - - - function isMap(maybeMap) { - return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]); - } - - src_Map__Map.isMap = isMap; - - var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@'; - - var MapPrototype = src_Map__Map.prototype; - MapPrototype[IS_MAP_SENTINEL] = true; - MapPrototype[DELETE] = MapPrototype.remove; - MapPrototype.removeIn = MapPrototype.deleteIn; - - - // #pragma Trie Nodes - - - - function ArrayMapNode(ownerID, entries) { - this.ownerID = ownerID; - this.entries = entries; - } - - ArrayMapNode.prototype.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; - }; - - ArrayMapNode.prototype.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; // undefined - } - - 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); - }; - - - - - function BitmapIndexedNode(ownerID, bitmap, nodes) { - this.ownerID = ownerID; - this.bitmap = bitmap; - this.nodes = nodes; - } - - BitmapIndexedNode.prototype.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); - }; - - BitmapIndexedNode.prototype.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); - }; - - - - - function HashArrayMapNode(ownerID, count, nodes) { - this.ownerID = ownerID; - this.count = count; - this.nodes = nodes; - } - - HashArrayMapNode.prototype.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; - }; - - HashArrayMapNode.prototype.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); - }; - - - - - function HashCollisionNode(ownerID, keyHash, entries) { - this.ownerID = ownerID; - this.keyHash = keyHash; - this.entries = entries; - } - - HashCollisionNode.prototype.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; - }; - - HashCollisionNode.prototype.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); - }; - - - - - function ValueNode(ownerID, keyHash, entry) { - this.ownerID = ownerID; - this.keyHash = keyHash; - this.entry = entry; - } - - ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) { - return is(key, this.entry[0]) ? this.entry[1] : notSetValue; - }; - - ValueNode.prototype.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; // undefined - } - - 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]); - }; - - - - // #pragma Iterators - - 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); - } - - createClass(MapIterator, src_Iterator__Iterator); - - function MapIterator(map, type, reverse) { - this._type = type; - this._reverse = reverse; - this._stack = map._root && mapIteratorFrame(map._root); - } - - MapIterator.prototype.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(); - }; - - - 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, key) - {return existing && existing.mergeDeepWith && isIterable(value) ? - existing.mergeDeepWith(merger, value) : - merger ? merger(existing, value, key) : value}; - } - - function mergeIntoCollectionWith(collection, merger, iters) { - iters = iters.filter(function(x ) {return x.size !== 0}); - if (iters.length === 0) { - return collection; - } - if (collection.size === 0 && !collection.__ownerID && iters.length === 1) { - return collection.constructor(iters[0]); - } - 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, key)} - ); - } : - function(value, key) { - collection.set(key, value); - } - for (var ii = 0; ii < iters.length; ii++) { - iters[ii].forEach(mergeIntoMap); - } - }); - } - - function updateInDeepMap(existing, keyPathIter, notSetValue, updater) { - var isNotSet = existing === NOT_SET; - var step = keyPathIter.next(); - if (step.done) { - var existingValue = isNotSet ? notSetValue : existing; - var newValue = updater(existingValue); - return newValue === existingValue ? existing : newValue; - } - invariant( - isNotSet || (existing && existing.set), - 'invalid keyPath' - ); - var key = step.value; - var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET); - var nextUpdated = updateInDeepMap( - nextExisting, - keyPathIter, - notSetValue, - updater - ); - return nextUpdated === nextExisting ? existing : - nextUpdated === NOT_SET ? existing.remove(key) : - (isNotSet ? emptyMap() : existing).set(key, nextUpdated); - } - - 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; - - createClass(List, IndexedCollection); - - // @pragma Construction - - function List(value) { - var empty = emptyList(); - if (value === null || value === undefined) { - return empty; - } - if (isList(value)) { - return value; - } - var iter = IndexedIterable(value); - var size = iter.size; - if (size === 0) { - return empty; - } - assertNotInfinite(size); - if (size > 0 && size < SIZE) { - return makeList(0, size, SHIFT, null, new VNode(iter.toArray())); - } - return empty.withMutations(function(list ) { - list.setSize(size); - iter.forEach(function(v, i) {return list.set(i, v)}); - }); - } - - List.of = function(/*...values*/) { - return this(arguments); - }; - - List.prototype.toString = function() { - return this.__toString('List [', ']'); - }; - - // @pragma Access - - List.prototype.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]; - }; - - // @pragma Modification - - List.prototype.set = function(index, value) { - return updateList(this, index, value); - }; - - List.prototype.remove = function(index) { - return !this.has(index) ? this : - index === 0 ? this.shift() : - index === this.size - 1 ? this.pop() : - this.splice(index, 1); - }; - - List.prototype.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(); - }; - - List.prototype.push = function(/*...values*/) { - 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]); - } - }); - }; - - List.prototype.pop = function() { - return setListBounds(this, 0, -1); - }; - - List.prototype.unshift = function(/*...values*/) { - 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]); - } - }); - }; - - List.prototype.shift = function() { - return setListBounds(this, 1); - }; - - // @pragma Composition - - List.prototype.merge = function(/*...iters*/) { - return mergeIntoListWith(this, undefined, arguments); - }; - - List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); - return mergeIntoListWith(this, merger, iters); - }; - - List.prototype.mergeDeep = function(/*...iters*/) { - return mergeIntoListWith(this, deepMerger(undefined), arguments); - }; - - List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1); - return mergeIntoListWith(this, deepMerger(merger), iters); - }; - - List.prototype.setSize = function(size) { - return setListBounds(this, 0, size); - }; - - // @pragma Iteration - - List.prototype.slice = function(begin, end) { - var size = this.size; - if (wholeSlice(begin, end, size)) { - return this; - } - return setListBounds( - this, - resolveBegin(begin, size), - resolveEnd(end, size) - ); - }; - - List.prototype.__iterator = function(type, reverse) { - var index = 0; - var values = iterateList(this, reverse); - return new src_Iterator__Iterator(function() { - var value = values(); - return value === DONE ? - iteratorDone() : - iteratorValue(type, index++, value); - }); - }; - - List.prototype.__iterate = function(fn, reverse) { - var index = 0; - var values = iterateList(this, reverse); - var value; - while ((value = values()) !== DONE) { - if (fn(value, index++, this) === false) { - break; - } - } - return index; - }; - - List.prototype.__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); - }; - - - 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.deleteIn = - ListPrototype.removeIn = MapPrototype.removeIn; - ListPrototype.update = MapPrototype.update; - ListPrototype.updateIn = MapPrototype.updateIn; - ListPrototype.mergeIn = MapPrototype.mergeIn; - ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn; - ListPrototype.withMutations = MapPrototype.withMutations; - ListPrototype.asMutable = MapPrototype.asMutable; - ListPrototype.asImmutable = MapPrototype.asImmutable; - ListPrototype.wasAltered = MapPrototype.wasAltered; - - - - function VNode(array, ownerID) { - this.array = array; - this.ownerID = ownerID; - } - - // TODO: seems like these methods are very similar - - VNode.prototype.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; - }; - - VNode.prototype.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; - }; - - - - var DONE = {}; - - function iterateList(list, reverse) { - var left = list._origin; - var right = list._capacity; - var tailPos = getTailOffset(right); - var tail = list._tail; - - return iterateNodeOrLeaf(list._root, list._level, 0); - - function iterateNodeOrLeaf(node, level, offset) { - return level === 0 ? - iterateLeaf(node, offset) : - iterateNode(node, level, offset); - } - - function iterateLeaf(node, offset) { - var array = offset === tailPos ? tail && tail.array : node && node.array; - var from = offset > left ? 0 : left - offset; - var to = right - offset; - if (to > SIZE) { - to = SIZE; - } - return function() { - if (from === to) { - return DONE; - } - var idx = reverse ? --to : from++; - return array && array[idx]; - }; - } - - function iterateNode(node, level, offset) { - var values; - var array = node && node.array; - var from = offset > left ? 0 : (left - offset) >> level; - var to = ((right - offset) >> level) + 1; - if (to > SIZE) { - to = SIZE; - } - return function() { - do { - if (values) { - var value = values(); - if (value !== DONE) { - return value; - } - values = null; - } - if (from === to) { - return DONE; - } - var idx = reverse ? --to : from++; - values = iterateNodeOrLeaf( - array && array[idx], level - SHIFT, offset + (idx << level) - ); - } while (true); - }; - } - } - - 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 it's going to end after it starts, it's empty. - if (newOrigin >= newCapacity) { - return list.clear(); - } - - var newLevel = list._level; - var newRoot = list._root; - - // New origin might need creating a higher 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); - - // New size might need creating a higher root. - while (newTailOffset >= 1 << (newLevel + SHIFT)) { - newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner); - newLevel += SHIFT; - } - - // Locate or create the new tail. - var oldTail = list._tail; - var newTail = newTailOffset < oldTailOffset ? - listNodeFor(list, newCapacity - 1) : - newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail; - - // Merge Tail into tree. - 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 the size has been reduced, there's a chance the tail needs to be trimmed. - if (newCapacity < oldCapacity) { - newTail = newTail && newTail.removeAfter(owner, 0, newCapacity); - } - - // If the new origin is within the tail, then we do not need a root. - if (newOrigin >= newTailOffset) { - newOrigin -= newTailOffset; - newCapacity -= newTailOffset; - newLevel = SHIFT; - newRoot = null; - newTail = newTail && newTail.removeBefore(owner, 0, newOrigin); - - // Otherwise, if the root has been trimmed, garbage collect. - } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) { - offsetShift = 0; - - // Identify the new top root node of the subtree of the old root. - 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]; - } - - // Trim the new sides of the new root. - 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); - } - - createClass(OrderedMap, src_Map__Map); - - // @pragma Construction - - function OrderedMap(value) { - return value === null || value === undefined ? emptyOrderedMap() : - isOrderedMap(value) ? value : - emptyOrderedMap().withMutations(function(map ) { - var iter = KeyedIterable(value); - assertNotInfinite(iter.size); - iter.forEach(function(v, k) {return map.set(k, v)}); - }); - } - - OrderedMap.of = function(/*...values*/) { - return this(arguments); - }; - - OrderedMap.prototype.toString = function() { - return this.__toString('OrderedMap {', '}'); - }; - - // @pragma Access - - OrderedMap.prototype.get = function(k, notSetValue) { - var index = this._map.get(k); - return index !== undefined ? this._list.get(index)[1] : notSetValue; - }; - - // @pragma Modification - - OrderedMap.prototype.clear = function() { - if (this.size === 0) { - return this; - } - if (this.__ownerID) { - this.size = 0; - this._map.clear(); - this._list.clear(); - return this; - } - return emptyOrderedMap(); - }; - - OrderedMap.prototype.set = function(k, v) { - return updateOrderedMap(this, k, v); - }; - - OrderedMap.prototype.remove = function(k) { - return updateOrderedMap(this, k, NOT_SET); - }; - - OrderedMap.prototype.wasAltered = function() { - return this._map.wasAltered() || this._list.wasAltered(); - }; - - OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this; - return this._list.__iterate( - function(entry ) {return entry && fn(entry[1], entry[0], this$0)}, - reverse - ); - }; - - OrderedMap.prototype.__iterator = function(type, reverse) { - return this._list.fromEntrySeq().__iterator(type, reverse); - }; - - OrderedMap.prototype.__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); - }; - - - function isOrderedMap(maybeOrderedMap) { - return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap); - } - - OrderedMap.isOrderedMap = isOrderedMap; - - OrderedMap.prototype[IS_ORDERED_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) { // removed - 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); - } - - createClass(Stack, IndexedCollection); - - // @pragma Construction - - function Stack(value) { - return value === null || value === undefined ? emptyStack() : - isStack(value) ? value : - emptyStack().unshiftAll(value); - } - - Stack.of = function(/*...values*/) { - return this(arguments); - }; - - Stack.prototype.toString = function() { - return this.__toString('Stack [', ']'); - }; - - // @pragma Access - - Stack.prototype.get = function(index, notSetValue) { - var head = this._head; - index = wrapIndex(this, index); - while (head && index--) { - head = head.next; - } - return head ? head.value : notSetValue; - }; - - Stack.prototype.peek = function() { - return this._head && this._head.value; - }; - - // @pragma Modification - - Stack.prototype.push = function(/*...values*/) { - 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); - }; - - Stack.prototype.pushAll = function(iter) { - iter = IndexedIterable(iter); - if (iter.size === 0) { - return this; - } - assertNotInfinite(iter.size); - 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); - }; - - Stack.prototype.pop = function() { - return this.slice(1); - }; - - Stack.prototype.unshift = function(/*...values*/) { - return this.push.apply(this, arguments); - }; - - Stack.prototype.unshiftAll = function(iter) { - return this.pushAll(iter); - }; - - Stack.prototype.shift = function() { - return this.pop.apply(this, arguments); - }; - - Stack.prototype.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(); - }; - - Stack.prototype.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) { - // super.slice(begin, end); - return IndexedCollection.prototype.slice.call(this, 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); - }; - - // @pragma Mutability - - Stack.prototype.__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); - }; - - // @pragma Iteration - - Stack.prototype.__iterate = function(fn, reverse) { - if (reverse) { - return this.reverse().__iterate(fn); - } - var iterations = 0; - var node = this._head; - while (node) { - if (fn(node.value, iterations++, this) === false) { - break; - } - node = node.next; - } - return iterations; - }; - - Stack.prototype.__iterator = function(type, reverse) { - if (reverse) { - return this.reverse().__iterator(type); - } - var iterations = 0; - var node = this._head; - return new src_Iterator__Iterator(function() { - if (node) { - var value = node.value; - node = node.next; - return iteratorValue(type, iterations++, value); - } - return iteratorDone(); - }); - }; - - - 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)); - } - - createClass(src_Set__Set, SetCollection); - - // @pragma Construction - - function src_Set__Set(value) { - return value === null || value === undefined ? emptySet() : - isSet(value) ? value : - emptySet().withMutations(function(set ) { - var iter = SetIterable(value); - assertNotInfinite(iter.size); - iter.forEach(function(v ) {return set.add(v)}); - }); - } - - src_Set__Set.of = function(/*...values*/) { - return this(arguments); - }; - - src_Set__Set.fromKeys = function(value) { - return this(KeyedIterable(value).keySeq()); - }; - - src_Set__Set.prototype.toString = function() { - return this.__toString('Set {', '}'); - }; - - // @pragma Access - - src_Set__Set.prototype.has = function(value) { - return this._map.has(value); - }; - - // @pragma Modification - - src_Set__Set.prototype.add = function(value) { - return updateSet(this, this._map.set(value, true)); - }; - - src_Set__Set.prototype.remove = function(value) { - return updateSet(this, this._map.remove(value)); - }; - - src_Set__Set.prototype.clear = function() { - return updateSet(this, this._map.clear()); - }; - - // @pragma Composition - - src_Set__Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0); - iters = iters.filter(function(x ) {return x.size !== 0}); - if (iters.length === 0) { - return this; - } - if (this.size === 0 && !this.__ownerID && iters.length === 1) { - return this.constructor(iters[0]); - } - return this.withMutations(function(set ) { - for (var ii = 0; ii < iters.length; ii++) { - SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)}); - } - }); - }; - - src_Set__Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0); - 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.includes(value)})) { - set.remove(value); - } - }); - }); - }; - - src_Set__Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0); - 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.includes(value)})) { - set.remove(value); - } - }); - }); - }; - - src_Set__Set.prototype.merge = function() { - return this.union.apply(this, arguments); - }; - - src_Set__Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1); - return this.union.apply(this, iters); - }; - - src_Set__Set.prototype.sort = function(comparator) { - // Late binding - return OrderedSet(sortFactory(this, comparator)); - }; - - src_Set__Set.prototype.sortBy = function(mapper, comparator) { - // Late binding - return OrderedSet(sortFactory(this, comparator, mapper)); - }; - - src_Set__Set.prototype.wasAltered = function() { - return this._map.wasAltered(); - }; - - src_Set__Set.prototype.__iterate = function(fn, reverse) {var this$0 = this; - return this._map.__iterate(function(_, k) {return fn(k, k, this$0)}, reverse); - }; - - src_Set__Set.prototype.__iterator = function(type, reverse) { - return this._map.map(function(_, k) {return k}).__iterator(type, reverse); - }; - - src_Set__Set.prototype.__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); - }; - - - function isSet(maybeSet) { - return !!(maybeSet && maybeSet[IS_SET_SENTINEL]); - } - - src_Set__Set.isSet = isSet; - - var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@'; - - var SetPrototype = src_Set__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())); - } - - createClass(OrderedSet, src_Set__Set); - - // @pragma Construction - - function OrderedSet(value) { - return value === null || value === undefined ? emptyOrderedSet() : - isOrderedSet(value) ? value : - emptyOrderedSet().withMutations(function(set ) { - var iter = SetIterable(value); - assertNotInfinite(iter.size); - iter.forEach(function(v ) {return set.add(v)}); - }); - } - - OrderedSet.of = function(/*...values*/) { - return this(arguments); - }; - - OrderedSet.fromKeys = function(value) { - return this(KeyedIterable(value).keySeq()); - }; - - OrderedSet.prototype.toString = function() { - return this.__toString('OrderedSet {', '}'); - }; - - - function isOrderedSet(maybeOrderedSet) { - return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet); - } - - OrderedSet.isOrderedSet = isOrderedSet; - - var OrderedSetPrototype = OrderedSet.prototype; - OrderedSetPrototype[IS_ORDERED_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())); - } - - createClass(Record, KeyedCollection); - - function Record(defaultValues, name) { - var hasInitialized; - - var RecordType = function Record(values) { - if (values instanceof RecordType) { - return values; - } - if (!(this instanceof RecordType)) { - return new RecordType(values); - } - if (!hasInitialized) { - hasInitialized = true; - var keys = Object.keys(defaultValues); - setProps(RecordTypePrototype, keys); - RecordTypePrototype.size = keys.length; - RecordTypePrototype._name = name; - RecordTypePrototype._keys = keys; - RecordTypePrototype._defaultValues = defaultValues; - } - this._map = src_Map__Map(values); - }; - - var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype); - RecordTypePrototype.constructor = RecordType; - - return RecordType; - } - - Record.prototype.toString = function() { - return this.__toString(recordName(this) + ' {', '}'); - }; - - // @pragma Access - - Record.prototype.has = function(k) { - return this._defaultValues.hasOwnProperty(k); - }; - - Record.prototype.get = function(k, notSetValue) { - if (!this.has(k)) { - return notSetValue; - } - var defaultVal = this._defaultValues[k]; - return this._map ? this._map.get(k, defaultVal) : defaultVal; - }; - - // @pragma Modification - - Record.prototype.clear = function() { - if (this.__ownerID) { - this._map && this._map.clear(); - return this; - } - var RecordType = this.constructor; - return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap())); - }; - - Record.prototype.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); - }; - - Record.prototype.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); - }; - - Record.prototype.wasAltered = function() { - return this._map.wasAltered(); - }; - - Record.prototype.__iterator = function(type, reverse) {var this$0 = this; - return KeyedIterable(this._defaultValues).map(function(_, k) {return this$0.get(k)}).__iterator(type, reverse); - }; - - Record.prototype.__iterate = function(fn, reverse) {var this$0 = this; - return KeyedIterable(this._defaultValues).map(function(_, k) {return this$0.get(k)}).__iterate(fn, reverse); - }; - - Record.prototype.__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); - }; - - - var RecordPrototype = Record.prototype; - RecordPrototype[DELETE] = RecordPrototype.remove; - RecordPrototype.deleteIn = - RecordPrototype.removeIn = MapPrototype.removeIn; - RecordPrototype.merge = MapPrototype.merge; - RecordPrototype.mergeWith = MapPrototype.mergeWith; - RecordPrototype.mergeIn = MapPrototype.mergeIn; - RecordPrototype.mergeDeep = MapPrototype.mergeDeep; - RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith; - RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn; - RecordPrototype.setIn = MapPrototype.setIn; - 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 || 'Record'; - } - - function setProps(prototype, names) { - try { - names.forEach(setProp.bind(undefined, prototype)); - } catch (error) { - // Object.defineProperty failed. Probably IE8. - } - } - - function setProp(prototype, name) { - Object.defineProperty(prototype, name, { - get: function() { - return this.get(name); - }, - set: function(value) { - invariant(this.__ownerID, 'Cannot set on an immutable record.'); - this.set(name, value); - } - }); - } - - function deepEqual(a, b) { - if (a === b) { - return true; - } - - if ( - !isIterable(b) || - a.size !== undefined && b.size !== undefined && a.size !== b.size || - a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash || - isKeyed(a) !== isKeyed(b) || - isIndexed(a) !== isIndexed(b) || - isOrdered(a) !== isOrdered(b) - ) { - return false; - } - - if (a.size === 0 && b.size === 0) { - return true; - } - - var notAssociative = !isAssociative(a); - - if (isOrdered(a)) { - var entries = a.entries(); - return b.every(function(v, k) { - var entry = entries.next().value; - return entry && is(entry[1], v) && (notAssociative || is(entry[0], k)); - }) && entries.next().done; - } - - var flipped = false; - - if (a.size === undefined) { - if (b.size === undefined) { - if (typeof a.cacheResult === 'function') { - a.cacheResult(); - } - } else { - flipped = true; - var _ = a; - a = b; - b = _; - } - } - - var allEqual = true; - var bSize = b.__iterate(function(v, k) { - if (notAssociative ? !a.has(v) : - flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) { - allEqual = false; - return false; - } - }); - - return allEqual && a.size === bSize; - } - - createClass(Range, IndexedSeq); - - 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; - } - 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); - if (this.size === 0) { - if (EMPTY_RANGE) { - return EMPTY_RANGE; - } - EMPTY_RANGE = this; - } - } - - Range.prototype.toString = function() { - if (this.size === 0) { - return 'Range []'; - } - return 'Range [ ' + - this._start + '...' + this._end + - (this._step > 1 ? ' by ' + this._step : '') + - ' ]'; - }; - - Range.prototype.get = function(index, notSetValue) { - return this.has(index) ? - this._start + wrapIndex(this, index) * this._step : - notSetValue; - }; - - Range.prototype.includes = function(searchValue) { - var possibleIndex = (searchValue - this._start) / this._step; - return possibleIndex >= 0 && - possibleIndex < this.size && - possibleIndex === Math.floor(possibleIndex); - }; - - Range.prototype.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 new Range(0, 0); - } - return new Range(this.get(begin, this._end), this.get(end, this._end), this._step); - }; - - Range.prototype.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; - }; - - Range.prototype.lastIndexOf = function(searchValue) { - return this.indexOf(searchValue); - }; - - Range.prototype.__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; - }; - - Range.prototype.__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 src_Iterator__Iterator(function() { - var v = value; - value += reverse ? -step : step; - return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v); - }); - }; - - Range.prototype.equals = function(other) { - return other instanceof Range ? - this._start === other._start && - this._end === other._end && - this._step === other._step : - deepEqual(this, other); - }; - - - var EMPTY_RANGE; - - createClass(Repeat, IndexedSeq); - - function Repeat(value, times) { - 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) { - if (EMPTY_REPEAT) { - return EMPTY_REPEAT; - } - EMPTY_REPEAT = this; - } - } - - Repeat.prototype.toString = function() { - if (this.size === 0) { - return 'Repeat []'; - } - return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]'; - }; - - Repeat.prototype.get = function(index, notSetValue) { - return this.has(index) ? this._value : notSetValue; - }; - - Repeat.prototype.includes = function(searchValue) { - return is(this._value, searchValue); - }; - - Repeat.prototype.slice = function(begin, end) { - var size = this.size; - return wholeSlice(begin, end, size) ? this : - new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size)); - }; - - Repeat.prototype.reverse = function() { - return this; - }; - - Repeat.prototype.indexOf = function(searchValue) { - if (is(this._value, searchValue)) { - return 0; - } - return -1; - }; - - Repeat.prototype.lastIndexOf = function(searchValue) { - if (is(this._value, searchValue)) { - return this.size; - } - return -1; - }; - - Repeat.prototype.__iterate = function(fn, reverse) { - for (var ii = 0; ii < this.size; ii++) { - if (fn(this._value, ii, this) === false) { - return ii + 1; - } - } - return ii; - }; - - Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this; - var ii = 0; - return new src_Iterator__Iterator(function() - {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()} - ); - }; - - Repeat.prototype.equals = function(other) { - return other instanceof Repeat ? - is(this._value, other._value) : - deepEqual(other); - }; - - - var EMPTY_REPEAT; - - /** - * Contributes additional methods to a constructor - */ - function mixin(ctor, methods) { - var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; }; - Object.keys(methods).forEach(keyCopier); - Object.getOwnPropertySymbols && - Object.getOwnPropertySymbols(methods).forEach(keyCopier); - return ctor; - } - - Iterable.Iterator = src_Iterator__Iterator; - - mixin(Iterable, { - - // ### Conversion to other types - - 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(); - }, - - toJSON: function() { - return this.toSeq().map( - function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value} - ).__toJS(); - }, - - toKeyedSeq: function() { - return new ToKeyedSequence(this, true); - }, - - toMap: function() { - // Use Late Binding here to solve the circular dependency. - return src_Map__Map(this.toKeyedSeq()); - }, - - toObject: function() { - assertNotInfinite(this.size); - var object = {}; - this.__iterate(function(v, k) { object[k] = v; }); - return object; - }, - - toOrderedMap: function() { - // Use Late Binding here to solve the circular dependency. - return OrderedMap(this.toKeyedSeq()); - }, - - toOrderedSet: function() { - // Use Late Binding here to solve the circular dependency. - return OrderedSet(isKeyed(this) ? this.valueSeq() : this); - }, - - toSet: function() { - // Use Late Binding here to solve the circular dependency. - return src_Set__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() { - // Use Late Binding here to solve the circular dependency. - return Stack(isKeyed(this) ? this.valueSeq() : this); - }, - - toList: function() { - // Use Late Binding here to solve the circular dependency. - return List(isKeyed(this) ? this.valueSeq() : this); - }, - - - // ### Common JavaScript methods and properties - - toString: function() { - return '[Iterable]'; - }, - - __toString: function(head, tail) { - if (this.size === 0) { - return head + tail; - } - return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail; - }, - - - // ### ES6 Collection methods (ES6 Array and Map) - - concat: function() {var values = SLICE$0.call(arguments, 0); - return reify(this, concatFactory(this, values)); - }, - - contains: function(searchValue) { - return this.includes(searchValue); - }, - - includes: function(searchValue) { - return this.some(function(value ) {return is(value, searchValue)}); - }, - - entries: function() { - return this.__iterator(ITERATE_ENTRIES); - }, - - every: function(predicate, context) { - assertNotInfinite(this.size); - 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 entry = this.findEntry(predicate, context); - return entry ? entry[1] : notSetValue; - }, - - findEntry: function(predicate, context) { - var found; - this.__iterate(function(v, k, c) { - if (predicate.call(context, v, k, c)) { - found = [k, v]; - return false; - } - }); - return found; - }, - - findLastEntry: function(predicate, context) { - return this.toSeq().reverse().findEntry(predicate, context); - }, - - forEach: function(sideEffect, context) { - assertNotInfinite(this.size); - return this.__iterate(context ? sideEffect.bind(context) : sideEffect); - }, - - join: function(separator) { - assertNotInfinite(this.size); - separator = separator !== undefined ? '' + separator : ','; - var joined = ''; - var isFirst = true; - this.__iterate(function(v ) { - isFirst ? (isFirst = false) : (joined += separator); - joined += v !== null && v !== undefined ? v.toString() : ''; - }); - 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) { - assertNotInfinite(this.size); - 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) { - return reify(this, sliceFactory(this, begin, end, true)); - }, - - 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); - }, - - - // ### More sequential methods - - butLast: function() { - return this.slice(0, -1); - }, - - isEmpty: function() { - return this.size !== undefined ? this.size === 0 : !this.some(function() {return true}); - }, - - 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) { - return deepEqual(this, other); - }, - - entrySeq: function() { - var iterable = this; - if (iterable._cache) { - // We cache as an entries array, so we can just return the 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; - // Note: in an ES6 environment, we would prefer: - // for (var key of searchKeyPath) { - var iter = forceIterator(searchKeyPath); - var step; - while (!(step = iter.next()).done) { - var key = step.value; - nested = nested && nested.get ? nested.get(key, 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; - }, - - hasIn: function(searchKeyPath) { - return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET; - }, - - isSubset: function(iter) { - iter = typeof iter.includes === 'function' ? iter : Iterable(iter); - return this.every(function(value ) {return iter.includes(value)}); - }, - - isSuperset: function(iter) { - iter = typeof iter.isSubset === 'function' ? iter : Iterable(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 this.slice(Math.max(0, amount)); - }, - - 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 this.slice(0, Math.max(0, 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(); - }, - - - // ### Hashable Object - - hashCode: function() { - return this.__hash || (this.__hash = hashIterable(this)); - }, - - - // ### Internal - - // abstract __iterate(fn, reverse) - - // abstract __iterator(type, reverse) - }); - - // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@'; - // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@'; - // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@'; - // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@'; - - var IterablePrototype = Iterable.prototype; - IterablePrototype[IS_ITERABLE_SENTINEL] = true; - IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values; - IterablePrototype.__toJS = IterablePrototype.toArray; - IterablePrototype.__toStringMapper = quoteString; - IterablePrototype.inspect = - IterablePrototype.toSource = function() { return this.toString(); }; - IterablePrototype.chain = IterablePrototype.flatMap; - - // Temporary warning about using length - (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) {} - })(); - - - - mixin(KeyedIterable, { - - // ### More sequential methods - - flip: function() { - return reify(this, flipFactory(this)); - }, - - findKey: function(predicate, context) { - var entry = this.findEntry(predicate, context); - return entry && entry[0]; - }, - - 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.findLastKey(function(value ) {return is(value, searchValue)}); - }, - - mapEntries: function(mapper, context) {var this$0 = this; - var iterations = 0; - return reify(this, - this.toSeq().map( - function(v, k) {return mapper.call(context, [k, v], iterations++, this$0)} - ).fromEntrySeq() - ); - }, - - mapKeys: function(mapper, context) {var this$0 = this; - return reify(this, - this.toSeq().flip().map( - function(k, v) {return mapper.call(context, k, v, this$0)} - ).flip() - ); - }, - - }); - - var KeyedIterablePrototype = KeyedIterable.prototype; - KeyedIterablePrototype[IS_KEYED_SENTINEL] = true; - KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries; - KeyedIterablePrototype.__toJS = IterablePrototype.toObject; - KeyedIterablePrototype.__toStringMapper = function(v, k) {return JSON.stringify(k) + ': ' + quoteString(v)}; - - - - mixin(IndexedIterable, { - - // ### Conversion to other types - - toKeyedSeq: function() { - return new ToKeyedSequence(this, false); - }, - - - // ### ES6 Collection methods (ES6 Array and Map) - - filter: function(predicate, context) { - return reify(this, filterFactory(this, predicate, context, false)); - }, - - findIndex: function(predicate, context) { - var entry = this.findEntry(predicate, context); - return entry ? entry[0] : -1; - }, - - indexOf: function(searchValue) { - var key = this.toKeyedSeq().keyOf(searchValue); - return key === undefined ? -1 : key; - }, - - lastIndexOf: function(searchValue) { - return this.toSeq().reverse().indexOf(searchValue); - }, - - reverse: function() { - return reify(this, reverseFactory(this, false)); - }, - - slice: function(begin, end) { - return reify(this, sliceFactory(this, begin, end, false)); - }, - - splice: function(index, removeNum /*, ...values*/) { - 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)) - ); - }, - - - // ### More collection methods - - 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)); - }, - - interleave: function(/*...iterables*/) { - var iterables = [this].concat(arrCopy(arguments)); - var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables); - var interleaved = zipped.flatten(true); - if (zipped.size) { - interleaved.size = zipped.size * iterables.length; - } - return reify(this, interleaved); - }, - - last: function() { - return this.get(-1); - }, - - skipWhile: function(predicate, context) { - return reify(this, skipWhileFactory(this, predicate, context, false)); - }, - - zip: function(/*, ...iterables */) { - var iterables = [this].concat(arrCopy(arguments)); - return reify(this, zipWithFactory(this, defaultZipper, iterables)); - }, - - zipWith: function(zipper/*, ...iterables */) { - var iterables = arrCopy(arguments); - iterables[0] = this; - return reify(this, zipWithFactory(this, zipper, iterables)); - }, - - }); - - IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true; - IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true; - - - - mixin(SetIterable, { - - // ### ES6 Collection methods (ES6 Array and Map) - - get: function(value, notSetValue) { - return this.has(value) ? value : notSetValue; - }, - - includes: function(value) { - return this.has(value); - }, - - - // ### More sequential methods - - keySeq: function() { - return this.valueSeq(); - }, - - }); - - SetIterable.prototype.has = IterablePrototype.includes; - - - // Mixin subclasses - - mixin(KeyedSeq, KeyedIterable.prototype); - mixin(IndexedSeq, IndexedIterable.prototype); - mixin(SetSeq, SetIterable.prototype); - - mixin(KeyedCollection, KeyedIterable.prototype); - mixin(IndexedCollection, IndexedIterable.prototype); - mixin(SetCollection, SetIterable.prototype); - - - // #pragma Helper functions - - 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 defaultZipper() { - return arrCopy(arguments); - } - - function defaultNegComparator(a, b) { - return a < b ? 1 : a > b ? -1 : 0; - } - - function hashIterable(iterable) { - if (iterable.size === Infinity) { - return 0; - } - var ordered = isOrdered(iterable); - var keyed = isKeyed(iterable); - var h = ordered ? 1 : 0; - var size = iterable.__iterate( - keyed ? - ordered ? - function(v, k) { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } : - function(v, k) { h = h + hashMerge(hash(v), hash(k)) | 0; } : - ordered ? - function(v ) { h = 31 * h + hash(v) | 0; } : - function(v ) { h = h + hash(v) | 0; } - ); - return murmurHashOfSize(size, h); - } - - function murmurHashOfSize(size, h) { - h = src_Math__imul(h, 0xCC9E2D51); - h = src_Math__imul(h << 15 | h >>> -15, 0x1B873593); - h = src_Math__imul(h << 13 | h >>> -13, 5); - h = (h + 0xE6546B64 | 0) ^ size; - h = src_Math__imul(h ^ h >>> 16, 0x85EBCA6B); - h = src_Math__imul(h ^ h >>> 13, 0xC2B2AE35); - h = smi(h ^ h >>> 16); - return h; - } - - function hashMerge(a, b) { - return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int } - var Immutable = { - - Iterable: Iterable, - - Seq: Seq, - Collection: Collection, - Map: src_Map__Map, - OrderedMap: OrderedMap, - List: List, - Stack: Stack, - Set: src_Set__Set, - OrderedSet: OrderedSet, - - Record: Record, - Range: Range, - Repeat: Repeat, - - is: is, - fromJS: fromJS, - - }; + return state; +}; - return Immutable; +module.exports = exports['default']; -})); -},{}],"store":[function(require,module,exports){ +},{"actions/types":225}],"store":[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -29301,7 +32276,6 @@ var DEFAULT = new _immutable2['default'].Map(Object.assign({ }, _dialogs2['default'], _menus2['default'])); var store = (0, _redux.createStore)(_reducersAll2['default'], DEFAULT); -store.dispatch((0, _actionsChangedir2['default'])(DEFAULT.get('dir'))); function bind(action) { return function () { @@ -29311,7 +32285,9 @@ function bind(action) { exports['default'] = store; -},{"./dialogs":235,"./menus":237,"actions/changedir":215,"immutable":248,"reducers/all":239,"redux":207}],"utils":[function(require,module,exports){ +store.dispatch((0, _actionsChangedir2['default'])(DEFAULT.get('dir'))); + +},{"./dialogs":239,"./menus":241,"actions/changedir":217,"immutable":3,"reducers/all":243,"redux":209}],"utils":[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { @@ -29379,4 +32355,4 @@ function humanSize(size) { } } -},{"actions/dialog":216,"store":"store"}]},{},[215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,"store","utils"]); +},{"actions/dialog":218,"store":"store"}]},{},[217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,"store","utils"]); diff --git a/build/style.css b/build/style.css index 768499f..cd73cef 100644 --- a/build/style.css +++ b/build/style.css @@ -43,6 +43,22 @@ width: 6px; height: 24px; } +.icon-search { + display: block; + background: url(/img/Search.svg) no-repeat; + width: 19px; + height: 27px; +} +.icon-cross { + display: block; + background: url(/img/Plus.svg) no-repeat; + width: 24px; + height: 24px; + transform: rotate(45deg); +} +.icon-cross svg * { + fill: white; +} .regular-medium { font-weight: normal; } @@ -104,10 +120,8 @@ input { font-weight: 200; font-size: 1.6rem; } -label { - clear: left; -} -label::after { +input[type='checkbox'] + label::after, +input[type='radio'] + label::after { content: ''; display: block; float: right; @@ -118,14 +132,36 @@ label::after { background: transparent; border: 1px solid #9b9b93; } -input[type='checkbox'] { - clear: right; - float: right; +input[type='checkbox'], +input[type='radio'] { display: none; } input:checked + label::after { background: #63b0cd; } +.coming-soon::after { + content: 'soon...'; + background: #f7c59f; + color: #39393a; + padding: 2px 8px; + border-radius: 12px; + font-size: 11px; + font-weight: normal; +} +li.coming-soon::after { + margin-right: 13px; + float: right; +} +button.coming-soon { + position: relative; +} +button.coming-soon::after { + position: absolute; + left: 50%; + top: 50%; + opacity: 0.8; + transform: translate(-50%, -50%) rotate(-45deg); +} .file, .directory { display: flex; @@ -141,11 +177,13 @@ input:checked + label::after { .file p, .directory p { flex: 1 1; + text-overflow: ellipsis; } .file > span, .directory > span { font-weight: 100; font-size: 1.5rem; + margin-left: 1rem; } .file i, .directory i { @@ -176,6 +214,10 @@ header { } header h1 { margin-left: -3rem; + flex: 1; +} +header i { + margin-right: 16px; } header button { background: none; @@ -202,7 +244,7 @@ header button::before { border-radius: 4px; pointer-events: none; opacity: 0; - transition: opacity 0.5s ease; + transition: opacity 0.3s ease; box-shadow: 0 8px 16px 3px rgba(0, 0, 0, 0.2); } .menu.active { @@ -221,6 +263,10 @@ header button::before { .menu li:last-of-type { border-bottom: none; } +.menu li.disabled { + color: #9b9b93; + pointer-events: none; +} nav { display: flex; flex-flow: column; @@ -229,18 +275,22 @@ nav { top: 0; width: 70vw; height: 100vh; + overflow-y: auto; background: #39393a; color: white; - box-shadow: 3px 0 16px 5px rgba(0, 0, 0, 0.2); + box-shadow: 3px 0 16px 5px transparent, 0 0 0 1000px rgba(0, 0, 0, 0); z-index: 6; - transition: left 0.5s ease; + transition: left 0.3s ease, box-shadow 0.3s ease; +} +nav ul:last-of-type li:last-of-type { + margin-bottom: 13px; } nav.active { left: 0; + box-shadow: 3px 0 16px 5px rgba(0, 0, 0, 0.2), 0 0 0 1000px rgba(0, 0, 0, 0.55); } nav.active i { pointer-events: all; - opacity: 0.99; } nav p { margin-left: 1.6rem; @@ -252,6 +302,7 @@ nav ul { padding-left: 0; } nav li { + display: flex; font-weight: 200; font-size: 1.6rem; padding: 1rem 0 1rem 3rem; @@ -264,18 +315,21 @@ nav li:last-of-type { padding-bottom: 0; border-bottom: none; } +nav li label { + flex: 1; + order: 0; +} +nav li input { + order: 1; +} nav i { display: block; position: fixed; - left: 0; + left: 70vw; top: 0; - pointer-events: none; - width: 100vw; + width: 30vw; height: 100vh; - background: rgba(0, 0, 0, 0.55); - opacity: 0; - z-index: -1; - transition: opacity 0.5s ease; + pointer-events: none; } .toolbar { display: flex; @@ -293,13 +347,20 @@ nav i { flex: 1; align-items: center; width: 100vw; - height: 3.5rem; + height: 4.5rem; + overflow-x: auto; padding: 8px; box-sizing: border-box; font-weight: 200; font-size: 1.6rem; background: #f8f8f8; border-bottom: 1px solid rgba(0, 0, 0, 0.2); + overflow-x: scroll; + overflow-y: hidden; + white-space: nowrap; +} +.breadcrumb span { + white-space: nowrap; } .breadcrumb i { margin: 0 2px; @@ -308,7 +369,7 @@ nav i { color: #9b9b93; } .file-list { - height: calc(100vh - 13.5rem); + height: calc(100vh - 14.5rem); overflow-x: hidden; overflow-y: auto; } @@ -319,13 +380,13 @@ nav i { top: 50%; left: 50%; transform: translate(-50%, -50%); - width: 335px; + width: 90vw; height: auto; padding: 1.5rem 1.7rem; background: white; box-shadow: 0 15px 24px 6px rgba(0, 0, 0, 0.2); - z-index: 3; - transition: opacity 0.5s ease; + z-index: 5; + transition: opacity 0.3s ease; opacity: 0; pointer-events: none; } @@ -356,6 +417,66 @@ nav i { .dialog .foot button:last-of-type { margin-right: 0; } +.sk-cube-grid { + opacity: 0; + pointer-events: none; + width: 4rem; + height: 4rem; + position: fixed; + left: 50%; + top: 50%; + margin-top: -2rem; + margin-left: -2rem; + z-index: 5; + transition: opacity 0.3s ease; +} +.sk-cube-grid.show { + opacity: 1; +} +.sk-cube-grid .sk-cube { + width: 33.33%; + height: 33.33%; + background-color: #333; + float: left; + animation: sk-cubeGridScaleDelay 1.3s infinite ease-in-out; +} +.sk-cube-grid .sk-cube1 { + animation-delay: 0.2s; +} +.sk-cube-grid .sk-cube2 { + animation-delay: 0.3s; +} +.sk-cube-grid .sk-cube3 { + animation-delay: 0.4s; +} +.sk-cube-grid .sk-cube4 { + animation-delay: 0.1s; +} +.sk-cube-grid .sk-cube5 { + animation-delay: 0.2s; +} +.sk-cube-grid .sk-cube6 { + animation-delay: 0.3s; +} +.sk-cube-grid .sk-cube7 { + animation-delay: 0s; +} +.sk-cube-grid .sk-cube8 { + animation-delay: 0.1s; +} +.sk-cube-grid .sk-cube9 { + animation-delay: 0.2s; +} +@keyframes sk-cubeGridScaleDelay { + 0%, + 70%, + 100% { + transform: scale3D(1, 1, 1); + } + 35% { + transform: scale3D(0, 0, 1); + } +} html, body { margin: 0; @@ -372,3 +493,7 @@ body { display: flex; flex-flow: column; } +a { + color: currentColor; + text-decoration: none; +} diff --git a/design/userinterface.sketch b/design/userinterface.sketch index 325b44a1284f86a648a2415b0b8121f849bc6412..eb576bb6bbdfc61efa5fcd3ec2ea5d15550e2bcc 100644 GIT binary patch delta 1038251 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

05m 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 Lb(bU-yfo^6r}Nb; delta 1027194 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.i& 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 t!DO`g;hnf$LObw#EmOzP71+Lwo{&8*dN#niQ$ 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

7i`-s>&G`1K*dTv2Y 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 z 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

F)dDmsAOcKlJdb?Z~P+M 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%0Dm>Gq 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

_xv7&8rhph_NI}& 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πu=f27{Zg30d=5}6g=jDDFgn3es69wk+ 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 AK>z>% diff --git a/package.json b/package.json index 38e8cbd..b57f880 100644 --- a/package.json +++ b/package.json @@ -43,6 +43,8 @@ "grunt-contrib-watch": "^0.6.1", "grunt-fxos": "^0.1.2", "grunt-task-loader": "^0.6.0", + "hammerjs": "^2.0.4", + "immutable": "^3.7.5", "less-plugin-clean-css": "^1.5.1", "lodash": "^3.10.1", "react": "^0.13.3", diff --git a/src/img/Search.png b/src/img/Search.png new file mode 100644 index 0000000000000000000000000000000000000000..f2dc1174886916c8e407e29c8918d5e1958e33c6 GIT binary patch literal 690 zcmV;j0!{siP)Px%Y)M2xR7ef2ls$+OQ4q)Tr3pz9u{jljl@^I!6;DMhatIcJjR%5-Ac(DngUMDT;4Tc{8PTOv zg+kl7!a-cMS}mT*WEP2M!{PAm;c)l^d0(kiUKI+3UqN}E@AY~;)$Mj~^?JQEWH>>- zyRLh+TrS5vi8!9hI-Sn`NF=gCC5QdM3H}T4=hEr4BQZ_ZXf$>ulgYOb9grZ$va#PF zt4J0(L3}S-)@$0an9JpQ@?oSo+C$?=F8=jmu^2T$wrwZC+(G(+1$WcLgy_LR6M%im z1MoTHo=QL09mh#)2*De&6Z*Lh1Q?cO?I7oq8 zw|PdIiEiQRS<@iHU|3IrGsi>C;O0{E#En!9LaW_wXC!WFaEB0Eu-JbtLV)a6h(@Do zEM!pE=*8`RzyFdOUL}^LpQkv|H84BJc}*}2@p$~R^7Zee9Co{cx{pXN)#sq)vdK~+ zk$4&e2vOl>NC$F^Nm{j})oLB_ll)ZyM^Vi;D^}O;aGWnl5jkHfmF82a)H^?!$5(F@ zyM8mP!C&%#rga#JvnCPt&uX + + + Search + Created with Sketch. + + + + + + + + + \ No newline at end of file diff --git a/src/index.html b/src/index.html index cb32db8..24a51e6 100644 --- a/src/index.html +++ b/src/index.html @@ -3,7 +3,7 @@ Hawk - + diff --git a/src/js/actions/file.js b/src/js/actions/file.js index 4214aa8..77fb4ff 100644 --- a/src/js/actions/file.js +++ b/src/js/actions/file.js @@ -1,4 +1,4 @@ -import { CREATE_FILE, SHARE_FILE, RENAME_FILE, ACTIVE_FILE, DELETE_FILE } from 'actions/types'; +import { CREATE_FILE, SHARE_FILE, RENAME_FILE, ACTIVE_FILE, DELETE_FILE, MOVE_FILE, COPY_FILE } from 'actions/types'; export function create(path, directory = false) { return { @@ -21,6 +21,20 @@ export function rename(file, name) { } } +export function move(file, newPath) { + return { + type: MOVE_FILE, + file, newPath + } +} + +export function copy(file, newPath) { + return { + type: COPY_FILE, + file, newPath + } +} + export function active(file = null) { return { type: ACTIVE_FILE, @@ -28,8 +42,7 @@ export function active(file = null) { } } -export function deleteFile(file) { - console.log('constructing deleteFile action', file); +export function remove(file) { return { type: DELETE_FILE, file diff --git a/src/js/actions/files-view.js b/src/js/actions/files-view.js index a9fd852..b3e6af9 100644 --- a/src/js/actions/files-view.js +++ b/src/js/actions/files-view.js @@ -1,6 +1,13 @@ -import { LIST_FILES, FILES_VIEW, SELECT_VIEW, REFRESH } from 'actions/types'; +import { LIST_FILES, FILES_VIEW, SELECT_VIEW, REFRESH, SEARCH } from 'actions/types'; import store from 'store'; +export function listFiles(files) { + return { + type: LIST_FILES, + files + }; +} + export function refresh() { return { type: REFRESH @@ -34,3 +41,10 @@ export function selectView(active = true) { active } } + +export function search(keywords) { + return { + type: SEARCH, + keywords + } +} diff --git a/src/js/actions/list-files.js b/src/js/actions/list-files.js deleted file mode 100644 index aa8aa9e..0000000 --- a/src/js/actions/list-files.js +++ /dev/null @@ -1,8 +0,0 @@ -import { LIST_FILES } from 'actions/types'; - -export default function listFiles(files) { - return { - type: LIST_FILES, - files - }; -} diff --git a/src/js/actions/spinner.js b/src/js/actions/spinner.js new file mode 100644 index 0000000..b9e105a --- /dev/null +++ b/src/js/actions/spinner.js @@ -0,0 +1,22 @@ +import { SPINNER } from 'actions/types'; + +export function show() { + return { + type: SPINNER, + active: true + } +} + +export function hide() { + return { + type: SPINNER, + active: false + } +} + +export function toggle() { + return { + type: SPINNER, + active: 'toggle' + } +} diff --git a/src/js/actions/types.js b/src/js/actions/types.js index ebca1c2..4cdc10e 100644 --- a/src/js/actions/types.js +++ b/src/js/actions/types.js @@ -16,11 +16,15 @@ const TYPES = { RENAME_FILE: Symbol('RENAME_FILE'), ACTIVE_FILE: Symbol('ACTIVE_FILE'), DELETE_FILE: Symbol('DELETE_FILE'), + COPY_FILE: Symbol('COPY_FILE'), + MOVE_FILE: Symbol('MOVE_FILE'), MENU: Symbol('MENU'), DIALOG: Symbol('DIALOG'), + SPINNER: Symbol('SPINNER'), + SETTINGS: Symbol('SETTINGS'), SEARCH: Symbol('SEARCH') diff --git a/src/js/api/files.js b/src/js/api/files.js index 121f27a..ae5bc8c 100644 --- a/src/js/api/files.js +++ b/src/js/api/files.js @@ -75,16 +75,25 @@ export async function createDirectory(...args) { return parent.createDirectory(...args); } -export async function remove(file) { +export async function remove(file, deep) { let parent = await root(); - return parent.remove(file); + console.log(deep); + return parent[deep ? 'removeDeep' : 'remove'](file); } export async function move(file, newPath) { let path = (file.path || '').replace(/^\//, ''); // remove starting slash let oldPath = path + file.name; + let process = await copy(file, newPath); + return remove(oldPath, true); +} + +export async function copy(file, newPath) { + let path = (file.path || '').replace(/^\//, ''); // remove starting slash + let oldPath = path + file.name; + newPath = newPath.replace(/^\//, ''); let target = await getFile(oldPath); @@ -102,7 +111,6 @@ export async function move(file, newPath) { await move(child, newPath + '/' + child.name); } - await parent.remove(oldPath); return; } else { let content = await readFile(oldPath); @@ -114,6 +122,6 @@ export async function move(file, newPath) { request.onsuccess = resolve; request.onerror = reject; request.onabort = reject; - }).then(() => sdcard().delete(oldPath)); + }); } } diff --git a/src/js/components/breadcrumb.js b/src/js/components/breadcrumb.js index 4bf5701..d96dd49 100644 --- a/src/js/components/breadcrumb.js +++ b/src/js/components/breadcrumb.js @@ -40,7 +40,9 @@ export default class Breadcrumb extends Component { return (

- {els} +
+ {els} +
); } diff --git a/src/js/components/directory.js b/src/js/components/directory.js index f1e02fc..c2fe9c0 100644 --- a/src/js/components/directory.js +++ b/src/js/components/directory.js @@ -4,10 +4,16 @@ import { show } from 'actions/menu'; import { active } from 'actions/file'; import { MENU_WIDTH } from './menu'; import store from 'store'; +import entry from './mixins/entry'; const MENU_TOP_SPACE = 20; export default class Directory extends Component { + constructor() { + super(); + Object.assign(this, entry); + } + render() { let checkId = `file-${this.props.index}`; @@ -40,28 +46,4 @@ export default class Directory extends Component { store.dispatch(changedir(file.path.slice(1) + file.name)); } - - contextMenu(e) { - e.preventDefault(); - - let rect = React.findDOMNode(this.refs.container).getBoundingClientRect(); - let {x, y, width, height} = rect; - - let left = x + width / 2 - MENU_WIDTH / 2, - top = y + height / 2 + MENU_TOP_SPACE; - store.dispatch(show('directoryMenu', {style: {left, top}})); - store.dispatch(active(this.props.index)); - } - - select() { - let current = (store.getState().get('activeFile') || []).slice(0); - let index = this.props.index; - - if (current.indexOf(index) > -1) { - current.splice(current.indexOf(index), 1); - } else { - current.push(index) - } - store.dispatch(active(current)); - } } diff --git a/src/js/components/file-list.js b/src/js/components/file-list.js index c774fdc..0519b34 100644 --- a/src/js/components/file-list.js +++ b/src/js/components/file-list.js @@ -4,6 +4,8 @@ import File from './file'; import Directory from './directory'; import store from 'store'; import { type } from 'utils'; +import Hammer from 'hammerjs'; +import changedir from 'actions/changedir'; @connect(props) export default class FileList extends Component { @@ -17,7 +19,7 @@ export default class FileList extends Component { let settings = store.getState().get('settings'); let els = files.map((file, index) => { - let selected = activeFile.indexOf(index) > -1; + let selected = activeFile.length && activeFile.indexOf(file) > -1; if (type(file) === 'File') { return ; } else { @@ -26,11 +28,25 @@ export default class FileList extends Component { }); return ( -
+
{els}
); } + + componentDidMount() { + let container = React.findDOMNode(this.refs.container); + let touch = Hammer(container); + + touch.on('swipe', e => { + let current = store.getState().get('cwd'); + let up = current.split('/').slice(0, -1).join('/'); + + if (up === current) return; + + store.dispatch(changedir(up)); + }).set({direction: Hammer.DIRECTION_RIGHT}); + } } function props(state) { diff --git a/src/js/components/file.js b/src/js/components/file.js index cb160e1..a0a7316 100644 --- a/src/js/components/file.js +++ b/src/js/components/file.js @@ -4,12 +4,14 @@ import { active } from 'actions/file'; import { MENU_WIDTH } from './menu'; import store from 'store'; import { humanSize } from 'utils'; +import entry from './mixins/entry'; const MENU_TOP_SPACE = 20; export default class File extends Component { constructor() { super(); + Object.assign(this, entry); } render() { @@ -22,7 +24,7 @@ export default class File extends Component { } let clickHandler = this.props.selectView ? this.select.bind(this) - : null; + : this.open.bind(this); return (
-1) { - current.splice(current.indexOf(index), 1); - } else { - current.push(index) - } - store.dispatch(active(current)); + let name = file.type === 'application/pdf' ? 'view' : 'open'; + new MozActivity({ + name, + data: { + type: file.type, + blob: file + } + }) } } diff --git a/src/js/components/header.js b/src/js/components/header.js index bdc5442..8382d9b 100644 --- a/src/js/components/header.js +++ b/src/js/components/header.js @@ -1,18 +1,34 @@ import React, { Component } from 'react'; import { toggle } from 'actions/navigation'; -import store from 'store'; +import { show } from 'actions/dialog'; +import { search } from 'actions/files-view'; +import { bind } from 'store'; +import { connect } from 'react-redux'; +@connect(props) export default class Header extends Component { render() { + let i; + + if (this.props.search) { + i = + } else { + i = + } + return (
- +
); } +} - toggleNavigation() { - store.dispatch(toggle()); +function props(state) { + return { + search: state.get('search') } } diff --git a/src/js/components/menu.js b/src/js/components/menu.js index f5a379b..88ba53e 100644 --- a/src/js/components/menu.js +++ b/src/js/components/menu.js @@ -8,7 +8,10 @@ export default class Menu extends Component { items = items || []; let els = items.map((item, index) => { - return
  • {item.name}
    • + let disabled = !(typeof item.enabled === 'function' ? item.enabled() : true) + let className = disabled ? 'disabled' : ''; + + return
  • {item.name}
    • }); let className = 'menu ' + (active ? 'active' : ''); diff --git a/src/js/components/mixins/entry.js b/src/js/components/mixins/entry.js new file mode 100644 index 0000000..b87c1bb --- /dev/null +++ b/src/js/components/mixins/entry.js @@ -0,0 +1,26 @@ +export default { + contextMenu(e) { + e.preventDefault(); + + let file = store.getState().get('files')[this.props.index]; + let rect = React.findDOMNode(this.refs.container).getBoundingClientRect(); + let {x, y, width, height} = rect; + + let left = x + width / 2 - MENU_WIDTH / 2, + top = y + height / 2 + MENU_TOP_SPACE; + store.dispatch(show('fileMenu', {style: {left, top}})); + store.dispatch(active([file])); + }, + + select() { + let current = store.getState().get('activeFile').slice(0); + let file = store.getState().get('files')[this.props.index]; + + if (current.indexOf(file) > -1) { + current.splice(current.indexOf(file), 1); + } else { + current.push(file) + } + store.dispatch(active(current)); + } +} diff --git a/src/js/components/navigation.js b/src/js/components/navigation.js index 3bf00d8..a6aac97 100644 --- a/src/js/components/navigation.js +++ b/src/js/components/navigation.js @@ -1,9 +1,9 @@ import React, { Component } from 'react'; import { connect } from 'react-redux'; -import { hide } from 'actions/navigation'; +import { hide as hideNavigation } from 'actions/navigation'; import camelCase from 'lodash/string/camelCase'; import updateSettings from 'actions/settings'; -import store from 'store'; +import store, { bind } from 'store'; @connect(props) export default class Navigation extends Component { @@ -11,23 +11,38 @@ export default class Navigation extends Component { let { settings } = this.props; return ( -