| !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.plist=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
| (function (Buffer){ |
| |
| /** |
| * Module dependencies. |
| */ |
| |
| var base64 = require('base64-js'); |
| var xmlbuilder = require('xmlbuilder'); |
| |
| /** |
| * Module exports. |
| */ |
| |
| exports.build = build; |
| |
| /** |
| * Accepts a `Date` instance and returns an ISO date string. |
| * |
| * @param {Date} d - Date instance to serialize |
| * @returns {String} ISO date string representation of `d` |
| * @api private |
| */ |
| |
| function ISODateString(d){ |
| function pad(n){ |
| return n < 10 ? '0' + n : n; |
| } |
| return d.getUTCFullYear()+'-' |
| + pad(d.getUTCMonth()+1)+'-' |
| + pad(d.getUTCDate())+'T' |
| + pad(d.getUTCHours())+':' |
| + pad(d.getUTCMinutes())+':' |
| + pad(d.getUTCSeconds())+'Z'; |
| } |
| |
| /** |
| * Returns the internal "type" of `obj` via the |
| * `Object.prototype.toString()` trick. |
| * |
| * @param {Mixed} obj - any value |
| * @returns {String} the internal "type" name |
| * @api private |
| */ |
| |
| var toString = Object.prototype.toString; |
| function type (obj) { |
| var m = toString.call(obj).match(/\[object (.*)\]/); |
| return m ? m[1] : m; |
| } |
| |
| /** |
| * Generate an XML plist string from the input object `obj`. |
| * |
| * @param {Object} obj - the object to convert |
| * @param {Object} [opts] - optional options object |
| * @returns {String} converted plist XML string |
| * @api public |
| */ |
| |
| function build (obj, opts) { |
| var XMLHDR = { |
| version: '1.0', |
| encoding: 'UTF-8' |
| }; |
| |
| var XMLDTD = { |
| pubid: '-//Apple//DTD PLIST 1.0//EN', |
| sysid: 'http://www.apple.com/DTDs/PropertyList-1.0.dtd' |
| }; |
| |
| var doc = xmlbuilder.create('plist'); |
| |
| doc.dec(XMLHDR.version, XMLHDR.encoding, XMLHDR.standalone); |
| doc.dtd(XMLDTD.pubid, XMLDTD.sysid); |
| doc.att('version', '1.0'); |
| |
| walk_obj(obj, doc); |
| |
| if (!opts) opts = {}; |
| // default `pretty` to `true` |
| opts.pretty = opts.pretty !== false; |
| return doc.end(opts); |
| } |
| |
| /** |
| * depth first, recursive traversal of a javascript object. when complete, |
| * next_child contains a reference to the build XML object. |
| * |
| * @api private |
| */ |
| |
| function walk_obj(next, next_child) { |
| var tag_type, i, prop; |
| var name = type(next); |
| |
| if (Array.isArray(next)) { |
| next_child = next_child.ele('array'); |
| for (i = 0; i < next.length; i++) { |
| walk_obj(next[i], next_child); |
| } |
| |
| } else if (Buffer.isBuffer(next)) { |
| next_child.ele('data').raw(next.toString('base64')); |
| |
| } else if ('Object' == name) { |
| next_child = next_child.ele('dict'); |
| for (prop in next) { |
| if (next.hasOwnProperty(prop)) { |
| next_child.ele('key').txt(prop); |
| walk_obj(next[prop], next_child); |
| } |
| } |
| |
| } else if ('Number' == name) { |
| // detect if this is an integer or real |
| // TODO: add an ability to force one way or another via a "cast" |
| tag_type = (next % 1 === 0) ? 'integer' : 'real'; |
| next_child.ele(tag_type).txt(next.toString()); |
| |
| } else if ('Date' == name) { |
| next_child.ele('date').txt(ISODateString(new Date(next))); |
| |
| } else if ('Boolean' == name) { |
| next_child.ele(next ? 'true' : 'false'); |
| |
| } else if ('String' == name) { |
| next_child.ele('string').txt(next); |
| |
| } else if ('ArrayBuffer' == name) { |
| next_child.ele('data').raw(base64.fromByteArray(next)); |
| |
| } else if (next.buffer && 'ArrayBuffer' == type(next.buffer)) { |
| // a typed array |
| next_child.ele('data').raw(base64.fromByteArray(new Uint8Array(next.buffer), next_child)); |
| |
| } |
| } |
| |
| }).call(this,require("buffer").Buffer) |
| },{"base64-js":2,"buffer":3,"xmlbuilder":21}],2:[function(require,module,exports){ |
| var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; |
| |
| ;(function (exports) { |
| 'use strict'; |
| |
| var Arr = (typeof Uint8Array !== 'undefined') |
| ? Uint8Array |
| : Array |
| |
| var ZERO = '0'.charCodeAt(0) |
| var PLUS = '+'.charCodeAt(0) |
| var SLASH = '/'.charCodeAt(0) |
| var NUMBER = '0'.charCodeAt(0) |
| var LOWER = 'a'.charCodeAt(0) |
| var UPPER = 'A'.charCodeAt(0) |
| |
| function decode (elt) { |
| var code = elt.charCodeAt(0) |
| if (code === PLUS) |
| return 62 // '+' |
| if (code === SLASH) |
| return 63 // '/' |
| if (code < NUMBER) |
| return -1 //no match |
| if (code < NUMBER + 10) |
| return code - NUMBER + 26 + 26 |
| if (code < UPPER + 26) |
| return code - UPPER |
| if (code < LOWER + 26) |
| return code - LOWER + 26 |
| } |
| |
| function b64ToByteArray (b64) { |
| var i, j, l, tmp, placeHolders, arr |
| |
| if (b64.length % 4 > 0) { |
| throw new Error('Invalid string. Length must be a multiple of 4') |
| } |
| |
| // the number of equal signs (place holders) |
| // if there are two placeholders, than the two characters before it |
| // represent one byte |
| // if there is only one, then the three characters before it represent 2 bytes |
| // this is just a cheap hack to not do indexOf twice |
| var len = b64.length |
| placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 |
| |
| // base64 is 4/3 + up to two characters of the original data |
| arr = new Arr(b64.length * 3 / 4 - placeHolders) |
| |
| // if there are placeholders, only get up to the last complete 4 chars |
| l = placeHolders > 0 ? b64.length - 4 : b64.length |
| |
| var L = 0 |
| |
| function push (v) { |
| arr[L++] = v |
| } |
| |
| for (i = 0, j = 0; i < l; i += 4, j += 3) { |
| tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) |
| push((tmp & 0xFF0000) >> 16) |
| push((tmp & 0xFF00) >> 8) |
| push(tmp & 0xFF) |
| } |
| |
| if (placeHolders === 2) { |
| tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) |
| push(tmp & 0xFF) |
| } else if (placeHolders === 1) { |
| tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) |
| push((tmp >> 8) & 0xFF) |
| push(tmp & 0xFF) |
| } |
| |
| return arr |
| } |
| |
| function uint8ToBase64 (uint8) { |
| var i, |
| extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes |
| output = "", |
| temp, length |
| |
| function encode (num) { |
| return lookup.charAt(num) |
| } |
| |
| function tripletToBase64 (num) { |
| return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) |
| } |
| |
| // go through the array every three bytes, we'll deal with trailing stuff later |
| for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { |
| temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) |
| output += tripletToBase64(temp) |
| } |
| |
| // pad the end with zeros, but make sure to not forget the extra bytes |
| switch (extraBytes) { |
| case 1: |
| temp = uint8[uint8.length - 1] |
| output += encode(temp >> 2) |
| output += encode((temp << 4) & 0x3F) |
| output += '==' |
| break |
| case 2: |
| temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) |
| output += encode(temp >> 10) |
| output += encode((temp >> 4) & 0x3F) |
| output += encode((temp << 2) & 0x3F) |
| output += '=' |
| break |
| } |
| |
| return output |
| } |
| |
| module.exports.toByteArray = b64ToByteArray |
| module.exports.fromByteArray = uint8ToBase64 |
| }()) |
| |
| },{}],3:[function(require,module,exports){ |
| /*! |
| * The buffer module from node.js, for the browser. |
| * |
| * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> |
| * @license MIT |
| */ |
| |
| var base64 = require('base64-js') |
| var ieee754 = require('ieee754') |
| |
| exports.Buffer = Buffer |
| exports.SlowBuffer = Buffer |
| exports.INSPECT_MAX_BYTES = 50 |
| Buffer.poolSize = 8192 |
| |
| /** |
| * If `TYPED_ARRAY_SUPPORT`: |
| * === true Use Uint8Array implementation (fastest) |
| * === false Use Object implementation (most compatible, even IE6) |
| * |
| * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, |
| * Opera 11.6+, iOS 4.2+. |
| * |
| * Note: |
| * |
| * - Implementation must support adding new properties to `Uint8Array` instances. |
| * Firefox 4-29 lacked support, fixed in Firefox 30+. |
| * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. |
| * |
| * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. |
| * |
| * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of |
| * incorrect length in some situations. |
| * |
| * We detect these buggy browsers and set `TYPED_ARRAY_SUPPORT` to `false` so they will |
| * get the Object implementation, which is slower but will work correctly. |
| */ |
| var TYPED_ARRAY_SUPPORT = (function () { |
| try { |
| var buf = new ArrayBuffer(0) |
| var arr = new Uint8Array(buf) |
| arr.foo = function () { return 42 } |
| return 42 === arr.foo() && // typed array instances can be augmented |
| typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` |
| new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` |
| } catch (e) { |
| return false |
| } |
| })() |
| |
| /** |
| * Class: Buffer |
| * ============= |
| * |
| * The Buffer constructor returns instances of `Uint8Array` that are augmented |
| * with function properties for all the node `Buffer` API functions. We use |
| * `Uint8Array` so that square bracket notation works as expected -- it returns |
| * a single octet. |
| * |
| * By augmenting the instances, we can avoid modifying the `Uint8Array` |
| * prototype. |
| */ |
| function Buffer (subject, encoding, noZero) { |
| if (!(this instanceof Buffer)) |
| return new Buffer(subject, encoding, noZero) |
| |
| var type = typeof subject |
| |
| // Find the length |
| var length |
| if (type === 'number') |
| length = subject > 0 ? subject >>> 0 : 0 |
| else if (type === 'string') { |
| if (encoding === 'base64') |
| subject = base64clean(subject) |
| length = Buffer.byteLength(subject, encoding) |
| } else if (type === 'object' && subject !== null) { // assume object is array-like |
| if (subject.type === 'Buffer' && isArray(subject.data)) |
| subject = subject.data |
| length = +subject.length > 0 ? Math.floor(+subject.length) : 0 |
| } else |
| throw new Error('First argument needs to be a number, array or string.') |
| |
| var buf |
| if (TYPED_ARRAY_SUPPORT) { |
| // Preferred: Return an augmented `Uint8Array` instance for best performance |
| buf = Buffer._augment(new Uint8Array(length)) |
| } else { |
| // Fallback: Return THIS instance of Buffer (created by `new`) |
| buf = this |
| buf.length = length |
| buf._isBuffer = true |
| } |
| |
| var i |
| if (TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') { |
| // Speed optimization -- use set if we're copying from a typed array |
| buf._set(subject) |
| } else if (isArrayish(subject)) { |
| // Treat array-ish objects as a byte array |
| if (Buffer.isBuffer(subject)) { |
| for (i = 0; i < length; i++) |
| buf[i] = subject.readUInt8(i) |
| } else { |
| for (i = 0; i < length; i++) |
| buf[i] = ((subject[i] % 256) + 256) % 256 |
| } |
| } else if (type === 'string') { |
| buf.write(subject, 0, encoding) |
| } else if (type === 'number' && !TYPED_ARRAY_SUPPORT && !noZero) { |
| for (i = 0; i < length; i++) { |
| buf[i] = 0 |
| } |
| } |
| |
| return buf |
| } |
| |
| // STATIC METHODS |
| // ============== |
| |
| Buffer.isEncoding = function (encoding) { |
| switch (String(encoding).toLowerCase()) { |
| case 'hex': |
| case 'utf8': |
| case 'utf-8': |
| case 'ascii': |
| case 'binary': |
| case 'base64': |
| case 'raw': |
| case 'ucs2': |
| case 'ucs-2': |
| case 'utf16le': |
| case 'utf-16le': |
| return true |
| default: |
| return false |
| } |
| } |
| |
| Buffer.isBuffer = function (b) { |
| return !!(b != null && b._isBuffer) |
| } |
| |
| Buffer.byteLength = function (str, encoding) { |
| var ret |
| str = str.toString() |
| switch (encoding || 'utf8') { |
| case 'hex': |
| ret = str.length / 2 |
| break |
| case 'utf8': |
| case 'utf-8': |
| ret = utf8ToBytes(str).length |
| break |
| case 'ascii': |
| case 'binary': |
| case 'raw': |
| ret = str.length |
| break |
| case 'base64': |
| ret = base64ToBytes(str).length |
| break |
| case 'ucs2': |
| case 'ucs-2': |
| case 'utf16le': |
| case 'utf-16le': |
| ret = str.length * 2 |
| break |
| default: |
| throw new Error('Unknown encoding') |
| } |
| return ret |
| } |
| |
| Buffer.concat = function (list, totalLength) { |
| assert(isArray(list), 'Usage: Buffer.concat(list[, length])') |
| |
| if (list.length === 0) { |
| return new Buffer(0) |
| } else if (list.length === 1) { |
| return list[0] |
| } |
| |
| var i |
| if (totalLength === undefined) { |
| totalLength = 0 |
| for (i = 0; i < list.length; i++) { |
| totalLength += list[i].length |
| } |
| } |
| |
| var buf = new Buffer(totalLength) |
| var pos = 0 |
| for (i = 0; i < list.length; i++) { |
| var item = list[i] |
| item.copy(buf, pos) |
| pos += item.length |
| } |
| return buf |
| } |
| |
| Buffer.compare = function (a, b) { |
| assert(Buffer.isBuffer(a) && Buffer.isBuffer(b), 'Arguments must be Buffers') |
| var x = a.length |
| var y = b.length |
| for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {} |
| if (i !== len) { |
| x = a[i] |
| y = b[i] |
| } |
| if (x < y) { |
| return -1 |
| } |
| if (y < x) { |
| return 1 |
| } |
| return 0 |
| } |
| |
| // BUFFER INSTANCE METHODS |
| // ======================= |
| |
| function hexWrite (buf, string, offset, length) { |
| offset = Number(offset) || 0 |
| var remaining = buf.length - offset |
| if (!length) { |
| length = remaining |
| } else { |
| length = Number(length) |
| if (length > remaining) { |
| length = remaining |
| } |
| } |
| |
| // must be an even number of digits |
| var strLen = string.length |
| assert(strLen % 2 === 0, 'Invalid hex string') |
| |
| if (length > strLen / 2) { |
| length = strLen / 2 |
| } |
| for (var i = 0; i < length; i++) { |
| var byte = parseInt(string.substr(i * 2, 2), 16) |
| assert(!isNaN(byte), 'Invalid hex string') |
| buf[offset + i] = byte |
| } |
| return i |
| } |
| |
| function utf8Write (buf, string, offset, length) { |
| var charsWritten = blitBuffer(utf8ToBytes(string), buf, offset, length) |
| return charsWritten |
| } |
| |
| function asciiWrite (buf, string, offset, length) { |
| var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length) |
| return charsWritten |
| } |
| |
| function binaryWrite (buf, string, offset, length) { |
| return asciiWrite(buf, string, offset, length) |
| } |
| |
| function base64Write (buf, string, offset, length) { |
| var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length) |
| return charsWritten |
| } |
| |
| function utf16leWrite (buf, string, offset, length) { |
| var charsWritten = blitBuffer(utf16leToBytes(string), buf, offset, length) |
| return charsWritten |
| } |
| |
| Buffer.prototype.write = function (string, offset, length, encoding) { |
| // Support both (string, offset, length, encoding) |
| // and the legacy (string, encoding, offset, length) |
| if (isFinite(offset)) { |
| if (!isFinite(length)) { |
| encoding = length |
| length = undefined |
| } |
| } else { // legacy |
| var swap = encoding |
| encoding = offset |
| offset = length |
| length = swap |
| } |
| |
| offset = Number(offset) || 0 |
| var remaining = this.length - offset |
| if (!length) { |
| length = remaining |
| } else { |
| length = Number(length) |
| if (length > remaining) { |
| length = remaining |
| } |
| } |
| encoding = String(encoding || 'utf8').toLowerCase() |
| |
| var ret |
| switch (encoding) { |
| case 'hex': |
| ret = hexWrite(this, string, offset, length) |
| break |
| case 'utf8': |
| case 'utf-8': |
| ret = utf8Write(this, string, offset, length) |
| break |
| case 'ascii': |
| ret = asciiWrite(this, string, offset, length) |
| break |
| case 'binary': |
| ret = binaryWrite(this, string, offset, length) |
| break |
| case 'base64': |
| ret = base64Write(this, string, offset, length) |
| break |
| case 'ucs2': |
| case 'ucs-2': |
| case 'utf16le': |
| case 'utf-16le': |
| ret = utf16leWrite(this, string, offset, length) |
| break |
| default: |
| throw new Error('Unknown encoding') |
| } |
| return ret |
| } |
| |
| Buffer.prototype.toString = function (encoding, start, end) { |
| var self = this |
| |
| encoding = String(encoding || 'utf8').toLowerCase() |
| start = Number(start) || 0 |
| end = (end === undefined) ? self.length : Number(end) |
| |
| // Fastpath empty strings |
| if (end === start) |
| return '' |
| |
| var ret |
| switch (encoding) { |
| case 'hex': |
| ret = hexSlice(self, start, end) |
| break |
| case 'utf8': |
| case 'utf-8': |
| ret = utf8Slice(self, start, end) |
| break |
| case 'ascii': |
| ret = asciiSlice(self, start, end) |
| break |
| case 'binary': |
| ret = binarySlice(self, start, end) |
| break |
| case 'base64': |
| ret = base64Slice(self, start, end) |
| break |
| case 'ucs2': |
| case 'ucs-2': |
| case 'utf16le': |
| case 'utf-16le': |
| ret = utf16leSlice(self, start, end) |
| break |
| default: |
| throw new Error('Unknown encoding') |
| } |
| return ret |
| } |
| |
| Buffer.prototype.toJSON = function () { |
| return { |
| type: 'Buffer', |
| data: Array.prototype.slice.call(this._arr || this, 0) |
| } |
| } |
| |
| Buffer.prototype.equals = function (b) { |
| assert(Buffer.isBuffer(b), 'Argument must be a Buffer') |
| return Buffer.compare(this, b) === 0 |
| } |
| |
| Buffer.prototype.compare = function (b) { |
| assert(Buffer.isBuffer(b), 'Argument must be a Buffer') |
| return Buffer.compare(this, b) |
| } |
| |
| // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) |
| Buffer.prototype.copy = function (target, target_start, start, end) { |
| var source = this |
| |
| if (!start) start = 0 |
| if (!end && end !== 0) end = this.length |
| if (!target_start) target_start = 0 |
| |
| // Copy 0 bytes; we're done |
| if (end === start) return |
| if (target.length === 0 || source.length === 0) return |
| |
| // Fatal error conditions |
| assert(end >= start, 'sourceEnd < sourceStart') |
| assert(target_start >= 0 && target_start < target.length, |
| 'targetStart out of bounds') |
| assert(start >= 0 && start < source.length, 'sourceStart out of bounds') |
| assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds') |
| |
| // Are we oob? |
| if (end > this.length) |
| end = this.length |
| if (target.length - target_start < end - start) |
| end = target.length - target_start + start |
| |
| var len = end - start |
| |
| if (len < 100 || !TYPED_ARRAY_SUPPORT) { |
| for (var i = 0; i < len; i++) { |
| target[i + target_start] = this[i + start] |
| } |
| } else { |
| target._set(this.subarray(start, start + len), target_start) |
| } |
| } |
| |
| function base64Slice (buf, start, end) { |
| if (start === 0 && end === buf.length) { |
| return base64.fromByteArray(buf) |
| } else { |
| return base64.fromByteArray(buf.slice(start, end)) |
| } |
| } |
| |
| function utf8Slice (buf, start, end) { |
| var res = '' |
| var tmp = '' |
| end = Math.min(buf.length, end) |
| |
| for (var i = start; i < end; i++) { |
| if (buf[i] <= 0x7F) { |
| res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]) |
| tmp = '' |
| } else { |
| tmp += '%' + buf[i].toString(16) |
| } |
| } |
| |
| return res + decodeUtf8Char(tmp) |
| } |
| |
| function asciiSlice (buf, start, end) { |
| var ret = '' |
| end = Math.min(buf.length, end) |
| |
| for (var i = start; i < end; i++) { |
| ret += String.fromCharCode(buf[i]) |
| } |
| return ret |
| } |
| |
| function binarySlice (buf, start, end) { |
| return asciiSlice(buf, start, end) |
| } |
| |
| function hexSlice (buf, start, end) { |
| var len = buf.length |
| |
| if (!start || start < 0) start = 0 |
| if (!end || end < 0 || end > len) end = len |
| |
| var out = '' |
| for (var i = start; i < end; i++) { |
| out += toHex(buf[i]) |
| } |
| return out |
| } |
| |
| function utf16leSlice (buf, start, end) { |
| var bytes = buf.slice(start, end) |
| var res = '' |
| for (var i = 0; i < bytes.length; i += 2) { |
| res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) |
| } |
| return res |
| } |
| |
| Buffer.prototype.slice = function (start, end) { |
| var len = this.length |
| start = ~~start |
| end = end === undefined ? len : ~~end |
| |
| if (start < 0) { |
| start += len; |
| if (start < 0) |
| start = 0 |
| } else if (start > len) { |
| start = len |
| } |
| |
| if (end < 0) { |
| end += len |
| if (end < 0) |
| end = 0 |
| } else if (end > len) { |
| end = len |
| } |
| |
| if (end < start) |
| end = start |
| |
| if (TYPED_ARRAY_SUPPORT) { |
| return Buffer._augment(this.subarray(start, end)) |
| } else { |
| var sliceLen = end - start |
| var newBuf = new Buffer(sliceLen, undefined, true) |
| for (var i = 0; i < sliceLen; i++) { |
| newBuf[i] = this[i + start] |
| } |
| return newBuf |
| } |
| } |
| |
| // `get` will be removed in Node 0.13+ |
| Buffer.prototype.get = function (offset) { |
| console.log('.get() is deprecated. Access using array indexes instead.') |
| return this.readUInt8(offset) |
| } |
| |
| // `set` will be removed in Node 0.13+ |
| Buffer.prototype.set = function (v, offset) { |
| console.log('.set() is deprecated. Access using array indexes instead.') |
| return this.writeUInt8(v, offset) |
| } |
| |
| Buffer.prototype.readUInt8 = function (offset, noAssert) { |
| if (!noAssert) { |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset < this.length, 'Trying to read beyond buffer length') |
| } |
| |
| if (offset >= this.length) |
| return |
| |
| return this[offset] |
| } |
| |
| function readUInt16 (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 1 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| var val |
| if (littleEndian) { |
| val = buf[offset] |
| if (offset + 1 < len) |
| val |= buf[offset + 1] << 8 |
| } else { |
| val = buf[offset] << 8 |
| if (offset + 1 < len) |
| val |= buf[offset + 1] |
| } |
| return val |
| } |
| |
| Buffer.prototype.readUInt16LE = function (offset, noAssert) { |
| return readUInt16(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readUInt16BE = function (offset, noAssert) { |
| return readUInt16(this, offset, false, noAssert) |
| } |
| |
| function readUInt32 (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 3 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| var val |
| if (littleEndian) { |
| if (offset + 2 < len) |
| val = buf[offset + 2] << 16 |
| if (offset + 1 < len) |
| val |= buf[offset + 1] << 8 |
| val |= buf[offset] |
| if (offset + 3 < len) |
| val = val + (buf[offset + 3] << 24 >>> 0) |
| } else { |
| if (offset + 1 < len) |
| val = buf[offset + 1] << 16 |
| if (offset + 2 < len) |
| val |= buf[offset + 2] << 8 |
| if (offset + 3 < len) |
| val |= buf[offset + 3] |
| val = val + (buf[offset] << 24 >>> 0) |
| } |
| return val |
| } |
| |
| Buffer.prototype.readUInt32LE = function (offset, noAssert) { |
| return readUInt32(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readUInt32BE = function (offset, noAssert) { |
| return readUInt32(this, offset, false, noAssert) |
| } |
| |
| Buffer.prototype.readInt8 = function (offset, noAssert) { |
| if (!noAssert) { |
| assert(offset !== undefined && offset !== null, |
| 'missing offset') |
| assert(offset < this.length, 'Trying to read beyond buffer length') |
| } |
| |
| if (offset >= this.length) |
| return |
| |
| var neg = this[offset] & 0x80 |
| if (neg) |
| return (0xff - this[offset] + 1) * -1 |
| else |
| return this[offset] |
| } |
| |
| function readInt16 (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 1 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| var val = readUInt16(buf, offset, littleEndian, true) |
| var neg = val & 0x8000 |
| if (neg) |
| return (0xffff - val + 1) * -1 |
| else |
| return val |
| } |
| |
| Buffer.prototype.readInt16LE = function (offset, noAssert) { |
| return readInt16(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readInt16BE = function (offset, noAssert) { |
| return readInt16(this, offset, false, noAssert) |
| } |
| |
| function readInt32 (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 3 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| var val = readUInt32(buf, offset, littleEndian, true) |
| var neg = val & 0x80000000 |
| if (neg) |
| return (0xffffffff - val + 1) * -1 |
| else |
| return val |
| } |
| |
| Buffer.prototype.readInt32LE = function (offset, noAssert) { |
| return readInt32(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readInt32BE = function (offset, noAssert) { |
| return readInt32(this, offset, false, noAssert) |
| } |
| |
| function readFloat (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset + 3 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| return ieee754.read(buf, offset, littleEndian, 23, 4) |
| } |
| |
| Buffer.prototype.readFloatLE = function (offset, noAssert) { |
| return readFloat(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readFloatBE = function (offset, noAssert) { |
| return readFloat(this, offset, false, noAssert) |
| } |
| |
| function readDouble (buf, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset + 7 < buf.length, 'Trying to read beyond buffer length') |
| } |
| |
| return ieee754.read(buf, offset, littleEndian, 52, 8) |
| } |
| |
| Buffer.prototype.readDoubleLE = function (offset, noAssert) { |
| return readDouble(this, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.readDoubleBE = function (offset, noAssert) { |
| return readDouble(this, offset, false, noAssert) |
| } |
| |
| Buffer.prototype.writeUInt8 = function (value, offset, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset < this.length, 'trying to write beyond buffer length') |
| verifuint(value, 0xff) |
| } |
| |
| if (offset >= this.length) return |
| |
| this[offset] = value |
| return offset + 1 |
| } |
| |
| function writeUInt16 (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 1 < buf.length, 'trying to write beyond buffer length') |
| verifuint(value, 0xffff) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) { |
| buf[offset + i] = |
| (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> |
| (littleEndian ? i : 1 - i) * 8 |
| } |
| return offset + 2 |
| } |
| |
| Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) { |
| return writeUInt16(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) { |
| return writeUInt16(this, value, offset, false, noAssert) |
| } |
| |
| function writeUInt32 (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 3 < buf.length, 'trying to write beyond buffer length') |
| verifuint(value, 0xffffffff) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) { |
| buf[offset + i] = |
| (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff |
| } |
| return offset + 4 |
| } |
| |
| Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) { |
| return writeUInt32(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) { |
| return writeUInt32(this, value, offset, false, noAssert) |
| } |
| |
| Buffer.prototype.writeInt8 = function (value, offset, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset < this.length, 'Trying to write beyond buffer length') |
| verifsint(value, 0x7f, -0x80) |
| } |
| |
| if (offset >= this.length) |
| return |
| |
| if (value >= 0) |
| this.writeUInt8(value, offset, noAssert) |
| else |
| this.writeUInt8(0xff + value + 1, offset, noAssert) |
| return offset + 1 |
| } |
| |
| function writeInt16 (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 1 < buf.length, 'Trying to write beyond buffer length') |
| verifsint(value, 0x7fff, -0x8000) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| if (value >= 0) |
| writeUInt16(buf, value, offset, littleEndian, noAssert) |
| else |
| writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert) |
| return offset + 2 |
| } |
| |
| Buffer.prototype.writeInt16LE = function (value, offset, noAssert) { |
| return writeInt16(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeInt16BE = function (value, offset, noAssert) { |
| return writeInt16(this, value, offset, false, noAssert) |
| } |
| |
| function writeInt32 (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 3 < buf.length, 'Trying to write beyond buffer length') |
| verifsint(value, 0x7fffffff, -0x80000000) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| if (value >= 0) |
| writeUInt32(buf, value, offset, littleEndian, noAssert) |
| else |
| writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert) |
| return offset + 4 |
| } |
| |
| Buffer.prototype.writeInt32LE = function (value, offset, noAssert) { |
| return writeInt32(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeInt32BE = function (value, offset, noAssert) { |
| return writeInt32(this, value, offset, false, noAssert) |
| } |
| |
| function writeFloat (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 3 < buf.length, 'Trying to write beyond buffer length') |
| verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| ieee754.write(buf, value, offset, littleEndian, 23, 4) |
| return offset + 4 |
| } |
| |
| Buffer.prototype.writeFloatLE = function (value, offset, noAssert) { |
| return writeFloat(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeFloatBE = function (value, offset, noAssert) { |
| return writeFloat(this, value, offset, false, noAssert) |
| } |
| |
| function writeDouble (buf, value, offset, littleEndian, noAssert) { |
| if (!noAssert) { |
| assert(value !== undefined && value !== null, 'missing value') |
| assert(typeof littleEndian === 'boolean', 'missing or invalid endian') |
| assert(offset !== undefined && offset !== null, 'missing offset') |
| assert(offset + 7 < buf.length, |
| 'Trying to write beyond buffer length') |
| verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308) |
| } |
| |
| var len = buf.length |
| if (offset >= len) |
| return |
| |
| ieee754.write(buf, value, offset, littleEndian, 52, 8) |
| return offset + 8 |
| } |
| |
| Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) { |
| return writeDouble(this, value, offset, true, noAssert) |
| } |
| |
| Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) { |
| return writeDouble(this, value, offset, false, noAssert) |
| } |
| |
| // fill(value, start=0, end=buffer.length) |
| Buffer.prototype.fill = function (value, start, end) { |
| if (!value) value = 0 |
| if (!start) start = 0 |
| if (!end) end = this.length |
| |
| assert(end >= start, 'end < start') |
| |
| // Fill 0 bytes; we're done |
| if (end === start) return |
| if (this.length === 0) return |
| |
| assert(start >= 0 && start < this.length, 'start out of bounds') |
| assert(end >= 0 && end <= this.length, 'end out of bounds') |
| |
| var i |
| if (typeof value === 'number') { |
| for (i = start; i < end; i++) { |
| this[i] = value |
| } |
| } else { |
| var bytes = utf8ToBytes(value.toString()) |
| var len = bytes.length |
| for (i = start; i < end; i++) { |
| this[i] = bytes[i % len] |
| } |
| } |
| |
| return this |
| } |
| |
| Buffer.prototype.inspect = function () { |
| var out = [] |
| var len = this.length |
| for (var i = 0; i < len; i++) { |
| out[i] = toHex(this[i]) |
| if (i === exports.INSPECT_MAX_BYTES) { |
| out[i + 1] = '...' |
| break |
| } |
| } |
| return '<Buffer ' + out.join(' ') + '>' |
| } |
| |
| /** |
| * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. |
| * Added in Node 0.12. Only available in browsers that support ArrayBuffer. |
| */ |
| Buffer.prototype.toArrayBuffer = function () { |
| if (typeof Uint8Array !== 'undefined') { |
| if (TYPED_ARRAY_SUPPORT) { |
| return (new Buffer(this)).buffer |
| } else { |
| var buf = new Uint8Array(this.length) |
| for (var i = 0, len = buf.length; i < len; i += 1) { |
| buf[i] = this[i] |
| } |
| return buf.buffer |
| } |
| } else { |
| throw new Error('Buffer.toArrayBuffer not supported in this browser') |
| } |
| } |
| |
| // HELPER FUNCTIONS |
| // ================ |
| |
| var BP = Buffer.prototype |
| |
| /** |
| * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods |
| */ |
| Buffer._augment = function (arr) { |
| arr._isBuffer = true |
| |
| // save reference to original Uint8Array get/set methods before overwriting |
| arr._get = arr.get |
| arr._set = arr.set |
| |
| // deprecated, will be removed in node 0.13+ |
| arr.get = BP.get |
| arr.set = BP.set |
| |
| arr.write = BP.write |
| arr.toString = BP.toString |
| arr.toLocaleString = BP.toString |
| arr.toJSON = BP.toJSON |
| arr.equals = BP.equals |
| arr.compare = BP.compare |
| arr.copy = BP.copy |
| arr.slice = BP.slice |
| arr.readUInt8 = BP.readUInt8 |
| arr.readUInt16LE = BP.readUInt16LE |
| arr.readUInt16BE = BP.readUInt16BE |
| arr.readUInt32LE = BP.readUInt32LE |
| arr.readUInt32BE = BP.readUInt32BE |
| arr.readInt8 = BP.readInt8 |
| arr.readInt16LE = BP.readInt16LE |
| arr.readInt16BE = BP.readInt16BE |
| arr.readInt32LE = BP.readInt32LE |
| arr.readInt32BE = BP.readInt32BE |
| arr.readFloatLE = BP.readFloatLE |
| arr.readFloatBE = BP.readFloatBE |
| arr.readDoubleLE = BP.readDoubleLE |
| arr.readDoubleBE = BP.readDoubleBE |
| arr.writeUInt8 = BP.writeUInt8 |
| arr.writeUInt16LE = BP.writeUInt16LE |
| arr.writeUInt16BE = BP.writeUInt16BE |
| arr.writeUInt32LE = BP.writeUInt32LE |
| arr.writeUInt32BE = BP.writeUInt32BE |
| arr.writeInt8 = BP.writeInt8 |
| arr.writeInt16LE = BP.writeInt16LE |
| arr.writeInt16BE = BP.writeInt16BE |
| arr.writeInt32LE = BP.writeInt32LE |
| arr.writeInt32BE = BP.writeInt32BE |
| arr.writeFloatLE = BP.writeFloatLE |
| arr.writeFloatBE = BP.writeFloatBE |
| arr.writeDoubleLE = BP.writeDoubleLE |
| arr.writeDoubleBE = BP.writeDoubleBE |
| arr.fill = BP.fill |
| arr.inspect = BP.inspect |
| arr.toArrayBuffer = BP.toArrayBuffer |
| |
| return arr |
| } |
| |
| var INVALID_BASE64_RE = /[^+\/0-9A-z]/g |
| |
| function base64clean (str) { |
| // Node strips out invalid characters like \n and \t from the string, base64-js does not |
| str = stringtrim(str).replace(INVALID_BASE64_RE, '') |
| // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not |
| while (str.length % 4 !== 0) { |
| str = str + '=' |
| } |
| return str |
| } |
| |
| function stringtrim (str) { |
| if (str.trim) return str.trim() |
| return str.replace(/^\s+|\s+$/g, '') |
| } |
| |
| function isArray (subject) { |
| return (Array.isArray || function (subject) { |
| return Object.prototype.toString.call(subject) === '[object Array]' |
| })(subject) |
| } |
| |
| function isArrayish (subject) { |
| return isArray(subject) || Buffer.isBuffer(subject) || |
| subject && typeof subject === 'object' && |
| typeof subject.length === 'number' |
| } |
| |
| function toHex (n) { |
| if (n < 16) return '0' + n.toString(16) |
| return n.toString(16) |
| } |
| |
| function utf8ToBytes (str) { |
| var byteArray = [] |
| for (var i = 0; i < str.length; i++) { |
| var b = str.charCodeAt(i) |
| if (b <= 0x7F) { |
| byteArray.push(b) |
| } else { |
| var start = i |
| if (b >= 0xD800 && b <= 0xDFFF) i++ |
| var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%') |
| for (var j = 0; j < h.length; j++) { |
| byteArray.push(parseInt(h[j], 16)) |
| } |
| } |
| } |
| return byteArray |
| } |
| |
| function asciiToBytes (str) { |
| var byteArray = [] |
| for (var i = 0; i < str.length; i++) { |
| // Node's code seems to be doing this and not & 0x7F.. |
| byteArray.push(str.charCodeAt(i) & 0xFF) |
| } |
| return byteArray |
| } |
| |
| function utf16leToBytes (str) { |
| var c, hi, lo |
| var byteArray = [] |
| for (var i = 0; i < str.length; i++) { |
| c = str.charCodeAt(i) |
| hi = c >> 8 |
| lo = c % 256 |
| byteArray.push(lo) |
| byteArray.push(hi) |
| } |
| |
| return byteArray |
| } |
| |
| function base64ToBytes (str) { |
| return base64.toByteArray(str) |
| } |
| |
| function blitBuffer (src, dst, offset, length) { |
| for (var i = 0; i < length; i++) { |
| if ((i + offset >= dst.length) || (i >= src.length)) |
| break |
| dst[i + offset] = src[i] |
| } |
| return i |
| } |
| |
| function decodeUtf8Char (str) { |
| try { |
| return decodeURIComponent(str) |
| } catch (err) { |
| return String.fromCharCode(0xFFFD) // UTF 8 invalid char |
| } |
| } |
| |
| /* |
| * We have to make sure that the value is a valid integer. This means that it |
| * is non-negative. It has no fractional component and that it does not |
| * exceed the maximum allowed value. |
| */ |
| function verifuint (value, max) { |
| assert(typeof value === 'number', 'cannot write a non-number as a number') |
| assert(value >= 0, 'specified a negative value for writing an unsigned value') |
| assert(value <= max, 'value is larger than maximum value for type') |
| assert(Math.floor(value) === value, 'value has a fractional component') |
| } |
| |
| function verifsint (value, max, min) { |
| assert(typeof value === 'number', 'cannot write a non-number as a number') |
| assert(value <= max, 'value larger than maximum allowed value') |
| assert(value >= min, 'value smaller than minimum allowed value') |
| assert(Math.floor(value) === value, 'value has a fractional component') |
| } |
| |
| function verifIEEE754 (value, max, min) { |
| assert(typeof value === 'number', 'cannot write a non-number as a number') |
| assert(value <= max, 'value larger than maximum allowed value') |
| assert(value >= min, 'value smaller than minimum allowed value') |
| } |
| |
| function assert (test, message) { |
| if (!test) throw new Error(message || 'Failed assertion') |
| } |
| |
| },{"base64-js":2,"ieee754":4}],4:[function(require,module,exports){ |
| exports.read = function(buffer, offset, isLE, mLen, nBytes) { |
| var e, m, |
| eLen = nBytes * 8 - mLen - 1, |
| eMax = (1 << eLen) - 1, |
| eBias = eMax >> 1, |
| nBits = -7, |
| i = isLE ? (nBytes - 1) : 0, |
| d = isLE ? -1 : 1, |
| s = buffer[offset + i]; |
| |
| i += d; |
| |
| e = s & ((1 << (-nBits)) - 1); |
| s >>= (-nBits); |
| nBits += eLen; |
| for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8); |
| |
| m = e & ((1 << (-nBits)) - 1); |
| e >>= (-nBits); |
| nBits += mLen; |
| for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8); |
| |
| if (e === 0) { |
| e = 1 - eBias; |
| } else if (e === eMax) { |
| return m ? NaN : ((s ? -1 : 1) * Infinity); |
| } else { |
| m = m + Math.pow(2, mLen); |
| e = e - eBias; |
| } |
| return (s ? -1 : 1) * m * Math.pow(2, e - mLen); |
| }; |
| |
| exports.write = function(buffer, value, offset, isLE, mLen, nBytes) { |
| var e, m, c, |
| eLen = nBytes * 8 - mLen - 1, |
| eMax = (1 << eLen) - 1, |
| eBias = eMax >> 1, |
| rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0), |
| i = isLE ? 0 : (nBytes - 1), |
| d = isLE ? 1 : -1, |
| s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; |
| |
| value = Math.abs(value); |
| |
| if (isNaN(value) || value === Infinity) { |
| m = isNaN(value) ? 1 : 0; |
| e = eMax; |
| } else { |
| e = Math.floor(Math.log(value) / Math.LN2); |
| if (value * (c = Math.pow(2, -e)) < 1) { |
| e--; |
| c *= 2; |
| } |
| if (e + eBias >= 1) { |
| value += rt / c; |
| } else { |
| value += rt * Math.pow(2, 1 - eBias); |
| } |
| if (value * c >= 2) { |
| e++; |
| c /= 2; |
| } |
| |
| if (e + eBias >= eMax) { |
| m = 0; |
| e = eMax; |
| } else if (e + eBias >= 1) { |
| m = (value * c - 1) * Math.pow(2, mLen); |
| e = e + eBias; |
| } else { |
| m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); |
| e = 0; |
| } |
| } |
| |
| for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8); |
| |
| e = (e << mLen) | m; |
| eLen += mLen; |
| for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8); |
| |
| buffer[offset + i - d] |= s * 128; |
| }; |
| |
| },{}],5:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLAttribute, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLAttribute = (function() { |
| function XMLAttribute(parent, name, value) { |
| this.stringify = parent.stringify; |
| if (name == null) { |
| throw new Error("Missing attribute name"); |
| } |
| if (value == null) { |
| throw new Error("Missing attribute value"); |
| } |
| this.name = this.stringify.attName(name); |
| this.value = this.stringify.attValue(value); |
| } |
| |
| XMLAttribute.prototype.clone = function() { |
| return _.create(XMLAttribute.prototype, this); |
| }; |
| |
| XMLAttribute.prototype.toString = function(options, level) { |
| return ' ' + this.name + '="' + this.value + '"'; |
| }; |
| |
| return XMLAttribute; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],6:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLBuilder, XMLDeclaration, XMLDocType, XMLElement, XMLStringifier, _; |
| |
| _ = require('lodash-node'); |
| |
| XMLStringifier = require('./XMLStringifier'); |
| |
| XMLDeclaration = require('./XMLDeclaration'); |
| |
| XMLDocType = require('./XMLDocType'); |
| |
| XMLElement = require('./XMLElement'); |
| |
| module.exports = XMLBuilder = (function() { |
| function XMLBuilder(name, options) { |
| var root, temp; |
| if (name == null) { |
| throw new Error("Root element needs a name"); |
| } |
| if (options == null) { |
| options = {}; |
| } |
| this.options = options; |
| this.stringify = new XMLStringifier(options); |
| temp = new XMLElement(this, 'doc'); |
| root = temp.element(name); |
| root.isRoot = true; |
| root.documentObject = this; |
| this.rootObject = root; |
| if (!options.headless) { |
| root.declaration(options); |
| if ((options.pubID != null) || (options.sysID != null)) { |
| root.doctype(options); |
| } |
| } |
| } |
| |
| XMLBuilder.prototype.root = function() { |
| return this.rootObject; |
| }; |
| |
| XMLBuilder.prototype.end = function(options) { |
| return toString(options); |
| }; |
| |
| XMLBuilder.prototype.toString = function(options) { |
| var indent, newline, pretty, r; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| r = ''; |
| if (this.xmldec != null) { |
| r += this.xmldec.toString(options); |
| } |
| if (this.doctype != null) { |
| r += this.doctype.toString(options); |
| } |
| r += this.rootObject.toString(options); |
| if (pretty && r.slice(-newline.length) === newline) { |
| r = r.slice(0, -newline.length); |
| } |
| return r; |
| }; |
| |
| return XMLBuilder; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"./XMLDeclaration":13,"./XMLDocType":14,"./XMLElement":15,"./XMLStringifier":19,"lodash-node":95}],7:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLCData, XMLNode, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| module.exports = XMLCData = (function(_super) { |
| __extends(XMLCData, _super); |
| |
| function XMLCData(parent, text) { |
| XMLCData.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing CDATA text"); |
| } |
| this.text = this.stringify.cdata(text); |
| } |
| |
| XMLCData.prototype.clone = function() { |
| return _.create(XMLCData.prototype, this); |
| }; |
| |
| XMLCData.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<![CDATA[' + this.text + ']]>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLCData; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLNode":16,"lodash-node":95}],8:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLComment, XMLNode, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| module.exports = XMLComment = (function(_super) { |
| __extends(XMLComment, _super); |
| |
| function XMLComment(parent, text) { |
| XMLComment.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing comment text"); |
| } |
| this.text = this.stringify.comment(text); |
| } |
| |
| XMLComment.prototype.clone = function() { |
| return _.create(XMLComment.prototype, this); |
| }; |
| |
| XMLComment.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!-- ' + this.text + ' -->'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLComment; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLNode":16,"lodash-node":95}],9:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDTDAttList, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLDTDAttList = (function() { |
| function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| this.stringify = parent.stringify; |
| if (elementName == null) { |
| throw new Error("Missing DTD element name"); |
| } |
| if (attributeName == null) { |
| throw new Error("Missing DTD attribute name"); |
| } |
| if (!attributeType) { |
| throw new Error("Missing DTD attribute type"); |
| } |
| if (!defaultValueType) { |
| throw new Error("Missing DTD attribute default"); |
| } |
| if (defaultValueType.indexOf('#') !== 0) { |
| defaultValueType = '#' + defaultValueType; |
| } |
| if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) { |
| throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT"); |
| } |
| if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) { |
| throw new Error("Default value only applies to #FIXED or #DEFAULT"); |
| } |
| this.elementName = this.stringify.eleName(elementName); |
| this.attributeName = this.stringify.attName(attributeName); |
| this.attributeType = this.stringify.dtdAttType(attributeType); |
| this.defaultValue = this.stringify.dtdAttDefault(defaultValue); |
| this.defaultValueType = defaultValueType; |
| } |
| |
| XMLDTDAttList.prototype.clone = function() { |
| return _.create(XMLDTDAttList.prototype, this); |
| }; |
| |
| XMLDTDAttList.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!ATTLIST ' + this.elementName + ' ' + this.attributeName + ' ' + this.attributeType; |
| if (this.defaultValueType !== '#DEFAULT') { |
| r += ' ' + this.defaultValueType; |
| } |
| if (this.defaultValue) { |
| r += ' "' + this.defaultValue + '"'; |
| } |
| r += '>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLDTDAttList; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],10:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDTDElement, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLDTDElement = (function() { |
| function XMLDTDElement(parent, name, value) { |
| this.stringify = parent.stringify; |
| if (name == null) { |
| throw new Error("Missing DTD element name"); |
| } |
| if (!value) { |
| value = '(#PCDATA)'; |
| } |
| if (_.isArray(value)) { |
| value = '(' + value.join(',') + ')'; |
| } |
| this.name = this.stringify.eleName(name); |
| this.value = this.stringify.dtdElementValue(value); |
| } |
| |
| XMLDTDElement.prototype.clone = function() { |
| return _.create(XMLDTDElement.prototype, this); |
| }; |
| |
| XMLDTDElement.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!ELEMENT ' + this.name + ' ' + this.value + '>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLDTDElement; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],11:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDTDEntity, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLDTDEntity = (function() { |
| function XMLDTDEntity(parent, pe, name, value) { |
| this.stringify = parent.stringify; |
| if (name == null) { |
| throw new Error("Missing entity name"); |
| } |
| if (value == null) { |
| throw new Error("Missing entity value"); |
| } |
| this.pe = !!pe; |
| this.name = this.stringify.eleName(name); |
| if (!_.isObject(value)) { |
| this.value = this.stringify.dtdEntityValue(value); |
| } else { |
| if (!value.pubID && !value.sysID) { |
| throw new Error("Public and/or system identifiers are required for an external entity"); |
| } |
| if (value.pubID && !value.sysID) { |
| throw new Error("System identifier is required for a public external entity"); |
| } |
| if (value.pubID != null) { |
| this.pubID = this.stringify.dtdPubID(value.pubID); |
| } |
| if (value.sysID != null) { |
| this.sysID = this.stringify.dtdSysID(value.sysID); |
| } |
| if (value.nData != null) { |
| this.nData = this.stringify.dtdNData(value.nData); |
| } |
| if (this.pe && this.nData) { |
| throw new Error("Notation declaration is not allowed in a parameter entity"); |
| } |
| } |
| } |
| |
| XMLDTDEntity.prototype.clone = function() { |
| return _.create(XMLDTDEntity.prototype, this); |
| }; |
| |
| XMLDTDEntity.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!ENTITY'; |
| if (this.pe) { |
| r += ' %'; |
| } |
| r += ' ' + this.name; |
| if (this.value) { |
| r += ' "' + this.value + '"'; |
| } else { |
| if (this.pubID && this.sysID) { |
| r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"'; |
| } else if (this.sysID) { |
| r += ' SYSTEM "' + this.sysID + '"'; |
| } |
| if (this.nData) { |
| r += ' NDATA ' + this.nData; |
| } |
| } |
| r += '>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLDTDEntity; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],12:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDTDNotation, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLDTDNotation = (function() { |
| function XMLDTDNotation(parent, name, value) { |
| this.stringify = parent.stringify; |
| if (name == null) { |
| throw new Error("Missing notation name"); |
| } |
| if (!value.pubID && !value.sysID) { |
| throw new Error("Public or system identifiers are required for an external entity"); |
| } |
| this.name = this.stringify.eleName(name); |
| if (value.pubID != null) { |
| this.pubID = this.stringify.dtdPubID(value.pubID); |
| } |
| if (value.sysID != null) { |
| this.sysID = this.stringify.dtdSysID(value.sysID); |
| } |
| } |
| |
| XMLDTDNotation.prototype.clone = function() { |
| return _.create(XMLDTDNotation.prototype, this); |
| }; |
| |
| XMLDTDNotation.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!NOTATION ' + this.name; |
| if (this.pubID && this.sysID) { |
| r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"'; |
| } else if (this.pubID) { |
| r += ' PUBLIC "' + this.pubID + '"'; |
| } else if (this.sysID) { |
| r += ' SYSTEM "' + this.sysID + '"'; |
| } |
| r += '>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLDTDNotation; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],13:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDeclaration, XMLNode, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| module.exports = XMLDeclaration = (function(_super) { |
| __extends(XMLDeclaration, _super); |
| |
| function XMLDeclaration(parent, version, encoding, standalone) { |
| var _ref; |
| XMLDeclaration.__super__.constructor.call(this, parent); |
| if (_.isObject(version)) { |
| _ref = version, version = _ref.version, encoding = _ref.encoding, standalone = _ref.standalone; |
| } |
| if (!version) { |
| version = '1.0'; |
| } |
| if (version != null) { |
| this.version = this.stringify.xmlVersion(version); |
| } |
| if (encoding != null) { |
| this.encoding = this.stringify.xmlEncoding(encoding); |
| } |
| if (standalone != null) { |
| this.standalone = this.stringify.xmlStandalone(standalone); |
| } |
| } |
| |
| XMLDeclaration.prototype.clone = function() { |
| return _.create(XMLDeclaration.prototype, this); |
| }; |
| |
| XMLDeclaration.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<?xml'; |
| if (this.version != null) { |
| r += ' version="' + this.version + '"'; |
| } |
| if (this.encoding != null) { |
| r += ' encoding="' + this.encoding + '"'; |
| } |
| if (this.standalone != null) { |
| r += ' standalone="' + this.standalone + '"'; |
| } |
| r += '?>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLDeclaration; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLNode":16,"lodash-node":95}],14:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLDocType, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLDocType = (function() { |
| function XMLDocType(parent, pubID, sysID) { |
| var _ref, _ref1; |
| this.documentObject = parent; |
| this.stringify = this.documentObject.stringify; |
| this.children = []; |
| if (_.isObject(pubID)) { |
| _ref = pubID, pubID = _ref.pubID, sysID = _ref.sysID; |
| } |
| if (sysID == null) { |
| _ref1 = [pubID, sysID], sysID = _ref1[0], pubID = _ref1[1]; |
| } |
| if (pubID != null) { |
| this.pubID = this.stringify.dtdPubID(pubID); |
| } |
| if (sysID != null) { |
| this.sysID = this.stringify.dtdSysID(sysID); |
| } |
| } |
| |
| XMLDocType.prototype.clone = function() { |
| return _.create(XMLDocType.prototype, this); |
| }; |
| |
| XMLDocType.prototype.element = function(name, value) { |
| var XMLDTDElement, child; |
| XMLDTDElement = require('./XMLDTDElement'); |
| child = new XMLDTDElement(this, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| var XMLDTDAttList, child; |
| XMLDTDAttList = require('./XMLDTDAttList'); |
| child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.entity = function(name, value) { |
| var XMLDTDEntity, child; |
| XMLDTDEntity = require('./XMLDTDEntity'); |
| child = new XMLDTDEntity(this, false, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.pEntity = function(name, value) { |
| var XMLDTDEntity, child; |
| XMLDTDEntity = require('./XMLDTDEntity'); |
| child = new XMLDTDEntity(this, true, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.notation = function(name, value) { |
| var XMLDTDNotation, child; |
| XMLDTDNotation = require('./XMLDTDNotation'); |
| child = new XMLDTDNotation(this, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.cdata = function(value) { |
| var XMLCData, child; |
| XMLCData = require('./XMLCData'); |
| child = new XMLCData(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.comment = function(value) { |
| var XMLComment, child; |
| XMLComment = require('./XMLComment'); |
| child = new XMLComment(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.instruction = function(target, value) { |
| var XMLProcessingInstruction, child; |
| XMLProcessingInstruction = require('./XMLProcessingInstruction'); |
| child = new XMLProcessingInstruction(this, target, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.root = function() { |
| return this.documentObject.root(); |
| }; |
| |
| XMLDocType.prototype.document = function() { |
| return this.documentObject; |
| }; |
| |
| XMLDocType.prototype.toString = function(options, level) { |
| var child, indent, newline, pretty, r, space, _i, _len, _ref; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<!DOCTYPE ' + this.root().name; |
| if (this.pubID && this.sysID) { |
| r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"'; |
| } else if (this.sysID) { |
| r += ' SYSTEM "' + this.sysID + '"'; |
| } |
| if (this.children.length > 0) { |
| r += ' ['; |
| if (pretty) { |
| r += newline; |
| } |
| _ref = this.children; |
| for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| child = _ref[_i]; |
| r += child.toString(options, level + 1); |
| } |
| r += ']'; |
| } |
| r += '>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| XMLDocType.prototype.ele = function(name, value) { |
| return this.element(name, value); |
| }; |
| |
| XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue); |
| }; |
| |
| XMLDocType.prototype.ent = function(name, value) { |
| return this.entity(name, value); |
| }; |
| |
| XMLDocType.prototype.pent = function(name, value) { |
| return this.pEntity(name, value); |
| }; |
| |
| XMLDocType.prototype.not = function(name, value) { |
| return this.notation(name, value); |
| }; |
| |
| XMLDocType.prototype.dat = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLDocType.prototype.com = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLDocType.prototype.ins = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLDocType.prototype.up = function() { |
| return this.root(); |
| }; |
| |
| XMLDocType.prototype.doc = function() { |
| return this.document(); |
| }; |
| |
| return XMLDocType; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"./XMLCData":7,"./XMLComment":8,"./XMLDTDAttList":9,"./XMLDTDElement":10,"./XMLDTDEntity":11,"./XMLDTDNotation":12,"./XMLProcessingInstruction":17,"lodash-node":95}],15:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLAttribute, XMLElement, XMLNode, XMLProcessingInstruction, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| XMLAttribute = require('./XMLAttribute'); |
| |
| XMLProcessingInstruction = require('./XMLProcessingInstruction'); |
| |
| module.exports = XMLElement = (function(_super) { |
| __extends(XMLElement, _super); |
| |
| function XMLElement(parent, name, attributes) { |
| XMLElement.__super__.constructor.call(this, parent); |
| if (name == null) { |
| throw new Error("Missing element name"); |
| } |
| this.name = this.stringify.eleName(name); |
| this.children = []; |
| this.instructions = []; |
| this.attributes = {}; |
| if (attributes != null) { |
| this.attribute(attributes); |
| } |
| } |
| |
| XMLElement.prototype.clone = function() { |
| var att, attName, clonedSelf, pi, _i, _len, _ref, _ref1; |
| clonedSelf = _.create(XMLElement.prototype, this); |
| clonedSelf.attributes = {}; |
| _ref = this.attributes; |
| for (attName in _ref) { |
| if (!__hasProp.call(_ref, attName)) continue; |
| att = _ref[attName]; |
| clonedSelf.attributes[attName] = att.clone(); |
| } |
| clonedSelf.instructions = []; |
| _ref1 = this.instructions; |
| for (_i = 0, _len = _ref1.length; _i < _len; _i++) { |
| pi = _ref1[_i]; |
| clonedSelf.instructions.push(pi.clone()); |
| } |
| clonedSelf.children = []; |
| this.children.forEach(function(child) { |
| var clonedChild; |
| clonedChild = child.clone(); |
| clonedChild.parent = clonedSelf; |
| return clonedSelf.children.push(clonedChild); |
| }); |
| return clonedSelf; |
| }; |
| |
| XMLElement.prototype.attribute = function(name, value) { |
| var attName, attValue; |
| if (_.isObject(name)) { |
| for (attName in name) { |
| if (!__hasProp.call(name, attName)) continue; |
| attValue = name[attName]; |
| this.attribute(attName, attValue); |
| } |
| } else { |
| if (_.isFunction(value)) { |
| value = value.apply(); |
| } |
| if (!this.options.skipNullAttributes || (value != null)) { |
| this.attributes[name] = new XMLAttribute(this, name, value); |
| } |
| } |
| return this; |
| }; |
| |
| XMLElement.prototype.removeAttribute = function(name) { |
| var attName, _i, _len; |
| if (name == null) { |
| throw new Error("Missing attribute name"); |
| } |
| if (_.isArray(name)) { |
| for (_i = 0, _len = name.length; _i < _len; _i++) { |
| attName = name[_i]; |
| delete this.attributes[attName]; |
| } |
| } else { |
| delete this.attributes[name]; |
| } |
| return this; |
| }; |
| |
| XMLElement.prototype.instruction = function(target, value) { |
| var insTarget, insValue, instruction, _i, _len; |
| if (_.isArray(target)) { |
| for (_i = 0, _len = target.length; _i < _len; _i++) { |
| insTarget = target[_i]; |
| this.instruction(insTarget); |
| } |
| } else if (_.isObject(target)) { |
| for (insTarget in target) { |
| if (!__hasProp.call(target, insTarget)) continue; |
| insValue = target[insTarget]; |
| this.instruction(insTarget, insValue); |
| } |
| } else { |
| if (_.isFunction(value)) { |
| value = value.apply(); |
| } |
| instruction = new XMLProcessingInstruction(this, target, value); |
| this.instructions.push(instruction); |
| } |
| return this; |
| }; |
| |
| XMLElement.prototype.toString = function(options, level) { |
| var att, child, indent, instruction, name, newline, pretty, r, space, _i, _j, _len, _len1, _ref, _ref1, _ref2; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| _ref = this.instructions; |
| for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| instruction = _ref[_i]; |
| r += instruction.toString(options, level + 1); |
| } |
| if (pretty) { |
| r += space; |
| } |
| r += '<' + this.name; |
| _ref1 = this.attributes; |
| for (name in _ref1) { |
| if (!__hasProp.call(_ref1, name)) continue; |
| att = _ref1[name]; |
| r += att.toString(options); |
| } |
| if (this.children.length === 0) { |
| r += '/>'; |
| if (pretty) { |
| r += newline; |
| } |
| } else if (pretty && this.children.length === 1 && (this.children[0].value != null)) { |
| r += '>'; |
| r += this.children[0].value; |
| r += '</' + this.name + '>'; |
| r += newline; |
| } else { |
| r += '>'; |
| if (pretty) { |
| r += newline; |
| } |
| _ref2 = this.children; |
| for (_j = 0, _len1 = _ref2.length; _j < _len1; _j++) { |
| child = _ref2[_j]; |
| r += child.toString(options, level + 1); |
| } |
| if (pretty) { |
| r += space; |
| } |
| r += '</' + this.name + '>'; |
| if (pretty) { |
| r += newline; |
| } |
| } |
| return r; |
| }; |
| |
| XMLElement.prototype.att = function(name, value) { |
| return this.attribute(name, value); |
| }; |
| |
| XMLElement.prototype.ins = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLElement.prototype.a = function(name, value) { |
| return this.attribute(name, value); |
| }; |
| |
| XMLElement.prototype.i = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| return XMLElement; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLAttribute":5,"./XMLNode":16,"./XMLProcessingInstruction":17,"lodash-node":95}],16:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLNode, _, |
| __hasProp = {}.hasOwnProperty; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLNode = (function() { |
| function XMLNode(parent) { |
| this.parent = parent; |
| this.options = this.parent.options; |
| this.stringify = this.parent.stringify; |
| } |
| |
| XMLNode.prototype.clone = function() { |
| throw new Error("Cannot clone generic XMLNode"); |
| }; |
| |
| XMLNode.prototype.element = function(name, attributes, text) { |
| var item, key, lastChild, val, _i, _len, _ref; |
| lastChild = null; |
| if (attributes == null) { |
| attributes = {}; |
| } |
| if (!_.isObject(attributes)) { |
| _ref = [attributes, text], text = _ref[0], attributes = _ref[1]; |
| } |
| if (_.isArray(name)) { |
| for (_i = 0, _len = name.length; _i < _len; _i++) { |
| item = name[_i]; |
| lastChild = this.element(item); |
| } |
| } else if (_.isFunction(name)) { |
| lastChild = this.element(name.apply()); |
| } else if (_.isObject(name)) { |
| for (key in name) { |
| if (!__hasProp.call(name, key)) continue; |
| val = name[key]; |
| if (!(val != null)) { |
| continue; |
| } |
| if (_.isFunction(val)) { |
| val = val.apply(); |
| } |
| if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) { |
| lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && key.indexOf(this.stringify.convertPIKey) === 0) { |
| lastChild = this.instruction(key.substr(this.stringify.convertPIKey.length), val); |
| } else if (_.isObject(val)) { |
| if (!this.options.ignoreDecorators && this.stringify.convertListKey && key.indexOf(this.stringify.convertListKey) === 0 && _.isArray(val)) { |
| lastChild = this.element(val); |
| } else { |
| lastChild = this.element(key); |
| lastChild.element(val); |
| } |
| } else { |
| lastChild = this.element(key, val); |
| } |
| } |
| } else { |
| if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) { |
| lastChild = this.text(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) { |
| lastChild = this.cdata(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) { |
| lastChild = this.comment(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) { |
| lastChild = this.raw(text); |
| } else { |
| lastChild = this.node(name, attributes, text); |
| } |
| } |
| if (lastChild == null) { |
| throw new Error("Could not create any elements with: " + name); |
| } |
| return lastChild; |
| }; |
| |
| XMLNode.prototype.insertBefore = function(name, attributes, text) { |
| var child, i, removed; |
| if (this.isRoot) { |
| throw new Error("Cannot insert elements at root level"); |
| } |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i); |
| child = this.parent.element(name, attributes, text); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return child; |
| }; |
| |
| XMLNode.prototype.insertAfter = function(name, attributes, text) { |
| var child, i, removed; |
| if (this.isRoot) { |
| throw new Error("Cannot insert elements at root level"); |
| } |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i + 1); |
| child = this.parent.element(name, attributes, text); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return child; |
| }; |
| |
| XMLNode.prototype.remove = function() { |
| var i, _ref; |
| if (this.isRoot) { |
| throw new Error("Cannot remove the root element"); |
| } |
| i = this.parent.children.indexOf(this); |
| [].splice.apply(this.parent.children, [i, i - i + 1].concat(_ref = [])), _ref; |
| return this.parent; |
| }; |
| |
| XMLNode.prototype.node = function(name, attributes, text) { |
| var XMLElement, child, _ref; |
| if (attributes == null) { |
| attributes = {}; |
| } |
| if (!_.isObject(attributes)) { |
| _ref = [attributes, text], text = _ref[0], attributes = _ref[1]; |
| } |
| XMLElement = require('./XMLElement'); |
| child = new XMLElement(this, name, attributes); |
| if (text != null) { |
| child.text(text); |
| } |
| this.children.push(child); |
| return child; |
| }; |
| |
| XMLNode.prototype.text = function(value) { |
| var XMLText, child; |
| XMLText = require('./XMLText'); |
| child = new XMLText(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.cdata = function(value) { |
| var XMLCData, child; |
| XMLCData = require('./XMLCData'); |
| child = new XMLCData(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.comment = function(value) { |
| var XMLComment, child; |
| XMLComment = require('./XMLComment'); |
| child = new XMLComment(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.raw = function(value) { |
| var XMLRaw, child; |
| XMLRaw = require('./XMLRaw'); |
| child = new XMLRaw(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.declaration = function(version, encoding, standalone) { |
| var XMLDeclaration, doc, xmldec; |
| doc = this.document(); |
| XMLDeclaration = require('./XMLDeclaration'); |
| xmldec = new XMLDeclaration(doc, version, encoding, standalone); |
| doc.xmldec = xmldec; |
| return doc.root(); |
| }; |
| |
| XMLNode.prototype.doctype = function(pubID, sysID) { |
| var XMLDocType, doc, doctype; |
| doc = this.document(); |
| XMLDocType = require('./XMLDocType'); |
| doctype = new XMLDocType(doc, pubID, sysID); |
| doc.doctype = doctype; |
| return doctype; |
| }; |
| |
| XMLNode.prototype.up = function() { |
| if (this.isRoot) { |
| throw new Error("The root node has no parent. Use doc() if you need to get the document object."); |
| } |
| return this.parent; |
| }; |
| |
| XMLNode.prototype.root = function() { |
| var child; |
| if (this.isRoot) { |
| return this; |
| } |
| child = this.parent; |
| while (!child.isRoot) { |
| child = child.parent; |
| } |
| return child; |
| }; |
| |
| XMLNode.prototype.document = function() { |
| return this.root().documentObject; |
| }; |
| |
| XMLNode.prototype.end = function(options) { |
| return this.document().toString(options); |
| }; |
| |
| XMLNode.prototype.prev = function() { |
| var i; |
| if (this.isRoot) { |
| throw new Error("Root node has no siblings"); |
| } |
| i = this.parent.children.indexOf(this); |
| if (i < 1) { |
| throw new Error("Already at the first node"); |
| } |
| return this.parent.children[i - 1]; |
| }; |
| |
| XMLNode.prototype.next = function() { |
| var i; |
| if (this.isRoot) { |
| throw new Error("Root node has no siblings"); |
| } |
| i = this.parent.children.indexOf(this); |
| if (i === -1 || i === this.parent.children.length - 1) { |
| throw new Error("Already at the last node"); |
| } |
| return this.parent.children[i + 1]; |
| }; |
| |
| XMLNode.prototype.importXMLBuilder = function(xmlbuilder) { |
| var clonedRoot; |
| clonedRoot = xmlbuilder.root().clone(); |
| clonedRoot.parent = this; |
| clonedRoot.isRoot = false; |
| this.children.push(clonedRoot); |
| return this; |
| }; |
| |
| XMLNode.prototype.ele = function(name, attributes, text) { |
| return this.element(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.nod = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.txt = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLNode.prototype.dat = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLNode.prototype.com = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLNode.prototype.doc = function() { |
| return this.document(); |
| }; |
| |
| XMLNode.prototype.dec = function(version, encoding, standalone) { |
| return this.declaration(version, encoding, standalone); |
| }; |
| |
| XMLNode.prototype.dtd = function(pubID, sysID) { |
| return this.doctype(pubID, sysID); |
| }; |
| |
| XMLNode.prototype.e = function(name, attributes, text) { |
| return this.element(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.n = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.t = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLNode.prototype.d = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLNode.prototype.c = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLNode.prototype.r = function(value) { |
| return this.raw(value); |
| }; |
| |
| XMLNode.prototype.u = function() { |
| return this.up(); |
| }; |
| |
| return XMLNode; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"./XMLCData":7,"./XMLComment":8,"./XMLDeclaration":13,"./XMLDocType":14,"./XMLElement":15,"./XMLRaw":18,"./XMLText":20,"lodash-node":95}],17:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLProcessingInstruction, _; |
| |
| _ = require('lodash-node'); |
| |
| module.exports = XMLProcessingInstruction = (function() { |
| function XMLProcessingInstruction(parent, target, value) { |
| this.stringify = parent.stringify; |
| if (target == null) { |
| throw new Error("Missing instruction target"); |
| } |
| this.target = this.stringify.insTarget(target); |
| if (value) { |
| this.value = this.stringify.insValue(value); |
| } |
| } |
| |
| XMLProcessingInstruction.prototype.clone = function() { |
| return _.create(XMLProcessingInstruction.prototype, this); |
| }; |
| |
| XMLProcessingInstruction.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += '<?'; |
| r += this.target; |
| if (this.value) { |
| r += ' ' + this.value; |
| } |
| r += '?>'; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLProcessingInstruction; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{"lodash-node":95}],18:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLNode, XMLRaw, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| module.exports = XMLRaw = (function(_super) { |
| __extends(XMLRaw, _super); |
| |
| function XMLRaw(parent, text) { |
| XMLRaw.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing raw text"); |
| } |
| this.value = this.stringify.raw(text); |
| } |
| |
| XMLRaw.prototype.clone = function() { |
| return _.create(XMLRaw.prototype, this); |
| }; |
| |
| XMLRaw.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += this.value; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLRaw; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLNode":16,"lodash-node":95}],19:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLStringifier, |
| __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, |
| __hasProp = {}.hasOwnProperty; |
| |
| module.exports = XMLStringifier = (function() { |
| function XMLStringifier(options) { |
| this.assertLegalChar = __bind(this.assertLegalChar, this); |
| var key, value, _ref; |
| this.allowSurrogateChars = options != null ? options.allowSurrogateChars : void 0; |
| _ref = (options != null ? options.stringify : void 0) || {}; |
| for (key in _ref) { |
| if (!__hasProp.call(_ref, key)) continue; |
| value = _ref[key]; |
| this[key] = value; |
| } |
| } |
| |
| XMLStringifier.prototype.eleName = function(val) { |
| val = '' + val || ''; |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.eleText = function(val) { |
| val = '' + val || ''; |
| return this.assertLegalChar(this.escape(val)); |
| }; |
| |
| XMLStringifier.prototype.cdata = function(val) { |
| val = '' + val || ''; |
| if (val.match(/]]>/)) { |
| throw new Error("Invalid CDATA text: " + val); |
| } |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.comment = function(val) { |
| val = '' + val || ''; |
| if (val.match(/--/)) { |
| throw new Error("Comment text cannot contain double-hypen: " + val); |
| } |
| return this.assertLegalChar(this.escape(val)); |
| }; |
| |
| XMLStringifier.prototype.raw = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.attName = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.attValue = function(val) { |
| val = '' + val || ''; |
| return this.escape(val); |
| }; |
| |
| XMLStringifier.prototype.insTarget = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.insValue = function(val) { |
| val = '' + val || ''; |
| if (val.match(/\?>/)) { |
| throw new Error("Invalid processing instruction value: " + val); |
| } |
| return val; |
| }; |
| |
| XMLStringifier.prototype.xmlVersion = function(val) { |
| val = '' + val || ''; |
| if (!val.match(/1\.[0-9]+/)) { |
| throw new Error("Invalid version number: " + val); |
| } |
| return val; |
| }; |
| |
| XMLStringifier.prototype.xmlEncoding = function(val) { |
| val = '' + val || ''; |
| if (!val.match(/[A-Za-z](?:[A-Za-z0-9._-]|-)*/)) { |
| throw new Error("Invalid encoding: " + options.val); |
| } |
| return val; |
| }; |
| |
| XMLStringifier.prototype.xmlStandalone = function(val) { |
| if (val) { |
| return "yes"; |
| } else { |
| return "no"; |
| } |
| }; |
| |
| XMLStringifier.prototype.dtdPubID = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.dtdSysID = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.dtdElementValue = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.dtdAttType = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.dtdAttDefault = function(val) { |
| if (val != null) { |
| return '' + val || ''; |
| } else { |
| return val; |
| } |
| }; |
| |
| XMLStringifier.prototype.dtdEntityValue = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.dtdNData = function(val) { |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.convertAttKey = '@'; |
| |
| XMLStringifier.prototype.convertPIKey = '?'; |
| |
| XMLStringifier.prototype.convertTextKey = '#text'; |
| |
| XMLStringifier.prototype.convertCDataKey = '#cdata'; |
| |
| XMLStringifier.prototype.convertCommentKey = '#comment'; |
| |
| XMLStringifier.prototype.convertRawKey = '#raw'; |
| |
| XMLStringifier.prototype.convertListKey = '#list'; |
| |
| XMLStringifier.prototype.assertLegalChar = function(str) { |
| var chars, chr; |
| if (this.allowSurrogateChars) { |
| chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]/; |
| } else { |
| chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/; |
| } |
| chr = str.match(chars); |
| if (chr) { |
| throw new Error("Invalid character (" + chr + ") in string: " + str + " at index " + chr.index); |
| } |
| return str; |
| }; |
| |
| XMLStringifier.prototype.escape = function(str) { |
| return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/'/g, ''').replace(/"/g, '"'); |
| }; |
| |
| return XMLStringifier; |
| |
| })(); |
| |
| }).call(this); |
| |
| },{}],20:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLNode, XMLText, _, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; |
| |
| _ = require('lodash-node'); |
| |
| XMLNode = require('./XMLNode'); |
| |
| module.exports = XMLText = (function(_super) { |
| __extends(XMLText, _super); |
| |
| function XMLText(parent, text) { |
| this.parent = parent; |
| XMLText.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing element text"); |
| } |
| this.value = this.stringify.eleText(text); |
| } |
| |
| XMLText.prototype.clone = function() { |
| return _.create(XMLText.prototype, this); |
| }; |
| |
| XMLText.prototype.toString = function(options, level) { |
| var indent, newline, pretty, r, space; |
| pretty = (options != null ? options.pretty : void 0) || false; |
| indent = (options != null ? options.indent : void 0) || ' '; |
| newline = (options != null ? options.newline : void 0) || '\n'; |
| level || (level = 0); |
| space = new Array(level + 1).join(indent); |
| r = ''; |
| if (pretty) { |
| r += space; |
| } |
| r += this.value; |
| if (pretty) { |
| r += newline; |
| } |
| return r; |
| }; |
| |
| return XMLText; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| },{"./XMLNode":16,"lodash-node":95}],21:[function(require,module,exports){ |
| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var XMLBuilder, _; |
| |
| _ = require('lodash-node'); |
| |
| XMLBuilder = require('./XMLBuilder'); |
| |
| module.exports.create = function(name, xmldec, doctype, options) { |
| options = _.extend({}, xmldec, doctype, options); |
| return new XMLBuilder(name, options).root(); |
| }; |
| |
| }).call(this); |
| |
| },{"./XMLBuilder":6,"lodash-node":95}],22:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'compact': require('./arrays/compact'), |
| 'difference': require('./arrays/difference'), |
| 'drop': require('./arrays/rest'), |
| 'findIndex': require('./arrays/findIndex'), |
| 'findLastIndex': require('./arrays/findLastIndex'), |
| 'first': require('./arrays/first'), |
| 'flatten': require('./arrays/flatten'), |
| 'head': require('./arrays/first'), |
| 'indexOf': require('./arrays/indexOf'), |
| 'initial': require('./arrays/initial'), |
| 'intersection': require('./arrays/intersection'), |
| 'last': require('./arrays/last'), |
| 'lastIndexOf': require('./arrays/lastIndexOf'), |
| 'object': require('./arrays/zipObject'), |
| 'pull': require('./arrays/pull'), |
| 'range': require('./arrays/range'), |
| 'remove': require('./arrays/remove'), |
| 'rest': require('./arrays/rest'), |
| 'sortedIndex': require('./arrays/sortedIndex'), |
| 'tail': require('./arrays/rest'), |
| 'take': require('./arrays/first'), |
| 'union': require('./arrays/union'), |
| 'uniq': require('./arrays/uniq'), |
| 'unique': require('./arrays/uniq'), |
| 'unzip': require('./arrays/zip'), |
| 'without': require('./arrays/without'), |
| 'xor': require('./arrays/xor'), |
| 'zip': require('./arrays/zip'), |
| 'zipObject': require('./arrays/zipObject') |
| }; |
| |
| },{"./arrays/compact":23,"./arrays/difference":24,"./arrays/findIndex":25,"./arrays/findLastIndex":26,"./arrays/first":27,"./arrays/flatten":28,"./arrays/indexOf":29,"./arrays/initial":30,"./arrays/intersection":31,"./arrays/last":32,"./arrays/lastIndexOf":33,"./arrays/pull":34,"./arrays/range":35,"./arrays/remove":36,"./arrays/rest":37,"./arrays/sortedIndex":38,"./arrays/union":39,"./arrays/uniq":40,"./arrays/without":41,"./arrays/xor":42,"./arrays/zip":43,"./arrays/zipObject":44}],23:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Creates an array with all falsey values removed. The values `false`, `null`, |
| * `0`, `""`, `undefined`, and `NaN` are all falsey. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to compact. |
| * @returns {Array} Returns a new array of filtered values. |
| * @example |
| * |
| * _.compact([0, 1, false, 2, '', 3]); |
| * // => [1, 2, 3] |
| */ |
| function compact(array) { |
| var index = -1, |
| length = array ? array.length : 0, |
| result = []; |
| |
| while (++index < length) { |
| var value = array[index]; |
| if (value) { |
| result.push(value); |
| } |
| } |
| return result; |
| } |
| |
| module.exports = compact; |
| |
| },{}],24:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseDifference = require('../internals/baseDifference'), |
| baseFlatten = require('../internals/baseFlatten'); |
| |
| /** |
| * Creates an array excluding all values of the provided arrays using strict |
| * equality for comparisons, i.e. `===`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to process. |
| * @param {...Array} [values] The arrays of values to exclude. |
| * @returns {Array} Returns a new array of filtered values. |
| * @example |
| * |
| * _.difference([1, 2, 3, 4, 5], [5, 2, 10]); |
| * // => [1, 3, 4] |
| */ |
| function difference(array) { |
| return baseDifference(array, baseFlatten(arguments, true, true, 1)); |
| } |
| |
| module.exports = difference; |
| |
| },{"../internals/baseDifference":102,"../internals/baseFlatten":103}],25:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'); |
| |
| /** |
| * This method is like `_.find` except that it returns the index of the first |
| * element that passes the callback check, instead of the element itself. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to search. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {number} Returns the index of the found element, else `-1`. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': false }, |
| * { 'name': 'fred', 'age': 40, 'blocked': true }, |
| * { 'name': 'pebbles', 'age': 1, 'blocked': false } |
| * ]; |
| * |
| * _.findIndex(characters, function(chr) { |
| * return chr.age < 20; |
| * }); |
| * // => 2 |
| * |
| * // using "_.where" callback shorthand |
| * _.findIndex(characters, { 'age': 36 }); |
| * // => 0 |
| * |
| * // using "_.pluck" callback shorthand |
| * _.findIndex(characters, 'blocked'); |
| * // => 1 |
| */ |
| function findIndex(array, callback, thisArg) { |
| var index = -1, |
| length = array ? array.length : 0; |
| |
| callback = createCallback(callback, thisArg, 3); |
| while (++index < length) { |
| if (callback(array[index], index, array)) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| |
| module.exports = findIndex; |
| |
| },{"../functions/createCallback":84}],26:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'); |
| |
| /** |
| * This method is like `_.findIndex` except that it iterates over elements |
| * of a `collection` from right to left. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to search. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {number} Returns the index of the found element, else `-1`. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': true }, |
| * { 'name': 'fred', 'age': 40, 'blocked': false }, |
| * { 'name': 'pebbles', 'age': 1, 'blocked': true } |
| * ]; |
| * |
| * _.findLastIndex(characters, function(chr) { |
| * return chr.age > 30; |
| * }); |
| * // => 1 |
| * |
| * // using "_.where" callback shorthand |
| * _.findLastIndex(characters, { 'age': 36 }); |
| * // => 0 |
| * |
| * // using "_.pluck" callback shorthand |
| * _.findLastIndex(characters, 'blocked'); |
| * // => 2 |
| */ |
| function findLastIndex(array, callback, thisArg) { |
| var length = array ? array.length : 0; |
| callback = createCallback(callback, thisArg, 3); |
| while (length--) { |
| if (callback(array[length], length, array)) { |
| return length; |
| } |
| } |
| return -1; |
| } |
| |
| module.exports = findLastIndex; |
| |
| },{"../functions/createCallback":84}],27:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| slice = require('../internals/slice'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max, |
| nativeMin = Math.min; |
| |
| /** |
| * Gets the first element or first `n` elements of an array. If a callback |
| * is provided elements at the beginning of the array are returned as long |
| * as the callback returns truey. The callback is bound to `thisArg` and |
| * invoked with three arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias head, take |
| * @category Arrays |
| * @param {Array} array The array to query. |
| * @param {Function|Object|number|string} [callback] The function called |
| * per element or the number of elements to return. If a property name or |
| * object is provided it will be used to create a "_.pluck" or "_.where" |
| * style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the first element(s) of `array`. |
| * @example |
| * |
| * _.first([1, 2, 3]); |
| * // => 1 |
| * |
| * _.first([1, 2, 3], 2); |
| * // => [1, 2] |
| * |
| * _.first([1, 2, 3], function(num) { |
| * return num < 3; |
| * }); |
| * // => [1, 2] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, |
| * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, |
| * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.first(characters, 'blocked'); |
| * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }] |
| * |
| * // using "_.where" callback shorthand |
| * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name'); |
| * // => ['barney', 'fred'] |
| */ |
| function first(array, callback, thisArg) { |
| var n = 0, |
| length = array ? array.length : 0; |
| |
| if (typeof callback != 'number' && callback != null) { |
| var index = -1; |
| callback = createCallback(callback, thisArg, 3); |
| while (++index < length && callback(array[index], index, array)) { |
| n++; |
| } |
| } else { |
| n = callback; |
| if (n == null || thisArg) { |
| return array ? array[0] : undefined; |
| } |
| } |
| return slice(array, 0, nativeMin(nativeMax(0, n), length)); |
| } |
| |
| module.exports = first; |
| |
| },{"../functions/createCallback":84,"../internals/slice":137}],28:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseFlatten = require('../internals/baseFlatten'), |
| map = require('../collections/map'); |
| |
| /** |
| * Flattens a nested array (the nesting can be to any depth). If `isShallow` |
| * is truey, the array will only be flattened a single level. If a callback |
| * is provided each element of the array is passed through the callback before |
| * flattening. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to flatten. |
| * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new flattened array. |
| * @example |
| * |
| * _.flatten([1, [2], [3, [[4]]]]); |
| * // => [1, 2, 3, 4]; |
| * |
| * _.flatten([1, [2], [3, [[4]]]], true); |
| * // => [1, 2, 3, [[4]]]; |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] }, |
| * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.flatten(characters, 'pets'); |
| * // => ['hoppy', 'baby puss', 'dino'] |
| */ |
| function flatten(array, isShallow, callback, thisArg) { |
| // juggle arguments |
| if (typeof isShallow != 'boolean' && isShallow != null) { |
| thisArg = callback; |
| callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow; |
| isShallow = false; |
| } |
| if (callback != null) { |
| array = map(array, callback, thisArg); |
| } |
| return baseFlatten(array, isShallow); |
| } |
| |
| module.exports = flatten; |
| |
| },{"../collections/map":64,"../internals/baseFlatten":103}],29:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('../internals/baseIndexOf'), |
| sortedIndex = require('./sortedIndex'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * Gets the index at which the first occurrence of `value` is found using |
| * strict equality for comparisons, i.e. `===`. If the array is already sorted |
| * providing `true` for `fromIndex` will run a faster binary search. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {boolean|number} [fromIndex=0] The index to search from or `true` |
| * to perform a binary search on a sorted array. |
| * @returns {number} Returns the index of the matched value or `-1`. |
| * @example |
| * |
| * _.indexOf([1, 2, 3, 1, 2, 3], 2); |
| * // => 1 |
| * |
| * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3); |
| * // => 4 |
| * |
| * _.indexOf([1, 1, 2, 2, 3, 3], 2, true); |
| * // => 2 |
| */ |
| function indexOf(array, value, fromIndex) { |
| if (typeof fromIndex == 'number') { |
| var length = array ? array.length : 0; |
| fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0); |
| } else if (fromIndex) { |
| var index = sortedIndex(array, value); |
| return array[index] === value ? index : -1; |
| } |
| return baseIndexOf(array, value, fromIndex); |
| } |
| |
| module.exports = indexOf; |
| |
| },{"../internals/baseIndexOf":104,"./sortedIndex":38}],30:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| slice = require('../internals/slice'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max, |
| nativeMin = Math.min; |
| |
| /** |
| * Gets all but the last element or last `n` elements of an array. If a |
| * callback is provided elements at the end of the array are excluded from |
| * the result as long as the callback returns truey. The callback is bound |
| * to `thisArg` and invoked with three arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to query. |
| * @param {Function|Object|number|string} [callback=1] The function called |
| * per element or the number of elements to exclude. If a property name or |
| * object is provided it will be used to create a "_.pluck" or "_.where" |
| * style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a slice of `array`. |
| * @example |
| * |
| * _.initial([1, 2, 3]); |
| * // => [1, 2] |
| * |
| * _.initial([1, 2, 3], 2); |
| * // => [1] |
| * |
| * _.initial([1, 2, 3], function(num) { |
| * return num > 1; |
| * }); |
| * // => [1] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, |
| * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, |
| * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.initial(characters, 'blocked'); |
| * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }] |
| * |
| * // using "_.where" callback shorthand |
| * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name'); |
| * // => ['barney', 'fred'] |
| */ |
| function initial(array, callback, thisArg) { |
| var n = 0, |
| length = array ? array.length : 0; |
| |
| if (typeof callback != 'number' && callback != null) { |
| var index = length; |
| callback = createCallback(callback, thisArg, 3); |
| while (index-- && callback(array[index], index, array)) { |
| n++; |
| } |
| } else { |
| n = (callback == null || thisArg) ? 1 : callback || n; |
| } |
| return slice(array, 0, nativeMin(nativeMax(0, length - n), length)); |
| } |
| |
| module.exports = initial; |
| |
| },{"../functions/createCallback":84,"../internals/slice":137}],31:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('../internals/baseIndexOf'), |
| cacheIndexOf = require('../internals/cacheIndexOf'), |
| createCache = require('../internals/createCache'), |
| getArray = require('../internals/getArray'), |
| isArguments = require('../objects/isArguments'), |
| isArray = require('../objects/isArray'), |
| largeArraySize = require('../internals/largeArraySize'), |
| releaseArray = require('../internals/releaseArray'), |
| releaseObject = require('../internals/releaseObject'); |
| |
| /** |
| * Creates an array of unique values present in all provided arrays using |
| * strict equality for comparisons, i.e. `===`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {...Array} [array] The arrays to inspect. |
| * @returns {Array} Returns an array of shared values. |
| * @example |
| * |
| * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]); |
| * // => [1, 2] |
| */ |
| function intersection() { |
| var args = [], |
| argsIndex = -1, |
| argsLength = arguments.length, |
| caches = getArray(), |
| indexOf = baseIndexOf, |
| trustIndexOf = indexOf === baseIndexOf, |
| seen = getArray(); |
| |
| while (++argsIndex < argsLength) { |
| var value = arguments[argsIndex]; |
| if (isArray(value) || isArguments(value)) { |
| args.push(value); |
| caches.push(trustIndexOf && value.length >= largeArraySize && |
| createCache(argsIndex ? args[argsIndex] : seen)); |
| } |
| } |
| var array = args[0], |
| index = -1, |
| length = array ? array.length : 0, |
| result = []; |
| |
| outer: |
| while (++index < length) { |
| var cache = caches[0]; |
| value = array[index]; |
| |
| if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) { |
| argsIndex = argsLength; |
| (cache || seen).push(value); |
| while (--argsIndex) { |
| cache = caches[argsIndex]; |
| if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) { |
| continue outer; |
| } |
| } |
| result.push(value); |
| } |
| } |
| while (argsLength--) { |
| cache = caches[argsLength]; |
| if (cache) { |
| releaseObject(cache); |
| } |
| } |
| releaseArray(caches); |
| releaseArray(seen); |
| return result; |
| } |
| |
| module.exports = intersection; |
| |
| },{"../internals/baseIndexOf":104,"../internals/cacheIndexOf":109,"../internals/createCache":114,"../internals/getArray":118,"../internals/largeArraySize":124,"../internals/releaseArray":132,"../internals/releaseObject":133,"../objects/isArguments":154,"../objects/isArray":155}],32:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| slice = require('../internals/slice'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * Gets the last element or last `n` elements of an array. If a callback is |
| * provided elements at the end of the array are returned as long as the |
| * callback returns truey. The callback is bound to `thisArg` and invoked |
| * with three arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to query. |
| * @param {Function|Object|number|string} [callback] The function called |
| * per element or the number of elements to return. If a property name or |
| * object is provided it will be used to create a "_.pluck" or "_.where" |
| * style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the last element(s) of `array`. |
| * @example |
| * |
| * _.last([1, 2, 3]); |
| * // => 3 |
| * |
| * _.last([1, 2, 3], 2); |
| * // => [2, 3] |
| * |
| * _.last([1, 2, 3], function(num) { |
| * return num > 1; |
| * }); |
| * // => [2, 3] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, |
| * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, |
| * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.pluck(_.last(characters, 'blocked'), 'name'); |
| * // => ['fred', 'pebbles'] |
| * |
| * // using "_.where" callback shorthand |
| * _.last(characters, { 'employer': 'na' }); |
| * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] |
| */ |
| function last(array, callback, thisArg) { |
| var n = 0, |
| length = array ? array.length : 0; |
| |
| if (typeof callback != 'number' && callback != null) { |
| var index = length; |
| callback = createCallback(callback, thisArg, 3); |
| while (index-- && callback(array[index], index, array)) { |
| n++; |
| } |
| } else { |
| n = callback; |
| if (n == null || thisArg) { |
| return array ? array[length - 1] : undefined; |
| } |
| } |
| return slice(array, nativeMax(0, length - n)); |
| } |
| |
| module.exports = last; |
| |
| },{"../functions/createCallback":84,"../internals/slice":137}],33:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max, |
| nativeMin = Math.min; |
| |
| /** |
| * Gets the index at which the last occurrence of `value` is found using strict |
| * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used |
| * as the offset from the end of the collection. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {number} [fromIndex=array.length-1] The index to search from. |
| * @returns {number} Returns the index of the matched value or `-1`. |
| * @example |
| * |
| * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2); |
| * // => 4 |
| * |
| * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); |
| * // => 1 |
| */ |
| function lastIndexOf(array, value, fromIndex) { |
| var index = array ? array.length : 0; |
| if (typeof fromIndex == 'number') { |
| index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1; |
| } |
| while (index--) { |
| if (array[index] === value) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| |
| module.exports = lastIndexOf; |
| |
| },{}],34:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var splice = arrayRef.splice; |
| |
| /** |
| * Removes all provided values from the given array using strict equality for |
| * comparisons, i.e. `===`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to modify. |
| * @param {...*} [value] The values to remove. |
| * @returns {Array} Returns `array`. |
| * @example |
| * |
| * var array = [1, 2, 3, 1, 2, 3]; |
| * _.pull(array, 2, 3); |
| * console.log(array); |
| * // => [1, 1] |
| */ |
| function pull(array) { |
| var args = arguments, |
| argsIndex = 0, |
| argsLength = args.length, |
| length = array ? array.length : 0; |
| |
| while (++argsIndex < argsLength) { |
| var index = -1, |
| value = args[argsIndex]; |
| while (++index < length) { |
| if (array[index] === value) { |
| splice.call(array, index--, 1); |
| length--; |
| } |
| } |
| } |
| return array; |
| } |
| |
| module.exports = pull; |
| |
| },{}],35:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Native method shortcuts */ |
| var ceil = Math.ceil; |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * Creates an array of numbers (positive and/or negative) progressing from |
| * `start` up to but not including `end`. If `start` is less than `stop` a |
| * zero-length range is created unless a negative `step` is specified. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {number} [start=0] The start of the range. |
| * @param {number} end The end of the range. |
| * @param {number} [step=1] The value to increment or decrement by. |
| * @returns {Array} Returns a new range array. |
| * @example |
| * |
| * _.range(4); |
| * // => [0, 1, 2, 3] |
| * |
| * _.range(1, 5); |
| * // => [1, 2, 3, 4] |
| * |
| * _.range(0, 20, 5); |
| * // => [0, 5, 10, 15] |
| * |
| * _.range(0, -4, -1); |
| * // => [0, -1, -2, -3] |
| * |
| * _.range(1, 4, 0); |
| * // => [1, 1, 1] |
| * |
| * _.range(0); |
| * // => [] |
| */ |
| function range(start, end, step) { |
| start = +start || 0; |
| step = typeof step == 'number' ? step : (+step || 1); |
| |
| if (end == null) { |
| end = start; |
| start = 0; |
| } |
| // use `Array(length)` so engines like Chakra and V8 avoid slower modes |
| // http://youtu.be/XAqIpGU8ZZk#t=17m25s |
| var index = -1, |
| length = nativeMax(0, ceil((end - start) / (step || 1))), |
| result = Array(length); |
| |
| while (++index < length) { |
| result[index] = start; |
| start += step; |
| } |
| return result; |
| } |
| |
| module.exports = range; |
| |
| },{}],36:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var splice = arrayRef.splice; |
| |
| /** |
| * Removes all elements from an array that the callback returns truey for |
| * and returns an array of removed elements. The callback is bound to `thisArg` |
| * and invoked with three arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to modify. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new array of removed elements. |
| * @example |
| * |
| * var array = [1, 2, 3, 4, 5, 6]; |
| * var evens = _.remove(array, function(num) { return num % 2 == 0; }); |
| * |
| * console.log(array); |
| * // => [1, 3, 5] |
| * |
| * console.log(evens); |
| * // => [2, 4, 6] |
| */ |
| function remove(array, callback, thisArg) { |
| var index = -1, |
| length = array ? array.length : 0, |
| result = []; |
| |
| callback = createCallback(callback, thisArg, 3); |
| while (++index < length) { |
| var value = array[index]; |
| if (callback(value, index, array)) { |
| result.push(value); |
| splice.call(array, index--, 1); |
| length--; |
| } |
| } |
| return result; |
| } |
| |
| module.exports = remove; |
| |
| },{"../functions/createCallback":84}],37:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| slice = require('../internals/slice'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * The opposite of `_.initial` this method gets all but the first element or |
| * first `n` elements of an array. If a callback function is provided elements |
| * at the beginning of the array are excluded from the result as long as the |
| * callback returns truey. The callback is bound to `thisArg` and invoked |
| * with three arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias drop, tail |
| * @category Arrays |
| * @param {Array} array The array to query. |
| * @param {Function|Object|number|string} [callback=1] The function called |
| * per element or the number of elements to exclude. If a property name or |
| * object is provided it will be used to create a "_.pluck" or "_.where" |
| * style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a slice of `array`. |
| * @example |
| * |
| * _.rest([1, 2, 3]); |
| * // => [2, 3] |
| * |
| * _.rest([1, 2, 3], 2); |
| * // => [3] |
| * |
| * _.rest([1, 2, 3], function(num) { |
| * return num < 3; |
| * }); |
| * // => [3] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, |
| * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, |
| * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.pluck(_.rest(characters, 'blocked'), 'name'); |
| * // => ['fred', 'pebbles'] |
| * |
| * // using "_.where" callback shorthand |
| * _.rest(characters, { 'employer': 'slate' }); |
| * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] |
| */ |
| function rest(array, callback, thisArg) { |
| if (typeof callback != 'number' && callback != null) { |
| var n = 0, |
| index = -1, |
| length = array ? array.length : 0; |
| |
| callback = createCallback(callback, thisArg, 3); |
| while (++index < length && callback(array[index], index, array)) { |
| n++; |
| } |
| } else { |
| n = (callback == null || thisArg) ? 1 : nativeMax(0, callback); |
| } |
| return slice(array, n); |
| } |
| |
| module.exports = rest; |
| |
| },{"../functions/createCallback":84,"../internals/slice":137}],38:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| identity = require('../utilities/identity'); |
| |
| /** |
| * Uses a binary search to determine the smallest index at which a value |
| * should be inserted into a given sorted array in order to maintain the sort |
| * order of the array. If a callback is provided it will be executed for |
| * `value` and each element of `array` to compute their sort ranking. The |
| * callback is bound to `thisArg` and invoked with one argument; (value). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to inspect. |
| * @param {*} value The value to evaluate. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {number} Returns the index at which `value` should be inserted |
| * into `array`. |
| * @example |
| * |
| * _.sortedIndex([20, 30, 50], 40); |
| * // => 2 |
| * |
| * // using "_.pluck" callback shorthand |
| * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); |
| * // => 2 |
| * |
| * var dict = { |
| * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } |
| * }; |
| * |
| * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { |
| * return dict.wordToNumber[word]; |
| * }); |
| * // => 2 |
| * |
| * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { |
| * return this.wordToNumber[word]; |
| * }, dict); |
| * // => 2 |
| */ |
| function sortedIndex(array, value, callback, thisArg) { |
| var low = 0, |
| high = array ? array.length : low; |
| |
| // explicitly reference `identity` for better inlining in Firefox |
| callback = callback ? createCallback(callback, thisArg, 1) : identity; |
| value = callback(value); |
| |
| while (low < high) { |
| var mid = (low + high) >>> 1; |
| (callback(array[mid]) < value) |
| ? low = mid + 1 |
| : high = mid; |
| } |
| return low; |
| } |
| |
| module.exports = sortedIndex; |
| |
| },{"../functions/createCallback":84,"../utilities/identity":183}],39:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseFlatten = require('../internals/baseFlatten'), |
| baseUniq = require('../internals/baseUniq'); |
| |
| /** |
| * Creates an array of unique values, in order, of the provided arrays using |
| * strict equality for comparisons, i.e. `===`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {...Array} [array] The arrays to inspect. |
| * @returns {Array} Returns an array of combined values. |
| * @example |
| * |
| * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]); |
| * // => [1, 2, 3, 5, 4] |
| */ |
| function union() { |
| return baseUniq(baseFlatten(arguments, true, true)); |
| } |
| |
| module.exports = union; |
| |
| },{"../internals/baseFlatten":103,"../internals/baseUniq":108}],40:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseUniq = require('../internals/baseUniq'), |
| createCallback = require('../functions/createCallback'); |
| |
| /** |
| * Creates a duplicate-value-free version of an array using strict equality |
| * for comparisons, i.e. `===`. If the array is sorted, providing |
| * `true` for `isSorted` will use a faster algorithm. If a callback is provided |
| * each element of `array` is passed through the callback before uniqueness |
| * is computed. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, index, array). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias unique |
| * @category Arrays |
| * @param {Array} array The array to process. |
| * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a duplicate-value-free array. |
| * @example |
| * |
| * _.uniq([1, 2, 1, 3, 1]); |
| * // => [1, 2, 3] |
| * |
| * _.uniq([1, 1, 2, 2, 3], true); |
| * // => [1, 2, 3] |
| * |
| * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); }); |
| * // => ['A', 'b', 'C'] |
| * |
| * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math); |
| * // => [1, 2.5, 3] |
| * |
| * // using "_.pluck" callback shorthand |
| * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); |
| * // => [{ 'x': 1 }, { 'x': 2 }] |
| */ |
| function uniq(array, isSorted, callback, thisArg) { |
| // juggle arguments |
| if (typeof isSorted != 'boolean' && isSorted != null) { |
| thisArg = callback; |
| callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted; |
| isSorted = false; |
| } |
| if (callback != null) { |
| callback = createCallback(callback, thisArg, 3); |
| } |
| return baseUniq(array, isSorted, callback); |
| } |
| |
| module.exports = uniq; |
| |
| },{"../functions/createCallback":84,"../internals/baseUniq":108}],41:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseDifference = require('../internals/baseDifference'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Creates an array excluding all provided values using strict equality for |
| * comparisons, i.e. `===`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {Array} array The array to filter. |
| * @param {...*} [value] The values to exclude. |
| * @returns {Array} Returns a new array of filtered values. |
| * @example |
| * |
| * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); |
| * // => [2, 3, 4] |
| */ |
| function without(array) { |
| return baseDifference(array, slice(arguments, 1)); |
| } |
| |
| module.exports = without; |
| |
| },{"../internals/baseDifference":102,"../internals/slice":137}],42:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseDifference = require('../internals/baseDifference'), |
| baseUniq = require('../internals/baseUniq'), |
| isArguments = require('../objects/isArguments'), |
| isArray = require('../objects/isArray'); |
| |
| /** |
| * Creates an array that is the symmetric difference of the provided arrays. |
| * See http://en.wikipedia.org/wiki/Symmetric_difference. |
| * |
| * @static |
| * @memberOf _ |
| * @category Arrays |
| * @param {...Array} [array] The arrays to inspect. |
| * @returns {Array} Returns an array of values. |
| * @example |
| * |
| * _.xor([1, 2, 3], [5, 2, 1, 4]); |
| * // => [3, 5, 4] |
| * |
| * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]); |
| * // => [1, 4, 5] |
| */ |
| function xor() { |
| var index = -1, |
| length = arguments.length; |
| |
| while (++index < length) { |
| var array = arguments[index]; |
| if (isArray(array) || isArguments(array)) { |
| var result = result |
| ? baseUniq(baseDifference(result, array).concat(baseDifference(array, result))) |
| : array; |
| } |
| } |
| return result || []; |
| } |
| |
| module.exports = xor; |
| |
| },{"../internals/baseDifference":102,"../internals/baseUniq":108,"../objects/isArguments":154,"../objects/isArray":155}],43:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var max = require('../collections/max'), |
| pluck = require('../collections/pluck'); |
| |
| /** |
| * Creates an array of grouped elements, the first of which contains the first |
| * elements of the given arrays, the second of which contains the second |
| * elements of the given arrays, and so on. |
| * |
| * @static |
| * @memberOf _ |
| * @alias unzip |
| * @category Arrays |
| * @param {...Array} [array] Arrays to process. |
| * @returns {Array} Returns a new array of grouped elements. |
| * @example |
| * |
| * _.zip(['fred', 'barney'], [30, 40], [true, false]); |
| * // => [['fred', 30, true], ['barney', 40, false]] |
| */ |
| function zip() { |
| var array = arguments.length > 1 ? arguments : arguments[0], |
| index = -1, |
| length = array ? max(pluck(array, 'length')) : 0, |
| result = Array(length < 0 ? 0 : length); |
| |
| while (++index < length) { |
| result[index] = pluck(array, index); |
| } |
| return result; |
| } |
| |
| module.exports = zip; |
| |
| },{"../collections/max":65,"../collections/pluck":67}],44:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isArray = require('../objects/isArray'); |
| |
| /** |
| * Creates an object composed from arrays of `keys` and `values`. Provide |
| * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]` |
| * or two arrays, one of `keys` and one of corresponding `values`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias object |
| * @category Arrays |
| * @param {Array} keys The array of keys. |
| * @param {Array} [values=[]] The array of values. |
| * @returns {Object} Returns an object composed of the given keys and |
| * corresponding values. |
| * @example |
| * |
| * _.zipObject(['fred', 'barney'], [30, 40]); |
| * // => { 'fred': 30, 'barney': 40 } |
| */ |
| function zipObject(keys, values) { |
| var index = -1, |
| length = keys ? keys.length : 0, |
| result = {}; |
| |
| if (!values && length && !isArray(keys[0])) { |
| values = []; |
| } |
| while (++index < length) { |
| var key = keys[index]; |
| if (values) { |
| result[key] = values[index]; |
| } else if (key) { |
| result[key[0]] = key[1]; |
| } |
| } |
| return result; |
| } |
| |
| module.exports = zipObject; |
| |
| },{"../objects/isArray":155}],45:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'chain': require('./chaining/chain'), |
| 'tap': require('./chaining/tap'), |
| 'value': require('./chaining/wrapperValueOf'), |
| 'wrapperChain': require('./chaining/wrapperChain'), |
| 'wrapperToString': require('./chaining/wrapperToString'), |
| 'wrapperValueOf': require('./chaining/wrapperValueOf') |
| }; |
| |
| },{"./chaining/chain":46,"./chaining/tap":47,"./chaining/wrapperChain":48,"./chaining/wrapperToString":49,"./chaining/wrapperValueOf":50}],46:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var lodashWrapper = require('../internals/lodashWrapper'); |
| |
| /** |
| * Creates a `lodash` object that wraps the given value with explicit |
| * method chaining enabled. |
| * |
| * @static |
| * @memberOf _ |
| * @category Chaining |
| * @param {*} value The value to wrap. |
| * @returns {Object} Returns the wrapper object. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 }, |
| * { 'name': 'pebbles', 'age': 1 } |
| * ]; |
| * |
| * var youngest = _.chain(characters) |
| * .sortBy('age') |
| * .map(function(chr) { return chr.name + ' is ' + chr.age; }) |
| * .first() |
| * .value(); |
| * // => 'pebbles is 1' |
| */ |
| function chain(value) { |
| value = new lodashWrapper(value); |
| value.__chain__ = true; |
| return value; |
| } |
| |
| module.exports = chain; |
| |
| },{"../internals/lodashWrapper":125}],47:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Invokes `interceptor` with the `value` as the first argument and then |
| * returns `value`. The purpose of this method is to "tap into" a method |
| * chain in order to perform operations on intermediate results within |
| * the chain. |
| * |
| * @static |
| * @memberOf _ |
| * @category Chaining |
| * @param {*} value The value to provide to `interceptor`. |
| * @param {Function} interceptor The function to invoke. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * _([1, 2, 3, 4]) |
| * .tap(function(array) { array.pop(); }) |
| * .reverse() |
| * .value(); |
| * // => [3, 2, 1] |
| */ |
| function tap(value, interceptor) { |
| interceptor(value); |
| return value; |
| } |
| |
| module.exports = tap; |
| |
| },{}],48:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Enables explicit method chaining on the wrapper object. |
| * |
| * @name chain |
| * @memberOf _ |
| * @category Chaining |
| * @returns {*} Returns the wrapper object. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // without explicit chaining |
| * _(characters).first(); |
| * // => { 'name': 'barney', 'age': 36 } |
| * |
| * // with explicit chaining |
| * _(characters).chain() |
| * .first() |
| * .pick('age') |
| * .value(); |
| * // => { 'age': 36 } |
| */ |
| function wrapperChain() { |
| this.__chain__ = true; |
| return this; |
| } |
| |
| module.exports = wrapperChain; |
| |
| },{}],49:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Produces the `toString` result of the wrapped value. |
| * |
| * @name toString |
| * @memberOf _ |
| * @category Chaining |
| * @returns {string} Returns the string result. |
| * @example |
| * |
| * _([1, 2, 3]).toString(); |
| * // => '1,2,3' |
| */ |
| function wrapperToString() { |
| return String(this.__wrapped__); |
| } |
| |
| module.exports = wrapperToString; |
| |
| },{}],50:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forEach = require('../collections/forEach'), |
| support = require('../support'); |
| |
| /** |
| * Extracts the wrapped value. |
| * |
| * @name valueOf |
| * @memberOf _ |
| * @alias value |
| * @category Chaining |
| * @returns {*} Returns the wrapped value. |
| * @example |
| * |
| * _([1, 2, 3]).valueOf(); |
| * // => [1, 2, 3] |
| */ |
| function wrapperValueOf() { |
| return this.__wrapped__; |
| } |
| |
| module.exports = wrapperValueOf; |
| |
| },{"../collections/forEach":59,"../support":179}],51:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'all': require('./collections/every'), |
| 'any': require('./collections/some'), |
| 'at': require('./collections/at'), |
| 'collect': require('./collections/map'), |
| 'contains': require('./collections/contains'), |
| 'countBy': require('./collections/countBy'), |
| 'detect': require('./collections/find'), |
| 'each': require('./collections/forEach'), |
| 'eachRight': require('./collections/forEachRight'), |
| 'every': require('./collections/every'), |
| 'filter': require('./collections/filter'), |
| 'find': require('./collections/find'), |
| 'findLast': require('./collections/findLast'), |
| 'findWhere': require('./collections/find'), |
| 'foldl': require('./collections/reduce'), |
| 'foldr': require('./collections/reduceRight'), |
| 'forEach': require('./collections/forEach'), |
| 'forEachRight': require('./collections/forEachRight'), |
| 'groupBy': require('./collections/groupBy'), |
| 'include': require('./collections/contains'), |
| 'indexBy': require('./collections/indexBy'), |
| 'inject': require('./collections/reduce'), |
| 'invoke': require('./collections/invoke'), |
| 'map': require('./collections/map'), |
| 'max': require('./collections/max'), |
| 'min': require('./collections/min'), |
| 'pluck': require('./collections/pluck'), |
| 'reduce': require('./collections/reduce'), |
| 'reduceRight': require('./collections/reduceRight'), |
| 'reject': require('./collections/reject'), |
| 'sample': require('./collections/sample'), |
| 'select': require('./collections/filter'), |
| 'shuffle': require('./collections/shuffle'), |
| 'size': require('./collections/size'), |
| 'some': require('./collections/some'), |
| 'sortBy': require('./collections/sortBy'), |
| 'toArray': require('./collections/toArray'), |
| 'where': require('./collections/where') |
| }; |
| |
| },{"./collections/at":52,"./collections/contains":53,"./collections/countBy":54,"./collections/every":55,"./collections/filter":56,"./collections/find":57,"./collections/findLast":58,"./collections/forEach":59,"./collections/forEachRight":60,"./collections/groupBy":61,"./collections/indexBy":62,"./collections/invoke":63,"./collections/map":64,"./collections/max":65,"./collections/min":66,"./collections/pluck":67,"./collections/reduce":68,"./collections/reduceRight":69,"./collections/reject":70,"./collections/sample":71,"./collections/shuffle":72,"./collections/size":73,"./collections/some":74,"./collections/sortBy":75,"./collections/toArray":76,"./collections/where":77}],52:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseFlatten = require('../internals/baseFlatten'), |
| isString = require('../objects/isString'); |
| |
| /** |
| * Creates an array of elements from the specified indexes, or keys, of the |
| * `collection`. Indexes may be specified as individual arguments or as arrays |
| * of indexes. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {...(number|number[]|string|string[])} [index] The indexes of `collection` |
| * to retrieve, specified as individual indexes or arrays of indexes. |
| * @returns {Array} Returns a new array of elements corresponding to the |
| * provided indexes. |
| * @example |
| * |
| * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]); |
| * // => ['a', 'c', 'e'] |
| * |
| * _.at(['fred', 'barney', 'pebbles'], 0, 2); |
| * // => ['fred', 'pebbles'] |
| */ |
| function at(collection) { |
| var args = arguments, |
| index = -1, |
| props = baseFlatten(args, true, false, 1), |
| length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length, |
| result = Array(length); |
| |
| while(++index < length) { |
| result[index] = collection[props[index]]; |
| } |
| return result; |
| } |
| |
| module.exports = at; |
| |
| },{"../internals/baseFlatten":103,"../objects/isString":169}],53:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('../internals/baseIndexOf'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'), |
| isString = require('../objects/isString'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * Checks if a given value is present in a collection using strict equality |
| * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the |
| * offset from the end of the collection. |
| * |
| * @static |
| * @memberOf _ |
| * @alias include |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {*} target The value to check for. |
| * @param {number} [fromIndex=0] The index to search from. |
| * @returns {boolean} Returns `true` if the `target` element is found, else `false`. |
| * @example |
| * |
| * _.contains([1, 2, 3], 1); |
| * // => true |
| * |
| * _.contains([1, 2, 3], 1, 2); |
| * // => false |
| * |
| * _.contains({ 'name': 'fred', 'age': 40 }, 'fred'); |
| * // => true |
| * |
| * _.contains('pebbles', 'eb'); |
| * // => true |
| */ |
| function contains(collection, target, fromIndex) { |
| var index = -1, |
| indexOf = baseIndexOf, |
| length = collection ? collection.length : 0, |
| result = false; |
| |
| fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0; |
| if (isArray(collection)) { |
| result = indexOf(collection, target, fromIndex) > -1; |
| } else if (typeof length == 'number') { |
| result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1; |
| } else { |
| forOwn(collection, function(value) { |
| if (++index >= fromIndex) { |
| return !(result = value === target); |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = contains; |
| |
| },{"../internals/baseIndexOf":104,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isString":169}],54:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createAggregator = require('../internals/createAggregator'); |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of `collection` through the callback. The corresponding value |
| * of each key is the number of times the key was returned by the callback. |
| * The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); |
| * // => { '4': 1, '6': 2 } |
| * |
| * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); |
| * // => { '4': 1, '6': 2 } |
| * |
| * _.countBy(['one', 'two', 'three'], 'length'); |
| * // => { '3': 2, '5': 1 } |
| */ |
| var countBy = createAggregator(function(result, value, key) { |
| (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1); |
| }); |
| |
| module.exports = countBy; |
| |
| },{"../internals/createAggregator":113}],55:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Checks if the given callback returns truey value for **all** elements of |
| * a collection. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias all |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {boolean} Returns `true` if all elements passed the callback check, |
| * else `false`. |
| * @example |
| * |
| * _.every([true, 1, null, 'yes']); |
| * // => false |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.every(characters, 'age'); |
| * // => true |
| * |
| * // using "_.where" callback shorthand |
| * _.every(characters, { 'age': 36 }); |
| * // => false |
| */ |
| function every(collection, callback, thisArg) { |
| var result = true; |
| callback = createCallback(callback, thisArg, 3); |
| |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| if (typeof length == 'number') { |
| while (++index < length) { |
| if (!(result = !!callback(collection[index], index, collection))) { |
| break; |
| } |
| } |
| } else { |
| forOwn(collection, function(value, index, collection) { |
| return (result = !!callback(value, index, collection)); |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = every; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149}],56:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Iterates over elements of a collection, returning an array of all elements |
| * the callback returns truey for. The callback is bound to `thisArg` and |
| * invoked with three arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias select |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new array of elements that passed the callback check. |
| * @example |
| * |
| * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); |
| * // => [2, 4, 6] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': false }, |
| * { 'name': 'fred', 'age': 40, 'blocked': true } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.filter(characters, 'blocked'); |
| * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] |
| * |
| * // using "_.where" callback shorthand |
| * _.filter(characters, { 'age': 36 }); |
| * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] |
| */ |
| function filter(collection, callback, thisArg) { |
| var result = []; |
| callback = createCallback(callback, thisArg, 3); |
| |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| if (typeof length == 'number') { |
| while (++index < length) { |
| var value = collection[index]; |
| if (callback(value, index, collection)) { |
| result.push(value); |
| } |
| } |
| } else { |
| forOwn(collection, function(value, index, collection) { |
| if (callback(value, index, collection)) { |
| result.push(value); |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = filter; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149}],57:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Iterates over elements of a collection, returning the first element that |
| * the callback returns truey for. The callback is bound to `thisArg` and |
| * invoked with three arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias detect, findWhere |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the found element, else `undefined`. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': false }, |
| * { 'name': 'fred', 'age': 40, 'blocked': true }, |
| * { 'name': 'pebbles', 'age': 1, 'blocked': false } |
| * ]; |
| * |
| * _.find(characters, function(chr) { |
| * return chr.age < 40; |
| * }); |
| * // => { 'name': 'barney', 'age': 36, 'blocked': false } |
| * |
| * // using "_.where" callback shorthand |
| * _.find(characters, { 'age': 1 }); |
| * // => { 'name': 'pebbles', 'age': 1, 'blocked': false } |
| * |
| * // using "_.pluck" callback shorthand |
| * _.find(characters, 'blocked'); |
| * // => { 'name': 'fred', 'age': 40, 'blocked': true } |
| */ |
| function find(collection, callback, thisArg) { |
| callback = createCallback(callback, thisArg, 3); |
| |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| if (typeof length == 'number') { |
| while (++index < length) { |
| var value = collection[index]; |
| if (callback(value, index, collection)) { |
| return value; |
| } |
| } |
| } else { |
| var result; |
| forOwn(collection, function(value, index, collection) { |
| if (callback(value, index, collection)) { |
| result = value; |
| return false; |
| } |
| }); |
| return result; |
| } |
| } |
| |
| module.exports = find; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149}],58:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forEachRight = require('./forEachRight'); |
| |
| /** |
| * This method is like `_.find` except that it iterates over elements |
| * of a `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the found element, else `undefined`. |
| * @example |
| * |
| * _.findLast([1, 2, 3, 4], function(num) { |
| * return num % 2 == 1; |
| * }); |
| * // => 3 |
| */ |
| function findLast(collection, callback, thisArg) { |
| var result; |
| callback = createCallback(callback, thisArg, 3); |
| forEachRight(collection, function(value, index, collection) { |
| if (callback(value, index, collection)) { |
| result = value; |
| return false; |
| } |
| }); |
| return result; |
| } |
| |
| module.exports = findLast; |
| |
| },{"../functions/createCallback":84,"./forEachRight":60}],59:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Iterates over elements of a collection, executing the callback for each |
| * element. The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, index|key, collection). Callbacks may exit iteration early by |
| * explicitly returning `false`. |
| * |
| * Note: As with other "Collections" methods, objects with a `length` property |
| * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn` |
| * may be used for object iteration. |
| * |
| * @static |
| * @memberOf _ |
| * @alias each |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array|Object|string} Returns `collection`. |
| * @example |
| * |
| * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(','); |
| * // => logs each number and returns '1,2,3' |
| * |
| * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); }); |
| * // => logs each number and returns the object (property order is not guaranteed across environments) |
| */ |
| function forEach(collection, callback, thisArg) { |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3); |
| if (typeof length == 'number') { |
| while (++index < length) { |
| if (callback(collection[index], index, collection) === false) { |
| break; |
| } |
| } |
| } else { |
| forOwn(collection, callback); |
| } |
| return collection; |
| } |
| |
| module.exports = forEach; |
| |
| },{"../internals/baseCreateCallback":100,"../objects/forOwn":149}],60:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'), |
| isString = require('../objects/isString'), |
| keys = require('../objects/keys'); |
| |
| /** |
| * This method is like `_.forEach` except that it iterates over elements |
| * of a `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @alias eachRight |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array|Object|string} Returns `collection`. |
| * @example |
| * |
| * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(','); |
| * // => logs each number from right to left and returns '3,2,1' |
| */ |
| function forEachRight(collection, callback, thisArg) { |
| var length = collection ? collection.length : 0; |
| callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3); |
| if (typeof length == 'number') { |
| while (length--) { |
| if (callback(collection[length], length, collection) === false) { |
| break; |
| } |
| } |
| } else { |
| var props = keys(collection); |
| length = props.length; |
| forOwn(collection, function(value, key, collection) { |
| key = props ? props[--length] : --length; |
| return callback(collection[key], key, collection); |
| }); |
| } |
| return collection; |
| } |
| |
| module.exports = forEachRight; |
| |
| },{"../internals/baseCreateCallback":100,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isString":169,"../objects/keys":171}],61:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createAggregator = require('../internals/createAggregator'); |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of a collection through the callback. The corresponding value |
| * of each key is an array of the elements responsible for generating the key. |
| * The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false` |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); |
| * // => { '4': [4.2], '6': [6.1, 6.4] } |
| * |
| * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); |
| * // => { '4': [4.2], '6': [6.1, 6.4] } |
| * |
| * // using "_.pluck" callback shorthand |
| * _.groupBy(['one', 'two', 'three'], 'length'); |
| * // => { '3': ['one', 'two'], '5': ['three'] } |
| */ |
| var groupBy = createAggregator(function(result, value, key) { |
| (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value); |
| }); |
| |
| module.exports = groupBy; |
| |
| },{"../internals/createAggregator":113}],62:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createAggregator = require('../internals/createAggregator'); |
| |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of the collection through the given callback. The corresponding |
| * value of each key is the last element responsible for generating the key. |
| * The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * var keys = [ |
| * { 'dir': 'left', 'code': 97 }, |
| * { 'dir': 'right', 'code': 100 } |
| * ]; |
| * |
| * _.indexBy(keys, 'dir'); |
| * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } |
| * |
| * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); }); |
| * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } |
| * |
| * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String); |
| * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } |
| */ |
| var indexBy = createAggregator(function(result, value, key) { |
| result[key] = value; |
| }); |
| |
| module.exports = indexBy; |
| |
| },{"../internals/createAggregator":113}],63:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forEach = require('./forEach'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Invokes the method named by `methodName` on each element in the `collection` |
| * returning an array of the results of each invoked method. Additional arguments |
| * will be provided to each invoked method. If `methodName` is a function it |
| * will be invoked for, and `this` bound to, each element in the `collection`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|string} methodName The name of the method to invoke or |
| * the function invoked per iteration. |
| * @param {...*} [arg] Arguments to invoke the method with. |
| * @returns {Array} Returns a new array of the results of each invoked method. |
| * @example |
| * |
| * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); |
| * // => [[1, 5, 7], [1, 2, 3]] |
| * |
| * _.invoke([123, 456], String.prototype.split, ''); |
| * // => [['1', '2', '3'], ['4', '5', '6']] |
| */ |
| function invoke(collection, methodName) { |
| var args = slice(arguments, 2), |
| index = -1, |
| isFunc = typeof methodName == 'function', |
| length = collection ? collection.length : 0, |
| result = Array(typeof length == 'number' ? length : 0); |
| |
| forEach(collection, function(value) { |
| result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args); |
| }); |
| return result; |
| } |
| |
| module.exports = invoke; |
| |
| },{"../internals/slice":137,"./forEach":59}],64:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Creates an array of values by running each element in the collection |
| * through the callback. The callback is bound to `thisArg` and invoked with |
| * three arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias collect |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new array of the results of each `callback` execution. |
| * @example |
| * |
| * _.map([1, 2, 3], function(num) { return num * 3; }); |
| * // => [3, 6, 9] |
| * |
| * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); |
| * // => [3, 6, 9] (property order is not guaranteed across environments) |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.map(characters, 'name'); |
| * // => ['barney', 'fred'] |
| */ |
| function map(collection, callback, thisArg) { |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| callback = createCallback(callback, thisArg, 3); |
| if (typeof length == 'number') { |
| var result = Array(length); |
| while (++index < length) { |
| result[index] = callback(collection[index], index, collection); |
| } |
| } else { |
| result = []; |
| forOwn(collection, function(value, key, collection) { |
| result[++index] = callback(value, key, collection); |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = map; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149}],65:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var charAtCallback = require('../internals/charAtCallback'), |
| createCallback = require('../functions/createCallback'), |
| forEach = require('./forEach'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'), |
| isString = require('../objects/isString'); |
| |
| /** |
| * Retrieves the maximum value of a collection. If the collection is empty or |
| * falsey `-Infinity` is returned. If a callback is provided it will be executed |
| * for each value in the collection to generate the criterion by which the value |
| * is ranked. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, index, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the maximum value. |
| * @example |
| * |
| * _.max([4, 2, 8, 6]); |
| * // => 8 |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.max(characters, function(chr) { return chr.age; }); |
| * // => { 'name': 'fred', 'age': 40 }; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.max(characters, 'age'); |
| * // => { 'name': 'fred', 'age': 40 }; |
| */ |
| function max(collection, callback, thisArg) { |
| var computed = -Infinity, |
| result = computed; |
| |
| // allows working with functions like `_.map` without using |
| // their `index` argument as a callback |
| if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { |
| callback = null; |
| } |
| if (callback == null && isArray(collection)) { |
| var index = -1, |
| length = collection.length; |
| |
| while (++index < length) { |
| var value = collection[index]; |
| if (value > result) { |
| result = value; |
| } |
| } |
| } else { |
| callback = (callback == null && isString(collection)) |
| ? charAtCallback |
| : createCallback(callback, thisArg, 3); |
| |
| forEach(collection, function(value, index, collection) { |
| var current = callback(value, index, collection); |
| if (current > computed) { |
| computed = current; |
| result = value; |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = max; |
| |
| },{"../functions/createCallback":84,"../internals/charAtCallback":111,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isString":169,"./forEach":59}],66:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var charAtCallback = require('../internals/charAtCallback'), |
| createCallback = require('../functions/createCallback'), |
| forEach = require('./forEach'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'), |
| isString = require('../objects/isString'); |
| |
| /** |
| * Retrieves the minimum value of a collection. If the collection is empty or |
| * falsey `Infinity` is returned. If a callback is provided it will be executed |
| * for each value in the collection to generate the criterion by which the value |
| * is ranked. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, index, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the minimum value. |
| * @example |
| * |
| * _.min([4, 2, 8, 6]); |
| * // => 2 |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.min(characters, function(chr) { return chr.age; }); |
| * // => { 'name': 'barney', 'age': 36 }; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.min(characters, 'age'); |
| * // => { 'name': 'barney', 'age': 36 }; |
| */ |
| function min(collection, callback, thisArg) { |
| var computed = Infinity, |
| result = computed; |
| |
| // allows working with functions like `_.map` without using |
| // their `index` argument as a callback |
| if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { |
| callback = null; |
| } |
| if (callback == null && isArray(collection)) { |
| var index = -1, |
| length = collection.length; |
| |
| while (++index < length) { |
| var value = collection[index]; |
| if (value < result) { |
| result = value; |
| } |
| } |
| } else { |
| callback = (callback == null && isString(collection)) |
| ? charAtCallback |
| : createCallback(callback, thisArg, 3); |
| |
| forEach(collection, function(value, index, collection) { |
| var current = callback(value, index, collection); |
| if (current < computed) { |
| computed = current; |
| result = value; |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = min; |
| |
| },{"../functions/createCallback":84,"../internals/charAtCallback":111,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isString":169,"./forEach":59}],67:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var map = require('./map'); |
| |
| /** |
| * Retrieves the value of a specified property from all elements in the collection. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {string} property The name of the property to pluck. |
| * @returns {Array} Returns a new array of property values. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.pluck(characters, 'name'); |
| * // => ['barney', 'fred'] |
| */ |
| var pluck = map; |
| |
| module.exports = pluck; |
| |
| },{"./map":64}],68:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'); |
| |
| /** |
| * Reduces a collection to a value which is the accumulated result of running |
| * each element in the collection through the callback, where each successive |
| * callback execution consumes the return value of the previous execution. If |
| * `accumulator` is not provided the first element of the collection will be |
| * used as the initial `accumulator` value. The callback is bound to `thisArg` |
| * and invoked with four arguments; (accumulator, value, index|key, collection). |
| * |
| * @static |
| * @memberOf _ |
| * @alias foldl, inject |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [accumulator] Initial value of the accumulator. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * var sum = _.reduce([1, 2, 3], function(sum, num) { |
| * return sum + num; |
| * }); |
| * // => 6 |
| * |
| * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { |
| * result[key] = num * 3; |
| * return result; |
| * }, {}); |
| * // => { 'a': 3, 'b': 6, 'c': 9 } |
| */ |
| function reduce(collection, callback, accumulator, thisArg) { |
| if (!collection) return accumulator; |
| var noaccum = arguments.length < 3; |
| callback = createCallback(callback, thisArg, 4); |
| |
| var index = -1, |
| length = collection.length; |
| |
| if (typeof length == 'number') { |
| if (noaccum) { |
| accumulator = collection[++index]; |
| } |
| while (++index < length) { |
| accumulator = callback(accumulator, collection[index], index, collection); |
| } |
| } else { |
| forOwn(collection, function(value, index, collection) { |
| accumulator = noaccum |
| ? (noaccum = false, value) |
| : callback(accumulator, value, index, collection) |
| }); |
| } |
| return accumulator; |
| } |
| |
| module.exports = reduce; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149}],69:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forEachRight = require('./forEachRight'); |
| |
| /** |
| * This method is like `_.reduce` except that it iterates over elements |
| * of a `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @alias foldr |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [accumulator] Initial value of the accumulator. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * var list = [[0, 1], [2, 3], [4, 5]]; |
| * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); |
| * // => [4, 5, 2, 3, 0, 1] |
| */ |
| function reduceRight(collection, callback, accumulator, thisArg) { |
| var noaccum = arguments.length < 3; |
| callback = createCallback(callback, thisArg, 4); |
| forEachRight(collection, function(value, index, collection) { |
| accumulator = noaccum |
| ? (noaccum = false, value) |
| : callback(accumulator, value, index, collection); |
| }); |
| return accumulator; |
| } |
| |
| module.exports = reduceRight; |
| |
| },{"../functions/createCallback":84,"./forEachRight":60}],70:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| filter = require('./filter'); |
| |
| /** |
| * The opposite of `_.filter` this method returns the elements of a |
| * collection that the callback does **not** return truey for. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new array of elements that failed the callback check. |
| * @example |
| * |
| * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); |
| * // => [1, 3, 5] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': false }, |
| * { 'name': 'fred', 'age': 40, 'blocked': true } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.reject(characters, 'blocked'); |
| * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] |
| * |
| * // using "_.where" callback shorthand |
| * _.reject(characters, { 'age': 36 }); |
| * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] |
| */ |
| function reject(collection, callback, thisArg) { |
| callback = createCallback(callback, thisArg, 3); |
| return filter(collection, function(value, index, collection) { |
| return !callback(value, index, collection); |
| }); |
| } |
| |
| module.exports = reject; |
| |
| },{"../functions/createCallback":84,"./filter":56}],71:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseRandom = require('../internals/baseRandom'), |
| isString = require('../objects/isString'), |
| shuffle = require('./shuffle'), |
| values = require('../objects/values'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max, |
| nativeMin = Math.min; |
| |
| /** |
| * Retrieves a random element or `n` random elements from a collection. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to sample. |
| * @param {number} [n] The number of elements to sample. |
| * @param- {Object} [guard] Allows working with functions like `_.map` |
| * without using their `index` arguments as `n`. |
| * @returns {Array} Returns the random sample(s) of `collection`. |
| * @example |
| * |
| * _.sample([1, 2, 3, 4]); |
| * // => 2 |
| * |
| * _.sample([1, 2, 3, 4], 2); |
| * // => [3, 1] |
| */ |
| function sample(collection, n, guard) { |
| if (collection && typeof collection.length != 'number') { |
| collection = values(collection); |
| } |
| if (n == null || guard) { |
| return collection ? collection[baseRandom(0, collection.length - 1)] : undefined; |
| } |
| var result = shuffle(collection); |
| result.length = nativeMin(nativeMax(0, n), result.length); |
| return result; |
| } |
| |
| module.exports = sample; |
| |
| },{"../internals/baseRandom":107,"../objects/isString":169,"../objects/values":178,"./shuffle":72}],72:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseRandom = require('../internals/baseRandom'), |
| forEach = require('./forEach'); |
| |
| /** |
| * Creates an array of shuffled values, using a version of the Fisher-Yates |
| * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to shuffle. |
| * @returns {Array} Returns a new shuffled collection. |
| * @example |
| * |
| * _.shuffle([1, 2, 3, 4, 5, 6]); |
| * // => [4, 1, 6, 3, 5, 2] |
| */ |
| function shuffle(collection) { |
| var index = -1, |
| length = collection ? collection.length : 0, |
| result = Array(typeof length == 'number' ? length : 0); |
| |
| forEach(collection, function(value) { |
| var rand = baseRandom(0, ++index); |
| result[index] = result[rand]; |
| result[rand] = value; |
| }); |
| return result; |
| } |
| |
| module.exports = shuffle; |
| |
| },{"../internals/baseRandom":107,"./forEach":59}],73:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('../objects/keys'); |
| |
| /** |
| * Gets the size of the `collection` by returning `collection.length` for arrays |
| * and array-like objects or the number of own enumerable properties for objects. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to inspect. |
| * @returns {number} Returns `collection.length` or number of own enumerable properties. |
| * @example |
| * |
| * _.size([1, 2]); |
| * // => 2 |
| * |
| * _.size({ 'one': 1, 'two': 2, 'three': 3 }); |
| * // => 3 |
| * |
| * _.size('pebbles'); |
| * // => 7 |
| */ |
| function size(collection) { |
| var length = collection ? collection.length : 0; |
| return typeof length == 'number' ? length : keys(collection).length; |
| } |
| |
| module.exports = size; |
| |
| },{"../objects/keys":171}],74:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'); |
| |
| /** |
| * Checks if the callback returns a truey value for **any** element of a |
| * collection. The function returns as soon as it finds a passing value and |
| * does not iterate over the entire collection. The callback is bound to |
| * `thisArg` and invoked with three arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias any |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {boolean} Returns `true` if any element passed the callback check, |
| * else `false`. |
| * @example |
| * |
| * _.some([null, 0, 'yes', false], Boolean); |
| * // => true |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'blocked': false }, |
| * { 'name': 'fred', 'age': 40, 'blocked': true } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.some(characters, 'blocked'); |
| * // => true |
| * |
| * // using "_.where" callback shorthand |
| * _.some(characters, { 'age': 1 }); |
| * // => false |
| */ |
| function some(collection, callback, thisArg) { |
| var result; |
| callback = createCallback(callback, thisArg, 3); |
| |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| if (typeof length == 'number') { |
| while (++index < length) { |
| if ((result = callback(collection[index], index, collection))) { |
| break; |
| } |
| } |
| } else { |
| forOwn(collection, function(value, index, collection) { |
| return !(result = callback(value, index, collection)); |
| }); |
| } |
| return !!result; |
| } |
| |
| module.exports = some; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149,"../objects/isArray":155}],75:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var compareAscending = require('../internals/compareAscending'), |
| createCallback = require('../functions/createCallback'), |
| forEach = require('./forEach'), |
| getArray = require('../internals/getArray'), |
| getObject = require('../internals/getObject'), |
| isArray = require('../objects/isArray'), |
| map = require('./map'), |
| releaseArray = require('../internals/releaseArray'), |
| releaseObject = require('../internals/releaseObject'); |
| |
| /** |
| * Creates an array of elements, sorted in ascending order by the results of |
| * running each element in a collection through the callback. This method |
| * performs a stable sort, that is, it will preserve the original sort order |
| * of equal elements. The callback is bound to `thisArg` and invoked with |
| * three arguments; (value, index|key, collection). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an array of property names is provided for `callback` the collection |
| * will be sorted by each property value. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Array|Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new array of sorted elements. |
| * @example |
| * |
| * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); |
| * // => [3, 1, 2] |
| * |
| * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); |
| * // => [3, 1, 2] |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 }, |
| * { 'name': 'barney', 'age': 26 }, |
| * { 'name': 'fred', 'age': 30 } |
| * ]; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.map(_.sortBy(characters, 'age'), _.values); |
| * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]] |
| * |
| * // sorting by multiple properties |
| * _.map(_.sortBy(characters, ['name', 'age']), _.values); |
| * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]] |
| */ |
| function sortBy(collection, callback, thisArg) { |
| var index = -1, |
| isArr = isArray(callback), |
| length = collection ? collection.length : 0, |
| result = Array(typeof length == 'number' ? length : 0); |
| |
| if (!isArr) { |
| callback = createCallback(callback, thisArg, 3); |
| } |
| forEach(collection, function(value, key, collection) { |
| var object = result[++index] = getObject(); |
| if (isArr) { |
| object.criteria = map(callback, function(key) { return value[key]; }); |
| } else { |
| (object.criteria = getArray())[0] = callback(value, key, collection); |
| } |
| object.index = index; |
| object.value = value; |
| }); |
| |
| length = result.length; |
| result.sort(compareAscending); |
| while (length--) { |
| var object = result[length]; |
| result[length] = object.value; |
| if (!isArr) { |
| releaseArray(object.criteria); |
| } |
| releaseObject(object); |
| } |
| return result; |
| } |
| |
| module.exports = sortBy; |
| |
| },{"../functions/createCallback":84,"../internals/compareAscending":112,"../internals/getArray":118,"../internals/getObject":119,"../internals/releaseArray":132,"../internals/releaseObject":133,"../objects/isArray":155,"./forEach":59,"./map":64}],76:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isString = require('../objects/isString'), |
| slice = require('../internals/slice'), |
| values = require('../objects/values'); |
| |
| /** |
| * Converts the `collection` to an array. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to convert. |
| * @returns {Array} Returns the new converted array. |
| * @example |
| * |
| * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); |
| * // => [2, 3, 4] |
| */ |
| function toArray(collection) { |
| if (collection && typeof collection.length == 'number') { |
| return slice(collection); |
| } |
| return values(collection); |
| } |
| |
| module.exports = toArray; |
| |
| },{"../internals/slice":137,"../objects/isString":169,"../objects/values":178}],77:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var filter = require('./filter'); |
| |
| /** |
| * Performs a deep comparison of each element in a `collection` to the given |
| * `properties` object, returning an array of all elements that have equivalent |
| * property values. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Collections |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Object} props The object of property values to filter by. |
| * @returns {Array} Returns a new array of elements that have the given properties. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }, |
| * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } |
| * ]; |
| * |
| * _.where(characters, { 'age': 36 }); |
| * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }] |
| * |
| * _.where(characters, { 'pets': ['dino'] }); |
| * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }] |
| */ |
| var where = filter; |
| |
| module.exports = where; |
| |
| },{"./filter":56}],78:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'after': require('./functions/after'), |
| 'bind': require('./functions/bind'), |
| 'bindAll': require('./functions/bindAll'), |
| 'bindKey': require('./functions/bindKey'), |
| 'compose': require('./functions/compose'), |
| 'createCallback': require('./functions/createCallback'), |
| 'curry': require('./functions/curry'), |
| 'debounce': require('./functions/debounce'), |
| 'defer': require('./functions/defer'), |
| 'delay': require('./functions/delay'), |
| 'memoize': require('./functions/memoize'), |
| 'once': require('./functions/once'), |
| 'partial': require('./functions/partial'), |
| 'partialRight': require('./functions/partialRight'), |
| 'throttle': require('./functions/throttle'), |
| 'wrap': require('./functions/wrap') |
| }; |
| |
| },{"./functions/after":79,"./functions/bind":80,"./functions/bindAll":81,"./functions/bindKey":82,"./functions/compose":83,"./functions/createCallback":84,"./functions/curry":85,"./functions/debounce":86,"./functions/defer":87,"./functions/delay":88,"./functions/memoize":89,"./functions/once":90,"./functions/partial":91,"./functions/partialRight":92,"./functions/throttle":93,"./functions/wrap":94}],79:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'); |
| |
| /** |
| * Creates a function that executes `func`, with the `this` binding and |
| * arguments of the created function, only after being called `n` times. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {number} n The number of times the function must be called before |
| * `func` is executed. |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * var saves = ['profile', 'settings']; |
| * |
| * var done = _.after(saves.length, function() { |
| * console.log('Done saving!'); |
| * }); |
| * |
| * _.forEach(saves, function(type) { |
| * asyncSave({ 'type': type, 'complete': done }); |
| * }); |
| * // => logs 'Done saving!', after all saves have completed |
| */ |
| function after(n, func) { |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| return function() { |
| if (--n < 1) { |
| return func.apply(this, arguments); |
| } |
| }; |
| } |
| |
| module.exports = after; |
| |
| },{"../objects/isFunction":162}],80:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Creates a function that, when called, invokes `func` with the `this` |
| * binding of `thisArg` and prepends any additional `bind` arguments to those |
| * provided to the bound function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to bind. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param {...*} [arg] Arguments to be partially applied. |
| * @returns {Function} Returns the new bound function. |
| * @example |
| * |
| * var func = function(greeting) { |
| * return greeting + ' ' + this.name; |
| * }; |
| * |
| * func = _.bind(func, { 'name': 'fred' }, 'hi'); |
| * func(); |
| * // => 'hi fred' |
| */ |
| function bind(func, thisArg) { |
| return arguments.length > 2 |
| ? createWrapper(func, 17, slice(arguments, 2), null, thisArg) |
| : createWrapper(func, 1, null, null, thisArg); |
| } |
| |
| module.exports = bind; |
| |
| },{"../internals/createWrapper":115,"../internals/slice":137}],81:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseFlatten = require('../internals/baseFlatten'), |
| createWrapper = require('../internals/createWrapper'), |
| functions = require('../objects/functions'); |
| |
| /** |
| * Binds methods of an object to the object itself, overwriting the existing |
| * method. Method names may be specified as individual arguments or as arrays |
| * of method names. If no method names are provided all the function properties |
| * of `object` will be bound. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Object} object The object to bind and assign the bound methods to. |
| * @param {...string} [methodName] The object method names to |
| * bind, specified as individual method names or arrays of method names. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * var view = { |
| * 'label': 'docs', |
| * 'onClick': function() { console.log('clicked ' + this.label); } |
| * }; |
| * |
| * _.bindAll(view); |
| * jQuery('#docs').on('click', view.onClick); |
| * // => logs 'clicked docs', when the button is clicked |
| */ |
| function bindAll(object) { |
| var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object), |
| index = -1, |
| length = funcs.length; |
| |
| while (++index < length) { |
| var key = funcs[index]; |
| object[key] = createWrapper(object[key], 1, null, null, object); |
| } |
| return object; |
| } |
| |
| module.exports = bindAll; |
| |
| },{"../internals/baseFlatten":103,"../internals/createWrapper":115,"../objects/functions":151}],82:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Creates a function that, when called, invokes the method at `object[key]` |
| * and prepends any additional `bindKey` arguments to those provided to the bound |
| * function. This method differs from `_.bind` by allowing bound functions to |
| * reference methods that will be redefined or don't yet exist. |
| * See http://michaux.ca/articles/lazy-function-definition-pattern. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Object} object The object the method belongs to. |
| * @param {string} key The key of the method. |
| * @param {...*} [arg] Arguments to be partially applied. |
| * @returns {Function} Returns the new bound function. |
| * @example |
| * |
| * var object = { |
| * 'name': 'fred', |
| * 'greet': function(greeting) { |
| * return greeting + ' ' + this.name; |
| * } |
| * }; |
| * |
| * var func = _.bindKey(object, 'greet', 'hi'); |
| * func(); |
| * // => 'hi fred' |
| * |
| * object.greet = function(greeting) { |
| * return greeting + 'ya ' + this.name + '!'; |
| * }; |
| * |
| * func(); |
| * // => 'hiya fred!' |
| */ |
| function bindKey(object, key) { |
| return arguments.length > 2 |
| ? createWrapper(key, 19, slice(arguments, 2), null, object) |
| : createWrapper(key, 3, null, null, object); |
| } |
| |
| module.exports = bindKey; |
| |
| },{"../internals/createWrapper":115,"../internals/slice":137}],83:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'); |
| |
| /** |
| * Creates a function that is the composition of the provided functions, |
| * where each function consumes the return value of the function that follows. |
| * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. |
| * Each function is executed with the `this` binding of the composed function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {...Function} [func] Functions to compose. |
| * @returns {Function} Returns the new composed function. |
| * @example |
| * |
| * var realNameMap = { |
| * 'pebbles': 'penelope' |
| * }; |
| * |
| * var format = function(name) { |
| * name = realNameMap[name.toLowerCase()] || name; |
| * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase(); |
| * }; |
| * |
| * var greet = function(formatted) { |
| * return 'Hiya ' + formatted + '!'; |
| * }; |
| * |
| * var welcome = _.compose(greet, format); |
| * welcome('pebbles'); |
| * // => 'Hiya Penelope!' |
| */ |
| function compose() { |
| var funcs = arguments, |
| length = funcs.length; |
| |
| while (length--) { |
| if (!isFunction(funcs[length])) { |
| throw new TypeError; |
| } |
| } |
| return function() { |
| var args = arguments, |
| length = funcs.length; |
| |
| while (length--) { |
| args = [funcs[length].apply(this, args)]; |
| } |
| return args[0]; |
| }; |
| } |
| |
| module.exports = compose; |
| |
| },{"../objects/isFunction":162}],84:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| baseIsEqual = require('../internals/baseIsEqual'), |
| isObject = require('../objects/isObject'), |
| keys = require('../objects/keys'), |
| property = require('../utilities/property'); |
| |
| /** |
| * Produces a callback bound to an optional `thisArg`. If `func` is a property |
| * name the created callback will return the property value for a given element. |
| * If `func` is an object the created callback will return `true` for elements |
| * that contain the equivalent object properties, otherwise it will return `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {*} [func=identity] The value to convert to a callback. |
| * @param {*} [thisArg] The `this` binding of the created callback. |
| * @param {number} [argCount] The number of arguments the callback accepts. |
| * @returns {Function} Returns a callback function. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // wrap to create custom callback shorthands |
| * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) { |
| * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback); |
| * return !match ? func(callback, thisArg) : function(object) { |
| * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3]; |
| * }; |
| * }); |
| * |
| * _.filter(characters, 'age__gt38'); |
| * // => [{ 'name': 'fred', 'age': 40 }] |
| */ |
| function createCallback(func, thisArg, argCount) { |
| var type = typeof func; |
| if (func == null || type == 'function') { |
| return baseCreateCallback(func, thisArg, argCount); |
| } |
| // handle "_.pluck" style callback shorthands |
| if (type != 'object') { |
| return property(func); |
| } |
| var props = keys(func), |
| key = props[0], |
| a = func[key]; |
| |
| // handle "_.where" style callback shorthands |
| if (props.length == 1 && a === a && !isObject(a)) { |
| // fast path the common case of providing an object with a single |
| // property containing a primitive value |
| return function(object) { |
| var b = object[key]; |
| return a === b && (a !== 0 || (1 / a == 1 / b)); |
| }; |
| } |
| return function(object) { |
| var length = props.length, |
| result = false; |
| |
| while (length--) { |
| if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) { |
| break; |
| } |
| } |
| return result; |
| }; |
| } |
| |
| module.exports = createCallback; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/baseIsEqual":105,"../objects/isObject":166,"../objects/keys":171,"../utilities/property":189}],85:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'); |
| |
| /** |
| * Creates a function which accepts one or more arguments of `func` that when |
| * invoked either executes `func` returning its result, if all `func` arguments |
| * have been provided, or returns a function that accepts one or more of the |
| * remaining `func` arguments, and so on. The arity of `func` can be specified |
| * if `func.length` is not sufficient. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to curry. |
| * @param {number} [arity=func.length] The arity of `func`. |
| * @returns {Function} Returns the new curried function. |
| * @example |
| * |
| * var curried = _.curry(function(a, b, c) { |
| * console.log(a + b + c); |
| * }); |
| * |
| * curried(1)(2)(3); |
| * // => 6 |
| * |
| * curried(1, 2)(3); |
| * // => 6 |
| * |
| * curried(1, 2, 3); |
| * // => 6 |
| */ |
| function curry(func, arity) { |
| arity = typeof arity == 'number' ? arity : (+arity || func.length); |
| return createWrapper(func, 4, null, null, null, arity); |
| } |
| |
| module.exports = curry; |
| |
| },{"../internals/createWrapper":115}],86:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'), |
| isObject = require('../objects/isObject'), |
| now = require('../utilities/now'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMax = Math.max; |
| |
| /** |
| * Creates a function that will delay the execution of `func` until after |
| * `wait` milliseconds have elapsed since the last time it was invoked. |
| * Provide an options object to indicate that `func` should be invoked on |
| * the leading and/or trailing edge of the `wait` timeout. Subsequent calls |
| * to the debounced function will return the result of the last `func` call. |
| * |
| * Note: If `leading` and `trailing` options are `true` `func` will be called |
| * on the trailing edge of the timeout only if the the debounced function is |
| * invoked more than once during the `wait` timeout. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to debounce. |
| * @param {number} wait The number of milliseconds to delay. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout. |
| * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called. |
| * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. |
| * @returns {Function} Returns the new debounced function. |
| * @example |
| * |
| * // avoid costly calculations while the window size is in flux |
| * var lazyLayout = _.debounce(calculateLayout, 150); |
| * jQuery(window).on('resize', lazyLayout); |
| * |
| * // execute `sendMail` when the click event is fired, debouncing subsequent calls |
| * jQuery('#postbox').on('click', _.debounce(sendMail, 300, { |
| * 'leading': true, |
| * 'trailing': false |
| * }); |
| * |
| * // ensure `batchLog` is executed once after 1 second of debounced calls |
| * var source = new EventSource('/stream'); |
| * source.addEventListener('message', _.debounce(batchLog, 250, { |
| * 'maxWait': 1000 |
| * }, false); |
| */ |
| function debounce(func, wait, options) { |
| var args, |
| maxTimeoutId, |
| result, |
| stamp, |
| thisArg, |
| timeoutId, |
| trailingCall, |
| lastCalled = 0, |
| maxWait = false, |
| trailing = true; |
| |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| wait = nativeMax(0, wait) || 0; |
| if (options === true) { |
| var leading = true; |
| trailing = false; |
| } else if (isObject(options)) { |
| leading = options.leading; |
| maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0); |
| trailing = 'trailing' in options ? options.trailing : trailing; |
| } |
| var delayed = function() { |
| var remaining = wait - (now() - stamp); |
| if (remaining <= 0) { |
| if (maxTimeoutId) { |
| clearTimeout(maxTimeoutId); |
| } |
| var isCalled = trailingCall; |
| maxTimeoutId = timeoutId = trailingCall = undefined; |
| if (isCalled) { |
| lastCalled = now(); |
| result = func.apply(thisArg, args); |
| if (!timeoutId && !maxTimeoutId) { |
| args = thisArg = null; |
| } |
| } |
| } else { |
| timeoutId = setTimeout(delayed, remaining); |
| } |
| }; |
| |
| var maxDelayed = function() { |
| if (timeoutId) { |
| clearTimeout(timeoutId); |
| } |
| maxTimeoutId = timeoutId = trailingCall = undefined; |
| if (trailing || (maxWait !== wait)) { |
| lastCalled = now(); |
| result = func.apply(thisArg, args); |
| if (!timeoutId && !maxTimeoutId) { |
| args = thisArg = null; |
| } |
| } |
| }; |
| |
| return function() { |
| args = arguments; |
| stamp = now(); |
| thisArg = this; |
| trailingCall = trailing && (timeoutId || !leading); |
| |
| if (maxWait === false) { |
| var leadingCall = leading && !timeoutId; |
| } else { |
| if (!maxTimeoutId && !leading) { |
| lastCalled = stamp; |
| } |
| var remaining = maxWait - (stamp - lastCalled), |
| isCalled = remaining <= 0; |
| |
| if (isCalled) { |
| if (maxTimeoutId) { |
| maxTimeoutId = clearTimeout(maxTimeoutId); |
| } |
| lastCalled = stamp; |
| result = func.apply(thisArg, args); |
| } |
| else if (!maxTimeoutId) { |
| maxTimeoutId = setTimeout(maxDelayed, remaining); |
| } |
| } |
| if (isCalled && timeoutId) { |
| timeoutId = clearTimeout(timeoutId); |
| } |
| else if (!timeoutId && wait !== maxWait) { |
| timeoutId = setTimeout(delayed, wait); |
| } |
| if (leadingCall) { |
| isCalled = true; |
| result = func.apply(thisArg, args); |
| } |
| if (isCalled && !timeoutId && !maxTimeoutId) { |
| args = thisArg = null; |
| } |
| return result; |
| }; |
| } |
| |
| module.exports = debounce; |
| |
| },{"../objects/isFunction":162,"../objects/isObject":166,"../utilities/now":187}],87:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Defers executing the `func` function until the current call stack has cleared. |
| * Additional arguments will be provided to `func` when it is invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to defer. |
| * @param {...*} [arg] Arguments to invoke the function with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.defer(function(text) { console.log(text); }, 'deferred'); |
| * // logs 'deferred' after one or more milliseconds |
| */ |
| function defer(func) { |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| var args = slice(arguments, 1); |
| return setTimeout(function() { func.apply(undefined, args); }, 1); |
| } |
| |
| module.exports = defer; |
| |
| },{"../internals/slice":137,"../objects/isFunction":162}],88:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Executes the `func` function after `wait` milliseconds. Additional arguments |
| * will be provided to `func` when it is invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to delay. |
| * @param {number} wait The number of milliseconds to delay execution. |
| * @param {...*} [arg] Arguments to invoke the function with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.delay(function(text) { console.log(text); }, 1000, 'later'); |
| * // => logs 'later' after one second |
| */ |
| function delay(func, wait) { |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| var args = slice(arguments, 2); |
| return setTimeout(function() { func.apply(undefined, args); }, wait); |
| } |
| |
| module.exports = delay; |
| |
| },{"../internals/slice":137,"../objects/isFunction":162}],89:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'), |
| keyPrefix = require('../internals/keyPrefix'); |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Creates a function that memoizes the result of `func`. If `resolver` is |
| * provided it will be used to determine the cache key for storing the result |
| * based on the arguments provided to the memoized function. By default, the |
| * first argument provided to the memoized function is used as the cache key. |
| * The `func` is executed with the `this` binding of the memoized function. |
| * The result cache is exposed as the `cache` property on the memoized function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to have its output memoized. |
| * @param {Function} [resolver] A function used to resolve the cache key. |
| * @returns {Function} Returns the new memoizing function. |
| * @example |
| * |
| * var fibonacci = _.memoize(function(n) { |
| * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); |
| * }); |
| * |
| * fibonacci(9) |
| * // => 34 |
| * |
| * var data = { |
| * 'fred': { 'name': 'fred', 'age': 40 }, |
| * 'pebbles': { 'name': 'pebbles', 'age': 1 } |
| * }; |
| * |
| * // modifying the result cache |
| * var get = _.memoize(function(name) { return data[name]; }, _.identity); |
| * get('pebbles'); |
| * // => { 'name': 'pebbles', 'age': 1 } |
| * |
| * get.cache.pebbles.name = 'penelope'; |
| * get('pebbles'); |
| * // => { 'name': 'penelope', 'age': 1 } |
| */ |
| function memoize(func, resolver) { |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| var memoized = function() { |
| var cache = memoized.cache, |
| key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0]; |
| |
| return hasOwnProperty.call(cache, key) |
| ? cache[key] |
| : (cache[key] = func.apply(this, arguments)); |
| } |
| memoized.cache = {}; |
| return memoized; |
| } |
| |
| module.exports = memoize; |
| |
| },{"../internals/keyPrefix":123,"../objects/isFunction":162}],90:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'); |
| |
| /** |
| * Creates a function that is restricted to execute `func` once. Repeat calls to |
| * the function will return the value of the first call. The `func` is executed |
| * with the `this` binding of the created function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * var initialize = _.once(createApplication); |
| * initialize(); |
| * initialize(); |
| * // `initialize` executes `createApplication` once |
| */ |
| function once(func) { |
| var ran, |
| result; |
| |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| return function() { |
| if (ran) { |
| return result; |
| } |
| ran = true; |
| result = func.apply(this, arguments); |
| |
| // clear the `func` variable so the function may be garbage collected |
| func = null; |
| return result; |
| }; |
| } |
| |
| module.exports = once; |
| |
| },{"../objects/isFunction":162}],91:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Creates a function that, when called, invokes `func` with any additional |
| * `partial` arguments prepended to those provided to the new function. This |
| * method is similar to `_.bind` except it does **not** alter the `this` binding. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to partially apply arguments to. |
| * @param {...*} [arg] Arguments to be partially applied. |
| * @returns {Function} Returns the new partially applied function. |
| * @example |
| * |
| * var greet = function(greeting, name) { return greeting + ' ' + name; }; |
| * var hi = _.partial(greet, 'hi'); |
| * hi('fred'); |
| * // => 'hi fred' |
| */ |
| function partial(func) { |
| return createWrapper(func, 16, slice(arguments, 1)); |
| } |
| |
| module.exports = partial; |
| |
| },{"../internals/createWrapper":115,"../internals/slice":137}],92:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * This method is like `_.partial` except that `partial` arguments are |
| * appended to those provided to the new function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to partially apply arguments to. |
| * @param {...*} [arg] Arguments to be partially applied. |
| * @returns {Function} Returns the new partially applied function. |
| * @example |
| * |
| * var defaultsDeep = _.partialRight(_.merge, _.defaults); |
| * |
| * var options = { |
| * 'variable': 'data', |
| * 'imports': { 'jq': $ } |
| * }; |
| * |
| * defaultsDeep(options, _.templateSettings); |
| * |
| * options.variable |
| * // => 'data' |
| * |
| * options.imports |
| * // => { '_': _, 'jq': $ } |
| */ |
| function partialRight(func) { |
| return createWrapper(func, 32, null, slice(arguments, 1)); |
| } |
| |
| module.exports = partialRight; |
| |
| },{"../internals/createWrapper":115,"../internals/slice":137}],93:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var debounce = require('./debounce'), |
| isFunction = require('../objects/isFunction'), |
| isObject = require('../objects/isObject'); |
| |
| /** Used as an internal `_.debounce` options object */ |
| var debounceOptions = { |
| 'leading': false, |
| 'maxWait': 0, |
| 'trailing': false |
| }; |
| |
| /** |
| * Creates a function that, when executed, will only call the `func` function |
| * at most once per every `wait` milliseconds. Provide an options object to |
| * indicate that `func` should be invoked on the leading and/or trailing edge |
| * of the `wait` timeout. Subsequent calls to the throttled function will |
| * return the result of the last `func` call. |
| * |
| * Note: If `leading` and `trailing` options are `true` `func` will be called |
| * on the trailing edge of the timeout only if the the throttled function is |
| * invoked more than once during the `wait` timeout. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {Function} func The function to throttle. |
| * @param {number} wait The number of milliseconds to throttle executions to. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout. |
| * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. |
| * @returns {Function} Returns the new throttled function. |
| * @example |
| * |
| * // avoid excessively updating the position while scrolling |
| * var throttled = _.throttle(updatePosition, 100); |
| * jQuery(window).on('scroll', throttled); |
| * |
| * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes |
| * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, { |
| * 'trailing': false |
| * })); |
| */ |
| function throttle(func, wait, options) { |
| var leading = true, |
| trailing = true; |
| |
| if (!isFunction(func)) { |
| throw new TypeError; |
| } |
| if (options === false) { |
| leading = false; |
| } else if (isObject(options)) { |
| leading = 'leading' in options ? options.leading : leading; |
| trailing = 'trailing' in options ? options.trailing : trailing; |
| } |
| debounceOptions.leading = leading; |
| debounceOptions.maxWait = wait; |
| debounceOptions.trailing = trailing; |
| |
| return debounce(func, wait, debounceOptions); |
| } |
| |
| module.exports = throttle; |
| |
| },{"../objects/isFunction":162,"../objects/isObject":166,"./debounce":86}],94:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createWrapper = require('../internals/createWrapper'); |
| |
| /** |
| * Creates a function that provides `value` to the wrapper function as its |
| * first argument. Additional arguments provided to the function are appended |
| * to those provided to the wrapper function. The wrapper is executed with |
| * the `this` binding of the created function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Functions |
| * @param {*} value The value to wrap. |
| * @param {Function} wrapper The wrapper function. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var p = _.wrap(_.escape, function(func, text) { |
| * return '<p>' + func(text) + '</p>'; |
| * }); |
| * |
| * p('Fred, Wilma, & Pebbles'); |
| * // => '<p>Fred, Wilma, & Pebbles</p>' |
| */ |
| function wrap(value, wrapper) { |
| return createWrapper(wrapper, 16, [value]); |
| } |
| |
| module.exports = wrap; |
| |
| },{"../internals/createWrapper":115}],95:[function(require,module,exports){ |
| /** |
| * @license |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var arrays = require('./arrays'), |
| chaining = require('./chaining'), |
| collections = require('./collections'), |
| functions = require('./functions'), |
| objects = require('./objects'), |
| utilities = require('./utilities'), |
| forEach = require('./collections/forEach'), |
| forOwn = require('./objects/forOwn'), |
| isArray = require('./objects/isArray'), |
| lodashWrapper = require('./internals/lodashWrapper'), |
| mixin = require('./utilities/mixin'), |
| support = require('./support'), |
| templateSettings = require('./utilities/templateSettings'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Creates a `lodash` object which wraps the given value to enable intuitive |
| * method chaining. |
| * |
| * In addition to Lo-Dash methods, wrappers also have the following `Array` methods: |
| * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`, |
| * and `unshift` |
| * |
| * Chaining is supported in custom builds as long as the `value` method is |
| * implicitly or explicitly included in the build. |
| * |
| * The chainable wrapper functions are: |
| * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, |
| * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`, |
| * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`, |
| * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, |
| * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, |
| * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`, |
| * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`, |
| * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, |
| * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`, |
| * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`, |
| * and `zip` |
| * |
| * The non-chainable wrapper functions are: |
| * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`, |
| * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`, |
| * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, |
| * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, |
| * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, |
| * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`, |
| * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`, |
| * `template`, `unescape`, `uniqueId`, and `value` |
| * |
| * The wrapper functions `first` and `last` return wrapped values when `n` is |
| * provided, otherwise they return unwrapped values. |
| * |
| * Explicit chaining can be enabled by using the `_.chain` method. |
| * |
| * @name _ |
| * @constructor |
| * @category Chaining |
| * @param {*} value The value to wrap in a `lodash` instance. |
| * @returns {Object} Returns a `lodash` instance. |
| * @example |
| * |
| * var wrapped = _([1, 2, 3]); |
| * |
| * // returns an unwrapped value |
| * wrapped.reduce(function(sum, num) { |
| * return sum + num; |
| * }); |
| * // => 6 |
| * |
| * // returns a wrapped value |
| * var squares = wrapped.map(function(num) { |
| * return num * num; |
| * }); |
| * |
| * _.isArray(squares); |
| * // => false |
| * |
| * _.isArray(squares.value()); |
| * // => true |
| */ |
| function lodash(value) { |
| // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor |
| return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__')) |
| ? value |
| : new lodashWrapper(value); |
| } |
| // ensure `new lodashWrapper` is an instance of `lodash` |
| lodashWrapper.prototype = lodash.prototype; |
| |
| // wrap `_.mixin` so it works when provided only one argument |
| mixin = (function(fn) { |
| var functions = objects.functions; |
| return function(object, source, options) { |
| if (!source || (!options && !functions(source).length)) { |
| if (options == null) { |
| options = source; |
| } |
| source = object; |
| object = lodash; |
| } |
| return fn(object, source, options); |
| }; |
| }(mixin)); |
| |
| // add functions that return wrapped values when chaining |
| lodash.after = functions.after; |
| lodash.assign = objects.assign; |
| lodash.at = collections.at; |
| lodash.bind = functions.bind; |
| lodash.bindAll = functions.bindAll; |
| lodash.bindKey = functions.bindKey; |
| lodash.chain = chaining.chain; |
| lodash.compact = arrays.compact; |
| lodash.compose = functions.compose; |
| lodash.constant = utilities.constant; |
| lodash.countBy = collections.countBy; |
| lodash.create = objects.create; |
| lodash.createCallback = functions.createCallback; |
| lodash.curry = functions.curry; |
| lodash.debounce = functions.debounce; |
| lodash.defaults = objects.defaults; |
| lodash.defer = functions.defer; |
| lodash.delay = functions.delay; |
| lodash.difference = arrays.difference; |
| lodash.filter = collections.filter; |
| lodash.flatten = arrays.flatten; |
| lodash.forEach = forEach; |
| lodash.forEachRight = collections.forEachRight; |
| lodash.forIn = objects.forIn; |
| lodash.forInRight = objects.forInRight; |
| lodash.forOwn = forOwn; |
| lodash.forOwnRight = objects.forOwnRight; |
| lodash.functions = objects.functions; |
| lodash.groupBy = collections.groupBy; |
| lodash.indexBy = collections.indexBy; |
| lodash.initial = arrays.initial; |
| lodash.intersection = arrays.intersection; |
| lodash.invert = objects.invert; |
| lodash.invoke = collections.invoke; |
| lodash.keys = objects.keys; |
| lodash.map = collections.map; |
| lodash.mapValues = objects.mapValues; |
| lodash.max = collections.max; |
| lodash.memoize = functions.memoize; |
| lodash.merge = objects.merge; |
| lodash.min = collections.min; |
| lodash.omit = objects.omit; |
| lodash.once = functions.once; |
| lodash.pairs = objects.pairs; |
| lodash.partial = functions.partial; |
| lodash.partialRight = functions.partialRight; |
| lodash.pick = objects.pick; |
| lodash.pluck = collections.pluck; |
| lodash.property = utilities.property; |
| lodash.pull = arrays.pull; |
| lodash.range = arrays.range; |
| lodash.reject = collections.reject; |
| lodash.remove = arrays.remove; |
| lodash.rest = arrays.rest; |
| lodash.shuffle = collections.shuffle; |
| lodash.sortBy = collections.sortBy; |
| lodash.tap = chaining.tap; |
| lodash.throttle = functions.throttle; |
| lodash.times = utilities.times; |
| lodash.toArray = collections.toArray; |
| lodash.transform = objects.transform; |
| lodash.union = arrays.union; |
| lodash.uniq = arrays.uniq; |
| lodash.values = objects.values; |
| lodash.where = collections.where; |
| lodash.without = arrays.without; |
| lodash.wrap = functions.wrap; |
| lodash.xor = arrays.xor; |
| lodash.zip = arrays.zip; |
| lodash.zipObject = arrays.zipObject; |
| |
| // add aliases |
| lodash.collect = collections.map; |
| lodash.drop = arrays.rest; |
| lodash.each = forEach; |
| lodash.eachRight = collections.forEachRight; |
| lodash.extend = objects.assign; |
| lodash.methods = objects.functions; |
| lodash.object = arrays.zipObject; |
| lodash.select = collections.filter; |
| lodash.tail = arrays.rest; |
| lodash.unique = arrays.uniq; |
| lodash.unzip = arrays.zip; |
| |
| // add functions to `lodash.prototype` |
| mixin(lodash); |
| |
| // add functions that return unwrapped values when chaining |
| lodash.clone = objects.clone; |
| lodash.cloneDeep = objects.cloneDeep; |
| lodash.contains = collections.contains; |
| lodash.escape = utilities.escape; |
| lodash.every = collections.every; |
| lodash.find = collections.find; |
| lodash.findIndex = arrays.findIndex; |
| lodash.findKey = objects.findKey; |
| lodash.findLast = collections.findLast; |
| lodash.findLastIndex = arrays.findLastIndex; |
| lodash.findLastKey = objects.findLastKey; |
| lodash.has = objects.has; |
| lodash.identity = utilities.identity; |
| lodash.indexOf = arrays.indexOf; |
| lodash.isArguments = objects.isArguments; |
| lodash.isArray = isArray; |
| lodash.isBoolean = objects.isBoolean; |
| lodash.isDate = objects.isDate; |
| lodash.isElement = objects.isElement; |
| lodash.isEmpty = objects.isEmpty; |
| lodash.isEqual = objects.isEqual; |
| lodash.isFinite = objects.isFinite; |
| lodash.isFunction = objects.isFunction; |
| lodash.isNaN = objects.isNaN; |
| lodash.isNull = objects.isNull; |
| lodash.isNumber = objects.isNumber; |
| lodash.isObject = objects.isObject; |
| lodash.isPlainObject = objects.isPlainObject; |
| lodash.isRegExp = objects.isRegExp; |
| lodash.isString = objects.isString; |
| lodash.isUndefined = objects.isUndefined; |
| lodash.lastIndexOf = arrays.lastIndexOf; |
| lodash.mixin = mixin; |
| lodash.noConflict = utilities.noConflict; |
| lodash.noop = utilities.noop; |
| lodash.now = utilities.now; |
| lodash.parseInt = utilities.parseInt; |
| lodash.random = utilities.random; |
| lodash.reduce = collections.reduce; |
| lodash.reduceRight = collections.reduceRight; |
| lodash.result = utilities.result; |
| lodash.size = collections.size; |
| lodash.some = collections.some; |
| lodash.sortedIndex = arrays.sortedIndex; |
| lodash.template = utilities.template; |
| lodash.unescape = utilities.unescape; |
| lodash.uniqueId = utilities.uniqueId; |
| |
| // add aliases |
| lodash.all = collections.every; |
| lodash.any = collections.some; |
| lodash.detect = collections.find; |
| lodash.findWhere = collections.find; |
| lodash.foldl = collections.reduce; |
| lodash.foldr = collections.reduceRight; |
| lodash.include = collections.contains; |
| lodash.inject = collections.reduce; |
| |
| mixin(function() { |
| var source = {} |
| forOwn(lodash, function(func, methodName) { |
| if (!lodash.prototype[methodName]) { |
| source[methodName] = func; |
| } |
| }); |
| return source; |
| }(), false); |
| |
| // add functions capable of returning wrapped and unwrapped values when chaining |
| lodash.first = arrays.first; |
| lodash.last = arrays.last; |
| lodash.sample = collections.sample; |
| |
| // add aliases |
| lodash.take = arrays.first; |
| lodash.head = arrays.first; |
| |
| forOwn(lodash, function(func, methodName) { |
| var callbackable = methodName !== 'sample'; |
| if (!lodash.prototype[methodName]) { |
| lodash.prototype[methodName]= function(n, guard) { |
| var chainAll = this.__chain__, |
| result = func(this.__wrapped__, n, guard); |
| |
| return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function'))) |
| ? result |
| : new lodashWrapper(result, chainAll); |
| }; |
| } |
| }); |
| |
| /** |
| * The semantic version number. |
| * |
| * @static |
| * @memberOf _ |
| * @type string |
| */ |
| lodash.VERSION = '2.4.1'; |
| |
| // add "Chaining" functions to the wrapper |
| lodash.prototype.chain = chaining.wrapperChain; |
| lodash.prototype.toString = chaining.wrapperToString; |
| lodash.prototype.value = chaining.wrapperValueOf; |
| lodash.prototype.valueOf = chaining.wrapperValueOf; |
| |
| // add `Array` functions that return unwrapped values |
| forEach(['join', 'pop', 'shift'], function(methodName) { |
| var func = arrayRef[methodName]; |
| lodash.prototype[methodName] = function() { |
| var chainAll = this.__chain__, |
| result = func.apply(this.__wrapped__, arguments); |
| |
| return chainAll |
| ? new lodashWrapper(result, chainAll) |
| : result; |
| }; |
| }); |
| |
| // add `Array` functions that return the existing wrapped value |
| forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) { |
| var func = arrayRef[methodName]; |
| lodash.prototype[methodName] = function() { |
| func.apply(this.__wrapped__, arguments); |
| return this; |
| }; |
| }); |
| |
| // add `Array` functions that return new wrapped values |
| forEach(['concat', 'slice', 'splice'], function(methodName) { |
| var func = arrayRef[methodName]; |
| lodash.prototype[methodName] = function() { |
| return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__); |
| }; |
| }); |
| |
| lodash.support = support; |
| (lodash.templateSettings = utilities.templateSettings).imports._ = lodash; |
| module.exports = lodash; |
| |
| },{"./arrays":22,"./chaining":45,"./collections":51,"./collections/forEach":59,"./functions":78,"./internals/lodashWrapper":125,"./objects":139,"./objects/forOwn":149,"./objects/isArray":155,"./support":179,"./utilities":180,"./utilities/mixin":184,"./utilities/templateSettings":193}],96:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to pool arrays and objects used internally */ |
| var arrayPool = []; |
| |
| module.exports = arrayPool; |
| |
| },{}],97:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreate = require('./baseCreate'), |
| isObject = require('../objects/isObject'), |
| setBindData = require('./setBindData'), |
| slice = require('./slice'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var push = arrayRef.push; |
| |
| /** |
| * The base implementation of `_.bind` that creates the bound function and |
| * sets its meta data. |
| * |
| * @private |
| * @param {Array} bindData The bind data array. |
| * @returns {Function} Returns the new bound function. |
| */ |
| function baseBind(bindData) { |
| var func = bindData[0], |
| partialArgs = bindData[2], |
| thisArg = bindData[4]; |
| |
| function bound() { |
| // `Function#bind` spec |
| // http://es5.github.io/#x15.3.4.5 |
| if (partialArgs) { |
| // avoid `arguments` object deoptimizations by using `slice` instead |
| // of `Array.prototype.slice.call` and not assigning `arguments` to a |
| // variable as a ternary expression |
| var args = slice(partialArgs); |
| push.apply(args, arguments); |
| } |
| // mimic the constructor's `return` behavior |
| // http://es5.github.io/#x13.2.2 |
| if (this instanceof bound) { |
| // ensure `new bound` is an instance of `func` |
| var thisBinding = baseCreate(func.prototype), |
| result = func.apply(thisBinding, args || arguments); |
| return isObject(result) ? result : thisBinding; |
| } |
| return func.apply(thisArg, args || arguments); |
| } |
| setBindData(bound, bindData); |
| return bound; |
| } |
| |
| module.exports = baseBind; |
| |
| },{"../objects/isObject":166,"./baseCreate":99,"./setBindData":134,"./slice":137}],98:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var assign = require('../objects/assign'), |
| forEach = require('../collections/forEach'), |
| forOwn = require('../objects/forOwn'), |
| getArray = require('./getArray'), |
| isArray = require('../objects/isArray'), |
| isObject = require('../objects/isObject'), |
| releaseArray = require('./releaseArray'), |
| slice = require('./slice'); |
| |
| /** Used to match regexp flags from their coerced string values */ |
| var reFlags = /\w*$/; |
| |
| /** `Object#toString` result shortcuts */ |
| var argsClass = '[object Arguments]', |
| arrayClass = '[object Array]', |
| boolClass = '[object Boolean]', |
| dateClass = '[object Date]', |
| funcClass = '[object Function]', |
| numberClass = '[object Number]', |
| objectClass = '[object Object]', |
| regexpClass = '[object RegExp]', |
| stringClass = '[object String]'; |
| |
| /** Used to identify object classifications that `_.clone` supports */ |
| var cloneableClasses = {}; |
| cloneableClasses[funcClass] = false; |
| cloneableClasses[argsClass] = cloneableClasses[arrayClass] = |
| cloneableClasses[boolClass] = cloneableClasses[dateClass] = |
| cloneableClasses[numberClass] = cloneableClasses[objectClass] = |
| cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** Used to lookup a built-in constructor by [[Class]] */ |
| var ctorByClass = {}; |
| ctorByClass[arrayClass] = Array; |
| ctorByClass[boolClass] = Boolean; |
| ctorByClass[dateClass] = Date; |
| ctorByClass[funcClass] = Function; |
| ctorByClass[objectClass] = Object; |
| ctorByClass[numberClass] = Number; |
| ctorByClass[regexpClass] = RegExp; |
| ctorByClass[stringClass] = String; |
| |
| /** |
| * The base implementation of `_.clone` without argument juggling or support |
| * for `thisArg` binding. |
| * |
| * @private |
| * @param {*} value The value to clone. |
| * @param {boolean} [isDeep=false] Specify a deep clone. |
| * @param {Function} [callback] The function to customize cloning values. |
| * @param {Array} [stackA=[]] Tracks traversed source objects. |
| * @param {Array} [stackB=[]] Associates clones with source counterparts. |
| * @returns {*} Returns the cloned value. |
| */ |
| function baseClone(value, isDeep, callback, stackA, stackB) { |
| if (callback) { |
| var result = callback(value); |
| if (typeof result != 'undefined') { |
| return result; |
| } |
| } |
| // inspect [[Class]] |
| var isObj = isObject(value); |
| if (isObj) { |
| var className = toString.call(value); |
| if (!cloneableClasses[className]) { |
| return value; |
| } |
| var ctor = ctorByClass[className]; |
| switch (className) { |
| case boolClass: |
| case dateClass: |
| return new ctor(+value); |
| |
| case numberClass: |
| case stringClass: |
| return new ctor(value); |
| |
| case regexpClass: |
| result = ctor(value.source, reFlags.exec(value)); |
| result.lastIndex = value.lastIndex; |
| return result; |
| } |
| } else { |
| return value; |
| } |
| var isArr = isArray(value); |
| if (isDeep) { |
| // check for circular references and return corresponding clone |
| var initedStack = !stackA; |
| stackA || (stackA = getArray()); |
| stackB || (stackB = getArray()); |
| |
| var length = stackA.length; |
| while (length--) { |
| if (stackA[length] == value) { |
| return stackB[length]; |
| } |
| } |
| result = isArr ? ctor(value.length) : {}; |
| } |
| else { |
| result = isArr ? slice(value) : assign({}, value); |
| } |
| // add array properties assigned by `RegExp#exec` |
| if (isArr) { |
| if (hasOwnProperty.call(value, 'index')) { |
| result.index = value.index; |
| } |
| if (hasOwnProperty.call(value, 'input')) { |
| result.input = value.input; |
| } |
| } |
| // exit for shallow clone |
| if (!isDeep) { |
| return result; |
| } |
| // add the source value to the stack of traversed objects |
| // and associate it with its clone |
| stackA.push(value); |
| stackB.push(result); |
| |
| // recursively populate clone (susceptible to call stack limits) |
| (isArr ? forEach : forOwn)(value, function(objValue, key) { |
| result[key] = baseClone(objValue, isDeep, callback, stackA, stackB); |
| }); |
| |
| if (initedStack) { |
| releaseArray(stackA); |
| releaseArray(stackB); |
| } |
| return result; |
| } |
| |
| module.exports = baseClone; |
| |
| },{"../collections/forEach":59,"../objects/assign":140,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isObject":166,"./getArray":118,"./releaseArray":132,"./slice":137}],99:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('./isNative'), |
| isObject = require('../objects/isObject'), |
| noop = require('../utilities/noop'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate; |
| |
| /** |
| * The base implementation of `_.create` without support for assigning |
| * properties to the created object. |
| * |
| * @private |
| * @param {Object} prototype The object to inherit from. |
| * @returns {Object} Returns the new object. |
| */ |
| function baseCreate(prototype, properties) { |
| return isObject(prototype) ? nativeCreate(prototype) : {}; |
| } |
| // fallback for browsers without `Object.create` |
| if (!nativeCreate) { |
| baseCreate = (function() { |
| function Object() {} |
| return function(prototype) { |
| if (isObject(prototype)) { |
| Object.prototype = prototype; |
| var result = new Object; |
| Object.prototype = null; |
| } |
| return result || global.Object(); |
| }; |
| }()); |
| } |
| |
| module.exports = baseCreate; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"../objects/isObject":166,"../utilities/noop":186,"./isNative":122}],100:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var bind = require('../functions/bind'), |
| identity = require('../utilities/identity'), |
| setBindData = require('./setBindData'), |
| support = require('../support'); |
| |
| /** Used to detected named functions */ |
| var reFuncName = /^\s*function[ \n\r\t]+\w/; |
| |
| /** Used to detect functions containing a `this` reference */ |
| var reThis = /\bthis\b/; |
| |
| /** Native method shortcuts */ |
| var fnToString = Function.prototype.toString; |
| |
| /** |
| * The base implementation of `_.createCallback` without support for creating |
| * "_.pluck" or "_.where" style callbacks. |
| * |
| * @private |
| * @param {*} [func=identity] The value to convert to a callback. |
| * @param {*} [thisArg] The `this` binding of the created callback. |
| * @param {number} [argCount] The number of arguments the callback accepts. |
| * @returns {Function} Returns a callback function. |
| */ |
| function baseCreateCallback(func, thisArg, argCount) { |
| if (typeof func != 'function') { |
| return identity; |
| } |
| // exit early for no `thisArg` or already bound by `Function#bind` |
| if (typeof thisArg == 'undefined' || !('prototype' in func)) { |
| return func; |
| } |
| var bindData = func.__bindData__; |
| if (typeof bindData == 'undefined') { |
| if (support.funcNames) { |
| bindData = !func.name; |
| } |
| bindData = bindData || !support.funcDecomp; |
| if (!bindData) { |
| var source = fnToString.call(func); |
| if (!support.funcNames) { |
| bindData = !reFuncName.test(source); |
| } |
| if (!bindData) { |
| // checks if `func` references the `this` keyword and stores the result |
| bindData = reThis.test(source); |
| setBindData(func, bindData); |
| } |
| } |
| } |
| // exit early if there are no `this` references or `func` is bound |
| if (bindData === false || (bindData !== true && bindData[1] & 1)) { |
| return func; |
| } |
| switch (argCount) { |
| case 1: return function(value) { |
| return func.call(thisArg, value); |
| }; |
| case 2: return function(a, b) { |
| return func.call(thisArg, a, b); |
| }; |
| case 3: return function(value, index, collection) { |
| return func.call(thisArg, value, index, collection); |
| }; |
| case 4: return function(accumulator, value, index, collection) { |
| return func.call(thisArg, accumulator, value, index, collection); |
| }; |
| } |
| return bind(func, thisArg); |
| } |
| |
| module.exports = baseCreateCallback; |
| |
| },{"../functions/bind":80,"../support":179,"../utilities/identity":183,"./setBindData":134}],101:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreate = require('./baseCreate'), |
| isObject = require('../objects/isObject'), |
| setBindData = require('./setBindData'), |
| slice = require('./slice'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var push = arrayRef.push; |
| |
| /** |
| * The base implementation of `createWrapper` that creates the wrapper and |
| * sets its meta data. |
| * |
| * @private |
| * @param {Array} bindData The bind data array. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseCreateWrapper(bindData) { |
| var func = bindData[0], |
| bitmask = bindData[1], |
| partialArgs = bindData[2], |
| partialRightArgs = bindData[3], |
| thisArg = bindData[4], |
| arity = bindData[5]; |
| |
| var isBind = bitmask & 1, |
| isBindKey = bitmask & 2, |
| isCurry = bitmask & 4, |
| isCurryBound = bitmask & 8, |
| key = func; |
| |
| function bound() { |
| var thisBinding = isBind ? thisArg : this; |
| if (partialArgs) { |
| var args = slice(partialArgs); |
| push.apply(args, arguments); |
| } |
| if (partialRightArgs || isCurry) { |
| args || (args = slice(arguments)); |
| if (partialRightArgs) { |
| push.apply(args, partialRightArgs); |
| } |
| if (isCurry && args.length < arity) { |
| bitmask |= 16 & ~32; |
| return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]); |
| } |
| } |
| args || (args = arguments); |
| if (isBindKey) { |
| func = thisBinding[key]; |
| } |
| if (this instanceof bound) { |
| thisBinding = baseCreate(func.prototype); |
| var result = func.apply(thisBinding, args); |
| return isObject(result) ? result : thisBinding; |
| } |
| return func.apply(thisBinding, args); |
| } |
| setBindData(bound, bindData); |
| return bound; |
| } |
| |
| module.exports = baseCreateWrapper; |
| |
| },{"../objects/isObject":166,"./baseCreate":99,"./setBindData":134,"./slice":137}],102:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('./baseIndexOf'), |
| cacheIndexOf = require('./cacheIndexOf'), |
| createCache = require('./createCache'), |
| largeArraySize = require('./largeArraySize'), |
| releaseObject = require('./releaseObject'); |
| |
| /** |
| * The base implementation of `_.difference` that accepts a single array |
| * of values to exclude. |
| * |
| * @private |
| * @param {Array} array The array to process. |
| * @param {Array} [values] The array of values to exclude. |
| * @returns {Array} Returns a new array of filtered values. |
| */ |
| function baseDifference(array, values) { |
| var index = -1, |
| indexOf = baseIndexOf, |
| length = array ? array.length : 0, |
| isLarge = length >= largeArraySize, |
| result = []; |
| |
| if (isLarge) { |
| var cache = createCache(values); |
| if (cache) { |
| indexOf = cacheIndexOf; |
| values = cache; |
| } else { |
| isLarge = false; |
| } |
| } |
| while (++index < length) { |
| var value = array[index]; |
| if (indexOf(values, value) < 0) { |
| result.push(value); |
| } |
| } |
| if (isLarge) { |
| releaseObject(values); |
| } |
| return result; |
| } |
| |
| module.exports = baseDifference; |
| |
| },{"./baseIndexOf":104,"./cacheIndexOf":109,"./createCache":114,"./largeArraySize":124,"./releaseObject":133}],103:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isArguments = require('../objects/isArguments'), |
| isArray = require('../objects/isArray'); |
| |
| /** |
| * The base implementation of `_.flatten` without support for callback |
| * shorthands or `thisArg` binding. |
| * |
| * @private |
| * @param {Array} array The array to flatten. |
| * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level. |
| * @param {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects. |
| * @param {number} [fromIndex=0] The index to start from. |
| * @returns {Array} Returns a new flattened array. |
| */ |
| function baseFlatten(array, isShallow, isStrict, fromIndex) { |
| var index = (fromIndex || 0) - 1, |
| length = array ? array.length : 0, |
| result = []; |
| |
| while (++index < length) { |
| var value = array[index]; |
| |
| if (value && typeof value == 'object' && typeof value.length == 'number' |
| && (isArray(value) || isArguments(value))) { |
| // recursively flatten arrays (susceptible to call stack limits) |
| if (!isShallow) { |
| value = baseFlatten(value, isShallow, isStrict); |
| } |
| var valIndex = -1, |
| valLength = value.length, |
| resIndex = result.length; |
| |
| result.length += valLength; |
| while (++valIndex < valLength) { |
| result[resIndex++] = value[valIndex]; |
| } |
| } else if (!isStrict) { |
| result.push(value); |
| } |
| } |
| return result; |
| } |
| |
| module.exports = baseFlatten; |
| |
| },{"../objects/isArguments":154,"../objects/isArray":155}],104:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * The base implementation of `_.indexOf` without support for binary searches |
| * or `fromIndex` constraints. |
| * |
| * @private |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {number} [fromIndex=0] The index to search from. |
| * @returns {number} Returns the index of the matched value or `-1`. |
| */ |
| function baseIndexOf(array, value, fromIndex) { |
| var index = (fromIndex || 0) - 1, |
| length = array ? array.length : 0; |
| |
| while (++index < length) { |
| if (array[index] === value) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| |
| module.exports = baseIndexOf; |
| |
| },{}],105:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forIn = require('../objects/forIn'), |
| getArray = require('./getArray'), |
| isFunction = require('../objects/isFunction'), |
| objectTypes = require('./objectTypes'), |
| releaseArray = require('./releaseArray'); |
| |
| /** `Object#toString` result shortcuts */ |
| var argsClass = '[object Arguments]', |
| arrayClass = '[object Array]', |
| boolClass = '[object Boolean]', |
| dateClass = '[object Date]', |
| numberClass = '[object Number]', |
| objectClass = '[object Object]', |
| regexpClass = '[object RegExp]', |
| stringClass = '[object String]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * The base implementation of `_.isEqual`, without support for `thisArg` binding, |
| * that allows partial "_.where" style comparisons. |
| * |
| * @private |
| * @param {*} a The value to compare. |
| * @param {*} b The other value to compare. |
| * @param {Function} [callback] The function to customize comparing values. |
| * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons. |
| * @param {Array} [stackA=[]] Tracks traversed `a` objects. |
| * @param {Array} [stackB=[]] Tracks traversed `b` objects. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| */ |
| function baseIsEqual(a, b, callback, isWhere, stackA, stackB) { |
| // used to indicate that when comparing objects, `a` has at least the properties of `b` |
| if (callback) { |
| var result = callback(a, b); |
| if (typeof result != 'undefined') { |
| return !!result; |
| } |
| } |
| // exit early for identical values |
| if (a === b) { |
| // treat `+0` vs. `-0` as not equal |
| return a !== 0 || (1 / a == 1 / b); |
| } |
| var type = typeof a, |
| otherType = typeof b; |
| |
| // exit early for unlike primitive values |
| if (a === a && |
| !(a && objectTypes[type]) && |
| !(b && objectTypes[otherType])) { |
| return false; |
| } |
| // exit early for `null` and `undefined` avoiding ES3's Function#call behavior |
| // http://es5.github.io/#x15.3.4.4 |
| if (a == null || b == null) { |
| return a === b; |
| } |
| // compare [[Class]] names |
| var className = toString.call(a), |
| otherClass = toString.call(b); |
| |
| if (className == argsClass) { |
| className = objectClass; |
| } |
| if (otherClass == argsClass) { |
| otherClass = objectClass; |
| } |
| if (className != otherClass) { |
| return false; |
| } |
| switch (className) { |
| case boolClass: |
| case dateClass: |
| // coerce dates and booleans to numbers, dates to milliseconds and booleans |
| // to `1` or `0` treating invalid dates coerced to `NaN` as not equal |
| return +a == +b; |
| |
| case numberClass: |
| // treat `NaN` vs. `NaN` as equal |
| return (a != +a) |
| ? b != +b |
| // but treat `+0` vs. `-0` as not equal |
| : (a == 0 ? (1 / a == 1 / b) : a == +b); |
| |
| case regexpClass: |
| case stringClass: |
| // coerce regexes to strings (http://es5.github.io/#x15.10.6.4) |
| // treat string primitives and their corresponding object instances as equal |
| return a == String(b); |
| } |
| var isArr = className == arrayClass; |
| if (!isArr) { |
| // unwrap any `lodash` wrapped values |
| var aWrapped = hasOwnProperty.call(a, '__wrapped__'), |
| bWrapped = hasOwnProperty.call(b, '__wrapped__'); |
| |
| if (aWrapped || bWrapped) { |
| return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB); |
| } |
| // exit for functions and DOM nodes |
| if (className != objectClass) { |
| return false; |
| } |
| // in older versions of Opera, `arguments` objects have `Array` constructors |
| var ctorA = a.constructor, |
| ctorB = b.constructor; |
| |
| // non `Object` object instances with different constructors are not equal |
| if (ctorA != ctorB && |
| !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) && |
| ('constructor' in a && 'constructor' in b) |
| ) { |
| return false; |
| } |
| } |
| // assume cyclic structures are equal |
| // the algorithm for detecting cyclic structures is adapted from ES 5.1 |
| // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3) |
| var initedStack = !stackA; |
| stackA || (stackA = getArray()); |
| stackB || (stackB = getArray()); |
| |
| var length = stackA.length; |
| while (length--) { |
| if (stackA[length] == a) { |
| return stackB[length] == b; |
| } |
| } |
| var size = 0; |
| result = true; |
| |
| // add `a` and `b` to the stack of traversed objects |
| stackA.push(a); |
| stackB.push(b); |
| |
| // recursively compare objects and arrays (susceptible to call stack limits) |
| if (isArr) { |
| // compare lengths to determine if a deep comparison is necessary |
| length = a.length; |
| size = b.length; |
| result = size == length; |
| |
| if (result || isWhere) { |
| // deep compare the contents, ignoring non-numeric properties |
| while (size--) { |
| var index = length, |
| value = b[size]; |
| |
| if (isWhere) { |
| while (index--) { |
| if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) { |
| break; |
| } |
| } |
| } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) { |
| break; |
| } |
| } |
| } |
| } |
| else { |
| // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys` |
| // which, in this case, is more costly |
| forIn(b, function(value, key, b) { |
| if (hasOwnProperty.call(b, key)) { |
| // count the number of properties. |
| size++; |
| // deep compare each property value. |
| return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB)); |
| } |
| }); |
| |
| if (result && !isWhere) { |
| // ensure both objects have the same number of properties |
| forIn(a, function(value, key, a) { |
| if (hasOwnProperty.call(a, key)) { |
| // `size` will be `-1` if `a` has more properties than `b` |
| return (result = --size > -1); |
| } |
| }); |
| } |
| } |
| stackA.pop(); |
| stackB.pop(); |
| |
| if (initedStack) { |
| releaseArray(stackA); |
| releaseArray(stackB); |
| } |
| return result; |
| } |
| |
| module.exports = baseIsEqual; |
| |
| },{"../objects/forIn":147,"../objects/isFunction":162,"./getArray":118,"./objectTypes":128,"./releaseArray":132}],106:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forEach = require('../collections/forEach'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'), |
| isPlainObject = require('../objects/isPlainObject'); |
| |
| /** |
| * The base implementation of `_.merge` without argument juggling or support |
| * for `thisArg` binding. |
| * |
| * @private |
| * @param {Object} object The destination object. |
| * @param {Object} source The source object. |
| * @param {Function} [callback] The function to customize merging properties. |
| * @param {Array} [stackA=[]] Tracks traversed source objects. |
| * @param {Array} [stackB=[]] Associates values with source counterparts. |
| */ |
| function baseMerge(object, source, callback, stackA, stackB) { |
| (isArray(source) ? forEach : forOwn)(source, function(source, key) { |
| var found, |
| isArr, |
| result = source, |
| value = object[key]; |
| |
| if (source && ((isArr = isArray(source)) || isPlainObject(source))) { |
| // avoid merging previously merged cyclic sources |
| var stackLength = stackA.length; |
| while (stackLength--) { |
| if ((found = stackA[stackLength] == source)) { |
| value = stackB[stackLength]; |
| break; |
| } |
| } |
| if (!found) { |
| var isShallow; |
| if (callback) { |
| result = callback(value, source); |
| if ((isShallow = typeof result != 'undefined')) { |
| value = result; |
| } |
| } |
| if (!isShallow) { |
| value = isArr |
| ? (isArray(value) ? value : []) |
| : (isPlainObject(value) ? value : {}); |
| } |
| // add `source` and associated `value` to the stack of traversed objects |
| stackA.push(source); |
| stackB.push(value); |
| |
| // recursively merge objects and arrays (susceptible to call stack limits) |
| if (!isShallow) { |
| baseMerge(value, source, callback, stackA, stackB); |
| } |
| } |
| } |
| else { |
| if (callback) { |
| result = callback(value, source); |
| if (typeof result == 'undefined') { |
| result = source; |
| } |
| } |
| if (typeof result != 'undefined') { |
| value = result; |
| } |
| } |
| object[key] = value; |
| }); |
| } |
| |
| module.exports = baseMerge; |
| |
| },{"../collections/forEach":59,"../objects/forOwn":149,"../objects/isArray":155,"../objects/isPlainObject":167}],107:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Native method shortcuts */ |
| var floor = Math.floor; |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeRandom = Math.random; |
| |
| /** |
| * The base implementation of `_.random` without argument juggling or support |
| * for returning floating-point numbers. |
| * |
| * @private |
| * @param {number} min The minimum possible value. |
| * @param {number} max The maximum possible value. |
| * @returns {number} Returns a random number. |
| */ |
| function baseRandom(min, max) { |
| return min + floor(nativeRandom() * (max - min + 1)); |
| } |
| |
| module.exports = baseRandom; |
| |
| },{}],108:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('./baseIndexOf'), |
| cacheIndexOf = require('./cacheIndexOf'), |
| createCache = require('./createCache'), |
| getArray = require('./getArray'), |
| largeArraySize = require('./largeArraySize'), |
| releaseArray = require('./releaseArray'), |
| releaseObject = require('./releaseObject'); |
| |
| /** |
| * The base implementation of `_.uniq` without support for callback shorthands |
| * or `thisArg` binding. |
| * |
| * @private |
| * @param {Array} array The array to process. |
| * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted. |
| * @param {Function} [callback] The function called per iteration. |
| * @returns {Array} Returns a duplicate-value-free array. |
| */ |
| function baseUniq(array, isSorted, callback) { |
| var index = -1, |
| indexOf = baseIndexOf, |
| length = array ? array.length : 0, |
| result = []; |
| |
| var isLarge = !isSorted && length >= largeArraySize, |
| seen = (callback || isLarge) ? getArray() : result; |
| |
| if (isLarge) { |
| var cache = createCache(seen); |
| indexOf = cacheIndexOf; |
| seen = cache; |
| } |
| while (++index < length) { |
| var value = array[index], |
| computed = callback ? callback(value, index, array) : value; |
| |
| if (isSorted |
| ? !index || seen[seen.length - 1] !== computed |
| : indexOf(seen, computed) < 0 |
| ) { |
| if (callback || isLarge) { |
| seen.push(computed); |
| } |
| result.push(value); |
| } |
| } |
| if (isLarge) { |
| releaseArray(seen.array); |
| releaseObject(seen); |
| } else if (callback) { |
| releaseArray(seen); |
| } |
| return result; |
| } |
| |
| module.exports = baseUniq; |
| |
| },{"./baseIndexOf":104,"./cacheIndexOf":109,"./createCache":114,"./getArray":118,"./largeArraySize":124,"./releaseArray":132,"./releaseObject":133}],109:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseIndexOf = require('./baseIndexOf'), |
| keyPrefix = require('./keyPrefix'); |
| |
| /** |
| * An implementation of `_.contains` for cache objects that mimics the return |
| * signature of `_.indexOf` by returning `0` if the value is found, else `-1`. |
| * |
| * @private |
| * @param {Object} cache The cache object to inspect. |
| * @param {*} value The value to search for. |
| * @returns {number} Returns `0` if `value` is found, else `-1`. |
| */ |
| function cacheIndexOf(cache, value) { |
| var type = typeof value; |
| cache = cache.cache; |
| |
| if (type == 'boolean' || value == null) { |
| return cache[value] ? 0 : -1; |
| } |
| if (type != 'number' && type != 'string') { |
| type = 'object'; |
| } |
| var key = type == 'number' ? value : keyPrefix + value; |
| cache = (cache = cache[type]) && cache[key]; |
| |
| return type == 'object' |
| ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1) |
| : (cache ? 0 : -1); |
| } |
| |
| module.exports = cacheIndexOf; |
| |
| },{"./baseIndexOf":104,"./keyPrefix":123}],110:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keyPrefix = require('./keyPrefix'); |
| |
| /** |
| * Adds a given value to the corresponding cache object. |
| * |
| * @private |
| * @param {*} value The value to add to the cache. |
| */ |
| function cachePush(value) { |
| var cache = this.cache, |
| type = typeof value; |
| |
| if (type == 'boolean' || value == null) { |
| cache[value] = true; |
| } else { |
| if (type != 'number' && type != 'string') { |
| type = 'object'; |
| } |
| var key = type == 'number' ? value : keyPrefix + value, |
| typeCache = cache[type] || (cache[type] = {}); |
| |
| if (type == 'object') { |
| (typeCache[key] || (typeCache[key] = [])).push(value); |
| } else { |
| typeCache[key] = true; |
| } |
| } |
| } |
| |
| module.exports = cachePush; |
| |
| },{"./keyPrefix":123}],111:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Used by `_.max` and `_.min` as the default callback when a given |
| * collection is a string value. |
| * |
| * @private |
| * @param {string} value The character to inspect. |
| * @returns {number} Returns the code unit of given character. |
| */ |
| function charAtCallback(value) { |
| return value.charCodeAt(0); |
| } |
| |
| module.exports = charAtCallback; |
| |
| },{}],112:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Used by `sortBy` to compare transformed `collection` elements, stable sorting |
| * them in ascending order. |
| * |
| * @private |
| * @param {Object} a The object to compare to `b`. |
| * @param {Object} b The object to compare to `a`. |
| * @returns {number} Returns the sort order indicator of `1` or `-1`. |
| */ |
| function compareAscending(a, b) { |
| var ac = a.criteria, |
| bc = b.criteria, |
| index = -1, |
| length = ac.length; |
| |
| while (++index < length) { |
| var value = ac[index], |
| other = bc[index]; |
| |
| if (value !== other) { |
| if (value > other || typeof value == 'undefined') { |
| return 1; |
| } |
| if (value < other || typeof other == 'undefined') { |
| return -1; |
| } |
| } |
| } |
| // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications |
| // that causes it, under certain circumstances, to return the same value for |
| // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247 |
| // |
| // This also ensures a stable sort in V8 and other engines. |
| // See http://code.google.com/p/v8/issues/detail?id=90 |
| return a.index - b.index; |
| } |
| |
| module.exports = compareAscending; |
| |
| },{}],113:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('../objects/forOwn'), |
| isArray = require('../objects/isArray'); |
| |
| /** |
| * Creates a function that aggregates a collection, creating an object composed |
| * of keys generated from the results of running each element of the collection |
| * through a callback. The given `setter` function sets the keys and values |
| * of the composed object. |
| * |
| * @private |
| * @param {Function} setter The setter function. |
| * @returns {Function} Returns the new aggregator function. |
| */ |
| function createAggregator(setter) { |
| return function(collection, callback, thisArg) { |
| var result = {}; |
| callback = createCallback(callback, thisArg, 3); |
| |
| var index = -1, |
| length = collection ? collection.length : 0; |
| |
| if (typeof length == 'number') { |
| while (++index < length) { |
| var value = collection[index]; |
| setter(result, value, callback(value, index, collection), collection); |
| } |
| } else { |
| forOwn(collection, function(value, key, collection) { |
| setter(result, value, callback(value, key, collection), collection); |
| }); |
| } |
| return result; |
| }; |
| } |
| |
| module.exports = createAggregator; |
| |
| },{"../functions/createCallback":84,"../objects/forOwn":149,"../objects/isArray":155}],114:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var cachePush = require('./cachePush'), |
| getObject = require('./getObject'), |
| releaseObject = require('./releaseObject'); |
| |
| /** |
| * Creates a cache object to optimize linear searches of large arrays. |
| * |
| * @private |
| * @param {Array} [array=[]] The array to search. |
| * @returns {null|Object} Returns the cache object or `null` if caching should not be used. |
| */ |
| function createCache(array) { |
| var index = -1, |
| length = array.length, |
| first = array[0], |
| mid = array[(length / 2) | 0], |
| last = array[length - 1]; |
| |
| if (first && typeof first == 'object' && |
| mid && typeof mid == 'object' && last && typeof last == 'object') { |
| return false; |
| } |
| var cache = getObject(); |
| cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false; |
| |
| var result = getObject(); |
| result.array = array; |
| result.cache = cache; |
| result.push = cachePush; |
| |
| while (++index < length) { |
| result.push(array[index]); |
| } |
| return result; |
| } |
| |
| module.exports = createCache; |
| |
| },{"./cachePush":110,"./getObject":119,"./releaseObject":133}],115:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseBind = require('./baseBind'), |
| baseCreateWrapper = require('./baseCreateWrapper'), |
| isFunction = require('../objects/isFunction'), |
| slice = require('./slice'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var push = arrayRef.push, |
| unshift = arrayRef.unshift; |
| |
| /** |
| * Creates a function that, when called, either curries or invokes `func` |
| * with an optional `this` binding and partially applied arguments. |
| * |
| * @private |
| * @param {Function|string} func The function or method name to reference. |
| * @param {number} bitmask The bitmask of method flags to compose. |
| * The bitmask may be composed of the following flags: |
| * 1 - `_.bind` |
| * 2 - `_.bindKey` |
| * 4 - `_.curry` |
| * 8 - `_.curry` (bound) |
| * 16 - `_.partial` |
| * 32 - `_.partialRight` |
| * @param {Array} [partialArgs] An array of arguments to prepend to those |
| * provided to the new function. |
| * @param {Array} [partialRightArgs] An array of arguments to append to those |
| * provided to the new function. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param {number} [arity] The arity of `func`. |
| * @returns {Function} Returns the new function. |
| */ |
| function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) { |
| var isBind = bitmask & 1, |
| isBindKey = bitmask & 2, |
| isCurry = bitmask & 4, |
| isCurryBound = bitmask & 8, |
| isPartial = bitmask & 16, |
| isPartialRight = bitmask & 32; |
| |
| if (!isBindKey && !isFunction(func)) { |
| throw new TypeError; |
| } |
| if (isPartial && !partialArgs.length) { |
| bitmask &= ~16; |
| isPartial = partialArgs = false; |
| } |
| if (isPartialRight && !partialRightArgs.length) { |
| bitmask &= ~32; |
| isPartialRight = partialRightArgs = false; |
| } |
| var bindData = func && func.__bindData__; |
| if (bindData && bindData !== true) { |
| // clone `bindData` |
| bindData = slice(bindData); |
| if (bindData[2]) { |
| bindData[2] = slice(bindData[2]); |
| } |
| if (bindData[3]) { |
| bindData[3] = slice(bindData[3]); |
| } |
| // set `thisBinding` is not previously bound |
| if (isBind && !(bindData[1] & 1)) { |
| bindData[4] = thisArg; |
| } |
| // set if previously bound but not currently (subsequent curried functions) |
| if (!isBind && bindData[1] & 1) { |
| bitmask |= 8; |
| } |
| // set curried arity if not yet set |
| if (isCurry && !(bindData[1] & 4)) { |
| bindData[5] = arity; |
| } |
| // append partial left arguments |
| if (isPartial) { |
| push.apply(bindData[2] || (bindData[2] = []), partialArgs); |
| } |
| // append partial right arguments |
| if (isPartialRight) { |
| unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs); |
| } |
| // merge flags |
| bindData[1] |= bitmask; |
| return createWrapper.apply(null, bindData); |
| } |
| // fast path for `_.bind` |
| var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper; |
| return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]); |
| } |
| |
| module.exports = createWrapper; |
| |
| },{"../objects/isFunction":162,"./baseBind":97,"./baseCreateWrapper":101,"./slice":137}],116:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var htmlEscapes = require('./htmlEscapes'); |
| |
| /** |
| * Used by `escape` to convert characters to HTML entities. |
| * |
| * @private |
| * @param {string} match The matched character to escape. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeHtmlChar(match) { |
| return htmlEscapes[match]; |
| } |
| |
| module.exports = escapeHtmlChar; |
| |
| },{"./htmlEscapes":120}],117:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to escape characters for inclusion in compiled string literals */ |
| var stringEscapes = { |
| '\\': '\\', |
| "'": "'", |
| '\n': 'n', |
| '\r': 'r', |
| '\t': 't', |
| '\u2028': 'u2028', |
| '\u2029': 'u2029' |
| }; |
| |
| /** |
| * Used by `template` to escape characters for inclusion in compiled |
| * string literals. |
| * |
| * @private |
| * @param {string} match The matched character to escape. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeStringChar(match) { |
| return '\\' + stringEscapes[match]; |
| } |
| |
| module.exports = escapeStringChar; |
| |
| },{}],118:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var arrayPool = require('./arrayPool'); |
| |
| /** |
| * Gets an array from the array pool or creates a new one if the pool is empty. |
| * |
| * @private |
| * @returns {Array} The array from the pool. |
| */ |
| function getArray() { |
| return arrayPool.pop() || []; |
| } |
| |
| module.exports = getArray; |
| |
| },{"./arrayPool":96}],119:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var objectPool = require('./objectPool'); |
| |
| /** |
| * Gets an object from the object pool or creates a new one if the pool is empty. |
| * |
| * @private |
| * @returns {Object} The object from the pool. |
| */ |
| function getObject() { |
| return objectPool.pop() || { |
| 'array': null, |
| 'cache': null, |
| 'criteria': null, |
| 'false': false, |
| 'index': 0, |
| 'null': false, |
| 'number': null, |
| 'object': null, |
| 'push': null, |
| 'string': null, |
| 'true': false, |
| 'undefined': false, |
| 'value': null |
| }; |
| } |
| |
| module.exports = getObject; |
| |
| },{"./objectPool":127}],120:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Used to convert characters to HTML entities: |
| * |
| * Though the `>` character is escaped for symmetry, characters like `>` and `/` |
| * don't require escaping in HTML and have no special meaning unless they're part |
| * of a tag or an unquoted attribute value. |
| * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact") |
| */ |
| var htmlEscapes = { |
| '&': '&', |
| '<': '<', |
| '>': '>', |
| '"': '"', |
| "'": ''' |
| }; |
| |
| module.exports = htmlEscapes; |
| |
| },{}],121:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var htmlEscapes = require('./htmlEscapes'), |
| invert = require('../objects/invert'); |
| |
| /** Used to convert HTML entities to characters */ |
| var htmlUnescapes = invert(htmlEscapes); |
| |
| module.exports = htmlUnescapes; |
| |
| },{"../objects/invert":153,"./htmlEscapes":120}],122:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** Used to detect if a method is native */ |
| var reNative = RegExp('^' + |
| String(toString) |
| .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') |
| .replace(/toString| for [^\]]+/g, '.*?') + '$' |
| ); |
| |
| /** |
| * Checks if `value` is a native function. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a native function, else `false`. |
| */ |
| function isNative(value) { |
| return typeof value == 'function' && reNative.test(value); |
| } |
| |
| module.exports = isNative; |
| |
| },{}],123:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */ |
| var keyPrefix = +new Date + ''; |
| |
| module.exports = keyPrefix; |
| |
| },{}],124:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used as the size when optimizations are enabled for large arrays */ |
| var largeArraySize = 75; |
| |
| module.exports = largeArraySize; |
| |
| },{}],125:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * A fast path for creating `lodash` wrapper objects. |
| * |
| * @private |
| * @param {*} value The value to wrap in a `lodash` instance. |
| * @param {boolean} chainAll A flag to enable chaining for all methods |
| * @returns {Object} Returns a `lodash` instance. |
| */ |
| function lodashWrapper(value, chainAll) { |
| this.__chain__ = !!chainAll; |
| this.__wrapped__ = value; |
| } |
| |
| module.exports = lodashWrapper; |
| |
| },{}],126:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used as the max size of the `arrayPool` and `objectPool` */ |
| var maxPoolSize = 40; |
| |
| module.exports = maxPoolSize; |
| |
| },{}],127:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to pool arrays and objects used internally */ |
| var objectPool = []; |
| |
| module.exports = objectPool; |
| |
| },{}],128:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to determine if values are of the language type Object */ |
| var objectTypes = { |
| 'boolean': false, |
| 'function': true, |
| 'object': true, |
| 'number': false, |
| 'string': false, |
| 'undefined': false |
| }; |
| |
| module.exports = objectTypes; |
| |
| },{}],129:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var htmlUnescapes = require('./htmlUnescapes'), |
| keys = require('../objects/keys'); |
| |
| /** Used to match HTML entities and HTML characters */ |
| var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'); |
| |
| module.exports = reEscapedHtml; |
| |
| },{"../objects/keys":171,"./htmlUnescapes":121}],130:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to match "interpolate" template delimiters */ |
| var reInterpolate = /<%=([\s\S]+?)%>/g; |
| |
| module.exports = reInterpolate; |
| |
| },{}],131:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var htmlEscapes = require('./htmlEscapes'), |
| keys = require('../objects/keys'); |
| |
| /** Used to match HTML entities and HTML characters */ |
| var reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g'); |
| |
| module.exports = reUnescapedHtml; |
| |
| },{"../objects/keys":171,"./htmlEscapes":120}],132:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var arrayPool = require('./arrayPool'), |
| maxPoolSize = require('./maxPoolSize'); |
| |
| /** |
| * Releases the given array back to the array pool. |
| * |
| * @private |
| * @param {Array} [array] The array to release. |
| */ |
| function releaseArray(array) { |
| array.length = 0; |
| if (arrayPool.length < maxPoolSize) { |
| arrayPool.push(array); |
| } |
| } |
| |
| module.exports = releaseArray; |
| |
| },{"./arrayPool":96,"./maxPoolSize":126}],133:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var maxPoolSize = require('./maxPoolSize'), |
| objectPool = require('./objectPool'); |
| |
| /** |
| * Releases the given object back to the object pool. |
| * |
| * @private |
| * @param {Object} [object] The object to release. |
| */ |
| function releaseObject(object) { |
| var cache = object.cache; |
| if (cache) { |
| releaseObject(cache); |
| } |
| object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null; |
| if (objectPool.length < maxPoolSize) { |
| objectPool.push(object); |
| } |
| } |
| |
| module.exports = releaseObject; |
| |
| },{"./maxPoolSize":126,"./objectPool":127}],134:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('./isNative'), |
| noop = require('../utilities/noop'); |
| |
| /** Used as the property descriptor for `__bindData__` */ |
| var descriptor = { |
| 'configurable': false, |
| 'enumerable': false, |
| 'value': null, |
| 'writable': false |
| }; |
| |
| /** Used to set meta data on functions */ |
| var defineProperty = (function() { |
| // IE 8 only accepts DOM elements |
| try { |
| var o = {}, |
| func = isNative(func = Object.defineProperty) && func, |
| result = func(o, o, o) && func; |
| } catch(e) { } |
| return result; |
| }()); |
| |
| /** |
| * Sets `this` binding data on a given function. |
| * |
| * @private |
| * @param {Function} func The function to set data on. |
| * @param {Array} value The data array to set. |
| */ |
| var setBindData = !defineProperty ? noop : function(func, value) { |
| descriptor.value = value; |
| defineProperty(func, '__bindData__', descriptor); |
| }; |
| |
| module.exports = setBindData; |
| |
| },{"../utilities/noop":186,"./isNative":122}],135:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forIn = require('../objects/forIn'), |
| isFunction = require('../objects/isFunction'); |
| |
| /** `Object#toString` result shortcuts */ |
| var objectClass = '[object Object]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * A fallback implementation of `isPlainObject` which checks if a given value |
| * is an object created by the `Object` constructor, assuming objects created |
| * by the `Object` constructor have no inherited enumerable properties and that |
| * there are no `Object.prototype` extensions. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. |
| */ |
| function shimIsPlainObject(value) { |
| var ctor, |
| result; |
| |
| // avoid non Object objects, `arguments` objects, and DOM elements |
| if (!(value && toString.call(value) == objectClass) || |
| (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) { |
| return false; |
| } |
| // In most environments an object's own properties are iterated before |
| // its inherited properties. If the last iterated property is an object's |
| // own property then there are no inherited enumerable properties. |
| forIn(value, function(value, key) { |
| result = key; |
| }); |
| return typeof result == 'undefined' || hasOwnProperty.call(value, result); |
| } |
| |
| module.exports = shimIsPlainObject; |
| |
| },{"../objects/forIn":147,"../objects/isFunction":162}],136:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var objectTypes = require('./objectTypes'); |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * A fallback implementation of `Object.keys` which produces an array of the |
| * given object's own enumerable property names. |
| * |
| * @private |
| * @type Function |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns an array of property names. |
| */ |
| var shimKeys = function(object) { |
| var index, iterable = object, result = []; |
| if (!iterable) return result; |
| if (!(objectTypes[typeof object])) return result; |
| for (index in iterable) { |
| if (hasOwnProperty.call(iterable, index)) { |
| result.push(index); |
| } |
| } |
| return result |
| }; |
| |
| module.exports = shimKeys; |
| |
| },{"./objectTypes":128}],137:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Slices the `collection` from the `start` index up to, but not including, |
| * the `end` index. |
| * |
| * Note: This function is used instead of `Array#slice` to support node lists |
| * in IE < 9 and to ensure dense arrays are returned. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to slice. |
| * @param {number} start The start index. |
| * @param {number} end The end index. |
| * @returns {Array} Returns the new array. |
| */ |
| function slice(array, start, end) { |
| start || (start = 0); |
| if (typeof end == 'undefined') { |
| end = array ? array.length : 0; |
| } |
| var index = -1, |
| length = end - start || 0, |
| result = Array(length < 0 ? 0 : length); |
| |
| while (++index < length) { |
| result[index] = array[start + index]; |
| } |
| return result; |
| } |
| |
| module.exports = slice; |
| |
| },{}],138:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var htmlUnescapes = require('./htmlUnescapes'); |
| |
| /** |
| * Used by `unescape` to convert HTML entities to characters. |
| * |
| * @private |
| * @param {string} match The matched character to unescape. |
| * @returns {string} Returns the unescaped character. |
| */ |
| function unescapeHtmlChar(match) { |
| return htmlUnescapes[match]; |
| } |
| |
| module.exports = unescapeHtmlChar; |
| |
| },{"./htmlUnescapes":121}],139:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'assign': require('./objects/assign'), |
| 'clone': require('./objects/clone'), |
| 'cloneDeep': require('./objects/cloneDeep'), |
| 'create': require('./objects/create'), |
| 'defaults': require('./objects/defaults'), |
| 'extend': require('./objects/assign'), |
| 'findKey': require('./objects/findKey'), |
| 'findLastKey': require('./objects/findLastKey'), |
| 'forIn': require('./objects/forIn'), |
| 'forInRight': require('./objects/forInRight'), |
| 'forOwn': require('./objects/forOwn'), |
| 'forOwnRight': require('./objects/forOwnRight'), |
| 'functions': require('./objects/functions'), |
| 'has': require('./objects/has'), |
| 'invert': require('./objects/invert'), |
| 'isArguments': require('./objects/isArguments'), |
| 'isArray': require('./objects/isArray'), |
| 'isBoolean': require('./objects/isBoolean'), |
| 'isDate': require('./objects/isDate'), |
| 'isElement': require('./objects/isElement'), |
| 'isEmpty': require('./objects/isEmpty'), |
| 'isEqual': require('./objects/isEqual'), |
| 'isFinite': require('./objects/isFinite'), |
| 'isFunction': require('./objects/isFunction'), |
| 'isNaN': require('./objects/isNaN'), |
| 'isNull': require('./objects/isNull'), |
| 'isNumber': require('./objects/isNumber'), |
| 'isObject': require('./objects/isObject'), |
| 'isPlainObject': require('./objects/isPlainObject'), |
| 'isRegExp': require('./objects/isRegExp'), |
| 'isString': require('./objects/isString'), |
| 'isUndefined': require('./objects/isUndefined'), |
| 'keys': require('./objects/keys'), |
| 'mapValues': require('./objects/mapValues'), |
| 'merge': require('./objects/merge'), |
| 'methods': require('./objects/functions'), |
| 'omit': require('./objects/omit'), |
| 'pairs': require('./objects/pairs'), |
| 'pick': require('./objects/pick'), |
| 'transform': require('./objects/transform'), |
| 'values': require('./objects/values') |
| }; |
| |
| },{"./objects/assign":140,"./objects/clone":141,"./objects/cloneDeep":142,"./objects/create":143,"./objects/defaults":144,"./objects/findKey":145,"./objects/findLastKey":146,"./objects/forIn":147,"./objects/forInRight":148,"./objects/forOwn":149,"./objects/forOwnRight":150,"./objects/functions":151,"./objects/has":152,"./objects/invert":153,"./objects/isArguments":154,"./objects/isArray":155,"./objects/isBoolean":156,"./objects/isDate":157,"./objects/isElement":158,"./objects/isEmpty":159,"./objects/isEqual":160,"./objects/isFinite":161,"./objects/isFunction":162,"./objects/isNaN":163,"./objects/isNull":164,"./objects/isNumber":165,"./objects/isObject":166,"./objects/isPlainObject":167,"./objects/isRegExp":168,"./objects/isString":169,"./objects/isUndefined":170,"./objects/keys":171,"./objects/mapValues":172,"./objects/merge":173,"./objects/omit":174,"./objects/pairs":175,"./objects/pick":176,"./objects/transform":177,"./objects/values":178}],140:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| keys = require('./keys'), |
| objectTypes = require('../internals/objectTypes'); |
| |
| /** |
| * Assigns own enumerable properties of source object(s) to the destination |
| * object. Subsequent sources will overwrite property assignments of previous |
| * sources. If a callback is provided it will be executed to produce the |
| * assigned values. The callback is bound to `thisArg` and invoked with two |
| * arguments; (objectValue, sourceValue). |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @alias extend |
| * @category Objects |
| * @param {Object} object The destination object. |
| * @param {...Object} [source] The source objects. |
| * @param {Function} [callback] The function to customize assigning values. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns the destination object. |
| * @example |
| * |
| * _.assign({ 'name': 'fred' }, { 'employer': 'slate' }); |
| * // => { 'name': 'fred', 'employer': 'slate' } |
| * |
| * var defaults = _.partialRight(_.assign, function(a, b) { |
| * return typeof a == 'undefined' ? b : a; |
| * }); |
| * |
| * var object = { 'name': 'barney' }; |
| * defaults(object, { 'name': 'fred', 'employer': 'slate' }); |
| * // => { 'name': 'barney', 'employer': 'slate' } |
| */ |
| var assign = function(object, source, guard) { |
| var index, iterable = object, result = iterable; |
| if (!iterable) return result; |
| var args = arguments, |
| argsIndex = 0, |
| argsLength = typeof guard == 'number' ? 2 : args.length; |
| if (argsLength > 3 && typeof args[argsLength - 2] == 'function') { |
| var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2); |
| } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') { |
| callback = args[--argsLength]; |
| } |
| while (++argsIndex < argsLength) { |
| iterable = args[argsIndex]; |
| if (iterable && objectTypes[typeof iterable]) { |
| var ownIndex = -1, |
| ownProps = objectTypes[typeof iterable] && keys(iterable), |
| length = ownProps ? ownProps.length : 0; |
| |
| while (++ownIndex < length) { |
| index = ownProps[ownIndex]; |
| result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]; |
| } |
| } |
| } |
| return result |
| }; |
| |
| module.exports = assign; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/objectTypes":128,"./keys":171}],141:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseClone = require('../internals/baseClone'), |
| baseCreateCallback = require('../internals/baseCreateCallback'); |
| |
| /** |
| * Creates a clone of `value`. If `isDeep` is `true` nested objects will also |
| * be cloned, otherwise they will be assigned by reference. If a callback |
| * is provided it will be executed to produce the cloned values. If the |
| * callback returns `undefined` cloning will be handled by the method instead. |
| * The callback is bound to `thisArg` and invoked with one argument; (value). |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to clone. |
| * @param {boolean} [isDeep=false] Specify a deep clone. |
| * @param {Function} [callback] The function to customize cloning values. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the cloned value. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * var shallow = _.clone(characters); |
| * shallow[0] === characters[0]; |
| * // => true |
| * |
| * var deep = _.clone(characters, true); |
| * deep[0] === characters[0]; |
| * // => false |
| * |
| * _.mixin({ |
| * 'clone': _.partialRight(_.clone, function(value) { |
| * return _.isElement(value) ? value.cloneNode(false) : undefined; |
| * }) |
| * }); |
| * |
| * var clone = _.clone(document.body); |
| * clone.childNodes.length; |
| * // => 0 |
| */ |
| function clone(value, isDeep, callback, thisArg) { |
| // allows working with "Collections" methods without using their `index` |
| // and `collection` arguments for `isDeep` and `callback` |
| if (typeof isDeep != 'boolean' && isDeep != null) { |
| thisArg = callback; |
| callback = isDeep; |
| isDeep = false; |
| } |
| return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); |
| } |
| |
| module.exports = clone; |
| |
| },{"../internals/baseClone":98,"../internals/baseCreateCallback":100}],142:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseClone = require('../internals/baseClone'), |
| baseCreateCallback = require('../internals/baseCreateCallback'); |
| |
| /** |
| * Creates a deep clone of `value`. If a callback is provided it will be |
| * executed to produce the cloned values. If the callback returns `undefined` |
| * cloning will be handled by the method instead. The callback is bound to |
| * `thisArg` and invoked with one argument; (value). |
| * |
| * Note: This method is loosely based on the structured clone algorithm. Functions |
| * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and |
| * objects created by constructors other than `Object` are cloned to plain `Object` objects. |
| * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to deep clone. |
| * @param {Function} [callback] The function to customize cloning values. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the deep cloned value. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'barney', 'age': 36 }, |
| * { 'name': 'fred', 'age': 40 } |
| * ]; |
| * |
| * var deep = _.cloneDeep(characters); |
| * deep[0] === characters[0]; |
| * // => false |
| * |
| * var view = { |
| * 'label': 'docs', |
| * 'node': element |
| * }; |
| * |
| * var clone = _.cloneDeep(view, function(value) { |
| * return _.isElement(value) ? value.cloneNode(true) : undefined; |
| * }); |
| * |
| * clone.node == view.node; |
| * // => false |
| */ |
| function cloneDeep(value, callback, thisArg) { |
| return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); |
| } |
| |
| module.exports = cloneDeep; |
| |
| },{"../internals/baseClone":98,"../internals/baseCreateCallback":100}],143:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var assign = require('./assign'), |
| baseCreate = require('../internals/baseCreate'); |
| |
| /** |
| * Creates an object that inherits from the given `prototype` object. If a |
| * `properties` object is provided its own enumerable properties are assigned |
| * to the created object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} prototype The object to inherit from. |
| * @param {Object} [properties] The properties to assign to the object. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * function Circle() { |
| * Shape.call(this); |
| * } |
| * |
| * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle }); |
| * |
| * var circle = new Circle; |
| * circle instanceof Circle; |
| * // => true |
| * |
| * circle instanceof Shape; |
| * // => true |
| */ |
| function create(prototype, properties) { |
| var result = baseCreate(prototype); |
| return properties ? assign(result, properties) : result; |
| } |
| |
| module.exports = create; |
| |
| },{"../internals/baseCreate":99,"./assign":140}],144:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('./keys'), |
| objectTypes = require('../internals/objectTypes'); |
| |
| /** |
| * Assigns own enumerable properties of source object(s) to the destination |
| * object for all destination properties that resolve to `undefined`. Once a |
| * property is set, additional defaults of the same property will be ignored. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Objects |
| * @param {Object} object The destination object. |
| * @param {...Object} [source] The source objects. |
| * @param- {Object} [guard] Allows working with `_.reduce` without using its |
| * `key` and `object` arguments as sources. |
| * @returns {Object} Returns the destination object. |
| * @example |
| * |
| * var object = { 'name': 'barney' }; |
| * _.defaults(object, { 'name': 'fred', 'employer': 'slate' }); |
| * // => { 'name': 'barney', 'employer': 'slate' } |
| */ |
| var defaults = function(object, source, guard) { |
| var index, iterable = object, result = iterable; |
| if (!iterable) return result; |
| var args = arguments, |
| argsIndex = 0, |
| argsLength = typeof guard == 'number' ? 2 : args.length; |
| while (++argsIndex < argsLength) { |
| iterable = args[argsIndex]; |
| if (iterable && objectTypes[typeof iterable]) { |
| var ownIndex = -1, |
| ownProps = objectTypes[typeof iterable] && keys(iterable), |
| length = ownProps ? ownProps.length : 0; |
| |
| while (++ownIndex < length) { |
| index = ownProps[ownIndex]; |
| if (typeof result[index] == 'undefined') result[index] = iterable[index]; |
| } |
| } |
| } |
| return result |
| }; |
| |
| module.exports = defaults; |
| |
| },{"../internals/objectTypes":128,"./keys":171}],145:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('./forOwn'); |
| |
| /** |
| * This method is like `_.findIndex` except that it returns the key of the |
| * first element that passes the callback check, instead of the element itself. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to search. |
| * @param {Function|Object|string} [callback=identity] The function called per |
| * iteration. If a property name or object is provided it will be used to |
| * create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {string|undefined} Returns the key of the found element, else `undefined`. |
| * @example |
| * |
| * var characters = { |
| * 'barney': { 'age': 36, 'blocked': false }, |
| * 'fred': { 'age': 40, 'blocked': true }, |
| * 'pebbles': { 'age': 1, 'blocked': false } |
| * }; |
| * |
| * _.findKey(characters, function(chr) { |
| * return chr.age < 40; |
| * }); |
| * // => 'barney' (property order is not guaranteed across environments) |
| * |
| * // using "_.where" callback shorthand |
| * _.findKey(characters, { 'age': 1 }); |
| * // => 'pebbles' |
| * |
| * // using "_.pluck" callback shorthand |
| * _.findKey(characters, 'blocked'); |
| * // => 'fred' |
| */ |
| function findKey(object, callback, thisArg) { |
| var result; |
| callback = createCallback(callback, thisArg, 3); |
| forOwn(object, function(value, key, object) { |
| if (callback(value, key, object)) { |
| result = key; |
| return false; |
| } |
| }); |
| return result; |
| } |
| |
| module.exports = findKey; |
| |
| },{"../functions/createCallback":84,"./forOwn":149}],146:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwnRight = require('./forOwnRight'); |
| |
| /** |
| * This method is like `_.findKey` except that it iterates over elements |
| * of a `collection` in the opposite order. |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to search. |
| * @param {Function|Object|string} [callback=identity] The function called per |
| * iteration. If a property name or object is provided it will be used to |
| * create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {string|undefined} Returns the key of the found element, else `undefined`. |
| * @example |
| * |
| * var characters = { |
| * 'barney': { 'age': 36, 'blocked': true }, |
| * 'fred': { 'age': 40, 'blocked': false }, |
| * 'pebbles': { 'age': 1, 'blocked': true } |
| * }; |
| * |
| * _.findLastKey(characters, function(chr) { |
| * return chr.age < 40; |
| * }); |
| * // => returns `pebbles`, assuming `_.findKey` returns `barney` |
| * |
| * // using "_.where" callback shorthand |
| * _.findLastKey(characters, { 'age': 40 }); |
| * // => 'fred' |
| * |
| * // using "_.pluck" callback shorthand |
| * _.findLastKey(characters, 'blocked'); |
| * // => 'pebbles' |
| */ |
| function findLastKey(object, callback, thisArg) { |
| var result; |
| callback = createCallback(callback, thisArg, 3); |
| forOwnRight(object, function(value, key, object) { |
| if (callback(value, key, object)) { |
| result = key; |
| return false; |
| } |
| }); |
| return result; |
| } |
| |
| module.exports = findLastKey; |
| |
| },{"../functions/createCallback":84,"./forOwnRight":150}],147:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| objectTypes = require('../internals/objectTypes'); |
| |
| /** |
| * Iterates over own and inherited enumerable properties of an object, |
| * executing the callback for each property. The callback is bound to `thisArg` |
| * and invoked with three arguments; (value, key, object). Callbacks may exit |
| * iteration early by explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Objects |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * Shape.prototype.move = function(x, y) { |
| * this.x += x; |
| * this.y += y; |
| * }; |
| * |
| * _.forIn(new Shape, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments) |
| */ |
| var forIn = function(collection, callback, thisArg) { |
| var index, iterable = collection, result = iterable; |
| if (!iterable) return result; |
| if (!objectTypes[typeof iterable]) return result; |
| callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3); |
| for (index in iterable) { |
| if (callback(iterable[index], index, collection) === false) return result; |
| } |
| return result |
| }; |
| |
| module.exports = forIn; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/objectTypes":128}],148:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| forIn = require('./forIn'); |
| |
| /** |
| * This method is like `_.forIn` except that it iterates over elements |
| * of a `collection` in the opposite order. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * Shape.prototype.move = function(x, y) { |
| * this.x += x; |
| * this.y += y; |
| * }; |
| * |
| * _.forInRight(new Shape, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move' |
| */ |
| function forInRight(object, callback, thisArg) { |
| var pairs = []; |
| |
| forIn(object, function(value, key) { |
| pairs.push(key, value); |
| }); |
| |
| var length = pairs.length; |
| callback = baseCreateCallback(callback, thisArg, 3); |
| while (length--) { |
| if (callback(pairs[length--], pairs[length], object) === false) { |
| break; |
| } |
| } |
| return object; |
| } |
| |
| module.exports = forInRight; |
| |
| },{"../internals/baseCreateCallback":100,"./forIn":147}],149:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| keys = require('./keys'), |
| objectTypes = require('../internals/objectTypes'); |
| |
| /** |
| * Iterates over own enumerable properties of an object, executing the callback |
| * for each property. The callback is bound to `thisArg` and invoked with three |
| * arguments; (value, key, object). Callbacks may exit iteration early by |
| * explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Objects |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { |
| * console.log(key); |
| * }); |
| * // => logs '0', '1', and 'length' (property order is not guaranteed across environments) |
| */ |
| var forOwn = function(collection, callback, thisArg) { |
| var index, iterable = collection, result = iterable; |
| if (!iterable) return result; |
| if (!objectTypes[typeof iterable]) return result; |
| callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3); |
| var ownIndex = -1, |
| ownProps = objectTypes[typeof iterable] && keys(iterable), |
| length = ownProps ? ownProps.length : 0; |
| |
| while (++ownIndex < length) { |
| index = ownProps[ownIndex]; |
| if (callback(iterable[index], index, collection) === false) return result; |
| } |
| return result |
| }; |
| |
| module.exports = forOwn; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/objectTypes":128,"./keys":171}],150:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| keys = require('./keys'); |
| |
| /** |
| * This method is like `_.forOwn` except that it iterates over elements |
| * of a `collection` in the opposite order. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length' |
| */ |
| function forOwnRight(object, callback, thisArg) { |
| var props = keys(object), |
| length = props.length; |
| |
| callback = baseCreateCallback(callback, thisArg, 3); |
| while (length--) { |
| var key = props[length]; |
| if (callback(object[key], key, object) === false) { |
| break; |
| } |
| } |
| return object; |
| } |
| |
| module.exports = forOwnRight; |
| |
| },{"../internals/baseCreateCallback":100,"./keys":171}],151:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forIn = require('./forIn'), |
| isFunction = require('./isFunction'); |
| |
| /** |
| * Creates a sorted array of property names of all enumerable properties, |
| * own and inherited, of `object` that have function values. |
| * |
| * @static |
| * @memberOf _ |
| * @alias methods |
| * @category Objects |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns an array of property names that have function values. |
| * @example |
| * |
| * _.functions(_); |
| * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] |
| */ |
| function functions(object) { |
| var result = []; |
| forIn(object, function(value, key) { |
| if (isFunction(value)) { |
| result.push(key); |
| } |
| }); |
| return result.sort(); |
| } |
| |
| module.exports = functions; |
| |
| },{"./forIn":147,"./isFunction":162}],152:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Native method shortcuts */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Checks if the specified property name exists as a direct property of `object`, |
| * instead of an inherited property. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to inspect. |
| * @param {string} key The name of the property to check. |
| * @returns {boolean} Returns `true` if key is a direct property, else `false`. |
| * @example |
| * |
| * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); |
| * // => true |
| */ |
| function has(object, key) { |
| return object ? hasOwnProperty.call(object, key) : false; |
| } |
| |
| module.exports = has; |
| |
| },{}],153:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('./keys'); |
| |
| /** |
| * Creates an object composed of the inverted keys and values of the given object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to invert. |
| * @returns {Object} Returns the created inverted object. |
| * @example |
| * |
| * _.invert({ 'first': 'fred', 'second': 'barney' }); |
| * // => { 'fred': 'first', 'barney': 'second' } |
| */ |
| function invert(object) { |
| var index = -1, |
| props = keys(object), |
| length = props.length, |
| result = {}; |
| |
| while (++index < length) { |
| var key = props[index]; |
| result[object[key]] = key; |
| } |
| return result; |
| } |
| |
| module.exports = invert; |
| |
| },{"./keys":171}],154:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var argsClass = '[object Arguments]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is an `arguments` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`. |
| * @example |
| * |
| * (function() { return _.isArguments(arguments); })(1, 2, 3); |
| * // => true |
| * |
| * _.isArguments([1, 2, 3]); |
| * // => false |
| */ |
| function isArguments(value) { |
| return value && typeof value == 'object' && typeof value.length == 'number' && |
| toString.call(value) == argsClass || false; |
| } |
| |
| module.exports = isArguments; |
| |
| },{}],155:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('../internals/isNative'); |
| |
| /** `Object#toString` result shortcuts */ |
| var arrayClass = '[object Array]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray; |
| |
| /** |
| * Checks if `value` is an array. |
| * |
| * @static |
| * @memberOf _ |
| * @type Function |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is an array, else `false`. |
| * @example |
| * |
| * (function() { return _.isArray(arguments); })(); |
| * // => false |
| * |
| * _.isArray([1, 2, 3]); |
| * // => true |
| */ |
| var isArray = nativeIsArray || function(value) { |
| return value && typeof value == 'object' && typeof value.length == 'number' && |
| toString.call(value) == arrayClass || false; |
| }; |
| |
| module.exports = isArray; |
| |
| },{"../internals/isNative":122}],156:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var boolClass = '[object Boolean]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is a boolean value. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`. |
| * @example |
| * |
| * _.isBoolean(null); |
| * // => false |
| */ |
| function isBoolean(value) { |
| return value === true || value === false || |
| value && typeof value == 'object' && toString.call(value) == boolClass || false; |
| } |
| |
| module.exports = isBoolean; |
| |
| },{}],157:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var dateClass = '[object Date]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is a date. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a date, else `false`. |
| * @example |
| * |
| * _.isDate(new Date); |
| * // => true |
| */ |
| function isDate(value) { |
| return value && typeof value == 'object' && toString.call(value) == dateClass || false; |
| } |
| |
| module.exports = isDate; |
| |
| },{}],158:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Checks if `value` is a DOM element. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`. |
| * @example |
| * |
| * _.isElement(document.body); |
| * // => true |
| */ |
| function isElement(value) { |
| return value && value.nodeType === 1 || false; |
| } |
| |
| module.exports = isElement; |
| |
| },{}],159:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forOwn = require('./forOwn'), |
| isFunction = require('./isFunction'); |
| |
| /** `Object#toString` result shortcuts */ |
| var argsClass = '[object Arguments]', |
| arrayClass = '[object Array]', |
| objectClass = '[object Object]', |
| stringClass = '[object String]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a |
| * length of `0` and objects with no own enumerable properties are considered |
| * "empty". |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Array|Object|string} value The value to inspect. |
| * @returns {boolean} Returns `true` if the `value` is empty, else `false`. |
| * @example |
| * |
| * _.isEmpty([1, 2, 3]); |
| * // => false |
| * |
| * _.isEmpty({}); |
| * // => true |
| * |
| * _.isEmpty(''); |
| * // => true |
| */ |
| function isEmpty(value) { |
| var result = true; |
| if (!value) { |
| return result; |
| } |
| var className = toString.call(value), |
| length = value.length; |
| |
| if ((className == arrayClass || className == stringClass || className == argsClass ) || |
| (className == objectClass && typeof length == 'number' && isFunction(value.splice))) { |
| return !length; |
| } |
| forOwn(value, function() { |
| return (result = false); |
| }); |
| return result; |
| } |
| |
| module.exports = isEmpty; |
| |
| },{"./forOwn":149,"./isFunction":162}],160:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| baseIsEqual = require('../internals/baseIsEqual'); |
| |
| /** |
| * Performs a deep comparison between two values to determine if they are |
| * equivalent to each other. If a callback is provided it will be executed |
| * to compare values. If the callback returns `undefined` comparisons will |
| * be handled by the method instead. The callback is bound to `thisArg` and |
| * invoked with two arguments; (a, b). |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} a The value to compare. |
| * @param {*} b The other value to compare. |
| * @param {Function} [callback] The function to customize comparing values. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| * @example |
| * |
| * var object = { 'name': 'fred' }; |
| * var copy = { 'name': 'fred' }; |
| * |
| * object == copy; |
| * // => false |
| * |
| * _.isEqual(object, copy); |
| * // => true |
| * |
| * var words = ['hello', 'goodbye']; |
| * var otherWords = ['hi', 'goodbye']; |
| * |
| * _.isEqual(words, otherWords, function(a, b) { |
| * var reGreet = /^(?:hello|hi)$/i, |
| * aGreet = _.isString(a) && reGreet.test(a), |
| * bGreet = _.isString(b) && reGreet.test(b); |
| * |
| * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined; |
| * }); |
| * // => true |
| */ |
| function isEqual(a, b, callback, thisArg) { |
| return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2)); |
| } |
| |
| module.exports = isEqual; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/baseIsEqual":105}],161:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeIsFinite = global.isFinite, |
| nativeIsNaN = global.isNaN; |
| |
| /** |
| * Checks if `value` is, or can be coerced to, a finite number. |
| * |
| * Note: This is not the same as native `isFinite` which will return true for |
| * booleans and empty strings. See http://es5.github.io/#x15.1.2.5. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is finite, else `false`. |
| * @example |
| * |
| * _.isFinite(-101); |
| * // => true |
| * |
| * _.isFinite('10'); |
| * // => true |
| * |
| * _.isFinite(true); |
| * // => false |
| * |
| * _.isFinite(''); |
| * // => false |
| * |
| * _.isFinite(Infinity); |
| * // => false |
| */ |
| function isFinite(value) { |
| return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value)); |
| } |
| |
| module.exports = isFinite; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],162:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Checks if `value` is a function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a function, else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| */ |
| function isFunction(value) { |
| return typeof value == 'function'; |
| } |
| |
| module.exports = isFunction; |
| |
| },{}],163:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNumber = require('./isNumber'); |
| |
| /** |
| * Checks if `value` is `NaN`. |
| * |
| * Note: This is not the same as native `isNaN` which will return `true` for |
| * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`. |
| * @example |
| * |
| * _.isNaN(NaN); |
| * // => true |
| * |
| * _.isNaN(new Number(NaN)); |
| * // => true |
| * |
| * isNaN(undefined); |
| * // => true |
| * |
| * _.isNaN(undefined); |
| * // => false |
| */ |
| function isNaN(value) { |
| // `NaN` as a primitive is the only value that is not equal to itself |
| // (perform the [[Class]] check first to avoid errors with some host objects in IE) |
| return isNumber(value) && value != +value; |
| } |
| |
| module.exports = isNaN; |
| |
| },{"./isNumber":165}],164:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Checks if `value` is `null`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is `null`, else `false`. |
| * @example |
| * |
| * _.isNull(null); |
| * // => true |
| * |
| * _.isNull(undefined); |
| * // => false |
| */ |
| function isNull(value) { |
| return value === null; |
| } |
| |
| module.exports = isNull; |
| |
| },{}],165:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var numberClass = '[object Number]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is a number. |
| * |
| * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a number, else `false`. |
| * @example |
| * |
| * _.isNumber(8.4 * 5); |
| * // => true |
| */ |
| function isNumber(value) { |
| return typeof value == 'number' || |
| value && typeof value == 'object' && toString.call(value) == numberClass || false; |
| } |
| |
| module.exports = isNumber; |
| |
| },{}],166:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var objectTypes = require('../internals/objectTypes'); |
| |
| /** |
| * Checks if `value` is the language type of Object. |
| * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(1); |
| * // => false |
| */ |
| function isObject(value) { |
| // check if the value is the ECMAScript language type of Object |
| // http://es5.github.io/#x8 |
| // and avoid a V8 bug |
| // http://code.google.com/p/v8/issues/detail?id=2291 |
| return !!(value && objectTypes[typeof value]); |
| } |
| |
| module.exports = isObject; |
| |
| },{"../internals/objectTypes":128}],167:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('../internals/isNative'), |
| shimIsPlainObject = require('../internals/shimIsPlainObject'); |
| |
| /** `Object#toString` result shortcuts */ |
| var objectClass = '[object Object]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** Native method shortcuts */ |
| var getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf; |
| |
| /** |
| * Checks if `value` is an object created by the `Object` constructor. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * _.isPlainObject(new Shape); |
| * // => false |
| * |
| * _.isPlainObject([1, 2, 3]); |
| * // => false |
| * |
| * _.isPlainObject({ 'x': 0, 'y': 0 }); |
| * // => true |
| */ |
| var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) { |
| if (!(value && toString.call(value) == objectClass)) { |
| return false; |
| } |
| var valueOf = value.valueOf, |
| objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto); |
| |
| return objProto |
| ? (value == objProto || getPrototypeOf(value) == objProto) |
| : shimIsPlainObject(value); |
| }; |
| |
| module.exports = isPlainObject; |
| |
| },{"../internals/isNative":122,"../internals/shimIsPlainObject":135}],168:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var regexpClass = '[object RegExp]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is a regular expression. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`. |
| * @example |
| * |
| * _.isRegExp(/fred/); |
| * // => true |
| */ |
| function isRegExp(value) { |
| return value && typeof value == 'object' && toString.call(value) == regexpClass || false; |
| } |
| |
| module.exports = isRegExp; |
| |
| },{}],169:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** `Object#toString` result shortcuts */ |
| var stringClass = '[object String]'; |
| |
| /** Used for native method references */ |
| var objectProto = Object.prototype; |
| |
| /** Used to resolve the internal [[Class]] of values */ |
| var toString = objectProto.toString; |
| |
| /** |
| * Checks if `value` is a string. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is a string, else `false`. |
| * @example |
| * |
| * _.isString('fred'); |
| * // => true |
| */ |
| function isString(value) { |
| return typeof value == 'string' || |
| value && typeof value == 'object' && toString.call(value) == stringClass || false; |
| } |
| |
| module.exports = isString; |
| |
| },{}],170:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Checks if `value` is `undefined`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`. |
| * @example |
| * |
| * _.isUndefined(void 0); |
| * // => true |
| */ |
| function isUndefined(value) { |
| return typeof value == 'undefined'; |
| } |
| |
| module.exports = isUndefined; |
| |
| },{}],171:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('../internals/isNative'), |
| isObject = require('./isObject'), |
| shimKeys = require('../internals/shimKeys'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys; |
| |
| /** |
| * Creates an array composed of the own enumerable property names of an object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns an array of property names. |
| * @example |
| * |
| * _.keys({ 'one': 1, 'two': 2, 'three': 3 }); |
| * // => ['one', 'two', 'three'] (property order is not guaranteed across environments) |
| */ |
| var keys = !nativeKeys ? shimKeys : function(object) { |
| if (!isObject(object)) { |
| return []; |
| } |
| return nativeKeys(object); |
| }; |
| |
| module.exports = keys; |
| |
| },{"../internals/isNative":122,"../internals/shimKeys":136,"./isObject":166}],172:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var createCallback = require('../functions/createCallback'), |
| forOwn = require('./forOwn'); |
| |
| /** |
| * Creates an object with the same keys as `object` and values generated by |
| * running each own enumerable property of `object` through the callback. |
| * The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, key, object). |
| * |
| * If a property name is provided for `callback` the created "_.pluck" style |
| * callback will return the property value of the given element. |
| * |
| * If an object is provided for `callback` the created "_.where" style callback |
| * will return `true` for elements that have the properties of the given object, |
| * else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to iterate over. |
| * @param {Function|Object|string} [callback=identity] The function called |
| * per iteration. If a property name or object is provided it will be used |
| * to create a "_.pluck" or "_.where" style callback, respectively. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns a new object with values of the results of each `callback` execution. |
| * @example |
| * |
| * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; }); |
| * // => { 'a': 3, 'b': 6, 'c': 9 } |
| * |
| * var characters = { |
| * 'fred': { 'name': 'fred', 'age': 40 }, |
| * 'pebbles': { 'name': 'pebbles', 'age': 1 } |
| * }; |
| * |
| * // using "_.pluck" callback shorthand |
| * _.mapValues(characters, 'age'); |
| * // => { 'fred': 40, 'pebbles': 1 } |
| */ |
| function mapValues(object, callback, thisArg) { |
| var result = {}; |
| callback = createCallback(callback, thisArg, 3); |
| |
| forOwn(object, function(value, key, object) { |
| result[key] = callback(value, key, object); |
| }); |
| return result; |
| } |
| |
| module.exports = mapValues; |
| |
| },{"../functions/createCallback":84,"./forOwn":149}],173:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'), |
| baseMerge = require('../internals/baseMerge'), |
| getArray = require('../internals/getArray'), |
| isObject = require('./isObject'), |
| releaseArray = require('../internals/releaseArray'), |
| slice = require('../internals/slice'); |
| |
| /** |
| * Recursively merges own enumerable properties of the source object(s), that |
| * don't resolve to `undefined` into the destination object. Subsequent sources |
| * will overwrite property assignments of previous sources. If a callback is |
| * provided it will be executed to produce the merged values of the destination |
| * and source properties. If the callback returns `undefined` merging will |
| * be handled by the method instead. The callback is bound to `thisArg` and |
| * invoked with two arguments; (objectValue, sourceValue). |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The destination object. |
| * @param {...Object} [source] The source objects. |
| * @param {Function} [callback] The function to customize merging properties. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns the destination object. |
| * @example |
| * |
| * var names = { |
| * 'characters': [ |
| * { 'name': 'barney' }, |
| * { 'name': 'fred' } |
| * ] |
| * }; |
| * |
| * var ages = { |
| * 'characters': [ |
| * { 'age': 36 }, |
| * { 'age': 40 } |
| * ] |
| * }; |
| * |
| * _.merge(names, ages); |
| * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] } |
| * |
| * var food = { |
| * 'fruits': ['apple'], |
| * 'vegetables': ['beet'] |
| * }; |
| * |
| * var otherFood = { |
| * 'fruits': ['banana'], |
| * 'vegetables': ['carrot'] |
| * }; |
| * |
| * _.merge(food, otherFood, function(a, b) { |
| * return _.isArray(a) ? a.concat(b) : undefined; |
| * }); |
| * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] } |
| */ |
| function merge(object) { |
| var args = arguments, |
| length = 2; |
| |
| if (!isObject(object)) { |
| return object; |
| } |
| // allows working with `_.reduce` and `_.reduceRight` without using |
| // their `index` and `collection` arguments |
| if (typeof args[2] != 'number') { |
| length = args.length; |
| } |
| if (length > 3 && typeof args[length - 2] == 'function') { |
| var callback = baseCreateCallback(args[--length - 1], args[length--], 2); |
| } else if (length > 2 && typeof args[length - 1] == 'function') { |
| callback = args[--length]; |
| } |
| var sources = slice(arguments, 1, length), |
| index = -1, |
| stackA = getArray(), |
| stackB = getArray(); |
| |
| while (++index < length) { |
| baseMerge(object, sources[index], callback, stackA, stackB); |
| } |
| releaseArray(stackA); |
| releaseArray(stackB); |
| return object; |
| } |
| |
| module.exports = merge; |
| |
| },{"../internals/baseCreateCallback":100,"../internals/baseMerge":106,"../internals/getArray":118,"../internals/releaseArray":132,"../internals/slice":137,"./isObject":166}],174:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseDifference = require('../internals/baseDifference'), |
| baseFlatten = require('../internals/baseFlatten'), |
| createCallback = require('../functions/createCallback'), |
| forIn = require('./forIn'); |
| |
| /** |
| * Creates a shallow clone of `object` excluding the specified properties. |
| * Property names may be specified as individual arguments or as arrays of |
| * property names. If a callback is provided it will be executed for each |
| * property of `object` omitting the properties the callback returns truey |
| * for. The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, key, object). |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The source object. |
| * @param {Function|...string|string[]} [callback] The properties to omit or the |
| * function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns an object without the omitted properties. |
| * @example |
| * |
| * _.omit({ 'name': 'fred', 'age': 40 }, 'age'); |
| * // => { 'name': 'fred' } |
| * |
| * _.omit({ 'name': 'fred', 'age': 40 }, function(value) { |
| * return typeof value == 'number'; |
| * }); |
| * // => { 'name': 'fred' } |
| */ |
| function omit(object, callback, thisArg) { |
| var result = {}; |
| if (typeof callback != 'function') { |
| var props = []; |
| forIn(object, function(value, key) { |
| props.push(key); |
| }); |
| props = baseDifference(props, baseFlatten(arguments, true, false, 1)); |
| |
| var index = -1, |
| length = props.length; |
| |
| while (++index < length) { |
| var key = props[index]; |
| result[key] = object[key]; |
| } |
| } else { |
| callback = createCallback(callback, thisArg, 3); |
| forIn(object, function(value, key, object) { |
| if (!callback(value, key, object)) { |
| result[key] = value; |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = omit; |
| |
| },{"../functions/createCallback":84,"../internals/baseDifference":102,"../internals/baseFlatten":103,"./forIn":147}],175:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('./keys'); |
| |
| /** |
| * Creates a two dimensional array of an object's key-value pairs, |
| * i.e. `[[key1, value1], [key2, value2]]`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns new array of key-value pairs. |
| * @example |
| * |
| * _.pairs({ 'barney': 36, 'fred': 40 }); |
| * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments) |
| */ |
| function pairs(object) { |
| var index = -1, |
| props = keys(object), |
| length = props.length, |
| result = Array(length); |
| |
| while (++index < length) { |
| var key = props[index]; |
| result[index] = [key, object[key]]; |
| } |
| return result; |
| } |
| |
| module.exports = pairs; |
| |
| },{"./keys":171}],176:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseFlatten = require('../internals/baseFlatten'), |
| createCallback = require('../functions/createCallback'), |
| forIn = require('./forIn'), |
| isObject = require('./isObject'); |
| |
| /** |
| * Creates a shallow clone of `object` composed of the specified properties. |
| * Property names may be specified as individual arguments or as arrays of |
| * property names. If a callback is provided it will be executed for each |
| * property of `object` picking the properties the callback returns truey |
| * for. The callback is bound to `thisArg` and invoked with three arguments; |
| * (value, key, object). |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The source object. |
| * @param {Function|...string|string[]} [callback] The function called per |
| * iteration or property names to pick, specified as individual property |
| * names or arrays of property names. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Object} Returns an object composed of the picked properties. |
| * @example |
| * |
| * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name'); |
| * // => { 'name': 'fred' } |
| * |
| * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) { |
| * return key.charAt(0) != '_'; |
| * }); |
| * // => { 'name': 'fred' } |
| */ |
| function pick(object, callback, thisArg) { |
| var result = {}; |
| if (typeof callback != 'function') { |
| var index = -1, |
| props = baseFlatten(arguments, true, false, 1), |
| length = isObject(object) ? props.length : 0; |
| |
| while (++index < length) { |
| var key = props[index]; |
| if (key in object) { |
| result[key] = object[key]; |
| } |
| } |
| } else { |
| callback = createCallback(callback, thisArg, 3); |
| forIn(object, function(value, key, object) { |
| if (callback(value, key, object)) { |
| result[key] = value; |
| } |
| }); |
| } |
| return result; |
| } |
| |
| module.exports = pick; |
| |
| },{"../functions/createCallback":84,"../internals/baseFlatten":103,"./forIn":147,"./isObject":166}],177:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreate = require('../internals/baseCreate'), |
| createCallback = require('../functions/createCallback'), |
| forEach = require('../collections/forEach'), |
| forOwn = require('./forOwn'), |
| isArray = require('./isArray'); |
| |
| /** |
| * An alternative to `_.reduce` this method transforms `object` to a new |
| * `accumulator` object which is the result of running each of its own |
| * enumerable properties through a callback, with each callback execution |
| * potentially mutating the `accumulator` object. The callback is bound to |
| * `thisArg` and invoked with four arguments; (accumulator, value, key, object). |
| * Callbacks may exit iteration early by explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Array|Object} object The object to iterate over. |
| * @param {Function} [callback=identity] The function called per iteration. |
| * @param {*} [accumulator] The custom accumulator value. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) { |
| * num *= num; |
| * if (num % 2) { |
| * return result.push(num) < 3; |
| * } |
| * }); |
| * // => [1, 9, 25] |
| * |
| * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { |
| * result[key] = num * 3; |
| * }); |
| * // => { 'a': 3, 'b': 6, 'c': 9 } |
| */ |
| function transform(object, callback, accumulator, thisArg) { |
| var isArr = isArray(object); |
| if (accumulator == null) { |
| if (isArr) { |
| accumulator = []; |
| } else { |
| var ctor = object && object.constructor, |
| proto = ctor && ctor.prototype; |
| |
| accumulator = baseCreate(proto); |
| } |
| } |
| if (callback) { |
| callback = createCallback(callback, thisArg, 4); |
| (isArr ? forEach : forOwn)(object, function(value, index, object) { |
| return callback(accumulator, value, index, object); |
| }); |
| } |
| return accumulator; |
| } |
| |
| module.exports = transform; |
| |
| },{"../collections/forEach":59,"../functions/createCallback":84,"../internals/baseCreate":99,"./forOwn":149,"./isArray":155}],178:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('./keys'); |
| |
| /** |
| * Creates an array composed of the own enumerable property values of `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Objects |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns an array of property values. |
| * @example |
| * |
| * _.values({ 'one': 1, 'two': 2, 'three': 3 }); |
| * // => [1, 2, 3] (property order is not guaranteed across environments) |
| */ |
| function values(object) { |
| var index = -1, |
| props = keys(object), |
| length = props.length, |
| result = Array(length); |
| |
| while (++index < length) { |
| result[index] = object[props[index]]; |
| } |
| return result; |
| } |
| |
| module.exports = values; |
| |
| },{"./keys":171}],179:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('./internals/isNative'); |
| |
| /** Used to detect functions containing a `this` reference */ |
| var reThis = /\bthis\b/; |
| |
| /** |
| * An object used to flag environments features. |
| * |
| * @static |
| * @memberOf _ |
| * @type Object |
| */ |
| var support = {}; |
| |
| /** |
| * Detect if functions can be decompiled by `Function#toString` |
| * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps). |
| * |
| * @memberOf _.support |
| * @type boolean |
| */ |
| support.funcDecomp = !isNative(global.WinRTError) && reThis.test(function() { return this; }); |
| |
| /** |
| * Detect if `Function#name` is supported (all but IE). |
| * |
| * @memberOf _.support |
| * @type boolean |
| */ |
| support.funcNames = typeof Function.name == 'string'; |
| |
| module.exports = support; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./internals/isNative":122}],180:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| module.exports = { |
| 'constant': require('./utilities/constant'), |
| 'createCallback': require('./functions/createCallback'), |
| 'escape': require('./utilities/escape'), |
| 'identity': require('./utilities/identity'), |
| 'mixin': require('./utilities/mixin'), |
| 'noConflict': require('./utilities/noConflict'), |
| 'noop': require('./utilities/noop'), |
| 'now': require('./utilities/now'), |
| 'parseInt': require('./utilities/parseInt'), |
| 'property': require('./utilities/property'), |
| 'random': require('./utilities/random'), |
| 'result': require('./utilities/result'), |
| 'template': require('./utilities/template'), |
| 'templateSettings': require('./utilities/templateSettings'), |
| 'times': require('./utilities/times'), |
| 'unescape': require('./utilities/unescape'), |
| 'uniqueId': require('./utilities/uniqueId') |
| }; |
| |
| },{"./functions/createCallback":84,"./utilities/constant":181,"./utilities/escape":182,"./utilities/identity":183,"./utilities/mixin":184,"./utilities/noConflict":185,"./utilities/noop":186,"./utilities/now":187,"./utilities/parseInt":188,"./utilities/property":189,"./utilities/random":190,"./utilities/result":191,"./utilities/template":192,"./utilities/templateSettings":193,"./utilities/times":194,"./utilities/unescape":195,"./utilities/uniqueId":196}],181:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Creates a function that returns `value`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {*} value The value to return from the new function. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var object = { 'name': 'fred' }; |
| * var getter = _.constant(object); |
| * getter() === object; |
| * // => true |
| */ |
| function constant(value) { |
| return function() { |
| return value; |
| }; |
| } |
| |
| module.exports = constant; |
| |
| },{}],182:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var escapeHtmlChar = require('../internals/escapeHtmlChar'), |
| keys = require('../objects/keys'), |
| reUnescapedHtml = require('../internals/reUnescapedHtml'); |
| |
| /** |
| * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their |
| * corresponding HTML entities. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} string The string to escape. |
| * @returns {string} Returns the escaped string. |
| * @example |
| * |
| * _.escape('Fred, Wilma, & Pebbles'); |
| * // => 'Fred, Wilma, & Pebbles' |
| */ |
| function escape(string) { |
| return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar); |
| } |
| |
| module.exports = escape; |
| |
| },{"../internals/escapeHtmlChar":116,"../internals/reUnescapedHtml":131,"../objects/keys":171}],183:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * This method returns the first argument provided to it. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {*} value Any value. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * var object = { 'name': 'fred' }; |
| * _.identity(object) === object; |
| * // => true |
| */ |
| function identity(value) { |
| return value; |
| } |
| |
| module.exports = identity; |
| |
| },{}],184:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var forEach = require('../collections/forEach'), |
| functions = require('../objects/functions'), |
| isFunction = require('../objects/isFunction'), |
| isObject = require('../objects/isObject'); |
| |
| /** |
| * Used for `Array` method references. |
| * |
| * Normally `Array.prototype` would suffice, however, using an array literal |
| * avoids issues in Narwhal. |
| */ |
| var arrayRef = []; |
| |
| /** Native method shortcuts */ |
| var push = arrayRef.push; |
| |
| /** |
| * Adds function properties of a source object to the destination object. |
| * If `object` is a function methods will be added to its prototype as well. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {Function|Object} [object=lodash] object The destination object. |
| * @param {Object} source The object of functions to add. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.chain=true] Specify whether the functions added are chainable. |
| * @example |
| * |
| * function capitalize(string) { |
| * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); |
| * } |
| * |
| * _.mixin({ 'capitalize': capitalize }); |
| * _.capitalize('fred'); |
| * // => 'Fred' |
| * |
| * _('fred').capitalize().value(); |
| * // => 'Fred' |
| * |
| * _.mixin({ 'capitalize': capitalize }, { 'chain': false }); |
| * _('fred').capitalize(); |
| * // => 'Fred' |
| */ |
| function mixin(object, source, options) { |
| var chain = true, |
| methodNames = source && functions(source); |
| |
| if (options === false) { |
| chain = false; |
| } else if (isObject(options) && 'chain' in options) { |
| chain = options.chain; |
| } |
| var ctor = object, |
| isFunc = isFunction(ctor); |
| |
| forEach(methodNames, function(methodName) { |
| var func = object[methodName] = source[methodName]; |
| if (isFunc) { |
| ctor.prototype[methodName] = function() { |
| var chainAll = this.__chain__, |
| value = this.__wrapped__, |
| args = [value]; |
| |
| push.apply(args, arguments); |
| var result = func.apply(object, args); |
| if (chain || chainAll) { |
| if (value === result && isObject(result)) { |
| return this; |
| } |
| result = new ctor(result); |
| result.__chain__ = chainAll; |
| } |
| return result; |
| }; |
| } |
| }); |
| } |
| |
| module.exports = mixin; |
| |
| },{"../collections/forEach":59,"../objects/functions":151,"../objects/isFunction":162,"../objects/isObject":166}],185:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to restore the original `_` reference in `noConflict` */ |
| var oldDash = global._; |
| |
| /** |
| * Reverts the '_' variable to its previous value and returns a reference to |
| * the `lodash` function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @returns {Function} Returns the `lodash` function. |
| * @example |
| * |
| * var lodash = _.noConflict(); |
| */ |
| function noConflict() { |
| global._ = oldDash; |
| return this; |
| } |
| |
| module.exports = noConflict; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],186:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * A no-operation function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @example |
| * |
| * var object = { 'name': 'fred' }; |
| * _.noop(object) === undefined; |
| * // => true |
| */ |
| function noop() { |
| // no operation performed |
| } |
| |
| module.exports = noop; |
| |
| },{}],187:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isNative = require('../internals/isNative'); |
| |
| /** |
| * Gets the number of milliseconds that have elapsed since the Unix epoch |
| * (1 January 1970 00:00:00 UTC). |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @example |
| * |
| * var stamp = _.now(); |
| * _.defer(function() { console.log(_.now() - stamp); }); |
| * // => logs the number of milliseconds it took for the deferred function to be called |
| */ |
| var now = isNative(now = Date.now) && now || function() { |
| return new Date().getTime(); |
| }; |
| |
| module.exports = now; |
| |
| },{"../internals/isNative":122}],188:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isString = require('../objects/isString'); |
| |
| /** Used to detect and test whitespace */ |
| var whitespace = ( |
| // whitespace |
| ' \t\x0B\f\xA0\ufeff' + |
| |
| // line terminators |
| '\n\r\u2028\u2029' + |
| |
| // unicode category "Zs" space separators |
| '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000' |
| ); |
| |
| /** Used to match leading whitespace and zeros to be removed */ |
| var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeParseInt = global.parseInt; |
| |
| /** |
| * Converts the given value into an integer of the specified radix. |
| * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the |
| * `value` is a hexadecimal, in which case a `radix` of `16` is used. |
| * |
| * Note: This method avoids differences in native ES3 and ES5 `parseInt` |
| * implementations. See http://es5.github.io/#E. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} value The value to parse. |
| * @param {number} [radix] The radix used to interpret the value to parse. |
| * @returns {number} Returns the new integer value. |
| * @example |
| * |
| * _.parseInt('08'); |
| * // => 8 |
| */ |
| var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) { |
| // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt` |
| return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0); |
| }; |
| |
| module.exports = parseInt; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"../objects/isString":169}],189:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** |
| * Creates a "_.pluck" style function, which returns the `key` value of a |
| * given object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} key The name of the property to retrieve. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var characters = [ |
| * { 'name': 'fred', 'age': 40 }, |
| * { 'name': 'barney', 'age': 36 } |
| * ]; |
| * |
| * var getName = _.property('name'); |
| * |
| * _.map(characters, getName); |
| * // => ['barney', 'fred'] |
| * |
| * _.sortBy(characters, getName); |
| * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] |
| */ |
| function property(key) { |
| return function(object) { |
| return object[key]; |
| }; |
| } |
| |
| module.exports = property; |
| |
| },{}],190:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseRandom = require('../internals/baseRandom'); |
| |
| /* Native method shortcuts for methods with the same name as other `lodash` methods */ |
| var nativeMin = Math.min, |
| nativeRandom = Math.random; |
| |
| /** |
| * Produces a random number between `min` and `max` (inclusive). If only one |
| * argument is provided a number between `0` and the given number will be |
| * returned. If `floating` is truey or either `min` or `max` are floats a |
| * floating-point number will be returned instead of an integer. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {number} [min=0] The minimum possible value. |
| * @param {number} [max=1] The maximum possible value. |
| * @param {boolean} [floating=false] Specify returning a floating-point number. |
| * @returns {number} Returns a random number. |
| * @example |
| * |
| * _.random(0, 5); |
| * // => an integer between 0 and 5 |
| * |
| * _.random(5); |
| * // => also an integer between 0 and 5 |
| * |
| * _.random(5, true); |
| * // => a floating-point number between 0 and 5 |
| * |
| * _.random(1.2, 5.2); |
| * // => a floating-point number between 1.2 and 5.2 |
| */ |
| function random(min, max, floating) { |
| var noMin = min == null, |
| noMax = max == null; |
| |
| if (floating == null) { |
| if (typeof min == 'boolean' && noMax) { |
| floating = min; |
| min = 1; |
| } |
| else if (!noMax && typeof max == 'boolean') { |
| floating = max; |
| noMax = true; |
| } |
| } |
| if (noMin && noMax) { |
| max = 1; |
| } |
| min = +min || 0; |
| if (noMax) { |
| max = min; |
| min = 0; |
| } else { |
| max = +max || 0; |
| } |
| if (floating || min % 1 || max % 1) { |
| var rand = nativeRandom(); |
| return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max); |
| } |
| return baseRandom(min, max); |
| } |
| |
| module.exports = random; |
| |
| },{"../internals/baseRandom":107}],191:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var isFunction = require('../objects/isFunction'); |
| |
| /** |
| * Resolves the value of property `key` on `object`. If `key` is a function |
| * it will be invoked with the `this` binding of `object` and its result returned, |
| * else the property value is returned. If `object` is falsey then `undefined` |
| * is returned. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {Object} object The object to inspect. |
| * @param {string} key The name of the property to resolve. |
| * @returns {*} Returns the resolved value. |
| * @example |
| * |
| * var object = { |
| * 'cheese': 'crumpets', |
| * 'stuff': function() { |
| * return 'nonsense'; |
| * } |
| * }; |
| * |
| * _.result(object, 'cheese'); |
| * // => 'crumpets' |
| * |
| * _.result(object, 'stuff'); |
| * // => 'nonsense' |
| */ |
| function result(object, key) { |
| if (object) { |
| var value = object[key]; |
| return isFunction(value) ? object[key]() : value; |
| } |
| } |
| |
| module.exports = result; |
| |
| },{"../objects/isFunction":162}],192:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var defaults = require('../objects/defaults'), |
| escape = require('./escape'), |
| escapeStringChar = require('../internals/escapeStringChar'), |
| keys = require('../objects/keys'), |
| reInterpolate = require('../internals/reInterpolate'), |
| templateSettings = require('./templateSettings'), |
| values = require('../objects/values'); |
| |
| /** Used to match empty string literals in compiled template source */ |
| var reEmptyStringLeading = /\b__p \+= '';/g, |
| reEmptyStringMiddle = /\b(__p \+=) '' \+/g, |
| reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; |
| |
| /** |
| * Used to match ES6 template delimiters |
| * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals |
| */ |
| var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; |
| |
| /** Used to ensure capturing order of template delimiters */ |
| var reNoMatch = /($^)/; |
| |
| /** Used to match unescaped characters in compiled string literals */ |
| var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g; |
| |
| /** |
| * A micro-templating method that handles arbitrary delimiters, preserves |
| * whitespace, and correctly escapes quotes within interpolated code. |
| * |
| * Note: In the development build, `_.template` utilizes sourceURLs for easier |
| * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl |
| * |
| * For more information on precompiling templates see: |
| * http://lodash.com/custom-builds |
| * |
| * For more information on Chrome extension sandboxes see: |
| * http://developer.chrome.com/stable/extensions/sandboxingEval.html |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} text The template text. |
| * @param {Object} data The data object used to populate the text. |
| * @param {Object} [options] The options object. |
| * @param {RegExp} [options.escape] The "escape" delimiter. |
| * @param {RegExp} [options.evaluate] The "evaluate" delimiter. |
| * @param {Object} [options.imports] An object to import into the template as local variables. |
| * @param {RegExp} [options.interpolate] The "interpolate" delimiter. |
| * @param {string} [sourceURL] The sourceURL of the template's compiled source. |
| * @param {string} [variable] The data object variable name. |
| * @returns {Function|string} Returns a compiled function when no `data` object |
| * is given, else it returns the interpolated text. |
| * @example |
| * |
| * // using the "interpolate" delimiter to create a compiled template |
| * var compiled = _.template('hello <%= name %>'); |
| * compiled({ 'name': 'fred' }); |
| * // => 'hello fred' |
| * |
| * // using the "escape" delimiter to escape HTML in data property values |
| * _.template('<b><%- value %></b>', { 'value': '<script>' }); |
| * // => '<b><script></b>' |
| * |
| * // using the "evaluate" delimiter to generate HTML |
| * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>'; |
| * _.template(list, { 'people': ['fred', 'barney'] }); |
| * // => '<li>fred</li><li>barney</li>' |
| * |
| * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter |
| * _.template('hello ${ name }', { 'name': 'pebbles' }); |
| * // => 'hello pebbles' |
| * |
| * // using the internal `print` function in "evaluate" delimiters |
| * _.template('<% print("hello " + name); %>!', { 'name': 'barney' }); |
| * // => 'hello barney!' |
| * |
| * // using a custom template delimiters |
| * _.templateSettings = { |
| * 'interpolate': /{{([\s\S]+?)}}/g |
| * }; |
| * |
| * _.template('hello {{ name }}!', { 'name': 'mustache' }); |
| * // => 'hello mustache!' |
| * |
| * // using the `imports` option to import jQuery |
| * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>'; |
| * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } }); |
| * // => '<li>fred</li><li>barney</li>' |
| * |
| * // using the `sourceURL` option to specify a custom sourceURL for the template |
| * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' }); |
| * compiled(data); |
| * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector |
| * |
| * // using the `variable` option to ensure a with-statement isn't used in the compiled template |
| * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' }); |
| * compiled.source; |
| * // => function(data) { |
| * var __t, __p = '', __e = _.escape; |
| * __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!'; |
| * return __p; |
| * } |
| * |
| * // using the `source` property to inline compiled templates for meaningful |
| * // line numbers in error messages and a stack trace |
| * fs.writeFileSync(path.join(cwd, 'jst.js'), '\ |
| * var JST = {\ |
| * "main": ' + _.template(mainText).source + '\ |
| * };\ |
| * '); |
| */ |
| function template(text, data, options) { |
| // based on John Resig's `tmpl` implementation |
| // http://ejohn.org/blog/javascript-micro-templating/ |
| // and Laura Doktorova's doT.js |
| // https://github.com/olado/doT |
| var settings = templateSettings.imports._.templateSettings || templateSettings; |
| text = String(text || ''); |
| |
| // avoid missing dependencies when `iteratorTemplate` is not defined |
| options = defaults({}, options, settings); |
| |
| var imports = defaults({}, options.imports, settings.imports), |
| importsKeys = keys(imports), |
| importsValues = values(imports); |
| |
| var isEvaluating, |
| index = 0, |
| interpolate = options.interpolate || reNoMatch, |
| source = "__p += '"; |
| |
| // compile the regexp to match each delimiter |
| var reDelimiters = RegExp( |
| (options.escape || reNoMatch).source + '|' + |
| interpolate.source + '|' + |
| (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' + |
| (options.evaluate || reNoMatch).source + '|$' |
| , 'g'); |
| |
| text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) { |
| interpolateValue || (interpolateValue = esTemplateValue); |
| |
| // escape characters that cannot be included in string literals |
| source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar); |
| |
| // replace delimiters with snippets |
| if (escapeValue) { |
| source += "' +\n__e(" + escapeValue + ") +\n'"; |
| } |
| if (evaluateValue) { |
| isEvaluating = true; |
| source += "';\n" + evaluateValue + ";\n__p += '"; |
| } |
| if (interpolateValue) { |
| source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'"; |
| } |
| index = offset + match.length; |
| |
| // the JS engine embedded in Adobe products requires returning the `match` |
| // string in order to produce the correct `offset` value |
| return match; |
| }); |
| |
| source += "';\n"; |
| |
| // if `variable` is not specified, wrap a with-statement around the generated |
| // code to add the data object to the top of the scope chain |
| var variable = options.variable, |
| hasVariable = variable; |
| |
| if (!hasVariable) { |
| variable = 'obj'; |
| source = 'with (' + variable + ') {\n' + source + '\n}\n'; |
| } |
| // cleanup code by stripping empty strings |
| source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source) |
| .replace(reEmptyStringMiddle, '$1') |
| .replace(reEmptyStringTrailing, '$1;'); |
| |
| // frame code as the function body |
| source = 'function(' + variable + ') {\n' + |
| (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') + |
| "var __t, __p = '', __e = _.escape" + |
| (isEvaluating |
| ? ', __j = Array.prototype.join;\n' + |
| "function print() { __p += __j.call(arguments, '') }\n" |
| : ';\n' |
| ) + |
| source + |
| 'return __p\n}'; |
| |
| try { |
| var result = Function(importsKeys, 'return ' + source ).apply(undefined, importsValues); |
| } catch(e) { |
| e.source = source; |
| throw e; |
| } |
| if (data) { |
| return result(data); |
| } |
| // provide the compiled function's source by its `toString` method, in |
| // supported environments, or the `source` property as a convenience for |
| // inlining compiled templates during the build process |
| result.source = source; |
| return result; |
| } |
| |
| module.exports = template; |
| |
| },{"../internals/escapeStringChar":117,"../internals/reInterpolate":130,"../objects/defaults":144,"../objects/keys":171,"../objects/values":178,"./escape":182,"./templateSettings":193}],193:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var escape = require('./escape'), |
| reInterpolate = require('../internals/reInterpolate'); |
| |
| /** |
| * By default, the template delimiters used by Lo-Dash are similar to those in |
| * embedded Ruby (ERB). Change the following template settings to use alternative |
| * delimiters. |
| * |
| * @static |
| * @memberOf _ |
| * @type Object |
| */ |
| var templateSettings = { |
| |
| /** |
| * Used to detect `data` property values to be HTML-escaped. |
| * |
| * @memberOf _.templateSettings |
| * @type RegExp |
| */ |
| 'escape': /<%-([\s\S]+?)%>/g, |
| |
| /** |
| * Used to detect code to be evaluated. |
| * |
| * @memberOf _.templateSettings |
| * @type RegExp |
| */ |
| 'evaluate': /<%([\s\S]+?)%>/g, |
| |
| /** |
| * Used to detect `data` property values to inject. |
| * |
| * @memberOf _.templateSettings |
| * @type RegExp |
| */ |
| 'interpolate': reInterpolate, |
| |
| /** |
| * Used to reference the data object in the template text. |
| * |
| * @memberOf _.templateSettings |
| * @type string |
| */ |
| 'variable': '', |
| |
| /** |
| * Used to import variables into the compiled template. |
| * |
| * @memberOf _.templateSettings |
| * @type Object |
| */ |
| 'imports': { |
| |
| /** |
| * A reference to the `lodash` function. |
| * |
| * @memberOf _.templateSettings.imports |
| * @type Function |
| */ |
| '_': { 'escape': escape } |
| } |
| }; |
| |
| module.exports = templateSettings; |
| |
| },{"../internals/reInterpolate":130,"./escape":182}],194:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var baseCreateCallback = require('../internals/baseCreateCallback'); |
| |
| /** |
| * Executes the callback `n` times, returning an array of the results |
| * of each callback execution. The callback is bound to `thisArg` and invoked |
| * with one argument; (index). |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {number} n The number of times to execute the callback. |
| * @param {Function} callback The function called per iteration. |
| * @param {*} [thisArg] The `this` binding of `callback`. |
| * @returns {Array} Returns an array of the results of each `callback` execution. |
| * @example |
| * |
| * var diceRolls = _.times(3, _.partial(_.random, 1, 6)); |
| * // => [3, 6, 4] |
| * |
| * _.times(3, function(n) { mage.castSpell(n); }); |
| * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively |
| * |
| * _.times(3, function(n) { this.cast(n); }, mage); |
| * // => also calls `mage.castSpell(n)` three times |
| */ |
| function times(n, callback, thisArg) { |
| n = (n = +n) > -1 ? n : 0; |
| var index = -1, |
| result = Array(n); |
| |
| callback = baseCreateCallback(callback, thisArg, 1); |
| while (++index < n) { |
| result[index] = callback(index); |
| } |
| return result; |
| } |
| |
| module.exports = times; |
| |
| },{"../internals/baseCreateCallback":100}],195:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| var keys = require('../objects/keys'), |
| reEscapedHtml = require('../internals/reEscapedHtml'), |
| unescapeHtmlChar = require('../internals/unescapeHtmlChar'); |
| |
| /** |
| * The inverse of `_.escape` this method converts the HTML entities |
| * `&`, `<`, `>`, `"`, and `'` in `string` to their |
| * corresponding characters. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} string The string to unescape. |
| * @returns {string} Returns the unescaped string. |
| * @example |
| * |
| * _.unescape('Fred, Barney & Pebbles'); |
| * // => 'Fred, Barney & Pebbles' |
| */ |
| function unescape(string) { |
| return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar); |
| } |
| |
| module.exports = unescape; |
| |
| },{"../internals/reEscapedHtml":129,"../internals/unescapeHtmlChar":138,"../objects/keys":171}],196:[function(require,module,exports){ |
| /** |
| * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> |
| * Build: `lodash modularize modern exports="node" -o ./modern/` |
| * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <http://lodash.com/license> |
| */ |
| |
| /** Used to generate unique IDs */ |
| var idCounter = 0; |
| |
| /** |
| * Generates a unique ID. If `prefix` is provided the ID will be appended to it. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utilities |
| * @param {string} [prefix] The value to prefix the ID with. |
| * @returns {string} Returns the unique ID. |
| * @example |
| * |
| * _.uniqueId('contact_'); |
| * // => 'contact_104' |
| * |
| * _.uniqueId(); |
| * // => '105' |
| */ |
| function uniqueId(prefix) { |
| var id = ++idCounter; |
| return String(prefix == null ? '' : prefix) + id; |
| } |
| |
| module.exports = uniqueId; |
| |
| },{}]},{},[1])(1) |
| }); |