-
-
Save sholtomaud/bafa2344b99fad117451 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var fastn = require('fastn')({ | |
list: require('fastn/listComponent'), | |
text: require('fastn/textComponent'), | |
templater: require('fastn/templaterComponent'), | |
_generic: require('fastn/genericComponent'), | |
leaflet: require('leaflet-component/leafletComponent'), | |
marker: require('leaflet-component/leafletMarkerComponent') | |
}, true); | |
let markerModel = new fastn.Model({ | |
markers : [ | |
{ | |
gis_lat:-35.2834600 , | |
gis_lng: 149.9, | |
title: 'Hello fastn 1' | |
}, | |
{ | |
gis_lat:-35.5 , | |
gis_lng: 144.12, | |
title: 'Hello fastn 2' | |
}, | |
{ | |
gis_lat:-35.1 , | |
gis_lng: 149.125, | |
title: 'Hello fastn 3' | |
}, | |
{ | |
gis_lat:-35.9 , | |
gis_lng: 149.131, | |
title: 'Hello fastn 4' | |
} | |
] | |
}) | |
const app = fastn('div', {class:'map'}, | |
fastn('list:leaflet',{ | |
items: fastn.binding('markers').attach(markerModel), | |
template: function(){ | |
return fastn('base:marker', { | |
gis_lat: fastn.binding('gis_lat'), | |
gis_lng: fastn.binding('gis_lng'), | |
title: fastn.binding('title') | |
}).binding('item') | |
} | |
}) | |
) | |
app.render(); | |
document.body.appendChild(app.element); |
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
setTimeout(function(){ | |
;require=(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 (global){ | |
/*! | |
* The buffer module from node.js, for the browser. | |
* | |
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> | |
* @license MIT | |
*/ | |
/* eslint-disable no-proto */ | |
'use strict' | |
var base64 = require('base64-js') | |
var ieee754 = require('ieee754') | |
var isArray = require('isarray') | |
exports.Buffer = Buffer | |
exports.SlowBuffer = SlowBuffer | |
exports.INSPECT_MAX_BYTES = 50 | |
Buffer.poolSize = 8192 // not used by this implementation | |
var rootParent = {} | |
/** | |
* If `Buffer.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+. | |
* | |
* Due to various browser bugs, sometimes the Object implementation will be used even | |
* when the browser supports typed arrays. | |
* | |
* Note: | |
* | |
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, | |
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. | |
* | |
* - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property | |
* on objects. | |
* | |
* - 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 `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they | |
* get the Object implementation, which is slower but behaves correctly. | |
*/ | |
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined | |
? global.TYPED_ARRAY_SUPPORT | |
: typedArraySupport() | |
function typedArraySupport () { | |
function Bar () {} | |
try { | |
var arr = new Uint8Array(1) | |
arr.foo = function () { return 42 } | |
arr.constructor = Bar | |
return arr.foo() === 42 && // typed array instances can be augmented | |
arr.constructor === Bar && // constructor can be set | |
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` | |
arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` | |
} catch (e) { | |
return false | |
} | |
} | |
function kMaxLength () { | |
return Buffer.TYPED_ARRAY_SUPPORT | |
? 0x7fffffff | |
: 0x3fffffff | |
} | |
/** | |
* 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 (arg) { | |
if (!(this instanceof Buffer)) { | |
// Avoid going through an ArgumentsAdaptorTrampoline in the common case. | |
if (arguments.length > 1) return new Buffer(arg, arguments[1]) | |
return new Buffer(arg) | |
} | |
if (!Buffer.TYPED_ARRAY_SUPPORT) { | |
this.length = 0 | |
this.parent = undefined | |
} | |
// Common case. | |
if (typeof arg === 'number') { | |
return fromNumber(this, arg) | |
} | |
// Slightly less common case. | |
if (typeof arg === 'string') { | |
return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') | |
} | |
// Unusual. | |
return fromObject(this, arg) | |
} | |
function fromNumber (that, length) { | |
that = allocate(that, length < 0 ? 0 : checked(length) | 0) | |
if (!Buffer.TYPED_ARRAY_SUPPORT) { | |
for (var i = 0; i < length; i++) { | |
that[i] = 0 | |
} | |
} | |
return that | |
} | |
function fromString (that, string, encoding) { | |
if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' | |
// Assumption: byteLength() return value is always < kMaxLength. | |
var length = byteLength(string, encoding) | 0 | |
that = allocate(that, length) | |
that.write(string, encoding) | |
return that | |
} | |
function fromObject (that, object) { | |
if (Buffer.isBuffer(object)) return fromBuffer(that, object) | |
if (isArray(object)) return fromArray(that, object) | |
if (object == null) { | |
throw new TypeError('must start with number, buffer, array or string') | |
} | |
if (typeof ArrayBuffer !== 'undefined') { | |
if (object.buffer instanceof ArrayBuffer) { | |
return fromTypedArray(that, object) | |
} | |
if (object instanceof ArrayBuffer) { | |
return fromArrayBuffer(that, object) | |
} | |
} | |
if (object.length) return fromArrayLike(that, object) | |
return fromJsonObject(that, object) | |
} | |
function fromBuffer (that, buffer) { | |
var length = checked(buffer.length) | 0 | |
that = allocate(that, length) | |
buffer.copy(that, 0, 0, length) | |
return that | |
} | |
function fromArray (that, array) { | |
var length = checked(array.length) | 0 | |
that = allocate(that, length) | |
for (var i = 0; i < length; i += 1) { | |
that[i] = array[i] & 255 | |
} | |
return that | |
} | |
// Duplicate of fromArray() to keep fromArray() monomorphic. | |
function fromTypedArray (that, array) { | |
var length = checked(array.length) | 0 | |
that = allocate(that, length) | |
// Truncating the elements is probably not what people expect from typed | |
// arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior | |
// of the old Buffer constructor. | |
for (var i = 0; i < length; i += 1) { | |
that[i] = array[i] & 255 | |
} | |
return that | |
} | |
function fromArrayBuffer (that, array) { | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
// Return an augmented `Uint8Array` instance, for best performance | |
array.byteLength | |
that = Buffer._augment(new Uint8Array(array)) | |
} else { | |
// Fallback: Return an object instance of the Buffer class | |
that = fromTypedArray(that, new Uint8Array(array)) | |
} | |
return that | |
} | |
function fromArrayLike (that, array) { | |
var length = checked(array.length) | 0 | |
that = allocate(that, length) | |
for (var i = 0; i < length; i += 1) { | |
that[i] = array[i] & 255 | |
} | |
return that | |
} | |
// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. | |
// Returns a zero-length buffer for inputs that don't conform to the spec. | |
function fromJsonObject (that, object) { | |
var array | |
var length = 0 | |
if (object.type === 'Buffer' && isArray(object.data)) { | |
array = object.data | |
length = checked(array.length) | 0 | |
} | |
that = allocate(that, length) | |
for (var i = 0; i < length; i += 1) { | |
that[i] = array[i] & 255 | |
} | |
return that | |
} | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
Buffer.prototype.__proto__ = Uint8Array.prototype | |
Buffer.__proto__ = Uint8Array | |
} else { | |
// pre-set for values that may exist in the future | |
Buffer.prototype.length = undefined | |
Buffer.prototype.parent = undefined | |
} | |
function allocate (that, length) { | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
// Return an augmented `Uint8Array` instance, for best performance | |
that = Buffer._augment(new Uint8Array(length)) | |
that.__proto__ = Buffer.prototype | |
} else { | |
// Fallback: Return an object instance of the Buffer class | |
that.length = length | |
that._isBuffer = true | |
} | |
var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 | |
if (fromPool) that.parent = rootParent | |
return that | |
} | |
function checked (length) { | |
// Note: cannot use `length < kMaxLength` here because that fails when | |
// length is NaN (which is otherwise coerced to zero.) | |
if (length >= kMaxLength()) { | |
throw new RangeError('Attempt to allocate Buffer larger than maximum ' + | |
'size: 0x' + kMaxLength().toString(16) + ' bytes') | |
} | |
return length | 0 | |
} | |
function SlowBuffer (subject, encoding) { | |
if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) | |
var buf = new Buffer(subject, encoding) | |
delete buf.parent | |
return buf | |
} | |
Buffer.isBuffer = function isBuffer (b) { | |
return !!(b != null && b._isBuffer) | |
} | |
Buffer.compare = function compare (a, b) { | |
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { | |
throw new TypeError('Arguments must be Buffers') | |
} | |
if (a === b) return 0 | |
var x = a.length | |
var y = b.length | |
var i = 0 | |
var len = Math.min(x, y) | |
while (i < len) { | |
if (a[i] !== b[i]) break | |
++i | |
} | |
if (i !== len) { | |
x = a[i] | |
y = b[i] | |
} | |
if (x < y) return -1 | |
if (y < x) return 1 | |
return 0 | |
} | |
Buffer.isEncoding = function isEncoding (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.concat = function concat (list, length) { | |
if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') | |
if (list.length === 0) { | |
return new Buffer(0) | |
} | |
var i | |
if (length === undefined) { | |
length = 0 | |
for (i = 0; i < list.length; i++) { | |
length += list[i].length | |
} | |
} | |
var buf = new Buffer(length) | |
var pos = 0 | |
for (i = 0; i < list.length; i++) { | |
var item = list[i] | |
item.copy(buf, pos) | |
pos += item.length | |
} | |
return buf | |
} | |
function byteLength (string, encoding) { | |
if (typeof string !== 'string') string = '' + string | |
var len = string.length | |
if (len === 0) return 0 | |
// Use a for loop to avoid recursion | |
var loweredCase = false | |
for (;;) { | |
switch (encoding) { | |
case 'ascii': | |
case 'binary': | |
// Deprecated | |
case 'raw': | |
case 'raws': | |
return len | |
case 'utf8': | |
case 'utf-8': | |
return utf8ToBytes(string).length | |
case 'ucs2': | |
case 'ucs-2': | |
case 'utf16le': | |
case 'utf-16le': | |
return len * 2 | |
case 'hex': | |
return len >>> 1 | |
case 'base64': | |
return base64ToBytes(string).length | |
default: | |
if (loweredCase) return utf8ToBytes(string).length // assume utf8 | |
encoding = ('' + encoding).toLowerCase() | |
loweredCase = true | |
} | |
} | |
} | |
Buffer.byteLength = byteLength | |
function slowToString (encoding, start, end) { | |
var loweredCase = false | |
start = start | 0 | |
end = end === undefined || end === Infinity ? this.length : end | 0 | |
if (!encoding) encoding = 'utf8' | |
if (start < 0) start = 0 | |
if (end > this.length) end = this.length | |
if (end <= start) return '' | |
while (true) { | |
switch (encoding) { | |
case 'hex': | |
return hexSlice(this, start, end) | |
case 'utf8': | |
case 'utf-8': | |
return utf8Slice(this, start, end) | |
case 'ascii': | |
return asciiSlice(this, start, end) | |
case 'binary': | |
return binarySlice(this, start, end) | |
case 'base64': | |
return base64Slice(this, start, end) | |
case 'ucs2': | |
case 'ucs-2': | |
case 'utf16le': | |
case 'utf-16le': | |
return utf16leSlice(this, start, end) | |
default: | |
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | |
encoding = (encoding + '').toLowerCase() | |
loweredCase = true | |
} | |
} | |
} | |
Buffer.prototype.toString = function toString () { | |
var length = this.length | 0 | |
if (length === 0) return '' | |
if (arguments.length === 0) return utf8Slice(this, 0, length) | |
return slowToString.apply(this, arguments) | |
} | |
Buffer.prototype.equals = function equals (b) { | |
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') | |
if (this === b) return true | |
return Buffer.compare(this, b) === 0 | |
} | |
Buffer.prototype.inspect = function inspect () { | |
var str = '' | |
var max = exports.INSPECT_MAX_BYTES | |
if (this.length > 0) { | |
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') | |
if (this.length > max) str += ' ... ' | |
} | |
return '<Buffer ' + str + '>' | |
} | |
Buffer.prototype.compare = function compare (b) { | |
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') | |
if (this === b) return 0 | |
return Buffer.compare(this, b) | |
} | |
Buffer.prototype.indexOf = function indexOf (val, byteOffset) { | |
if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff | |
else if (byteOffset < -0x80000000) byteOffset = -0x80000000 | |
byteOffset >>= 0 | |
if (this.length === 0) return -1 | |
if (byteOffset >= this.length) return -1 | |
// Negative offsets start from the end of the buffer | |
if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) | |
if (typeof val === 'string') { | |
if (val.length === 0) return -1 // special case: looking for empty string always fails | |
return String.prototype.indexOf.call(this, val, byteOffset) | |
} | |
if (Buffer.isBuffer(val)) { | |
return arrayIndexOf(this, val, byteOffset) | |
} | |
if (typeof val === 'number') { | |
if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { | |
return Uint8Array.prototype.indexOf.call(this, val, byteOffset) | |
} | |
return arrayIndexOf(this, [ val ], byteOffset) | |
} | |
function arrayIndexOf (arr, val, byteOffset) { | |
var foundIndex = -1 | |
for (var i = 0; byteOffset + i < arr.length; i++) { | |
if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { | |
if (foundIndex === -1) foundIndex = i | |
if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex | |
} else { | |
foundIndex = -1 | |
} | |
} | |
return -1 | |
} | |
throw new TypeError('val must be string, number or Buffer') | |
} | |
// `get` is deprecated | |
Buffer.prototype.get = function get (offset) { | |
console.log('.get() is deprecated. Access using array indexes instead.') | |
return this.readUInt8(offset) | |
} | |
// `set` is deprecated | |
Buffer.prototype.set = function set (v, offset) { | |
console.log('.set() is deprecated. Access using array indexes instead.') | |
return this.writeUInt8(v, offset) | |
} | |
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 | |
if (strLen % 2 !== 0) throw new Error('Invalid hex string') | |
if (length > strLen / 2) { | |
length = strLen / 2 | |
} | |
for (var i = 0; i < length; i++) { | |
var parsed = parseInt(string.substr(i * 2, 2), 16) | |
if (isNaN(parsed)) throw new Error('Invalid hex string') | |
buf[offset + i] = parsed | |
} | |
return i | |
} | |
function utf8Write (buf, string, offset, length) { | |
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) | |
} | |
function asciiWrite (buf, string, offset, length) { | |
return blitBuffer(asciiToBytes(string), buf, offset, length) | |
} | |
function binaryWrite (buf, string, offset, length) { | |
return asciiWrite(buf, string, offset, length) | |
} | |
function base64Write (buf, string, offset, length) { | |
return blitBuffer(base64ToBytes(string), buf, offset, length) | |
} | |
function ucs2Write (buf, string, offset, length) { | |
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) | |
} | |
Buffer.prototype.write = function write (string, offset, length, encoding) { | |
// Buffer#write(string) | |
if (offset === undefined) { | |
encoding = 'utf8' | |
length = this.length | |
offset = 0 | |
// Buffer#write(string, encoding) | |
} else if (length === undefined && typeof offset === 'string') { | |
encoding = offset | |
length = this.length | |
offset = 0 | |
// Buffer#write(string, offset[, length][, encoding]) | |
} else if (isFinite(offset)) { | |
offset = offset | 0 | |
if (isFinite(length)) { | |
length = length | 0 | |
if (encoding === undefined) encoding = 'utf8' | |
} else { | |
encoding = length | |
length = undefined | |
} | |
// legacy write(string, encoding, offset, length) - remove in v0.13 | |
} else { | |
var swap = encoding | |
encoding = offset | |
offset = length | 0 | |
length = swap | |
} | |
var remaining = this.length - offset | |
if (length === undefined || length > remaining) length = remaining | |
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { | |
throw new RangeError('attempt to write outside buffer bounds') | |
} | |
if (!encoding) encoding = 'utf8' | |
var loweredCase = false | |
for (;;) { | |
switch (encoding) { | |
case 'hex': | |
return hexWrite(this, string, offset, length) | |
case 'utf8': | |
case 'utf-8': | |
return utf8Write(this, string, offset, length) | |
case 'ascii': | |
return asciiWrite(this, string, offset, length) | |
case 'binary': | |
return binaryWrite(this, string, offset, length) | |
case 'base64': | |
// Warning: maxLength not taken into account in base64Write | |
return base64Write(this, string, offset, length) | |
case 'ucs2': | |
case 'ucs-2': | |
case 'utf16le': | |
case 'utf-16le': | |
return ucs2Write(this, string, offset, length) | |
default: | |
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | |
encoding = ('' + encoding).toLowerCase() | |
loweredCase = true | |
} | |
} | |
} | |
Buffer.prototype.toJSON = function toJSON () { | |
return { | |
type: 'Buffer', | |
data: Array.prototype.slice.call(this._arr || this, 0) | |
} | |
} | |
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) { | |
end = Math.min(buf.length, end) | |
var res = [] | |
var i = start | |
while (i < end) { | |
var firstByte = buf[i] | |
var codePoint = null | |
var bytesPerSequence = (firstByte > 0xEF) ? 4 | |
: (firstByte > 0xDF) ? 3 | |
: (firstByte > 0xBF) ? 2 | |
: 1 | |
if (i + bytesPerSequence <= end) { | |
var secondByte, thirdByte, fourthByte, tempCodePoint | |
switch (bytesPerSequence) { | |
case 1: | |
if (firstByte < 0x80) { | |
codePoint = firstByte | |
} | |
break | |
case 2: | |
secondByte = buf[i + 1] | |
if ((secondByte & 0xC0) === 0x80) { | |
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) | |
if (tempCodePoint > 0x7F) { | |
codePoint = tempCodePoint | |
} | |
} | |
break | |
case 3: | |
secondByte = buf[i + 1] | |
thirdByte = buf[i + 2] | |
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { | |
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) | |
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { | |
codePoint = tempCodePoint | |
} | |
} | |
break | |
case 4: | |
secondByte = buf[i + 1] | |
thirdByte = buf[i + 2] | |
fourthByte = buf[i + 3] | |
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { | |
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) | |
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { | |
codePoint = tempCodePoint | |
} | |
} | |
} | |
} | |
if (codePoint === null) { | |
// we did not generate a valid codePoint so insert a | |
// replacement char (U+FFFD) and advance only 1 byte | |
codePoint = 0xFFFD | |
bytesPerSequence = 1 | |
} else if (codePoint > 0xFFFF) { | |
// encode to utf16 (surrogate pair dance) | |
codePoint -= 0x10000 | |
res.push(codePoint >>> 10 & 0x3FF | 0xD800) | |
codePoint = 0xDC00 | codePoint & 0x3FF | |
} | |
res.push(codePoint) | |
i += bytesPerSequence | |
} | |
return decodeCodePointsArray(res) | |
} | |
// Based on http://stackoverflow.com/a/22747272/680742, the browser with | |
// the lowest limit is Chrome, with 0x10000 args. | |
// We go 1 magnitude less, for safety | |
var MAX_ARGUMENTS_LENGTH = 0x1000 | |
function decodeCodePointsArray (codePoints) { | |
var len = codePoints.length | |
if (len <= MAX_ARGUMENTS_LENGTH) { | |
return String.fromCharCode.apply(String, codePoints) // avoid extra slice() | |
} | |
// Decode in chunks to avoid "call stack size exceeded". | |
var res = '' | |
var i = 0 | |
while (i < len) { | |
res += String.fromCharCode.apply( | |
String, | |
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) | |
) | |
} | |
return res | |
} | |
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] & 0x7F) | |
} | |
return ret | |
} | |
function binarySlice (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 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 slice (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 | |
var newBuf | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
newBuf = Buffer._augment(this.subarray(start, end)) | |
} else { | |
var sliceLen = end - start | |
newBuf = new Buffer(sliceLen, undefined) | |
for (var i = 0; i < sliceLen; i++) { | |
newBuf[i] = this[i + start] | |
} | |
} | |
if (newBuf.length) newBuf.parent = this.parent || this | |
return newBuf | |
} | |
/* | |
* Need to make sure that buffer isn't trying to write out of bounds. | |
*/ | |
function checkOffset (offset, ext, length) { | |
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') | |
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') | |
} | |
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) checkOffset(offset, byteLength, this.length) | |
var val = this[offset] | |
var mul = 1 | |
var i = 0 | |
while (++i < byteLength && (mul *= 0x100)) { | |
val += this[offset + i] * mul | |
} | |
return val | |
} | |
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) { | |
checkOffset(offset, byteLength, this.length) | |
} | |
var val = this[offset + --byteLength] | |
var mul = 1 | |
while (byteLength > 0 && (mul *= 0x100)) { | |
val += this[offset + --byteLength] * mul | |
} | |
return val | |
} | |
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 1, this.length) | |
return this[offset] | |
} | |
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 2, this.length) | |
return this[offset] | (this[offset + 1] << 8) | |
} | |
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 2, this.length) | |
return (this[offset] << 8) | this[offset + 1] | |
} | |
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return ((this[offset]) | | |
(this[offset + 1] << 8) | | |
(this[offset + 2] << 16)) + | |
(this[offset + 3] * 0x1000000) | |
} | |
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return (this[offset] * 0x1000000) + | |
((this[offset + 1] << 16) | | |
(this[offset + 2] << 8) | | |
this[offset + 3]) | |
} | |
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) checkOffset(offset, byteLength, this.length) | |
var val = this[offset] | |
var mul = 1 | |
var i = 0 | |
while (++i < byteLength && (mul *= 0x100)) { | |
val += this[offset + i] * mul | |
} | |
mul *= 0x80 | |
if (val >= mul) val -= Math.pow(2, 8 * byteLength) | |
return val | |
} | |
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) checkOffset(offset, byteLength, this.length) | |
var i = byteLength | |
var mul = 1 | |
var val = this[offset + --i] | |
while (i > 0 && (mul *= 0x100)) { | |
val += this[offset + --i] * mul | |
} | |
mul *= 0x80 | |
if (val >= mul) val -= Math.pow(2, 8 * byteLength) | |
return val | |
} | |
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 1, this.length) | |
if (!(this[offset] & 0x80)) return (this[offset]) | |
return ((0xff - this[offset] + 1) * -1) | |
} | |
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 2, this.length) | |
var val = this[offset] | (this[offset + 1] << 8) | |
return (val & 0x8000) ? val | 0xFFFF0000 : val | |
} | |
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 2, this.length) | |
var val = this[offset + 1] | (this[offset] << 8) | |
return (val & 0x8000) ? val | 0xFFFF0000 : val | |
} | |
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return (this[offset]) | | |
(this[offset + 1] << 8) | | |
(this[offset + 2] << 16) | | |
(this[offset + 3] << 24) | |
} | |
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return (this[offset] << 24) | | |
(this[offset + 1] << 16) | | |
(this[offset + 2] << 8) | | |
(this[offset + 3]) | |
} | |
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return ieee754.read(this, offset, true, 23, 4) | |
} | |
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 4, this.length) | |
return ieee754.read(this, offset, false, 23, 4) | |
} | |
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 8, this.length) | |
return ieee754.read(this, offset, true, 52, 8) | |
} | |
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { | |
if (!noAssert) checkOffset(offset, 8, this.length) | |
return ieee754.read(this, offset, false, 52, 8) | |
} | |
function checkInt (buf, value, offset, ext, max, min) { | |
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') | |
if (value > max || value < min) throw new RangeError('value is out of bounds') | |
if (offset + ext > buf.length) throw new RangeError('index out of range') | |
} | |
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { | |
value = +value | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) | |
var mul = 1 | |
var i = 0 | |
this[offset] = value & 0xFF | |
while (++i < byteLength && (mul *= 0x100)) { | |
this[offset + i] = (value / mul) & 0xFF | |
} | |
return offset + byteLength | |
} | |
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { | |
value = +value | |
offset = offset | 0 | |
byteLength = byteLength | 0 | |
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) | |
var i = byteLength - 1 | |
var mul = 1 | |
this[offset + i] = value & 0xFF | |
while (--i >= 0 && (mul *= 0x100)) { | |
this[offset + i] = (value / mul) & 0xFF | |
} | |
return offset + byteLength | |
} | |
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) | |
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) | |
this[offset] = (value & 0xff) | |
return offset + 1 | |
} | |
function objectWriteUInt16 (buf, value, offset, littleEndian) { | |
if (value < 0) value = 0xffff + value + 1 | |
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { | |
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> | |
(littleEndian ? i : 1 - i) * 8 | |
} | |
} | |
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value & 0xff) | |
this[offset + 1] = (value >>> 8) | |
} else { | |
objectWriteUInt16(this, value, offset, true) | |
} | |
return offset + 2 | |
} | |
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value >>> 8) | |
this[offset + 1] = (value & 0xff) | |
} else { | |
objectWriteUInt16(this, value, offset, false) | |
} | |
return offset + 2 | |
} | |
function objectWriteUInt32 (buf, value, offset, littleEndian) { | |
if (value < 0) value = 0xffffffff + value + 1 | |
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { | |
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff | |
} | |
} | |
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset + 3] = (value >>> 24) | |
this[offset + 2] = (value >>> 16) | |
this[offset + 1] = (value >>> 8) | |
this[offset] = (value & 0xff) | |
} else { | |
objectWriteUInt32(this, value, offset, true) | |
} | |
return offset + 4 | |
} | |
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value >>> 24) | |
this[offset + 1] = (value >>> 16) | |
this[offset + 2] = (value >>> 8) | |
this[offset + 3] = (value & 0xff) | |
} else { | |
objectWriteUInt32(this, value, offset, false) | |
} | |
return offset + 4 | |
} | |
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) { | |
var limit = Math.pow(2, 8 * byteLength - 1) | |
checkInt(this, value, offset, byteLength, limit - 1, -limit) | |
} | |
var i = 0 | |
var mul = 1 | |
var sub = value < 0 ? 1 : 0 | |
this[offset] = value & 0xFF | |
while (++i < byteLength && (mul *= 0x100)) { | |
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | |
} | |
return offset + byteLength | |
} | |
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) { | |
var limit = Math.pow(2, 8 * byteLength - 1) | |
checkInt(this, value, offset, byteLength, limit - 1, -limit) | |
} | |
var i = byteLength - 1 | |
var mul = 1 | |
var sub = value < 0 ? 1 : 0 | |
this[offset + i] = value & 0xFF | |
while (--i >= 0 && (mul *= 0x100)) { | |
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | |
} | |
return offset + byteLength | |
} | |
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) | |
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) | |
if (value < 0) value = 0xff + value + 1 | |
this[offset] = (value & 0xff) | |
return offset + 1 | |
} | |
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value & 0xff) | |
this[offset + 1] = (value >>> 8) | |
} else { | |
objectWriteUInt16(this, value, offset, true) | |
} | |
return offset + 2 | |
} | |
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value >>> 8) | |
this[offset + 1] = (value & 0xff) | |
} else { | |
objectWriteUInt16(this, value, offset, false) | |
} | |
return offset + 2 | |
} | |
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value & 0xff) | |
this[offset + 1] = (value >>> 8) | |
this[offset + 2] = (value >>> 16) | |
this[offset + 3] = (value >>> 24) | |
} else { | |
objectWriteUInt32(this, value, offset, true) | |
} | |
return offset + 4 | |
} | |
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { | |
value = +value | |
offset = offset | 0 | |
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | |
if (value < 0) value = 0xffffffff + value + 1 | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = (value >>> 24) | |
this[offset + 1] = (value >>> 16) | |
this[offset + 2] = (value >>> 8) | |
this[offset + 3] = (value & 0xff) | |
} else { | |
objectWriteUInt32(this, value, offset, false) | |
} | |
return offset + 4 | |
} | |
function checkIEEE754 (buf, value, offset, ext, max, min) { | |
if (value > max || value < min) throw new RangeError('value is out of bounds') | |
if (offset + ext > buf.length) throw new RangeError('index out of range') | |
if (offset < 0) throw new RangeError('index out of range') | |
} | |
function writeFloat (buf, value, offset, littleEndian, noAssert) { | |
if (!noAssert) { | |
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) | |
} | |
ieee754.write(buf, value, offset, littleEndian, 23, 4) | |
return offset + 4 | |
} | |
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { | |
return writeFloat(this, value, offset, true, noAssert) | |
} | |
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { | |
return writeFloat(this, value, offset, false, noAssert) | |
} | |
function writeDouble (buf, value, offset, littleEndian, noAssert) { | |
if (!noAssert) { | |
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) | |
} | |
ieee754.write(buf, value, offset, littleEndian, 52, 8) | |
return offset + 8 | |
} | |
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { | |
return writeDouble(this, value, offset, true, noAssert) | |
} | |
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { | |
return writeDouble(this, value, offset, false, noAssert) | |
} | |
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) | |
Buffer.prototype.copy = function copy (target, targetStart, start, end) { | |
if (!start) start = 0 | |
if (!end && end !== 0) end = this.length | |
if (targetStart >= target.length) targetStart = target.length | |
if (!targetStart) targetStart = 0 | |
if (end > 0 && end < start) end = start | |
// Copy 0 bytes; we're done | |
if (end === start) return 0 | |
if (target.length === 0 || this.length === 0) return 0 | |
// Fatal error conditions | |
if (targetStart < 0) { | |
throw new RangeError('targetStart out of bounds') | |
} | |
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') | |
if (end < 0) throw new RangeError('sourceEnd out of bounds') | |
// Are we oob? | |
if (end > this.length) end = this.length | |
if (target.length - targetStart < end - start) { | |
end = target.length - targetStart + start | |
} | |
var len = end - start | |
var i | |
if (this === target && start < targetStart && targetStart < end) { | |
// descending copy from end | |
for (i = len - 1; i >= 0; i--) { | |
target[i + targetStart] = this[i + start] | |
} | |
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { | |
// ascending copy from start | |
for (i = 0; i < len; i++) { | |
target[i + targetStart] = this[i + start] | |
} | |
} else { | |
target._set(this.subarray(start, start + len), targetStart) | |
} | |
return len | |
} | |
// fill(value, start=0, end=buffer.length) | |
Buffer.prototype.fill = function fill (value, start, end) { | |
if (!value) value = 0 | |
if (!start) start = 0 | |
if (!end) end = this.length | |
if (end < start) throw new RangeError('end < start') | |
// Fill 0 bytes; we're done | |
if (end === start) return | |
if (this.length === 0) return | |
if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') | |
if (end < 0 || end > this.length) throw new RangeError('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 | |
} | |
/** | |
* 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 toArrayBuffer () { | |
if (typeof Uint8Array !== 'undefined') { | |
if (Buffer.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 TypeError('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 _augment (arr) { | |
arr.constructor = Buffer | |
arr._isBuffer = true | |
// save reference to original Uint8Array set method before overwriting | |
arr._set = arr.set | |
// deprecated | |
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.indexOf = BP.indexOf | |
arr.copy = BP.copy | |
arr.slice = BP.slice | |
arr.readUIntLE = BP.readUIntLE | |
arr.readUIntBE = BP.readUIntBE | |
arr.readUInt8 = BP.readUInt8 | |
arr.readUInt16LE = BP.readUInt16LE | |
arr.readUInt16BE = BP.readUInt16BE | |
arr.readUInt32LE = BP.readUInt32LE | |
arr.readUInt32BE = BP.readUInt32BE | |
arr.readIntLE = BP.readIntLE | |
arr.readIntBE = BP.readIntBE | |
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.writeUIntLE = BP.writeUIntLE | |
arr.writeUIntBE = BP.writeUIntBE | |
arr.writeUInt16LE = BP.writeUInt16LE | |
arr.writeUInt16BE = BP.writeUInt16BE | |
arr.writeUInt32LE = BP.writeUInt32LE | |
arr.writeUInt32BE = BP.writeUInt32BE | |
arr.writeIntLE = BP.writeIntLE | |
arr.writeIntBE = BP.writeIntBE | |
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-Za-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 converts strings with length < 2 to '' | |
if (str.length < 2) return '' | |
// 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 toHex (n) { | |
if (n < 16) return '0' + n.toString(16) | |
return n.toString(16) | |
} | |
function utf8ToBytes (string, units) { | |
units = units || Infinity | |
var codePoint | |
var length = string.length | |
var leadSurrogate = null | |
var bytes = [] | |
for (var i = 0; i < length; i++) { | |
codePoint = string.charCodeAt(i) | |
// is surrogate component | |
if (codePoint > 0xD7FF && codePoint < 0xE000) { | |
// last char was a lead | |
if (!leadSurrogate) { | |
// no lead yet | |
if (codePoint > 0xDBFF) { | |
// unexpected trail | |
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
continue | |
} else if (i + 1 === length) { | |
// unpaired lead | |
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
continue | |
} | |
// valid lead | |
leadSurrogate = codePoint | |
continue | |
} | |
// 2 leads in a row | |
if (codePoint < 0xDC00) { | |
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
leadSurrogate = codePoint | |
continue | |
} | |
// valid surrogate pair | |
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 | |
} else if (leadSurrogate) { | |
// valid bmp char, but last char was a lead | |
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
} | |
leadSurrogate = null | |
// encode utf8 | |
if (codePoint < 0x80) { | |
if ((units -= 1) < 0) break | |
bytes.push(codePoint) | |
} else if (codePoint < 0x800) { | |
if ((units -= 2) < 0) break | |
bytes.push( | |
codePoint >> 0x6 | 0xC0, | |
codePoint & 0x3F | 0x80 | |
) | |
} else if (codePoint < 0x10000) { | |
if ((units -= 3) < 0) break | |
bytes.push( | |
codePoint >> 0xC | 0xE0, | |
codePoint >> 0x6 & 0x3F | 0x80, | |
codePoint & 0x3F | 0x80 | |
) | |
} else if (codePoint < 0x110000) { | |
if ((units -= 4) < 0) break | |
bytes.push( | |
codePoint >> 0x12 | 0xF0, | |
codePoint >> 0xC & 0x3F | 0x80, | |
codePoint >> 0x6 & 0x3F | 0x80, | |
codePoint & 0x3F | 0x80 | |
) | |
} else { | |
throw new Error('Invalid code point') | |
} | |
} | |
return bytes | |
} | |
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, units) { | |
var c, hi, lo | |
var byteArray = [] | |
for (var i = 0; i < str.length; i++) { | |
if ((units -= 2) < 0) break | |
c = str.charCodeAt(i) | |
hi = c >> 8 | |
lo = c % 256 | |
byteArray.push(lo) | |
byteArray.push(hi) | |
} | |
return byteArray | |
} | |
function base64ToBytes (str) { | |
return base64.toByteArray(base64clean(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 | |
} | |
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/index.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192 // not used by this implementation\n\nvar rootParent = {}\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property\n *     on objects.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\nfunction typedArraySupport () {\n  function Bar () {}\n  try {\n    var arr = new Uint8Array(1)\n    arr.foo = function () { return 42 }\n    arr.constructor = Bar\n    return arr.foo() === 42 && // typed array instances can be augmented\n        arr.constructor === Bar && // constructor can be set\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (arg) {\n  if (!(this instanceof Buffer)) {\n    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.\n    if (arguments.length > 1) return new Buffer(arg, arguments[1])\n    return new Buffer(arg)\n  }\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    this.length = 0\n    this.parent = undefined\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    return fromNumber(this, arg)\n  }\n\n  // Slightly less common case.\n  if (typeof arg === 'string') {\n    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')\n  }\n\n  // Unusual.\n  return fromObject(this, arg)\n}\n\nfunction fromNumber (that, length) {\n  that = allocate(that, length < 0 ? 0 : checked(length) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < length; i++) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'\n\n  // Assumption: byteLength() return value is always < kMaxLength.\n  var length = byteLength(string, encoding) | 0\n  that = allocate(that, length)\n\n  that.write(string, encoding)\n  return that\n}\n\nfunction fromObject (that, object) {\n  if (Buffer.isBuffer(object)) return fromBuffer(that, object)\n\n  if (isArray(object)) return fromArray(that, object)\n\n  if (object == null) {\n    throw new TypeError('must start with number, buffer, array or string')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined') {\n    if (object.buffer instanceof ArrayBuffer) {\n      return fromTypedArray(that, object)\n    }\n    if (object instanceof ArrayBuffer) {\n      return fromArrayBuffer(that, object)\n    }\n  }\n\n  if (object.length) return fromArrayLike(that, object)\n\n  return fromJsonObject(that, object)\n}\n\nfunction fromBuffer (that, buffer) {\n  var length = checked(buffer.length) | 0\n  that = allocate(that, length)\n  buffer.copy(that, 0, 0, length)\n  return that\n}\n\nfunction fromArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Duplicate of fromArray() to keep fromArray() monomorphic.\nfunction fromTypedArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  // Truncating the elements is probably not what people expect from typed\n  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior\n  // of the old Buffer constructor.\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    array.byteLength\n    that = Buffer._augment(new Uint8Array(array))\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromTypedArray(that, new Uint8Array(array))\n  }\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.\n// Returns a zero-length buffer for inputs that don't conform to the spec.\nfunction fromJsonObject (that, object) {\n  var array\n  var length = 0\n\n  if (object.type === 'Buffer' && isArray(object.data)) {\n    array = object.data\n    length = checked(array.length) | 0\n  }\n  that = allocate(that, length)\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n} else {\n  // pre-set for values that may exist in the future\n  Buffer.prototype.length = undefined\n  Buffer.prototype.parent = undefined\n}\n\nfunction allocate (that, length) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = Buffer._augment(new Uint8Array(length))\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that.length = length\n    that._isBuffer = true\n  }\n\n  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1\n  if (fromPool) that.parent = rootParent\n\n  return that\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (subject, encoding) {\n  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)\n\n  var buf = new Buffer(subject, encoding)\n  delete buf.parent\n  return buf\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  var i = 0\n  var len = Math.min(x, y)\n  while (i < len) {\n    if (a[i] !== b[i]) break\n\n    ++i\n  }\n\n  if (i !== len) {\n    x = a[i]\n    y = b[i]\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; i++) {\n      length += list[i].length\n    }\n  }\n\n  var buf = new Buffer(length)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\nfunction byteLength (string, encoding) {\n  if (typeof string !== 'string') string = '' + string\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'binary':\n      // Deprecated\n      case 'raw':\n      case 'raws':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  start = start | 0\n  end = end === undefined || end === Infinity ? this.length : end | 0\n\n  if (!encoding) encoding = 'utf8'\n  if (start < 0) start = 0\n  if (end > this.length) end = this.length\n  if (end <= start) return ''\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'binary':\n        return binarySlice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return 0\n  return Buffer.compare(this, b)\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset) {\n  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff\n  else if (byteOffset < -0x80000000) byteOffset = -0x80000000\n  byteOffset >>= 0\n\n  if (this.length === 0) return -1\n  if (byteOffset >= this.length) return -1\n\n  // Negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)\n\n  if (typeof val === 'string') {\n    if (val.length === 0) return -1 // special case: looking for empty string always fails\n    return String.prototype.indexOf.call(this, val, byteOffset)\n  }\n  if (Buffer.isBuffer(val)) {\n    return arrayIndexOf(this, val, byteOffset)\n  }\n  if (typeof val === 'number') {\n    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {\n      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)\n    }\n    return arrayIndexOf(this, [ val ], byteOffset)\n  }\n\n  function arrayIndexOf (arr, val, byteOffset) {\n    var foundIndex = -1\n    for (var i = 0; byteOffset + i < arr.length; i++) {\n      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex\n      } else {\n        foundIndex = -1\n      }\n    }\n    return -1\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\n// `get` is deprecated\nBuffer.prototype.get = function get (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` is deprecated\nBuffer.prototype.set = function set (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new Error('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) throw new Error('Invalid hex string')\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction binaryWrite (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    var swap = encoding\n    encoding = offset\n    offset = length | 0\n    length = swap\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'binary':\n        return binaryWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction binarySlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  if (newBuf.length) newBuf.parent = this.parent || this\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n  if (offset < 0) throw new RangeError('index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; i--) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; i++) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    target._set(this.subarray(start, start + len), targetStart)\n  }\n\n  return len\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function fill (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (end < start) throw new RangeError('end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')\n  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')\n\n  var i\n  if (typeof value === 'number') {\n    for (i = start; i < end; i++) {\n      this[i] = value\n    }\n  } else {\n    var bytes = utf8ToBytes(value.toString())\n    var len = bytes.length\n    for (i = start; i < end; i++) {\n      this[i] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function toArrayBuffer () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1) {\n        buf[i] = this[i]\n      }\n      return buf.buffer\n    }\n  } else {\n    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function _augment (arr) {\n  arr.constructor = Buffer\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array set method before overwriting\n  arr._set = arr.set\n\n  // deprecated\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.equals = BP.equals\n  arr.compare = BP.compare\n  arr.indexOf = BP.indexOf\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUIntLE = BP.readUIntLE\n  arr.readUIntBE = BP.readUIntBE\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readIntLE = BP.readIntLE\n  arr.readIntBE = BP.readIntBE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUIntLE = BP.writeUIntLE\n  arr.writeUIntBE = BP.writeUIntBE\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeIntLE = BP.writeIntLE\n  arr.writeIntBE = BP.writeIntBE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; i++) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n"]} | |
},{"base64-js":2,"ieee754":3,"isarray":4}],2:[function(require,module,exports){ | |
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; | |
;(function (exports) { | |
'use strict'; | |
var Arr = (typeof Uint8Array !== 'undefined') | |
? Uint8Array | |
: Array | |
var PLUS = '+'.charCodeAt(0) | |
var SLASH = '/'.charCodeAt(0) | |
var NUMBER = '0'.charCodeAt(0) | |
var LOWER = 'a'.charCodeAt(0) | |
var UPPER = 'A'.charCodeAt(0) | |
var PLUS_URL_SAFE = '-'.charCodeAt(0) | |
var SLASH_URL_SAFE = '_'.charCodeAt(0) | |
function decode (elt) { | |
var code = elt.charCodeAt(0) | |
if (code === PLUS || | |
code === PLUS_URL_SAFE) | |
return 62 // '+' | |
if (code === SLASH || | |
code === SLASH_URL_SAFE) | |
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 | |
} | |
exports.toByteArray = b64ToByteArray | |
exports.fromByteArray = uint8ToBase64 | |
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) | |
},{}],3:[function(require,module,exports){ | |
exports.read = function (buffer, offset, isLE, mLen, nBytes) { | |
var e, m | |
var eLen = nBytes * 8 - mLen - 1 | |
var eMax = (1 << eLen) - 1 | |
var eBias = eMax >> 1 | |
var nBits = -7 | |
var i = isLE ? (nBytes - 1) : 0 | |
var d = isLE ? -1 : 1 | |
var 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 | |
var eLen = nBytes * 8 - mLen - 1 | |
var eMax = (1 << eLen) - 1 | |
var eBias = eMax >> 1 | |
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) | |
var i = isLE ? 0 : (nBytes - 1) | |
var d = isLE ? 1 : -1 | |
var 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 | |
} | |
},{}],4:[function(require,module,exports){ | |
var toString = {}.toString; | |
module.exports = Array.isArray || function (arr) { | |
return toString.call(arr) == '[object Array]'; | |
}; | |
},{}],5:[function(require,module,exports){ | |
// Copyright Joyent, Inc. and other Node contributors. | |
// | |
// Permission is hereby granted, free of charge, to any person obtaining a | |
// copy of this software and associated documentation files (the | |
// "Software"), to deal in the Software without restriction, including | |
// without limitation the rights to use, copy, modify, merge, publish, | |
// distribute, sublicense, and/or sell copies of the Software, and to permit | |
// persons to whom the Software is furnished to do so, subject to the | |
// following conditions: | |
// | |
// The above copyright notice and this permission notice shall be included | |
// in all copies or substantial portions of the Software. | |
// | |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
// USE OR OTHER DEALINGS IN THE SOFTWARE. | |
function EventEmitter() { | |
this._events = this._events || {}; | |
this._maxListeners = this._maxListeners || undefined; | |
} | |
module.exports = EventEmitter; | |
// Backwards-compat with node 0.10.x | |
EventEmitter.EventEmitter = EventEmitter; | |
EventEmitter.prototype._events = undefined; | |
EventEmitter.prototype._maxListeners = undefined; | |
// By default EventEmitters will print a warning if more than 10 listeners are | |
// added to it. This is a useful default which helps finding memory leaks. | |
EventEmitter.defaultMaxListeners = 10; | |
// Obviously not all Emitters should be limited to 10. This function allows | |
// that to be increased. Set to zero for unlimited. | |
EventEmitter.prototype.setMaxListeners = function(n) { | |
if (!isNumber(n) || n < 0 || isNaN(n)) | |
throw TypeError('n must be a positive number'); | |
this._maxListeners = n; | |
return this; | |
}; | |
EventEmitter.prototype.emit = function(type) { | |
var er, handler, len, args, i, listeners; | |
if (!this._events) | |
this._events = {}; | |
// If there is no 'error' event listener then throw. | |
if (type === 'error') { | |
if (!this._events.error || | |
(isObject(this._events.error) && !this._events.error.length)) { | |
er = arguments[1]; | |
if (er instanceof Error) { | |
throw er; // Unhandled 'error' event | |
} | |
throw TypeError('Uncaught, unspecified "error" event.'); | |
} | |
} | |
handler = this._events[type]; | |
if (isUndefined(handler)) | |
return false; | |
if (isFunction(handler)) { | |
switch (arguments.length) { | |
// fast cases | |
case 1: | |
handler.call(this); | |
break; | |
case 2: | |
handler.call(this, arguments[1]); | |
break; | |
case 3: | |
handler.call(this, arguments[1], arguments[2]); | |
break; | |
// slower | |
default: | |
len = arguments.length; | |
args = new Array(len - 1); | |
for (i = 1; i < len; i++) | |
args[i - 1] = arguments[i]; | |
handler.apply(this, args); | |
} | |
} else if (isObject(handler)) { | |
len = arguments.length; | |
args = new Array(len - 1); | |
for (i = 1; i < len; i++) | |
args[i - 1] = arguments[i]; | |
listeners = handler.slice(); | |
len = listeners.length; | |
for (i = 0; i < len; i++) | |
listeners[i].apply(this, args); | |
} | |
return true; | |
}; | |
EventEmitter.prototype.addListener = function(type, listener) { | |
var m; | |
if (!isFunction(listener)) | |
throw TypeError('listener must be a function'); | |
if (!this._events) | |
this._events = {}; | |
// To avoid recursion in the case that type === "newListener"! Before | |
// adding it to the listeners, first emit "newListener". | |
if (this._events.newListener) | |
this.emit('newListener', type, | |
isFunction(listener.listener) ? | |
listener.listener : listener); | |
if (!this._events[type]) | |
// Optimize the case of one listener. Don't need the extra array object. | |
this._events[type] = listener; | |
else if (isObject(this._events[type])) | |
// If we've already got an array, just append. | |
this._events[type].push(listener); | |
else | |
// Adding the second element, need to change to array. | |
this._events[type] = [this._events[type], listener]; | |
// Check for listener leak | |
if (isObject(this._events[type]) && !this._events[type].warned) { | |
var m; | |
if (!isUndefined(this._maxListeners)) { | |
m = this._maxListeners; | |
} else { | |
m = EventEmitter.defaultMaxListeners; | |
} | |
if (m && m > 0 && this._events[type].length > m) { | |
this._events[type].warned = true; | |
console.error('(node) warning: possible EventEmitter memory ' + | |
'leak detected. %d listeners added. ' + | |
'Use emitter.setMaxListeners() to increase limit.', | |
this._events[type].length); | |
if (typeof console.trace === 'function') { | |
// not supported in IE 10 | |
console.trace(); | |
} | |
} | |
} | |
return this; | |
}; | |
EventEmitter.prototype.on = EventEmitter.prototype.addListener; | |
EventEmitter.prototype.once = function(type, listener) { | |
if (!isFunction(listener)) | |
throw TypeError('listener must be a function'); | |
var fired = false; | |
function g() { | |
this.removeListener(type, g); | |
if (!fired) { | |
fired = true; | |
listener.apply(this, arguments); | |
} | |
} | |
g.listener = listener; | |
this.on(type, g); | |
return this; | |
}; | |
// emits a 'removeListener' event iff the listener was removed | |
EventEmitter.prototype.removeListener = function(type, listener) { | |
var list, position, length, i; | |
if (!isFunction(listener)) | |
throw TypeError('listener must be a function'); | |
if (!this._events || !this._events[type]) | |
return this; | |
list = this._events[type]; | |
length = list.length; | |
position = -1; | |
if (list === listener || | |
(isFunction(list.listener) && list.listener === listener)) { | |
delete this._events[type]; | |
if (this._events.removeListener) | |
this.emit('removeListener', type, listener); | |
} else if (isObject(list)) { | |
for (i = length; i-- > 0;) { | |
if (list[i] === listener || | |
(list[i].listener && list[i].listener === listener)) { | |
position = i; | |
break; | |
} | |
} | |
if (position < 0) | |
return this; | |
if (list.length === 1) { | |
list.length = 0; | |
delete this._events[type]; | |
} else { | |
list.splice(position, 1); | |
} | |
if (this._events.removeListener) | |
this.emit('removeListener', type, listener); | |
} | |
return this; | |
}; | |
EventEmitter.prototype.removeAllListeners = function(type) { | |
var key, listeners; | |
if (!this._events) | |
return this; | |
// not listening for removeListener, no need to emit | |
if (!this._events.removeListener) { | |
if (arguments.length === 0) | |
this._events = {}; | |
else if (this._events[type]) | |
delete this._events[type]; | |
return this; | |
} | |
// emit removeListener for all listeners on all events | |
if (arguments.length === 0) { | |
for (key in this._events) { | |
if (key === 'removeListener') continue; | |
this.removeAllListeners(key); | |
} | |
this.removeAllListeners('removeListener'); | |
this._events = {}; | |
return this; | |
} | |
listeners = this._events[type]; | |
if (isFunction(listeners)) { | |
this.removeListener(type, listeners); | |
} else { | |
// LIFO order | |
while (listeners.length) | |
this.removeListener(type, listeners[listeners.length - 1]); | |
} | |
delete this._events[type]; | |
return this; | |
}; | |
EventEmitter.prototype.listeners = function(type) { | |
var ret; | |
if (!this._events || !this._events[type]) | |
ret = []; | |
else if (isFunction(this._events[type])) | |
ret = [this._events[type]]; | |
else | |
ret = this._events[type].slice(); | |
return ret; | |
}; | |
EventEmitter.listenerCount = function(emitter, type) { | |
var ret; | |
if (!emitter._events || !emitter._events[type]) | |
ret = 0; | |
else if (isFunction(emitter._events[type])) | |
ret = 1; | |
else | |
ret = emitter._events[type].length; | |
return ret; | |
}; | |
function isFunction(arg) { | |
return typeof arg === 'function'; | |
} | |
function isNumber(arg) { | |
return typeof arg === 'number'; | |
} | |
function isObject(arg) { | |
return typeof arg === 'object' && arg !== null; | |
} | |
function isUndefined(arg) { | |
return arg === void 0; | |
} | |
},{}],6:[function(require,module,exports){ | |
var is = require('./is'), | |
GENERIC = '_generic', | |
EventEmitter = require('events').EventEmitter, | |
slice = Array.prototype.slice; | |
function flatten(item){ | |
return Array.isArray(item) ? item.reduce(function(result, element){ | |
if(element == null){ | |
return result; | |
} | |
return result.concat(flatten(element)); | |
},[]) : item; | |
} | |
function attachProperties(object, firm){ | |
for(var key in this._properties){ | |
this._properties[key].attach(object, firm); | |
} | |
} | |
function onRender(){ | |
// Ensure all bindings are somewhat attached just before rendering | |
this.attach(undefined, 0); | |
for(var key in this._properties){ | |
this._properties[key].update(); | |
} | |
} | |
function detachProperties(firm){ | |
for(var key in this._properties){ | |
this._properties[key].detach(firm); | |
} | |
} | |
function destroyProperties(){ | |
for(var key in this._properties){ | |
this._properties[key].destroy(); | |
} | |
} | |
function clone(){ | |
return this.fastn(this.component._type, this.component._settings, this.component._children.filter(function(child){ | |
return !child._templated; | |
}).map(function(child){ | |
return child.clone(); | |
}) | |
); | |
} | |
function getSetBinding(newBinding){ | |
if(!arguments.length){ | |
return this.binding; | |
} | |
if(!is.binding(newBinding)){ | |
newBinding = this.fastn.binding(newBinding); | |
} | |
if(this.binding && this.binding !== newBinding){ | |
this.binding.removeListener('change', this.emitAttach); | |
newBinding.attach(this.binding._model, this.binding._firm); | |
} | |
this.binding = newBinding; | |
this.binding.on('change', this.emitAttach); | |
this.binding.on('detach', this.emitDetach); | |
this.emitAttach(); | |
return this.component; | |
}; | |
function emitAttach(){ | |
var newBound = this.binding(); | |
if(newBound !== this.lastBound){ | |
this.lastBound = newBound; | |
this.scope.attach(this.lastBound); | |
this.component.emit('attach', this.scope, 1); | |
} | |
} | |
function emitDetach(){ | |
this.component.emit('detach', 1); | |
} | |
function getScope(){ | |
return this.scope; | |
} | |
function destroy(){ | |
if(this.destroyed){ | |
return; | |
} | |
this.destroyed = true; | |
this.component | |
.removeAllListeners('render') | |
.removeAllListeners('attach'); | |
this.component.emit('destroy'); | |
this.component.element = null; | |
this.scope.destroy(); | |
this.binding.destroy(); | |
return this.component; | |
} | |
function attachComponent(object, firm){ | |
this.binding.attach(object, firm); | |
return this.component; | |
} | |
function detachComponent(firm){ | |
this.binding.detach(firm); | |
return this.component; | |
} | |
function isDestroyed(){ | |
return this.destroyed; | |
} | |
function setProperty(key, property){ | |
// Add a default property or use the one already there | |
if(!property){ | |
property = this.component[key] || this.fastn.property(); | |
} | |
this.component[key] = property; | |
this.component._properties[key] = property; | |
return this.component; | |
} | |
function extendComponent(type, settings, children){ | |
if(type in this.types){ | |
return this.component; | |
} | |
if(!(type in this.fastn.components)){ | |
if(!(GENERIC in this.fastn.components)){ | |
throw new Error('No component of type "' + type + '" is loaded'); | |
} | |
this.fastn.components._generic(this.fastn, this.component, type, settings, children); | |
this.types._generic = true; | |
}else{ | |
this.fastn.components[type](this.fastn, this.component, type, settings, children); | |
} | |
this.types[type] = true; | |
return this.component; | |
}; | |
function isType(type){ | |
return type in this.types; | |
} | |
function FastnComponent(fastn, type, settings, children){ | |
var component = this; | |
var componentScope = { | |
types: {}, | |
fastn: fastn, | |
component: component, | |
binding: fastn.binding('.'), | |
destroyed: false, | |
scope: new fastn.Model(false), | |
lastBound: null | |
}; | |
componentScope.emitAttach = emitAttach.bind(componentScope); | |
componentScope.emitDetach = emitDetach.bind(componentScope); | |
componentScope.binding._default_binding = true; | |
component._type = type; | |
component._properties = {}; | |
component._settings = settings || {}; | |
component._children = children ? flatten(children) : []; | |
component.attach = attachComponent.bind(componentScope); | |
component.detach = detachComponent.bind(componentScope); | |
component.scope = getScope.bind(componentScope); | |
component.destroy = destroy.bind(componentScope); | |
component.destroyed = isDestroyed.bind(componentScope); | |
component.binding = getSetBinding.bind(componentScope); | |
component.setProperty = setProperty.bind(componentScope); | |
component.clone = clone.bind(componentScope); | |
component.children = slice.bind(component._children); | |
component.extend = extendComponent.bind(componentScope); | |
component.is = isType.bind(componentScope); | |
component.binding(componentScope.binding); | |
component.on('attach', attachProperties.bind(this)); | |
component.on('render', onRender.bind(this)); | |
component.on('detach', detachProperties.bind(this)); | |
component.on('destroy', destroyProperties.bind(this)); | |
if(fastn.debug){ | |
component.on('render', function(){ | |
if(component.element && typeof component.element === 'object'){ | |
component.element._component = component; | |
} | |
}); | |
} | |
} | |
FastnComponent.prototype = Object.create(EventEmitter.prototype); | |
FastnComponent.prototype.constructor = FastnComponent; | |
FastnComponent.prototype._fastn_component = true; | |
module.exports = FastnComponent; | |
},{"./is":10,"events":5}],7:[function(require,module,exports){ | |
var is = require('./is'), | |
firmer = require('./firmer'), | |
functionEmitter = require('function-emitter'), | |
setPrototypeOf = require('setprototypeof'), | |
same = require('same-value'); | |
function fuseBinding(){ | |
var fastn = this, | |
args = Array.prototype.slice.call(arguments); | |
var bindings = args.slice(), | |
transform = bindings.pop(), | |
updateTransform, | |
resultBinding = createBinding.call(fastn, 'result'), | |
selfChanging; | |
resultBinding._arguments = args; | |
if(typeof bindings[bindings.length-1] === 'function' && !is.binding(bindings[bindings.length-1])){ | |
updateTransform = transform; | |
transform = bindings.pop(); | |
} | |
resultBinding._model.removeAllListeners(); | |
resultBinding._set = function(value){ | |
if(updateTransform){ | |
selfChanging = true; | |
var newValue = updateTransform(value); | |
if(!same(newValue, bindings[0]())){ | |
bindings[0](newValue); | |
resultBinding._change(newValue); | |
} | |
selfChanging = false; | |
}else{ | |
resultBinding._change(value); | |
} | |
}; | |
function change(){ | |
if(selfChanging){ | |
return; | |
} | |
resultBinding(transform.apply(null, bindings.map(function(binding){ | |
return binding(); | |
}))); | |
} | |
bindings.forEach(function(binding, index){ | |
if(!is.binding(binding)){ | |
binding = createBinding.call(fastn, binding); | |
bindings.splice(index,1,binding); | |
} | |
binding.on('change', change); | |
resultBinding.on('detach', binding.detach); | |
}); | |
var lastAttached; | |
resultBinding.on('attach', function(object){ | |
selfChanging = true; | |
bindings.forEach(function(binding){ | |
binding.attach(object, 1); | |
}); | |
selfChanging = false; | |
if(lastAttached !== object){ | |
change(); | |
} | |
lastAttached = object; | |
}); | |
return resultBinding; | |
} | |
function createValueBinding(fastn){ | |
var valueBinding = createBinding.call(fastn, 'value'); | |
valueBinding.attach = function(){return valueBinding;}; | |
valueBinding.detach = function(){return valueBinding;}; | |
return valueBinding; | |
} | |
function bindingTemplate(newValue){ | |
if(!arguments.length){ | |
return this.value; | |
} | |
if(this.binding._fastn_binding === '.'){ | |
return; | |
} | |
this.binding._set(newValue); | |
return this.binding; | |
} | |
function createBinding(path, more){ | |
var fastn = this; | |
if(more){ // used instead of arguments.length for performance | |
return fuseBinding.apply(fastn, arguments); | |
} | |
if(path == null){ | |
return createValueBinding(fastn); | |
} | |
var bindingScope = {}, | |
binding = bindingScope.binding = bindingTemplate.bind(bindingScope), | |
destroyed; | |
setPrototypeOf(binding, functionEmitter); | |
binding.setMaxListeners(10000); | |
binding._arguments = [path]; | |
binding._model = new fastn.Model(false); | |
binding._fastn_binding = path; | |
binding._firm = -Infinity; | |
function modelAttachHandler(data){ | |
binding._model.attach(data); | |
binding._change(binding._model.get(path)); | |
binding.emit('attach', data, 1); | |
} | |
function modelDetachHandler(){ | |
binding._model.detach(); | |
} | |
binding.attach = function(object, firm){ | |
// If the binding is being asked to attach loosly to an object, | |
// but it has already been defined as being firmly attached, do not attach. | |
if(firmer(binding, firm)){ | |
return binding; | |
} | |
binding._firm = firm; | |
var isModel = fastn.isModel(object); | |
if(isModel && bindingScope.attachedModel === object){ | |
return binding; | |
} | |
if(bindingScope.attachedModel){ | |
bindingScope.attachedModel.removeListener('attach', modelAttachHandler); | |
bindingScope.attachedModel.removeListener('detach', modelDetachHandler); | |
bindingScope.attachedModel = null; | |
} | |
if(isModel){ | |
bindingScope.attachedModel = object; | |
bindingScope.attachedModel.on('attach', modelAttachHandler); | |
bindingScope.attachedModel.on('detach', modelDetachHandler); | |
object = object._model; | |
} | |
if(!(object instanceof Object)){ | |
object = {}; | |
} | |
if(binding._model._model === object){ | |
return binding; | |
} | |
modelAttachHandler(object); | |
return binding; | |
}; | |
binding.detach = function(firm){ | |
if(firmer(binding, firm)){ | |
return binding; | |
} | |
bindingScope.value = undefined; | |
if(binding._model.isAttached()){ | |
binding._model.detach(); | |
} | |
binding.emit('detach', 1); | |
return binding; | |
}; | |
binding._set = function(newValue){ | |
if(same(binding._model.get(path), newValue)){ | |
return; | |
} | |
if(!binding._model.isAttached()){ | |
binding._model.attach(binding._model.get('.')); | |
} | |
binding._model.set(path, newValue); | |
}; | |
binding._change = function(newValue){ | |
bindingScope.value = newValue; | |
binding.emit('change', binding()); | |
}; | |
binding.clone = function(keepAttachment){ | |
var newBinding = createBinding.apply(fastn, binding._arguments); | |
if(keepAttachment){ | |
newBinding.attach(bindingScope.attachedModel || binding._model._model, binding._firm); | |
} | |
return newBinding; | |
}; | |
binding.destroy = function(soft){ | |
if(destroyed){ | |
return; | |
} | |
if(soft && binding.listeners('change').length){ | |
return; | |
} | |
destroyed = true; | |
binding.emit('destroy'); | |
binding.detach(); | |
binding._model.destroy(); | |
}; | |
binding.destroyed = function(){ | |
return destroyed; | |
}; | |
if(path !== '.'){ | |
binding._model.on(path, binding._change); | |
} | |
return binding; | |
} | |
function from(valueOrBinding){ | |
if(is.binding(valueOrBinding)){ | |
return valueOrBinding; | |
} | |
var result = this(); | |
result(valueOrBinding) | |
return result; | |
} | |
module.exports = function(fastn){ | |
var binding = createBinding.bind(fastn); | |
binding.from = from.bind(binding); | |
return binding; | |
}; | |
},{"./firmer":9,"./is":10,"function-emitter":14,"same-value":16,"setprototypeof":17}],8:[function(require,module,exports){ | |
function insertChild(fastn, container, child, index){ | |
if(child == null || child === false){ | |
return; | |
} | |
var currentIndex = container._children.indexOf(child), | |
newComponent = fastn.toComponent(child); | |
if(newComponent !== child && ~currentIndex){ | |
container._children.splice(currentIndex, 1, newComponent); | |
} | |
if(!~currentIndex || newComponent !== child){ | |
newComponent.attach(container.scope(), 1); | |
} | |
if(currentIndex !== index){ | |
if(~currentIndex){ | |
container._children.splice(currentIndex, 1); | |
} | |
container._children.splice(index, 0, newComponent); | |
} | |
if(container.element){ | |
if(!newComponent.element){ | |
newComponent.render(); | |
} | |
container._insert(newComponent.element, index); | |
newComponent.emit('insert', container); | |
container.emit('childInsert', newComponent); | |
} | |
} | |
function getContainerElement(){ | |
return this.containerElement || this.element; | |
} | |
function insert(child, index){ | |
var childComponent = child, | |
container = this.container, | |
fastn = this.fastn; | |
if(index && typeof index === 'object'){ | |
childComponent = Array.prototype.slice.call(arguments); | |
} | |
if(isNaN(index)){ | |
index = container._children.length; | |
} | |
if(Array.isArray(childComponent)){ | |
for (var i = 0; i < childComponent.length; i++) { | |
container.insert(childComponent[i], i + index); | |
} | |
}else{ | |
insertChild(fastn, container, childComponent, index); | |
} | |
return container; | |
} | |
module.exports = function(fastn, component, type, settings, children){ | |
component.insert = insert.bind({ | |
container: component, | |
fastn: fastn | |
}); | |
component._insert = function(element, index){ | |
var containerElement = component.getContainerElement(); | |
if(!containerElement){ | |
return; | |
} | |
if(containerElement.childNodes[index] === element){ | |
return; | |
} | |
containerElement.insertBefore(element, containerElement.childNodes[index]); | |
}; | |
component.remove = function(childComponent){ | |
var index = component._children.indexOf(childComponent); | |
if(~index){ | |
component._children.splice(index,1); | |
} | |
childComponent.detach(1); | |
if(childComponent.element){ | |
component._remove(childComponent.element); | |
childComponent.emit('remove', component); | |
} | |
component.emit('childRemove', childComponent); | |
}; | |
component._remove = function(element){ | |
var containerElement = component.getContainerElement(); | |
if(!element || !containerElement || element.parentNode !== containerElement){ | |
return; | |
} | |
containerElement.removeChild(element); | |
}; | |
component.empty = function(){ | |
while(component._children.length){ | |
component.remove(component._children.pop()); | |
} | |
}; | |
component.replaceChild = function(oldChild, newChild){ | |
var index = component._children.indexOf(oldChild); | |
if(!~index){ | |
return; | |
} | |
component.remove(oldChild); | |
component.insert(newChild, index); | |
}; | |
component.getContainerElement = getContainerElement.bind(component); | |
component.on('render', component.insert.bind(null, component._children, 0)); | |
component.on('attach', function(model, firm){ | |
for(var i = 0; i < component._children.length; i++){ | |
if(fastn.isComponent(component._children[i])){ | |
component._children[i].attach(model, firm); | |
} | |
} | |
}); | |
component.on('destroy', function(data, firm){ | |
for(var i = 0; i < component._children.length; i++){ | |
if(fastn.isComponent(component._children[i])){ | |
component._children[i].destroy(firm); | |
} | |
} | |
}); | |
return component; | |
}; | |
},{}],9:[function(require,module,exports){ | |
// Is the entity firmer than the new firmness | |
module.exports = function(entity, firm){ | |
if(firm != null && (entity._firm === undefined || firm < entity._firm)){ | |
return true; | |
} | |
}; | |
},{}],10:[function(require,module,exports){ | |
var FUNCTION = 'function', | |
OBJECT = 'object', | |
FASTNBINDING = '_fastn_binding', | |
FASTNPROPERTY = '_fastn_property', | |
FASTNCOMPONENT = '_fastn_component', | |
DEFAULTBINDING = '_default_binding'; | |
function isComponent(thing){ | |
return thing && typeof thing === OBJECT && FASTNCOMPONENT in thing; | |
} | |
function isBindingObject(thing){ | |
return thing && typeof thing === OBJECT && FASTNBINDING in thing; | |
} | |
function isBinding(thing){ | |
return typeof thing === FUNCTION && FASTNBINDING in thing; | |
} | |
function isProperty(thing){ | |
return typeof thing === FUNCTION && FASTNPROPERTY in thing; | |
} | |
function isDefaultBinding(thing){ | |
return typeof thing === FUNCTION && FASTNBINDING in thing && DEFAULTBINDING in thing; | |
} | |
module.exports = { | |
component: isComponent, | |
bindingObject: isBindingObject, | |
binding: isBinding, | |
defaultBinding: isDefaultBinding, | |
property: isProperty | |
}; | |
},{}],11:[function(require,module,exports){ | |
//Copyright (C) 2012 Kory Nunn | |
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: | |
//The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. | |
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
/* | |
This code is not formatted for readability, but rather run-speed and to assist compilers. | |
However, the code's intention should be transparent. | |
*** IE SUPPORT *** | |
If you require this library to work in IE7, add the following after declaring crel. | |
var testDiv = document.createElement('div'), | |
testLabel = document.createElement('label'); | |
testDiv.setAttribute('class', 'a'); | |
testDiv['className'] !== 'a' ? crel.attrMap['class'] = 'className':undefined; | |
testDiv.setAttribute('name','a'); | |
testDiv['name'] !== 'a' ? crel.attrMap['name'] = function(element, value){ | |
element.id = value; | |
}:undefined; | |
testLabel.setAttribute('for', 'a'); | |
testLabel['htmlFor'] !== 'a' ? crel.attrMap['for'] = 'htmlFor':undefined; | |
*/ | |
(function (root, factory) { | |
if (typeof exports === 'object') { | |
module.exports = factory(); | |
} else if (typeof define === 'function' && define.amd) { | |
define(factory); | |
} else { | |
root.crel = factory(); | |
} | |
}(this, function () { | |
var fn = 'function', | |
obj = 'object', | |
nodeType = 'nodeType', | |
textContent = 'textContent', | |
setAttribute = 'setAttribute', | |
attrMapString = 'attrMap', | |
isNodeString = 'isNode', | |
isElementString = 'isElement', | |
d = typeof document === obj ? document : {}, | |
isType = function(a, type){ | |
return typeof a === type; | |
}, | |
isNode = typeof Node === fn ? function (object) { | |
return object instanceof Node; | |
} : | |
// in IE <= 8 Node is an object, obviously.. | |
function(object){ | |
return object && | |
isType(object, obj) && | |
(nodeType in object) && | |
isType(object.ownerDocument,obj); | |
}, | |
isElement = function (object) { | |
return crel[isNodeString](object) && object[nodeType] === 1; | |
}, | |
isArray = function(a){ | |
return a instanceof Array; | |
}, | |
appendChild = function(element, child) { | |
if(!crel[isNodeString](child)){ | |
child = d.createTextNode(child); | |
} | |
element.appendChild(child); | |
}; | |
function crel(){ | |
var args = arguments, //Note: assigned to a variable to assist compilers. Saves about 40 bytes in closure compiler. Has negligable effect on performance. | |
element = args[0], | |
child, | |
settings = args[1], | |
childIndex = 2, | |
argumentsLength = args.length, | |
attributeMap = crel[attrMapString]; | |
element = crel[isElementString](element) ? element : d.createElement(element); | |
// shortcut | |
if(argumentsLength === 1){ | |
return element; | |
} | |
if(!isType(settings,obj) || crel[isNodeString](settings) || isArray(settings)) { | |
--childIndex; | |
settings = null; | |
} | |
// shortcut if there is only one child that is a string | |
if((argumentsLength - childIndex) === 1 && isType(args[childIndex], 'string') && element[textContent] !== undefined){ | |
element[textContent] = args[childIndex]; | |
}else{ | |
for(; childIndex < argumentsLength; ++childIndex){ | |
child = args[childIndex]; | |
if(child == null){ | |
continue; | |
} | |
if (isArray(child)) { | |
for (var i=0; i < child.length; ++i) { | |
appendChild(element, child[i]); | |
} | |
} else { | |
appendChild(element, child); | |
} | |
} | |
} | |
for(var key in settings){ | |
if(!attributeMap[key]){ | |
element[setAttribute](key, settings[key]); | |
}else{ | |
var attr = attributeMap[key]; | |
if(typeof attr === fn){ | |
attr(element, settings[key]); | |
}else{ | |
element[setAttribute](attr, settings[key]); | |
} | |
} | |
} | |
return element; | |
} | |
// Used for mapping one kind of attribute to the supported version of that in bad browsers. | |
crel[attrMapString] = {}; | |
crel[isElementString] = isElement; | |
crel[isNodeString] = isNode; | |
if(typeof Proxy !== 'undefined'){ | |
return new Proxy(crel, { | |
get: function(target, key){ | |
!(key in crel) && (crel[key] = crel.bind(null, key)); | |
return crel[key]; | |
} | |
}); | |
} | |
return crel; | |
})); | |
},{}],12:[function(require,module,exports){ | |
(function (global){ | |
var EventEmitter = require('events').EventEmitter, | |
isInstance = require('is-instance'); | |
function toArray(items){ | |
return Array.prototype.slice.call(items); | |
} | |
var deepRegex = /[|.]/i; | |
function matchDeep(path){ | |
return (path + '').match(deepRegex); | |
} | |
function isWildcardPath(path){ | |
var stringPath = (path + ''); | |
return ~stringPath.indexOf('*'); | |
} | |
function getTargetKey(path){ | |
var stringPath = (path + ''); | |
return stringPath.split('|').shift(); | |
} | |
var eventSystemVersion = 1, | |
globalKey = '_entiEventState' + eventSystemVersion | |
globalState = global[globalKey] = global[globalKey] || { | |
instances: [] | |
}; | |
var modifiedEnties = globalState.modifiedEnties = globalState.modifiedEnties || new Set(), | |
trackedObjects = globalState.trackedObjects = globalState.trackedObjects || new WeakMap(); | |
function leftAndRest(path){ | |
var stringPath = (path + ''); | |
// Special case when you want to filter on self (.) | |
if(stringPath.slice(0,2) === '.|'){ | |
return ['.', stringPath.slice(2)]; | |
} | |
var match = matchDeep(stringPath); | |
if(match){ | |
return [stringPath.slice(0, match.index), stringPath.slice(match.index+1)]; | |
} | |
return stringPath; | |
} | |
function isWildcardKey(key){ | |
return key.charAt(0) === '*'; | |
} | |
function isFeralcardKey(key){ | |
return key === '**'; | |
} | |
function addHandler(object, key, handler){ | |
var trackedKeys = trackedObjects.get(object); | |
if(trackedKeys == null){ | |
trackedKeys = {}; | |
trackedObjects.set(object, trackedKeys); | |
} | |
var handlers = trackedKeys[key]; | |
if(!handlers){ | |
handlers = new Set(); | |
trackedKeys[key] = handlers; | |
} | |
handlers.add(handler); | |
} | |
function removeHandler(object, key, handler){ | |
var trackedKeys = trackedObjects.get(object); | |
if(trackedKeys == null){ | |
return; | |
} | |
var handlers = trackedKeys[key]; | |
if(!handlers){ | |
return; | |
} | |
handlers.delete(handler); | |
} | |
function trackObjects(eventName, tracked, handler, object, key, path){ | |
if(!object || typeof object !== 'object'){ | |
return; | |
} | |
var target = object[key]; | |
if(target && typeof target === 'object' && tracked.has(target)){ | |
return; | |
} | |
trackObject(eventName, tracked, handler, object, key, path); | |
} | |
function trackKeys(eventName, tracked, handler, target, root, rest){ | |
var keys = Object.keys(target); | |
for(var i = 0; i < keys.length; i++){ | |
if(isFeralcardKey(root)){ | |
trackObjects(eventName, tracked, handler, target, keys[i], '**' + (rest ? '.' : '') + (rest || '')); | |
}else{ | |
trackObjects(eventName, tracked, handler, target, keys[i], rest); | |
} | |
} | |
} | |
function trackObject(eventName, tracked, handler, object, key, path){ | |
var eventKey = key === '**' ? '*' : key, | |
target = object[key], | |
targetIsObject = target && typeof target === 'object'; | |
var handle = function(value, event, emitKey){ | |
if(eventKey !== '*' && typeof object[eventKey] === 'object' && object[eventKey] !== target){ | |
if(targetIsObject){ | |
tracked.delete(target); | |
} | |
removeHandler(object, eventKey, handle); | |
trackObjects(eventName, tracked, handler, object, key, path); | |
return; | |
} | |
if(eventKey === '*'){ | |
trackKeys(eventName, tracked, handler, object, key, path); | |
} | |
if(!tracked.has(object)){ | |
return; | |
} | |
if(key !== '**' || !path){ | |
handler(value, event, emitKey); | |
} | |
}; | |
addHandler(object, eventKey, handle); | |
if(!targetIsObject){ | |
return; | |
} | |
tracked.add(target); | |
if(!path){ | |
return; | |
} | |
var rootAndRest = leftAndRest(path), | |
root, | |
rest; | |
if(!Array.isArray(rootAndRest)){ | |
root = rootAndRest; | |
}else{ | |
root = rootAndRest[0]; | |
rest = rootAndRest[1]; | |
// If the root is '.', watch for events on * | |
if(root === '.'){ | |
root = '*'; | |
} | |
} | |
if(targetIsObject && isWildcardKey(root)){ | |
trackKeys(eventName, tracked, handler, target, root, rest); | |
} | |
trackObjects(eventName, tracked, handler, target, root, rest); | |
} | |
var trackedEvents = new WeakMap(); | |
function createHandler(enti, trackedObjectPaths, trackedPaths, eventName){ | |
var oldModel = enti._model; | |
return function(event, emitKey){ | |
trackedPaths.entis.forEach(function(enti){ | |
if(enti._emittedEvents[eventName] === emitKey){ | |
return; | |
} | |
if(enti._model !== oldModel){ | |
trackedPaths.entis.delete(enti); | |
if(trackedPaths.entis.size === 0){ | |
delete trackedObjectPaths[eventName]; | |
if(!Object.keys(trackedObjectPaths).length){ | |
trackedEvents.delete(oldModel); | |
} | |
} | |
return; | |
} | |
enti._emittedEvents[eventName] = emitKey; | |
var targetKey = getTargetKey(eventName), | |
value = isWildcardPath(targetKey) ? undefined : enti.get(targetKey); | |
enti.emit(eventName, value, event); | |
}); | |
}; | |
} | |
function trackPath(enti, eventName){ | |
var object = enti._model, | |
trackedObjectPaths = trackedEvents.get(object); | |
if(!trackedObjectPaths){ | |
trackedObjectPaths = {}; | |
trackedEvents.set(object, trackedObjectPaths); | |
} | |
var trackedPaths = trackedObjectPaths[eventName]; | |
if(!trackedPaths){ | |
trackedPaths = { | |
entis: new Set(), | |
trackedObjects: new WeakSet() | |
}; | |
trackedObjectPaths[eventName] = trackedPaths; | |
}else if(trackedPaths.entis.has(enti)){ | |
return; | |
} | |
trackedPaths.entis.add(enti); | |
var handler = createHandler(enti, trackedObjectPaths, trackedPaths, eventName); | |
trackObjects(eventName, trackedPaths.trackedObjects, handler, {model:object}, 'model', eventName); | |
} | |
function trackPaths(enti){ | |
if(!enti._events || !enti._model){ | |
return; | |
} | |
for(var key in enti._events){ | |
trackPath(enti, key); | |
} | |
modifiedEnties.delete(enti); | |
} | |
function emitEvent(object, key, value, emitKey){ | |
modifiedEnties.forEach(trackPaths); | |
var trackedKeys = trackedObjects.get(object); | |
if(!trackedKeys){ | |
return; | |
} | |
var event = { | |
value: value, | |
key: key, | |
object: object | |
}; | |
function emitForKey(handler){ | |
handler(event, emitKey); | |
} | |
if(trackedKeys[key]){ | |
trackedKeys[key].forEach(emitForKey); | |
} | |
if(trackedKeys['*']){ | |
trackedKeys['*'].forEach(emitForKey); | |
} | |
} | |
function emit(events){ | |
var emitKey = {}; | |
events.forEach(function(event){ | |
emitEvent(event[0], event[1], event[2], emitKey); | |
}); | |
} | |
function Enti(model){ | |
var detached = model === false; | |
if(!model || (typeof model !== 'object' && typeof model !== 'function')){ | |
model = {}; | |
} | |
this._emittedEvents = {}; | |
if(detached){ | |
this._model = {}; | |
}else{ | |
this.attach(model); | |
} | |
this.on('newListener', function(){ | |
modifiedEnties.add(this); | |
}); | |
} | |
Enti.emit = function(model, key, value){ | |
if(!(typeof model === 'object' || typeof model === 'function')){ | |
return; | |
} | |
emit([[model, key, value]]); | |
}; | |
Enti.get = function(model, key){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
key = getTargetKey(key); | |
if(key === '.'){ | |
return model; | |
} | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.get(model[path[0]], path[1]); | |
} | |
return model[key]; | |
}; | |
Enti.set = function(model, key, value){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
key = getTargetKey(key); | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.set(model[path[0]], path[1], value); | |
} | |
var original = model[key]; | |
if(typeof value !== 'object' && value === original){ | |
return; | |
} | |
var keysChanged = !(key in model); | |
model[key] = value; | |
var events = [[model, key, value]]; | |
if(keysChanged){ | |
if(Array.isArray(model)){ | |
events.push([model, 'length', model.length]); | |
} | |
} | |
emit(events); | |
}; | |
Enti.push = function(model, key, value){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
var target; | |
if(arguments.length < 3){ | |
value = key; | |
key = '.'; | |
target = model; | |
}else{ | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.push(model[path[0]], path[1], value); | |
} | |
target = model[key]; | |
} | |
if(!Array.isArray(target)){ | |
throw 'The target is not an array.'; | |
} | |
target.push(value); | |
var events = [ | |
[target, target.length-1, value], | |
[target, 'length', target.length] | |
]; | |
emit(events); | |
}; | |
Enti.insert = function(model, key, value, index){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
var target; | |
if(arguments.length < 4){ | |
index = value; | |
value = key; | |
key = '.'; | |
target = model; | |
}else{ | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.insert(model[path[0]], path[1], value, index); | |
} | |
target = model[key]; | |
} | |
if(!Array.isArray(target)){ | |
throw 'The target is not an array.'; | |
} | |
target.splice(index, 0, value); | |
var events = [ | |
[target, index, value], | |
[target, 'length', target.length] | |
]; | |
emit(events); | |
}; | |
Enti.remove = function(model, key, subKey){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.remove(model[path[0]], path[1], subKey); | |
} | |
// Remove a key off of an object at 'key' | |
if(subKey != null){ | |
Enti.remove(model[key], subKey); | |
return; | |
} | |
if(key === '.'){ | |
throw '. (self) is not a valid key to remove'; | |
} | |
var events = []; | |
if(Array.isArray(model)){ | |
model.splice(key, 1); | |
events.push([model, 'length', model.length]); | |
}else{ | |
delete model[key]; | |
events.push([model, key]); | |
} | |
emit(events); | |
}; | |
Enti.move = function(model, key, index){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.move(model[path[0]], path[1], index); | |
} | |
if(key === index){ | |
return; | |
} | |
if(!Array.isArray(model)){ | |
throw 'The model is not an array.'; | |
} | |
var item = model[key]; | |
model.splice(key, 1); | |
model.splice(index - (index > key ? 0 : 1), 0, item); | |
emit([[model, index, item]]); | |
}; | |
Enti.update = function(model, key, value){ | |
if(!model || typeof model !== 'object'){ | |
return; | |
} | |
var target, | |
isArray = Array.isArray(value); | |
if(arguments.length < 3){ | |
value = key; | |
key = '.'; | |
target = model; | |
}else{ | |
var path = leftAndRest(key); | |
if(Array.isArray(path)){ | |
return Enti.update(model[path[0]], path[1], value); | |
} | |
target = model[key]; | |
if(target == null){ | |
model[key] = isArray ? [] : {}; | |
} | |
} | |
if(typeof value !== 'object'){ | |
throw 'The value is not an object.'; | |
} | |
if(typeof target !== 'object'){ | |
throw 'The target is not an object.'; | |
} | |
var events = [], | |
updatedObjects = new WeakSet(); | |
function updateTarget(target, value){ | |
for(var key in value){ | |
var currentValue = target[key]; | |
if(currentValue instanceof Object && !updatedObjects.has(currentValue) && !(currentValue instanceof Date)){ | |
updatedObjects.add(currentValue); | |
updateTarget(currentValue, value[key]); | |
continue; | |
} | |
target[key] = value[key]; | |
events.push([target, key, value[key]]); | |
} | |
if(Array.isArray(target)){ | |
events.push([target, 'length', target.length]); | |
} | |
} | |
updateTarget(target, value); | |
emit(events); | |
}; | |
Enti.prototype = Object.create(EventEmitter.prototype); | |
Enti.prototype._maxListeners = 100; | |
Enti.prototype.constructor = Enti; | |
Enti.prototype.attach = function(model){ | |
if(this._model !== model){ | |
this.detach(); | |
} | |
if(model && !isInstance(model)){ | |
throw 'Entis may only be attached to an object, or null/undefined'; | |
} | |
modifiedEnties.add(this); | |
this._attached = true; | |
this._model = model; | |
this.emit('attach', model); | |
}; | |
Enti.prototype.detach = function(){ | |
modifiedEnties.delete(this); | |
this._emittedEvents = {}; | |
this._model = {}; | |
this._attached = false; | |
this.emit('detach'); | |
}; | |
Enti.prototype.destroy = function(){ | |
this.detach(); | |
this._events = null; | |
this.emit('destroy'); | |
}; | |
Enti.prototype.get = function(key){ | |
return Enti.get(this._model, key); | |
}; | |
Enti.prototype.set = function(key, value){ | |
return Enti.set(this._model, key, value); | |
}; | |
Enti.prototype.push = function(key, value){ | |
return Enti.push.apply(null, [this._model].concat(toArray(arguments))); | |
}; | |
Enti.prototype.insert = function(key, value, index){ | |
return Enti.insert.apply(null, [this._model].concat(toArray(arguments))); | |
}; | |
Enti.prototype.remove = function(key, subKey){ | |
return Enti.remove.apply(null, [this._model].concat(toArray(arguments))); | |
}; | |
Enti.prototype.move = function(key, index){ | |
return Enti.move.apply(null, [this._model].concat(toArray(arguments))); | |
}; | |
Enti.prototype.update = function(key, index){ | |
return Enti.update.apply(null, [this._model].concat(toArray(arguments))); | |
}; | |
Enti.prototype.isAttached = function(){ | |
return this._attached; | |
}; | |
Enti.prototype.attachedCount = function(){ | |
return modifiedEnties.size; | |
}; | |
Enti.isEnti = function(target){ | |
return target && !!~globalState.instances.indexOf(target.constructor); | |
}; | |
Enti.store = function(target, key, value){ | |
if(arguments.length < 2){ | |
return Enti.get(target, key); | |
} | |
Enti.set(target, key, value); | |
}; | |
globalState.instances.push(Enti); | |
module.exports = Enti; | |
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/enti/index.js"],"names":[],"mappings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file":"generated.js","sourceRoot":"","sourcesContent":["var EventEmitter = require('events').EventEmitter,\n    isInstance = require('is-instance');\n\nfunction toArray(items){\n    return Array.prototype.slice.call(items);\n}\n\nvar deepRegex = /[|.]/i;\n\nfunction matchDeep(path){\n    return (path + '').match(deepRegex);\n}\n\nfunction isWildcardPath(path){\n    var stringPath = (path + '');\n    return ~stringPath.indexOf('*');\n}\n\nfunction getTargetKey(path){\n    var stringPath = (path + '');\n    return stringPath.split('|').shift();\n}\n\nvar eventSystemVersion = 1,\n    globalKey = '_entiEventState' + eventSystemVersion\n    globalState = global[globalKey] = global[globalKey] || {\n        instances: []\n    };\n\nvar modifiedEnties = globalState.modifiedEnties = globalState.modifiedEnties || new Set(),\n    trackedObjects = globalState.trackedObjects = globalState.trackedObjects || new WeakMap();\n\nfunction leftAndRest(path){\n    var stringPath = (path + '');\n\n    // Special case when you want to filter on self (.)\n    if(stringPath.slice(0,2) === '.|'){\n        return ['.', stringPath.slice(2)];\n    }\n\n    var match = matchDeep(stringPath);\n    if(match){\n        return [stringPath.slice(0, match.index), stringPath.slice(match.index+1)];\n    }\n    return stringPath;\n}\n\nfunction isWildcardKey(key){\n    return key.charAt(0) === '*';\n}\n\nfunction isFeralcardKey(key){\n    return key === '**';\n}\n\nfunction addHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        trackedKeys = {};\n        trackedObjects.set(object, trackedKeys);\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        handlers = new Set();\n        trackedKeys[key] = handlers;\n    }\n\n    handlers.add(handler);\n}\n\nfunction removeHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        return;\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        return;\n    }\n\n    handlers.delete(handler);\n}\n\nfunction trackObjects(eventName, tracked, handler, object, key, path){\n    if(!object || typeof object !== 'object'){\n        return;\n    }\n\n    var target = object[key];\n\n    if(target && typeof target === 'object' && tracked.has(target)){\n        return;\n    }\n\n    trackObject(eventName, tracked, handler, object, key, path);\n}\n\nfunction trackKeys(eventName, tracked, handler, target, root, rest){\n    var keys = Object.keys(target);\n    for(var i = 0; i < keys.length; i++){\n        if(isFeralcardKey(root)){\n            trackObjects(eventName, tracked, handler, target, keys[i], '**' + (rest ? '.' : '') + (rest || ''));\n        }else{\n            trackObjects(eventName, tracked, handler, target, keys[i], rest);\n        }\n    }\n}\n\nfunction trackObject(eventName, tracked, handler, object, key, path){\n    var eventKey = key === '**' ? '*' : key,\n        target = object[key],\n        targetIsObject = target && typeof target === 'object';\n\n    var handle = function(value, event, emitKey){\n        if(eventKey !== '*' && typeof object[eventKey] === 'object' && object[eventKey] !== target){\n            if(targetIsObject){\n                tracked.delete(target);\n            }\n            removeHandler(object, eventKey, handle);\n            trackObjects(eventName, tracked, handler, object, key, path);\n            return;\n        }\n\n        if(eventKey === '*'){\n            trackKeys(eventName, tracked, handler, object, key, path);\n        }\n\n        if(!tracked.has(object)){\n            return;\n        }\n\n        if(key !== '**' || !path){\n            handler(value, event, emitKey);\n        }\n    };\n\n    addHandler(object, eventKey, handle);\n\n    if(!targetIsObject){\n        return;\n    }\n\n    tracked.add(target);\n\n    if(!path){\n        return;\n    }\n\n    var rootAndRest = leftAndRest(path),\n        root,\n        rest;\n\n    if(!Array.isArray(rootAndRest)){\n        root = rootAndRest;\n    }else{\n        root = rootAndRest[0];\n        rest = rootAndRest[1];\n\n        // If the root is '.', watch for events on *\n        if(root === '.'){\n            root = '*';\n        }\n    }\n\n    if(targetIsObject && isWildcardKey(root)){\n        trackKeys(eventName, tracked, handler, target, root, rest);\n    }\n\n    trackObjects(eventName, tracked, handler, target, root, rest);\n}\n\nvar trackedEvents = new WeakMap();\nfunction createHandler(enti, trackedObjectPaths, trackedPaths, eventName){\n    var oldModel = enti._model;\n    return function(event, emitKey){\n        trackedPaths.entis.forEach(function(enti){\n            if(enti._emittedEvents[eventName] === emitKey){\n                return;\n            }\n\n            if(enti._model !== oldModel){\n                trackedPaths.entis.delete(enti);\n                if(trackedPaths.entis.size === 0){\n                    delete trackedObjectPaths[eventName];\n                    if(!Object.keys(trackedObjectPaths).length){\n                        trackedEvents.delete(oldModel);\n                    }\n                }\n                return;\n            }\n\n            enti._emittedEvents[eventName] = emitKey;\n\n            var targetKey = getTargetKey(eventName),\n                value = isWildcardPath(targetKey) ? undefined : enti.get(targetKey);\n\n            enti.emit(eventName, value, event);\n        });\n    };\n}\n\nfunction trackPath(enti, eventName){\n    var object = enti._model,\n        trackedObjectPaths = trackedEvents.get(object);\n\n    if(!trackedObjectPaths){\n        trackedObjectPaths = {};\n        trackedEvents.set(object, trackedObjectPaths);\n    }\n\n    var trackedPaths = trackedObjectPaths[eventName];\n\n    if(!trackedPaths){\n        trackedPaths = {\n            entis: new Set(),\n            trackedObjects: new WeakSet()\n        };\n        trackedObjectPaths[eventName] = trackedPaths;\n    }else if(trackedPaths.entis.has(enti)){\n        return;\n    }\n\n    trackedPaths.entis.add(enti);\n\n    var handler = createHandler(enti, trackedObjectPaths, trackedPaths, eventName);\n\n    trackObjects(eventName, trackedPaths.trackedObjects, handler, {model:object}, 'model', eventName);\n}\n\nfunction trackPaths(enti){\n    if(!enti._events || !enti._model){\n        return;\n    }\n\n    for(var key in enti._events){\n        trackPath(enti, key);\n    }\n    modifiedEnties.delete(enti);\n}\n\nfunction emitEvent(object, key, value, emitKey){\n\n    modifiedEnties.forEach(trackPaths);\n\n    var trackedKeys = trackedObjects.get(object);\n\n    if(!trackedKeys){\n        return;\n    }\n\n    var event = {\n        value: value,\n        key: key,\n        object: object\n    };\n\n    function emitForKey(handler){\n        handler(event, emitKey);\n    }\n\n    if(trackedKeys[key]){\n        trackedKeys[key].forEach(emitForKey);\n    }\n\n    if(trackedKeys['*']){\n        trackedKeys['*'].forEach(emitForKey);\n    }\n}\n\nfunction emit(events){\n    var emitKey = {};\n    events.forEach(function(event){\n        emitEvent(event[0], event[1], event[2], emitKey);\n    });\n}\n\nfunction Enti(model){\n    var detached = model === false;\n\n    if(!model || (typeof model !== 'object' && typeof model !== 'function')){\n        model = {};\n    }\n\n    this._emittedEvents = {};\n    if(detached){\n        this._model = {};\n    }else{\n        this.attach(model);\n    }\n\n    this.on('newListener', function(){\n        modifiedEnties.add(this);\n    });\n}\nEnti.emit = function(model, key, value){\n    if(!(typeof model === 'object' || typeof model === 'function')){\n        return;\n    }\n\n    emit([[model, key, value]]);\n};\nEnti.get = function(model, key){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    if(key === '.'){\n        return model;\n    }\n\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.get(model[path[0]], path[1]);\n    }\n\n    return model[key];\n};\nEnti.set = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.set(model[path[0]], path[1], value);\n    }\n\n    var original = model[key];\n\n    if(typeof value !== 'object' && value === original){\n        return;\n    }\n\n    var keysChanged = !(key in model);\n\n    model[key] = value;\n\n    var events = [[model, key, value]];\n\n    if(keysChanged){\n        if(Array.isArray(model)){\n            events.push([model, 'length', model.length]);\n        }\n    }\n\n    emit(events);\n};\nEnti.push = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target;\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.push(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.push(value);\n\n    var events = [\n        [target, target.length-1, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.insert = function(model, key, value, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n\n    var target;\n    if(arguments.length < 4){\n        index = value;\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.insert(model[path[0]], path[1], value, index);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.splice(index, 0, value);\n\n    var events = [\n        [target, index, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.remove = function(model, key, subKey){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.remove(model[path[0]], path[1], subKey);\n    }\n\n    // Remove a key off of an object at 'key'\n    if(subKey != null){\n        Enti.remove(model[key], subKey);\n        return;\n    }\n\n    if(key === '.'){\n        throw '. (self) is not a valid key to remove';\n    }\n\n    var events = [];\n\n    if(Array.isArray(model)){\n        model.splice(key, 1);\n        events.push([model, 'length', model.length]);\n    }else{\n        delete model[key];\n        events.push([model, key]);\n    }\n\n    emit(events);\n};\nEnti.move = function(model, key, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.move(model[path[0]], path[1], index);\n    }\n\n    if(key === index){\n        return;\n    }\n\n    if(!Array.isArray(model)){\n        throw 'The model is not an array.';\n    }\n\n    var item = model[key];\n\n    model.splice(key, 1);\n\n    model.splice(index - (index > key ? 0 : 1), 0, item);\n\n    emit([[model, index, item]]);\n};\nEnti.update = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target,\n        isArray = Array.isArray(value);\n\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.update(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n\n        if(target == null){\n            model[key] = isArray ? [] : {};\n        }\n    }\n\n    if(typeof value !== 'object'){\n        throw 'The value is not an object.';\n    }\n\n    if(typeof target !== 'object'){\n        throw 'The target is not an object.';\n    }\n\n    var events = [],\n        updatedObjects = new WeakSet();\n\n    function updateTarget(target, value){\n        for(var key in value){\n            var currentValue = target[key];\n            if(currentValue instanceof Object && !updatedObjects.has(currentValue) && !(currentValue instanceof Date)){\n                updatedObjects.add(currentValue);\n                updateTarget(currentValue, value[key]);\n                continue;\n            }\n            target[key] = value[key];\n            events.push([target, key, value[key]]);\n        }\n\n        if(Array.isArray(target)){\n            events.push([target, 'length', target.length]);\n        }\n    }\n\n    updateTarget(target, value);\n\n    emit(events);\n};\nEnti.prototype = Object.create(EventEmitter.prototype);\nEnti.prototype._maxListeners = 100;\nEnti.prototype.constructor = Enti;\nEnti.prototype.attach = function(model){\n    if(this._model !== model){\n        this.detach();\n    }\n\n    if(model && !isInstance(model)){\n        throw 'Entis may only be attached to an object, or null/undefined';\n    }\n\n    modifiedEnties.add(this);\n    this._attached = true;\n    this._model = model;\n    this.emit('attach', model);\n};\nEnti.prototype.detach = function(){\n    modifiedEnties.delete(this);\n\n    this._emittedEvents = {};\n    this._model = {};\n    this._attached = false;\n    this.emit('detach');\n};\nEnti.prototype.destroy = function(){\n    this.detach();\n    this._events = null;\n    this.emit('destroy');\n};\nEnti.prototype.get = function(key){\n    return Enti.get(this._model, key);\n};\n\nEnti.prototype.set = function(key, value){\n    return Enti.set(this._model, key, value);\n};\n\nEnti.prototype.push = function(key, value){\n    return Enti.push.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.insert = function(key, value, index){\n    return Enti.insert.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.remove = function(key, subKey){\n    return Enti.remove.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.move = function(key, index){\n    return Enti.move.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.update = function(key, index){\n    return Enti.update.apply(null, [this._model].concat(toArray(arguments)));\n};\nEnti.prototype.isAttached = function(){\n    return this._attached;\n};\nEnti.prototype.attachedCount = function(){\n    return modifiedEnties.size;\n};\n\nEnti.isEnti = function(target){\n    return target && !!~globalState.instances.indexOf(target.constructor);\n};\n\nEnti.store = function(target, key, value){\n    if(arguments.length < 2){\n        return Enti.get(target, key);\n    }\n\n    Enti.set(target, key, value);\n};\n\nglobalState.instances.push(Enti);\n\nmodule.exports = Enti;\n"]} | |
},{"events":5,"is-instance":13}],13:[function(require,module,exports){ | |
module.exports = function(value){ | |
return value && typeof value === 'object' || typeof value === 'function'; | |
}; | |
},{}],14:[function(require,module,exports){ | |
var EventEmitter = require('events').EventEmitter, | |
functionEmitterPrototype = function(){}; | |
for(var key in EventEmitter.prototype){ | |
functionEmitterPrototype[key] = EventEmitter.prototype[key]; | |
} | |
module.exports = functionEmitterPrototype; | |
},{"events":5}],15:[function(require,module,exports){ | |
'use strict'; | |
var propIsEnumerable = Object.prototype.propertyIsEnumerable; | |
function ToObject(val) { | |
if (val == null) { | |
throw new TypeError('Object.assign cannot be called with null or undefined'); | |
} | |
return Object(val); | |
} | |
function ownEnumerableKeys(obj) { | |
var keys = Object.getOwnPropertyNames(obj); | |
if (Object.getOwnPropertySymbols) { | |
keys = keys.concat(Object.getOwnPropertySymbols(obj)); | |
} | |
return keys.filter(function (key) { | |
return propIsEnumerable.call(obj, key); | |
}); | |
} | |
module.exports = Object.assign || function (target, source) { | |
var from; | |
var keys; | |
var to = ToObject(target); | |
for (var s = 1; s < arguments.length; s++) { | |
from = arguments[s]; | |
keys = ownEnumerableKeys(Object(from)); | |
for (var i = 0; i < keys.length; i++) { | |
to[keys[i]] = from[keys[i]]; | |
} | |
} | |
return to; | |
}; | |
},{}],16:[function(require,module,exports){ | |
module.exports = function isSame(a, b){ | |
if(a === b){ | |
return true; | |
} | |
if( | |
typeof a !== typeof b || | |
typeof a === 'object' && | |
!(a instanceof Date && b instanceof Date) | |
){ | |
return false; | |
} | |
return String(a) === String(b); | |
}; | |
},{}],17:[function(require,module,exports){ | |
module.exports = Object.setPrototypeOf || ({__proto__:[]} instanceof Array ? setProtoOf : mixinProperties); | |
function setProtoOf(obj, proto) { | |
obj.__proto__ = proto; | |
} | |
function mixinProperties(obj, proto) { | |
for (var prop in proto) { | |
obj[prop] = proto[prop]; | |
} | |
} | |
},{}],18:[function(require,module,exports){ | |
var clone = require('clone'), | |
deepEqual = require('cyclic-deep-equal'); | |
function keysAreDifferent(keys1, keys2){ | |
if(keys1 === keys2){ | |
return; | |
} | |
if(!keys1 || !keys2 || keys1.length !== keys2.length){ | |
return true; | |
} | |
for(var i = 0; i < keys1.length; i++){ | |
if(!~keys2.indexOf(keys1[i])){ | |
return true; | |
} | |
} | |
} | |
function getKeys(value){ | |
if(!value || typeof value !== 'object'){ | |
return; | |
} | |
return Object.keys(value); | |
} | |
function WhatChanged(value, changesToTrack){ | |
this._changesToTrack = {}; | |
if(changesToTrack == null){ | |
changesToTrack = 'value type keys structure reference'; | |
} | |
if(typeof changesToTrack !== 'string'){ | |
throw 'changesToTrack must be of type string'; | |
} | |
changesToTrack = changesToTrack.split(' '); | |
for (var i = 0; i < changesToTrack.length; i++) { | |
this._changesToTrack[changesToTrack[i]] = true; | |
}; | |
this.update(value); | |
} | |
WhatChanged.prototype.update = function(value){ | |
var result = {}, | |
changesToTrack = this._changesToTrack, | |
newKeys = getKeys(value); | |
if('value' in changesToTrack && value+'' !== this._lastReference+''){ | |
result.value = true; | |
} | |
if( | |
'type' in changesToTrack && typeof value !== typeof this._lastValue || | |
(value === null || this._lastValue === null) && this.value !== this._lastValue // typeof null === 'object' | |
){ | |
result.type = true; | |
} | |
if('keys' in changesToTrack && keysAreDifferent(this._lastKeys, getKeys(value))){ | |
result.keys = true; | |
} | |
if(value !== null && typeof value === 'object' || typeof value === 'function'){ | |
var lastValue = this._lastValue; | |
if('shallowStructure' in changesToTrack && (!lastValue || typeof lastValue !== 'object' || Object.keys(value).some(function(key, index){ | |
return value[key] !== lastValue[key]; | |
}))){ | |
result.shallowStructure = true; | |
} | |
if('structure' in changesToTrack && !deepEqual(value, lastValue)){ | |
result.structure = true; | |
} | |
if('reference' in changesToTrack && value !== this._lastReference){ | |
result.reference = true; | |
} | |
} | |
this._lastValue = 'structure' in changesToTrack ? clone(value) : 'shallowStructure' in changesToTrack ? clone(value, true, 1): value; | |
this._lastReference = value; | |
this._lastKeys = newKeys; | |
return result; | |
}; | |
module.exports = WhatChanged; | |
},{"clone":19,"cyclic-deep-equal":20}],19:[function(require,module,exports){ | |
(function (Buffer){ | |
var clone = (function() { | |
'use strict'; | |
/** | |
* Clones (copies) an Object using deep copying. | |
* | |
* This function supports circular references by default, but if you are certain | |
* there are no circular references in your object, you can save some CPU time | |
* by calling clone(obj, false). | |
* | |
* Caution: if `circular` is false and `parent` contains circular references, | |
* your program may enter an infinite loop and crash. | |
* | |
* @param `parent` - the object to be cloned | |
* @param `circular` - set to true if the object to be cloned may contain | |
* circular references. (optional - true by default) | |
* @param `depth` - set to a number if the object is only to be cloned to | |
* a particular depth. (optional - defaults to Infinity) | |
* @param `prototype` - sets the prototype to be used when cloning an object. | |
* (optional - defaults to parent prototype). | |
*/ | |
function clone(parent, circular, depth, prototype) { | |
var filter; | |
if (typeof circular === 'object') { | |
depth = circular.depth; | |
prototype = circular.prototype; | |
filter = circular.filter; | |
circular = circular.circular | |
} | |
// maintain two arrays for circular references, where corresponding parents | |
// and children have the same index | |
var allParents = []; | |
var allChildren = []; | |
var useBuffer = typeof Buffer != 'undefined'; | |
if (typeof circular == 'undefined') | |
circular = true; | |
if (typeof depth == 'undefined') | |
depth = Infinity; | |
// recurse this function so we don't reset allParents and allChildren | |
function _clone(parent, depth) { | |
// cloning null always returns null | |
if (parent === null) | |
return null; | |
if (depth == 0) | |
return parent; | |
var child; | |
var proto; | |
if (typeof parent != 'object') { | |
return parent; | |
} | |
if (clone.__isArray(parent)) { | |
child = []; | |
} else if (clone.__isRegExp(parent)) { | |
child = new RegExp(parent.source, __getRegExpFlags(parent)); | |
if (parent.lastIndex) child.lastIndex = parent.lastIndex; | |
} else if (clone.__isDate(parent)) { | |
child = new Date(parent.getTime()); | |
} else if (useBuffer && Buffer.isBuffer(parent)) { | |
child = new Buffer(parent.length); | |
parent.copy(child); | |
return child; | |
} else { | |
if (typeof prototype == 'undefined') { | |
proto = Object.getPrototypeOf(parent); | |
child = Object.create(proto); | |
} | |
else { | |
child = Object.create(prototype); | |
proto = prototype; | |
} | |
} | |
if (circular) { | |
var index = allParents.indexOf(parent); | |
if (index != -1) { | |
return allChildren[index]; | |
} | |
allParents.push(parent); | |
allChildren.push(child); | |
} | |
for (var i in parent) { | |
var attrs; | |
if (proto) { | |
attrs = Object.getOwnPropertyDescriptor(proto, i); | |
} | |
if (attrs && attrs.set == null) { | |
continue; | |
} | |
child[i] = _clone(parent[i], depth - 1); | |
} | |
return child; | |
} | |
return _clone(parent, depth); | |
} | |
/** | |
* Simple flat clone using prototype, accepts only objects, usefull for property | |
* override on FLAT configuration object (no nested props). | |
* | |
* USE WITH CAUTION! This may not behave as you wish if you do not know how this | |
* works. | |
*/ | |
clone.clonePrototype = function clonePrototype(parent) { | |
if (parent === null) | |
return null; | |
var c = function () {}; | |
c.prototype = parent; | |
return new c(); | |
}; | |
// private utility functions | |
function __objToStr(o) { | |
return Object.prototype.toString.call(o); | |
}; | |
clone.__objToStr = __objToStr; | |
function __isDate(o) { | |
return typeof o === 'object' && __objToStr(o) === '[object Date]'; | |
}; | |
clone.__isDate = __isDate; | |
function __isArray(o) { | |
return typeof o === 'object' && __objToStr(o) === '[object Array]'; | |
}; | |
clone.__isArray = __isArray; | |
function __isRegExp(o) { | |
return typeof o === 'object' && __objToStr(o) === '[object RegExp]'; | |
}; | |
clone.__isRegExp = __isRegExp; | |
function __getRegExpFlags(re) { | |
var flags = ''; | |
if (re.global) flags += 'g'; | |
if (re.ignoreCase) flags += 'i'; | |
if (re.multiline) flags += 'm'; | |
return flags; | |
}; | |
clone.__getRegExpFlags = __getRegExpFlags; | |
return clone; | |
})(); | |
if (typeof module === 'object' && module.exports) { | |
module.exports = clone; | |
} | |
}).call(this,require("buffer").Buffer) | |
//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy93aGF0LWNoYW5nZWQvbm9kZV9tb2R1bGVzL2Nsb25lL2Nsb25lLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgY2xvbmUgPSAoZnVuY3Rpb24oKSB7XG4ndXNlIHN0cmljdCc7XG5cbi8qKlxuICogQ2xvbmVzIChjb3BpZXMpIGFuIE9iamVjdCB1c2luZyBkZWVwIGNvcHlpbmcuXG4gKlxuICogVGhpcyBmdW5jdGlvbiBzdXBwb3J0cyBjaXJjdWxhciByZWZlcmVuY2VzIGJ5IGRlZmF1bHQsIGJ1dCBpZiB5b3UgYXJlIGNlcnRhaW5cbiAqIHRoZXJlIGFyZSBubyBjaXJjdWxhciByZWZlcmVuY2VzIGluIHlvdXIgb2JqZWN0LCB5b3UgY2FuIHNhdmUgc29tZSBDUFUgdGltZVxuICogYnkgY2FsbGluZyBjbG9uZShvYmosIGZhbHNlKS5cbiAqXG4gKiBDYXV0aW9uOiBpZiBgY2lyY3VsYXJgIGlzIGZhbHNlIGFuZCBgcGFyZW50YCBjb250YWlucyBjaXJjdWxhciByZWZlcmVuY2VzLFxuICogeW91ciBwcm9ncmFtIG1heSBlbnRlciBhbiBpbmZpbml0ZSBsb29wIGFuZCBjcmFzaC5cbiAqXG4gKiBAcGFyYW0gYHBhcmVudGAgLSB0aGUgb2JqZWN0IHRvIGJlIGNsb25lZFxuICogQHBhcmFtIGBjaXJjdWxhcmAgLSBzZXQgdG8gdHJ1ZSBpZiB0aGUgb2JqZWN0IHRvIGJlIGNsb25lZCBtYXkgY29udGFpblxuICogICAgY2lyY3VsYXIgcmVmZXJlbmNlcy4gKG9wdGlvbmFsIC0gdHJ1ZSBieSBkZWZhdWx0KVxuICogQHBhcmFtIGBkZXB0aGAgLSBzZXQgdG8gYSBudW1iZXIgaWYgdGhlIG9iamVjdCBpcyBvbmx5IHRvIGJlIGNsb25lZCB0b1xuICogICAgYSBwYXJ0aWN1bGFyIGRlcHRoLiAob3B0aW9uYWwgLSBkZWZhdWx0cyB0byBJbmZpbml0eSlcbiAqIEBwYXJhbSBgcHJvdG90eXBlYCAtIHNldHMgdGhlIHByb3RvdHlwZSB0byBiZSB1c2VkIHdoZW4gY2xvbmluZyBhbiBvYmplY3QuXG4gKiAgICAob3B0aW9uYWwgLSBkZWZhdWx0cyB0byBwYXJlbnQgcHJvdG90eXBlKS5cbiovXG5mdW5jdGlvbiBjbG9uZShwYXJlbnQsIGNpcmN1bGFyLCBkZXB0aCwgcHJvdG90eXBlKSB7XG4gIHZhciBmaWx0ZXI7XG4gIGlmICh0eXBlb2YgY2lyY3VsYXIgPT09ICdvYmplY3QnKSB7XG4gICAgZGVwdGggPSBjaXJjdWxhci5kZXB0aDtcbiAgICBwcm90b3R5cGUgPSBjaXJjdWxhci5wcm90b3R5cGU7XG4gICAgZmlsdGVyID0gY2lyY3VsYXIuZmlsdGVyO1xuICAgIGNpcmN1bGFyID0gY2lyY3VsYXIuY2lyY3VsYXJcbiAgfVxuICAvLyBtYWludGFpbiB0d28gYXJyYXlzIGZvciBjaXJjdWxhciByZWZlcmVuY2VzLCB3aGVyZSBjb3JyZXNwb25kaW5nIHBhcmVudHNcbiAgLy8gYW5kIGNoaWxkcmVuIGhhdmUgdGhlIHNhbWUgaW5kZXhcbiAgdmFyIGFsbFBhcmVudHMgPSBbXTtcbiAgdmFyIGFsbENoaWxkcmVuID0gW107XG5cbiAgdmFyIHVzZUJ1ZmZlciA9IHR5cGVvZiBCdWZmZXIgIT0gJ3VuZGVmaW5lZCc7XG5cbiAgaWYgKHR5cGVvZiBjaXJjdWxhciA9PSAndW5kZWZpbmVkJylcbiAgICBjaXJjdWxhciA9IHRydWU7XG5cbiAgaWYgKHR5cGVvZiBkZXB0aCA9PSAndW5kZWZpbmVkJylcbiAgICBkZXB0aCA9IEluZmluaXR5O1xuXG4gIC8vIHJlY3Vyc2UgdGhpcyBmdW5jdGlvbiBzbyB3ZSBkb24ndCByZXNldCBhbGxQYXJlbnRzIGFuZCBhbGxDaGlsZHJlblxuICBmdW5jdGlvbiBfY2xvbmUocGFyZW50LCBkZXB0aCkge1xuICAgIC8vIGNsb25pbmcgbnVsbCBhbHdheXMgcmV0dXJucyBudWxsXG4gICAgaWYgKHBhcmVudCA9PT0gbnVsbClcbiAgICAgIHJldHVybiBudWxsO1xuXG4gICAgaWYgKGRlcHRoID09IDApXG4gICAgICByZXR1cm4gcGFyZW50O1xuXG4gICAgdmFyIGNoaWxkO1xuICAgIHZhciBwcm90bztcbiAgICBpZiAodHlwZW9mIHBhcmVudCAhPSAnb2JqZWN0Jykge1xuICAgICAgcmV0dXJuIHBhcmVudDtcbiAgICB9XG5cbiAgICBpZiAoY2xvbmUuX19pc0FycmF5KHBhcmVudCkpIHtcbiAgICAgIGNoaWxkID0gW107XG4gICAgfSBlbHNlIGlmIChjbG9uZS5fX2lzUmVnRXhwKHBhcmVudCkpIHtcbiAgICAgIGNoaWxkID0gbmV3IFJlZ0V4cChwYXJlbnQuc291cmNlLCBfX2dldFJlZ0V4cEZsYWdzKHBhcmVudCkpO1xuICAgICAgaWYgKHBhcmVudC5sYXN0SW5kZXgpIGNoaWxkLmxhc3RJbmRleCA9IHBhcmVudC5sYXN0SW5kZXg7XG4gICAgfSBlbHNlIGlmIChjbG9uZS5fX2lzRGF0ZShwYXJlbnQpKSB7XG4gICAgICBjaGlsZCA9IG5ldyBEYXRlKHBhcmVudC5nZXRUaW1lKCkpO1xuICAgIH0gZWxzZSBpZiAodXNlQnVmZmVyICYmIEJ1ZmZlci5pc0J1ZmZlcihwYXJlbnQpKSB7XG4gICAgICBjaGlsZCA9IG5ldyBCdWZmZXIocGFyZW50Lmxlbmd0aCk7XG4gICAgICBwYXJlbnQuY29weShjaGlsZCk7XG4gICAgICByZXR1cm4gY2hpbGQ7XG4gICAgfSBlbHNlIHtcbiAgICAgIGlmICh0eXBlb2YgcHJvdG90eXBlID09ICd1bmRlZmluZWQnKSB7XG4gICAgICAgIHByb3RvID0gT2JqZWN0LmdldFByb3RvdHlwZU9mKHBhcmVudCk7XG4gICAgICAgIGNoaWxkID0gT2JqZWN0LmNyZWF0ZShwcm90byk7XG4gICAgICB9XG4gICAgICBlbHNlIHtcbiAgICAgICAgY2hpbGQgPSBPYmplY3QuY3JlYXRlKHByb3RvdHlwZSk7XG4gICAgICAgIHByb3RvID0gcHJvdG90eXBlO1xuICAgICAgfVxuICAgIH1cblxuICAgIGlmIChjaXJjdWxhcikge1xuICAgICAgdmFyIGluZGV4ID0gYWxsUGFyZW50cy5pbmRleE9mKHBhcmVudCk7XG5cbiAgICAgIGlmIChpbmRleCAhPSAtMSkge1xuICAgICAgICByZXR1cm4gYWxsQ2hpbGRyZW5baW5kZXhdO1xuICAgICAgfVxuICAgICAgYWxsUGFyZW50cy5wdXNoKHBhcmVudCk7XG4gICAgICBhbGxDaGlsZHJlbi5wdXNoKGNoaWxkKTtcbiAgICB9XG5cbiAgICBmb3IgKHZhciBpIGluIHBhcmVudCkge1xuICAgICAgdmFyIGF0dHJzO1xuICAgICAgaWYgKHByb3RvKSB7XG4gICAgICAgIGF0dHJzID0gT2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcihwcm90bywgaSk7XG4gICAgICB9XG5cbiAgICAgIGlmIChhdHRycyAmJiBhdHRycy5zZXQgPT0gbnVsbCkge1xuICAgICAgICBjb250aW51ZTtcbiAgICAgIH1cbiAgICAgIGNoaWxkW2ldID0gX2Nsb25lKHBhcmVudFtpXSwgZGVwdGggLSAxKTtcbiAgICB9XG5cbiAgICByZXR1cm4gY2hpbGQ7XG4gIH1cblxuICByZXR1cm4gX2Nsb25lKHBhcmVudCwgZGVwdGgpO1xufVxuXG4vKipcbiAqIFNpbXBsZSBmbGF0IGNsb25lIHVzaW5nIHByb3RvdHlwZSwgYWNjZXB0cyBvbmx5IG9iamVjdHMsIHVzZWZ1bGwgZm9yIHByb3BlcnR5XG4gKiBvdmVycmlkZSBvbiBGTEFUIGNvbmZpZ3VyYXRpb24gb2JqZWN0IChubyBuZXN0ZWQgcHJvcHMpLlxuICpcbiAqIFVTRSBXSVRIIENBVVRJT04hIFRoaXMgbWF5IG5vdCBiZWhhdmUgYXMgeW91IHdpc2ggaWYgeW91IGRvIG5vdCBrbm93IGhvdyB0aGlzXG4gKiB3b3Jrcy5cbiAqL1xuY2xvbmUuY2xvbmVQcm90b3R5cGUgPSBmdW5jdGlvbiBjbG9uZVByb3RvdHlwZShwYXJlbnQpIHtcbiAgaWYgKHBhcmVudCA9PT0gbnVsbClcbiAgICByZXR1cm4gbnVsbDtcblxuICB2YXIgYyA9IGZ1bmN0aW9uICgpIHt9O1xuICBjLnByb3RvdHlwZSA9IHBhcmVudDtcbiAgcmV0dXJuIG5ldyBjKCk7XG59O1xuXG4vLyBwcml2YXRlIHV0aWxpdHkgZnVuY3Rpb25zXG5cbmZ1bmN0aW9uIF9fb2JqVG9TdHIobykge1xuICByZXR1cm4gT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKG8pO1xufTtcbmNsb25lLl9fb2JqVG9TdHIgPSBfX29ialRvU3RyO1xuXG5mdW5jdGlvbiBfX2lzRGF0ZShvKSB7XG4gIHJldHVybiB0eXBlb2YgbyA9PT0gJ29iamVjdCcgJiYgX19vYmpUb1N0cihvKSA9PT0gJ1tvYmplY3QgRGF0ZV0nO1xufTtcbmNsb25lLl9faXNEYXRlID0gX19pc0RhdGU7XG5cbmZ1bmN0aW9uIF9faXNBcnJheShvKSB7XG4gIHJldHVybiB0eXBlb2YgbyA9PT0gJ29iamVjdCcgJiYgX19vYmpUb1N0cihvKSA9PT0gJ1tvYmplY3QgQXJyYXldJztcbn07XG5jbG9uZS5fX2lzQXJyYXkgPSBfX2lzQXJyYXk7XG5cbmZ1bmN0aW9uIF9faXNSZWdFeHAobykge1xuICByZXR1cm4gdHlwZW9mIG8gPT09ICdvYmplY3QnICYmIF9fb2JqVG9TdHIobykgPT09ICdbb2JqZWN0IFJlZ0V4cF0nO1xufTtcbmNsb25lLl9faXNSZWdFeHAgPSBfX2lzUmVnRXhwO1xuXG5mdW5jdGlvbiBfX2dldFJlZ0V4cEZsYWdzKHJlKSB7XG4gIHZhciBmbGFncyA9ICcnO1xuICBpZiAocmUuZ2xvYmFsKSBmbGFncyArPSAnZyc7XG4gIGlmIChyZS5pZ25vcmVDYXNlKSBmbGFncyArPSAnaSc7XG4gIGlmIChyZS5tdWx0aWxpbmUpIGZsYWdzICs9ICdtJztcbiAgcmV0dXJuIGZsYWdzO1xufTtcbmNsb25lLl9fZ2V0UmVnRXhwRmxhZ3MgPSBfX2dldFJlZ0V4cEZsYWdzO1xuXG5yZXR1cm4gY2xvbmU7XG59KSgpO1xuXG5pZiAodHlwZW9mIG1vZHVsZSA9PT0gJ29iamVjdCcgJiYgbW9kdWxlLmV4cG9ydHMpIHtcbiAgbW9kdWxlLmV4cG9ydHMgPSBjbG9uZTtcbn1cbiJdfQ== | |
},{"buffer":1}],20:[function(require,module,exports){ | |
function compare(a, b, visited){ | |
var aType = typeof a; | |
if(aType !== typeof b){ | |
return false; | |
} | |
if(a == null || b == null || !(aType === 'object' || aType === 'function')){ | |
if(aType === 'number' && isNaN(a) && isNaN(b)){ | |
return true; | |
} | |
return a === b; | |
} | |
if(Array.isArray(a) !== Array.isArray(b)){ | |
return false; | |
} | |
var aKeys = Object.keys(a), | |
bKeys = Object.keys(b); | |
if(aKeys.length !== bKeys.length){ | |
return false; | |
} | |
var equal = true; | |
if(!visited){ | |
visited = new Set(); | |
} | |
aKeys.forEach(function(key){ | |
if(!(key in b)){ | |
equal = false; | |
return; | |
} | |
if(visited.has(a[key])){ | |
return; | |
} | |
visited.add(a[key]); | |
if(!compare(a[key], b[key], visited)){ | |
equal = false; | |
return; | |
} | |
}); | |
return equal; | |
}; | |
module.exports = function(a, b){ | |
return compare(a, b); | |
} | |
},{}],21:[function(require,module,exports){ | |
var WhatChanged = require('what-changed'), | |
same = require('same-value'), | |
firmer = require('./firmer'), | |
functionEmitter = require('function-emitter'), | |
setPrototypeOf = require('setprototypeof'); | |
var propertyProto = Object.create(functionEmitter); | |
propertyProto._fastn_property = true; | |
propertyProto._firm = 1; | |
function propertyTemplate(value){ | |
if(!arguments.length){ | |
return this.binding && this.binding() || this.property._value; | |
} | |
if(!this.destroyed){ | |
if(this.binding){ | |
this.binding(value); | |
return this.property; | |
} | |
this.valueUpdate(value); | |
} | |
return this.property; | |
} | |
function changeChecker(current, changes){ | |
if(changes){ | |
var changes = new WhatChanged(current, changes); | |
return function(value){ | |
return Object.keys(changes.update(value)).length > 0; | |
}; | |
}else{ | |
var lastValue = current; | |
return function(newValue){ | |
if(!same(lastValue, newValue)){ | |
lastValue = newValue; | |
return true; | |
} | |
}; | |
} | |
} | |
function propertyBinding(newBinding){ | |
if(!arguments.length){ | |
return this.binding; | |
} | |
if(!this.fastn.isBinding(newBinding)){ | |
newBinding = this.fastn.binding(newBinding); | |
} | |
if(newBinding === this.binding){ | |
return this.property; | |
} | |
if(this.binding){ | |
this.binding.removeListener('change', this.valueUpdate); | |
} | |
this.binding = newBinding; | |
if(this.model){ | |
this.property.attach(this.model, this.property._firm); | |
} | |
this.binding.on('change', this.valueUpdate); | |
this.valueUpdate(this.binding()); | |
return this.property; | |
}; | |
function attachProperty(object, firm){ | |
if(firmer(this.property, firm)){ | |
return this.property; | |
} | |
this.property._firm = firm; | |
if(!(object instanceof Object)){ | |
object = {}; | |
} | |
if(this.binding){ | |
this.model = object; | |
this.binding.attach(object, 1); | |
} | |
if(this.property._events && 'attach' in this.property._events){ | |
this.property.emit('attach', object, 1); | |
} | |
return this.property; | |
}; | |
function detachProperty(firm){ | |
if(firmer(this.property, firm)){ | |
return this.property; | |
} | |
if(this.binding){ | |
this.binding.removeListener('change', this.valueUpdate); | |
this.binding.detach(1); | |
this.model = null; | |
} | |
if(this.property._events && 'detach' in this.property._events){ | |
this.property.emit('detach', 1); | |
} | |
return this.property; | |
}; | |
function updateProperty(){ | |
if(!this.destroyed){ | |
if(this.property._update){ | |
this.property._update(this.property._value, this.property); | |
} | |
this.property.emit('update', this.property._value); | |
} | |
return this.property; | |
}; | |
function propertyUpdater(fn){ | |
if(!arguments.length){ | |
return this.property._update; | |
} | |
this.property._update = fn; | |
return this.property; | |
}; | |
function destroyProperty(){ | |
if(!this.destroyed){ | |
this.destroyed = true; | |
this.property | |
.removeAllListeners('change') | |
.removeAllListeners('update') | |
.removeAllListeners('attach'); | |
this.property.emit('destroy'); | |
this.property.detach(); | |
if(this.binding){ | |
this.binding.destroy(true); | |
} | |
} | |
return this.property; | |
}; | |
function propertyDestroyed(){ | |
return this.destroyed; | |
}; | |
function addPropertyTo(component, key){ | |
component.setProperty(key, this.property); | |
return this.property; | |
}; | |
function createProperty(currentValue, changes, updater){ | |
if(typeof changes === 'function'){ | |
updater = changes; | |
changes = null; | |
} | |
var propertyScope = | |
property = propertyTemplate.bind(propertyScope) | |
propertyScope = { | |
fastn: this, | |
hasChanged: changeChecker(currentValue, changes), | |
valueUpdate: function(value){ | |
property._value = value; | |
if(!propertyScope.hasChanged(value)){ | |
return; | |
} | |
property.emit('change', property._value); | |
property.update(); | |
} | |
}; | |
var property = propertyScope.property = propertyTemplate.bind(propertyScope); | |
property._value = currentValue; | |
property._update = updater; | |
setPrototypeOf(property, propertyProto); | |
property.binding = propertyBinding.bind(propertyScope); | |
property.attach = attachProperty.bind(propertyScope); | |
property.detach = detachProperty.bind(propertyScope); | |
property.update = updateProperty.bind(propertyScope); | |
property.updater = propertyUpdater.bind(propertyScope); | |
property.destroy = destroyProperty.bind(propertyScope); | |
property.destroyed = propertyDestroyed.bind(propertyScope); | |
property.addTo = addPropertyTo.bind(propertyScope); | |
return property; | |
}; | |
module.exports = createProperty; | |
},{"./firmer":9,"function-emitter":14,"same-value":16,"setprototypeof":17,"what-changed":18}],"fastn":[function(require,module,exports){ | |
var createProperty = require('./property'), | |
createBinding = require('./binding'), | |
BaseComponent = require('./baseComponent'), | |
crel = require('crel'), | |
Enti = require('enti'), | |
objectAssign = require('object-assign'), | |
is = require('./is'); | |
function inflateProperties(component, settings){ | |
for(var key in settings){ | |
var setting = settings[key], | |
property = component[key]; | |
if(is.property(settings[key])){ | |
if(is.property(property)){ | |
property.destroy(); | |
} | |
setting.addTo(component, key); | |
}else if(is.property(property)){ | |
if(is.binding(setting)){ | |
property.binding(setting); | |
}else{ | |
property(setting); | |
} | |
property.addTo(component, key); | |
} | |
} | |
} | |
function validateExpectedComponents(components, componentName, expectedComponents){ | |
expectedComponents = expectedComponents.filter(function(componentName){ | |
return !(componentName in components); | |
}); | |
if(expectedComponents.length){ | |
console.warn([ | |
'fastn("' + componentName + '") uses some components that have not been registered with fastn', | |
'Expected conponent constructors: ' + expectedComponents.join(', ') | |
].join('\n\n')); | |
} | |
} | |
module.exports = function(components, debug){ | |
if(!components || typeof components !== 'object'){ | |
throw new Error('fastn must be initialised with a components object'); | |
} | |
components._container = components._container || require('./containerComponent'); | |
function fastn(type){ | |
var args = []; | |
for(var i = 0; i < arguments.length; i++){ | |
args[i] = arguments[i]; | |
} | |
var settings = args[1], | |
childrenIndex = 2, | |
settingsChild = fastn.toComponent(args[1]); | |
if(Array.isArray(args[1]) || settingsChild || !args[1]){ | |
args[1] = settingsChild || args[1]; | |
childrenIndex--; | |
settings = null; | |
} | |
settings = objectAssign({}, settings || {}); | |
var types = typeof type === 'string' ? type.split(':') : Array.isArray(type) ? type : [type], | |
baseType, | |
children = args.slice(childrenIndex), | |
component = fastn.base(type, settings, children); | |
while(baseType = types.shift()){ | |
component.extend(baseType, settings, children); | |
} | |
component._properties = {}; | |
inflateProperties(component, settings); | |
return component; | |
} | |
fastn.toComponent = function(component){ | |
if(component == null){ | |
return; | |
} | |
if(is.component(component)){ | |
return component; | |
} | |
if(typeof component !== 'object' || component instanceof Date){ | |
return fastn('text', {auto: true}, component); | |
} | |
if(crel.isElement(component)){ | |
return fastn(component); | |
} | |
if(crel.isNode(component)){ | |
return fastn('text', {auto: true}, component.textContent); | |
} | |
}; | |
fastn.debug = debug; | |
fastn.property = createProperty.bind(fastn); | |
fastn.binding = createBinding(fastn); | |
fastn.isComponent = is.component; | |
fastn.isBinding = is.binding; | |
fastn.isDefaultBinding = is.defaultBinding; | |
fastn.isBindingObject = is.bindingObject; | |
fastn.isProperty = is.property; | |
fastn.components = components; | |
fastn.Model = Enti; | |
fastn.isModel = Enti.isEnti.bind(Enti); | |
fastn.base = function(type, settings, children){ | |
return new BaseComponent(fastn, type, settings, children); | |
}; | |
for(var key in components){ | |
var componentConstructor = components[key]; | |
if(componentConstructor.expectedComponents){ | |
validateExpectedComponents(components, key, componentConstructor.expectedComponents); | |
} | |
} | |
return fastn; | |
}; | |
},{"./baseComponent":6,"./binding":7,"./containerComponent":8,"./is":10,"./property":21,"crel":11,"enti":12,"object-assign":15}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/index.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/node_modules/base64-js/lib/b64.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/node_modules/ieee754/index.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/node_modules/isarray/index.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/events/events.js","baseComponent.js","binding.js","containerComponent.js","firmer.js","is.js","node_modules/crel/crel.js","node_modules/enti/index.js","node_modules/enti/node_modules/is-instance/index.js","node_modules/function-emitter/index.js","node_modules/object-assign/index.js","node_modules/same-value/index.js","node_modules/setprototypeof/index.js","node_modules/what-changed/index.js","node_modules/what-changed/node_modules/clone/clone.js","node_modules/what-changed/node_modules/cyclic-deep-equal/index.js","property.js","index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/gDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/IA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7mBA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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})","(function (global){\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192 // not used by this implementation\n\nvar rootParent = {}\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property\n *     on objects.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\nfunction typedArraySupport () {\n  function Bar () {}\n  try {\n    var arr = new Uint8Array(1)\n    arr.foo = function () { return 42 }\n    arr.constructor = Bar\n    return arr.foo() === 42 && // typed array instances can be augmented\n        arr.constructor === Bar && // constructor can be set\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (arg) {\n  if (!(this instanceof Buffer)) {\n    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.\n    if (arguments.length > 1) return new Buffer(arg, arguments[1])\n    return new Buffer(arg)\n  }\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    this.length = 0\n    this.parent = undefined\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    return fromNumber(this, arg)\n  }\n\n  // Slightly less common case.\n  if (typeof arg === 'string') {\n    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')\n  }\n\n  // Unusual.\n  return fromObject(this, arg)\n}\n\nfunction fromNumber (that, length) {\n  that = allocate(that, length < 0 ? 0 : checked(length) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < length; i++) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'\n\n  // Assumption: byteLength() return value is always < kMaxLength.\n  var length = byteLength(string, encoding) | 0\n  that = allocate(that, length)\n\n  that.write(string, encoding)\n  return that\n}\n\nfunction fromObject (that, object) {\n  if (Buffer.isBuffer(object)) return fromBuffer(that, object)\n\n  if (isArray(object)) return fromArray(that, object)\n\n  if (object == null) {\n    throw new TypeError('must start with number, buffer, array or string')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined') {\n    if (object.buffer instanceof ArrayBuffer) {\n      return fromTypedArray(that, object)\n    }\n    if (object instanceof ArrayBuffer) {\n      return fromArrayBuffer(that, object)\n    }\n  }\n\n  if (object.length) return fromArrayLike(that, object)\n\n  return fromJsonObject(that, object)\n}\n\nfunction fromBuffer (that, buffer) {\n  var length = checked(buffer.length) | 0\n  that = allocate(that, length)\n  buffer.copy(that, 0, 0, length)\n  return that\n}\n\nfunction fromArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Duplicate of fromArray() to keep fromArray() monomorphic.\nfunction fromTypedArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  // Truncating the elements is probably not what people expect from typed\n  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior\n  // of the old Buffer constructor.\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    array.byteLength\n    that = Buffer._augment(new Uint8Array(array))\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromTypedArray(that, new Uint8Array(array))\n  }\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.\n// Returns a zero-length buffer for inputs that don't conform to the spec.\nfunction fromJsonObject (that, object) {\n  var array\n  var length = 0\n\n  if (object.type === 'Buffer' && isArray(object.data)) {\n    array = object.data\n    length = checked(array.length) | 0\n  }\n  that = allocate(that, length)\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n} else {\n  // pre-set for values that may exist in the future\n  Buffer.prototype.length = undefined\n  Buffer.prototype.parent = undefined\n}\n\nfunction allocate (that, length) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = Buffer._augment(new Uint8Array(length))\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that.length = length\n    that._isBuffer = true\n  }\n\n  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1\n  if (fromPool) that.parent = rootParent\n\n  return that\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (subject, encoding) {\n  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)\n\n  var buf = new Buffer(subject, encoding)\n  delete buf.parent\n  return buf\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  var i = 0\n  var len = Math.min(x, y)\n  while (i < len) {\n    if (a[i] !== b[i]) break\n\n    ++i\n  }\n\n  if (i !== len) {\n    x = a[i]\n    y = b[i]\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; i++) {\n      length += list[i].length\n    }\n  }\n\n  var buf = new Buffer(length)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\nfunction byteLength (string, encoding) {\n  if (typeof string !== 'string') string = '' + string\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'binary':\n      // Deprecated\n      case 'raw':\n      case 'raws':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  start = start | 0\n  end = end === undefined || end === Infinity ? this.length : end | 0\n\n  if (!encoding) encoding = 'utf8'\n  if (start < 0) start = 0\n  if (end > this.length) end = this.length\n  if (end <= start) return ''\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'binary':\n        return binarySlice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return 0\n  return Buffer.compare(this, b)\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset) {\n  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff\n  else if (byteOffset < -0x80000000) byteOffset = -0x80000000\n  byteOffset >>= 0\n\n  if (this.length === 0) return -1\n  if (byteOffset >= this.length) return -1\n\n  // Negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)\n\n  if (typeof val === 'string') {\n    if (val.length === 0) return -1 // special case: looking for empty string always fails\n    return String.prototype.indexOf.call(this, val, byteOffset)\n  }\n  if (Buffer.isBuffer(val)) {\n    return arrayIndexOf(this, val, byteOffset)\n  }\n  if (typeof val === 'number') {\n    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {\n      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)\n    }\n    return arrayIndexOf(this, [ val ], byteOffset)\n  }\n\n  function arrayIndexOf (arr, val, byteOffset) {\n    var foundIndex = -1\n    for (var i = 0; byteOffset + i < arr.length; i++) {\n      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex\n      } else {\n        foundIndex = -1\n      }\n    }\n    return -1\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\n// `get` is deprecated\nBuffer.prototype.get = function get (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` is deprecated\nBuffer.prototype.set = function set (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new Error('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) throw new Error('Invalid hex string')\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction binaryWrite (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    var swap = encoding\n    encoding = offset\n    offset = length | 0\n    length = swap\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'binary':\n        return binaryWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction binarySlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  if (newBuf.length) newBuf.parent = this.parent || this\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n  if (offset < 0) throw new RangeError('index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; i--) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; i++) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    target._set(this.subarray(start, start + len), targetStart)\n  }\n\n  return len\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function fill (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (end < start) throw new RangeError('end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')\n  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')\n\n  var i\n  if (typeof value === 'number') {\n    for (i = start; i < end; i++) {\n      this[i] = value\n    }\n  } else {\n    var bytes = utf8ToBytes(value.toString())\n    var len = bytes.length\n    for (i = start; i < end; i++) {\n      this[i] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function toArrayBuffer () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1) {\n        buf[i] = this[i]\n      }\n      return buf.buffer\n    }\n  } else {\n    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function _augment (arr) {\n  arr.constructor = Buffer\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array set method before overwriting\n  arr._set = arr.set\n\n  // deprecated\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.equals = BP.equals\n  arr.compare = BP.compare\n  arr.indexOf = BP.indexOf\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUIntLE = BP.readUIntLE\n  arr.readUIntBE = BP.readUIntBE\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readIntLE = BP.readIntLE\n  arr.readIntBE = BP.readIntBE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUIntLE = BP.writeUIntLE\n  arr.writeUIntBE = BP.writeUIntBE\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeIntLE = BP.writeIntLE\n  arr.writeIntBE = BP.writeIntBE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; i++) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/buffer/index.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192 // not used by this implementation\n\nvar rootParent = {}\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property\n *     on objects.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\nfunction typedArraySupport () {\n  function Bar () {}\n  try {\n    var arr = new Uint8Array(1)\n    arr.foo = function () { return 42 }\n    arr.constructor = Bar\n    return arr.foo() === 42 && // typed array instances can be augmented\n        arr.constructor === Bar && // constructor can be set\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (arg) {\n  if (!(this instanceof Buffer)) {\n    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.\n    if (arguments.length > 1) return new Buffer(arg, arguments[1])\n    return new Buffer(arg)\n  }\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    this.length = 0\n    this.parent = undefined\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    return fromNumber(this, arg)\n  }\n\n  // Slightly less common case.\n  if (typeof arg === 'string') {\n    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')\n  }\n\n  // Unusual.\n  return fromObject(this, arg)\n}\n\nfunction fromNumber (that, length) {\n  that = allocate(that, length < 0 ? 0 : checked(length) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < length; i++) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'\n\n  // Assumption: byteLength() return value is always < kMaxLength.\n  var length = byteLength(string, encoding) | 0\n  that = allocate(that, length)\n\n  that.write(string, encoding)\n  return that\n}\n\nfunction fromObject (that, object) {\n  if (Buffer.isBuffer(object)) return fromBuffer(that, object)\n\n  if (isArray(object)) return fromArray(that, object)\n\n  if (object == null) {\n    throw new TypeError('must start with number, buffer, array or string')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined') {\n    if (object.buffer instanceof ArrayBuffer) {\n      return fromTypedArray(that, object)\n    }\n    if (object instanceof ArrayBuffer) {\n      return fromArrayBuffer(that, object)\n    }\n  }\n\n  if (object.length) return fromArrayLike(that, object)\n\n  return fromJsonObject(that, object)\n}\n\nfunction fromBuffer (that, buffer) {\n  var length = checked(buffer.length) | 0\n  that = allocate(that, length)\n  buffer.copy(that, 0, 0, length)\n  return that\n}\n\nfunction fromArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Duplicate of fromArray() to keep fromArray() monomorphic.\nfunction fromTypedArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  // Truncating the elements is probably not what people expect from typed\n  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior\n  // of the old Buffer constructor.\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    array.byteLength\n    that = Buffer._augment(new Uint8Array(array))\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromTypedArray(that, new Uint8Array(array))\n  }\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.\n// Returns a zero-length buffer for inputs that don't conform to the spec.\nfunction fromJsonObject (that, object) {\n  var array\n  var length = 0\n\n  if (object.type === 'Buffer' && isArray(object.data)) {\n    array = object.data\n    length = checked(array.length) | 0\n  }\n  that = allocate(that, length)\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n} else {\n  // pre-set for values that may exist in the future\n  Buffer.prototype.length = undefined\n  Buffer.prototype.parent = undefined\n}\n\nfunction allocate (that, length) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = Buffer._augment(new Uint8Array(length))\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that.length = length\n    that._isBuffer = true\n  }\n\n  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1\n  if (fromPool) that.parent = rootParent\n\n  return that\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (subject, encoding) {\n  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)\n\n  var buf = new Buffer(subject, encoding)\n  delete buf.parent\n  return buf\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  var i = 0\n  var len = Math.min(x, y)\n  while (i < len) {\n    if (a[i] !== b[i]) break\n\n    ++i\n  }\n\n  if (i !== len) {\n    x = a[i]\n    y = b[i]\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; i++) {\n      length += list[i].length\n    }\n  }\n\n  var buf = new Buffer(length)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\nfunction byteLength (string, encoding) {\n  if (typeof string !== 'string') string = '' + string\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'binary':\n      // Deprecated\n      case 'raw':\n      case 'raws':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  start = start | 0\n  end = end === undefined || end === Infinity ? this.length : end | 0\n\n  if (!encoding) encoding = 'utf8'\n  if (start < 0) start = 0\n  if (end > this.length) end = this.length\n  if (end <= start) return ''\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'binary':\n        return binarySlice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return 0\n  return Buffer.compare(this, b)\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset) {\n  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff\n  else if (byteOffset < -0x80000000) byteOffset = -0x80000000\n  byteOffset >>= 0\n\n  if (this.length === 0) return -1\n  if (byteOffset >= this.length) return -1\n\n  // Negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)\n\n  if (typeof val === 'string') {\n    if (val.length === 0) return -1 // special case: looking for empty string always fails\n    return String.prototype.indexOf.call(this, val, byteOffset)\n  }\n  if (Buffer.isBuffer(val)) {\n    return arrayIndexOf(this, val, byteOffset)\n  }\n  if (typeof val === 'number') {\n    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {\n      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)\n    }\n    return arrayIndexOf(this, [ val ], byteOffset)\n  }\n\n  function arrayIndexOf (arr, val, byteOffset) {\n    var foundIndex = -1\n    for (var i = 0; byteOffset + i < arr.length; i++) {\n      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex\n      } else {\n        foundIndex = -1\n      }\n    }\n    return -1\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\n// `get` is deprecated\nBuffer.prototype.get = function get (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` is deprecated\nBuffer.prototype.set = function set (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new Error('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) throw new Error('Invalid hex string')\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction binaryWrite (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    var swap = encoding\n    encoding = offset\n    offset = length | 0\n    length = swap\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'binary':\n        return binaryWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction binarySlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  if (newBuf.length) newBuf.parent = this.parent || this\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n  if (offset < 0) throw new RangeError('index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; i--) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; i++) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    target._set(this.subarray(start, start + len), targetStart)\n  }\n\n  return len\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function fill (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (end < start) throw new RangeError('end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')\n  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')\n\n  var i\n  if (typeof value === 'number') {\n    for (i = start; i < end; i++) {\n      this[i] = value\n    }\n  } else {\n    var bytes = utf8ToBytes(value.toString())\n    var len = bytes.length\n    for (i = start; i < end; i++) {\n      this[i] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function toArrayBuffer () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1) {\n        buf[i] = this[i]\n      }\n      return buf.buffer\n    }\n  } else {\n    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function _augment (arr) {\n  arr.constructor = Buffer\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array set method before overwriting\n  arr._set = arr.set\n\n  // deprecated\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.equals = BP.equals\n  arr.compare = BP.compare\n  arr.indexOf = BP.indexOf\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUIntLE = BP.readUIntLE\n  arr.readUIntBE = BP.readUIntBE\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readIntLE = BP.readIntLE\n  arr.readIntBE = BP.readIntBE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUIntLE = BP.writeUIntLE\n  arr.writeUIntBE = BP.writeUIntBE\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeIntLE = BP.writeIntLE\n  arr.writeIntBE = BP.writeIntBE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; i++) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n"]}","var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n;(function (exports) {\n\t'use strict';\n\n  var Arr = (typeof Uint8Array !== 'undefined')\n    ? Uint8Array\n    : Array\n\n\tvar PLUS   = '+'.charCodeAt(0)\n\tvar SLASH  = '/'.charCodeAt(0)\n\tvar NUMBER = '0'.charCodeAt(0)\n\tvar LOWER  = 'a'.charCodeAt(0)\n\tvar UPPER  = 'A'.charCodeAt(0)\n\tvar PLUS_URL_SAFE = '-'.charCodeAt(0)\n\tvar SLASH_URL_SAFE = '_'.charCodeAt(0)\n\n\tfunction decode (elt) {\n\t\tvar code = elt.charCodeAt(0)\n\t\tif (code === PLUS ||\n\t\t    code === PLUS_URL_SAFE)\n\t\t\treturn 62 // '+'\n\t\tif (code === SLASH ||\n\t\t    code === SLASH_URL_SAFE)\n\t\t\treturn 63 // '/'\n\t\tif (code < NUMBER)\n\t\t\treturn -1 //no match\n\t\tif (code < NUMBER + 10)\n\t\t\treturn code - NUMBER + 26 + 26\n\t\tif (code < UPPER + 26)\n\t\t\treturn code - UPPER\n\t\tif (code < LOWER + 26)\n\t\t\treturn code - LOWER + 26\n\t}\n\n\tfunction b64ToByteArray (b64) {\n\t\tvar i, j, l, tmp, placeHolders, arr\n\n\t\tif (b64.length % 4 > 0) {\n\t\t\tthrow new Error('Invalid string. Length must be a multiple of 4')\n\t\t}\n\n\t\t// the number of equal signs (place holders)\n\t\t// if there are two placeholders, than the two characters before it\n\t\t// represent one byte\n\t\t// if there is only one, then the three characters before it represent 2 bytes\n\t\t// this is just a cheap hack to not do indexOf twice\n\t\tvar len = b64.length\n\t\tplaceHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0\n\n\t\t// base64 is 4/3 + up to two characters of the original data\n\t\tarr = new Arr(b64.length * 3 / 4 - placeHolders)\n\n\t\t// if there are placeholders, only get up to the last complete 4 chars\n\t\tl = placeHolders > 0 ? b64.length - 4 : b64.length\n\n\t\tvar L = 0\n\n\t\tfunction push (v) {\n\t\t\tarr[L++] = v\n\t\t}\n\n\t\tfor (i = 0, j = 0; i < l; i += 4, j += 3) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))\n\t\t\tpush((tmp & 0xFF0000) >> 16)\n\t\t\tpush((tmp & 0xFF00) >> 8)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\tif (placeHolders === 2) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)\n\t\t\tpush(tmp & 0xFF)\n\t\t} else if (placeHolders === 1) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)\n\t\t\tpush((tmp >> 8) & 0xFF)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\treturn arr\n\t}\n\n\tfunction uint8ToBase64 (uint8) {\n\t\tvar i,\n\t\t\textraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes\n\t\t\toutput = \"\",\n\t\t\ttemp, length\n\n\t\tfunction encode (num) {\n\t\t\treturn lookup.charAt(num)\n\t\t}\n\n\t\tfunction tripletToBase64 (num) {\n\t\t\treturn encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)\n\t\t}\n\n\t\t// go through the array every three bytes, we'll deal with trailing stuff later\n\t\tfor (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {\n\t\t\ttemp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n\t\t\toutput += tripletToBase64(temp)\n\t\t}\n\n\t\t// pad the end with zeros, but make sure to not forget the extra bytes\n\t\tswitch (extraBytes) {\n\t\t\tcase 1:\n\t\t\t\ttemp = uint8[uint8.length - 1]\n\t\t\t\toutput += encode(temp >> 2)\n\t\t\t\toutput += encode((temp << 4) & 0x3F)\n\t\t\t\toutput += '=='\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\ttemp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])\n\t\t\t\toutput += encode(temp >> 10)\n\t\t\t\toutput += encode((temp >> 4) & 0x3F)\n\t\t\t\toutput += encode((temp << 2) & 0x3F)\n\t\t\t\toutput += '='\n\t\t\t\tbreak\n\t\t}\n\n\t\treturn output\n\t}\n\n\texports.toByteArray = b64ToByteArray\n\texports.fromByteArray = uint8ToBase64\n}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      }\n      throw TypeError('Uncaught, unspecified \"error\" event.');\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        len = arguments.length;\n        args = new Array(len - 1);\n        for (i = 1; i < len; i++)\n          args[i - 1] = arguments[i];\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    len = arguments.length;\n    args = new Array(len - 1);\n    for (i = 1; i < len; i++)\n      args[i - 1] = arguments[i];\n\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    var m;\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  var ret;\n  if (!emitter._events || !emitter._events[type])\n    ret = 0;\n  else if (isFunction(emitter._events[type]))\n    ret = 1;\n  else\n    ret = emitter._events[type].length;\n  return ret;\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","var is = require('./is'),\n    GENERIC = '_generic',\n    EventEmitter = require('events').EventEmitter,\n    slice = Array.prototype.slice;\n\nfunction flatten(item){\n    return Array.isArray(item) ? item.reduce(function(result, element){\n        if(element == null){\n            return result;\n        }\n        return result.concat(flatten(element));\n    },[]) : item;\n}\n\nfunction attachProperties(object, firm){\n    for(var key in this._properties){\n        this._properties[key].attach(object, firm);\n    }\n}\n\nfunction onRender(){\n\n    // Ensure all bindings are somewhat attached just before rendering\n    this.attach(undefined, 0);\n\n    for(var key in this._properties){\n        this._properties[key].update();\n    }\n}\n\nfunction detachProperties(firm){\n    for(var key in this._properties){\n        this._properties[key].detach(firm);\n    }\n}\n\nfunction destroyProperties(){\n    for(var key in this._properties){\n        this._properties[key].destroy();\n    }\n}\n\nfunction clone(){\n    return this.fastn(this.component._type, this.component._settings, this.component._children.filter(function(child){\n            return !child._templated;\n        }).map(function(child){\n            return child.clone();\n        })\n    );\n}\n\nfunction getSetBinding(newBinding){\n    if(!arguments.length){\n        return this.binding;\n    }\n\n    if(!is.binding(newBinding)){\n        newBinding = this.fastn.binding(newBinding);\n    }\n\n    if(this.binding && this.binding !== newBinding){\n        this.binding.removeListener('change', this.emitAttach);\n        newBinding.attach(this.binding._model, this.binding._firm);\n    }\n\n    this.binding = newBinding;\n\n    this.binding.on('change', this.emitAttach);\n    this.binding.on('detach', this.emitDetach);\n\n    this.emitAttach();\n\n    return this.component;\n};\n\nfunction emitAttach(){\n    var newBound = this.binding();\n    if(newBound !== this.lastBound){\n        this.lastBound = newBound;\n        this.scope.attach(this.lastBound);\n        this.component.emit('attach', this.scope, 1);\n    }\n}\n\nfunction emitDetach(){\n    this.component.emit('detach', 1);\n}\n\nfunction getScope(){\n    return this.scope;\n}\n\nfunction destroy(){\n    if(this.destroyed){\n        return;\n    }\n    this.destroyed = true;\n\n    this.component\n        .removeAllListeners('render')\n        .removeAllListeners('attach');\n\n    this.component.emit('destroy');\n    this.component.element = null;\n    this.scope.destroy();\n    this.binding.destroy();\n\n    return this.component;\n}\n\nfunction attachComponent(object, firm){\n    this.binding.attach(object, firm);\n    return this.component;\n}\n\nfunction detachComponent(firm){\n    this.binding.detach(firm);\n    return this.component;\n}\n\nfunction isDestroyed(){\n    return this.destroyed;\n}\n\nfunction setProperty(key, property){\n\n    // Add a default property or use the one already there\n    if(!property){\n        property = this.component[key] || this.fastn.property();\n    }\n\n    this.component[key] = property;\n    this.component._properties[key] = property;\n\n    return this.component;\n}\n\nfunction extendComponent(type, settings, children){\n\n    if(type in this.types){\n        return this.component;\n    }\n\n    if(!(type in this.fastn.components)){\n\n        if(!(GENERIC in this.fastn.components)){\n            throw new Error('No component of type \"' + type + '\" is loaded');\n        }\n\n        this.fastn.components._generic(this.fastn, this.component, type, settings, children);\n\n        this.types._generic = true;\n    }else{\n\n        this.fastn.components[type](this.fastn, this.component, type, settings, children);\n    }\n\n    this.types[type] = true;\n\n    return this.component;\n};\n\nfunction isType(type){\n    return type in this.types;\n}\n\nfunction FastnComponent(fastn, type, settings, children){\n    var component = this;\n\n    var componentScope = {\n        types: {},\n        fastn: fastn,\n        component: component,\n        binding: fastn.binding('.'),\n        destroyed: false,\n        scope: new fastn.Model(false),\n        lastBound: null\n    };\n\n    componentScope.emitAttach = emitAttach.bind(componentScope);\n    componentScope.emitDetach = emitDetach.bind(componentScope);\n    componentScope.binding._default_binding = true;\n\n    component._type = type;\n    component._properties = {};\n    component._settings = settings || {};\n    component._children = children ? flatten(children) : [];\n\n    component.attach = attachComponent.bind(componentScope);\n    component.detach = detachComponent.bind(componentScope);\n    component.scope = getScope.bind(componentScope);\n    component.destroy = destroy.bind(componentScope);\n    component.destroyed = isDestroyed.bind(componentScope);\n    component.binding = getSetBinding.bind(componentScope);\n    component.setProperty = setProperty.bind(componentScope);\n    component.clone = clone.bind(componentScope);\n    component.children = slice.bind(component._children);\n    component.extend = extendComponent.bind(componentScope);\n    component.is = isType.bind(componentScope);\n\n    component.binding(componentScope.binding);\n\n    component.on('attach', attachProperties.bind(this));\n    component.on('render', onRender.bind(this));\n    component.on('detach', detachProperties.bind(this));\n    component.on('destroy', destroyProperties.bind(this));\n\n    if(fastn.debug){\n        component.on('render', function(){\n            if(component.element && typeof component.element === 'object'){\n                component.element._component = component;\n            }\n        });\n    }\n}\nFastnComponent.prototype = Object.create(EventEmitter.prototype);\nFastnComponent.prototype.constructor = FastnComponent;\nFastnComponent.prototype._fastn_component = true;\n\nmodule.exports = FastnComponent;","var is = require('./is'),\n    firmer = require('./firmer'),\n    functionEmitter = require('function-emitter'),\n    setPrototypeOf = require('setprototypeof'),\n    same = require('same-value');\n\nfunction fuseBinding(){\n    var fastn = this,\n        args = Array.prototype.slice.call(arguments);\n\n    var bindings = args.slice(),\n        transform = bindings.pop(),\n        updateTransform,\n        resultBinding = createBinding.call(fastn, 'result'),\n        selfChanging;\n\n    resultBinding._arguments = args;\n\n    if(typeof bindings[bindings.length-1] === 'function' && !is.binding(bindings[bindings.length-1])){\n        updateTransform = transform;\n        transform = bindings.pop();\n    }\n\n    resultBinding._model.removeAllListeners();\n    resultBinding._set = function(value){\n        if(updateTransform){\n            selfChanging = true;\n            var newValue = updateTransform(value);\n            if(!same(newValue, bindings[0]())){\n                bindings[0](newValue);\n                resultBinding._change(newValue);\n            }\n            selfChanging = false;\n        }else{\n            resultBinding._change(value);\n        }\n    };\n\n    function change(){\n        if(selfChanging){\n            return;\n        }\n        resultBinding(transform.apply(null, bindings.map(function(binding){\n            return binding();\n        })));\n    }\n\n    bindings.forEach(function(binding, index){\n        if(!is.binding(binding)){\n            binding = createBinding.call(fastn, binding);\n            bindings.splice(index,1,binding);\n        }\n        binding.on('change', change);\n        resultBinding.on('detach', binding.detach);\n    });\n\n    var lastAttached;\n    resultBinding.on('attach', function(object){\n        selfChanging = true;\n        bindings.forEach(function(binding){\n            binding.attach(object, 1);\n        });\n        selfChanging = false;\n        if(lastAttached !== object){\n            change();\n        }\n        lastAttached = object;\n    });\n\n    return resultBinding;\n}\n\nfunction createValueBinding(fastn){\n    var valueBinding = createBinding.call(fastn, 'value');\n    valueBinding.attach = function(){return valueBinding;};\n    valueBinding.detach = function(){return valueBinding;};\n    return valueBinding;\n}\n\nfunction bindingTemplate(newValue){\n    if(!arguments.length){\n        return this.value;\n    }\n\n    if(this.binding._fastn_binding === '.'){\n        return;\n    }\n\n    this.binding._set(newValue);\n    return this.binding;\n}\n\nfunction createBinding(path, more){\n    var fastn = this;\n\n    if(more){ // used instead of arguments.length for performance\n        return fuseBinding.apply(fastn, arguments);\n    }\n\n    if(path == null){\n        return createValueBinding(fastn);\n    }\n\n    var bindingScope = {},\n        binding = bindingScope.binding = bindingTemplate.bind(bindingScope),\n        destroyed;\n\n    setPrototypeOf(binding, functionEmitter);\n    binding.setMaxListeners(10000);\n    binding._arguments = [path];\n    binding._model = new fastn.Model(false);\n    binding._fastn_binding = path;\n    binding._firm = -Infinity;\n\n    function modelAttachHandler(data){\n        binding._model.attach(data);\n        binding._change(binding._model.get(path));\n        binding.emit('attach', data, 1);\n    }\n\n    function modelDetachHandler(){\n        binding._model.detach();\n    }\n\n    binding.attach = function(object, firm){\n\n        // If the binding is being asked to attach loosly to an object,\n        // but it has already been defined as being firmly attached, do not attach.\n        if(firmer(binding, firm)){\n            return binding;\n        }\n\n        binding._firm = firm;\n\n        var isModel = fastn.isModel(object);\n\n        if(isModel && bindingScope.attachedModel === object){\n            return binding;\n        }\n\n        if(bindingScope.attachedModel){\n            bindingScope.attachedModel.removeListener('attach', modelAttachHandler);\n            bindingScope.attachedModel.removeListener('detach', modelDetachHandler);\n            bindingScope.attachedModel = null;\n        }\n\n        if(isModel){\n            bindingScope.attachedModel = object;\n            bindingScope.attachedModel.on('attach', modelAttachHandler);\n            bindingScope.attachedModel.on('detach', modelDetachHandler);\n            object = object._model;\n        }\n\n        if(!(object instanceof Object)){\n            object = {};\n        }\n\n        if(binding._model._model === object){\n            return binding;\n        }\n\n        modelAttachHandler(object);\n\n        return binding;\n    };\n\n    binding.detach = function(firm){\n        if(firmer(binding, firm)){\n            return binding;\n        }\n\n        bindingScope.value = undefined;\n        if(binding._model.isAttached()){\n            binding._model.detach();\n        }\n        binding.emit('detach', 1);\n        return binding;\n    };\n    binding._set = function(newValue){\n        if(same(binding._model.get(path), newValue)){\n            return;\n        }\n        if(!binding._model.isAttached()){\n            binding._model.attach(binding._model.get('.'));\n        }\n        binding._model.set(path, newValue);\n    };\n    binding._change = function(newValue){\n        bindingScope.value = newValue;\n        binding.emit('change', binding());\n    };\n    binding.clone = function(keepAttachment){\n        var newBinding = createBinding.apply(fastn, binding._arguments);\n\n        if(keepAttachment){\n            newBinding.attach(bindingScope.attachedModel || binding._model._model, binding._firm);\n        }\n\n        return newBinding;\n    };\n    binding.destroy = function(soft){\n        if(destroyed){\n            return;\n        }\n        if(soft && binding.listeners('change').length){\n            return;\n        }\n        destroyed = true;\n        binding.emit('destroy');\n        binding.detach();\n        binding._model.destroy();\n    };\n\n    binding.destroyed = function(){\n        return destroyed;\n    };\n\n    if(path !== '.'){\n        binding._model.on(path, binding._change);\n    }\n\n    return binding;\n}\n\nfunction from(valueOrBinding){\n    if(is.binding(valueOrBinding)){\n        return valueOrBinding;\n    }\n\n    var result = this();\n    result(valueOrBinding)\n\n    return result;\n}\n\nmodule.exports = function(fastn){\n    var binding = createBinding.bind(fastn);\n    binding.from = from.bind(binding);\n    return binding;\n};","function insertChild(fastn, container, child, index){\n    if(child == null || child === false){\n        return;\n    }\n\n    var currentIndex = container._children.indexOf(child),\n        newComponent = fastn.toComponent(child);\n\n    if(newComponent !== child && ~currentIndex){\n        container._children.splice(currentIndex, 1, newComponent);\n    }\n\n    if(!~currentIndex || newComponent !== child){\n        newComponent.attach(container.scope(), 1);\n    }\n\n    if(currentIndex !== index){\n        if(~currentIndex){\n            container._children.splice(currentIndex, 1);\n        }\n        container._children.splice(index, 0, newComponent);\n    }\n\n    if(container.element){\n        if(!newComponent.element){\n            newComponent.render();\n        }\n        container._insert(newComponent.element, index);\n        newComponent.emit('insert', container);\n        container.emit('childInsert', newComponent);\n    }\n}\n\nfunction getContainerElement(){\n    return this.containerElement || this.element;\n}\n\nfunction insert(child, index){\n    var childComponent = child,\n        container = this.container,\n        fastn = this.fastn;\n\n    if(index && typeof index === 'object'){\n        childComponent = Array.prototype.slice.call(arguments);\n    }\n\n    if(isNaN(index)){\n        index = container._children.length;\n    }\n\n    if(Array.isArray(childComponent)){\n        for (var i = 0; i < childComponent.length; i++) {\n            container.insert(childComponent[i], i + index);\n        }\n    }else{\n        insertChild(fastn, container, childComponent, index);\n    }\n\n    return container;\n}\n\nmodule.exports = function(fastn, component, type, settings, children){\n    component.insert = insert.bind({\n        container: component,\n        fastn: fastn\n    });\n\n    component._insert = function(element, index){\n        var containerElement = component.getContainerElement();\n        if(!containerElement){\n            return;\n        }\n\n        if(containerElement.childNodes[index] === element){\n            return;\n        }\n\n        containerElement.insertBefore(element, containerElement.childNodes[index]);\n    };\n\n    component.remove = function(childComponent){\n        var index = component._children.indexOf(childComponent);\n        if(~index){\n            component._children.splice(index,1);\n        }\n\n        childComponent.detach(1);\n\n        if(childComponent.element){\n            component._remove(childComponent.element);\n            childComponent.emit('remove', component);\n        }\n        component.emit('childRemove', childComponent);\n    };\n\n    component._remove = function(element){\n        var containerElement = component.getContainerElement();\n\n        if(!element || !containerElement || element.parentNode !== containerElement){\n            return;\n        }\n\n        containerElement.removeChild(element);\n    };\n\n    component.empty = function(){\n        while(component._children.length){\n            component.remove(component._children.pop());\n        }\n    };\n\n    component.replaceChild = function(oldChild, newChild){\n        var index = component._children.indexOf(oldChild);\n\n        if(!~index){\n            return;\n        }\n\n        component.remove(oldChild);\n        component.insert(newChild, index);\n    };\n\n    component.getContainerElement = getContainerElement.bind(component);\n\n    component.on('render', component.insert.bind(null, component._children, 0));\n\n    component.on('attach', function(model, firm){\n        for(var i = 0; i < component._children.length; i++){\n            if(fastn.isComponent(component._children[i])){\n                component._children[i].attach(model, firm);\n            }\n        }\n    });\n\n    component.on('destroy', function(data, firm){\n        for(var i = 0; i < component._children.length; i++){\n            if(fastn.isComponent(component._children[i])){\n                component._children[i].destroy(firm);\n            }\n        }\n    });\n\n    return component;\n};","// Is the entity firmer than the new firmness\nmodule.exports = function(entity, firm){\n    if(firm != null && (entity._firm === undefined || firm < entity._firm)){\n        return true;\n    }\n};","var FUNCTION = 'function',\n    OBJECT = 'object',\n    FASTNBINDING = '_fastn_binding',\n    FASTNPROPERTY = '_fastn_property',\n    FASTNCOMPONENT = '_fastn_component',\n    DEFAULTBINDING = '_default_binding';\n\nfunction isComponent(thing){\n    return thing && typeof thing === OBJECT && FASTNCOMPONENT in thing;\n}\n\nfunction isBindingObject(thing){\n    return thing && typeof thing === OBJECT && FASTNBINDING in thing;\n}\n\nfunction isBinding(thing){\n    return typeof thing === FUNCTION && FASTNBINDING in thing;\n}\n\nfunction isProperty(thing){\n    return typeof thing === FUNCTION && FASTNPROPERTY in thing;\n}\n\nfunction isDefaultBinding(thing){\n    return typeof thing === FUNCTION && FASTNBINDING in thing && DEFAULTBINDING in thing;\n}\n\nmodule.exports = {\n    component: isComponent,\n    bindingObject: isBindingObject,\n    binding: isBinding,\n    defaultBinding: isDefaultBinding,\n    property: isProperty\n};","//Copyright (C) 2012 Kory Nunn\r\n\r\n//Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\r\n\r\n//The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\r\n\r\n//THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n/*\r\n\r\n    This code is not formatted for readability, but rather run-speed and to assist compilers.\r\n\r\n    However, the code's intention should be transparent.\r\n\r\n    *** IE SUPPORT ***\r\n\r\n    If you require this library to work in IE7, add the following after declaring crel.\r\n\r\n    var testDiv = document.createElement('div'),\r\n        testLabel = document.createElement('label');\r\n\r\n    testDiv.setAttribute('class', 'a');\r\n    testDiv['className'] !== 'a' ? crel.attrMap['class'] = 'className':undefined;\r\n    testDiv.setAttribute('name','a');\r\n    testDiv['name'] !== 'a' ? crel.attrMap['name'] = function(element, value){\r\n        element.id = value;\r\n    }:undefined;\r\n\r\n\r\n    testLabel.setAttribute('for', 'a');\r\n    testLabel['htmlFor'] !== 'a' ? crel.attrMap['for'] = 'htmlFor':undefined;\r\n\r\n\r\n\r\n*/\r\n\r\n(function (root, factory) {\r\n    if (typeof exports === 'object') {\r\n        module.exports = factory();\r\n    } else if (typeof define === 'function' && define.amd) {\r\n        define(factory);\r\n    } else {\r\n        root.crel = factory();\r\n    }\r\n}(this, function () {\r\n    var fn = 'function',\r\n        obj = 'object',\r\n        nodeType = 'nodeType',\r\n        textContent = 'textContent',\r\n        setAttribute = 'setAttribute',\r\n        attrMapString = 'attrMap',\r\n        isNodeString = 'isNode',\r\n        isElementString = 'isElement',\r\n        d = typeof document === obj ? document : {},\r\n        isType = function(a, type){\r\n            return typeof a === type;\r\n        },\r\n        isNode = typeof Node === fn ? function (object) {\r\n            return object instanceof Node;\r\n        } :\r\n        // in IE <= 8 Node is an object, obviously..\r\n        function(object){\r\n            return object &&\r\n                isType(object, obj) &&\r\n                (nodeType in object) &&\r\n                isType(object.ownerDocument,obj);\r\n        },\r\n        isElement = function (object) {\r\n            return crel[isNodeString](object) && object[nodeType] === 1;\r\n        },\r\n        isArray = function(a){\r\n            return a instanceof Array;\r\n        },\r\n        appendChild = function(element, child) {\r\n          if(!crel[isNodeString](child)){\r\n              child = d.createTextNode(child);\r\n          }\r\n          element.appendChild(child);\r\n        };\r\n\r\n\r\n    function crel(){\r\n        var args = arguments, //Note: assigned to a variable to assist compilers. Saves about 40 bytes in closure compiler. Has negligable effect on performance.\r\n            element = args[0],\r\n            child,\r\n            settings = args[1],\r\n            childIndex = 2,\r\n            argumentsLength = args.length,\r\n            attributeMap = crel[attrMapString];\r\n\r\n        element = crel[isElementString](element) ? element : d.createElement(element);\r\n        // shortcut\r\n        if(argumentsLength === 1){\r\n            return element;\r\n        }\r\n\r\n        if(!isType(settings,obj) || crel[isNodeString](settings) || isArray(settings)) {\r\n            --childIndex;\r\n            settings = null;\r\n        }\r\n\r\n        // shortcut if there is only one child that is a string\r\n        if((argumentsLength - childIndex) === 1 && isType(args[childIndex], 'string') && element[textContent] !== undefined){\r\n            element[textContent] = args[childIndex];\r\n        }else{\r\n            for(; childIndex < argumentsLength; ++childIndex){\r\n                child = args[childIndex];\r\n\r\n                if(child == null){\r\n                    continue;\r\n                }\r\n\r\n                if (isArray(child)) {\r\n                  for (var i=0; i < child.length; ++i) {\r\n                    appendChild(element, child[i]);\r\n                  }\r\n                } else {\r\n                  appendChild(element, child);\r\n                }\r\n            }\r\n        }\r\n\r\n        for(var key in settings){\r\n            if(!attributeMap[key]){\r\n                element[setAttribute](key, settings[key]);\r\n            }else{\r\n                var attr = attributeMap[key];\r\n                if(typeof attr === fn){\r\n                    attr(element, settings[key]);\r\n                }else{\r\n                    element[setAttribute](attr, settings[key]);\r\n                }\r\n            }\r\n        }\r\n\r\n        return element;\r\n    }\r\n\r\n    // Used for mapping one kind of attribute to the supported version of that in bad browsers.\r\n    crel[attrMapString] = {};\r\n\r\n    crel[isElementString] = isElement;\r\n\r\n    crel[isNodeString] = isNode;\r\n\r\n    if(typeof Proxy !== 'undefined'){\r\n        return new Proxy(crel, {\r\n            get: function(target, key){\r\n                !(key in crel) && (crel[key] = crel.bind(null, key));\r\n                return crel[key];\r\n            }\r\n        });\r\n    }\r\n\r\n    return crel;\r\n}));\r\n","(function (global){\nvar EventEmitter = require('events').EventEmitter,\n    isInstance = require('is-instance');\n\nfunction toArray(items){\n    return Array.prototype.slice.call(items);\n}\n\nvar deepRegex = /[|.]/i;\n\nfunction matchDeep(path){\n    return (path + '').match(deepRegex);\n}\n\nfunction isWildcardPath(path){\n    var stringPath = (path + '');\n    return ~stringPath.indexOf('*');\n}\n\nfunction getTargetKey(path){\n    var stringPath = (path + '');\n    return stringPath.split('|').shift();\n}\n\nvar eventSystemVersion = 1,\n    globalKey = '_entiEventState' + eventSystemVersion\n    globalState = global[globalKey] = global[globalKey] || {\n        instances: []\n    };\n\nvar modifiedEnties = globalState.modifiedEnties = globalState.modifiedEnties || new Set(),\n    trackedObjects = globalState.trackedObjects = globalState.trackedObjects || new WeakMap();\n\nfunction leftAndRest(path){\n    var stringPath = (path + '');\n\n    // Special case when you want to filter on self (.)\n    if(stringPath.slice(0,2) === '.|'){\n        return ['.', stringPath.slice(2)];\n    }\n\n    var match = matchDeep(stringPath);\n    if(match){\n        return [stringPath.slice(0, match.index), stringPath.slice(match.index+1)];\n    }\n    return stringPath;\n}\n\nfunction isWildcardKey(key){\n    return key.charAt(0) === '*';\n}\n\nfunction isFeralcardKey(key){\n    return key === '**';\n}\n\nfunction addHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        trackedKeys = {};\n        trackedObjects.set(object, trackedKeys);\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        handlers = new Set();\n        trackedKeys[key] = handlers;\n    }\n\n    handlers.add(handler);\n}\n\nfunction removeHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        return;\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        return;\n    }\n\n    handlers.delete(handler);\n}\n\nfunction trackObjects(eventName, tracked, handler, object, key, path){\n    if(!object || typeof object !== 'object'){\n        return;\n    }\n\n    var target = object[key];\n\n    if(target && typeof target === 'object' && tracked.has(target)){\n        return;\n    }\n\n    trackObject(eventName, tracked, handler, object, key, path);\n}\n\nfunction trackKeys(eventName, tracked, handler, target, root, rest){\n    var keys = Object.keys(target);\n    for(var i = 0; i < keys.length; i++){\n        if(isFeralcardKey(root)){\n            trackObjects(eventName, tracked, handler, target, keys[i], '**' + (rest ? '.' : '') + (rest || ''));\n        }else{\n            trackObjects(eventName, tracked, handler, target, keys[i], rest);\n        }\n    }\n}\n\nfunction trackObject(eventName, tracked, handler, object, key, path){\n    var eventKey = key === '**' ? '*' : key,\n        target = object[key],\n        targetIsObject = target && typeof target === 'object';\n\n    var handle = function(value, event, emitKey){\n        if(eventKey !== '*' && typeof object[eventKey] === 'object' && object[eventKey] !== target){\n            if(targetIsObject){\n                tracked.delete(target);\n            }\n            removeHandler(object, eventKey, handle);\n            trackObjects(eventName, tracked, handler, object, key, path);\n            return;\n        }\n\n        if(eventKey === '*'){\n            trackKeys(eventName, tracked, handler, object, key, path);\n        }\n\n        if(!tracked.has(object)){\n            return;\n        }\n\n        if(key !== '**' || !path){\n            handler(value, event, emitKey);\n        }\n    };\n\n    addHandler(object, eventKey, handle);\n\n    if(!targetIsObject){\n        return;\n    }\n\n    tracked.add(target);\n\n    if(!path){\n        return;\n    }\n\n    var rootAndRest = leftAndRest(path),\n        root,\n        rest;\n\n    if(!Array.isArray(rootAndRest)){\n        root = rootAndRest;\n    }else{\n        root = rootAndRest[0];\n        rest = rootAndRest[1];\n\n        // If the root is '.', watch for events on *\n        if(root === '.'){\n            root = '*';\n        }\n    }\n\n    if(targetIsObject && isWildcardKey(root)){\n        trackKeys(eventName, tracked, handler, target, root, rest);\n    }\n\n    trackObjects(eventName, tracked, handler, target, root, rest);\n}\n\nvar trackedEvents = new WeakMap();\nfunction createHandler(enti, trackedObjectPaths, trackedPaths, eventName){\n    var oldModel = enti._model;\n    return function(event, emitKey){\n        trackedPaths.entis.forEach(function(enti){\n            if(enti._emittedEvents[eventName] === emitKey){\n                return;\n            }\n\n            if(enti._model !== oldModel){\n                trackedPaths.entis.delete(enti);\n                if(trackedPaths.entis.size === 0){\n                    delete trackedObjectPaths[eventName];\n                    if(!Object.keys(trackedObjectPaths).length){\n                        trackedEvents.delete(oldModel);\n                    }\n                }\n                return;\n            }\n\n            enti._emittedEvents[eventName] = emitKey;\n\n            var targetKey = getTargetKey(eventName),\n                value = isWildcardPath(targetKey) ? undefined : enti.get(targetKey);\n\n            enti.emit(eventName, value, event);\n        });\n    };\n}\n\nfunction trackPath(enti, eventName){\n    var object = enti._model,\n        trackedObjectPaths = trackedEvents.get(object);\n\n    if(!trackedObjectPaths){\n        trackedObjectPaths = {};\n        trackedEvents.set(object, trackedObjectPaths);\n    }\n\n    var trackedPaths = trackedObjectPaths[eventName];\n\n    if(!trackedPaths){\n        trackedPaths = {\n            entis: new Set(),\n            trackedObjects: new WeakSet()\n        };\n        trackedObjectPaths[eventName] = trackedPaths;\n    }else if(trackedPaths.entis.has(enti)){\n        return;\n    }\n\n    trackedPaths.entis.add(enti);\n\n    var handler = createHandler(enti, trackedObjectPaths, trackedPaths, eventName);\n\n    trackObjects(eventName, trackedPaths.trackedObjects, handler, {model:object}, 'model', eventName);\n}\n\nfunction trackPaths(enti){\n    if(!enti._events || !enti._model){\n        return;\n    }\n\n    for(var key in enti._events){\n        trackPath(enti, key);\n    }\n    modifiedEnties.delete(enti);\n}\n\nfunction emitEvent(object, key, value, emitKey){\n\n    modifiedEnties.forEach(trackPaths);\n\n    var trackedKeys = trackedObjects.get(object);\n\n    if(!trackedKeys){\n        return;\n    }\n\n    var event = {\n        value: value,\n        key: key,\n        object: object\n    };\n\n    function emitForKey(handler){\n        handler(event, emitKey);\n    }\n\n    if(trackedKeys[key]){\n        trackedKeys[key].forEach(emitForKey);\n    }\n\n    if(trackedKeys['*']){\n        trackedKeys['*'].forEach(emitForKey);\n    }\n}\n\nfunction emit(events){\n    var emitKey = {};\n    events.forEach(function(event){\n        emitEvent(event[0], event[1], event[2], emitKey);\n    });\n}\n\nfunction Enti(model){\n    var detached = model === false;\n\n    if(!model || (typeof model !== 'object' && typeof model !== 'function')){\n        model = {};\n    }\n\n    this._emittedEvents = {};\n    if(detached){\n        this._model = {};\n    }else{\n        this.attach(model);\n    }\n\n    this.on('newListener', function(){\n        modifiedEnties.add(this);\n    });\n}\nEnti.emit = function(model, key, value){\n    if(!(typeof model === 'object' || typeof model === 'function')){\n        return;\n    }\n\n    emit([[model, key, value]]);\n};\nEnti.get = function(model, key){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    if(key === '.'){\n        return model;\n    }\n\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.get(model[path[0]], path[1]);\n    }\n\n    return model[key];\n};\nEnti.set = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.set(model[path[0]], path[1], value);\n    }\n\n    var original = model[key];\n\n    if(typeof value !== 'object' && value === original){\n        return;\n    }\n\n    var keysChanged = !(key in model);\n\n    model[key] = value;\n\n    var events = [[model, key, value]];\n\n    if(keysChanged){\n        if(Array.isArray(model)){\n            events.push([model, 'length', model.length]);\n        }\n    }\n\n    emit(events);\n};\nEnti.push = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target;\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.push(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.push(value);\n\n    var events = [\n        [target, target.length-1, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.insert = function(model, key, value, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n\n    var target;\n    if(arguments.length < 4){\n        index = value;\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.insert(model[path[0]], path[1], value, index);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.splice(index, 0, value);\n\n    var events = [\n        [target, index, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.remove = function(model, key, subKey){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.remove(model[path[0]], path[1], subKey);\n    }\n\n    // Remove a key off of an object at 'key'\n    if(subKey != null){\n        Enti.remove(model[key], subKey);\n        return;\n    }\n\n    if(key === '.'){\n        throw '. (self) is not a valid key to remove';\n    }\n\n    var events = [];\n\n    if(Array.isArray(model)){\n        model.splice(key, 1);\n        events.push([model, 'length', model.length]);\n    }else{\n        delete model[key];\n        events.push([model, key]);\n    }\n\n    emit(events);\n};\nEnti.move = function(model, key, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.move(model[path[0]], path[1], index);\n    }\n\n    if(key === index){\n        return;\n    }\n\n    if(!Array.isArray(model)){\n        throw 'The model is not an array.';\n    }\n\n    var item = model[key];\n\n    model.splice(key, 1);\n\n    model.splice(index - (index > key ? 0 : 1), 0, item);\n\n    emit([[model, index, item]]);\n};\nEnti.update = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target,\n        isArray = Array.isArray(value);\n\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.update(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n\n        if(target == null){\n            model[key] = isArray ? [] : {};\n        }\n    }\n\n    if(typeof value !== 'object'){\n        throw 'The value is not an object.';\n    }\n\n    if(typeof target !== 'object'){\n        throw 'The target is not an object.';\n    }\n\n    var events = [],\n        updatedObjects = new WeakSet();\n\n    function updateTarget(target, value){\n        for(var key in value){\n            var currentValue = target[key];\n            if(currentValue instanceof Object && !updatedObjects.has(currentValue) && !(currentValue instanceof Date)){\n                updatedObjects.add(currentValue);\n                updateTarget(currentValue, value[key]);\n                continue;\n            }\n            target[key] = value[key];\n            events.push([target, key, value[key]]);\n        }\n\n        if(Array.isArray(target)){\n            events.push([target, 'length', target.length]);\n        }\n    }\n\n    updateTarget(target, value);\n\n    emit(events);\n};\nEnti.prototype = Object.create(EventEmitter.prototype);\nEnti.prototype._maxListeners = 100;\nEnti.prototype.constructor = Enti;\nEnti.prototype.attach = function(model){\n    if(this._model !== model){\n        this.detach();\n    }\n\n    if(model && !isInstance(model)){\n        throw 'Entis may only be attached to an object, or null/undefined';\n    }\n\n    modifiedEnties.add(this);\n    this._attached = true;\n    this._model = model;\n    this.emit('attach', model);\n};\nEnti.prototype.detach = function(){\n    modifiedEnties.delete(this);\n\n    this._emittedEvents = {};\n    this._model = {};\n    this._attached = false;\n    this.emit('detach');\n};\nEnti.prototype.destroy = function(){\n    this.detach();\n    this._events = null;\n    this.emit('destroy');\n};\nEnti.prototype.get = function(key){\n    return Enti.get(this._model, key);\n};\n\nEnti.prototype.set = function(key, value){\n    return Enti.set(this._model, key, value);\n};\n\nEnti.prototype.push = function(key, value){\n    return Enti.push.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.insert = function(key, value, index){\n    return Enti.insert.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.remove = function(key, subKey){\n    return Enti.remove.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.move = function(key, index){\n    return Enti.move.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.update = function(key, index){\n    return Enti.update.apply(null, [this._model].concat(toArray(arguments)));\n};\nEnti.prototype.isAttached = function(){\n    return this._attached;\n};\nEnti.prototype.attachedCount = function(){\n    return modifiedEnties.size;\n};\n\nEnti.isEnti = function(target){\n    return target && !!~globalState.instances.indexOf(target.constructor);\n};\n\nEnti.store = function(target, key, value){\n    if(arguments.length < 2){\n        return Enti.get(target, key);\n    }\n\n    Enti.set(target, key, value);\n};\n\nglobalState.instances.push(Enti);\n\nmodule.exports = Enti;\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/enti/index.js"],"names":[],"mappings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file":"generated.js","sourceRoot":"","sourcesContent":["var EventEmitter = require('events').EventEmitter,\n    isInstance = require('is-instance');\n\nfunction toArray(items){\n    return Array.prototype.slice.call(items);\n}\n\nvar deepRegex = /[|.]/i;\n\nfunction matchDeep(path){\n    return (path + '').match(deepRegex);\n}\n\nfunction isWildcardPath(path){\n    var stringPath = (path + '');\n    return ~stringPath.indexOf('*');\n}\n\nfunction getTargetKey(path){\n    var stringPath = (path + '');\n    return stringPath.split('|').shift();\n}\n\nvar eventSystemVersion = 1,\n    globalKey = '_entiEventState' + eventSystemVersion\n    globalState = global[globalKey] = global[globalKey] || {\n        instances: []\n    };\n\nvar modifiedEnties = globalState.modifiedEnties = globalState.modifiedEnties || new Set(),\n    trackedObjects = globalState.trackedObjects = globalState.trackedObjects || new WeakMap();\n\nfunction leftAndRest(path){\n    var stringPath = (path + '');\n\n    // Special case when you want to filter on self (.)\n    if(stringPath.slice(0,2) === '.|'){\n        return ['.', stringPath.slice(2)];\n    }\n\n    var match = matchDeep(stringPath);\n    if(match){\n        return [stringPath.slice(0, match.index), stringPath.slice(match.index+1)];\n    }\n    return stringPath;\n}\n\nfunction isWildcardKey(key){\n    return key.charAt(0) === '*';\n}\n\nfunction isFeralcardKey(key){\n    return key === '**';\n}\n\nfunction addHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        trackedKeys = {};\n        trackedObjects.set(object, trackedKeys);\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        handlers = new Set();\n        trackedKeys[key] = handlers;\n    }\n\n    handlers.add(handler);\n}\n\nfunction removeHandler(object, key, handler){\n    var trackedKeys = trackedObjects.get(object);\n\n    if(trackedKeys == null){\n        return;\n    }\n\n    var handlers = trackedKeys[key];\n\n    if(!handlers){\n        return;\n    }\n\n    handlers.delete(handler);\n}\n\nfunction trackObjects(eventName, tracked, handler, object, key, path){\n    if(!object || typeof object !== 'object'){\n        return;\n    }\n\n    var target = object[key];\n\n    if(target && typeof target === 'object' && tracked.has(target)){\n        return;\n    }\n\n    trackObject(eventName, tracked, handler, object, key, path);\n}\n\nfunction trackKeys(eventName, tracked, handler, target, root, rest){\n    var keys = Object.keys(target);\n    for(var i = 0; i < keys.length; i++){\n        if(isFeralcardKey(root)){\n            trackObjects(eventName, tracked, handler, target, keys[i], '**' + (rest ? '.' : '') + (rest || ''));\n        }else{\n            trackObjects(eventName, tracked, handler, target, keys[i], rest);\n        }\n    }\n}\n\nfunction trackObject(eventName, tracked, handler, object, key, path){\n    var eventKey = key === '**' ? '*' : key,\n        target = object[key],\n        targetIsObject = target && typeof target === 'object';\n\n    var handle = function(value, event, emitKey){\n        if(eventKey !== '*' && typeof object[eventKey] === 'object' && object[eventKey] !== target){\n            if(targetIsObject){\n                tracked.delete(target);\n            }\n            removeHandler(object, eventKey, handle);\n            trackObjects(eventName, tracked, handler, object, key, path);\n            return;\n        }\n\n        if(eventKey === '*'){\n            trackKeys(eventName, tracked, handler, object, key, path);\n        }\n\n        if(!tracked.has(object)){\n            return;\n        }\n\n        if(key !== '**' || !path){\n            handler(value, event, emitKey);\n        }\n    };\n\n    addHandler(object, eventKey, handle);\n\n    if(!targetIsObject){\n        return;\n    }\n\n    tracked.add(target);\n\n    if(!path){\n        return;\n    }\n\n    var rootAndRest = leftAndRest(path),\n        root,\n        rest;\n\n    if(!Array.isArray(rootAndRest)){\n        root = rootAndRest;\n    }else{\n        root = rootAndRest[0];\n        rest = rootAndRest[1];\n\n        // If the root is '.', watch for events on *\n        if(root === '.'){\n            root = '*';\n        }\n    }\n\n    if(targetIsObject && isWildcardKey(root)){\n        trackKeys(eventName, tracked, handler, target, root, rest);\n    }\n\n    trackObjects(eventName, tracked, handler, target, root, rest);\n}\n\nvar trackedEvents = new WeakMap();\nfunction createHandler(enti, trackedObjectPaths, trackedPaths, eventName){\n    var oldModel = enti._model;\n    return function(event, emitKey){\n        trackedPaths.entis.forEach(function(enti){\n            if(enti._emittedEvents[eventName] === emitKey){\n                return;\n            }\n\n            if(enti._model !== oldModel){\n                trackedPaths.entis.delete(enti);\n                if(trackedPaths.entis.size === 0){\n                    delete trackedObjectPaths[eventName];\n                    if(!Object.keys(trackedObjectPaths).length){\n                        trackedEvents.delete(oldModel);\n                    }\n                }\n                return;\n            }\n\n            enti._emittedEvents[eventName] = emitKey;\n\n            var targetKey = getTargetKey(eventName),\n                value = isWildcardPath(targetKey) ? undefined : enti.get(targetKey);\n\n            enti.emit(eventName, value, event);\n        });\n    };\n}\n\nfunction trackPath(enti, eventName){\n    var object = enti._model,\n        trackedObjectPaths = trackedEvents.get(object);\n\n    if(!trackedObjectPaths){\n        trackedObjectPaths = {};\n        trackedEvents.set(object, trackedObjectPaths);\n    }\n\n    var trackedPaths = trackedObjectPaths[eventName];\n\n    if(!trackedPaths){\n        trackedPaths = {\n            entis: new Set(),\n            trackedObjects: new WeakSet()\n        };\n        trackedObjectPaths[eventName] = trackedPaths;\n    }else if(trackedPaths.entis.has(enti)){\n        return;\n    }\n\n    trackedPaths.entis.add(enti);\n\n    var handler = createHandler(enti, trackedObjectPaths, trackedPaths, eventName);\n\n    trackObjects(eventName, trackedPaths.trackedObjects, handler, {model:object}, 'model', eventName);\n}\n\nfunction trackPaths(enti){\n    if(!enti._events || !enti._model){\n        return;\n    }\n\n    for(var key in enti._events){\n        trackPath(enti, key);\n    }\n    modifiedEnties.delete(enti);\n}\n\nfunction emitEvent(object, key, value, emitKey){\n\n    modifiedEnties.forEach(trackPaths);\n\n    var trackedKeys = trackedObjects.get(object);\n\n    if(!trackedKeys){\n        return;\n    }\n\n    var event = {\n        value: value,\n        key: key,\n        object: object\n    };\n\n    function emitForKey(handler){\n        handler(event, emitKey);\n    }\n\n    if(trackedKeys[key]){\n        trackedKeys[key].forEach(emitForKey);\n    }\n\n    if(trackedKeys['*']){\n        trackedKeys['*'].forEach(emitForKey);\n    }\n}\n\nfunction emit(events){\n    var emitKey = {};\n    events.forEach(function(event){\n        emitEvent(event[0], event[1], event[2], emitKey);\n    });\n}\n\nfunction Enti(model){\n    var detached = model === false;\n\n    if(!model || (typeof model !== 'object' && typeof model !== 'function')){\n        model = {};\n    }\n\n    this._emittedEvents = {};\n    if(detached){\n        this._model = {};\n    }else{\n        this.attach(model);\n    }\n\n    this.on('newListener', function(){\n        modifiedEnties.add(this);\n    });\n}\nEnti.emit = function(model, key, value){\n    if(!(typeof model === 'object' || typeof model === 'function')){\n        return;\n    }\n\n    emit([[model, key, value]]);\n};\nEnti.get = function(model, key){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    if(key === '.'){\n        return model;\n    }\n\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.get(model[path[0]], path[1]);\n    }\n\n    return model[key];\n};\nEnti.set = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    key = getTargetKey(key);\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.set(model[path[0]], path[1], value);\n    }\n\n    var original = model[key];\n\n    if(typeof value !== 'object' && value === original){\n        return;\n    }\n\n    var keysChanged = !(key in model);\n\n    model[key] = value;\n\n    var events = [[model, key, value]];\n\n    if(keysChanged){\n        if(Array.isArray(model)){\n            events.push([model, 'length', model.length]);\n        }\n    }\n\n    emit(events);\n};\nEnti.push = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target;\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.push(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.push(value);\n\n    var events = [\n        [target, target.length-1, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.insert = function(model, key, value, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n\n    var target;\n    if(arguments.length < 4){\n        index = value;\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.insert(model[path[0]], path[1], value, index);\n        }\n\n        target = model[key];\n    }\n\n    if(!Array.isArray(target)){\n        throw 'The target is not an array.';\n    }\n\n    target.splice(index, 0, value);\n\n    var events = [\n        [target, index, value],\n        [target, 'length', target.length]\n    ];\n\n    emit(events);\n};\nEnti.remove = function(model, key, subKey){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.remove(model[path[0]], path[1], subKey);\n    }\n\n    // Remove a key off of an object at 'key'\n    if(subKey != null){\n        Enti.remove(model[key], subKey);\n        return;\n    }\n\n    if(key === '.'){\n        throw '. (self) is not a valid key to remove';\n    }\n\n    var events = [];\n\n    if(Array.isArray(model)){\n        model.splice(key, 1);\n        events.push([model, 'length', model.length]);\n    }else{\n        delete model[key];\n        events.push([model, key]);\n    }\n\n    emit(events);\n};\nEnti.move = function(model, key, index){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var path = leftAndRest(key);\n    if(Array.isArray(path)){\n        return Enti.move(model[path[0]], path[1], index);\n    }\n\n    if(key === index){\n        return;\n    }\n\n    if(!Array.isArray(model)){\n        throw 'The model is not an array.';\n    }\n\n    var item = model[key];\n\n    model.splice(key, 1);\n\n    model.splice(index - (index > key ? 0 : 1), 0, item);\n\n    emit([[model, index, item]]);\n};\nEnti.update = function(model, key, value){\n    if(!model || typeof model !== 'object'){\n        return;\n    }\n\n    var target,\n        isArray = Array.isArray(value);\n\n    if(arguments.length < 3){\n        value = key;\n        key = '.';\n        target = model;\n    }else{\n        var path = leftAndRest(key);\n        if(Array.isArray(path)){\n            return Enti.update(model[path[0]], path[1], value);\n        }\n\n        target = model[key];\n\n        if(target == null){\n            model[key] = isArray ? [] : {};\n        }\n    }\n\n    if(typeof value !== 'object'){\n        throw 'The value is not an object.';\n    }\n\n    if(typeof target !== 'object'){\n        throw 'The target is not an object.';\n    }\n\n    var events = [],\n        updatedObjects = new WeakSet();\n\n    function updateTarget(target, value){\n        for(var key in value){\n            var currentValue = target[key];\n            if(currentValue instanceof Object && !updatedObjects.has(currentValue) && !(currentValue instanceof Date)){\n                updatedObjects.add(currentValue);\n                updateTarget(currentValue, value[key]);\n                continue;\n            }\n            target[key] = value[key];\n            events.push([target, key, value[key]]);\n        }\n\n        if(Array.isArray(target)){\n            events.push([target, 'length', target.length]);\n        }\n    }\n\n    updateTarget(target, value);\n\n    emit(events);\n};\nEnti.prototype = Object.create(EventEmitter.prototype);\nEnti.prototype._maxListeners = 100;\nEnti.prototype.constructor = Enti;\nEnti.prototype.attach = function(model){\n    if(this._model !== model){\n        this.detach();\n    }\n\n    if(model && !isInstance(model)){\n        throw 'Entis may only be attached to an object, or null/undefined';\n    }\n\n    modifiedEnties.add(this);\n    this._attached = true;\n    this._model = model;\n    this.emit('attach', model);\n};\nEnti.prototype.detach = function(){\n    modifiedEnties.delete(this);\n\n    this._emittedEvents = {};\n    this._model = {};\n    this._attached = false;\n    this.emit('detach');\n};\nEnti.prototype.destroy = function(){\n    this.detach();\n    this._events = null;\n    this.emit('destroy');\n};\nEnti.prototype.get = function(key){\n    return Enti.get(this._model, key);\n};\n\nEnti.prototype.set = function(key, value){\n    return Enti.set(this._model, key, value);\n};\n\nEnti.prototype.push = function(key, value){\n    return Enti.push.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.insert = function(key, value, index){\n    return Enti.insert.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.remove = function(key, subKey){\n    return Enti.remove.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.move = function(key, index){\n    return Enti.move.apply(null, [this._model].concat(toArray(arguments)));\n};\n\nEnti.prototype.update = function(key, index){\n    return Enti.update.apply(null, [this._model].concat(toArray(arguments)));\n};\nEnti.prototype.isAttached = function(){\n    return this._attached;\n};\nEnti.prototype.attachedCount = function(){\n    return modifiedEnties.size;\n};\n\nEnti.isEnti = function(target){\n    return target && !!~globalState.instances.indexOf(target.constructor);\n};\n\nEnti.store = function(target, key, value){\n    if(arguments.length < 2){\n        return Enti.get(target, key);\n    }\n\n    Enti.set(target, key, value);\n};\n\nglobalState.instances.push(Enti);\n\nmodule.exports = Enti;\n"]}","module.exports = function(value){\r\n    return value && typeof value === 'object' || typeof value === 'function';\r\n};","var EventEmitter = require('events').EventEmitter,\n    functionEmitterPrototype = function(){};\n\nfor(var key in EventEmitter.prototype){\n    functionEmitterPrototype[key] = EventEmitter.prototype[key];\n}\n\nmodule.exports = functionEmitterPrototype;","'use strict';\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction ToObject(val) {\n\tif (val == null) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction ownEnumerableKeys(obj) {\n\tvar keys = Object.getOwnPropertyNames(obj);\n\n\tif (Object.getOwnPropertySymbols) {\n\t\tkeys = keys.concat(Object.getOwnPropertySymbols(obj));\n\t}\n\n\treturn keys.filter(function (key) {\n\t\treturn propIsEnumerable.call(obj, key);\n\t});\n}\n\nmodule.exports = Object.assign || function (target, source) {\n\tvar from;\n\tvar keys;\n\tvar to = ToObject(target);\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = arguments[s];\n\t\tkeys = ownEnumerableKeys(Object(from));\n\n\t\tfor (var i = 0; i < keys.length; i++) {\n\t\t\tto[keys[i]] = from[keys[i]];\n\t\t}\n\t}\n\n\treturn to;\n};\n","module.exports = function isSame(a, b){\n    if(a === b){\n        return true;\n    }\n\n    if(\n        typeof a !== typeof b ||\n        typeof a === 'object' &&\n        !(a instanceof Date && b instanceof Date)\n    ){\n        return false;\n    }\n\n    return String(a) === String(b);\n};","module.exports = Object.setPrototypeOf || ({__proto__:[]} instanceof Array ? setProtoOf : mixinProperties);\n\nfunction setProtoOf(obj, proto) {\n\tobj.__proto__ = proto;\n}\n\nfunction mixinProperties(obj, proto) {\n\tfor (var prop in proto) {\n\t\tobj[prop] = proto[prop];\n\t}\n}\n","var clone = require('clone'),\n    deepEqual = require('cyclic-deep-equal');\n\nfunction keysAreDifferent(keys1, keys2){\n    if(keys1 === keys2){\n        return;\n    }\n    if(!keys1 || !keys2 || keys1.length !== keys2.length){\n        return true;\n    }\n    for(var i = 0; i < keys1.length; i++){\n        if(!~keys2.indexOf(keys1[i])){\n            return true;\n        }\n    }\n}\n\nfunction getKeys(value){\n    if(!value || typeof value !== 'object'){\n        return;\n    }\n\n    return Object.keys(value);\n}\n\nfunction WhatChanged(value, changesToTrack){\n    this._changesToTrack = {};\n\n    if(changesToTrack == null){\n        changesToTrack = 'value type keys structure reference';\n    }\n\n    if(typeof changesToTrack !== 'string'){\n        throw 'changesToTrack must be of type string';\n    }\n\n    changesToTrack = changesToTrack.split(' ');\n\n    for (var i = 0; i < changesToTrack.length; i++) {\n        this._changesToTrack[changesToTrack[i]] = true;\n    };\n\n    this.update(value);\n}\nWhatChanged.prototype.update = function(value){\n    var result = {},\n        changesToTrack = this._changesToTrack,\n        newKeys = getKeys(value);\n\n    if('value' in changesToTrack && value+'' !== this._lastReference+''){\n        result.value = true;\n    }\n    if(\n        'type' in changesToTrack && typeof value !== typeof this._lastValue ||\n        (value === null || this._lastValue === null) && this.value !== this._lastValue // typeof null === 'object'\n    ){\n        result.type = true;\n    }\n    if('keys' in changesToTrack && keysAreDifferent(this._lastKeys, getKeys(value))){\n        result.keys = true;\n    }\n\n    if(value !== null && typeof value === 'object' || typeof value === 'function'){\n        var lastValue = this._lastValue;\n\n        if('shallowStructure' in changesToTrack && (!lastValue || typeof lastValue !== 'object' || Object.keys(value).some(function(key, index){\n            return value[key] !== lastValue[key];\n        }))){\n            result.shallowStructure = true;\n        }\n        if('structure' in changesToTrack && !deepEqual(value, lastValue)){\n            result.structure = true;\n        }\n        if('reference' in changesToTrack && value !== this._lastReference){\n            result.reference = true;\n        }\n    }\n\n    this._lastValue = 'structure' in changesToTrack ? clone(value) : 'shallowStructure' in changesToTrack ? clone(value, true, 1): value;\n    this._lastReference = value;\n    this._lastKeys = newKeys;\n\n    return result;\n};\n\nmodule.exports = WhatChanged;","(function (Buffer){\nvar clone = (function() {\n'use strict';\n\n/**\n * Clones (copies) an Object using deep copying.\n *\n * This function supports circular references by default, but if you are certain\n * there are no circular references in your object, you can save some CPU time\n * by calling clone(obj, false).\n *\n * Caution: if `circular` is false and `parent` contains circular references,\n * your program may enter an infinite loop and crash.\n *\n * @param `parent` - the object to be cloned\n * @param `circular` - set to true if the object to be cloned may contain\n *    circular references. (optional - true by default)\n * @param `depth` - set to a number if the object is only to be cloned to\n *    a particular depth. (optional - defaults to Infinity)\n * @param `prototype` - sets the prototype to be used when cloning an object.\n *    (optional - defaults to parent prototype).\n*/\nfunction clone(parent, circular, depth, prototype) {\n  var filter;\n  if (typeof circular === 'object') {\n    depth = circular.depth;\n    prototype = circular.prototype;\n    filter = circular.filter;\n    circular = circular.circular\n  }\n  // maintain two arrays for circular references, where corresponding parents\n  // and children have the same index\n  var allParents = [];\n  var allChildren = [];\n\n  var useBuffer = typeof Buffer != 'undefined';\n\n  if (typeof circular == 'undefined')\n    circular = true;\n\n  if (typeof depth == 'undefined')\n    depth = Infinity;\n\n  // recurse this function so we don't reset allParents and allChildren\n  function _clone(parent, depth) {\n    // cloning null always returns null\n    if (parent === null)\n      return null;\n\n    if (depth == 0)\n      return parent;\n\n    var child;\n    var proto;\n    if (typeof parent != 'object') {\n      return parent;\n    }\n\n    if (clone.__isArray(parent)) {\n      child = [];\n    } else if (clone.__isRegExp(parent)) {\n      child = new RegExp(parent.source, __getRegExpFlags(parent));\n      if (parent.lastIndex) child.lastIndex = parent.lastIndex;\n    } else if (clone.__isDate(parent)) {\n      child = new Date(parent.getTime());\n    } else if (useBuffer && Buffer.isBuffer(parent)) {\n      child = new Buffer(parent.length);\n      parent.copy(child);\n      return child;\n    } else {\n      if (typeof prototype == 'undefined') {\n        proto = Object.getPrototypeOf(parent);\n        child = Object.create(proto);\n      }\n      else {\n        child = Object.create(prototype);\n        proto = prototype;\n      }\n    }\n\n    if (circular) {\n      var index = allParents.indexOf(parent);\n\n      if (index != -1) {\n        return allChildren[index];\n      }\n      allParents.push(parent);\n      allChildren.push(child);\n    }\n\n    for (var i in parent) {\n      var attrs;\n      if (proto) {\n        attrs = Object.getOwnPropertyDescriptor(proto, i);\n      }\n\n      if (attrs && attrs.set == null) {\n        continue;\n      }\n      child[i] = _clone(parent[i], depth - 1);\n    }\n\n    return child;\n  }\n\n  return _clone(parent, depth);\n}\n\n/**\n * Simple flat clone using prototype, accepts only objects, usefull for property\n * override on FLAT configuration object (no nested props).\n *\n * USE WITH CAUTION! This may not behave as you wish if you do not know how this\n * works.\n */\nclone.clonePrototype = function clonePrototype(parent) {\n  if (parent === null)\n    return null;\n\n  var c = function () {};\n  c.prototype = parent;\n  return new c();\n};\n\n// private utility functions\n\nfunction __objToStr(o) {\n  return Object.prototype.toString.call(o);\n};\nclone.__objToStr = __objToStr;\n\nfunction __isDate(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Date]';\n};\nclone.__isDate = __isDate;\n\nfunction __isArray(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Array]';\n};\nclone.__isArray = __isArray;\n\nfunction __isRegExp(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';\n};\nclone.__isRegExp = __isRegExp;\n\nfunction __getRegExpFlags(re) {\n  var flags = '';\n  if (re.global) flags += 'g';\n  if (re.ignoreCase) flags += 'i';\n  if (re.multiline) flags += 'm';\n  return flags;\n};\nclone.__getRegExpFlags = __getRegExpFlags;\n\nreturn clone;\n})();\n\nif (typeof module === 'object' && module.exports) {\n  module.exports = clone;\n}\n\n}).call(this,require(\"buffer\").Buffer)\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,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","function compare(a, b, visited){\n    var aType = typeof a;\n\n    if(aType !== typeof b){\n        return false;\n    }\n\n    if(a == null || b == null || !(aType === 'object' || aType === 'function')){\n        if(aType === 'number' && isNaN(a) && isNaN(b)){\n            return true;\n        }\n\n        return a === b;\n    }\n\n    if(Array.isArray(a) !== Array.isArray(b)){\n        return false;\n    }\n\n    var aKeys = Object.keys(a),\n        bKeys = Object.keys(b);\n\n    if(aKeys.length !== bKeys.length){\n        return false;\n    }\n\n    var equal = true;\n\n    if(!visited){\n        visited = new Set();\n    }\n\n    aKeys.forEach(function(key){\n        if(!(key in b)){\n            equal = false;\n            return;\n        }\n        if(visited.has(a[key])){\n            return;\n        }\n        visited.add(a[key]);\n        if(!compare(a[key], b[key], visited)){\n            equal = false;\n            return;\n        }\n    });\n\n    return equal;\n};\n\nmodule.exports = function(a, b){\n    return compare(a, b);\n}","var WhatChanged = require('what-changed'),\n    same = require('same-value'),\n    firmer = require('./firmer'),\n    functionEmitter = require('function-emitter'),\n    setPrototypeOf = require('setprototypeof');\n\nvar propertyProto = Object.create(functionEmitter);\n\npropertyProto._fastn_property = true;\npropertyProto._firm = 1;\n\nfunction propertyTemplate(value){\n    if(!arguments.length){\n        return this.binding && this.binding() || this.property._value;\n    }\n\n    if(!this.destroyed){\n        if(this.binding){\n            this.binding(value);\n            return this.property;\n        }\n\n        this.valueUpdate(value);\n    }\n\n    return this.property;\n}\n\nfunction changeChecker(current, changes){\n    if(changes){\n        var changes = new WhatChanged(current, changes);\n\n        return function(value){\n            return Object.keys(changes.update(value)).length > 0;\n        };\n    }else{\n        var lastValue = current;\n        return function(newValue){\n            if(!same(lastValue, newValue)){\n                lastValue = newValue;\n                return true;\n            }\n        };\n    }\n}\n\n\nfunction propertyBinding(newBinding){\n    if(!arguments.length){\n        return this.binding;\n    }\n\n    if(!this.fastn.isBinding(newBinding)){\n        newBinding = this.fastn.binding(newBinding);\n    }\n\n    if(newBinding === this.binding){\n        return this.property;\n    }\n\n    if(this.binding){\n        this.binding.removeListener('change', this.valueUpdate);\n    }\n\n    this.binding = newBinding;\n\n    if(this.model){\n        this.property.attach(this.model, this.property._firm);\n    }\n\n    this.binding.on('change', this.valueUpdate);\n    this.valueUpdate(this.binding());\n\n    return this.property;\n};\n\nfunction attachProperty(object, firm){\n    if(firmer(this.property, firm)){\n        return this.property;\n    }\n\n    this.property._firm = firm;\n\n    if(!(object instanceof Object)){\n        object = {};\n    }\n\n    if(this.binding){\n        this.model = object;\n        this.binding.attach(object, 1);\n    }\n\n    if(this.property._events && 'attach' in this.property._events){\n        this.property.emit('attach', object, 1);\n    }\n\n    return this.property;\n};\n\nfunction detachProperty(firm){\n    if(firmer(this.property, firm)){\n        return this.property;\n    }\n\n    if(this.binding){\n        this.binding.removeListener('change', this.valueUpdate);\n        this.binding.detach(1);\n        this.model = null;\n    }\n\n    if(this.property._events && 'detach' in this.property._events){\n        this.property.emit('detach', 1);\n    }\n\n    return this.property;\n};\n\nfunction updateProperty(){\n    if(!this.destroyed){\n\n        if(this.property._update){\n            this.property._update(this.property._value, this.property);\n        }\n\n        this.property.emit('update', this.property._value);\n    }\n    return this.property;\n};\n\nfunction propertyUpdater(fn){\n    if(!arguments.length){\n        return this.property._update;\n    }\n    this.property._update = fn;\n    return this.property;\n};\n\nfunction destroyProperty(){\n    if(!this.destroyed){\n        this.destroyed = true;\n\n        this.property\n            .removeAllListeners('change')\n            .removeAllListeners('update')\n            .removeAllListeners('attach');\n\n        this.property.emit('destroy');\n        this.property.detach();\n        if(this.binding){\n            this.binding.destroy(true);\n        }\n    }\n    return this.property;\n};\n\nfunction propertyDestroyed(){\n    return this.destroyed;\n};\n\nfunction addPropertyTo(component, key){\n    component.setProperty(key, this.property);\n\n    return this.property;\n};\n\nfunction createProperty(currentValue, changes, updater){\n    if(typeof changes === 'function'){\n        updater = changes;\n        changes = null;\n    }\n\n    var propertyScope =\n        property = propertyTemplate.bind(propertyScope)\n        propertyScope = {\n            fastn: this,\n            hasChanged: changeChecker(currentValue, changes),\n            valueUpdate: function(value){\n                property._value = value;\n                if(!propertyScope.hasChanged(value)){\n                    return;\n                }\n                property.emit('change', property._value);\n                property.update();\n            }\n        };\n\n    var property = propertyScope.property = propertyTemplate.bind(propertyScope);\n\n    property._value = currentValue;\n    property._update = updater;\n\n    setPrototypeOf(property, propertyProto);\n\n    property.binding = propertyBinding.bind(propertyScope);\n    property.attach = attachProperty.bind(propertyScope);\n    property.detach = detachProperty.bind(propertyScope);\n    property.update = updateProperty.bind(propertyScope);\n    property.updater = propertyUpdater.bind(propertyScope);\n    property.destroy = destroyProperty.bind(propertyScope);\n    property.destroyed = propertyDestroyed.bind(propertyScope);\n    property.addTo = addPropertyTo.bind(propertyScope);\n\n    return property;\n};\n\nmodule.exports = createProperty;","var createProperty = require('./property'),\n    createBinding = require('./binding'),\n    BaseComponent = require('./baseComponent'),\n    crel = require('crel'),\n    Enti = require('enti'),\n    objectAssign = require('object-assign'),\n    is = require('./is');\n\nfunction inflateProperties(component, settings){\n    for(var key in settings){\n        var setting = settings[key],\n            property = component[key];\n\n        if(is.property(settings[key])){\n\n            if(is.property(property)){\n                property.destroy();\n            }\n\n            setting.addTo(component, key);\n\n        }else if(is.property(property)){\n\n            if(is.binding(setting)){\n                property.binding(setting);\n            }else{\n                property(setting);\n            }\n\n            property.addTo(component, key);\n        }\n    }\n}\n\nfunction validateExpectedComponents(components, componentName, expectedComponents){\n    expectedComponents = expectedComponents.filter(function(componentName){\n        return !(componentName in components);\n    });\n\n    if(expectedComponents.length){\n        console.warn([\n            'fastn(\"' + componentName + '\") uses some components that have not been registered with fastn',\n            'Expected conponent constructors: ' + expectedComponents.join(', ')\n        ].join('\\n\\n'));\n    }\n}\n\nmodule.exports = function(components, debug){\n\n    if(!components || typeof components !== 'object'){\n        throw new Error('fastn must be initialised with a components object');\n    }\n\n    components._container = components._container || require('./containerComponent');\n\n    function fastn(type){\n\n        var args = [];\n        for(var i = 0; i < arguments.length; i++){\n            args[i] = arguments[i];\n        }\n\n        var settings = args[1],\n            childrenIndex = 2,\n            settingsChild = fastn.toComponent(args[1]);\n\n        if(Array.isArray(args[1]) || settingsChild || !args[1]){\n            args[1] = settingsChild || args[1];\n            childrenIndex--;\n            settings = null;\n        }\n\n        settings = objectAssign({}, settings || {});\n\n        var types = typeof type === 'string' ? type.split(':') : Array.isArray(type) ? type : [type],\n            baseType,\n            children = args.slice(childrenIndex),\n            component = fastn.base(type, settings, children);\n\n        while(baseType = types.shift()){\n            component.extend(baseType, settings, children);\n        }\n\n        component._properties = {};\n\n        inflateProperties(component, settings);\n\n        return component;\n    }\n\n    fastn.toComponent = function(component){\n        if(component == null){\n            return;\n        }\n        if(is.component(component)){\n            return component;\n        }\n        if(typeof component !== 'object' || component instanceof Date){\n            return fastn('text', {auto: true}, component);\n        }\n        if(crel.isElement(component)){\n            return fastn(component);\n        }\n        if(crel.isNode(component)){\n            return fastn('text', {auto: true}, component.textContent);\n        }\n    };\n\n    fastn.debug = debug;\n    fastn.property = createProperty.bind(fastn);\n    fastn.binding = createBinding(fastn);\n    fastn.isComponent = is.component;\n    fastn.isBinding = is.binding;\n    fastn.isDefaultBinding = is.defaultBinding;\n    fastn.isBindingObject = is.bindingObject;\n    fastn.isProperty = is.property;\n    fastn.components = components;\n    fastn.Model = Enti;\n    fastn.isModel = Enti.isEnti.bind(Enti);\n\n    fastn.base = function(type, settings, children){\n        return new BaseComponent(fastn, type, settings, children);\n    };\n\n    for(var key in components){\n        var componentConstructor = components[key];\n\n        if(componentConstructor.expectedComponents){\n            validateExpectedComponents(components, key, componentConstructor.expectedComponents);\n        }\n    }\n\n    return fastn;\n};"]} | |
require=(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})({"fastn/textComponent":[function(require,module,exports){ | |
function updateText(){ | |
if(!this.element){ | |
return; | |
} | |
var value = this.text(); | |
this.element.textContent = (value == null ? '' : value); | |
} | |
function autoRender(content){ | |
this.element = document.createTextNode(content); | |
} | |
function autoText(text, fastn, content) { | |
text.render = autoRender.bind(text, content); | |
return text; | |
} | |
function render(){ | |
this.element = this.createTextNode(this.text()); | |
this.emit('render'); | |
}; | |
function textComponent(fastn, component, type, settings, children){ | |
if(settings.auto){ | |
delete settings.auto; | |
if(!fastn.isBinding(children[0])){ | |
return autoText(component, fastn, children[0]); | |
} | |
settings.text = children.pop(); | |
} | |
component.createTextNode = textComponent.createTextNode; | |
component.render = render.bind(component); | |
component.setProperty('text', fastn.property('', updateText.bind(component))); | |
return component; | |
} | |
textComponent.createTextNode = function(text){ | |
return document.createTextNode(text); | |
}; | |
module.exports = textComponent; | |
},{}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2hvbWUvYWRtaW4vYnJvd3NlcmlmeS1jZG4vbm9kZV9tb2R1bGVzL2Jyb3dzZXJpZnkvbm9kZV9tb2R1bGVzL2Jyb3dzZXItcGFjay9fcHJlbHVkZS5qcyIsInRleHRDb21wb25lbnQuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7QUNBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIoZnVuY3Rpb24gZSh0LG4scil7ZnVuY3Rpb24gcyhvLHUpe2lmKCFuW29dKXtpZighdFtvXSl7dmFyIGE9dHlwZW9mIHJlcXVpcmU9PVwiZnVuY3Rpb25cIiYmcmVxdWlyZTtpZighdSYmYSlyZXR1cm4gYShvLCEwKTtpZihpKXJldHVybiBpKG8sITApO3ZhciBmPW5ldyBFcnJvcihcIkNhbm5vdCBmaW5kIG1vZHVsZSAnXCIrbytcIidcIik7dGhyb3cgZi5jb2RlPVwiTU9EVUxFX05PVF9GT1VORFwiLGZ9dmFyIGw9bltvXT17ZXhwb3J0czp7fX07dFtvXVswXS5jYWxsKGwuZXhwb3J0cyxmdW5jdGlvbihlKXt2YXIgbj10W29dWzFdW2VdO3JldHVybiBzKG4/bjplKX0sbCxsLmV4cG9ydHMsZSx0LG4scil9cmV0dXJuIG5bb10uZXhwb3J0c312YXIgaT10eXBlb2YgcmVxdWlyZT09XCJmdW5jdGlvblwiJiZyZXF1aXJlO2Zvcih2YXIgbz0wO288ci5sZW5ndGg7bysrKXMocltvXSk7cmV0dXJuIHN9KSIsImZ1bmN0aW9uIHVwZGF0ZVRleHQoKXtcbiAgICBpZighdGhpcy5lbGVtZW50KXtcbiAgICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIHZhciB2YWx1ZSA9IHRoaXMudGV4dCgpO1xuXG4gICAgdGhpcy5lbGVtZW50LnRleHRDb250ZW50ID0gKHZhbHVlID09IG51bGwgPyAnJyA6IHZhbHVlKTtcbn1cblxuZnVuY3Rpb24gYXV0b1JlbmRlcihjb250ZW50KXtcbiAgICB0aGlzLmVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShjb250ZW50KTtcbn1cblxuZnVuY3Rpb24gYXV0b1RleHQodGV4dCwgZmFzdG4sIGNvbnRlbnQpIHtcbiAgICB0ZXh0LnJlbmRlciA9IGF1dG9SZW5kZXIuYmluZCh0ZXh0LCBjb250ZW50KTtcblxuICAgIHJldHVybiB0ZXh0O1xufVxuXG5mdW5jdGlvbiByZW5kZXIoKXtcbiAgICB0aGlzLmVsZW1lbnQgPSB0aGlzLmNyZWF0ZVRleHROb2RlKHRoaXMudGV4dCgpKTtcbiAgICB0aGlzLmVtaXQoJ3JlbmRlcicpO1xufTtcblxuZnVuY3Rpb24gdGV4dENvbXBvbmVudChmYXN0biwgY29tcG9uZW50LCB0eXBlLCBzZXR0aW5ncywgY2hpbGRyZW4pe1xuICAgIGlmKHNldHRpbmdzLmF1dG8pe1xuICAgICAgICBkZWxldGUgc2V0dGluZ3MuYXV0bztcbiAgICAgICAgaWYoIWZhc3RuLmlzQmluZGluZyhjaGlsZHJlblswXSkpe1xuICAgICAgICAgICAgcmV0dXJuIGF1dG9UZXh0KGNvbXBvbmVudCwgZmFzdG4sIGNoaWxkcmVuWzBdKTtcbiAgICAgICAgfVxuICAgICAgICBzZXR0aW5ncy50ZXh0ID0gY2hpbGRyZW4ucG9wKCk7XG4gICAgfVxuXG4gICAgY29tcG9uZW50LmNyZWF0ZVRleHROb2RlID0gdGV4dENvbXBvbmVudC5jcmVhdGVUZXh0Tm9kZTtcbiAgICBjb21wb25lbnQucmVuZGVyID0gcmVuZGVyLmJpbmQoY29tcG9uZW50KTtcblxuICAgIGNvbXBvbmVudC5zZXRQcm9wZXJ0eSgndGV4dCcsIGZhc3RuLnByb3BlcnR5KCcnLCB1cGRhdGVUZXh0LmJpbmQoY29tcG9uZW50KSkpO1xuXG4gICAgcmV0dXJuIGNvbXBvbmVudDtcbn1cblxudGV4dENvbXBvbmVudC5jcmVhdGVUZXh0Tm9kZSA9IGZ1bmN0aW9uKHRleHQpe1xuICAgIHJldHVybiBkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSh0ZXh0KTtcbn07XG5cbm1vZHVsZS5leHBvcnRzID0gdGV4dENvbXBvbmVudDsiXX0= | |
require=(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})({"fastn/templaterComponent":[function(require,module,exports){ | |
module.exports = function(fastn, component, type, settings, children){ | |
var itemModel = new fastn.Model({}); | |
if(!('template' in settings)){ | |
console.warn('No "template" function was set for this templater component'); | |
} | |
function replaceElement(element){ | |
if(component.element && component.element.parentNode){ | |
component.element.parentNode.replaceChild(element, component.element); | |
} | |
component.element = element; | |
} | |
function update(){ | |
var value = component.data(), | |
template = component.template(); | |
itemModel.set('item', value); | |
var newComponent; | |
if(template){ | |
newComponent = fastn.toComponent(template(itemModel, component.scope(), component._currentComponent)); | |
} | |
if(component._currentComponent && component._currentComponent !== newComponent){ | |
if(fastn.isComponent(component._currentComponent)){ | |
component._currentComponent.destroy(); | |
} | |
} | |
component._currentComponent = newComponent; | |
if(!newComponent){ | |
replaceElement(component.emptyElement); | |
return; | |
} | |
if(fastn.isComponent(newComponent)){ | |
if(component._settings.attachTemplates !== false){ | |
newComponent.attach(itemModel, 2); | |
}else{ | |
newComponent.attach(component.scope(), 1); | |
} | |
if(component.element && component.element !== newComponent.element){ | |
if(newComponent.element == null){ | |
newComponent.render(); | |
} | |
replaceElement(component._currentComponent.element); | |
} | |
} | |
} | |
component.render = function(){ | |
var element; | |
component.emptyElement = document.createTextNode(''); | |
if(component._currentComponent){ | |
component._currentComponent.render(); | |
element = component._currentComponent.element; | |
} | |
component.element = element || component.emptyElement; | |
component.emit('render'); | |
}; | |
component.setProperty('data', | |
fastn.property(undefined, settings.dataChanges || 'value structure') | |
.on('change', update) | |
); | |
component.setProperty('template', | |
fastn.property(undefined, 'value reference') | |
.on('change', update) | |
); | |
component.on('destroy', function(){ | |
if(fastn.isComponent(component._currentComponent)){ | |
component._currentComponent.destroy(); | |
} | |
}); | |
component.on('attach', function(data){ | |
if(fastn.isComponent(component._currentComponent)){ | |
component._currentComponent.attach(component.scope(), 1); | |
} | |
}); | |
return component; | |
}; | |
},{}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,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 | |
require=(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 insertChild(fastn, container, child, index){ | |
if(child == null || child === false){ | |
return; | |
} | |
var currentIndex = container._children.indexOf(child), | |
newComponent = fastn.toComponent(child); | |
if(newComponent !== child && ~currentIndex){ | |
container._children.splice(currentIndex, 1, newComponent); | |
} | |
if(!~currentIndex || newComponent !== child){ | |
newComponent.attach(container.scope(), 1); | |
} | |
if(currentIndex !== index){ | |
if(~currentIndex){ | |
container._children.splice(currentIndex, 1); | |
} | |
container._children.splice(index, 0, newComponent); | |
} | |
if(container.element){ | |
if(!newComponent.element){ | |
newComponent.render(); | |
} | |
container._insert(newComponent.element, index); | |
newComponent.emit('insert', container); | |
container.emit('childInsert', newComponent); | |
} | |
} | |
function getContainerElement(){ | |
return this.containerElement || this.element; | |
} | |
function insert(child, index){ | |
var childComponent = child, | |
container = this.container, | |
fastn = this.fastn; | |
if(index && typeof index === 'object'){ | |
childComponent = Array.prototype.slice.call(arguments); | |
} | |
if(isNaN(index)){ | |
index = container._children.length; | |
} | |
if(Array.isArray(childComponent)){ | |
for (var i = 0; i < childComponent.length; i++) { | |
container.insert(childComponent[i], i + index); | |
} | |
}else{ | |
insertChild(fastn, container, childComponent, index); | |
} | |
return container; | |
} | |
module.exports = function(fastn, component, type, settings, children){ | |
component.insert = insert.bind({ | |
container: component, | |
fastn: fastn | |
}); | |
component._insert = function(element, index){ | |
var containerElement = component.getContainerElement(); | |
if(!containerElement){ | |
return; | |
} | |
if(containerElement.childNodes[index] === element){ | |
return; | |
} | |
containerElement.insertBefore(element, containerElement.childNodes[index]); | |
}; | |
component.remove = function(childComponent){ | |
var index = component._children.indexOf(childComponent); | |
if(~index){ | |
component._children.splice(index,1); | |
} | |
childComponent.detach(1); | |
if(childComponent.element){ | |
component._remove(childComponent.element); | |
childComponent.emit('remove', component); | |
} | |
component.emit('childRemove', childComponent); | |
}; | |
component._remove = function(element){ | |
var containerElement = component.getContainerElement(); | |
if(!element || !containerElement || element.parentNode !== containerElement){ | |
return; | |
} | |
containerElement.removeChild(element); | |
}; | |
component.empty = function(){ | |
while(component._children.length){ | |
component.remove(component._children.pop()); | |
} | |
}; | |
component.replaceChild = function(oldChild, newChild){ | |
var index = component._children.indexOf(oldChild); | |
if(!~index){ | |
return; | |
} | |
component.remove(oldChild); | |
component.insert(newChild, index); | |
}; | |
component.getContainerElement = getContainerElement.bind(component); | |
component.on('render', component.insert.bind(null, component._children, 0)); | |
component.on('attach', function(model, firm){ | |
for(var i = 0; i < component._children.length; i++){ | |
if(fastn.isComponent(component._children[i])){ | |
component._children[i].attach(model, firm); | |
} | |
} | |
}); | |
component.on('destroy', function(data, firm){ | |
for(var i = 0; i < component._children.length; i++){ | |
if(fastn.isComponent(component._children[i])){ | |
component._children[i].destroy(firm); | |
} | |
} | |
}); | |
return component; | |
}; | |
},{}],2:[function(require,module,exports){ | |
var setify = require('setify'), | |
classist = require('classist'); | |
function updateTextProperty(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.textContent; | |
} | |
element.textContent = (value == null ? '' : value); | |
} | |
module.exports = { | |
class: function(generic, element, value){ | |
if(!generic._classist){ | |
generic._classist = classist(element); | |
} | |
if(arguments.length < 3){ | |
return generic._classist(); | |
} | |
generic._classist(value); | |
}, | |
display: function(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.style.display !== 'none'; | |
} | |
element.style.display = value ? null : 'none'; | |
}, | |
disabled: function(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.hasAttribute('disabled'); | |
} | |
if(value){ | |
element.setAttribute('disabled', 'disabled'); | |
}else{ | |
element.removeAttribute('disabled'); | |
} | |
}, | |
textContent: updateTextProperty, | |
innerText: updateTextProperty, | |
innerHTML: function(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.innerHTML; | |
} | |
element.innerHTML = (value == null ? '' : value); | |
}, | |
value: function(generic, element, value){ | |
var inputType = element.type; | |
if(element.nodeName === 'INPUT' && inputType === 'date'){ | |
if(arguments.length === 2){ | |
return element.value ? new Date(element.value.replace(/-/g,'/').replace('T',' ')) : null; | |
} | |
value = value != null ? new Date(value) : null; | |
if(!value || isNaN(value)){ | |
element.value = null; | |
}else{ | |
element.value = [ | |
value.getFullYear(), | |
('0' + (value.getMonth() + 1)).slice(-2), | |
('0' + value.getDate()).slice(-2) | |
].join('-'); | |
} | |
return; | |
} | |
if(arguments.length === 2){ | |
return element.value; | |
} | |
if(value === undefined){ | |
value = null; | |
} | |
if(element.nodeName === 'PROGRESS'){ | |
value = parseFloat(value) || 0; | |
} | |
setify(element, value); | |
}, | |
max: function(generic, element, value) { | |
if(arguments.length === 2){ | |
return element.value; | |
} | |
if(element.nodeName === 'PROGRESS'){ | |
value = parseFloat(value) || 0; | |
} | |
element.max = value; | |
}, | |
style: function(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.style; | |
} | |
for(var key in value){ | |
element.style[key] = value[key]; | |
} | |
}, | |
type: function(generic, element, value){ | |
if(arguments.length === 2){ | |
return element.type; | |
} | |
element.setAttribute('type', value); | |
} | |
}; | |
},{"classist":3,"setify":4}],3:[function(require,module,exports){ | |
module.exports = function(element){ | |
var lastClasses = []; | |
return function(classes){ | |
if(!arguments.length){ | |
return lastClasses.join(' '); | |
} | |
function cleanClassName(result, className){ | |
if(typeof className === 'string' && className.match(/\s/)){ | |
className = className.split(' '); | |
} | |
if(Array.isArray(className)){ | |
return result.concat(className.reduce(cleanClassName, [])); | |
} | |
if(className != null && className !== '' && typeof className !== 'boolean'){ | |
result.push(String(className).trim()); | |
} | |
return result; | |
} | |
var newClasses = cleanClassName([], classes), | |
currentClasses = element.className ? element.className.split(' ') : []; | |
lastClasses.map(function(className){ | |
if(!className){ | |
return; | |
} | |
var index = currentClasses.indexOf(className); | |
if(~index){ | |
currentClasses.splice(index, 1); | |
} | |
}); | |
currentClasses = currentClasses.concat(newClasses); | |
lastClasses = newClasses; | |
element.className = currentClasses.join(' '); | |
}; | |
}; | |
},{}],4:[function(require,module,exports){ | |
var naturalSelection = require('natural-selection'); | |
module.exports = function(element, value){ | |
var canSet = naturalSelection(element) && element === document.activeElement; | |
if (canSet) { | |
var start = element.selectionStart, | |
end = element.selectionEnd; | |
element.value = value; | |
element.setSelectionRange(start, end); | |
} else { | |
element.value = value; | |
} | |
}; | |
},{"natural-selection":5}],5:[function(require,module,exports){ | |
var supportedTypes = ['text', 'search', 'tel', 'url', 'password']; | |
module.exports = function(element){ | |
return !!(element.setSelectionRange && ~supportedTypes.indexOf(element.type)); | |
}; | |
},{}],6:[function(require,module,exports){ | |
var todo = [], | |
todoKeys = [], | |
scheduled, | |
updates = 0; | |
function run(){ | |
var startTime = Date.now(); | |
while(todo.length && Date.now() - startTime < 16){ | |
todoKeys.shift(); | |
todo.shift()(); | |
} | |
if(todo.length){ | |
requestAnimationFrame(run); | |
}else{ | |
scheduled = false; | |
} | |
} | |
function schedule(key, fn){ | |
if(~todoKeys.indexOf(key)){ | |
return; | |
} | |
todo.push(fn); | |
todoKeys.push(key); | |
if(!scheduled){ | |
scheduled = true; | |
requestAnimationFrame(run); | |
} | |
} | |
module.exports = schedule; | |
},{}],"fastn/genericComponent":[function(require,module,exports){ | |
var containerComponent = require('./containerComponent'), | |
schedule = require('./schedule'), | |
fancyProps = require('./fancyProps'), | |
matchDomHandlerName = /^((?:el\.)?)([^. ]+)(?:\.(capture))?$/, | |
GENERIC = '_generic'; | |
function createProperties(fastn, component, settings){ | |
for(var key in settings){ | |
var setting = settings[key]; | |
if(typeof setting === 'function' && !fastn.isProperty(setting) && !fastn.isBinding(setting)){ | |
continue; | |
} | |
component.addDomProperty(key); | |
} | |
} | |
function trackKeyEvents(component, element, event){ | |
if('_lastStates' in component && 'charCode' in event){ | |
component._lastStates.unshift(element.value); | |
component._lastStates.pop(); | |
} | |
} | |
function addDomHandler(component, element, handlerName, eventName, capture){ | |
var eventParts = handlerName.split('.'); | |
if(eventParts[0] === 'on'){ | |
eventParts.shift(); | |
} | |
var handler = function(event){ | |
trackKeyEvents(component, element, event); | |
component.emit(handlerName, event, component.scope()); | |
}; | |
element.addEventListener(eventName, handler, capture); | |
component.on('destroy', function(){ | |
element.removeEventListener(eventName, handler, capture); | |
}); | |
} | |
function addDomHandlers(component, element, eventNames){ | |
var events = eventNames.split(' '); | |
for(var i = 0; i < events.length; i++){ | |
var eventName = events[i], | |
match = eventName.match(matchDomHandlerName); | |
if(!match){ | |
continue; | |
} | |
if(match[1] || 'on' + match[2] in element){ | |
addDomHandler(component, element, eventNames, match[2], match[3]); | |
} | |
} | |
} | |
function addAutoHandler(component, element, key, settings){ | |
if(!settings[key]){ | |
return; | |
} | |
var autoEvent = settings[key].split(':'), | |
eventName = key.slice(2); | |
delete settings[key]; | |
var handler = function(event){ | |
var fancyProp = fancyProps[autoEvent[1]], | |
value = fancyProp ? fancyProp(component, element) : element[autoEvent[1]]; | |
trackKeyEvents(component, element, event); | |
component[autoEvent[0]](value); | |
}; | |
element.addEventListener(eventName, handler); | |
component.on('destroy', function(){ | |
element.removeEventListener(eventName, handler); | |
}); | |
} | |
function addDomProperty(fastn, key, property){ | |
var component = this, | |
timeout; | |
property = property || component[key] || fastn.property(); | |
component.setProperty(key, property); | |
function update(){ | |
var element = component.getPropertyElement(key), | |
value = property(); | |
if(!element || component.destroyed()){ | |
return; | |
} | |
if( | |
key === 'value' && | |
component._lastStates && | |
~component._lastStates.indexOf(value) | |
){ | |
clearTimeout(timeout); | |
timeout = setTimeout(update, 50); | |
return; | |
} | |
var isProperty = key in element, | |
fancyProp = fancyProps[key], | |
previous = fancyProp ? fancyProp(component, element) : isProperty ? element[key] : element.getAttribute(key); | |
if(!fancyProp && !isProperty && value == null){ | |
value = ''; | |
} | |
if(value !== previous){ | |
if(fancyProp){ | |
fancyProp(component, element, value); | |
return; | |
} | |
if(isProperty){ | |
element[key] = value; | |
return; | |
} | |
if(typeof value !== 'function' && typeof value !== 'object'){ | |
element.setAttribute(key, value); | |
} | |
} | |
} | |
property.updater(update); | |
} | |
function onRender(){ | |
var component = this, | |
element; | |
for(var key in component._settings){ | |
element = component.getEventElement(key); | |
if(key.slice(0,2) === 'on' && key in element){ | |
addAutoHandler(component, element, key, component._settings); | |
} | |
} | |
for(var eventKey in component._events){ | |
element = component.getEventElement(key); | |
addDomHandlers(component, element, eventKey); | |
} | |
} | |
function render(){ | |
this.element = this.createElement(this._settings.tagName || this._tagName); | |
if('value' in this.element){ | |
this._lastStates = new Array(2); | |
} | |
this.emit('render'); | |
return this; | |
}; | |
function genericComponent(fastn, component, type, settings, children){ | |
if(component.is(type)){ | |
return component; | |
} | |
if(type === GENERIC){ | |
component._tagName = component._tagName || 'div'; | |
}else{ | |
component._tagName = type; | |
} | |
if(component.is(GENERIC)){ | |
return component; | |
} | |
component.extend('_container', settings, children); | |
component.addDomProperty = addDomProperty.bind(component, fastn); | |
component.getEventElement = component.getContainerElement; | |
component.getPropertyElement = component.getContainerElement; | |
component.updateProperty = genericComponent.updateProperty; | |
component.createElement = genericComponent.createElement; | |
createProperties(fastn, component, settings); | |
component.render = render.bind(component); | |
component.on('render', onRender); | |
return component; | |
} | |
genericComponent.updateProperty = function(component, property, update){ | |
if(typeof document !== 'undefined' && document.contains(component.element)){ | |
schedule(property, update); | |
}else{ | |
update(); | |
} | |
}; | |
genericComponent.createElement = function(tagName){ | |
if(tagName instanceof Node){ | |
return tagName; | |
} | |
return document.createElement(tagName); | |
}; | |
module.exports = genericComponent; | |
},{"./containerComponent":1,"./fancyProps":2,"./schedule":6}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","containerComponent.js","fancyProps.js","node_modules/classist/index.js","node_modules/setify/index.js","node_modules/setify/node_modules/natural-selection/index.js","schedule.js","genericComponent.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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})","function insertChild(fastn, container, child, index){\n    if(child == null || child === false){\n        return;\n    }\n\n    var currentIndex = container._children.indexOf(child),\n        newComponent = fastn.toComponent(child);\n\n    if(newComponent !== child && ~currentIndex){\n        container._children.splice(currentIndex, 1, newComponent);\n    }\n\n    if(!~currentIndex || newComponent !== child){\n        newComponent.attach(container.scope(), 1);\n    }\n\n    if(currentIndex !== index){\n        if(~currentIndex){\n            container._children.splice(currentIndex, 1);\n        }\n        container._children.splice(index, 0, newComponent);\n    }\n\n    if(container.element){\n        if(!newComponent.element){\n            newComponent.render();\n        }\n        container._insert(newComponent.element, index);\n        newComponent.emit('insert', container);\n        container.emit('childInsert', newComponent);\n    }\n}\n\nfunction getContainerElement(){\n    return this.containerElement || this.element;\n}\n\nfunction insert(child, index){\n    var childComponent = child,\n        container = this.container,\n        fastn = this.fastn;\n\n    if(index && typeof index === 'object'){\n        childComponent = Array.prototype.slice.call(arguments);\n    }\n\n    if(isNaN(index)){\n        index = container._children.length;\n    }\n\n    if(Array.isArray(childComponent)){\n        for (var i = 0; i < childComponent.length; i++) {\n            container.insert(childComponent[i], i + index);\n        }\n    }else{\n        insertChild(fastn, container, childComponent, index);\n    }\n\n    return container;\n}\n\nmodule.exports = function(fastn, component, type, settings, children){\n    component.insert = insert.bind({\n        container: component,\n        fastn: fastn\n    });\n\n    component._insert = function(element, index){\n        var containerElement = component.getContainerElement();\n        if(!containerElement){\n            return;\n        }\n\n        if(containerElement.childNodes[index] === element){\n            return;\n        }\n\n        containerElement.insertBefore(element, containerElement.childNodes[index]);\n    };\n\n    component.remove = function(childComponent){\n        var index = component._children.indexOf(childComponent);\n        if(~index){\n            component._children.splice(index,1);\n        }\n\n        childComponent.detach(1);\n\n        if(childComponent.element){\n            component._remove(childComponent.element);\n            childComponent.emit('remove', component);\n        }\n        component.emit('childRemove', childComponent);\n    };\n\n    component._remove = function(element){\n        var containerElement = component.getContainerElement();\n\n        if(!element || !containerElement || element.parentNode !== containerElement){\n            return;\n        }\n\n        containerElement.removeChild(element);\n    };\n\n    component.empty = function(){\n        while(component._children.length){\n            component.remove(component._children.pop());\n        }\n    };\n\n    component.replaceChild = function(oldChild, newChild){\n        var index = component._children.indexOf(oldChild);\n\n        if(!~index){\n            return;\n        }\n\n        component.remove(oldChild);\n        component.insert(newChild, index);\n    };\n\n    component.getContainerElement = getContainerElement.bind(component);\n\n    component.on('render', component.insert.bind(null, component._children, 0));\n\n    component.on('attach', function(model, firm){\n        for(var i = 0; i < component._children.length; i++){\n            if(fastn.isComponent(component._children[i])){\n                component._children[i].attach(model, firm);\n            }\n        }\n    });\n\n    component.on('destroy', function(data, firm){\n        for(var i = 0; i < component._children.length; i++){\n            if(fastn.isComponent(component._children[i])){\n                component._children[i].destroy(firm);\n            }\n        }\n    });\n\n    return component;\n};","var setify = require('setify'),\n    classist = require('classist');\n\nfunction updateTextProperty(generic, element, value){\n    if(arguments.length === 2){\n        return element.textContent;\n    }\n    element.textContent = (value == null ? '' : value);\n}\n\nmodule.exports = {\n    class: function(generic, element, value){\n        if(!generic._classist){\n            generic._classist = classist(element);\n        }\n\n        if(arguments.length < 3){\n            return generic._classist();\n        }\n\n        generic._classist(value);\n    },\n    display: function(generic, element, value){\n        if(arguments.length === 2){\n            return element.style.display !== 'none';\n        }\n        element.style.display = value ? null : 'none';\n    },\n    disabled: function(generic, element, value){\n        if(arguments.length === 2){\n            return element.hasAttribute('disabled');\n        }\n        if(value){\n            element.setAttribute('disabled', 'disabled');\n        }else{\n            element.removeAttribute('disabled');\n        }\n    },\n    textContent: updateTextProperty,\n    innerText: updateTextProperty,\n    innerHTML: function(generic, element, value){\n        if(arguments.length === 2){\n            return element.innerHTML;\n        }\n        element.innerHTML = (value == null ? '' : value);\n    },\n    value: function(generic, element, value){\n        var inputType = element.type;\n\n        if(element.nodeName === 'INPUT' && inputType === 'date'){\n            if(arguments.length === 2){\n                return element.value ? new Date(element.value.replace(/-/g,'/').replace('T',' ')) : null;\n            }\n\n            value = value != null ? new Date(value) : null;\n\n            if(!value || isNaN(value)){\n                element.value = null;\n            }else{\n                element.value = [\n                    value.getFullYear(),\n                    ('0' + (value.getMonth() + 1)).slice(-2),\n                    ('0' + value.getDate()).slice(-2)\n                ].join('-');\n            }\n            return;\n        }\n\n        if(arguments.length === 2){\n            return element.value;\n        }\n        if(value === undefined){\n            value = null;\n        }\n\n        if(element.nodeName === 'PROGRESS'){\n            value = parseFloat(value) || 0;\n        }\n\n        setify(element, value);\n    },\n    max: function(generic, element, value) {\n        if(arguments.length === 2){\n            return element.value;\n        }\n\n        if(element.nodeName === 'PROGRESS'){\n            value = parseFloat(value) || 0;\n        }\n\n        element.max = value;\n    },\n    style: function(generic, element, value){\n        if(arguments.length === 2){\n            return element.style;\n        }\n\n        for(var key in value){\n            element.style[key] = value[key];\n        }\n    },\n    type: function(generic, element, value){\n        if(arguments.length === 2){\n            return element.type;\n        }\n        element.setAttribute('type', value);\n    }\n};","module.exports = function(element){\n    var lastClasses = [];\n\n    return function(classes){\n\n        if(!arguments.length){\n            return lastClasses.join(' ');\n        }\n\n        function cleanClassName(result, className){\n            if(typeof className === 'string' && className.match(/\\s/)){\n                className = className.split(' ');\n            }\n\n            if(Array.isArray(className)){\n                return result.concat(className.reduce(cleanClassName, []));\n            }\n\n            if(className != null && className !== '' && typeof className !== 'boolean'){\n                result.push(String(className).trim());\n            }\n\n            return result;\n        }\n\n        var newClasses = cleanClassName([], classes),\n            currentClasses = element.className ? element.className.split(' ') : [];\n\n        lastClasses.map(function(className){\n            if(!className){\n                return;\n            }\n\n            var index = currentClasses.indexOf(className);\n\n            if(~index){\n                currentClasses.splice(index, 1);\n            }\n        });\n\n        currentClasses = currentClasses.concat(newClasses);\n        lastClasses = newClasses;\n\n        element.className = currentClasses.join(' ');\n    };\n};\n","var naturalSelection = require('natural-selection');\n\nmodule.exports = function(element, value){\n    var canSet = naturalSelection(element) && element === document.activeElement;\n\n    if (canSet) {\n        var start = element.selectionStart,\n            end = element.selectionEnd;\n\n        element.value = value;\n        element.setSelectionRange(start, end);\n    } else {\n        element.value = value;\n    }\n};\n","var supportedTypes = ['text', 'search', 'tel', 'url', 'password'];\n\nmodule.exports = function(element){\n    return !!(element.setSelectionRange && ~supportedTypes.indexOf(element.type));\n};\n","var todo = [],\n    todoKeys = [],\n    scheduled,\n    updates = 0;\n\nfunction run(){\n    var startTime = Date.now();\n\n    while(todo.length && Date.now() - startTime < 16){\n        todoKeys.shift();\n        todo.shift()();\n    }\n\n    if(todo.length){\n        requestAnimationFrame(run);\n    }else{\n        scheduled = false;\n    }\n}\n\nfunction schedule(key, fn){\n    if(~todoKeys.indexOf(key)){\n        return;\n    }\n\n    todo.push(fn);\n    todoKeys.push(key);\n\n    if(!scheduled){\n        scheduled = true;\n        requestAnimationFrame(run);\n    }\n}\n\nmodule.exports = schedule;","var containerComponent = require('./containerComponent'),\n    schedule = require('./schedule'),\n    fancyProps = require('./fancyProps'),\n    matchDomHandlerName = /^((?:el\\.)?)([^. ]+)(?:\\.(capture))?$/,\n    GENERIC = '_generic';\n\nfunction createProperties(fastn, component, settings){\n    for(var key in settings){\n        var setting = settings[key];\n\n        if(typeof setting === 'function' && !fastn.isProperty(setting) && !fastn.isBinding(setting)){\n            continue;\n        }\n\n        component.addDomProperty(key);\n    }\n}\n\nfunction trackKeyEvents(component, element, event){\n    if('_lastStates' in component && 'charCode' in event){\n        component._lastStates.unshift(element.value);\n        component._lastStates.pop();\n    }\n}\n\nfunction addDomHandler(component, element, handlerName, eventName, capture){\n    var eventParts = handlerName.split('.');\n\n    if(eventParts[0] === 'on'){\n        eventParts.shift();\n    }\n\n    var handler = function(event){\n            trackKeyEvents(component, element, event);\n            component.emit(handlerName, event, component.scope());\n        };\n\n    element.addEventListener(eventName, handler, capture);\n\n    component.on('destroy', function(){\n        element.removeEventListener(eventName, handler, capture);\n    });\n}\n\nfunction addDomHandlers(component, element, eventNames){\n    var events = eventNames.split(' ');\n\n    for(var i = 0; i < events.length; i++){\n        var eventName = events[i],\n            match = eventName.match(matchDomHandlerName);\n\n        if(!match){\n            continue;\n        }\n\n        if(match[1] || 'on' + match[2] in element){\n            addDomHandler(component, element, eventNames, match[2], match[3]);\n        }\n    }\n}\n\nfunction addAutoHandler(component, element, key, settings){\n    if(!settings[key]){\n        return;\n    }\n\n    var autoEvent = settings[key].split(':'),\n        eventName = key.slice(2);\n\n    delete settings[key];\n\n    var handler = function(event){\n        var fancyProp = fancyProps[autoEvent[1]],\n            value = fancyProp ? fancyProp(component, element) : element[autoEvent[1]];\n\n        trackKeyEvents(component, element, event);\n\n        component[autoEvent[0]](value);\n    };\n\n    element.addEventListener(eventName, handler);\n\n    component.on('destroy', function(){\n        element.removeEventListener(eventName, handler);\n    });\n}\n\nfunction addDomProperty(fastn, key, property){\n    var component = this,\n        timeout;\n\n    property = property || component[key] || fastn.property();\n    component.setProperty(key, property);\n\n    function update(){\n\n        var element = component.getPropertyElement(key),\n            value = property();\n\n        if(!element || component.destroyed()){\n            return;\n        }\n\n        if(\n            key === 'value' &&\n            component._lastStates &&\n            ~component._lastStates.indexOf(value)\n        ){\n            clearTimeout(timeout);\n            timeout = setTimeout(update, 50);\n            return;\n        }\n\n        var isProperty = key in element,\n            fancyProp = fancyProps[key],\n            previous = fancyProp ? fancyProp(component, element) : isProperty ? element[key] : element.getAttribute(key);\n\n        if(!fancyProp && !isProperty && value == null){\n            value = '';\n        }\n\n        if(value !== previous){\n            if(fancyProp){\n                fancyProp(component, element, value);\n                return;\n            }\n\n            if(isProperty){\n                element[key] = value;\n                return;\n            }\n\n            if(typeof value !== 'function' && typeof value !== 'object'){\n                element.setAttribute(key, value);\n            }\n        }\n    }\n\n    property.updater(update);\n}\n\nfunction onRender(){\n    var component = this,\n        element;\n\n    for(var key in component._settings){\n        element = component.getEventElement(key);\n        if(key.slice(0,2) === 'on' && key in element){\n            addAutoHandler(component, element, key, component._settings);\n        }\n    }\n\n    for(var eventKey in component._events){\n        element = component.getEventElement(key);\n        addDomHandlers(component, element, eventKey);\n    }\n}\n\nfunction render(){\n    this.element = this.createElement(this._settings.tagName || this._tagName);\n\n    if('value' in this.element){\n        this._lastStates = new Array(2);\n    }\n\n    this.emit('render');\n\n    return this;\n};\n\nfunction genericComponent(fastn, component, type, settings, children){\n    if(component.is(type)){\n        return component;\n    }\n\n    if(type === GENERIC){\n        component._tagName = component._tagName || 'div';\n    }else{\n        component._tagName = type;\n    }\n\n    if(component.is(GENERIC)){\n        return component;\n    }\n\n    component.extend('_container', settings, children);\n\n    component.addDomProperty = addDomProperty.bind(component, fastn);\n    component.getEventElement = component.getContainerElement;\n    component.getPropertyElement = component.getContainerElement;\n    component.updateProperty = genericComponent.updateProperty;\n    component.createElement = genericComponent.createElement;\n\n    createProperties(fastn, component, settings);\n\n    component.render = render.bind(component);\n\n    component.on('render', onRender);\n\n    return component;\n}\n\ngenericComponent.updateProperty = function(component, property, update){\n    if(typeof document !== 'undefined' && document.contains(component.element)){\n        schedule(property, update);\n    }else{\n        update();\n    }\n};\n\ngenericComponent.createElement = function(tagName){\n    if(tagName instanceof Node){\n        return tagName;\n    }\n    return document.createElement(tagName);\n};\n\nmodule.exports = genericComponent;"]} | |
require=(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 flatMerge(a,b){ | |
if(!b || typeof b !== 'object'){ | |
b = {}; | |
} | |
if(!a || typeof a !== 'object'){ | |
a = new b.constructor(); | |
} | |
var result = new a.constructor(), | |
aKeys = Object.keys(a), | |
bKeys = Object.keys(b); | |
for(var i = 0; i < aKeys.length; i++){ | |
result[aKeys[i]] = a[aKeys[i]]; | |
} | |
for(var i = 0; i < bKeys.length; i++){ | |
result[bKeys[i]] = b[bKeys[i]]; | |
} | |
return result; | |
} | |
module.exports = flatMerge; | |
},{}],2:[function(require,module,exports){ | |
"use strict"; | |
/* global module, define */ | |
function mapEach(map, operation){ | |
var keys = map.keys(); | |
var next; | |
while(!(next = keys.next()).done) { | |
operation(map.get(next.value), next.value, map); | |
} | |
} | |
var Multimap = (function() { | |
var mapCtor; | |
if (typeof Map !== 'undefined') { | |
mapCtor = Map; | |
if (!Map.prototype.keys) { | |
Map.prototype.keys = function() { | |
var keys = []; | |
this.forEach(function(item, key) { | |
keys.push(key); | |
}); | |
return keys; | |
}; | |
} | |
} | |
function Multimap(iterable) { | |
var self = this; | |
self._map = mapCtor; | |
if (Multimap.Map) { | |
self._map = Multimap.Map; | |
} | |
self._ = self._map ? new self._map() : {}; | |
if (iterable) { | |
iterable.forEach(function(i) { | |
self.set(i[0], i[1]); | |
}); | |
} | |
} | |
/** | |
* @param {Object} key | |
* @return {Array} An array of values, undefined if no such a key; | |
*/ | |
Multimap.prototype.get = function(key) { | |
return this._map ? this._.get(key) : this._[key]; | |
}; | |
/** | |
* @param {Object} key | |
* @param {Object} val... | |
*/ | |
Multimap.prototype.set = function(key, val) { | |
var args = Array.prototype.slice.call(arguments); | |
key = args.shift(); | |
var entry = this.get(key); | |
if (!entry) { | |
entry = []; | |
if (this._map) | |
this._.set(key, entry); | |
else | |
this._[key] = entry; | |
} | |
Array.prototype.push.apply(entry, args); | |
return this; | |
}; | |
/** | |
* @param {Object} key | |
* @param {Object=} val | |
* @return {boolean} true if any thing changed | |
*/ | |
Multimap.prototype.delete = function(key, val) { | |
if (!this.has(key)) | |
return false; | |
if (arguments.length == 1) { | |
this._map ? (this._.delete(key)) : (delete this._[key]); | |
return true; | |
} else { | |
var entry = this.get(key); | |
var idx = entry.indexOf(val); | |
if (idx != -1) { | |
entry.splice(idx, 1); | |
return true; | |
} | |
} | |
return false; | |
}; | |
/** | |
* @param {Object} key | |
* @param {Object=} val | |
* @return {boolean} whether the map contains 'key' or 'key=>val' pair | |
*/ | |
Multimap.prototype.has = function(key, val) { | |
var hasKey = this._map ? this._.has(key) : this._.hasOwnProperty(key); | |
if (arguments.length == 1 || !hasKey) | |
return hasKey; | |
var entry = this.get(key) || []; | |
return entry.indexOf(val) != -1; | |
}; | |
/** | |
* @return {Array} all the keys in the map | |
*/ | |
Multimap.prototype.keys = function() { | |
if (this._map) | |
return makeIterator(this._.keys()); | |
return makeIterator(Object.keys(this._)); | |
}; | |
/** | |
* @return {Array} all the values in the map | |
*/ | |
Multimap.prototype.values = function() { | |
var vals = []; | |
this.forEachEntry(function(entry) { | |
Array.prototype.push.apply(vals, entry); | |
}); | |
return makeIterator(vals); | |
}; | |
/** | |
* | |
*/ | |
Multimap.prototype.forEachEntry = function(iter) { | |
mapEach(this, iter); | |
}; | |
Multimap.prototype.forEach = function(iter) { | |
var self = this; | |
self.forEachEntry(function(entry, key) { | |
entry.forEach(function(item) { | |
iter(item, key, self); | |
}); | |
}); | |
}; | |
Multimap.prototype.clear = function() { | |
if (this._map) { | |
this._.clear(); | |
} else { | |
this._ = {}; | |
} | |
}; | |
Object.defineProperty( | |
Multimap.prototype, | |
"size", { | |
configurable: false, | |
enumerable: true, | |
get: function() { | |
var total = 0; | |
mapEach(this, function(value){ | |
total += value.length; | |
}); | |
return total; | |
} | |
}); | |
var safariNext; | |
try{ | |
safariNext = new Function('iterator', 'makeIterator', 'var keysArray = []; for(var key of iterator){keysArray.push(key);} return makeIterator(keysArray).next;'); | |
}catch(error){ | |
// for of not implemented; | |
} | |
function makeIterator(iterator){ | |
if(Array.isArray(iterator)){ | |
var nextIndex = 0; | |
return { | |
next: function(){ | |
return nextIndex < iterator.length ? | |
{value: iterator[nextIndex++], done: false} : | |
{done: true}; | |
} | |
}; | |
} | |
// Only an issue in safari | |
if(!iterator.next && safariNext){ | |
iterator.next = safariNext(iterator, makeIterator); | |
} | |
return iterator; | |
} | |
return Multimap; | |
})(); | |
if(typeof exports === 'object' && module && module.exports) | |
module.exports = Multimap; | |
else if(typeof define === 'function' && define.amd) | |
define(function() { return Multimap; }); | |
},{}],"fastn/listComponent":[function(require,module,exports){ | |
var MultiMap = require('multimap'), | |
merge = require('flat-merge'); | |
MultiMap.Map = Map; | |
function each(value, fn){ | |
if(!value || typeof value !== 'object'){ | |
return; | |
} | |
if(Array.isArray(value)){ | |
for(var i = 0; i < value.length; i++){ | |
fn(value[i], i) | |
} | |
}else{ | |
for(var key in value){ | |
fn(value[key], key); | |
} | |
} | |
} | |
function keyFor(object, value){ | |
if(!object || typeof object !== 'object'){ | |
return false; | |
} | |
if(Array.isArray(object)){ | |
var index = object.indexOf(value); | |
return index >=0 ? index : false; | |
} | |
for(var key in object){ | |
if(object[key] === value){ | |
return key; | |
} | |
} | |
return false; | |
} | |
module.exports = function(fastn, component, type, settings, children){ | |
if(fastn.components._generic){ | |
component.extend('_generic', settings, children); | |
}else{ | |
component.extend('_container', settings, children); | |
} | |
if(!('template' in settings)){ | |
console.warn('No "template" function was set for this templater component'); | |
} | |
var itemsMap = new MultiMap(), | |
dataMap = new WeakMap(), | |
lastTemplate, | |
existingItem = {}; | |
function updateItems(){ | |
var value = component.items(), | |
template = component.template(), | |
emptyTemplate = component.emptyTemplate(), | |
newTemplate = lastTemplate !== template; | |
var currentItems = merge(template ? value : []); | |
itemsMap.forEach(function(childComponent, item){ | |
var currentKey = keyFor(currentItems, item); | |
if(!newTemplate && currentKey !== false){ | |
currentItems[currentKey] = [existingItem, item, childComponent]; | |
}else{ | |
removeComponent(childComponent); | |
itemsMap.delete(item); | |
} | |
}); | |
var index = 0; | |
function updateItem(item, key){ | |
var child, | |
existing; | |
while(index < component._children.length && !component._children[index]._templated){ | |
index++; | |
} | |
if(Array.isArray(item) && item[0] === existingItem){ | |
existing = true; | |
child = item[2]; | |
item = item[1]; | |
} | |
var childModel; | |
if(!existing){ | |
childModel = new fastn.Model({ | |
item: item, | |
key: key | |
}); | |
child = fastn.toComponent(template(childModel, component.scope())); | |
if(!child){ | |
child = fastn('template'); | |
} | |
child._listItem = item; | |
child._templated = true; | |
dataMap.set(child, childModel); | |
itemsMap.set(item, child); | |
}else{ | |
childModel = dataMap.get(child); | |
childModel.set('key', key); | |
} | |
if(fastn.isComponent(child) && component._settings.attachTemplates !== false){ | |
child.attach(childModel, 2); | |
} | |
component.insert(child, index); | |
index++; | |
} | |
each(currentItems, updateItem); | |
lastTemplate = template; | |
if(index === 0 && emptyTemplate){ | |
var child = fastn.toComponent(emptyTemplate(component.scope())); | |
if(!child){ | |
child = fastn('template'); | |
} | |
child._templated = true; | |
itemsMap.set({}, child); | |
component.insert(child); | |
} | |
} | |
function removeComponent(childComponent){ | |
component.remove(childComponent); | |
childComponent.destroy(); | |
} | |
component.setProperty('items', | |
fastn.property([], settings.itemChanges || 'type keys shallowStructure') | |
.on('change', updateItems) | |
); | |
component.setProperty('template', | |
fastn.property().on('change', updateItems) | |
); | |
component.setProperty('emptyTemplate', | |
fastn.property().on('change', updateItems) | |
); | |
return component; | |
}; | |
},{"flat-merge":1,"multimap":2}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/flat-merge/index.js","node_modules/multimap/index.js","listComponent.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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})","function flatMerge(a,b){\n    if(!b || typeof b !== 'object'){\n        b = {};\n    }\n\n    if(!a || typeof a !== 'object'){\n        a = new b.constructor();\n    }\n\n    var result = new a.constructor(),\n        aKeys = Object.keys(a),\n        bKeys = Object.keys(b);\n\n    for(var i = 0; i < aKeys.length; i++){\n        result[aKeys[i]] = a[aKeys[i]];\n    }\n\n    for(var i = 0; i < bKeys.length; i++){\n        result[bKeys[i]] = b[bKeys[i]];\n    }\n\n    return result;\n}\n\nmodule.exports = flatMerge;","\"use strict\";\n\n/* global module, define */\n\nfunction mapEach(map, operation){\n  var keys = map.keys();\n  var next;\n  while(!(next = keys.next()).done) {\n    operation(map.get(next.value), next.value, map);\n  }\n}\n\nvar Multimap = (function() {\n  var mapCtor;\n  if (typeof Map !== 'undefined') {\n    mapCtor = Map;\n\n    if (!Map.prototype.keys) {\n      Map.prototype.keys = function() {\n        var keys = [];\n        this.forEach(function(item, key) {\n          keys.push(key);\n        });\n        return keys;\n      };\n    }\n  }\n\n  function Multimap(iterable) {\n    var self = this;\n\n    self._map = mapCtor;\n\n    if (Multimap.Map) {\n      self._map = Multimap.Map;\n    }\n\n    self._ = self._map ? new self._map() : {};\n\n    if (iterable) {\n      iterable.forEach(function(i) {\n        self.set(i[0], i[1]);\n      });\n    }\n  }\n\n  /**\n   * @param {Object} key\n   * @return {Array} An array of values, undefined if no such a key;\n   */\n  Multimap.prototype.get = function(key) {\n    return this._map ? this._.get(key) : this._[key];\n  };\n\n  /**\n   * @param {Object} key\n   * @param {Object} val...\n   */\n  Multimap.prototype.set = function(key, val) {\n    var args = Array.prototype.slice.call(arguments);\n\n    key = args.shift();\n\n    var entry = this.get(key);\n    if (!entry) {\n      entry = [];\n      if (this._map)\n        this._.set(key, entry);\n      else\n        this._[key] = entry;\n    }\n\n    Array.prototype.push.apply(entry, args);\n    return this;\n  };\n\n  /**\n   * @param {Object} key\n   * @param {Object=} val\n   * @return {boolean} true if any thing changed\n   */\n  Multimap.prototype.delete = function(key, val) {\n    if (!this.has(key))\n      return false;\n\n    if (arguments.length == 1) {\n      this._map ? (this._.delete(key)) : (delete this._[key]);\n      return true;\n    } else {\n      var entry = this.get(key);\n      var idx = entry.indexOf(val);\n      if (idx != -1) {\n        entry.splice(idx, 1);\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  /**\n   * @param {Object} key\n   * @param {Object=} val\n   * @return {boolean} whether the map contains 'key' or 'key=>val' pair\n   */\n  Multimap.prototype.has = function(key, val) {\n    var hasKey = this._map ? this._.has(key) : this._.hasOwnProperty(key);\n\n    if (arguments.length == 1 || !hasKey)\n      return hasKey;\n\n    var entry = this.get(key) || [];\n    return entry.indexOf(val) != -1;\n  };\n\n\n  /**\n   * @return {Array} all the keys in the map\n   */\n  Multimap.prototype.keys = function() {\n    if (this._map)\n      return makeIterator(this._.keys());\n\n    return makeIterator(Object.keys(this._));\n  };\n\n  /**\n   * @return {Array} all the values in the map\n   */\n  Multimap.prototype.values = function() {\n    var vals = [];\n    this.forEachEntry(function(entry) {\n      Array.prototype.push.apply(vals, entry);\n    });\n\n    return makeIterator(vals);\n  };\n\n  /**\n   *\n   */\n  Multimap.prototype.forEachEntry = function(iter) {\n    mapEach(this, iter);\n  };\n\n  Multimap.prototype.forEach = function(iter) {\n    var self = this;\n    self.forEachEntry(function(entry, key) {\n      entry.forEach(function(item) {\n        iter(item, key, self);\n      });\n    });\n  };\n\n\n  Multimap.prototype.clear = function() {\n    if (this._map) {\n      this._.clear();\n    } else {\n      this._ = {};\n    }\n  };\n\n  Object.defineProperty(\n    Multimap.prototype,\n    \"size\", {\n      configurable: false,\n      enumerable: true,\n      get: function() {\n        var total = 0;\n\n        mapEach(this, function(value){\n          total += value.length;\n        });\n\n        return total;\n      }\n    });\n\n  var safariNext;\n\n  try{\n    safariNext = new Function('iterator', 'makeIterator', 'var keysArray = []; for(var key of iterator){keysArray.push(key);} return makeIterator(keysArray).next;');\n  }catch(error){\n    // for of not implemented;\n  }\n\n  function makeIterator(iterator){\n    if(Array.isArray(iterator)){\n      var nextIndex = 0;\n\n      return {\n        next: function(){\n          return nextIndex < iterator.length ?\n            {value: iterator[nextIndex++], done: false} :\n          {done: true};\n        }\n      };\n    }\n\n    // Only an issue in safari\n    if(!iterator.next && safariNext){\n      iterator.next = safariNext(iterator, makeIterator);\n    }\n\n    return iterator;\n  }\n\n  return Multimap;\n})();\n\n\nif(typeof exports === 'object' && module && module.exports)\n  module.exports = Multimap;\nelse if(typeof define === 'function' && define.amd)\n  define(function() { return Multimap; });\n","var MultiMap = require('multimap'),\n    merge = require('flat-merge');\n\nMultiMap.Map = Map;\n\nfunction each(value, fn){\n    if(!value || typeof value !== 'object'){\n        return;\n    }\n\n    if(Array.isArray(value)){\n        for(var i = 0; i < value.length; i++){\n            fn(value[i], i)\n        }\n    }else{\n        for(var key in value){\n            fn(value[key], key);\n        }\n    }\n}\n\nfunction keyFor(object, value){\n    if(!object || typeof object !== 'object'){\n        return false;\n    }\n\n    if(Array.isArray(object)){\n        var index = object.indexOf(value);\n        return index >=0 ? index : false;\n    }\n\n    for(var key in object){\n        if(object[key] === value){\n            return key;\n        }\n    }\n\n    return false;\n}\n\nmodule.exports = function(fastn, component, type, settings, children){\n\n    if(fastn.components._generic){\n        component.extend('_generic', settings, children);\n    }else{\n        component.extend('_container', settings, children);\n    }\n\n    if(!('template' in settings)){\n        console.warn('No \"template\" function was set for this templater component');\n    }\n\n    var itemsMap = new MultiMap(),\n        dataMap = new WeakMap(),\n        lastTemplate,\n        existingItem = {};\n\n    function updateItems(){\n        var value = component.items(),\n            template = component.template(),\n            emptyTemplate = component.emptyTemplate(),\n            newTemplate = lastTemplate !== template;\n\n        var currentItems = merge(template ? value : []);\n\n        itemsMap.forEach(function(childComponent, item){\n            var currentKey = keyFor(currentItems, item);\n\n            if(!newTemplate && currentKey !== false){\n                currentItems[currentKey] = [existingItem, item, childComponent];\n            }else{\n                removeComponent(childComponent);\n                itemsMap.delete(item);\n            }\n        });\n\n        var index = 0;\n\n        function updateItem(item, key){\n            var child,\n                existing;\n\n            while(index < component._children.length && !component._children[index]._templated){\n                index++;\n            }\n\n            if(Array.isArray(item) && item[0] === existingItem){\n                existing = true;\n                child = item[2];\n                item = item[1];\n            }\n\n            var childModel;\n\n            if(!existing){\n                childModel = new fastn.Model({\n                    item: item,\n                    key: key\n                });\n\n                child = fastn.toComponent(template(childModel, component.scope()));\n                if(!child){\n                    child = fastn('template');\n                }\n                child._listItem = item;\n                child._templated = true;\n\n                dataMap.set(child, childModel);\n                itemsMap.set(item, child);\n            }else{\n                childModel = dataMap.get(child);\n                childModel.set('key', key);\n            }\n\n            if(fastn.isComponent(child) && component._settings.attachTemplates !== false){\n                child.attach(childModel, 2);\n            }\n\n            component.insert(child, index);\n            index++;\n        }\n\n        each(currentItems, updateItem);\n\n        lastTemplate = template;\n\n        if(index === 0 && emptyTemplate){\n            var child = fastn.toComponent(emptyTemplate(component.scope()));\n            if(!child){\n                child = fastn('template');\n            }\n            child._templated = true;\n\n            itemsMap.set({}, child);\n\n            component.insert(child);\n        }\n    }\n\n    function removeComponent(childComponent){\n        component.remove(childComponent);\n        childComponent.destroy();\n    }\n\n    component.setProperty('items',\n        fastn.property([], settings.itemChanges || 'type keys shallowStructure')\n            .on('change', updateItems)\n    );\n\n    component.setProperty('template',\n        fastn.property().on('change', updateItems)\n    );\n\n    component.setProperty('emptyTemplate',\n        fastn.property().on('change', updateItems)\n    );\n\n    return component;\n};"]} | |
require=(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){ | |
/* | |
Leaflet, a JavaScript library for mobile-friendly interactive maps. http://leafletjs.com | |
(c) 2010-2013, Vladimir Agafonkin | |
(c) 2010-2011, CloudMade | |
*/ | |
(function (window, document, undefined) { | |
var oldL = window.L, | |
L = {}; | |
L.version = '0.7.7'; | |
// define Leaflet for Node module pattern loaders, including Browserify | |
if (typeof module === 'object' && typeof module.exports === 'object') { | |
module.exports = L; | |
// define Leaflet as an AMD module | |
} else if (typeof define === 'function' && define.amd) { | |
define(L); | |
} | |
// define Leaflet as a global L variable, saving the original L to restore later if needed | |
L.noConflict = function () { | |
window.L = oldL; | |
return this; | |
}; | |
window.L = L; | |
/* | |
* L.Util contains various utility functions used throughout Leaflet code. | |
*/ | |
L.Util = { | |
extend: function (dest) { // (Object[, Object, ...]) -> | |
var sources = Array.prototype.slice.call(arguments, 1), | |
i, j, len, src; | |
for (j = 0, len = sources.length; j < len; j++) { | |
src = sources[j] || {}; | |
for (i in src) { | |
if (src.hasOwnProperty(i)) { | |
dest[i] = src[i]; | |
} | |
} | |
} | |
return dest; | |
}, | |
bind: function (fn, obj) { // (Function, Object) -> Function | |
var args = arguments.length > 2 ? Array.prototype.slice.call(arguments, 2) : null; | |
return function () { | |
return fn.apply(obj, args || arguments); | |
}; | |
}, | |
stamp: (function () { | |
var lastId = 0, | |
key = '_leaflet_id'; | |
return function (obj) { | |
obj[key] = obj[key] || ++lastId; | |
return obj[key]; | |
}; | |
}()), | |
invokeEach: function (obj, method, context) { | |
var i, args; | |
if (typeof obj === 'object') { | |
args = Array.prototype.slice.call(arguments, 3); | |
for (i in obj) { | |
method.apply(context, [i, obj[i]].concat(args)); | |
} | |
return true; | |
} | |
return false; | |
}, | |
limitExecByInterval: function (fn, time, context) { | |
var lock, execOnUnlock; | |
return function wrapperFn() { | |
var args = arguments; | |
if (lock) { | |
execOnUnlock = true; | |
return; | |
} | |
lock = true; | |
setTimeout(function () { | |
lock = false; | |
if (execOnUnlock) { | |
wrapperFn.apply(context, args); | |
execOnUnlock = false; | |
} | |
}, time); | |
fn.apply(context, args); | |
}; | |
}, | |
falseFn: function () { | |
return false; | |
}, | |
formatNum: function (num, digits) { | |
var pow = Math.pow(10, digits || 5); | |
return Math.round(num * pow) / pow; | |
}, | |
trim: function (str) { | |
return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, ''); | |
}, | |
splitWords: function (str) { | |
return L.Util.trim(str).split(/\s+/); | |
}, | |
setOptions: function (obj, options) { | |
obj.options = L.extend({}, obj.options, options); | |
return obj.options; | |
}, | |
getParamString: function (obj, existingUrl, uppercase) { | |
var params = []; | |
for (var i in obj) { | |
params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i])); | |
} | |
return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&'); | |
}, | |
template: function (str, data) { | |
return str.replace(/\{ *([\w_]+) *\}/g, function (str, key) { | |
var value = data[key]; | |
if (value === undefined) { | |
throw new Error('No value provided for variable ' + str); | |
} else if (typeof value === 'function') { | |
value = value(data); | |
} | |
return value; | |
}); | |
}, | |
isArray: Array.isArray || function (obj) { | |
return (Object.prototype.toString.call(obj) === '[object Array]'); | |
}, | |
emptyImageUrl: 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=' | |
}; | |
(function () { | |
// inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/ | |
function getPrefixed(name) { | |
var i, fn, | |
prefixes = ['webkit', 'moz', 'o', 'ms']; | |
for (i = 0; i < prefixes.length && !fn; i++) { | |
fn = window[prefixes[i] + name]; | |
} | |
return fn; | |
} | |
var lastTime = 0; | |
function timeoutDefer(fn) { | |
var time = +new Date(), | |
timeToCall = Math.max(0, 16 - (time - lastTime)); | |
lastTime = time + timeToCall; | |
return window.setTimeout(fn, timeToCall); | |
} | |
var requestFn = window.requestAnimationFrame || | |
getPrefixed('RequestAnimationFrame') || timeoutDefer; | |
var cancelFn = window.cancelAnimationFrame || | |
getPrefixed('CancelAnimationFrame') || | |
getPrefixed('CancelRequestAnimationFrame') || | |
function (id) { window.clearTimeout(id); }; | |
L.Util.requestAnimFrame = function (fn, context, immediate, element) { | |
fn = L.bind(fn, context); | |
if (immediate && requestFn === timeoutDefer) { | |
fn(); | |
} else { | |
return requestFn.call(window, fn, element); | |
} | |
}; | |
L.Util.cancelAnimFrame = function (id) { | |
if (id) { | |
cancelFn.call(window, id); | |
} | |
}; | |
}()); | |
// shortcuts for most used utility functions | |
L.extend = L.Util.extend; | |
L.bind = L.Util.bind; | |
L.stamp = L.Util.stamp; | |
L.setOptions = L.Util.setOptions; | |
/* | |
* L.Class powers the OOP facilities of the library. | |
* Thanks to John Resig and Dean Edwards for inspiration! | |
*/ | |
L.Class = function () {}; | |
L.Class.extend = function (props) { | |
// extended class with the new prototype | |
var NewClass = function () { | |
// call the constructor | |
if (this.initialize) { | |
this.initialize.apply(this, arguments); | |
} | |
// call all constructor hooks | |
if (this._initHooks) { | |
this.callInitHooks(); | |
} | |
}; | |
// instantiate class without calling constructor | |
var F = function () {}; | |
F.prototype = this.prototype; | |
var proto = new F(); | |
proto.constructor = NewClass; | |
NewClass.prototype = proto; | |
//inherit parent's statics | |
for (var i in this) { | |
if (this.hasOwnProperty(i) && i !== 'prototype') { | |
NewClass[i] = this[i]; | |
} | |
} | |
// mix static properties into the class | |
if (props.statics) { | |
L.extend(NewClass, props.statics); | |
delete props.statics; | |
} | |
// mix includes into the prototype | |
if (props.includes) { | |
L.Util.extend.apply(null, [proto].concat(props.includes)); | |
delete props.includes; | |
} | |
// merge options | |
if (props.options && proto.options) { | |
props.options = L.extend({}, proto.options, props.options); | |
} | |
// mix given properties into the prototype | |
L.extend(proto, props); | |
proto._initHooks = []; | |
var parent = this; | |
// jshint camelcase: false | |
NewClass.__super__ = parent.prototype; | |
// add method for calling all hooks | |
proto.callInitHooks = function () { | |
if (this._initHooksCalled) { return; } | |
if (parent.prototype.callInitHooks) { | |
parent.prototype.callInitHooks.call(this); | |
} | |
this._initHooksCalled = true; | |
for (var i = 0, len = proto._initHooks.length; i < len; i++) { | |
proto._initHooks[i].call(this); | |
} | |
}; | |
return NewClass; | |
}; | |
// method for adding properties to prototype | |
L.Class.include = function (props) { | |
L.extend(this.prototype, props); | |
}; | |
// merge new default options to the Class | |
L.Class.mergeOptions = function (options) { | |
L.extend(this.prototype.options, options); | |
}; | |
// add a constructor hook | |
L.Class.addInitHook = function (fn) { // (Function) || (String, args...) | |
var args = Array.prototype.slice.call(arguments, 1); | |
var init = typeof fn === 'function' ? fn : function () { | |
this[fn].apply(this, args); | |
}; | |
this.prototype._initHooks = this.prototype._initHooks || []; | |
this.prototype._initHooks.push(init); | |
}; | |
/* | |
* L.Mixin.Events is used to add custom events functionality to Leaflet classes. | |
*/ | |
var eventsKey = '_leaflet_events'; | |
L.Mixin = {}; | |
L.Mixin.Events = { | |
addEventListener: function (types, fn, context) { // (String, Function[, Object]) or (Object[, Object]) | |
// types can be a map of types/handlers | |
if (L.Util.invokeEach(types, this.addEventListener, this, fn, context)) { return this; } | |
var events = this[eventsKey] = this[eventsKey] || {}, | |
contextId = context && context !== this && L.stamp(context), | |
i, len, event, type, indexKey, indexLenKey, typeIndex; | |
// types can be a string of space-separated words | |
types = L.Util.splitWords(types); | |
for (i = 0, len = types.length; i < len; i++) { | |
event = { | |
action: fn, | |
context: context || this | |
}; | |
type = types[i]; | |
if (contextId) { | |
// store listeners of a particular context in a separate hash (if it has an id) | |
// gives a major performance boost when removing thousands of map layers | |
indexKey = type + '_idx'; | |
indexLenKey = indexKey + '_len'; | |
typeIndex = events[indexKey] = events[indexKey] || {}; | |
if (!typeIndex[contextId]) { | |
typeIndex[contextId] = []; | |
// keep track of the number of keys in the index to quickly check if it's empty | |
events[indexLenKey] = (events[indexLenKey] || 0) + 1; | |
} | |
typeIndex[contextId].push(event); | |
} else { | |
events[type] = events[type] || []; | |
events[type].push(event); | |
} | |
} | |
return this; | |
}, | |
hasEventListeners: function (type) { // (String) -> Boolean | |
var events = this[eventsKey]; | |
return !!events && ((type in events && events[type].length > 0) || | |
(type + '_idx' in events && events[type + '_idx_len'] > 0)); | |
}, | |
removeEventListener: function (types, fn, context) { // ([String, Function, Object]) or (Object[, Object]) | |
if (!this[eventsKey]) { | |
return this; | |
} | |
if (!types) { | |
return this.clearAllEventListeners(); | |
} | |
if (L.Util.invokeEach(types, this.removeEventListener, this, fn, context)) { return this; } | |
var events = this[eventsKey], | |
contextId = context && context !== this && L.stamp(context), | |
i, len, type, listeners, j, indexKey, indexLenKey, typeIndex, removed; | |
types = L.Util.splitWords(types); | |
for (i = 0, len = types.length; i < len; i++) { | |
type = types[i]; | |
indexKey = type + '_idx'; | |
indexLenKey = indexKey + '_len'; | |
typeIndex = events[indexKey]; | |
if (!fn) { | |
// clear all listeners for a type if function isn't specified | |
delete events[type]; | |
delete events[indexKey]; | |
delete events[indexLenKey]; | |
} else { | |
listeners = contextId && typeIndex ? typeIndex[contextId] : events[type]; | |
if (listeners) { | |
for (j = listeners.length - 1; j >= 0; j--) { | |
if ((listeners[j].action === fn) && (!context || (listeners[j].context === context))) { | |
removed = listeners.splice(j, 1); | |
// set the old action to a no-op, because it is possible | |
// that the listener is being iterated over as part of a dispatch | |
removed[0].action = L.Util.falseFn; | |
} | |
} | |
if (context && typeIndex && (listeners.length === 0)) { | |
delete typeIndex[contextId]; | |
events[indexLenKey]--; | |
} | |
} | |
} | |
} | |
return this; | |
}, | |
clearAllEventListeners: function () { | |
delete this[eventsKey]; | |
return this; | |
}, | |
fireEvent: function (type, data) { // (String[, Object]) | |
if (!this.hasEventListeners(type)) { | |
return this; | |
} | |
var event = L.Util.extend({}, data, { type: type, target: this }); | |
var events = this[eventsKey], | |
listeners, i, len, typeIndex, contextId; | |
if (events[type]) { | |
// make sure adding/removing listeners inside other listeners won't cause infinite loop | |
listeners = events[type].slice(); | |
for (i = 0, len = listeners.length; i < len; i++) { | |
listeners[i].action.call(listeners[i].context, event); | |
} | |
} | |
// fire event for the context-indexed listeners as well | |
typeIndex = events[type + '_idx']; | |
for (contextId in typeIndex) { | |
listeners = typeIndex[contextId].slice(); | |
if (listeners) { | |
for (i = 0, len = listeners.length; i < len; i++) { | |
listeners[i].action.call(listeners[i].context, event); | |
} | |
} | |
} | |
return this; | |
}, | |
addOneTimeEventListener: function (types, fn, context) { | |
if (L.Util.invokeEach(types, this.addOneTimeEventListener, this, fn, context)) { return this; } | |
var handler = L.bind(function () { | |
this | |
.removeEventListener(types, fn, context) | |
.removeEventListener(types, handler, context); | |
}, this); | |
return this | |
.addEventListener(types, fn, context) | |
.addEventListener(types, handler, context); | |
} | |
}; | |
L.Mixin.Events.on = L.Mixin.Events.addEventListener; | |
L.Mixin.Events.off = L.Mixin.Events.removeEventListener; | |
L.Mixin.Events.once = L.Mixin.Events.addOneTimeEventListener; | |
L.Mixin.Events.fire = L.Mixin.Events.fireEvent; | |
/* | |
* L.Browser handles different browser and feature detections for internal Leaflet use. | |
*/ | |
(function () { | |
var ie = 'ActiveXObject' in window, | |
ielt9 = ie && !document.addEventListener, | |
// terrible browser detection to work around Safari / iOS / Android browser bugs | |
ua = navigator.userAgent.toLowerCase(), | |
webkit = ua.indexOf('webkit') !== -1, | |
chrome = ua.indexOf('chrome') !== -1, | |
phantomjs = ua.indexOf('phantom') !== -1, | |
android = ua.indexOf('android') !== -1, | |
android23 = ua.search('android [23]') !== -1, | |
gecko = ua.indexOf('gecko') !== -1, | |
mobile = typeof orientation !== undefined + '', | |
msPointer = !window.PointerEvent && window.MSPointerEvent, | |
pointer = (window.PointerEvent && window.navigator.pointerEnabled) || | |
msPointer, | |
retina = ('devicePixelRatio' in window && window.devicePixelRatio > 1) || | |
('matchMedia' in window && window.matchMedia('(min-resolution:144dpi)') && | |
window.matchMedia('(min-resolution:144dpi)').matches), | |
doc = document.documentElement, | |
ie3d = ie && ('transition' in doc.style), | |
webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23, | |
gecko3d = 'MozPerspective' in doc.style, | |
opera3d = 'OTransition' in doc.style, | |
any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d || opera3d) && !phantomjs; | |
var touch = !window.L_NO_TOUCH && !phantomjs && (pointer || 'ontouchstart' in window || | |
(window.DocumentTouch && document instanceof window.DocumentTouch)); | |
L.Browser = { | |
ie: ie, | |
ielt9: ielt9, | |
webkit: webkit, | |
gecko: gecko && !webkit && !window.opera && !ie, | |
android: android, | |
android23: android23, | |
chrome: chrome, | |
ie3d: ie3d, | |
webkit3d: webkit3d, | |
gecko3d: gecko3d, | |
opera3d: opera3d, | |
any3d: any3d, | |
mobile: mobile, | |
mobileWebkit: mobile && webkit, | |
mobileWebkit3d: mobile && webkit3d, | |
mobileOpera: mobile && window.opera, | |
touch: touch, | |
msPointer: msPointer, | |
pointer: pointer, | |
retina: retina | |
}; | |
}()); | |
/* | |
* L.Point represents a point with x and y coordinates. | |
*/ | |
L.Point = function (/*Number*/ x, /*Number*/ y, /*Boolean*/ round) { | |
this.x = (round ? Math.round(x) : x); | |
this.y = (round ? Math.round(y) : y); | |
}; | |
L.Point.prototype = { | |
clone: function () { | |
return new L.Point(this.x, this.y); | |
}, | |
// non-destructive, returns a new point | |
add: function (point) { | |
return this.clone()._add(L.point(point)); | |
}, | |
// destructive, used directly for performance in situations where it's safe to modify existing point | |
_add: function (point) { | |
this.x += point.x; | |
this.y += point.y; | |
return this; | |
}, | |
subtract: function (point) { | |
return this.clone()._subtract(L.point(point)); | |
}, | |
_subtract: function (point) { | |
this.x -= point.x; | |
this.y -= point.y; | |
return this; | |
}, | |
divideBy: function (num) { | |
return this.clone()._divideBy(num); | |
}, | |
_divideBy: function (num) { | |
this.x /= num; | |
this.y /= num; | |
return this; | |
}, | |
multiplyBy: function (num) { | |
return this.clone()._multiplyBy(num); | |
}, | |
_multiplyBy: function (num) { | |
this.x *= num; | |
this.y *= num; | |
return this; | |
}, | |
round: function () { | |
return this.clone()._round(); | |
}, | |
_round: function () { | |
this.x = Math.round(this.x); | |
this.y = Math.round(this.y); | |
return this; | |
}, | |
floor: function () { | |
return this.clone()._floor(); | |
}, | |
_floor: function () { | |
this.x = Math.floor(this.x); | |
this.y = Math.floor(this.y); | |
return this; | |
}, | |
distanceTo: function (point) { | |
point = L.point(point); | |
var x = point.x - this.x, | |
y = point.y - this.y; | |
return Math.sqrt(x * x + y * y); | |
}, | |
equals: function (point) { | |
point = L.point(point); | |
return point.x === this.x && | |
point.y === this.y; | |
}, | |
contains: function (point) { | |
point = L.point(point); | |
return Math.abs(point.x) <= Math.abs(this.x) && | |
Math.abs(point.y) <= Math.abs(this.y); | |
}, | |
toString: function () { | |
return 'Point(' + | |
L.Util.formatNum(this.x) + ', ' + | |
L.Util.formatNum(this.y) + ')'; | |
} | |
}; | |
L.point = function (x, y, round) { | |
if (x instanceof L.Point) { | |
return x; | |
} | |
if (L.Util.isArray(x)) { | |
return new L.Point(x[0], x[1]); | |
} | |
if (x === undefined || x === null) { | |
return x; | |
} | |
return new L.Point(x, y, round); | |
}; | |
/* | |
* L.Bounds represents a rectangular area on the screen in pixel coordinates. | |
*/ | |
L.Bounds = function (a, b) { //(Point, Point) or Point[] | |
if (!a) { return; } | |
var points = b ? [a, b] : a; | |
for (var i = 0, len = points.length; i < len; i++) { | |
this.extend(points[i]); | |
} | |
}; | |
L.Bounds.prototype = { | |
// extend the bounds to contain the given point | |
extend: function (point) { // (Point) | |
point = L.point(point); | |
if (!this.min && !this.max) { | |
this.min = point.clone(); | |
this.max = point.clone(); | |
} else { | |
this.min.x = Math.min(point.x, this.min.x); | |
this.max.x = Math.max(point.x, this.max.x); | |
this.min.y = Math.min(point.y, this.min.y); | |
this.max.y = Math.max(point.y, this.max.y); | |
} | |
return this; | |
}, | |
getCenter: function (round) { // (Boolean) -> Point | |
return new L.Point( | |
(this.min.x + this.max.x) / 2, | |
(this.min.y + this.max.y) / 2, round); | |
}, | |
getBottomLeft: function () { // -> Point | |
return new L.Point(this.min.x, this.max.y); | |
}, | |
getTopRight: function () { // -> Point | |
return new L.Point(this.max.x, this.min.y); | |
}, | |
getSize: function () { | |
return this.max.subtract(this.min); | |
}, | |
contains: function (obj) { // (Bounds) or (Point) -> Boolean | |
var min, max; | |
if (typeof obj[0] === 'number' || obj instanceof L.Point) { | |
obj = L.point(obj); | |
} else { | |
obj = L.bounds(obj); | |
} | |
if (obj instanceof L.Bounds) { | |
min = obj.min; | |
max = obj.max; | |
} else { | |
min = max = obj; | |
} | |
return (min.x >= this.min.x) && | |
(max.x <= this.max.x) && | |
(min.y >= this.min.y) && | |
(max.y <= this.max.y); | |
}, | |
intersects: function (bounds) { // (Bounds) -> Boolean | |
bounds = L.bounds(bounds); | |
var min = this.min, | |
max = this.max, | |
min2 = bounds.min, | |
max2 = bounds.max, | |
xIntersects = (max2.x >= min.x) && (min2.x <= max.x), | |
yIntersects = (max2.y >= min.y) && (min2.y <= max.y); | |
return xIntersects && yIntersects; | |
}, | |
isValid: function () { | |
return !!(this.min && this.max); | |
} | |
}; | |
L.bounds = function (a, b) { // (Bounds) or (Point, Point) or (Point[]) | |
if (!a || a instanceof L.Bounds) { | |
return a; | |
} | |
return new L.Bounds(a, b); | |
}; | |
/* | |
* L.Transformation is an utility class to perform simple point transformations through a 2d-matrix. | |
*/ | |
L.Transformation = function (a, b, c, d) { | |
this._a = a; | |
this._b = b; | |
this._c = c; | |
this._d = d; | |
}; | |
L.Transformation.prototype = { | |
transform: function (point, scale) { // (Point, Number) -> Point | |
return this._transform(point.clone(), scale); | |
}, | |
// destructive transform (faster) | |
_transform: function (point, scale) { | |
scale = scale || 1; | |
point.x = scale * (this._a * point.x + this._b); | |
point.y = scale * (this._c * point.y + this._d); | |
return point; | |
}, | |
untransform: function (point, scale) { | |
scale = scale || 1; | |
return new L.Point( | |
(point.x / scale - this._b) / this._a, | |
(point.y / scale - this._d) / this._c); | |
} | |
}; | |
/* | |
* L.DomUtil contains various utility functions for working with DOM. | |
*/ | |
L.DomUtil = { | |
get: function (id) { | |
return (typeof id === 'string' ? document.getElementById(id) : id); | |
}, | |
getStyle: function (el, style) { | |
var value = el.style[style]; | |
if (!value && el.currentStyle) { | |
value = el.currentStyle[style]; | |
} | |
if ((!value || value === 'auto') && document.defaultView) { | |
var css = document.defaultView.getComputedStyle(el, null); | |
value = css ? css[style] : null; | |
} | |
return value === 'auto' ? null : value; | |
}, | |
getViewportOffset: function (element) { | |
var top = 0, | |
left = 0, | |
el = element, | |
docBody = document.body, | |
docEl = document.documentElement, | |
pos; | |
do { | |
top += el.offsetTop || 0; | |
left += el.offsetLeft || 0; | |
//add borders | |
top += parseInt(L.DomUtil.getStyle(el, 'borderTopWidth'), 10) || 0; | |
left += parseInt(L.DomUtil.getStyle(el, 'borderLeftWidth'), 10) || 0; | |
pos = L.DomUtil.getStyle(el, 'position'); | |
if (el.offsetParent === docBody && pos === 'absolute') { break; } | |
if (pos === 'fixed') { | |
top += docBody.scrollTop || docEl.scrollTop || 0; | |
left += docBody.scrollLeft || docEl.scrollLeft || 0; | |
break; | |
} | |
if (pos === 'relative' && !el.offsetLeft) { | |
var width = L.DomUtil.getStyle(el, 'width'), | |
maxWidth = L.DomUtil.getStyle(el, 'max-width'), | |
r = el.getBoundingClientRect(); | |
if (width !== 'none' || maxWidth !== 'none') { | |
left += r.left + el.clientLeft; | |
} | |
//calculate full y offset since we're breaking out of the loop | |
top += r.top + (docBody.scrollTop || docEl.scrollTop || 0); | |
break; | |
} | |
el = el.offsetParent; | |
} while (el); | |
el = element; | |
do { | |
if (el === docBody) { break; } | |
top -= el.scrollTop || 0; | |
left -= el.scrollLeft || 0; | |
el = el.parentNode; | |
} while (el); | |
return new L.Point(left, top); | |
}, | |
documentIsLtr: function () { | |
if (!L.DomUtil._docIsLtrCached) { | |
L.DomUtil._docIsLtrCached = true; | |
L.DomUtil._docIsLtr = L.DomUtil.getStyle(document.body, 'direction') === 'ltr'; | |
} | |
return L.DomUtil._docIsLtr; | |
}, | |
create: function (tagName, className, container) { | |
var el = document.createElement(tagName); | |
el.className = className; | |
if (container) { | |
container.appendChild(el); | |
} | |
return el; | |
}, | |
hasClass: function (el, name) { | |
if (el.classList !== undefined) { | |
return el.classList.contains(name); | |
} | |
var className = L.DomUtil._getClass(el); | |
return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className); | |
}, | |
addClass: function (el, name) { | |
if (el.classList !== undefined) { | |
var classes = L.Util.splitWords(name); | |
for (var i = 0, len = classes.length; i < len; i++) { | |
el.classList.add(classes[i]); | |
} | |
} else if (!L.DomUtil.hasClass(el, name)) { | |
var className = L.DomUtil._getClass(el); | |
L.DomUtil._setClass(el, (className ? className + ' ' : '') + name); | |
} | |
}, | |
removeClass: function (el, name) { | |
if (el.classList !== undefined) { | |
el.classList.remove(name); | |
} else { | |
L.DomUtil._setClass(el, L.Util.trim((' ' + L.DomUtil._getClass(el) + ' ').replace(' ' + name + ' ', ' '))); | |
} | |
}, | |
_setClass: function (el, name) { | |
if (el.className.baseVal === undefined) { | |
el.className = name; | |
} else { | |
// in case of SVG element | |
el.className.baseVal = name; | |
} | |
}, | |
_getClass: function (el) { | |
return el.className.baseVal === undefined ? el.className : el.className.baseVal; | |
}, | |
setOpacity: function (el, value) { | |
if ('opacity' in el.style) { | |
el.style.opacity = value; | |
} else if ('filter' in el.style) { | |
var filter = false, | |
filterName = 'DXImageTransform.Microsoft.Alpha'; | |
// filters collection throws an error if we try to retrieve a filter that doesn't exist | |
try { | |
filter = el.filters.item(filterName); | |
} catch (e) { | |
// don't set opacity to 1 if we haven't already set an opacity, | |
// it isn't needed and breaks transparent pngs. | |
if (value === 1) { return; } | |
} | |
value = Math.round(value * 100); | |
if (filter) { | |
filter.Enabled = (value !== 100); | |
filter.Opacity = value; | |
} else { | |
el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')'; | |
} | |
} | |
}, | |
testProp: function (props) { | |
var style = document.documentElement.style; | |
for (var i = 0; i < props.length; i++) { | |
if (props[i] in style) { | |
return props[i]; | |
} | |
} | |
return false; | |
}, | |
getTranslateString: function (point) { | |
// on WebKit browsers (Chrome/Safari/iOS Safari/Android) using translate3d instead of translate | |
// makes animation smoother as it ensures HW accel is used. Firefox 13 doesn't care | |
// (same speed either way), Opera 12 doesn't support translate3d | |
var is3d = L.Browser.webkit3d, | |
open = 'translate' + (is3d ? '3d' : '') + '(', | |
close = (is3d ? ',0' : '') + ')'; | |
return open + point.x + 'px,' + point.y + 'px' + close; | |
}, | |
getScaleString: function (scale, origin) { | |
var preTranslateStr = L.DomUtil.getTranslateString(origin.add(origin.multiplyBy(-1 * scale))), | |
scaleStr = ' scale(' + scale + ') '; | |
return preTranslateStr + scaleStr; | |
}, | |
setPosition: function (el, point, disable3D) { // (HTMLElement, Point[, Boolean]) | |
// jshint camelcase: false | |
el._leaflet_pos = point; | |
if (!disable3D && L.Browser.any3d) { | |
el.style[L.DomUtil.TRANSFORM] = L.DomUtil.getTranslateString(point); | |
} else { | |
el.style.left = point.x + 'px'; | |
el.style.top = point.y + 'px'; | |
} | |
}, | |
getPosition: function (el) { | |
// this method is only used for elements previously positioned using setPosition, | |
// so it's safe to cache the position for performance | |
// jshint camelcase: false | |
return el._leaflet_pos; | |
} | |
}; | |
// prefix style property names | |
L.DomUtil.TRANSFORM = L.DomUtil.testProp( | |
['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']); | |
// webkitTransition comes first because some browser versions that drop vendor prefix don't do | |
// the same for the transitionend event, in particular the Android 4.1 stock browser | |
L.DomUtil.TRANSITION = L.DomUtil.testProp( | |
['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']); | |
L.DomUtil.TRANSITION_END = | |
L.DomUtil.TRANSITION === 'webkitTransition' || L.DomUtil.TRANSITION === 'OTransition' ? | |
L.DomUtil.TRANSITION + 'End' : 'transitionend'; | |
(function () { | |
if ('onselectstart' in document) { | |
L.extend(L.DomUtil, { | |
disableTextSelection: function () { | |
L.DomEvent.on(window, 'selectstart', L.DomEvent.preventDefault); | |
}, | |
enableTextSelection: function () { | |
L.DomEvent.off(window, 'selectstart', L.DomEvent.preventDefault); | |
} | |
}); | |
} else { | |
var userSelectProperty = L.DomUtil.testProp( | |
['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']); | |
L.extend(L.DomUtil, { | |
disableTextSelection: function () { | |
if (userSelectProperty) { | |
var style = document.documentElement.style; | |
this._userSelect = style[userSelectProperty]; | |
style[userSelectProperty] = 'none'; | |
} | |
}, | |
enableTextSelection: function () { | |
if (userSelectProperty) { | |
document.documentElement.style[userSelectProperty] = this._userSelect; | |
delete this._userSelect; | |
} | |
} | |
}); | |
} | |
L.extend(L.DomUtil, { | |
disableImageDrag: function () { | |
L.DomEvent.on(window, 'dragstart', L.DomEvent.preventDefault); | |
}, | |
enableImageDrag: function () { | |
L.DomEvent.off(window, 'dragstart', L.DomEvent.preventDefault); | |
} | |
}); | |
})(); | |
/* | |
* L.LatLng represents a geographical point with latitude and longitude coordinates. | |
*/ | |
L.LatLng = function (lat, lng, alt) { // (Number, Number, Number) | |
lat = parseFloat(lat); | |
lng = parseFloat(lng); | |
if (isNaN(lat) || isNaN(lng)) { | |
throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')'); | |
} | |
this.lat = lat; | |
this.lng = lng; | |
if (alt !== undefined) { | |
this.alt = parseFloat(alt); | |
} | |
}; | |
L.extend(L.LatLng, { | |
DEG_TO_RAD: Math.PI / 180, | |
RAD_TO_DEG: 180 / Math.PI, | |
MAX_MARGIN: 1.0E-9 // max margin of error for the "equals" check | |
}); | |
L.LatLng.prototype = { | |
equals: function (obj) { // (LatLng) -> Boolean | |
if (!obj) { return false; } | |
obj = L.latLng(obj); | |
var margin = Math.max( | |
Math.abs(this.lat - obj.lat), | |
Math.abs(this.lng - obj.lng)); | |
return margin <= L.LatLng.MAX_MARGIN; | |
}, | |
toString: function (precision) { // (Number) -> String | |
return 'LatLng(' + | |
L.Util.formatNum(this.lat, precision) + ', ' + | |
L.Util.formatNum(this.lng, precision) + ')'; | |
}, | |
// Haversine distance formula, see http://en.wikipedia.org/wiki/Haversine_formula | |
// TODO move to projection code, LatLng shouldn't know about Earth | |
distanceTo: function (other) { // (LatLng) -> Number | |
other = L.latLng(other); | |
var R = 6378137, // earth radius in meters | |
d2r = L.LatLng.DEG_TO_RAD, | |
dLat = (other.lat - this.lat) * d2r, | |
dLon = (other.lng - this.lng) * d2r, | |
lat1 = this.lat * d2r, | |
lat2 = other.lat * d2r, | |
sin1 = Math.sin(dLat / 2), | |
sin2 = Math.sin(dLon / 2); | |
var a = sin1 * sin1 + sin2 * sin2 * Math.cos(lat1) * Math.cos(lat2); | |
return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); | |
}, | |
wrap: function (a, b) { // (Number, Number) -> LatLng | |
var lng = this.lng; | |
a = a || -180; | |
b = b || 180; | |
lng = (lng + b) % (b - a) + (lng < a || lng === b ? b : a); | |
return new L.LatLng(this.lat, lng); | |
} | |
}; | |
L.latLng = function (a, b) { // (LatLng) or ([Number, Number]) or (Number, Number) | |
if (a instanceof L.LatLng) { | |
return a; | |
} | |
if (L.Util.isArray(a)) { | |
if (typeof a[0] === 'number' || typeof a[0] === 'string') { | |
return new L.LatLng(a[0], a[1], a[2]); | |
} else { | |
return null; | |
} | |
} | |
if (a === undefined || a === null) { | |
return a; | |
} | |
if (typeof a === 'object' && 'lat' in a) { | |
return new L.LatLng(a.lat, 'lng' in a ? a.lng : a.lon); | |
} | |
if (b === undefined) { | |
return null; | |
} | |
return new L.LatLng(a, b); | |
}; | |
/* | |
* L.LatLngBounds represents a rectangular area on the map in geographical coordinates. | |
*/ | |
L.LatLngBounds = function (southWest, northEast) { // (LatLng, LatLng) or (LatLng[]) | |
if (!southWest) { return; } | |
var latlngs = northEast ? [southWest, northEast] : southWest; | |
for (var i = 0, len = latlngs.length; i < len; i++) { | |
this.extend(latlngs[i]); | |
} | |
}; | |
L.LatLngBounds.prototype = { | |
// extend the bounds to contain the given point or bounds | |
extend: function (obj) { // (LatLng) or (LatLngBounds) | |
if (!obj) { return this; } | |
var latLng = L.latLng(obj); | |
if (latLng !== null) { | |
obj = latLng; | |
} else { | |
obj = L.latLngBounds(obj); | |
} | |
if (obj instanceof L.LatLng) { | |
if (!this._southWest && !this._northEast) { | |
this._southWest = new L.LatLng(obj.lat, obj.lng); | |
this._northEast = new L.LatLng(obj.lat, obj.lng); | |
} else { | |
this._southWest.lat = Math.min(obj.lat, this._southWest.lat); | |
this._southWest.lng = Math.min(obj.lng, this._southWest.lng); | |
this._northEast.lat = Math.max(obj.lat, this._northEast.lat); | |
this._northEast.lng = Math.max(obj.lng, this._northEast.lng); | |
} | |
} else if (obj instanceof L.LatLngBounds) { | |
this.extend(obj._southWest); | |
this.extend(obj._northEast); | |
} | |
return this; | |
}, | |
// extend the bounds by a percentage | |
pad: function (bufferRatio) { // (Number) -> LatLngBounds | |
var sw = this._southWest, | |
ne = this._northEast, | |
heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio, | |
widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio; | |
return new L.LatLngBounds( | |
new L.LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer), | |
new L.LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer)); | |
}, | |
getCenter: function () { // -> LatLng | |
return new L.LatLng( | |
(this._southWest.lat + this._northEast.lat) / 2, | |
(this._southWest.lng + this._northEast.lng) / 2); | |
}, | |
getSouthWest: function () { | |
return this._southWest; | |
}, | |
getNorthEast: function () { | |
return this._northEast; | |
}, | |
getNorthWest: function () { | |
return new L.LatLng(this.getNorth(), this.getWest()); | |
}, | |
getSouthEast: function () { | |
return new L.LatLng(this.getSouth(), this.getEast()); | |
}, | |
getWest: function () { | |
return this._southWest.lng; | |
}, | |
getSouth: function () { | |
return this._southWest.lat; | |
}, | |
getEast: function () { | |
return this._northEast.lng; | |
}, | |
getNorth: function () { | |
return this._northEast.lat; | |
}, | |
contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean | |
if (typeof obj[0] === 'number' || obj instanceof L.LatLng) { | |
obj = L.latLng(obj); | |
} else { | |
obj = L.latLngBounds(obj); | |
} | |
var sw = this._southWest, | |
ne = this._northEast, | |
sw2, ne2; | |
if (obj instanceof L.LatLngBounds) { | |
sw2 = obj.getSouthWest(); | |
ne2 = obj.getNorthEast(); | |
} else { | |
sw2 = ne2 = obj; | |
} | |
return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) && | |
(sw2.lng >= sw.lng) && (ne2.lng <= ne.lng); | |
}, | |
intersects: function (bounds) { // (LatLngBounds) | |
bounds = L.latLngBounds(bounds); | |
var sw = this._southWest, | |
ne = this._northEast, | |
sw2 = bounds.getSouthWest(), | |
ne2 = bounds.getNorthEast(), | |
latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat), | |
lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng); | |
return latIntersects && lngIntersects; | |
}, | |
toBBoxString: function () { | |
return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(','); | |
}, | |
equals: function (bounds) { // (LatLngBounds) | |
if (!bounds) { return false; } | |
bounds = L.latLngBounds(bounds); | |
return this._southWest.equals(bounds.getSouthWest()) && | |
this._northEast.equals(bounds.getNorthEast()); | |
}, | |
isValid: function () { | |
return !!(this._southWest && this._northEast); | |
} | |
}; | |
//TODO International date line? | |
L.latLngBounds = function (a, b) { // (LatLngBounds) or (LatLng, LatLng) | |
if (!a || a instanceof L.LatLngBounds) { | |
return a; | |
} | |
return new L.LatLngBounds(a, b); | |
}; | |
/* | |
* L.Projection contains various geographical projections used by CRS classes. | |
*/ | |
L.Projection = {}; | |
/* | |
* Spherical Mercator is the most popular map projection, used by EPSG:3857 CRS used by default. | |
*/ | |
L.Projection.SphericalMercator = { | |
MAX_LATITUDE: 85.0511287798, | |
project: function (latlng) { // (LatLng) -> Point | |
var d = L.LatLng.DEG_TO_RAD, | |
max = this.MAX_LATITUDE, | |
lat = Math.max(Math.min(max, latlng.lat), -max), | |
x = latlng.lng * d, | |
y = lat * d; | |
y = Math.log(Math.tan((Math.PI / 4) + (y / 2))); | |
return new L.Point(x, y); | |
}, | |
unproject: function (point) { // (Point, Boolean) -> LatLng | |
var d = L.LatLng.RAD_TO_DEG, | |
lng = point.x * d, | |
lat = (2 * Math.atan(Math.exp(point.y)) - (Math.PI / 2)) * d; | |
return new L.LatLng(lat, lng); | |
} | |
}; | |
/* | |
* Simple equirectangular (Plate Carree) projection, used by CRS like EPSG:4326 and Simple. | |
*/ | |
L.Projection.LonLat = { | |
project: function (latlng) { | |
return new L.Point(latlng.lng, latlng.lat); | |
}, | |
unproject: function (point) { | |
return new L.LatLng(point.y, point.x); | |
} | |
}; | |
/* | |
* L.CRS is a base object for all defined CRS (Coordinate Reference Systems) in Leaflet. | |
*/ | |
L.CRS = { | |
latLngToPoint: function (latlng, zoom) { // (LatLng, Number) -> Point | |
var projectedPoint = this.projection.project(latlng), | |
scale = this.scale(zoom); | |
return this.transformation._transform(projectedPoint, scale); | |
}, | |
pointToLatLng: function (point, zoom) { // (Point, Number[, Boolean]) -> LatLng | |
var scale = this.scale(zoom), | |
untransformedPoint = this.transformation.untransform(point, scale); | |
return this.projection.unproject(untransformedPoint); | |
}, | |
project: function (latlng) { | |
return this.projection.project(latlng); | |
}, | |
scale: function (zoom) { | |
return 256 * Math.pow(2, zoom); | |
}, | |
getSize: function (zoom) { | |
var s = this.scale(zoom); | |
return L.point(s, s); | |
} | |
}; | |
/* | |
* A simple CRS that can be used for flat non-Earth maps like panoramas or game maps. | |
*/ | |
L.CRS.Simple = L.extend({}, L.CRS, { | |
projection: L.Projection.LonLat, | |
transformation: new L.Transformation(1, 0, -1, 0), | |
scale: function (zoom) { | |
return Math.pow(2, zoom); | |
} | |
}); | |
/* | |
* L.CRS.EPSG3857 (Spherical Mercator) is the most common CRS for web mapping | |
* and is used by Leaflet by default. | |
*/ | |
L.CRS.EPSG3857 = L.extend({}, L.CRS, { | |
code: 'EPSG:3857', | |
projection: L.Projection.SphericalMercator, | |
transformation: new L.Transformation(0.5 / Math.PI, 0.5, -0.5 / Math.PI, 0.5), | |
project: function (latlng) { // (LatLng) -> Point | |
var projectedPoint = this.projection.project(latlng), | |
earthRadius = 6378137; | |
return projectedPoint.multiplyBy(earthRadius); | |
} | |
}); | |
L.CRS.EPSG900913 = L.extend({}, L.CRS.EPSG3857, { | |
code: 'EPSG:900913' | |
}); | |
/* | |
* L.CRS.EPSG4326 is a CRS popular among advanced GIS specialists. | |
*/ | |
L.CRS.EPSG4326 = L.extend({}, L.CRS, { | |
code: 'EPSG:4326', | |
projection: L.Projection.LonLat, | |
transformation: new L.Transformation(1 / 360, 0.5, -1 / 360, 0.5) | |
}); | |
/* | |
* L.Map is the central class of the API - it is used to create a map. | |
*/ | |
L.Map = L.Class.extend({ | |
includes: L.Mixin.Events, | |
options: { | |
crs: L.CRS.EPSG3857, | |
/* | |
center: LatLng, | |
zoom: Number, | |
layers: Array, | |
*/ | |
fadeAnimation: L.DomUtil.TRANSITION && !L.Browser.android23, | |
trackResize: true, | |
markerZoomAnimation: L.DomUtil.TRANSITION && L.Browser.any3d | |
}, | |
initialize: function (id, options) { // (HTMLElement or String, Object) | |
options = L.setOptions(this, options); | |
this._initContainer(id); | |
this._initLayout(); | |
// hack for https://github.com/Leaflet/Leaflet/issues/1980 | |
this._onResize = L.bind(this._onResize, this); | |
this._initEvents(); | |
if (options.maxBounds) { | |
this.setMaxBounds(options.maxBounds); | |
} | |
if (options.center && options.zoom !== undefined) { | |
this.setView(L.latLng(options.center), options.zoom, {reset: true}); | |
} | |
this._handlers = []; | |
this._layers = {}; | |
this._zoomBoundLayers = {}; | |
this._tileLayersNum = 0; | |
this.callInitHooks(); | |
this._addLayers(options.layers); | |
}, | |
// public methods that modify map state | |
// replaced by animation-powered implementation in Map.PanAnimation.js | |
setView: function (center, zoom) { | |
zoom = zoom === undefined ? this.getZoom() : zoom; | |
this._resetView(L.latLng(center), this._limitZoom(zoom)); | |
return this; | |
}, | |
setZoom: function (zoom, options) { | |
if (!this._loaded) { | |
this._zoom = this._limitZoom(zoom); | |
return this; | |
} | |
return this.setView(this.getCenter(), zoom, {zoom: options}); | |
}, | |
zoomIn: function (delta, options) { | |
return this.setZoom(this._zoom + (delta || 1), options); | |
}, | |
zoomOut: function (delta, options) { | |
return this.setZoom(this._zoom - (delta || 1), options); | |
}, | |
setZoomAround: function (latlng, zoom, options) { | |
var scale = this.getZoomScale(zoom), | |
viewHalf = this.getSize().divideBy(2), | |
containerPoint = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng), | |
centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale), | |
newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset)); | |
return this.setView(newCenter, zoom, {zoom: options}); | |
}, | |
fitBounds: function (bounds, options) { | |
options = options || {}; | |
bounds = bounds.getBounds ? bounds.getBounds() : L.latLngBounds(bounds); | |
var paddingTL = L.point(options.paddingTopLeft || options.padding || [0, 0]), | |
paddingBR = L.point(options.paddingBottomRight || options.padding || [0, 0]), | |
zoom = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR)); | |
zoom = (options.maxZoom) ? Math.min(options.maxZoom, zoom) : zoom; | |
var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2), | |
swPoint = this.project(bounds.getSouthWest(), zoom), | |
nePoint = this.project(bounds.getNorthEast(), zoom), | |
center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom); | |
return this.setView(center, zoom, options); | |
}, | |
fitWorld: function (options) { | |
return this.fitBounds([[-90, -180], [90, 180]], options); | |
}, | |
panTo: function (center, options) { // (LatLng) | |
return this.setView(center, this._zoom, {pan: options}); | |
}, | |
panBy: function (offset) { // (Point) | |
// replaced with animated panBy in Map.PanAnimation.js | |
this.fire('movestart'); | |
this._rawPanBy(L.point(offset)); | |
this.fire('move'); | |
return this.fire('moveend'); | |
}, | |
setMaxBounds: function (bounds) { | |
bounds = L.latLngBounds(bounds); | |
this.options.maxBounds = bounds; | |
if (!bounds) { | |
return this.off('moveend', this._panInsideMaxBounds, this); | |
} | |
if (this._loaded) { | |
this._panInsideMaxBounds(); | |
} | |
return this.on('moveend', this._panInsideMaxBounds, this); | |
}, | |
panInsideBounds: function (bounds, options) { | |
var center = this.getCenter(), | |
newCenter = this._limitCenter(center, this._zoom, bounds); | |
if (center.equals(newCenter)) { return this; } | |
return this.panTo(newCenter, options); | |
}, | |
addLayer: function (layer) { | |
// TODO method is too big, refactor | |
var id = L.stamp(layer); | |
if (this._layers[id]) { return this; } | |
this._layers[id] = layer; | |
// TODO getMaxZoom, getMinZoom in ILayer (instead of options) | |
if (layer.options && (!isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom))) { | |
this._zoomBoundLayers[id] = layer; | |
this._updateZoomLevels(); | |
} | |
// TODO looks ugly, refactor!!! | |
if (this.options.zoomAnimation && L.TileLayer && (layer instanceof L.TileLayer)) { | |
this._tileLayersNum++; | |
this._tileLayersToLoad++; | |
layer.on('load', this._onTileLayerLoad, this); | |
} | |
if (this._loaded) { | |
this._layerAdd(layer); | |
} | |
return this; | |
}, | |
removeLayer: function (layer) { | |
var id = L.stamp(layer); | |
if (!this._layers[id]) { return this; } | |
if (this._loaded) { | |
layer.onRemove(this); | |
} | |
delete this._layers[id]; | |
if (this._loaded) { | |
this.fire('layerremove', {layer: layer}); | |
} | |
if (this._zoomBoundLayers[id]) { | |
delete this._zoomBoundLayers[id]; | |
this._updateZoomLevels(); | |
} | |
// TODO looks ugly, refactor | |
if (this.options.zoomAnimation && L.TileLayer && (layer instanceof L.TileLayer)) { | |
this._tileLayersNum--; | |
this._tileLayersToLoad--; | |
layer.off('load', this._onTileLayerLoad, this); | |
} | |
return this; | |
}, | |
hasLayer: function (layer) { | |
if (!layer) { return false; } | |
return (L.stamp(layer) in this._layers); | |
}, | |
eachLayer: function (method, context) { | |
for (var i in this._layers) { | |
method.call(context, this._layers[i]); | |
} | |
return this; | |
}, | |
invalidateSize: function (options) { | |
if (!this._loaded) { return this; } | |
options = L.extend({ | |
animate: false, | |
pan: true | |
}, options === true ? {animate: true} : options); | |
var oldSize = this.getSize(); | |
this._sizeChanged = true; | |
this._initialCenter = null; | |
var newSize = this.getSize(), | |
oldCenter = oldSize.divideBy(2).round(), | |
newCenter = newSize.divideBy(2).round(), | |
offset = oldCenter.subtract(newCenter); | |
if (!offset.x && !offset.y) { return this; } | |
if (options.animate && options.pan) { | |
this.panBy(offset); | |
} else { | |
if (options.pan) { | |
this._rawPanBy(offset); | |
} | |
this.fire('move'); | |
if (options.debounceMoveend) { | |
clearTimeout(this._sizeTimer); | |
this._sizeTimer = setTimeout(L.bind(this.fire, this, 'moveend'), 200); | |
} else { | |
this.fire('moveend'); | |
} | |
} | |
return this.fire('resize', { | |
oldSize: oldSize, | |
newSize: newSize | |
}); | |
}, | |
// TODO handler.addTo | |
addHandler: function (name, HandlerClass) { | |
if (!HandlerClass) { return this; } | |
var handler = this[name] = new HandlerClass(this); | |
this._handlers.push(handler); | |
if (this.options[name]) { | |
handler.enable(); | |
} | |
return this; | |
}, | |
remove: function () { | |
if (this._loaded) { | |
this.fire('unload'); | |
} | |
this._initEvents('off'); | |
try { | |
// throws error in IE6-8 | |
delete this._container._leaflet; | |
} catch (e) { | |
this._container._leaflet = undefined; | |
} | |
this._clearPanes(); | |
if (this._clearControlPos) { | |
this._clearControlPos(); | |
} | |
this._clearHandlers(); | |
return this; | |
}, | |
// public methods for getting map state | |
getCenter: function () { // (Boolean) -> LatLng | |
this._checkIfLoaded(); | |
if (this._initialCenter && !this._moved()) { | |
return this._initialCenter; | |
} | |
return this.layerPointToLatLng(this._getCenterLayerPoint()); | |
}, | |
getZoom: function () { | |
return this._zoom; | |
}, | |
getBounds: function () { | |
var bounds = this.getPixelBounds(), | |
sw = this.unproject(bounds.getBottomLeft()), | |
ne = this.unproject(bounds.getTopRight()); | |
return new L.LatLngBounds(sw, ne); | |
}, | |
getMinZoom: function () { | |
return this.options.minZoom === undefined ? | |
(this._layersMinZoom === undefined ? 0 : this._layersMinZoom) : | |
this.options.minZoom; | |
}, | |
getMaxZoom: function () { | |
return this.options.maxZoom === undefined ? | |
(this._layersMaxZoom === undefined ? Infinity : this._layersMaxZoom) : | |
this.options.maxZoom; | |
}, | |
getBoundsZoom: function (bounds, inside, padding) { // (LatLngBounds[, Boolean, Point]) -> Number | |
bounds = L.latLngBounds(bounds); | |
var zoom = this.getMinZoom() - (inside ? 1 : 0), | |
maxZoom = this.getMaxZoom(), | |
size = this.getSize(), | |
nw = bounds.getNorthWest(), | |
se = bounds.getSouthEast(), | |
zoomNotFound = true, | |
boundsSize; | |
padding = L.point(padding || [0, 0]); | |
do { | |
zoom++; | |
boundsSize = this.project(se, zoom).subtract(this.project(nw, zoom)).add(padding); | |
zoomNotFound = !inside ? size.contains(boundsSize) : boundsSize.x < size.x || boundsSize.y < size.y; | |
} while (zoomNotFound && zoom <= maxZoom); | |
if (zoomNotFound && inside) { | |
return null; | |
} | |
return inside ? zoom : zoom - 1; | |
}, | |
getSize: function () { | |
if (!this._size || this._sizeChanged) { | |
this._size = new L.Point( | |
this._container.clientWidth, | |
this._container.clientHeight); | |
this._sizeChanged = false; | |
} | |
return this._size.clone(); | |
}, | |
getPixelBounds: function () { | |
var topLeftPoint = this._getTopLeftPoint(); | |
return new L.Bounds(topLeftPoint, topLeftPoint.add(this.getSize())); | |
}, | |
getPixelOrigin: function () { | |
this._checkIfLoaded(); | |
return this._initialTopLeftPoint; | |
}, | |
getPanes: function () { | |
return this._panes; | |
}, | |
getContainer: function () { | |
return this._container; | |
}, | |
// TODO replace with universal implementation after refactoring projections | |
getZoomScale: function (toZoom) { | |
var crs = this.options.crs; | |
return crs.scale(toZoom) / crs.scale(this._zoom); | |
}, | |
getScaleZoom: function (scale) { | |
return this._zoom + (Math.log(scale) / Math.LN2); | |
}, | |
// conversion methods | |
project: function (latlng, zoom) { // (LatLng[, Number]) -> Point | |
zoom = zoom === undefined ? this._zoom : zoom; | |
return this.options.crs.latLngToPoint(L.latLng(latlng), zoom); | |
}, | |
unproject: function (point, zoom) { // (Point[, Number]) -> LatLng | |
zoom = zoom === undefined ? this._zoom : zoom; | |
return this.options.crs.pointToLatLng(L.point(point), zoom); | |
}, | |
layerPointToLatLng: function (point) { // (Point) | |
var projectedPoint = L.point(point).add(this.getPixelOrigin()); | |
return this.unproject(projectedPoint); | |
}, | |
latLngToLayerPoint: function (latlng) { // (LatLng) | |
var projectedPoint = this.project(L.latLng(latlng))._round(); | |
return projectedPoint._subtract(this.getPixelOrigin()); | |
}, | |
containerPointToLayerPoint: function (point) { // (Point) | |
return L.point(point).subtract(this._getMapPanePos()); | |
}, | |
layerPointToContainerPoint: function (point) { // (Point) | |
return L.point(point).add(this._getMapPanePos()); | |
}, | |
containerPointToLatLng: function (point) { | |
var layerPoint = this.containerPointToLayerPoint(L.point(point)); | |
return this.layerPointToLatLng(layerPoint); | |
}, | |
latLngToContainerPoint: function (latlng) { | |
return this.layerPointToContainerPoint(this.latLngToLayerPoint(L.latLng(latlng))); | |
}, | |
mouseEventToContainerPoint: function (e) { // (MouseEvent) | |
return L.DomEvent.getMousePosition(e, this._container); | |
}, | |
mouseEventToLayerPoint: function (e) { // (MouseEvent) | |
return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e)); | |
}, | |
mouseEventToLatLng: function (e) { // (MouseEvent) | |
return this.layerPointToLatLng(this.mouseEventToLayerPoint(e)); | |
}, | |
// map initialization methods | |
_initContainer: function (id) { | |
var container = this._container = L.DomUtil.get(id); | |
if (!container) { | |
throw new Error('Map container not found.'); | |
} else if (container._leaflet) { | |
throw new Error('Map container is already initialized.'); | |
} | |
container._leaflet = true; | |
}, | |
_initLayout: function () { | |
var container = this._container; | |
L.DomUtil.addClass(container, 'leaflet-container' + | |
(L.Browser.touch ? ' leaflet-touch' : '') + | |
(L.Browser.retina ? ' leaflet-retina' : '') + | |
(L.Browser.ielt9 ? ' leaflet-oldie' : '') + | |
(this.options.fadeAnimation ? ' leaflet-fade-anim' : '')); | |
var position = L.DomUtil.getStyle(container, 'position'); | |
if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') { | |
container.style.position = 'relative'; | |
} | |
this._initPanes(); | |
if (this._initControlPos) { | |
this._initControlPos(); | |
} | |
}, | |
_initPanes: function () { | |
var panes = this._panes = {}; | |
this._mapPane = panes.mapPane = this._createPane('leaflet-map-pane', this._container); | |
this._tilePane = panes.tilePane = this._createPane('leaflet-tile-pane', this._mapPane); | |
panes.objectsPane = this._createPane('leaflet-objects-pane', this._mapPane); | |
panes.shadowPane = this._createPane('leaflet-shadow-pane'); | |
panes.overlayPane = this._createPane('leaflet-overlay-pane'); | |
panes.markerPane = this._createPane('leaflet-marker-pane'); | |
panes.popupPane = this._createPane('leaflet-popup-pane'); | |
var zoomHide = ' leaflet-zoom-hide'; | |
if (!this.options.markerZoomAnimation) { | |
L.DomUtil.addClass(panes.markerPane, zoomHide); | |
L.DomUtil.addClass(panes.shadowPane, zoomHide); | |
L.DomUtil.addClass(panes.popupPane, zoomHide); | |
} | |
}, | |
_createPane: function (className, container) { | |
return L.DomUtil.create('div', className, container || this._panes.objectsPane); | |
}, | |
_clearPanes: function () { | |
this._container.removeChild(this._mapPane); | |
}, | |
_addLayers: function (layers) { | |
layers = layers ? (L.Util.isArray(layers) ? layers : [layers]) : []; | |
for (var i = 0, len = layers.length; i < len; i++) { | |
this.addLayer(layers[i]); | |
} | |
}, | |
// private methods that modify map state | |
_resetView: function (center, zoom, preserveMapOffset, afterZoomAnim) { | |
var zoomChanged = (this._zoom !== zoom); | |
if (!afterZoomAnim) { | |
this.fire('movestart'); | |
if (zoomChanged) { | |
this.fire('zoomstart'); | |
} | |
} | |
this._zoom = zoom; | |
this._initialCenter = center; | |
this._initialTopLeftPoint = this._getNewTopLeftPoint(center); | |
if (!preserveMapOffset) { | |
L.DomUtil.setPosition(this._mapPane, new L.Point(0, 0)); | |
} else { | |
this._initialTopLeftPoint._add(this._getMapPanePos()); | |
} | |
this._tileLayersToLoad = this._tileLayersNum; | |
var loading = !this._loaded; | |
this._loaded = true; | |
this.fire('viewreset', {hard: !preserveMapOffset}); | |
if (loading) { | |
this.fire('load'); | |
this.eachLayer(this._layerAdd, this); | |
} | |
this.fire('move'); | |
if (zoomChanged || afterZoomAnim) { | |
this.fire('zoomend'); | |
} | |
this.fire('moveend', {hard: !preserveMapOffset}); | |
}, | |
_rawPanBy: function (offset) { | |
L.DomUtil.setPosition(this._mapPane, this._getMapPanePos().subtract(offset)); | |
}, | |
_getZoomSpan: function () { | |
return this.getMaxZoom() - this.getMinZoom(); | |
}, | |
_updateZoomLevels: function () { | |
var i, | |
minZoom = Infinity, | |
maxZoom = -Infinity, | |
oldZoomSpan = this._getZoomSpan(); | |
for (i in this._zoomBoundLayers) { | |
var layer = this._zoomBoundLayers[i]; | |
if (!isNaN(layer.options.minZoom)) { | |
minZoom = Math.min(minZoom, layer.options.minZoom); | |
} | |
if (!isNaN(layer.options.maxZoom)) { | |
maxZoom = Math.max(maxZoom, layer.options.maxZoom); | |
} | |
} | |
if (i === undefined) { // we have no tilelayers | |
this._layersMaxZoom = this._layersMinZoom = undefined; | |
} else { | |
this._layersMaxZoom = maxZoom; | |
this._layersMinZoom = minZoom; | |
} | |
if (oldZoomSpan !== this._getZoomSpan()) { | |
this.fire('zoomlevelschange'); | |
} | |
}, | |
_panInsideMaxBounds: function () { | |
this.panInsideBounds(this.options.maxBounds); | |
}, | |
_checkIfLoaded: function () { | |
if (!this._loaded) { | |
throw new Error('Set map center and zoom first.'); | |
} | |
}, | |
// map events | |
_initEvents: function (onOff) { | |
if (!L.DomEvent) { return; } | |
onOff = onOff || 'on'; | |
L.DomEvent[onOff](this._container, 'click', this._onMouseClick, this); | |
var events = ['dblclick', 'mousedown', 'mouseup', 'mouseenter', | |
'mouseleave', 'mousemove', 'contextmenu'], | |
i, len; | |
for (i = 0, len = events.length; i < len; i++) { | |
L.DomEvent[onOff](this._container, events[i], this._fireMouseEvent, this); | |
} | |
if (this.options.trackResize) { | |
L.DomEvent[onOff](window, 'resize', this._onResize, this); | |
} | |
}, | |
_onResize: function () { | |
L.Util.cancelAnimFrame(this._resizeRequest); | |
this._resizeRequest = L.Util.requestAnimFrame( | |
function () { this.invalidateSize({debounceMoveend: true}); }, this, false, this._container); | |
}, | |
_onMouseClick: function (e) { | |
if (!this._loaded || (!e._simulated && | |
((this.dragging && this.dragging.moved()) || | |
(this.boxZoom && this.boxZoom.moved()))) || | |
L.DomEvent._skipped(e)) { return; } | |
this.fire('preclick'); | |
this._fireMouseEvent(e); | |
}, | |
_fireMouseEvent: function (e) { | |
if (!this._loaded || L.DomEvent._skipped(e)) { return; } | |
var type = e.type; | |
type = (type === 'mouseenter' ? 'mouseover' : (type === 'mouseleave' ? 'mouseout' : type)); | |
if (!this.hasEventListeners(type)) { return; } | |
if (type === 'contextmenu') { | |
L.DomEvent.preventDefault(e); | |
} | |
var containerPoint = this.mouseEventToContainerPoint(e), | |
layerPoint = this.containerPointToLayerPoint(containerPoint), | |
latlng = this.layerPointToLatLng(layerPoint); | |
this.fire(type, { | |
latlng: latlng, | |
layerPoint: layerPoint, | |
containerPoint: containerPoint, | |
originalEvent: e | |
}); | |
}, | |
_onTileLayerLoad: function () { | |
this._tileLayersToLoad--; | |
if (this._tileLayersNum && !this._tileLayersToLoad) { | |
this.fire('tilelayersload'); | |
} | |
}, | |
_clearHandlers: function () { | |
for (var i = 0, len = this._handlers.length; i < len; i++) { | |
this._handlers[i].disable(); | |
} | |
}, | |
whenReady: function (callback, context) { | |
if (this._loaded) { | |
callback.call(context || this, this); | |
} else { | |
this.on('load', callback, context); | |
} | |
return this; | |
}, | |
_layerAdd: function (layer) { | |
layer.onAdd(this); | |
this.fire('layeradd', {layer: layer}); | |
}, | |
// private methods for getting map state | |
_getMapPanePos: function () { | |
return L.DomUtil.getPosition(this._mapPane); | |
}, | |
_moved: function () { | |
var pos = this._getMapPanePos(); | |
return pos && !pos.equals([0, 0]); | |
}, | |
_getTopLeftPoint: function () { | |
return this.getPixelOrigin().subtract(this._getMapPanePos()); | |
}, | |
_getNewTopLeftPoint: function (center, zoom) { | |
var viewHalf = this.getSize()._divideBy(2); | |
// TODO round on display, not calculation to increase precision? | |
return this.project(center, zoom)._subtract(viewHalf)._round(); | |
}, | |
_latLngToNewLayerPoint: function (latlng, newZoom, newCenter) { | |
var topLeft = this._getNewTopLeftPoint(newCenter, newZoom).add(this._getMapPanePos()); | |
return this.project(latlng, newZoom)._subtract(topLeft); | |
}, | |
// layer point of the current center | |
_getCenterLayerPoint: function () { | |
return this.containerPointToLayerPoint(this.getSize()._divideBy(2)); | |
}, | |
// offset of the specified place to the current center in pixels | |
_getCenterOffset: function (latlng) { | |
return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint()); | |
}, | |
// adjust center for view to get inside bounds | |
_limitCenter: function (center, zoom, bounds) { | |
if (!bounds) { return center; } | |
var centerPoint = this.project(center, zoom), | |
viewHalf = this.getSize().divideBy(2), | |
viewBounds = new L.Bounds(centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)), | |
offset = this._getBoundsOffset(viewBounds, bounds, zoom); | |
return this.unproject(centerPoint.add(offset), zoom); | |
}, | |
// adjust offset for view to get inside bounds | |
_limitOffset: function (offset, bounds) { | |
if (!bounds) { return offset; } | |
var viewBounds = this.getPixelBounds(), | |
newBounds = new L.Bounds(viewBounds.min.add(offset), viewBounds.max.add(offset)); | |
return offset.add(this._getBoundsOffset(newBounds, bounds)); | |
}, | |
// returns offset needed for pxBounds to get inside maxBounds at a specified zoom | |
_getBoundsOffset: function (pxBounds, maxBounds, zoom) { | |
var nwOffset = this.project(maxBounds.getNorthWest(), zoom).subtract(pxBounds.min), | |
seOffset = this.project(maxBounds.getSouthEast(), zoom).subtract(pxBounds.max), | |
dx = this._rebound(nwOffset.x, -seOffset.x), | |
dy = this._rebound(nwOffset.y, -seOffset.y); | |
return new L.Point(dx, dy); | |
}, | |
_rebound: function (left, right) { | |
return left + right > 0 ? | |
Math.round(left - right) / 2 : | |
Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right)); | |
}, | |
_limitZoom: function (zoom) { | |
var min = this.getMinZoom(), | |
max = this.getMaxZoom(); | |
return Math.max(min, Math.min(max, zoom)); | |
} | |
}); | |
L.map = function (id, options) { | |
return new L.Map(id, options); | |
}; | |
/* | |
* Mercator projection that takes into account that the Earth is not a perfect sphere. | |
* Less popular than spherical mercator; used by projections like EPSG:3395. | |
*/ | |
L.Projection.Mercator = { | |
MAX_LATITUDE: 85.0840591556, | |
R_MINOR: 6356752.314245179, | |
R_MAJOR: 6378137, | |
project: function (latlng) { // (LatLng) -> Point | |
var d = L.LatLng.DEG_TO_RAD, | |
max = this.MAX_LATITUDE, | |
lat = Math.max(Math.min(max, latlng.lat), -max), | |
r = this.R_MAJOR, | |
r2 = this.R_MINOR, | |
x = latlng.lng * d * r, | |
y = lat * d, | |
tmp = r2 / r, | |
eccent = Math.sqrt(1.0 - tmp * tmp), | |
con = eccent * Math.sin(y); | |
con = Math.pow((1 - con) / (1 + con), eccent * 0.5); | |
var ts = Math.tan(0.5 * ((Math.PI * 0.5) - y)) / con; | |
y = -r * Math.log(ts); | |
return new L.Point(x, y); | |
}, | |
unproject: function (point) { // (Point, Boolean) -> LatLng | |
var d = L.LatLng.RAD_TO_DEG, | |
r = this.R_MAJOR, | |
r2 = this.R_MINOR, | |
lng = point.x * d / r, | |
tmp = r2 / r, | |
eccent = Math.sqrt(1 - (tmp * tmp)), | |
ts = Math.exp(- point.y / r), | |
phi = (Math.PI / 2) - 2 * Math.atan(ts), | |
numIter = 15, | |
tol = 1e-7, | |
i = numIter, | |
dphi = 0.1, | |
con; | |
while ((Math.abs(dphi) > tol) && (--i > 0)) { | |
con = eccent * Math.sin(phi); | |
dphi = (Math.PI / 2) - 2 * Math.atan(ts * | |
Math.pow((1.0 - con) / (1.0 + con), 0.5 * eccent)) - phi; | |
phi += dphi; | |
} | |
return new L.LatLng(phi * d, lng); | |
} | |
}; | |
L.CRS.EPSG3395 = L.extend({}, L.CRS, { | |
code: 'EPSG:3395', | |
projection: L.Projection.Mercator, | |
transformation: (function () { | |
var m = L.Projection.Mercator, | |
r = m.R_MAJOR, | |
scale = 0.5 / (Math.PI * r); | |
return new L.Transformation(scale, 0.5, -scale, 0.5); | |
}()) | |
}); | |
/* | |
* L.TileLayer is used for standard xyz-numbered tile layers. | |
*/ | |
L.TileLayer = L.Class.extend({ | |
includes: L.Mixin.Events, | |
options: { | |
minZoom: 0, | |
maxZoom: 18, | |
tileSize: 256, | |
subdomains: 'abc', | |
errorTileUrl: '', | |
attribution: '', | |
zoomOffset: 0, | |
opacity: 1, | |
/* | |
maxNativeZoom: null, | |
zIndex: null, | |
tms: false, | |
continuousWorld: false, | |
noWrap: false, | |
zoomReverse: false, | |
detectRetina: false, | |
reuseTiles: false, | |
bounds: false, | |
*/ | |
unloadInvisibleTiles: L.Browser.mobile, | |
updateWhenIdle: L.Browser.mobile | |
}, | |
initialize: function (url, options) { | |
options = L.setOptions(this, options); | |
// detecting retina displays, adjusting tileSize and zoom levels | |
if (options.detectRetina && L.Browser.retina && options.maxZoom > 0) { | |
options.tileSize = Math.floor(options.tileSize / 2); | |
options.zoomOffset++; | |
if (options.minZoom > 0) { | |
options.minZoom--; | |
} | |
this.options.maxZoom--; | |
} | |
if (options.bounds) { | |
options.bounds = L.latLngBounds(options.bounds); | |
} | |
this._url = url; | |
var subdomains = this.options.subdomains; | |
if (typeof subdomains === 'string') { | |
this.options.subdomains = subdomains.split(''); | |
} | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
this._animated = map._zoomAnimated; | |
// create a container div for tiles | |
this._initContainer(); | |
// set up events | |
map.on({ | |
'viewreset': this._reset, | |
'moveend': this._update | |
}, this); | |
if (this._animated) { | |
map.on({ | |
'zoomanim': this._animateZoom, | |
'zoomend': this._endZoomAnim | |
}, this); | |
} | |
if (!this.options.updateWhenIdle) { | |
this._limitedUpdate = L.Util.limitExecByInterval(this._update, 150, this); | |
map.on('move', this._limitedUpdate, this); | |
} | |
this._reset(); | |
this._update(); | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
onRemove: function (map) { | |
this._container.parentNode.removeChild(this._container); | |
map.off({ | |
'viewreset': this._reset, | |
'moveend': this._update | |
}, this); | |
if (this._animated) { | |
map.off({ | |
'zoomanim': this._animateZoom, | |
'zoomend': this._endZoomAnim | |
}, this); | |
} | |
if (!this.options.updateWhenIdle) { | |
map.off('move', this._limitedUpdate, this); | |
} | |
this._container = null; | |
this._map = null; | |
}, | |
bringToFront: function () { | |
var pane = this._map._panes.tilePane; | |
if (this._container) { | |
pane.appendChild(this._container); | |
this._setAutoZIndex(pane, Math.max); | |
} | |
return this; | |
}, | |
bringToBack: function () { | |
var pane = this._map._panes.tilePane; | |
if (this._container) { | |
pane.insertBefore(this._container, pane.firstChild); | |
this._setAutoZIndex(pane, Math.min); | |
} | |
return this; | |
}, | |
getAttribution: function () { | |
return this.options.attribution; | |
}, | |
getContainer: function () { | |
return this._container; | |
}, | |
setOpacity: function (opacity) { | |
this.options.opacity = opacity; | |
if (this._map) { | |
this._updateOpacity(); | |
} | |
return this; | |
}, | |
setZIndex: function (zIndex) { | |
this.options.zIndex = zIndex; | |
this._updateZIndex(); | |
return this; | |
}, | |
setUrl: function (url, noRedraw) { | |
this._url = url; | |
if (!noRedraw) { | |
this.redraw(); | |
} | |
return this; | |
}, | |
redraw: function () { | |
if (this._map) { | |
this._reset({hard: true}); | |
this._update(); | |
} | |
return this; | |
}, | |
_updateZIndex: function () { | |
if (this._container && this.options.zIndex !== undefined) { | |
this._container.style.zIndex = this.options.zIndex; | |
} | |
}, | |
_setAutoZIndex: function (pane, compare) { | |
var layers = pane.children, | |
edgeZIndex = -compare(Infinity, -Infinity), // -Infinity for max, Infinity for min | |
zIndex, i, len; | |
for (i = 0, len = layers.length; i < len; i++) { | |
if (layers[i] !== this._container) { | |
zIndex = parseInt(layers[i].style.zIndex, 10); | |
if (!isNaN(zIndex)) { | |
edgeZIndex = compare(edgeZIndex, zIndex); | |
} | |
} | |
} | |
this.options.zIndex = this._container.style.zIndex = | |
(isFinite(edgeZIndex) ? edgeZIndex : 0) + compare(1, -1); | |
}, | |
_updateOpacity: function () { | |
var i, | |
tiles = this._tiles; | |
if (L.Browser.ielt9) { | |
for (i in tiles) { | |
L.DomUtil.setOpacity(tiles[i], this.options.opacity); | |
} | |
} else { | |
L.DomUtil.setOpacity(this._container, this.options.opacity); | |
} | |
}, | |
_initContainer: function () { | |
var tilePane = this._map._panes.tilePane; | |
if (!this._container) { | |
this._container = L.DomUtil.create('div', 'leaflet-layer'); | |
this._updateZIndex(); | |
if (this._animated) { | |
var className = 'leaflet-tile-container'; | |
this._bgBuffer = L.DomUtil.create('div', className, this._container); | |
this._tileContainer = L.DomUtil.create('div', className, this._container); | |
} else { | |
this._tileContainer = this._container; | |
} | |
tilePane.appendChild(this._container); | |
if (this.options.opacity < 1) { | |
this._updateOpacity(); | |
} | |
} | |
}, | |
_reset: function (e) { | |
for (var key in this._tiles) { | |
this.fire('tileunload', {tile: this._tiles[key]}); | |
} | |
this._tiles = {}; | |
this._tilesToLoad = 0; | |
if (this.options.reuseTiles) { | |
this._unusedTiles = []; | |
} | |
this._tileContainer.innerHTML = ''; | |
if (this._animated && e && e.hard) { | |
this._clearBgBuffer(); | |
} | |
this._initContainer(); | |
}, | |
_getTileSize: function () { | |
var map = this._map, | |
zoom = map.getZoom() + this.options.zoomOffset, | |
zoomN = this.options.maxNativeZoom, | |
tileSize = this.options.tileSize; | |
if (zoomN && zoom > zoomN) { | |
tileSize = Math.round(map.getZoomScale(zoom) / map.getZoomScale(zoomN) * tileSize); | |
} | |
return tileSize; | |
}, | |
_update: function () { | |
if (!this._map) { return; } | |
var map = this._map, | |
bounds = map.getPixelBounds(), | |
zoom = map.getZoom(), | |
tileSize = this._getTileSize(); | |
if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { | |
return; | |
} | |
var tileBounds = L.bounds( | |
bounds.min.divideBy(tileSize)._floor(), | |
bounds.max.divideBy(tileSize)._floor()); | |
this._addTilesFromCenterOut(tileBounds); | |
if (this.options.unloadInvisibleTiles || this.options.reuseTiles) { | |
this._removeOtherTiles(tileBounds); | |
} | |
}, | |
_addTilesFromCenterOut: function (bounds) { | |
var queue = [], | |
center = bounds.getCenter(); | |
var j, i, point; | |
for (j = bounds.min.y; j <= bounds.max.y; j++) { | |
for (i = bounds.min.x; i <= bounds.max.x; i++) { | |
point = new L.Point(i, j); | |
if (this._tileShouldBeLoaded(point)) { | |
queue.push(point); | |
} | |
} | |
} | |
var tilesToLoad = queue.length; | |
if (tilesToLoad === 0) { return; } | |
// load tiles in order of their distance to center | |
queue.sort(function (a, b) { | |
return a.distanceTo(center) - b.distanceTo(center); | |
}); | |
var fragment = document.createDocumentFragment(); | |
// if its the first batch of tiles to load | |
if (!this._tilesToLoad) { | |
this.fire('loading'); | |
} | |
this._tilesToLoad += tilesToLoad; | |
for (i = 0; i < tilesToLoad; i++) { | |
this._addTile(queue[i], fragment); | |
} | |
this._tileContainer.appendChild(fragment); | |
}, | |
_tileShouldBeLoaded: function (tilePoint) { | |
if ((tilePoint.x + ':' + tilePoint.y) in this._tiles) { | |
return false; // already loaded | |
} | |
var options = this.options; | |
if (!options.continuousWorld) { | |
var limit = this._getWrapTileNum(); | |
// don't load if exceeds world bounds | |
if ((options.noWrap && (tilePoint.x < 0 || tilePoint.x >= limit.x)) || | |
tilePoint.y < 0 || tilePoint.y >= limit.y) { return false; } | |
} | |
if (options.bounds) { | |
var tileSize = this._getTileSize(), | |
nwPoint = tilePoint.multiplyBy(tileSize), | |
sePoint = nwPoint.add([tileSize, tileSize]), | |
nw = this._map.unproject(nwPoint), | |
se = this._map.unproject(sePoint); | |
// TODO temporary hack, will be removed after refactoring projections | |
// https://github.com/Leaflet/Leaflet/issues/1618 | |
if (!options.continuousWorld && !options.noWrap) { | |
nw = nw.wrap(); | |
se = se.wrap(); | |
} | |
if (!options.bounds.intersects([nw, se])) { return false; } | |
} | |
return true; | |
}, | |
_removeOtherTiles: function (bounds) { | |
var kArr, x, y, key; | |
for (key in this._tiles) { | |
kArr = key.split(':'); | |
x = parseInt(kArr[0], 10); | |
y = parseInt(kArr[1], 10); | |
// remove tile if it's out of bounds | |
if (x < bounds.min.x || x > bounds.max.x || y < bounds.min.y || y > bounds.max.y) { | |
this._removeTile(key); | |
} | |
} | |
}, | |
_removeTile: function (key) { | |
var tile = this._tiles[key]; | |
this.fire('tileunload', {tile: tile, url: tile.src}); | |
if (this.options.reuseTiles) { | |
L.DomUtil.removeClass(tile, 'leaflet-tile-loaded'); | |
this._unusedTiles.push(tile); | |
} else if (tile.parentNode === this._tileContainer) { | |
this._tileContainer.removeChild(tile); | |
} | |
// for https://github.com/CloudMade/Leaflet/issues/137 | |
if (!L.Browser.android) { | |
tile.onload = null; | |
tile.src = L.Util.emptyImageUrl; | |
} | |
delete this._tiles[key]; | |
}, | |
_addTile: function (tilePoint, container) { | |
var tilePos = this._getTilePos(tilePoint); | |
// get unused tile - or create a new tile | |
var tile = this._getTile(); | |
/* | |
Chrome 20 layouts much faster with top/left (verify with timeline, frames) | |
Android 4 browser has display issues with top/left and requires transform instead | |
(other browsers don't currently care) - see debug/hacks/jitter.html for an example | |
*/ | |
L.DomUtil.setPosition(tile, tilePos, L.Browser.chrome); | |
this._tiles[tilePoint.x + ':' + tilePoint.y] = tile; | |
this._loadTile(tile, tilePoint); | |
if (tile.parentNode !== this._tileContainer) { | |
container.appendChild(tile); | |
} | |
}, | |
_getZoomForUrl: function () { | |
var options = this.options, | |
zoom = this._map.getZoom(); | |
if (options.zoomReverse) { | |
zoom = options.maxZoom - zoom; | |
} | |
zoom += options.zoomOffset; | |
return options.maxNativeZoom ? Math.min(zoom, options.maxNativeZoom) : zoom; | |
}, | |
_getTilePos: function (tilePoint) { | |
var origin = this._map.getPixelOrigin(), | |
tileSize = this._getTileSize(); | |
return tilePoint.multiplyBy(tileSize).subtract(origin); | |
}, | |
// image-specific code (override to implement e.g. Canvas or SVG tile layer) | |
getTileUrl: function (tilePoint) { | |
return L.Util.template(this._url, L.extend({ | |
s: this._getSubdomain(tilePoint), | |
z: tilePoint.z, | |
x: tilePoint.x, | |
y: tilePoint.y | |
}, this.options)); | |
}, | |
_getWrapTileNum: function () { | |
var crs = this._map.options.crs, | |
size = crs.getSize(this._map.getZoom()); | |
return size.divideBy(this._getTileSize())._floor(); | |
}, | |
_adjustTilePoint: function (tilePoint) { | |
var limit = this._getWrapTileNum(); | |
// wrap tile coordinates | |
if (!this.options.continuousWorld && !this.options.noWrap) { | |
tilePoint.x = ((tilePoint.x % limit.x) + limit.x) % limit.x; | |
} | |
if (this.options.tms) { | |
tilePoint.y = limit.y - tilePoint.y - 1; | |
} | |
tilePoint.z = this._getZoomForUrl(); | |
}, | |
_getSubdomain: function (tilePoint) { | |
var index = Math.abs(tilePoint.x + tilePoint.y) % this.options.subdomains.length; | |
return this.options.subdomains[index]; | |
}, | |
_getTile: function () { | |
if (this.options.reuseTiles && this._unusedTiles.length > 0) { | |
var tile = this._unusedTiles.pop(); | |
this._resetTile(tile); | |
return tile; | |
} | |
return this._createTile(); | |
}, | |
// Override if data stored on a tile needs to be cleaned up before reuse | |
_resetTile: function (/*tile*/) {}, | |
_createTile: function () { | |
var tile = L.DomUtil.create('img', 'leaflet-tile'); | |
tile.style.width = tile.style.height = this._getTileSize() + 'px'; | |
tile.galleryimg = 'no'; | |
tile.onselectstart = tile.onmousemove = L.Util.falseFn; | |
if (L.Browser.ielt9 && this.options.opacity !== undefined) { | |
L.DomUtil.setOpacity(tile, this.options.opacity); | |
} | |
// without this hack, tiles disappear after zoom on Chrome for Android | |
// https://github.com/Leaflet/Leaflet/issues/2078 | |
if (L.Browser.mobileWebkit3d) { | |
tile.style.WebkitBackfaceVisibility = 'hidden'; | |
} | |
return tile; | |
}, | |
_loadTile: function (tile, tilePoint) { | |
tile._layer = this; | |
tile.onload = this._tileOnLoad; | |
tile.onerror = this._tileOnError; | |
this._adjustTilePoint(tilePoint); | |
tile.src = this.getTileUrl(tilePoint); | |
this.fire('tileloadstart', { | |
tile: tile, | |
url: tile.src | |
}); | |
}, | |
_tileLoaded: function () { | |
this._tilesToLoad--; | |
if (this._animated) { | |
L.DomUtil.addClass(this._tileContainer, 'leaflet-zoom-animated'); | |
} | |
if (!this._tilesToLoad) { | |
this.fire('load'); | |
if (this._animated) { | |
// clear scaled tiles after all new tiles are loaded (for performance) | |
clearTimeout(this._clearBgBufferTimer); | |
this._clearBgBufferTimer = setTimeout(L.bind(this._clearBgBuffer, this), 500); | |
} | |
} | |
}, | |
_tileOnLoad: function () { | |
var layer = this._layer; | |
//Only if we are loading an actual image | |
if (this.src !== L.Util.emptyImageUrl) { | |
L.DomUtil.addClass(this, 'leaflet-tile-loaded'); | |
layer.fire('tileload', { | |
tile: this, | |
url: this.src | |
}); | |
} | |
layer._tileLoaded(); | |
}, | |
_tileOnError: function () { | |
var layer = this._layer; | |
layer.fire('tileerror', { | |
tile: this, | |
url: this.src | |
}); | |
var newUrl = layer.options.errorTileUrl; | |
if (newUrl) { | |
this.src = newUrl; | |
} | |
layer._tileLoaded(); | |
} | |
}); | |
L.tileLayer = function (url, options) { | |
return new L.TileLayer(url, options); | |
}; | |
/* | |
* L.TileLayer.WMS is used for putting WMS tile layers on the map. | |
*/ | |
L.TileLayer.WMS = L.TileLayer.extend({ | |
defaultWmsParams: { | |
service: 'WMS', | |
request: 'GetMap', | |
version: '1.1.1', | |
layers: '', | |
styles: '', | |
format: 'image/jpeg', | |
transparent: false | |
}, | |
initialize: function (url, options) { // (String, Object) | |
this._url = url; | |
var wmsParams = L.extend({}, this.defaultWmsParams), | |
tileSize = options.tileSize || this.options.tileSize; | |
if (options.detectRetina && L.Browser.retina) { | |
wmsParams.width = wmsParams.height = tileSize * 2; | |
} else { | |
wmsParams.width = wmsParams.height = tileSize; | |
} | |
for (var i in options) { | |
// all keys that are not TileLayer options go to WMS params | |
if (!this.options.hasOwnProperty(i) && i !== 'crs') { | |
wmsParams[i] = options[i]; | |
} | |
} | |
this.wmsParams = wmsParams; | |
L.setOptions(this, options); | |
}, | |
onAdd: function (map) { | |
this._crs = this.options.crs || map.options.crs; | |
this._wmsVersion = parseFloat(this.wmsParams.version); | |
var projectionKey = this._wmsVersion >= 1.3 ? 'crs' : 'srs'; | |
this.wmsParams[projectionKey] = this._crs.code; | |
L.TileLayer.prototype.onAdd.call(this, map); | |
}, | |
getTileUrl: function (tilePoint) { // (Point, Number) -> String | |
var map = this._map, | |
tileSize = this.options.tileSize, | |
nwPoint = tilePoint.multiplyBy(tileSize), | |
sePoint = nwPoint.add([tileSize, tileSize]), | |
nw = this._crs.project(map.unproject(nwPoint, tilePoint.z)), | |
se = this._crs.project(map.unproject(sePoint, tilePoint.z)), | |
bbox = this._wmsVersion >= 1.3 && this._crs === L.CRS.EPSG4326 ? | |
[se.y, nw.x, nw.y, se.x].join(',') : | |
[nw.x, se.y, se.x, nw.y].join(','), | |
url = L.Util.template(this._url, {s: this._getSubdomain(tilePoint)}); | |
return url + L.Util.getParamString(this.wmsParams, url, true) + '&BBOX=' + bbox; | |
}, | |
setParams: function (params, noRedraw) { | |
L.extend(this.wmsParams, params); | |
if (!noRedraw) { | |
this.redraw(); | |
} | |
return this; | |
} | |
}); | |
L.tileLayer.wms = function (url, options) { | |
return new L.TileLayer.WMS(url, options); | |
}; | |
/* | |
* L.TileLayer.Canvas is a class that you can use as a base for creating | |
* dynamically drawn Canvas-based tile layers. | |
*/ | |
L.TileLayer.Canvas = L.TileLayer.extend({ | |
options: { | |
async: false | |
}, | |
initialize: function (options) { | |
L.setOptions(this, options); | |
}, | |
redraw: function () { | |
if (this._map) { | |
this._reset({hard: true}); | |
this._update(); | |
} | |
for (var i in this._tiles) { | |
this._redrawTile(this._tiles[i]); | |
} | |
return this; | |
}, | |
_redrawTile: function (tile) { | |
this.drawTile(tile, tile._tilePoint, this._map._zoom); | |
}, | |
_createTile: function () { | |
var tile = L.DomUtil.create('canvas', 'leaflet-tile'); | |
tile.width = tile.height = this.options.tileSize; | |
tile.onselectstart = tile.onmousemove = L.Util.falseFn; | |
return tile; | |
}, | |
_loadTile: function (tile, tilePoint) { | |
tile._layer = this; | |
tile._tilePoint = tilePoint; | |
this._redrawTile(tile); | |
if (!this.options.async) { | |
this.tileDrawn(tile); | |
} | |
}, | |
drawTile: function (/*tile, tilePoint*/) { | |
// override with rendering code | |
}, | |
tileDrawn: function (tile) { | |
this._tileOnLoad.call(tile); | |
} | |
}); | |
L.tileLayer.canvas = function (options) { | |
return new L.TileLayer.Canvas(options); | |
}; | |
/* | |
* L.ImageOverlay is used to overlay images over the map (to specific geographical bounds). | |
*/ | |
L.ImageOverlay = L.Class.extend({ | |
includes: L.Mixin.Events, | |
options: { | |
opacity: 1 | |
}, | |
initialize: function (url, bounds, options) { // (String, LatLngBounds, Object) | |
this._url = url; | |
this._bounds = L.latLngBounds(bounds); | |
L.setOptions(this, options); | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
if (!this._image) { | |
this._initImage(); | |
} | |
map._panes.overlayPane.appendChild(this._image); | |
map.on('viewreset', this._reset, this); | |
if (map.options.zoomAnimation && L.Browser.any3d) { | |
map.on('zoomanim', this._animateZoom, this); | |
} | |
this._reset(); | |
}, | |
onRemove: function (map) { | |
map.getPanes().overlayPane.removeChild(this._image); | |
map.off('viewreset', this._reset, this); | |
if (map.options.zoomAnimation) { | |
map.off('zoomanim', this._animateZoom, this); | |
} | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
setOpacity: function (opacity) { | |
this.options.opacity = opacity; | |
this._updateOpacity(); | |
return this; | |
}, | |
// TODO remove bringToFront/bringToBack duplication from TileLayer/Path | |
bringToFront: function () { | |
if (this._image) { | |
this._map._panes.overlayPane.appendChild(this._image); | |
} | |
return this; | |
}, | |
bringToBack: function () { | |
var pane = this._map._panes.overlayPane; | |
if (this._image) { | |
pane.insertBefore(this._image, pane.firstChild); | |
} | |
return this; | |
}, | |
setUrl: function (url) { | |
this._url = url; | |
this._image.src = this._url; | |
}, | |
getAttribution: function () { | |
return this.options.attribution; | |
}, | |
_initImage: function () { | |
this._image = L.DomUtil.create('img', 'leaflet-image-layer'); | |
if (this._map.options.zoomAnimation && L.Browser.any3d) { | |
L.DomUtil.addClass(this._image, 'leaflet-zoom-animated'); | |
} else { | |
L.DomUtil.addClass(this._image, 'leaflet-zoom-hide'); | |
} | |
this._updateOpacity(); | |
//TODO createImage util method to remove duplication | |
L.extend(this._image, { | |
galleryimg: 'no', | |
onselectstart: L.Util.falseFn, | |
onmousemove: L.Util.falseFn, | |
onload: L.bind(this._onImageLoad, this), | |
src: this._url | |
}); | |
}, | |
_animateZoom: function (e) { | |
var map = this._map, | |
image = this._image, | |
scale = map.getZoomScale(e.zoom), | |
nw = this._bounds.getNorthWest(), | |
se = this._bounds.getSouthEast(), | |
topLeft = map._latLngToNewLayerPoint(nw, e.zoom, e.center), | |
size = map._latLngToNewLayerPoint(se, e.zoom, e.center)._subtract(topLeft), | |
origin = topLeft._add(size._multiplyBy((1 / 2) * (1 - 1 / scale))); | |
image.style[L.DomUtil.TRANSFORM] = | |
L.DomUtil.getTranslateString(origin) + ' scale(' + scale + ') '; | |
}, | |
_reset: function () { | |
var image = this._image, | |
topLeft = this._map.latLngToLayerPoint(this._bounds.getNorthWest()), | |
size = this._map.latLngToLayerPoint(this._bounds.getSouthEast())._subtract(topLeft); | |
L.DomUtil.setPosition(image, topLeft); | |
image.style.width = size.x + 'px'; | |
image.style.height = size.y + 'px'; | |
}, | |
_onImageLoad: function () { | |
this.fire('load'); | |
}, | |
_updateOpacity: function () { | |
L.DomUtil.setOpacity(this._image, this.options.opacity); | |
} | |
}); | |
L.imageOverlay = function (url, bounds, options) { | |
return new L.ImageOverlay(url, bounds, options); | |
}; | |
/* | |
* L.Icon is an image-based icon class that you can use with L.Marker for custom markers. | |
*/ | |
L.Icon = L.Class.extend({ | |
options: { | |
/* | |
iconUrl: (String) (required) | |
iconRetinaUrl: (String) (optional, used for retina devices if detected) | |
iconSize: (Point) (can be set through CSS) | |
iconAnchor: (Point) (centered by default, can be set in CSS with negative margins) | |
popupAnchor: (Point) (if not specified, popup opens in the anchor point) | |
shadowUrl: (String) (no shadow by default) | |
shadowRetinaUrl: (String) (optional, used for retina devices if detected) | |
shadowSize: (Point) | |
shadowAnchor: (Point) | |
*/ | |
className: '' | |
}, | |
initialize: function (options) { | |
L.setOptions(this, options); | |
}, | |
createIcon: function (oldIcon) { | |
return this._createIcon('icon', oldIcon); | |
}, | |
createShadow: function (oldIcon) { | |
return this._createIcon('shadow', oldIcon); | |
}, | |
_createIcon: function (name, oldIcon) { | |
var src = this._getIconUrl(name); | |
if (!src) { | |
if (name === 'icon') { | |
throw new Error('iconUrl not set in Icon options (see the docs).'); | |
} | |
return null; | |
} | |
var img; | |
if (!oldIcon || oldIcon.tagName !== 'IMG') { | |
img = this._createImg(src); | |
} else { | |
img = this._createImg(src, oldIcon); | |
} | |
this._setIconStyles(img, name); | |
return img; | |
}, | |
_setIconStyles: function (img, name) { | |
var options = this.options, | |
size = L.point(options[name + 'Size']), | |
anchor; | |
if (name === 'shadow') { | |
anchor = L.point(options.shadowAnchor || options.iconAnchor); | |
} else { | |
anchor = L.point(options.iconAnchor); | |
} | |
if (!anchor && size) { | |
anchor = size.divideBy(2, true); | |
} | |
img.className = 'leaflet-marker-' + name + ' ' + options.className; | |
if (anchor) { | |
img.style.marginLeft = (-anchor.x) + 'px'; | |
img.style.marginTop = (-anchor.y) + 'px'; | |
} | |
if (size) { | |
img.style.width = size.x + 'px'; | |
img.style.height = size.y + 'px'; | |
} | |
}, | |
_createImg: function (src, el) { | |
el = el || document.createElement('img'); | |
el.src = src; | |
return el; | |
}, | |
_getIconUrl: function (name) { | |
if (L.Browser.retina && this.options[name + 'RetinaUrl']) { | |
return this.options[name + 'RetinaUrl']; | |
} | |
return this.options[name + 'Url']; | |
} | |
}); | |
L.icon = function (options) { | |
return new L.Icon(options); | |
}; | |
/* | |
* L.Icon.Default is the blue marker icon used by default in Leaflet. | |
*/ | |
L.Icon.Default = L.Icon.extend({ | |
options: { | |
iconSize: [25, 41], | |
iconAnchor: [12, 41], | |
popupAnchor: [1, -34], | |
shadowSize: [41, 41] | |
}, | |
_getIconUrl: function (name) { | |
var key = name + 'Url'; | |
if (this.options[key]) { | |
return this.options[key]; | |
} | |
if (L.Browser.retina && name === 'icon') { | |
name += '-2x'; | |
} | |
var path = L.Icon.Default.imagePath; | |
if (!path) { | |
throw new Error('Couldn\'t autodetect L.Icon.Default.imagePath, set it manually.'); | |
} | |
return path + '/marker-' + name + '.png'; | |
} | |
}); | |
L.Icon.Default.imagePath = (function () { | |
var scripts = document.getElementsByTagName('script'), | |
leafletRe = /[\/^]leaflet[\-\._]?([\w\-\._]*)\.js\??/; | |
var i, len, src, matches, path; | |
for (i = 0, len = scripts.length; i < len; i++) { | |
src = scripts[i].src; | |
matches = src.match(leafletRe); | |
if (matches) { | |
path = src.split(leafletRe)[0]; | |
return (path ? path + '/' : '') + 'images'; | |
} | |
} | |
}()); | |
/* | |
* L.Marker is used to display clickable/draggable icons on the map. | |
*/ | |
L.Marker = L.Class.extend({ | |
includes: L.Mixin.Events, | |
options: { | |
icon: new L.Icon.Default(), | |
title: '', | |
alt: '', | |
clickable: true, | |
draggable: false, | |
keyboard: true, | |
zIndexOffset: 0, | |
opacity: 1, | |
riseOnHover: false, | |
riseOffset: 250 | |
}, | |
initialize: function (latlng, options) { | |
L.setOptions(this, options); | |
this._latlng = L.latLng(latlng); | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
map.on('viewreset', this.update, this); | |
this._initIcon(); | |
this.update(); | |
this.fire('add'); | |
if (map.options.zoomAnimation && map.options.markerZoomAnimation) { | |
map.on('zoomanim', this._animateZoom, this); | |
} | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
onRemove: function (map) { | |
if (this.dragging) { | |
this.dragging.disable(); | |
} | |
this._removeIcon(); | |
this._removeShadow(); | |
this.fire('remove'); | |
map.off({ | |
'viewreset': this.update, | |
'zoomanim': this._animateZoom | |
}, this); | |
this._map = null; | |
}, | |
getLatLng: function () { | |
return this._latlng; | |
}, | |
setLatLng: function (latlng) { | |
this._latlng = L.latLng(latlng); | |
this.update(); | |
return this.fire('move', { latlng: this._latlng }); | |
}, | |
setZIndexOffset: function (offset) { | |
this.options.zIndexOffset = offset; | |
this.update(); | |
return this; | |
}, | |
setIcon: function (icon) { | |
this.options.icon = icon; | |
if (this._map) { | |
this._initIcon(); | |
this.update(); | |
} | |
if (this._popup) { | |
this.bindPopup(this._popup); | |
} | |
return this; | |
}, | |
update: function () { | |
if (this._icon) { | |
this._setPos(this._map.latLngToLayerPoint(this._latlng).round()); | |
} | |
return this; | |
}, | |
_initIcon: function () { | |
var options = this.options, | |
map = this._map, | |
animation = (map.options.zoomAnimation && map.options.markerZoomAnimation), | |
classToAdd = animation ? 'leaflet-zoom-animated' : 'leaflet-zoom-hide'; | |
var icon = options.icon.createIcon(this._icon), | |
addIcon = false; | |
// if we're not reusing the icon, remove the old one and init new one | |
if (icon !== this._icon) { | |
if (this._icon) { | |
this._removeIcon(); | |
} | |
addIcon = true; | |
if (options.title) { | |
icon.title = options.title; | |
} | |
if (options.alt) { | |
icon.alt = options.alt; | |
} | |
} | |
L.DomUtil.addClass(icon, classToAdd); | |
if (options.keyboard) { | |
icon.tabIndex = '0'; | |
} | |
this._icon = icon; | |
this._initInteraction(); | |
if (options.riseOnHover) { | |
L.DomEvent | |
.on(icon, 'mouseover', this._bringToFront, this) | |
.on(icon, 'mouseout', this._resetZIndex, this); | |
} | |
var newShadow = options.icon.createShadow(this._shadow), | |
addShadow = false; | |
if (newShadow !== this._shadow) { | |
this._removeShadow(); | |
addShadow = true; | |
} | |
if (newShadow) { | |
L.DomUtil.addClass(newShadow, classToAdd); | |
} | |
this._shadow = newShadow; | |
if (options.opacity < 1) { | |
this._updateOpacity(); | |
} | |
var panes = this._map._panes; | |
if (addIcon) { | |
panes.markerPane.appendChild(this._icon); | |
} | |
if (newShadow && addShadow) { | |
panes.shadowPane.appendChild(this._shadow); | |
} | |
}, | |
_removeIcon: function () { | |
if (this.options.riseOnHover) { | |
L.DomEvent | |
.off(this._icon, 'mouseover', this._bringToFront) | |
.off(this._icon, 'mouseout', this._resetZIndex); | |
} | |
this._map._panes.markerPane.removeChild(this._icon); | |
this._icon = null; | |
}, | |
_removeShadow: function () { | |
if (this._shadow) { | |
this._map._panes.shadowPane.removeChild(this._shadow); | |
} | |
this._shadow = null; | |
}, | |
_setPos: function (pos) { | |
L.DomUtil.setPosition(this._icon, pos); | |
if (this._shadow) { | |
L.DomUtil.setPosition(this._shadow, pos); | |
} | |
this._zIndex = pos.y + this.options.zIndexOffset; | |
this._resetZIndex(); | |
}, | |
_updateZIndex: function (offset) { | |
this._icon.style.zIndex = this._zIndex + offset; | |
}, | |
_animateZoom: function (opt) { | |
var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center).round(); | |
this._setPos(pos); | |
}, | |
_initInteraction: function () { | |
if (!this.options.clickable) { return; } | |
// TODO refactor into something shared with Map/Path/etc. to DRY it up | |
var icon = this._icon, | |
events = ['dblclick', 'mousedown', 'mouseover', 'mouseout', 'contextmenu']; | |
L.DomUtil.addClass(icon, 'leaflet-clickable'); | |
L.DomEvent.on(icon, 'click', this._onMouseClick, this); | |
L.DomEvent.on(icon, 'keypress', this._onKeyPress, this); | |
for (var i = 0; i < events.length; i++) { | |
L.DomEvent.on(icon, events[i], this._fireMouseEvent, this); | |
} | |
if (L.Handler.MarkerDrag) { | |
this.dragging = new L.Handler.MarkerDrag(this); | |
if (this.options.draggable) { | |
this.dragging.enable(); | |
} | |
} | |
}, | |
_onMouseClick: function (e) { | |
var wasDragged = this.dragging && this.dragging.moved(); | |
if (this.hasEventListeners(e.type) || wasDragged) { | |
L.DomEvent.stopPropagation(e); | |
} | |
if (wasDragged) { return; } | |
if ((!this.dragging || !this.dragging._enabled) && this._map.dragging && this._map.dragging.moved()) { return; } | |
this.fire(e.type, { | |
originalEvent: e, | |
latlng: this._latlng | |
}); | |
}, | |
_onKeyPress: function (e) { | |
if (e.keyCode === 13) { | |
this.fire('click', { | |
originalEvent: e, | |
latlng: this._latlng | |
}); | |
} | |
}, | |
_fireMouseEvent: function (e) { | |
this.fire(e.type, { | |
originalEvent: e, | |
latlng: this._latlng | |
}); | |
// TODO proper custom event propagation | |
// this line will always be called if marker is in a FeatureGroup | |
if (e.type === 'contextmenu' && this.hasEventListeners(e.type)) { | |
L.DomEvent.preventDefault(e); | |
} | |
if (e.type !== 'mousedown') { | |
L.DomEvent.stopPropagation(e); | |
} else { | |
L.DomEvent.preventDefault(e); | |
} | |
}, | |
setOpacity: function (opacity) { | |
this.options.opacity = opacity; | |
if (this._map) { | |
this._updateOpacity(); | |
} | |
return this; | |
}, | |
_updateOpacity: function () { | |
L.DomUtil.setOpacity(this._icon, this.options.opacity); | |
if (this._shadow) { | |
L.DomUtil.setOpacity(this._shadow, this.options.opacity); | |
} | |
}, | |
_bringToFront: function () { | |
this._updateZIndex(this.options.riseOffset); | |
}, | |
_resetZIndex: function () { | |
this._updateZIndex(0); | |
} | |
}); | |
L.marker = function (latlng, options) { | |
return new L.Marker(latlng, options); | |
}; | |
/* | |
* L.DivIcon is a lightweight HTML-based icon class (as opposed to the image-based L.Icon) | |
* to use with L.Marker. | |
*/ | |
L.DivIcon = L.Icon.extend({ | |
options: { | |
iconSize: [12, 12], // also can be set through CSS | |
/* | |
iconAnchor: (Point) | |
popupAnchor: (Point) | |
html: (String) | |
bgPos: (Point) | |
*/ | |
className: 'leaflet-div-icon', | |
html: false | |
}, | |
createIcon: function (oldIcon) { | |
var div = (oldIcon && oldIcon.tagName === 'DIV') ? oldIcon : document.createElement('div'), | |
options = this.options; | |
if (options.html !== false) { | |
div.innerHTML = options.html; | |
} else { | |
div.innerHTML = ''; | |
} | |
if (options.bgPos) { | |
div.style.backgroundPosition = | |
(-options.bgPos.x) + 'px ' + (-options.bgPos.y) + 'px'; | |
} | |
this._setIconStyles(div, 'icon'); | |
return div; | |
}, | |
createShadow: function () { | |
return null; | |
} | |
}); | |
L.divIcon = function (options) { | |
return new L.DivIcon(options); | |
}; | |
/* | |
* L.Popup is used for displaying popups on the map. | |
*/ | |
L.Map.mergeOptions({ | |
closePopupOnClick: true | |
}); | |
L.Popup = L.Class.extend({ | |
includes: L.Mixin.Events, | |
options: { | |
minWidth: 50, | |
maxWidth: 300, | |
// maxHeight: null, | |
autoPan: true, | |
closeButton: true, | |
offset: [0, 7], | |
autoPanPadding: [5, 5], | |
// autoPanPaddingTopLeft: null, | |
// autoPanPaddingBottomRight: null, | |
keepInView: false, | |
className: '', | |
zoomAnimation: true | |
}, | |
initialize: function (options, source) { | |
L.setOptions(this, options); | |
this._source = source; | |
this._animated = L.Browser.any3d && this.options.zoomAnimation; | |
this._isOpen = false; | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
if (!this._container) { | |
this._initLayout(); | |
} | |
var animFade = map.options.fadeAnimation; | |
if (animFade) { | |
L.DomUtil.setOpacity(this._container, 0); | |
} | |
map._panes.popupPane.appendChild(this._container); | |
map.on(this._getEvents(), this); | |
this.update(); | |
if (animFade) { | |
L.DomUtil.setOpacity(this._container, 1); | |
} | |
this.fire('open'); | |
map.fire('popupopen', {popup: this}); | |
if (this._source) { | |
this._source.fire('popupopen', {popup: this}); | |
} | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
openOn: function (map) { | |
map.openPopup(this); | |
return this; | |
}, | |
onRemove: function (map) { | |
map._panes.popupPane.removeChild(this._container); | |
L.Util.falseFn(this._container.offsetWidth); // force reflow | |
map.off(this._getEvents(), this); | |
if (map.options.fadeAnimation) { | |
L.DomUtil.setOpacity(this._container, 0); | |
} | |
this._map = null; | |
this.fire('close'); | |
map.fire('popupclose', {popup: this}); | |
if (this._source) { | |
this._source.fire('popupclose', {popup: this}); | |
} | |
}, | |
getLatLng: function () { | |
return this._latlng; | |
}, | |
setLatLng: function (latlng) { | |
this._latlng = L.latLng(latlng); | |
if (this._map) { | |
this._updatePosition(); | |
this._adjustPan(); | |
} | |
return this; | |
}, | |
getContent: function () { | |
return this._content; | |
}, | |
setContent: function (content) { | |
this._content = content; | |
this.update(); | |
return this; | |
}, | |
update: function () { | |
if (!this._map) { return; } | |
this._container.style.visibility = 'hidden'; | |
this._updateContent(); | |
this._updateLayout(); | |
this._updatePosition(); | |
this._container.style.visibility = ''; | |
this._adjustPan(); | |
}, | |
_getEvents: function () { | |
var events = { | |
viewreset: this._updatePosition | |
}; | |
if (this._animated) { | |
events.zoomanim = this._zoomAnimation; | |
} | |
if ('closeOnClick' in this.options ? this.options.closeOnClick : this._map.options.closePopupOnClick) { | |
events.preclick = this._close; | |
} | |
if (this.options.keepInView) { | |
events.moveend = this._adjustPan; | |
} | |
return events; | |
}, | |
_close: function () { | |
if (this._map) { | |
this._map.closePopup(this); | |
} | |
}, | |
_initLayout: function () { | |
var prefix = 'leaflet-popup', | |
containerClass = prefix + ' ' + this.options.className + ' leaflet-zoom-' + | |
(this._animated ? 'animated' : 'hide'), | |
container = this._container = L.DomUtil.create('div', containerClass), | |
closeButton; | |
if (this.options.closeButton) { | |
closeButton = this._closeButton = | |
L.DomUtil.create('a', prefix + '-close-button', container); | |
closeButton.href = '#close'; | |
closeButton.innerHTML = '×'; | |
L.DomEvent.disableClickPropagation(closeButton); | |
L.DomEvent.on(closeButton, 'click', this._onCloseButtonClick, this); | |
} | |
var wrapper = this._wrapper = | |
L.DomUtil.create('div', prefix + '-content-wrapper', container); | |
L.DomEvent.disableClickPropagation(wrapper); | |
this._contentNode = L.DomUtil.create('div', prefix + '-content', wrapper); | |
L.DomEvent.disableScrollPropagation(this._contentNode); | |
L.DomEvent.on(wrapper, 'contextmenu', L.DomEvent.stopPropagation); | |
this._tipContainer = L.DomUtil.create('div', prefix + '-tip-container', container); | |
this._tip = L.DomUtil.create('div', prefix + '-tip', this._tipContainer); | |
}, | |
_updateContent: function () { | |
if (!this._content) { return; } | |
if (typeof this._content === 'string') { | |
this._contentNode.innerHTML = this._content; | |
} else { | |
while (this._contentNode.hasChildNodes()) { | |
this._contentNode.removeChild(this._contentNode.firstChild); | |
} | |
this._contentNode.appendChild(this._content); | |
} | |
this.fire('contentupdate'); | |
}, | |
_updateLayout: function () { | |
var container = this._contentNode, | |
style = container.style; | |
style.width = ''; | |
style.whiteSpace = 'nowrap'; | |
var width = container.offsetWidth; | |
width = Math.min(width, this.options.maxWidth); | |
width = Math.max(width, this.options.minWidth); | |
style.width = (width + 1) + 'px'; | |
style.whiteSpace = ''; | |
style.height = ''; | |
var height = container.offsetHeight, | |
maxHeight = this.options.maxHeight, | |
scrolledClass = 'leaflet-popup-scrolled'; | |
if (maxHeight && height > maxHeight) { | |
style.height = maxHeight + 'px'; | |
L.DomUtil.addClass(container, scrolledClass); | |
} else { | |
L.DomUtil.removeClass(container, scrolledClass); | |
} | |
this._containerWidth = this._container.offsetWidth; | |
}, | |
_updatePosition: function () { | |
if (!this._map) { return; } | |
var pos = this._map.latLngToLayerPoint(this._latlng), | |
animated = this._animated, | |
offset = L.point(this.options.offset); | |
if (animated) { | |
L.DomUtil.setPosition(this._container, pos); | |
} | |
this._containerBottom = -offset.y - (animated ? 0 : pos.y); | |
this._containerLeft = -Math.round(this._containerWidth / 2) + offset.x + (animated ? 0 : pos.x); | |
// bottom position the popup in case the height of the popup changes (images loading etc) | |
this._container.style.bottom = this._containerBottom + 'px'; | |
this._container.style.left = this._containerLeft + 'px'; | |
}, | |
_zoomAnimation: function (opt) { | |
var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center); | |
L.DomUtil.setPosition(this._container, pos); | |
}, | |
_adjustPan: function () { | |
if (!this.options.autoPan) { return; } | |
var map = this._map, | |
containerHeight = this._container.offsetHeight, | |
containerWidth = this._containerWidth, | |
layerPos = new L.Point(this._containerLeft, -containerHeight - this._containerBottom); | |
if (this._animated) { | |
layerPos._add(L.DomUtil.getPosition(this._container)); | |
} | |
var containerPos = map.layerPointToContainerPoint(layerPos), | |
padding = L.point(this.options.autoPanPadding), | |
paddingTL = L.point(this.options.autoPanPaddingTopLeft || padding), | |
paddingBR = L.point(this.options.autoPanPaddingBottomRight || padding), | |
size = map.getSize(), | |
dx = 0, | |
dy = 0; | |
if (containerPos.x + containerWidth + paddingBR.x > size.x) { // right | |
dx = containerPos.x + containerWidth - size.x + paddingBR.x; | |
} | |
if (containerPos.x - dx - paddingTL.x < 0) { // left | |
dx = containerPos.x - paddingTL.x; | |
} | |
if (containerPos.y + containerHeight + paddingBR.y > size.y) { // bottom | |
dy = containerPos.y + containerHeight - size.y + paddingBR.y; | |
} | |
if (containerPos.y - dy - paddingTL.y < 0) { // top | |
dy = containerPos.y - paddingTL.y; | |
} | |
if (dx || dy) { | |
map | |
.fire('autopanstart') | |
.panBy([dx, dy]); | |
} | |
}, | |
_onCloseButtonClick: function (e) { | |
this._close(); | |
L.DomEvent.stop(e); | |
} | |
}); | |
L.popup = function (options, source) { | |
return new L.Popup(options, source); | |
}; | |
L.Map.include({ | |
openPopup: function (popup, latlng, options) { // (Popup) or (String || HTMLElement, LatLng[, Object]) | |
this.closePopup(); | |
if (!(popup instanceof L.Popup)) { | |
var content = popup; | |
popup = new L.Popup(options) | |
.setLatLng(latlng) | |
.setContent(content); | |
} | |
popup._isOpen = true; | |
this._popup = popup; | |
return this.addLayer(popup); | |
}, | |
closePopup: function (popup) { | |
if (!popup || popup === this._popup) { | |
popup = this._popup; | |
this._popup = null; | |
} | |
if (popup) { | |
this.removeLayer(popup); | |
popup._isOpen = false; | |
} | |
return this; | |
} | |
}); | |
/* | |
* Popup extension to L.Marker, adding popup-related methods. | |
*/ | |
L.Marker.include({ | |
openPopup: function () { | |
if (this._popup && this._map && !this._map.hasLayer(this._popup)) { | |
this._popup.setLatLng(this._latlng); | |
this._map.openPopup(this._popup); | |
} | |
return this; | |
}, | |
closePopup: function () { | |
if (this._popup) { | |
this._popup._close(); | |
} | |
return this; | |
}, | |
togglePopup: function () { | |
if (this._popup) { | |
if (this._popup._isOpen) { | |
this.closePopup(); | |
} else { | |
this.openPopup(); | |
} | |
} | |
return this; | |
}, | |
bindPopup: function (content, options) { | |
var anchor = L.point(this.options.icon.options.popupAnchor || [0, 0]); | |
anchor = anchor.add(L.Popup.prototype.options.offset); | |
if (options && options.offset) { | |
anchor = anchor.add(options.offset); | |
} | |
options = L.extend({offset: anchor}, options); | |
if (!this._popupHandlersAdded) { | |
this | |
.on('click', this.togglePopup, this) | |
.on('remove', this.closePopup, this) | |
.on('move', this._movePopup, this); | |
this._popupHandlersAdded = true; | |
} | |
if (content instanceof L.Popup) { | |
L.setOptions(content, options); | |
this._popup = content; | |
content._source = this; | |
} else { | |
this._popup = new L.Popup(options, this) | |
.setContent(content); | |
} | |
return this; | |
}, | |
setPopupContent: function (content) { | |
if (this._popup) { | |
this._popup.setContent(content); | |
} | |
return this; | |
}, | |
unbindPopup: function () { | |
if (this._popup) { | |
this._popup = null; | |
this | |
.off('click', this.togglePopup, this) | |
.off('remove', this.closePopup, this) | |
.off('move', this._movePopup, this); | |
this._popupHandlersAdded = false; | |
} | |
return this; | |
}, | |
getPopup: function () { | |
return this._popup; | |
}, | |
_movePopup: function (e) { | |
this._popup.setLatLng(e.latlng); | |
} | |
}); | |
/* | |
* L.LayerGroup is a class to combine several layers into one so that | |
* you can manipulate the group (e.g. add/remove it) as one layer. | |
*/ | |
L.LayerGroup = L.Class.extend({ | |
initialize: function (layers) { | |
this._layers = {}; | |
var i, len; | |
if (layers) { | |
for (i = 0, len = layers.length; i < len; i++) { | |
this.addLayer(layers[i]); | |
} | |
} | |
}, | |
addLayer: function (layer) { | |
var id = this.getLayerId(layer); | |
this._layers[id] = layer; | |
if (this._map) { | |
this._map.addLayer(layer); | |
} | |
return this; | |
}, | |
removeLayer: function (layer) { | |
var id = layer in this._layers ? layer : this.getLayerId(layer); | |
if (this._map && this._layers[id]) { | |
this._map.removeLayer(this._layers[id]); | |
} | |
delete this._layers[id]; | |
return this; | |
}, | |
hasLayer: function (layer) { | |
if (!layer) { return false; } | |
return (layer in this._layers || this.getLayerId(layer) in this._layers); | |
}, | |
clearLayers: function () { | |
this.eachLayer(this.removeLayer, this); | |
return this; | |
}, | |
invoke: function (methodName) { | |
var args = Array.prototype.slice.call(arguments, 1), | |
i, layer; | |
for (i in this._layers) { | |
layer = this._layers[i]; | |
if (layer[methodName]) { | |
layer[methodName].apply(layer, args); | |
} | |
} | |
return this; | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
this.eachLayer(map.addLayer, map); | |
}, | |
onRemove: function (map) { | |
this.eachLayer(map.removeLayer, map); | |
this._map = null; | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
eachLayer: function (method, context) { | |
for (var i in this._layers) { | |
method.call(context, this._layers[i]); | |
} | |
return this; | |
}, | |
getLayer: function (id) { | |
return this._layers[id]; | |
}, | |
getLayers: function () { | |
var layers = []; | |
for (var i in this._layers) { | |
layers.push(this._layers[i]); | |
} | |
return layers; | |
}, | |
setZIndex: function (zIndex) { | |
return this.invoke('setZIndex', zIndex); | |
}, | |
getLayerId: function (layer) { | |
return L.stamp(layer); | |
} | |
}); | |
L.layerGroup = function (layers) { | |
return new L.LayerGroup(layers); | |
}; | |
/* | |
* L.FeatureGroup extends L.LayerGroup by introducing mouse events and additional methods | |
* shared between a group of interactive layers (like vectors or markers). | |
*/ | |
L.FeatureGroup = L.LayerGroup.extend({ | |
includes: L.Mixin.Events, | |
statics: { | |
EVENTS: 'click dblclick mouseover mouseout mousemove contextmenu popupopen popupclose' | |
}, | |
addLayer: function (layer) { | |
if (this.hasLayer(layer)) { | |
return this; | |
} | |
if ('on' in layer) { | |
layer.on(L.FeatureGroup.EVENTS, this._propagateEvent, this); | |
} | |
L.LayerGroup.prototype.addLayer.call(this, layer); | |
if (this._popupContent && layer.bindPopup) { | |
layer.bindPopup(this._popupContent, this._popupOptions); | |
} | |
return this.fire('layeradd', {layer: layer}); | |
}, | |
removeLayer: function (layer) { | |
if (!this.hasLayer(layer)) { | |
return this; | |
} | |
if (layer in this._layers) { | |
layer = this._layers[layer]; | |
} | |
if ('off' in layer) { | |
layer.off(L.FeatureGroup.EVENTS, this._propagateEvent, this); | |
} | |
L.LayerGroup.prototype.removeLayer.call(this, layer); | |
if (this._popupContent) { | |
this.invoke('unbindPopup'); | |
} | |
return this.fire('layerremove', {layer: layer}); | |
}, | |
bindPopup: function (content, options) { | |
this._popupContent = content; | |
this._popupOptions = options; | |
return this.invoke('bindPopup', content, options); | |
}, | |
openPopup: function (latlng) { | |
// open popup on the first layer | |
for (var id in this._layers) { | |
this._layers[id].openPopup(latlng); | |
break; | |
} | |
return this; | |
}, | |
setStyle: function (style) { | |
return this.invoke('setStyle', style); | |
}, | |
bringToFront: function () { | |
return this.invoke('bringToFront'); | |
}, | |
bringToBack: function () { | |
return this.invoke('bringToBack'); | |
}, | |
getBounds: function () { | |
var bounds = new L.LatLngBounds(); | |
this.eachLayer(function (layer) { | |
bounds.extend(layer instanceof L.Marker ? layer.getLatLng() : layer.getBounds()); | |
}); | |
return bounds; | |
}, | |
_propagateEvent: function (e) { | |
e = L.extend({ | |
layer: e.target, | |
target: this | |
}, e); | |
this.fire(e.type, e); | |
} | |
}); | |
L.featureGroup = function (layers) { | |
return new L.FeatureGroup(layers); | |
}; | |
/* | |
* L.Path is a base class for rendering vector paths on a map. Inherited by Polyline, Circle, etc. | |
*/ | |
L.Path = L.Class.extend({ | |
includes: [L.Mixin.Events], | |
statics: { | |
// how much to extend the clip area around the map view | |
// (relative to its size, e.g. 0.5 is half the screen in each direction) | |
// set it so that SVG element doesn't exceed 1280px (vectors flicker on dragend if it is) | |
CLIP_PADDING: (function () { | |
var max = L.Browser.mobile ? 1280 : 2000, | |
target = (max / Math.max(window.outerWidth, window.outerHeight) - 1) / 2; | |
return Math.max(0, Math.min(0.5, target)); | |
})() | |
}, | |
options: { | |
stroke: true, | |
color: '#0033ff', | |
dashArray: null, | |
lineCap: null, | |
lineJoin: null, | |
weight: 5, | |
opacity: 0.5, | |
fill: false, | |
fillColor: null, //same as color by default | |
fillOpacity: 0.2, | |
clickable: true | |
}, | |
initialize: function (options) { | |
L.setOptions(this, options); | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
if (!this._container) { | |
this._initElements(); | |
this._initEvents(); | |
} | |
this.projectLatlngs(); | |
this._updatePath(); | |
if (this._container) { | |
this._map._pathRoot.appendChild(this._container); | |
} | |
this.fire('add'); | |
map.on({ | |
'viewreset': this.projectLatlngs, | |
'moveend': this._updatePath | |
}, this); | |
}, | |
addTo: function (map) { | |
map.addLayer(this); | |
return this; | |
}, | |
onRemove: function (map) { | |
map._pathRoot.removeChild(this._container); | |
// Need to fire remove event before we set _map to null as the event hooks might need the object | |
this.fire('remove'); | |
this._map = null; | |
if (L.Browser.vml) { | |
this._container = null; | |
this._stroke = null; | |
this._fill = null; | |
} | |
map.off({ | |
'viewreset': this.projectLatlngs, | |
'moveend': this._updatePath | |
}, this); | |
}, | |
projectLatlngs: function () { | |
// do all projection stuff here | |
}, | |
setStyle: function (style) { | |
L.setOptions(this, style); | |
if (this._container) { | |
this._updateStyle(); | |
} | |
return this; | |
}, | |
redraw: function () { | |
if (this._map) { | |
this.projectLatlngs(); | |
this._updatePath(); | |
} | |
return this; | |
} | |
}); | |
L.Map.include({ | |
_updatePathViewport: function () { | |
var p = L.Path.CLIP_PADDING, | |
size = this.getSize(), | |
panePos = L.DomUtil.getPosition(this._mapPane), | |
min = panePos.multiplyBy(-1)._subtract(size.multiplyBy(p)._round()), | |
max = min.add(size.multiplyBy(1 + p * 2)._round()); | |
this._pathViewport = new L.Bounds(min, max); | |
} | |
}); | |
/* | |
* Extends L.Path with SVG-specific rendering code. | |
*/ | |
L.Path.SVG_NS = 'http://www.w3.org/2000/svg'; | |
L.Browser.svg = !!(document.createElementNS && document.createElementNS(L.Path.SVG_NS, 'svg').createSVGRect); | |
L.Path = L.Path.extend({ | |
statics: { | |
SVG: L.Browser.svg | |
}, | |
bringToFront: function () { | |
var root = this._map._pathRoot, | |
path = this._container; | |
if (path && root.lastChild !== path) { | |
root.appendChild(path); | |
} | |
return this; | |
}, | |
bringToBack: function () { | |
var root = this._map._pathRoot, | |
path = this._container, | |
first = root.firstChild; | |
if (path && first !== path) { | |
root.insertBefore(path, first); | |
} | |
return this; | |
}, | |
getPathString: function () { | |
// form path string here | |
}, | |
_createElement: function (name) { | |
return document.createElementNS(L.Path.SVG_NS, name); | |
}, | |
_initElements: function () { | |
this._map._initPathRoot(); | |
this._initPath(); | |
this._initStyle(); | |
}, | |
_initPath: function () { | |
this._container = this._createElement('g'); | |
this._path = this._createElement('path'); | |
if (this.options.className) { | |
L.DomUtil.addClass(this._path, this.options.className); | |
} | |
this._container.appendChild(this._path); | |
}, | |
_initStyle: function () { | |
if (this.options.stroke) { | |
this._path.setAttribute('stroke-linejoin', 'round'); | |
this._path.setAttribute('stroke-linecap', 'round'); | |
} | |
if (this.options.fill) { | |
this._path.setAttribute('fill-rule', 'evenodd'); | |
} | |
if (this.options.pointerEvents) { | |
this._path.setAttribute('pointer-events', this.options.pointerEvents); | |
} | |
if (!this.options.clickable && !this.options.pointerEvents) { | |
this._path.setAttribute('pointer-events', 'none'); | |
} | |
this._updateStyle(); | |
}, | |
_updateStyle: function () { | |
if (this.options.stroke) { | |
this._path.setAttribute('stroke', this.options.color); | |
this._path.setAttribute('stroke-opacity', this.options.opacity); | |
this._path.setAttribute('stroke-width', this.options.weight); | |
if (this.options.dashArray) { | |
this._path.setAttribute('stroke-dasharray', this.options.dashArray); | |
} else { | |
this._path.removeAttribute('stroke-dasharray'); | |
} | |
if (this.options.lineCap) { | |
this._path.setAttribute('stroke-linecap', this.options.lineCap); | |
} | |
if (this.options.lineJoin) { | |
this._path.setAttribute('stroke-linejoin', this.options.lineJoin); | |
} | |
} else { | |
this._path.setAttribute('stroke', 'none'); | |
} | |
if (this.options.fill) { | |
this._path.setAttribute('fill', this.options.fillColor || this.options.color); | |
this._path.setAttribute('fill-opacity', this.options.fillOpacity); | |
} else { | |
this._path.setAttribute('fill', 'none'); | |
} | |
}, | |
_updatePath: function () { | |
var str = this.getPathString(); | |
if (!str) { | |
// fix webkit empty string parsing bug | |
str = 'M0 0'; | |
} | |
this._path.setAttribute('d', str); | |
}, | |
// TODO remove duplication with L.Map | |
_initEvents: function () { | |
if (this.options.clickable) { | |
if (L.Browser.svg || !L.Browser.vml) { | |
L.DomUtil.addClass(this._path, 'leaflet-clickable'); | |
} | |
L.DomEvent.on(this._container, 'click', this._onMouseClick, this); | |
var events = ['dblclick', 'mousedown', 'mouseover', | |
'mouseout', 'mousemove', 'contextmenu']; | |
for (var i = 0; i < events.length; i++) { | |
L.DomEvent.on(this._container, events[i], this._fireMouseEvent, this); | |
} | |
} | |
}, | |
_onMouseClick: function (e) { | |
if (this._map.dragging && this._map.dragging.moved()) { return; } | |
this._fireMouseEvent(e); | |
}, | |
_fireMouseEvent: function (e) { | |
if (!this._map || !this.hasEventListeners(e.type)) { return; } | |
var map = this._map, | |
containerPoint = map.mouseEventToContainerPoint(e), | |
layerPoint = map.containerPointToLayerPoint(containerPoint), | |
latlng = map.layerPointToLatLng(layerPoint); | |
this.fire(e.type, { | |
latlng: latlng, | |
layerPoint: layerPoint, | |
containerPoint: containerPoint, | |
originalEvent: e | |
}); | |
if (e.type === 'contextmenu') { | |
L.DomEvent.preventDefault(e); | |
} | |
if (e.type !== 'mousemove') { | |
L.DomEvent.stopPropagation(e); | |
} | |
} | |
}); | |
L.Map.include({ | |
_initPathRoot: function () { | |
if (!this._pathRoot) { | |
this._pathRoot = L.Path.prototype._createElement('svg'); | |
this._panes.overlayPane.appendChild(this._pathRoot); | |
if (this.options.zoomAnimation && L.Browser.any3d) { | |
L.DomUtil.addClass(this._pathRoot, 'leaflet-zoom-animated'); | |
this.on({ | |
'zoomanim': this._animatePathZoom, | |
'zoomend': this._endPathZoom | |
}); | |
} else { | |
L.DomUtil.addClass(this._pathRoot, 'leaflet-zoom-hide'); | |
} | |
this.on('moveend', this._updateSvgViewport); | |
this._updateSvgViewport(); | |
} | |
}, | |
_animatePathZoom: function (e) { | |
var scale = this.getZoomScale(e.zoom), | |
offset = this._getCenterOffset(e.center)._multiplyBy(-scale)._add(this._pathViewport.min); | |
this._pathRoot.style[L.DomUtil.TRANSFORM] = | |
L.DomUtil.getTranslateString(offset) + ' scale(' + scale + ') '; | |
this._pathZooming = true; | |
}, | |
_endPathZoom: function () { | |
this._pathZooming = false; | |
}, | |
_updateSvgViewport: function () { | |
if (this._pathZooming) { | |
// Do not update SVGs while a zoom animation is going on otherwise the animation will break. | |
// When the zoom animation ends we will be updated again anyway | |
// This fixes the case where you do a momentum move and zoom while the move is still ongoing. | |
return; | |
} | |
this._updatePathViewport(); | |
var vp = this._pathViewport, | |
min = vp.min, | |
max = vp.max, | |
width = max.x - min.x, | |
height = max.y - min.y, | |
root = this._pathRoot, | |
pane = this._panes.overlayPane; | |
// Hack to make flicker on drag end on mobile webkit less irritating | |
if (L.Browser.mobileWebkit) { | |
pane.removeChild(root); | |
} | |
L.DomUtil.setPosition(root, min); | |
root.setAttribute('width', width); | |
root.setAttribute('height', height); | |
root.setAttribute('viewBox', [min.x, min.y, width, height].join(' ')); | |
if (L.Browser.mobileWebkit) { | |
pane.appendChild(root); | |
} | |
} | |
}); | |
/* | |
* Popup extension to L.Path (polylines, polygons, circles), adding popup-related methods. | |
*/ | |
L.Path.include({ | |
bindPopup: function (content, options) { | |
if (content instanceof L.Popup) { | |
this._popup = content; | |
} else { | |
if (!this._popup || options) { | |
this._popup = new L.Popup(options, this); | |
} | |
this._popup.setContent(content); | |
} | |
if (!this._popupHandlersAdded) { | |
this | |
.on('click', this._openPopup, this) | |
.on('remove', this.closePopup, this); | |
this._popupHandlersAdded = true; | |
} | |
return this; | |
}, | |
unbindPopup: function () { | |
if (this._popup) { | |
this._popup = null; | |
this | |
.off('click', this._openPopup) | |
.off('remove', this.closePopup); | |
this._popupHandlersAdded = false; | |
} | |
return this; | |
}, | |
openPopup: function (latlng) { | |
if (this._popup) { | |
// open the popup from one of the path's points if not specified | |
latlng = latlng || this._latlng || | |
this._latlngs[Math.floor(this._latlngs.length / 2)]; | |
this._openPopup({latlng: latlng}); | |
} | |
return this; | |
}, | |
closePopup: function () { | |
if (this._popup) { | |
this._popup._close(); | |
} | |
return this; | |
}, | |
_openPopup: function (e) { | |
this._popup.setLatLng(e.latlng); | |
this._map.openPopup(this._popup); | |
} | |
}); | |
/* | |
* Vector rendering for IE6-8 through VML. | |
* Thanks to Dmitry Baranovsky and his Raphael library for inspiration! | |
*/ | |
L.Browser.vml = !L.Browser.svg && (function () { | |
try { | |
var div = document.createElement('div'); | |
div.innerHTML = '<v:shape adj="1"/>'; | |
var shape = div.firstChild; | |
shape.style.behavior = 'url(#default#VML)'; | |
return shape && (typeof shape.adj === 'object'); | |
} catch (e) { | |
return false; | |
} | |
}()); | |
L.Path = L.Browser.svg || !L.Browser.vml ? L.Path : L.Path.extend({ | |
statics: { | |
VML: true, | |
CLIP_PADDING: 0.02 | |
}, | |
_createElement: (function () { | |
try { | |
document.namespaces.add('lvml', 'urn:schemas-microsoft-com:vml'); | |
return function (name) { | |
return document.createElement('<lvml:' + name + ' class="lvml">'); | |
}; | |
} catch (e) { | |
return function (name) { | |
return document.createElement( | |
'<' + name + ' xmlns="urn:schemas-microsoft.com:vml" class="lvml">'); | |
}; | |
} | |
}()), | |
_initPath: function () { | |
var container = this._container = this._createElement('shape'); | |
L.DomUtil.addClass(container, 'leaflet-vml-shape' + | |
(this.options.className ? ' ' + this.options.className : '')); | |
if (this.options.clickable) { | |
L.DomUtil.addClass(container, 'leaflet-clickable'); | |
} | |
container.coordsize = '1 1'; | |
this._path = this._createElement('path'); | |
container.appendChild(this._path); | |
this._map._pathRoot.appendChild(container); | |
}, | |
_initStyle: function () { | |
this._updateStyle(); | |
}, | |
_updateStyle: function () { | |
var stroke = this._stroke, | |
fill = this._fill, | |
options = this.options, | |
container = this._container; | |
container.stroked = options.stroke; | |
container.filled = options.fill; | |
if (options.stroke) { | |
if (!stroke) { | |
stroke = this._stroke = this._createElement('stroke'); | |
stroke.endcap = 'round'; | |
container.appendChild(stroke); | |
} | |
stroke.weight = options.weight + 'px'; | |
stroke.color = options.color; | |
stroke.opacity = options.opacity; | |
if (options.dashArray) { | |
stroke.dashStyle = L.Util.isArray(options.dashArray) ? | |
options.dashArray.join(' ') : | |
options.dashArray.replace(/( *, *)/g, ' '); | |
} else { | |
stroke.dashStyle = ''; | |
} | |
if (options.lineCap) { | |
stroke.endcap = options.lineCap.replace('butt', 'flat'); | |
} | |
if (options.lineJoin) { | |
stroke.joinstyle = options.lineJoin; | |
} | |
} else if (stroke) { | |
container.removeChild(stroke); | |
this._stroke = null; | |
} | |
if (options.fill) { | |
if (!fill) { | |
fill = this._fill = this._createElement('fill'); | |
container.appendChild(fill); | |
} | |
fill.color = options.fillColor || options.color; | |
fill.opacity = options.fillOpacity; | |
} else if (fill) { | |
container.removeChild(fill); | |
this._fill = null; | |
} | |
}, | |
_updatePath: function () { | |
var style = this._container.style; | |
style.display = 'none'; | |
this._path.v = this.getPathString() + ' '; // the space fixes IE empty path string bug | |
style.display = ''; | |
} | |
}); | |
L.Map.include(L.Browser.svg || !L.Browser.vml ? {} : { | |
_initPathRoot: function () { | |
if (this._pathRoot) { return; } | |
var root = this._pathRoot = document.createElement('div'); | |
root.className = 'leaflet-vml-container'; | |
this._panes.overlayPane.appendChild(root); | |
this.on('moveend', this._updatePathViewport); | |
this._updatePathViewport(); | |
} | |
}); | |
/* | |
* Vector rendering for all browsers that support canvas. | |
*/ | |
L.Browser.canvas = (function () { | |
return !!document.createElement('canvas').getContext; | |
}()); | |
L.Path = (L.Path.SVG && !window.L_PREFER_CANVAS) || !L.Browser.canvas ? L.Path : L.Path.extend({ | |
statics: { | |
//CLIP_PADDING: 0.02, // not sure if there's a need to set it to a small value | |
CANVAS: true, | |
SVG: false | |
}, | |
redraw: function () { | |
if (this._map) { | |
this.projectLatlngs(); | |
this._requestUpdate(); | |
} | |
return this; | |
}, | |
setStyle: function (style) { | |
L.setOptions(this, style); | |
if (this._map) { | |
this._updateStyle(); | |
this._requestUpdate(); | |
} | |
return this; | |
}, | |
onRemove: function (map) { | |
map | |
.off('viewreset', this.projectLatlngs, this) | |
.off('moveend', this._updatePath, this); | |
if (this.options.clickable) { | |
this._map.off('click', this._onClick, this); | |
this._map.off('mousemove', this._onMouseMove, this); | |
} | |
this._requestUpdate(); | |
this.fire('remove'); | |
this._map = null; | |
}, | |
_requestUpdate: function () { | |
if (this._map && !L.Path._updateRequest) { | |
L.Path._updateRequest = L.Util.requestAnimFrame(this._fireMapMoveEnd, this._map); | |
} | |
}, | |
_fireMapMoveEnd: function () { | |
L.Path._updateRequest = null; | |
this.fire('moveend'); | |
}, | |
_initElements: function () { | |
this._map._initPathRoot(); | |
this._ctx = this._map._canvasCtx; | |
}, | |
_updateStyle: function () { | |
var options = this.options; | |
if (options.stroke) { | |
this._ctx.lineWidth = options.weight; | |
this._ctx.strokeStyle = options.color; | |
} | |
if (options.fill) { | |
this._ctx.fillStyle = options.fillColor || options.color; | |
} | |
if (options.lineCap) { | |
this._ctx.lineCap = options.lineCap; | |
} | |
if (options.lineJoin) { | |
this._ctx.lineJoin = options.lineJoin; | |
} | |
}, | |
_drawPath: function () { | |
var i, j, len, len2, point, drawMethod; | |
this._ctx.beginPath(); | |
for (i = 0, len = this._parts.length; i < len; i++) { | |
for (j = 0, len2 = this._parts[i].length; j < len2; j++) { | |
point = this._parts[i][j]; | |
drawMethod = (j === 0 ? 'move' : 'line') + 'To'; | |
this._ctx[drawMethod](point.x, point.y); | |
} | |
// TODO refactor ugly hack | |
if (this instanceof L.Polygon) { | |
this._ctx.closePath(); | |
} | |
} | |
}, | |
_checkIfEmpty: function () { | |
return !this._parts.length; | |
}, | |
_updatePath: function () { | |
if (this._checkIfEmpty()) { return; } | |
var ctx = this._ctx, | |
options = this.options; | |
this._drawPath(); | |
ctx.save(); | |
this._updateStyle(); | |
if (options.fill) { | |
ctx.globalAlpha = options.fillOpacity; | |
ctx.fill(options.fillRule || 'evenodd'); | |
} | |
if (options.stroke) { | |
ctx.globalAlpha = options.opacity; | |
ctx.stroke(); | |
} | |
ctx.restore(); | |
// TODO optimization: 1 fill/stroke for all features with equal style instead of 1 for each feature | |
}, | |
_initEvents: function () { | |
if (this.options.clickable) { | |
this._map.on('mousemove', this._onMouseMove, this); | |
this._map.on('click dblclick contextmenu', this._fireMouseEvent, this); | |
} | |
}, | |
_fireMouseEvent: function (e) { | |
if (this._containsPoint(e.layerPoint)) { | |
this.fire(e.type, e); | |
} | |
}, | |
_onMouseMove: function (e) { | |
if (!this._map || this._map._animatingZoom) { return; } | |
// TODO don't do on each move | |
if (this._containsPoint(e.layerPoint)) { | |
this._ctx.canvas.style.cursor = 'pointer'; | |
this._mouseInside = true; | |
this.fire('mouseover', e); | |
} else if (this._mouseInside) { | |
this._ctx.canvas.style.cursor = ''; | |
this._mouseInside = false; | |
this.fire('mouseout', e); | |
} | |
} | |
}); | |
L.Map.include((L.Path.SVG && !window.L_PREFER_CANVAS) || !L.Browser.canvas ? {} : { | |
_initPathRoot: function () { | |
var root = this._pathRoot, | |
ctx; | |
if (!root) { | |
root = this._pathRoot = document.createElement('canvas'); | |
root.style.position = 'absolute'; | |
ctx = this._canvasCtx = root.getContext('2d'); | |
ctx.lineCap = 'round'; | |
ctx.lineJoin = 'round'; | |
this._panes.overlayPane.appendChild(root); | |
if (this.options.zoomAnimation) { | |
this._pathRoot.className = 'leaflet-zoom-animated'; | |
this.on('zoomanim', this._animatePathZoom); | |
this.on('zoomend', this._endPathZoom); | |
} | |
this.on('moveend', this._updateCanvasViewport); | |
this._updateCanvasViewport(); | |
} | |
}, | |
_updateCanvasViewport: function () { | |
// don't redraw while zooming. See _updateSvgViewport for more details | |
if (this._pathZooming) { return; } | |
this._updatePathViewport(); | |
var vp = this._pathViewport, | |
min = vp.min, | |
size = vp.max.subtract(min), | |
root = this._pathRoot; | |
//TODO check if this works properly on mobile webkit | |
L.DomUtil.setPosition(root, min); | |
root.width = size.x; | |
root.height = size.y; | |
root.getContext('2d').translate(-min.x, -min.y); | |
} | |
}); | |
/* | |
* L.LineUtil contains different utility functions for line segments | |
* and polylines (clipping, simplification, distances, etc.) | |
*/ | |
/*jshint bitwise:false */ // allow bitwise operations for this file | |
L.LineUtil = { | |
// Simplify polyline with vertex reduction and Douglas-Peucker simplification. | |
// Improves rendering performance dramatically by lessening the number of points to draw. | |
simplify: function (/*Point[]*/ points, /*Number*/ tolerance) { | |
if (!tolerance || !points.length) { | |
return points.slice(); | |
} | |
var sqTolerance = tolerance * tolerance; | |
// stage 1: vertex reduction | |
points = this._reducePoints(points, sqTolerance); | |
// stage 2: Douglas-Peucker simplification | |
points = this._simplifyDP(points, sqTolerance); | |
return points; | |
}, | |
// distance from a point to a segment between two points | |
pointToSegmentDistance: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) { | |
return Math.sqrt(this._sqClosestPointOnSegment(p, p1, p2, true)); | |
}, | |
closestPointOnSegment: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) { | |
return this._sqClosestPointOnSegment(p, p1, p2); | |
}, | |
// Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm | |
_simplifyDP: function (points, sqTolerance) { | |
var len = points.length, | |
ArrayConstructor = typeof Uint8Array !== undefined + '' ? Uint8Array : Array, | |
markers = new ArrayConstructor(len); | |
markers[0] = markers[len - 1] = 1; | |
this._simplifyDPStep(points, markers, sqTolerance, 0, len - 1); | |
var i, | |
newPoints = []; | |
for (i = 0; i < len; i++) { | |
if (markers[i]) { | |
newPoints.push(points[i]); | |
} | |
} | |
return newPoints; | |
}, | |
_simplifyDPStep: function (points, markers, sqTolerance, first, last) { | |
var maxSqDist = 0, | |
index, i, sqDist; | |
for (i = first + 1; i <= last - 1; i++) { | |
sqDist = this._sqClosestPointOnSegment(points[i], points[first], points[last], true); | |
if (sqDist > maxSqDist) { | |
index = i; | |
maxSqDist = sqDist; | |
} | |
} | |
if (maxSqDist > sqTolerance) { | |
markers[index] = 1; | |
this._simplifyDPStep(points, markers, sqTolerance, first, index); | |
this._simplifyDPStep(points, markers, sqTolerance, index, last); | |
} | |
}, | |
// reduce points that are too close to each other to a single point | |
_reducePoints: function (points, sqTolerance) { | |
var reducedPoints = [points[0]]; | |
for (var i = 1, prev = 0, len = points.length; i < len; i++) { | |
if (this._sqDist(points[i], points[prev]) > sqTolerance) { | |
reducedPoints.push(points[i]); | |
prev = i; | |
} | |
} | |
if (prev < len - 1) { | |
reducedPoints.push(points[len - 1]); | |
} | |
return reducedPoints; | |
}, | |
// Cohen-Sutherland line clipping algorithm. | |
// Used to avoid rendering parts of a polyline that are not currently visible. | |
clipSegment: function (a, b, bounds, useLastCode) { | |
var codeA = useLastCode ? this._lastCode : this._getBitCode(a, bounds), | |
codeB = this._getBitCode(b, bounds), | |
codeOut, p, newCode; | |
// save 2nd code to avoid calculating it on the next segment | |
this._lastCode = codeB; | |
while (true) { | |
// if a,b is inside the clip window (trivial accept) | |
if (!(codeA | codeB)) { | |
return [a, b]; | |
// if a,b is outside the clip window (trivial reject) | |
} else if (codeA & codeB) { | |
return false; | |
// other cases | |
} else { | |
codeOut = codeA || codeB; | |
p = this._getEdgeIntersection(a, b, codeOut, bounds); | |
newCode = this._getBitCode(p, bounds); | |
if (codeOut === codeA) { | |
a = p; | |
codeA = newCode; | |
} else { | |
b = p; | |
codeB = newCode; | |
} | |
} | |
} | |
}, | |
_getEdgeIntersection: function (a, b, code, bounds) { | |
var dx = b.x - a.x, | |
dy = b.y - a.y, | |
min = bounds.min, | |
max = bounds.max; | |
if (code & 8) { // top | |
return new L.Point(a.x + dx * (max.y - a.y) / dy, max.y); | |
} else if (code & 4) { // bottom | |
return new L.Point(a.x + dx * (min.y - a.y) / dy, min.y); | |
} else if (code & 2) { // right | |
return new L.Point(max.x, a.y + dy * (max.x - a.x) / dx); | |
} else if (code & 1) { // left | |
return new L.Point(min.x, a.y + dy * (min.x - a.x) / dx); | |
} | |
}, | |
_getBitCode: function (/*Point*/ p, bounds) { | |
var code = 0; | |
if (p.x < bounds.min.x) { // left | |
code |= 1; | |
} else if (p.x > bounds.max.x) { // right | |
code |= 2; | |
} | |
if (p.y < bounds.min.y) { // bottom | |
code |= 4; | |
} else if (p.y > bounds.max.y) { // top | |
code |= 8; | |
} | |
return code; | |
}, | |
// square distance (to avoid unnecessary Math.sqrt calls) | |
_sqDist: function (p1, p2) { | |
var dx = p2.x - p1.x, | |
dy = p2.y - p1.y; | |
return dx * dx + dy * dy; | |
}, | |
// return closest point on segment or distance to that point | |
_sqClosestPointOnSegment: function (p, p1, p2, sqDist) { | |
var x = p1.x, | |
y = p1.y, | |
dx = p2.x - x, | |
dy = p2.y - y, | |
dot = dx * dx + dy * dy, | |
t; | |
if (dot > 0) { | |
t = ((p.x - x) * dx + (p.y - y) * dy) / dot; | |
if (t > 1) { | |
x = p2.x; | |
y = p2.y; | |
} else if (t > 0) { | |
x += dx * t; | |
y += dy * t; | |
} | |
} | |
dx = p.x - x; | |
dy = p.y - y; | |
return sqDist ? dx * dx + dy * dy : new L.Point(x, y); | |
} | |
}; | |
/* | |
* L.Polyline is used to display polylines on a map. | |
*/ | |
L.Polyline = L.Path.extend({ | |
initialize: function (latlngs, options) { | |
L.Path.prototype.initialize.call(this, options); | |
this._latlngs = this._convertLatLngs(latlngs); | |
}, | |
options: { | |
// how much to simplify the polyline on each zoom level | |
// more = better performance and smoother look, less = more accurate | |
smoothFactor: 1.0, | |
noClip: false | |
}, | |
projectLatlngs: function () { | |
this._originalPoints = []; | |
for (var i = 0, len = this._latlngs.length; i < len; i++) { | |
this._originalPoints[i] = this._map.latLngToLayerPoint(this._latlngs[i]); | |
} | |
}, | |
getPathString: function () { | |
for (var i = 0, len = this._parts.length, str = ''; i < len; i++) { | |
str += this._getPathPartStr(this._parts[i]); | |
} | |
return str; | |
}, | |
getLatLngs: function () { | |
return this._latlngs; | |
}, | |
setLatLngs: function (latlngs) { | |
this._latlngs = this._convertLatLngs(latlngs); | |
return this.redraw(); | |
}, | |
addLatLng: function (latlng) { | |
this._latlngs.push(L.latLng(latlng)); | |
return this.redraw(); | |
}, | |
spliceLatLngs: function () { // (Number index, Number howMany) | |
var removed = [].splice.apply(this._latlngs, arguments); | |
this._convertLatLngs(this._latlngs, true); | |
this.redraw(); | |
return removed; | |
}, | |
closestLayerPoint: function (p) { | |
var minDistance = Infinity, parts = this._parts, p1, p2, minPoint = null; | |
for (var j = 0, jLen = parts.length; j < jLen; j++) { | |
var points = parts[j]; | |
for (var i = 1, len = points.length; i < len; i++) { | |
p1 = points[i - 1]; | |
p2 = points[i]; | |
var sqDist = L.LineUtil._sqClosestPointOnSegment(p, p1, p2, true); | |
if (sqDist < minDistance) { | |
minDistance = sqDist; | |
minPoint = L.LineUtil._sqClosestPointOnSegment(p, p1, p2); | |
} | |
} | |
} | |
if (minPoint) { | |
minPoint.distance = Math.sqrt(minDistance); | |
} | |
return minPoint; | |
}, | |
getBounds: function () { | |
return new L.LatLngBounds(this.getLatLngs()); | |
}, | |
_convertLatLngs: function (latlngs, overwrite) { | |
var i, len, target = overwrite ? latlngs : []; | |
for (i = 0, len = latlngs.length; i < len; i++) { | |
if (L.Util.isArray(latlngs[i]) && typeof latlngs[i][0] !== 'number') { | |
return; | |
} | |
target[i] = L.latLng(latlngs[i]); | |
} | |
return target; | |
}, | |
_initEvents: function () { | |
L.Path.prototype._initEvents.call(this); | |
}, | |
_getPathPartStr: function (points) { | |
var round = L.Path.VML; | |
for (var j = 0, len2 = points.length, str = '', p; j < len2; j++) { | |
p = points[j]; | |
if (round) { | |
p._round(); | |
} | |
str += (j ? 'L' : 'M') + p.x + ' ' + p.y; | |
} | |
return str; | |
}, | |
_clipPoints: function () { | |
var points = this._originalPoints, | |
len = points.length, | |
i, k, segment; | |
if (this.options.noClip) { | |
this._parts = [points]; | |
return; | |
} | |
this._parts = []; | |
var parts = this._parts, | |
vp = this._map._pathViewport, | |
lu = L.LineUtil; | |
for (i = 0, k = 0; i < len - 1; i++) { | |
segment = lu.clipSegment(points[i], points[i + 1], vp, i); | |
if (!segment) { | |
continue; | |
} | |
parts[k] = parts[k] || []; | |
parts[k].push(segment[0]); | |
// if segment goes out of screen, or it's the last one, it's the end of the line part | |
if ((segment[1] !== points[i + 1]) || (i === len - 2)) { | |
parts[k].push(segment[1]); | |
k++; | |
} | |
} | |
}, | |
// simplify each clipped part of the polyline | |
_simplifyPoints: function () { | |
var parts = this._parts, | |
lu = L.LineUtil; | |
for (var i = 0, len = parts.length; i < len; i++) { | |
parts[i] = lu.simplify(parts[i], this.options.smoothFactor); | |
} | |
}, | |
_updatePath: function () { | |
if (!this._map) { return; } | |
this._clipPoints(); | |
this._simplifyPoints(); | |
L.Path.prototype._updatePath.call(this); | |
} | |
}); | |
L.polyline = function (latlngs, options) { | |
return new L.Polyline(latlngs, options); | |
}; | |
/* | |
* L.PolyUtil contains utility functions for polygons (clipping, etc.). | |
*/ | |
/*jshint bitwise:false */ // allow bitwise operations here | |
L.PolyUtil = {}; | |
/* | |
* Sutherland-Hodgeman polygon clipping algorithm. | |
* Used to avoid rendering parts of a polygon that are not currently visible. | |
*/ | |
L.PolyUtil.clipPolygon = function (points, bounds) { | |
var clippedPoints, | |
edges = [1, 4, 2, 8], | |
i, j, k, | |
a, b, | |
len, edge, p, | |
lu = L.LineUtil; | |
for (i = 0, len = points.length; i < len; i++) { | |
points[i]._code = lu._getBitCode(points[i], bounds); | |
} | |
// for each edge (left, bottom, right, top) | |
for (k = 0; k < 4; k++) { | |
edge = edges[k]; | |
clippedPoints = []; | |
for (i = 0, len = points.length, j = len - 1; i < len; j = i++) { | |
a = points[i]; | |
b = points[j]; | |
// if a is inside the clip window | |
if (!(a._code & edge)) { | |
// if b is outside the clip window (a->b goes out of screen) | |
if (b._code & edge) { | |
p = lu._getEdgeIntersection(b, a, edge, bounds); | |
p._code = lu._getBitCode(p, bounds); | |
clippedPoints.push(p); | |
} | |
clippedPoints.push(a); | |
// else if b is inside the clip window (a->b enters the screen) | |
} else if (!(b._code & edge)) { | |
p = lu._getEdgeIntersection(b, a, edge, bounds); | |
p._code = lu._getBitCode(p, bounds); | |
clippedPoints.push(p); | |
} | |
} | |
points = clippedPoints; | |
} | |
return points; | |
}; | |
/* | |
* L.Polygon is used to display polygons on a map. | |
*/ | |
L.Polygon = L.Polyline.extend({ | |
options: { | |
fill: true | |
}, | |
initialize: function (latlngs, options) { | |
L.Polyline.prototype.initialize.call(this, latlngs, options); | |
this._initWithHoles(latlngs); | |
}, | |
_initWithHoles: function (latlngs) { | |
var i, len, hole; | |
if (latlngs && L.Util.isArray(latlngs[0]) && (typeof latlngs[0][0] !== 'number')) { | |
this._latlngs = this._convertLatLngs(latlngs[0]); | |
this._holes = latlngs.slice(1); | |
for (i = 0, len = this._holes.length; i < len; i++) { | |
hole = this._holes[i] = this._convertLatLngs(this._holes[i]); | |
if (hole[0].equals(hole[hole.length - 1])) { | |
hole.pop(); | |
} | |
} | |
} | |
// filter out last point if its equal to the first one | |
latlngs = this._latlngs; | |
if (latlngs.length >= 2 && latlngs[0].equals(latlngs[latlngs.length - 1])) { | |
latlngs.pop(); | |
} | |
}, | |
projectLatlngs: function () { | |
L.Polyline.prototype.projectLatlngs.call(this); | |
// project polygon holes points | |
// TODO move this logic to Polyline to get rid of duplication | |
this._holePoints = []; | |
if (!this._holes) { return; } | |
var i, j, len, len2; | |
for (i = 0, len = this._holes.length; i < len; i++) { | |
this._holePoints[i] = []; | |
for (j = 0, len2 = this._holes[i].length; j < len2; j++) { | |
this._holePoints[i][j] = this._map.latLngToLayerPoint(this._holes[i][j]); | |
} | |
} | |
}, | |
setLatLngs: function (latlngs) { | |
if (latlngs && L.Util.isArray(latlngs[0]) && (typeof latlngs[0][0] !== 'number')) { | |
this._initWithHoles(latlngs); | |
return this.redraw(); | |
} else { | |
return L.Polyline.prototype.setLatLngs.call(this, latlngs); | |
} | |
}, | |
_clipPoints: function () { | |
var points = this._originalPoints, | |
newParts = []; | |
this._parts = [points].concat(this._holePoints); | |
if (this.options.noClip) { return; } | |
for (var i = 0, len = this._parts.length; i < len; i++) { | |
var clipped = L.PolyUtil.clipPolygon(this._parts[i], this._map._pathViewport); | |
if (clipped.length) { | |
newParts.push(clipped); | |
} | |
} | |
this._parts = newParts; | |
}, | |
_getPathPartStr: function (points) { | |
var str = L.Polyline.prototype._getPathPartStr.call(this, points); | |
return str + (L.Browser.svg ? 'z' : 'x'); | |
} | |
}); | |
L.polygon = function (latlngs, options) { | |
return new L.Polygon(latlngs, options); | |
}; | |
/* | |
* Contains L.MultiPolyline and L.MultiPolygon layers. | |
*/ | |
(function () { | |
function createMulti(Klass) { | |
return L.FeatureGroup.extend({ | |
initialize: function (latlngs, options) { | |
this._layers = {}; | |
this._options = options; | |
this.setLatLngs(latlngs); | |
}, | |
setLatLngs: function (latlngs) { | |
var i = 0, | |
len = latlngs.length; | |
this.eachLayer(function (layer) { | |
if (i < len) { | |
layer.setLatLngs(latlngs[i++]); | |
} else { | |
this.removeLayer(layer); | |
} | |
}, this); | |
while (i < len) { | |
this.addLayer(new Klass(latlngs[i++], this._options)); | |
} | |
return this; | |
}, | |
getLatLngs: function () { | |
var latlngs = []; | |
this.eachLayer(function (layer) { | |
latlngs.push(layer.getLatLngs()); | |
}); | |
return latlngs; | |
} | |
}); | |
} | |
L.MultiPolyline = createMulti(L.Polyline); | |
L.MultiPolygon = createMulti(L.Polygon); | |
L.multiPolyline = function (latlngs, options) { | |
return new L.MultiPolyline(latlngs, options); | |
}; | |
L.multiPolygon = function (latlngs, options) { | |
return new L.MultiPolygon(latlngs, options); | |
}; | |
}()); | |
/* | |
* L.Rectangle extends Polygon and creates a rectangle when passed a LatLngBounds object. | |
*/ | |
L.Rectangle = L.Polygon.extend({ | |
initialize: function (latLngBounds, options) { | |
L.Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options); | |
}, | |
setBounds: function (latLngBounds) { | |
this.setLatLngs(this._boundsToLatLngs(latLngBounds)); | |
}, | |
_boundsToLatLngs: function (latLngBounds) { | |
latLngBounds = L.latLngBounds(latLngBounds); | |
return [ | |
latLngBounds.getSouthWest(), | |
latLngBounds.getNorthWest(), | |
latLngBounds.getNorthEast(), | |
latLngBounds.getSouthEast() | |
]; | |
} | |
}); | |
L.rectangle = function (latLngBounds, options) { | |
return new L.Rectangle(latLngBounds, options); | |
}; | |
/* | |
* L.Circle is a circle overlay (with a certain radius in meters). | |
*/ | |
L.Circle = L.Path.extend({ | |
initialize: function (latlng, radius, options) { | |
L.Path.prototype.initialize.call(this, options); | |
this._latlng = L.latLng(latlng); | |
this._mRadius = radius; | |
}, | |
options: { | |
fill: true | |
}, | |
setLatLng: function (latlng) { | |
this._latlng = L.latLng(latlng); | |
return this.redraw(); | |
}, | |
setRadius: function (radius) { | |
this._mRadius = radius; | |
return this.redraw(); | |
}, | |
projectLatlngs: function () { | |
var lngRadius = this._getLngRadius(), | |
latlng = this._latlng, | |
pointLeft = this._map.latLngToLayerPoint([latlng.lat, latlng.lng - lngRadius]); | |
this._point = this._map.latLngToLayerPoint(latlng); | |
this._radius = Math.max(this._point.x - pointLeft.x, 1); | |
}, | |
getBounds: function () { | |
var lngRadius = this._getLngRadius(), | |
latRadius = (this._mRadius / 40075017) * 360, | |
latlng = this._latlng; | |
return new L.LatLngBounds( | |
[latlng.lat - latRadius, latlng.lng - lngRadius], | |
[latlng.lat + latRadius, latlng.lng + lngRadius]); | |
}, | |
getLatLng: function () { | |
return this._latlng; | |
}, | |
getPathString: function () { | |
var p = this._point, | |
r = this._radius; | |
if (this._checkIfEmpty()) { | |
return ''; | |
} | |
if (L.Browser.svg) { | |
return 'M' + p.x + ',' + (p.y - r) + | |
'A' + r + ',' + r + ',0,1,1,' + | |
(p.x - 0.1) + ',' + (p.y - r) + ' z'; | |
} else { | |
p._round(); | |
r = Math.round(r); | |
return 'AL ' + p.x + ',' + p.y + ' ' + r + ',' + r + ' 0,' + (65535 * 360); | |
} | |
}, | |
getRadius: function () { | |
return this._mRadius; | |
}, | |
// TODO Earth hardcoded, move into projection code! | |
_getLatRadius: function () { | |
return (this._mRadius / 40075017) * 360; | |
}, | |
_getLngRadius: function () { | |
return this._getLatRadius() / Math.cos(L.LatLng.DEG_TO_RAD * this._latlng.lat); | |
}, | |
_checkIfEmpty: function () { | |
if (!this._map) { | |
return false; | |
} | |
var vp = this._map._pathViewport, | |
r = this._radius, | |
p = this._point; | |
return p.x - r > vp.max.x || p.y - r > vp.max.y || | |
p.x + r < vp.min.x || p.y + r < vp.min.y; | |
} | |
}); | |
L.circle = function (latlng, radius, options) { | |
return new L.Circle(latlng, radius, options); | |
}; | |
/* | |
* L.CircleMarker is a circle overlay with a permanent pixel radius. | |
*/ | |
L.CircleMarker = L.Circle.extend({ | |
options: { | |
radius: 10, | |
weight: 2 | |
}, | |
initialize: function (latlng, options) { | |
L.Circle.prototype.initialize.call(this, latlng, null, options); | |
this._radius = this.options.radius; | |
}, | |
projectLatlngs: function () { | |
this._point = this._map.latLngToLayerPoint(this._latlng); | |
}, | |
_updateStyle : function () { | |
L.Circle.prototype._updateStyle.call(this); | |
this.setRadius(this.options.radius); | |
}, | |
setLatLng: function (latlng) { | |
L.Circle.prototype.setLatLng.call(this, latlng); | |
if (this._popup && this._popup._isOpen) { | |
this._popup.setLatLng(latlng); | |
} | |
return this; | |
}, | |
setRadius: function (radius) { | |
this.options.radius = this._radius = radius; | |
return this.redraw(); | |
}, | |
getRadius: function () { | |
return this._radius; | |
} | |
}); | |
L.circleMarker = function (latlng, options) { | |
return new L.CircleMarker(latlng, options); | |
}; | |
/* | |
* Extends L.Polyline to be able to manually detect clicks on Canvas-rendered polylines. | |
*/ | |
L.Polyline.include(!L.Path.CANVAS ? {} : { | |
_containsPoint: function (p, closed) { | |
var i, j, k, len, len2, dist, part, | |
w = this.options.weight / 2; | |
if (L.Browser.touch) { | |
w += 10; // polyline click tolerance on touch devices | |
} | |
for (i = 0, len = this._parts.length; i < len; i++) { | |
part = this._parts[i]; | |
for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) { | |
if (!closed && (j === 0)) { | |
continue; | |
} | |
dist = L.LineUtil.pointToSegmentDistance(p, part[k], part[j]); | |
if (dist <= w) { | |
return true; | |
} | |
} | |
} | |
return false; | |
} | |
}); | |
/* | |
* Extends L.Polygon to be able to manually detect clicks on Canvas-rendered polygons. | |
*/ | |
L.Polygon.include(!L.Path.CANVAS ? {} : { | |
_containsPoint: function (p) { | |
var inside = false, | |
part, p1, p2, | |
i, j, k, | |
len, len2; | |
// TODO optimization: check if within bounds first | |
if (L.Polyline.prototype._containsPoint.call(this, p, true)) { | |
// click on polygon border | |
return true; | |
} | |
// ray casting algorithm for detecting if point is in polygon | |
for (i = 0, len = this._parts.length; i < len; i++) { | |
part = this._parts[i]; | |
for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) { | |
p1 = part[j]; | |
p2 = part[k]; | |
if (((p1.y > p.y) !== (p2.y > p.y)) && | |
(p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) { | |
inside = !inside; | |
} | |
} | |
} | |
return inside; | |
} | |
}); | |
/* | |
* Extends L.Circle with Canvas-specific code. | |
*/ | |
L.Circle.include(!L.Path.CANVAS ? {} : { | |
_drawPath: function () { | |
var p = this._point; | |
this._ctx.beginPath(); | |
this._ctx.arc(p.x, p.y, this._radius, 0, Math.PI * 2, false); | |
}, | |
_containsPoint: function (p) { | |
var center = this._point, | |
w2 = this.options.stroke ? this.options.weight / 2 : 0; | |
return (p.distanceTo(center) <= this._radius + w2); | |
} | |
}); | |
/* | |
* CircleMarker canvas specific drawing parts. | |
*/ | |
L.CircleMarker.include(!L.Path.CANVAS ? {} : { | |
_updateStyle: function () { | |
L.Path.prototype._updateStyle.call(this); | |
} | |
}); | |
/* | |
* L.GeoJSON turns any GeoJSON data into a Leaflet layer. | |
*/ | |
L.GeoJSON = L.FeatureGroup.extend({ | |
initialize: function (geojson, options) { | |
L.setOptions(this, options); | |
this._layers = {}; | |
if (geojson) { | |
this.addData(geojson); | |
} | |
}, | |
addData: function (geojson) { | |
var features = L.Util.isArray(geojson) ? geojson : geojson.features, | |
i, len, feature; | |
if (features) { | |
for (i = 0, len = features.length; i < len; i++) { | |
// Only add this if geometry or geometries are set and not null | |
feature = features[i]; | |
if (feature.geometries || feature.geometry || feature.features || feature.coordinates) { | |
this.addData(features[i]); | |
} | |
} | |
return this; | |
} | |
var options = this.options; | |
if (options.filter && !options.filter(geojson)) { return; } | |
var layer = L.GeoJSON.geometryToLayer(geojson, options.pointToLayer, options.coordsToLatLng, options); | |
layer.feature = L.GeoJSON.asFeature(geojson); | |
layer.defaultOptions = layer.options; | |
this.resetStyle(layer); | |
if (options.onEachFeature) { | |
options.onEachFeature(geojson, layer); | |
} | |
return this.addLayer(layer); | |
}, | |
resetStyle: function (layer) { | |
var style = this.options.style; | |
if (style) { | |
// reset any custom styles | |
L.Util.extend(layer.options, layer.defaultOptions); | |
this._setLayerStyle(layer, style); | |
} | |
}, | |
setStyle: function (style) { | |
this.eachLayer(function (layer) { | |
this._setLayerStyle(layer, style); | |
}, this); | |
}, | |
_setLayerStyle: function (layer, style) { | |
if (typeof style === 'function') { | |
style = style(layer.feature); | |
} | |
if (layer.setStyle) { | |
layer.setStyle(style); | |
} | |
} | |
}); | |
L.extend(L.GeoJSON, { | |
geometryToLayer: function (geojson, pointToLayer, coordsToLatLng, vectorOptions) { | |
var geometry = geojson.type === 'Feature' ? geojson.geometry : geojson, | |
coords = geometry.coordinates, | |
layers = [], | |
latlng, latlngs, i, len; | |
coordsToLatLng = coordsToLatLng || this.coordsToLatLng; | |
switch (geometry.type) { | |
case 'Point': | |
latlng = coordsToLatLng(coords); | |
return pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng); | |
case 'MultiPoint': | |
for (i = 0, len = coords.length; i < len; i++) { | |
latlng = coordsToLatLng(coords[i]); | |
layers.push(pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng)); | |
} | |
return new L.FeatureGroup(layers); | |
case 'LineString': | |
latlngs = this.coordsToLatLngs(coords, 0, coordsToLatLng); | |
return new L.Polyline(latlngs, vectorOptions); | |
case 'Polygon': | |
if (coords.length === 2 && !coords[1].length) { | |
throw new Error('Invalid GeoJSON object.'); | |
} | |
latlngs = this.coordsToLatLngs(coords, 1, coordsToLatLng); | |
return new L.Polygon(latlngs, vectorOptions); | |
case 'MultiLineString': | |
latlngs = this.coordsToLatLngs(coords, 1, coordsToLatLng); | |
return new L.MultiPolyline(latlngs, vectorOptions); | |
case 'MultiPolygon': | |
latlngs = this.coordsToLatLngs(coords, 2, coordsToLatLng); | |
return new L.MultiPolygon(latlngs, vectorOptions); | |
case 'GeometryCollection': | |
for (i = 0, len = geometry.geometries.length; i < len; i++) { | |
layers.push(this.geometryToLayer({ | |
geometry: geometry.geometries[i], | |
type: 'Feature', | |
properties: geojson.properties | |
}, pointToLayer, coordsToLatLng, vectorOptions)); | |
} | |
return new L.FeatureGroup(layers); | |
default: | |
throw new Error('Invalid GeoJSON object.'); | |
} | |
}, | |
coordsToLatLng: function (coords) { // (Array[, Boolean]) -> LatLng | |
return new L.LatLng(coords[1], coords[0], coords[2]); | |
}, | |
coordsToLatLngs: function (coords, levelsDeep, coordsToLatLng) { // (Array[, Number, Function]) -> Array | |
var latlng, i, len, | |
latlngs = []; | |
for (i = 0, len = coords.length; i < len; i++) { | |
latlng = levelsDeep ? | |
this.coordsToLatLngs(coords[i], levelsDeep - 1, coordsToLatLng) : | |
(coordsToLatLng || this.coordsToLatLng)(coords[i]); | |
latlngs.push(latlng); | |
} | |
return latlngs; | |
}, | |
latLngToCoords: function (latlng) { | |
var coords = [latlng.lng, latlng.lat]; | |
if (latlng.alt !== undefined) { | |
coords.push(latlng.alt); | |
} | |
return coords; | |
}, | |
latLngsToCoords: function (latLngs) { | |
var coords = []; | |
for (var i = 0, len = latLngs.length; i < len; i++) { | |
coords.push(L.GeoJSON.latLngToCoords(latLngs[i])); | |
} | |
return coords; | |
}, | |
getFeature: function (layer, newGeometry) { | |
return layer.feature ? L.extend({}, layer.feature, {geometry: newGeometry}) : L.GeoJSON.asFeature(newGeometry); | |
}, | |
asFeature: function (geoJSON) { | |
if (geoJSON.type === 'Feature') { | |
return geoJSON; | |
} | |
return { | |
type: 'Feature', | |
properties: {}, | |
geometry: geoJSON | |
}; | |
} | |
}); | |
var PointToGeoJSON = { | |
toGeoJSON: function () { | |
return L.GeoJSON.getFeature(this, { | |
type: 'Point', | |
coordinates: L.GeoJSON.latLngToCoords(this.getLatLng()) | |
}); | |
} | |
}; | |
L.Marker.include(PointToGeoJSON); | |
L.Circle.include(PointToGeoJSON); | |
L.CircleMarker.include(PointToGeoJSON); | |
L.Polyline.include({ | |
toGeoJSON: function () { | |
return L.GeoJSON.getFeature(this, { | |
type: 'LineString', | |
coordinates: L.GeoJSON.latLngsToCoords(this.getLatLngs()) | |
}); | |
} | |
}); | |
L.Polygon.include({ | |
toGeoJSON: function () { | |
var coords = [L.GeoJSON.latLngsToCoords(this.getLatLngs())], | |
i, len, hole; | |
coords[0].push(coords[0][0]); | |
if (this._holes) { | |
for (i = 0, len = this._holes.length; i < len; i++) { | |
hole = L.GeoJSON.latLngsToCoords(this._holes[i]); | |
hole.push(hole[0]); | |
coords.push(hole); | |
} | |
} | |
return L.GeoJSON.getFeature(this, { | |
type: 'Polygon', | |
coordinates: coords | |
}); | |
} | |
}); | |
(function () { | |
function multiToGeoJSON(type) { | |
return function () { | |
var coords = []; | |
this.eachLayer(function (layer) { | |
coords.push(layer.toGeoJSON().geometry.coordinates); | |
}); | |
return L.GeoJSON.getFeature(this, { | |
type: type, | |
coordinates: coords | |
}); | |
}; | |
} | |
L.MultiPolyline.include({toGeoJSON: multiToGeoJSON('MultiLineString')}); | |
L.MultiPolygon.include({toGeoJSON: multiToGeoJSON('MultiPolygon')}); | |
L.LayerGroup.include({ | |
toGeoJSON: function () { | |
var geometry = this.feature && this.feature.geometry, | |
jsons = [], | |
json; | |
if (geometry && geometry.type === 'MultiPoint') { | |
return multiToGeoJSON('MultiPoint').call(this); | |
} | |
var isGeometryCollection = geometry && geometry.type === 'GeometryCollection'; | |
this.eachLayer(function (layer) { | |
if (layer.toGeoJSON) { | |
json = layer.toGeoJSON(); | |
jsons.push(isGeometryCollection ? json.geometry : L.GeoJSON.asFeature(json)); | |
} | |
}); | |
if (isGeometryCollection) { | |
return L.GeoJSON.getFeature(this, { | |
geometries: jsons, | |
type: 'GeometryCollection' | |
}); | |
} | |
return { | |
type: 'FeatureCollection', | |
features: jsons | |
}; | |
} | |
}); | |
}()); | |
L.geoJson = function (geojson, options) { | |
return new L.GeoJSON(geojson, options); | |
}; | |
/* | |
* L.DomEvent contains functions for working with DOM events. | |
*/ | |
L.DomEvent = { | |
/* inspired by John Resig, Dean Edwards and YUI addEvent implementations */ | |
addListener: function (obj, type, fn, context) { // (HTMLElement, String, Function[, Object]) | |
var id = L.stamp(fn), | |
key = '_leaflet_' + type + id, | |
handler, originalHandler, newType; | |
if (obj[key]) { return this; } | |
handler = function (e) { | |
return fn.call(context || obj, e || L.DomEvent._getEvent()); | |
}; | |
if (L.Browser.pointer && type.indexOf('touch') === 0) { | |
return this.addPointerListener(obj, type, handler, id); | |
} | |
if (L.Browser.touch && (type === 'dblclick') && this.addDoubleTapListener) { | |
this.addDoubleTapListener(obj, handler, id); | |
} | |
if ('addEventListener' in obj) { | |
if (type === 'mousewheel') { | |
obj.addEventListener('DOMMouseScroll', handler, false); | |
obj.addEventListener(type, handler, false); | |
} else if ((type === 'mouseenter') || (type === 'mouseleave')) { | |
originalHandler = handler; | |
newType = (type === 'mouseenter' ? 'mouseover' : 'mouseout'); | |
handler = function (e) { | |
if (!L.DomEvent._checkMouse(obj, e)) { return; } | |
return originalHandler(e); | |
}; | |
obj.addEventListener(newType, handler, false); | |
} else if (type === 'click' && L.Browser.android) { | |
originalHandler = handler; | |
handler = function (e) { | |
return L.DomEvent._filterClick(e, originalHandler); | |
}; | |
obj.addEventListener(type, handler, false); | |
} else { | |
obj.addEventListener(type, handler, false); | |
} | |
} else if ('attachEvent' in obj) { | |
obj.attachEvent('on' + type, handler); | |
} | |
obj[key] = handler; | |
return this; | |
}, | |
removeListener: function (obj, type, fn) { // (HTMLElement, String, Function) | |
var id = L.stamp(fn), | |
key = '_leaflet_' + type + id, | |
handler = obj[key]; | |
if (!handler) { return this; } | |
if (L.Browser.pointer && type.indexOf('touch') === 0) { | |
this.removePointerListener(obj, type, id); | |
} else if (L.Browser.touch && (type === 'dblclick') && this.removeDoubleTapListener) { | |
this.removeDoubleTapListener(obj, id); | |
} else if ('removeEventListener' in obj) { | |
if (type === 'mousewheel') { | |
obj.removeEventListener('DOMMouseScroll', handler, false); | |
obj.removeEventListener(type, handler, false); | |
} else if ((type === 'mouseenter') || (type === 'mouseleave')) { | |
obj.removeEventListener((type === 'mouseenter' ? 'mouseover' : 'mouseout'), handler, false); | |
} else { | |
obj.removeEventListener(type, handler, false); | |
} | |
} else if ('detachEvent' in obj) { | |
obj.detachEvent('on' + type, handler); | |
} | |
obj[key] = null; | |
return this; | |
}, | |
stopPropagation: function (e) { | |
if (e.stopPropagation) { | |
e.stopPropagation(); | |
} else { | |
e.cancelBubble = true; | |
} | |
L.DomEvent._skipped(e); | |
return this; | |
}, | |
disableScrollPropagation: function (el) { | |
var stop = L.DomEvent.stopPropagation; | |
return L.DomEvent | |
.on(el, 'mousewheel', stop) | |
.on(el, 'MozMousePixelScroll', stop); | |
}, | |
disableClickPropagation: function (el) { | |
var stop = L.DomEvent.stopPropagation; | |
for (var i = L.Draggable.START.length - 1; i >= 0; i--) { | |
L.DomEvent.on(el, L.Draggable.START[i], stop); | |
} | |
return L.DomEvent | |
.on(el, 'click', L.DomEvent._fakeStop) | |
.on(el, 'dblclick', stop); | |
}, | |
preventDefault: function (e) { | |
if (e.preventDefault) { | |
e.preventDefault(); | |
} else { | |
e.returnValue = false; | |
} | |
return this; | |
}, | |
stop: function (e) { | |
return L.DomEvent | |
.preventDefault(e) | |
.stopPropagation(e); | |
}, | |
getMousePosition: function (e, container) { | |
if (!container) { | |
return new L.Point(e.clientX, e.clientY); | |
} | |
var rect = container.getBoundingClientRect(); | |
return new L.Point( | |
e.clientX - rect.left - container.clientLeft, | |
e.clientY - rect.top - container.clientTop); | |
}, | |
getWheelDelta: function (e) { | |
var delta = 0; | |
if (e.wheelDelta) { | |
delta = e.wheelDelta / 120; | |
} | |
if (e.detail) { | |
delta = -e.detail / 3; | |
} | |
return delta; | |
}, | |
_skipEvents: {}, | |
_fakeStop: function (e) { | |
// fakes stopPropagation by setting a special event flag, checked/reset with L.DomEvent._skipped(e) | |
L.DomEvent._skipEvents[e.type] = true; | |
}, | |
_skipped: function (e) { | |
var skipped = this._skipEvents[e.type]; | |
// reset when checking, as it's only used in map container and propagates outside of the map | |
this._skipEvents[e.type] = false; | |
return skipped; | |
}, | |
// check if element really left/entered the event target (for mouseenter/mouseleave) | |
_checkMouse: function (el, e) { | |
var related = e.relatedTarget; | |
if (!related) { return true; } | |
try { | |
while (related && (related !== el)) { | |
related = related.parentNode; | |
} | |
} catch (err) { | |
return false; | |
} | |
return (related !== el); | |
}, | |
_getEvent: function () { // evil magic for IE | |
/*jshint noarg:false */ | |
var e = window.event; | |
if (!e) { | |
var caller = arguments.callee.caller; | |
while (caller) { | |
e = caller['arguments'][0]; | |
if (e && window.Event === e.constructor) { | |
break; | |
} | |
caller = caller.caller; | |
} | |
} | |
return e; | |
}, | |
// this is a horrible workaround for a bug in Android where a single touch triggers two click events | |
_filterClick: function (e, handler) { | |
var timeStamp = (e.timeStamp || e.originalEvent.timeStamp), | |
elapsed = L.DomEvent._lastClick && (timeStamp - L.DomEvent._lastClick); | |
// are they closer together than 500ms yet more than 100ms? | |
// Android typically triggers them ~300ms apart while multiple listeners | |
// on the same event should be triggered far faster; | |
// or check if click is simulated on the element, and if it is, reject any non-simulated events | |
if ((elapsed && elapsed > 100 && elapsed < 500) || (e.target._simulatedClick && !e._simulated)) { | |
L.DomEvent.stop(e); | |
return; | |
} | |
L.DomEvent._lastClick = timeStamp; | |
return handler(e); | |
} | |
}; | |
L.DomEvent.on = L.DomEvent.addListener; | |
L.DomEvent.off = L.DomEvent.removeListener; | |
/* | |
* L.Draggable allows you to add dragging capabilities to any element. Supports mobile devices too. | |
*/ | |
L.Draggable = L.Class.extend({ | |
includes: L.Mixin.Events, | |
statics: { | |
START: L.Browser.touch ? ['touchstart', 'mousedown'] : ['mousedown'], | |
END: { | |
mousedown: 'mouseup', | |
touchstart: 'touchend', | |
pointerdown: 'touchend', | |
MSPointerDown: 'touchend' | |
}, | |
MOVE: { | |
mousedown: 'mousemove', | |
touchstart: 'touchmove', | |
pointerdown: 'touchmove', | |
MSPointerDown: 'touchmove' | |
} | |
}, | |
initialize: function (element, dragStartTarget) { | |
this._element = element; | |
this._dragStartTarget = dragStartTarget || element; | |
}, | |
enable: function () { | |
if (this._enabled) { return; } | |
for (var i = L.Draggable.START.length - 1; i >= 0; i--) { | |
L.DomEvent.on(this._dragStartTarget, L.Draggable.START[i], this._onDown, this); | |
} | |
this._enabled = true; | |
}, | |
disable: function () { | |
if (!this._enabled) { return; } | |
for (var i = L.Draggable.START.length - 1; i >= 0; i--) { | |
L.DomEvent.off(this._dragStartTarget, L.Draggable.START[i], this._onDown, this); | |
} | |
this._enabled = false; | |
this._moved = false; | |
}, | |
_onDown: function (e) { | |
this._moved = false; | |
if (e.shiftKey || ((e.which !== 1) && (e.button !== 1) && !e.touches)) { return; } | |
L.DomEvent.stopPropagation(e); | |
if (L.Draggable._disabled) { return; } | |
L.DomUtil.disableImageDrag(); | |
L.DomUtil.disableTextSelection(); | |
if (this._moving) { return; } | |
var first = e.touches ? e.touches[0] : e; | |
this._startPoint = new L.Point(first.clientX, first.clientY); | |
this._startPos = this._newPos = L.DomUtil.getPosition(this._element); | |
L.DomEvent | |
.on(document, L.Draggable.MOVE[e.type], this._onMove, this) | |
.on(document, L.Draggable.END[e.type], this._onUp, this); | |
}, | |
_onMove: function (e) { | |
if (e.touches && e.touches.length > 1) { | |
this._moved = true; | |
return; | |
} | |
var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e), | |
newPoint = new L.Point(first.clientX, first.clientY), | |
offset = newPoint.subtract(this._startPoint); | |
if (!offset.x && !offset.y) { return; } | |
if (L.Browser.touch && Math.abs(offset.x) + Math.abs(offset.y) < 3) { return; } | |
L.DomEvent.preventDefault(e); | |
if (!this._moved) { | |
this.fire('dragstart'); | |
this._moved = true; | |
this._startPos = L.DomUtil.getPosition(this._element).subtract(offset); | |
L.DomUtil.addClass(document.body, 'leaflet-dragging'); | |
this._lastTarget = e.target || e.srcElement; | |
L.DomUtil.addClass(this._lastTarget, 'leaflet-drag-target'); | |
} | |
this._newPos = this._startPos.add(offset); | |
this._moving = true; | |
L.Util.cancelAnimFrame(this._animRequest); | |
this._animRequest = L.Util.requestAnimFrame(this._updatePosition, this, true, this._dragStartTarget); | |
}, | |
_updatePosition: function () { | |
this.fire('predrag'); | |
L.DomUtil.setPosition(this._element, this._newPos); | |
this.fire('drag'); | |
}, | |
_onUp: function () { | |
L.DomUtil.removeClass(document.body, 'leaflet-dragging'); | |
if (this._lastTarget) { | |
L.DomUtil.removeClass(this._lastTarget, 'leaflet-drag-target'); | |
this._lastTarget = null; | |
} | |
for (var i in L.Draggable.MOVE) { | |
L.DomEvent | |
.off(document, L.Draggable.MOVE[i], this._onMove) | |
.off(document, L.Draggable.END[i], this._onUp); | |
} | |
L.DomUtil.enableImageDrag(); | |
L.DomUtil.enableTextSelection(); | |
if (this._moved && this._moving) { | |
// ensure drag is not fired after dragend | |
L.Util.cancelAnimFrame(this._animRequest); | |
this.fire('dragend', { | |
distance: this._newPos.distanceTo(this._startPos) | |
}); | |
} | |
this._moving = false; | |
} | |
}); | |
/* | |
L.Handler is a base class for handler classes that are used internally to inject | |
interaction features like dragging to classes like Map and Marker. | |
*/ | |
L.Handler = L.Class.extend({ | |
initialize: function (map) { | |
this._map = map; | |
}, | |
enable: function () { | |
if (this._enabled) { return; } | |
this._enabled = true; | |
this.addHooks(); | |
}, | |
disable: function () { | |
if (!this._enabled) { return; } | |
this._enabled = false; | |
this.removeHooks(); | |
}, | |
enabled: function () { | |
return !!this._enabled; | |
} | |
}); | |
/* | |
* L.Handler.MapDrag is used to make the map draggable (with panning inertia), enabled by default. | |
*/ | |
L.Map.mergeOptions({ | |
dragging: true, | |
inertia: !L.Browser.android23, | |
inertiaDeceleration: 3400, // px/s^2 | |
inertiaMaxSpeed: Infinity, // px/s | |
inertiaThreshold: L.Browser.touch ? 32 : 18, // ms | |
easeLinearity: 0.25, | |
// TODO refactor, move to CRS | |
worldCopyJump: false | |
}); | |
L.Map.Drag = L.Handler.extend({ | |
addHooks: function () { | |
if (!this._draggable) { | |
var map = this._map; | |
this._draggable = new L.Draggable(map._mapPane, map._container); | |
this._draggable.on({ | |
'dragstart': this._onDragStart, | |
'drag': this._onDrag, | |
'dragend': this._onDragEnd | |
}, this); | |
if (map.options.worldCopyJump) { | |
this._draggable.on('predrag', this._onPreDrag, this); | |
map.on('viewreset', this._onViewReset, this); | |
map.whenReady(this._onViewReset, this); | |
} | |
} | |
this._draggable.enable(); | |
}, | |
removeHooks: function () { | |
this._draggable.disable(); | |
}, | |
moved: function () { | |
return this._draggable && this._draggable._moved; | |
}, | |
_onDragStart: function () { | |
var map = this._map; | |
if (map._panAnim) { | |
map._panAnim.stop(); | |
} | |
map | |
.fire('movestart') | |
.fire('dragstart'); | |
if (map.options.inertia) { | |
this._positions = []; | |
this._times = []; | |
} | |
}, | |
_onDrag: function () { | |
if (this._map.options.inertia) { | |
var time = this._lastTime = +new Date(), | |
pos = this._lastPos = this._draggable._newPos; | |
this._positions.push(pos); | |
this._times.push(time); | |
if (time - this._times[0] > 200) { | |
this._positions.shift(); | |
this._times.shift(); | |
} | |
} | |
this._map | |
.fire('move') | |
.fire('drag'); | |
}, | |
_onViewReset: function () { | |
// TODO fix hardcoded Earth values | |
var pxCenter = this._map.getSize()._divideBy(2), | |
pxWorldCenter = this._map.latLngToLayerPoint([0, 0]); | |
this._initialWorldOffset = pxWorldCenter.subtract(pxCenter).x; | |
this._worldWidth = this._map.project([0, 180]).x; | |
}, | |
_onPreDrag: function () { | |
// TODO refactor to be able to adjust map pane position after zoom | |
var worldWidth = this._worldWidth, | |
halfWidth = Math.round(worldWidth / 2), | |
dx = this._initialWorldOffset, | |
x = this._draggable._newPos.x, | |
newX1 = (x - halfWidth + dx) % worldWidth + halfWidth - dx, | |
newX2 = (x + halfWidth + dx) % worldWidth - halfWidth - dx, | |
newX = Math.abs(newX1 + dx) < Math.abs(newX2 + dx) ? newX1 : newX2; | |
this._draggable._newPos.x = newX; | |
}, | |
_onDragEnd: function (e) { | |
var map = this._map, | |
options = map.options, | |
delay = +new Date() - this._lastTime, | |
noInertia = !options.inertia || delay > options.inertiaThreshold || !this._positions[0]; | |
map.fire('dragend', e); | |
if (noInertia) { | |
map.fire('moveend'); | |
} else { | |
var direction = this._lastPos.subtract(this._positions[0]), | |
duration = (this._lastTime + delay - this._times[0]) / 1000, | |
ease = options.easeLinearity, | |
speedVector = direction.multiplyBy(ease / duration), | |
speed = speedVector.distanceTo([0, 0]), | |
limitedSpeed = Math.min(options.inertiaMaxSpeed, speed), | |
limitedSpeedVector = speedVector.multiplyBy(limitedSpeed / speed), | |
decelerationDuration = limitedSpeed / (options.inertiaDeceleration * ease), | |
offset = limitedSpeedVector.multiplyBy(-decelerationDuration / 2).round(); | |
if (!offset.x || !offset.y) { | |
map.fire('moveend'); | |
} else { | |
offset = map._limitOffset(offset, map.options.maxBounds); | |
L.Util.requestAnimFrame(function () { | |
map.panBy(offset, { | |
duration: decelerationDuration, | |
easeLinearity: ease, | |
noMoveStart: true | |
}); | |
}); | |
} | |
} | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'dragging', L.Map.Drag); | |
/* | |
* L.Handler.DoubleClickZoom is used to handle double-click zoom on the map, enabled by default. | |
*/ | |
L.Map.mergeOptions({ | |
doubleClickZoom: true | |
}); | |
L.Map.DoubleClickZoom = L.Handler.extend({ | |
addHooks: function () { | |
this._map.on('dblclick', this._onDoubleClick, this); | |
}, | |
removeHooks: function () { | |
this._map.off('dblclick', this._onDoubleClick, this); | |
}, | |
_onDoubleClick: function (e) { | |
var map = this._map, | |
zoom = map.getZoom() + (e.originalEvent.shiftKey ? -1 : 1); | |
if (map.options.doubleClickZoom === 'center') { | |
map.setZoom(zoom); | |
} else { | |
map.setZoomAround(e.containerPoint, zoom); | |
} | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'doubleClickZoom', L.Map.DoubleClickZoom); | |
/* | |
* L.Handler.ScrollWheelZoom is used by L.Map to enable mouse scroll wheel zoom on the map. | |
*/ | |
L.Map.mergeOptions({ | |
scrollWheelZoom: true | |
}); | |
L.Map.ScrollWheelZoom = L.Handler.extend({ | |
addHooks: function () { | |
L.DomEvent.on(this._map._container, 'mousewheel', this._onWheelScroll, this); | |
L.DomEvent.on(this._map._container, 'MozMousePixelScroll', L.DomEvent.preventDefault); | |
this._delta = 0; | |
}, | |
removeHooks: function () { | |
L.DomEvent.off(this._map._container, 'mousewheel', this._onWheelScroll); | |
L.DomEvent.off(this._map._container, 'MozMousePixelScroll', L.DomEvent.preventDefault); | |
}, | |
_onWheelScroll: function (e) { | |
var delta = L.DomEvent.getWheelDelta(e); | |
this._delta += delta; | |
this._lastMousePos = this._map.mouseEventToContainerPoint(e); | |
if (!this._startTime) { | |
this._startTime = +new Date(); | |
} | |
var left = Math.max(40 - (+new Date() - this._startTime), 0); | |
clearTimeout(this._timer); | |
this._timer = setTimeout(L.bind(this._performZoom, this), left); | |
L.DomEvent.preventDefault(e); | |
L.DomEvent.stopPropagation(e); | |
}, | |
_performZoom: function () { | |
var map = this._map, | |
delta = this._delta, | |
zoom = map.getZoom(); | |
delta = delta > 0 ? Math.ceil(delta) : Math.floor(delta); | |
delta = Math.max(Math.min(delta, 4), -4); | |
delta = map._limitZoom(zoom + delta) - zoom; | |
this._delta = 0; | |
this._startTime = null; | |
if (!delta) { return; } | |
if (map.options.scrollWheelZoom === 'center') { | |
map.setZoom(zoom + delta); | |
} else { | |
map.setZoomAround(this._lastMousePos, zoom + delta); | |
} | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'scrollWheelZoom', L.Map.ScrollWheelZoom); | |
/* | |
* Extends the event handling code with double tap support for mobile browsers. | |
*/ | |
L.extend(L.DomEvent, { | |
_touchstart: L.Browser.msPointer ? 'MSPointerDown' : L.Browser.pointer ? 'pointerdown' : 'touchstart', | |
_touchend: L.Browser.msPointer ? 'MSPointerUp' : L.Browser.pointer ? 'pointerup' : 'touchend', | |
// inspired by Zepto touch code by Thomas Fuchs | |
addDoubleTapListener: function (obj, handler, id) { | |
var last, | |
doubleTap = false, | |
delay = 250, | |
touch, | |
pre = '_leaflet_', | |
touchstart = this._touchstart, | |
touchend = this._touchend, | |
trackedTouches = []; | |
function onTouchStart(e) { | |
var count; | |
if (L.Browser.pointer) { | |
trackedTouches.push(e.pointerId); | |
count = trackedTouches.length; | |
} else { | |
count = e.touches.length; | |
} | |
if (count > 1) { | |
return; | |
} | |
var now = Date.now(), | |
delta = now - (last || now); | |
touch = e.touches ? e.touches[0] : e; | |
doubleTap = (delta > 0 && delta <= delay); | |
last = now; | |
} | |
function onTouchEnd(e) { | |
if (L.Browser.pointer) { | |
var idx = trackedTouches.indexOf(e.pointerId); | |
if (idx === -1) { | |
return; | |
} | |
trackedTouches.splice(idx, 1); | |
} | |
if (doubleTap) { | |
if (L.Browser.pointer) { | |
// work around .type being readonly with MSPointer* events | |
var newTouch = { }, | |
prop; | |
// jshint forin:false | |
for (var i in touch) { | |
prop = touch[i]; | |
if (typeof prop === 'function') { | |
newTouch[i] = prop.bind(touch); | |
} else { | |
newTouch[i] = prop; | |
} | |
} | |
touch = newTouch; | |
} | |
touch.type = 'dblclick'; | |
handler(touch); | |
last = null; | |
} | |
} | |
obj[pre + touchstart + id] = onTouchStart; | |
obj[pre + touchend + id] = onTouchEnd; | |
// on pointer we need to listen on the document, otherwise a drag starting on the map and moving off screen | |
// will not come through to us, so we will lose track of how many touches are ongoing | |
var endElement = L.Browser.pointer ? document.documentElement : obj; | |
obj.addEventListener(touchstart, onTouchStart, false); | |
endElement.addEventListener(touchend, onTouchEnd, false); | |
if (L.Browser.pointer) { | |
endElement.addEventListener(L.DomEvent.POINTER_CANCEL, onTouchEnd, false); | |
} | |
return this; | |
}, | |
removeDoubleTapListener: function (obj, id) { | |
var pre = '_leaflet_'; | |
obj.removeEventListener(this._touchstart, obj[pre + this._touchstart + id], false); | |
(L.Browser.pointer ? document.documentElement : obj).removeEventListener( | |
this._touchend, obj[pre + this._touchend + id], false); | |
if (L.Browser.pointer) { | |
document.documentElement.removeEventListener(L.DomEvent.POINTER_CANCEL, obj[pre + this._touchend + id], | |
false); | |
} | |
return this; | |
} | |
}); | |
/* | |
* Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices. | |
*/ | |
L.extend(L.DomEvent, { | |
//static | |
POINTER_DOWN: L.Browser.msPointer ? 'MSPointerDown' : 'pointerdown', | |
POINTER_MOVE: L.Browser.msPointer ? 'MSPointerMove' : 'pointermove', | |
POINTER_UP: L.Browser.msPointer ? 'MSPointerUp' : 'pointerup', | |
POINTER_CANCEL: L.Browser.msPointer ? 'MSPointerCancel' : 'pointercancel', | |
_pointers: [], | |
_pointerDocumentListener: false, | |
// Provides a touch events wrapper for (ms)pointer events. | |
// Based on changes by veproza https://github.com/CloudMade/Leaflet/pull/1019 | |
//ref http://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890 | |
addPointerListener: function (obj, type, handler, id) { | |
switch (type) { | |
case 'touchstart': | |
return this.addPointerListenerStart(obj, type, handler, id); | |
case 'touchend': | |
return this.addPointerListenerEnd(obj, type, handler, id); | |
case 'touchmove': | |
return this.addPointerListenerMove(obj, type, handler, id); | |
default: | |
throw 'Unknown touch event type'; | |
} | |
}, | |
addPointerListenerStart: function (obj, type, handler, id) { | |
var pre = '_leaflet_', | |
pointers = this._pointers; | |
var cb = function (e) { | |
if (e.pointerType !== 'mouse' && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) { | |
L.DomEvent.preventDefault(e); | |
} | |
var alreadyInArray = false; | |
for (var i = 0; i < pointers.length; i++) { | |
if (pointers[i].pointerId === e.pointerId) { | |
alreadyInArray = true; | |
break; | |
} | |
} | |
if (!alreadyInArray) { | |
pointers.push(e); | |
} | |
e.touches = pointers.slice(); | |
e.changedTouches = [e]; | |
handler(e); | |
}; | |
obj[pre + 'touchstart' + id] = cb; | |
obj.addEventListener(this.POINTER_DOWN, cb, false); | |
// need to also listen for end events to keep the _pointers list accurate | |
// this needs to be on the body and never go away | |
if (!this._pointerDocumentListener) { | |
var internalCb = function (e) { | |
for (var i = 0; i < pointers.length; i++) { | |
if (pointers[i].pointerId === e.pointerId) { | |
pointers.splice(i, 1); | |
break; | |
} | |
} | |
}; | |
//We listen on the documentElement as any drags that end by moving the touch off the screen get fired there | |
document.documentElement.addEventListener(this.POINTER_UP, internalCb, false); | |
document.documentElement.addEventListener(this.POINTER_CANCEL, internalCb, false); | |
this._pointerDocumentListener = true; | |
} | |
return this; | |
}, | |
addPointerListenerMove: function (obj, type, handler, id) { | |
var pre = '_leaflet_', | |
touches = this._pointers; | |
function cb(e) { | |
// don't fire touch moves when mouse isn't down | |
if ((e.pointerType === e.MSPOINTER_TYPE_MOUSE || e.pointerType === 'mouse') && e.buttons === 0) { return; } | |
for (var i = 0; i < touches.length; i++) { | |
if (touches[i].pointerId === e.pointerId) { | |
touches[i] = e; | |
break; | |
} | |
} | |
e.touches = touches.slice(); | |
e.changedTouches = [e]; | |
handler(e); | |
} | |
obj[pre + 'touchmove' + id] = cb; | |
obj.addEventListener(this.POINTER_MOVE, cb, false); | |
return this; | |
}, | |
addPointerListenerEnd: function (obj, type, handler, id) { | |
var pre = '_leaflet_', | |
touches = this._pointers; | |
var cb = function (e) { | |
for (var i = 0; i < touches.length; i++) { | |
if (touches[i].pointerId === e.pointerId) { | |
touches.splice(i, 1); | |
break; | |
} | |
} | |
e.touches = touches.slice(); | |
e.changedTouches = [e]; | |
handler(e); | |
}; | |
obj[pre + 'touchend' + id] = cb; | |
obj.addEventListener(this.POINTER_UP, cb, false); | |
obj.addEventListener(this.POINTER_CANCEL, cb, false); | |
return this; | |
}, | |
removePointerListener: function (obj, type, id) { | |
var pre = '_leaflet_', | |
cb = obj[pre + type + id]; | |
switch (type) { | |
case 'touchstart': | |
obj.removeEventListener(this.POINTER_DOWN, cb, false); | |
break; | |
case 'touchmove': | |
obj.removeEventListener(this.POINTER_MOVE, cb, false); | |
break; | |
case 'touchend': | |
obj.removeEventListener(this.POINTER_UP, cb, false); | |
obj.removeEventListener(this.POINTER_CANCEL, cb, false); | |
break; | |
} | |
return this; | |
} | |
}); | |
/* | |
* L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers. | |
*/ | |
L.Map.mergeOptions({ | |
touchZoom: L.Browser.touch && !L.Browser.android23, | |
bounceAtZoomLimits: true | |
}); | |
L.Map.TouchZoom = L.Handler.extend({ | |
addHooks: function () { | |
L.DomEvent.on(this._map._container, 'touchstart', this._onTouchStart, this); | |
}, | |
removeHooks: function () { | |
L.DomEvent.off(this._map._container, 'touchstart', this._onTouchStart, this); | |
}, | |
_onTouchStart: function (e) { | |
var map = this._map; | |
if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; } | |
var p1 = map.mouseEventToLayerPoint(e.touches[0]), | |
p2 = map.mouseEventToLayerPoint(e.touches[1]), | |
viewCenter = map._getCenterLayerPoint(); | |
this._startCenter = p1.add(p2)._divideBy(2); | |
this._startDist = p1.distanceTo(p2); | |
this._moved = false; | |
this._zooming = true; | |
this._centerOffset = viewCenter.subtract(this._startCenter); | |
if (map._panAnim) { | |
map._panAnim.stop(); | |
} | |
L.DomEvent | |
.on(document, 'touchmove', this._onTouchMove, this) | |
.on(document, 'touchend', this._onTouchEnd, this); | |
L.DomEvent.preventDefault(e); | |
}, | |
_onTouchMove: function (e) { | |
var map = this._map; | |
if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; } | |
var p1 = map.mouseEventToLayerPoint(e.touches[0]), | |
p2 = map.mouseEventToLayerPoint(e.touches[1]); | |
this._scale = p1.distanceTo(p2) / this._startDist; | |
this._delta = p1._add(p2)._divideBy(2)._subtract(this._startCenter); | |
if (this._scale === 1) { return; } | |
if (!map.options.bounceAtZoomLimits) { | |
if ((map.getZoom() === map.getMinZoom() && this._scale < 1) || | |
(map.getZoom() === map.getMaxZoom() && this._scale > 1)) { return; } | |
} | |
if (!this._moved) { | |
L.DomUtil.addClass(map._mapPane, 'leaflet-touching'); | |
map | |
.fire('movestart') | |
.fire('zoomstart'); | |
this._moved = true; | |
} | |
L.Util.cancelAnimFrame(this._animRequest); | |
this._animRequest = L.Util.requestAnimFrame( | |
this._updateOnMove, this, true, this._map._container); | |
L.DomEvent.preventDefault(e); | |
}, | |
_updateOnMove: function () { | |
var map = this._map, | |
origin = this._getScaleOrigin(), | |
center = map.layerPointToLatLng(origin), | |
zoom = map.getScaleZoom(this._scale); | |
map._animateZoom(center, zoom, this._startCenter, this._scale, this._delta, false, true); | |
}, | |
_onTouchEnd: function () { | |
if (!this._moved || !this._zooming) { | |
this._zooming = false; | |
return; | |
} | |
var map = this._map; | |
this._zooming = false; | |
L.DomUtil.removeClass(map._mapPane, 'leaflet-touching'); | |
L.Util.cancelAnimFrame(this._animRequest); | |
L.DomEvent | |
.off(document, 'touchmove', this._onTouchMove) | |
.off(document, 'touchend', this._onTouchEnd); | |
var origin = this._getScaleOrigin(), | |
center = map.layerPointToLatLng(origin), | |
oldZoom = map.getZoom(), | |
floatZoomDelta = map.getScaleZoom(this._scale) - oldZoom, | |
roundZoomDelta = (floatZoomDelta > 0 ? | |
Math.ceil(floatZoomDelta) : Math.floor(floatZoomDelta)), | |
zoom = map._limitZoom(oldZoom + roundZoomDelta), | |
scale = map.getZoomScale(zoom) / this._scale; | |
map._animateZoom(center, zoom, origin, scale); | |
}, | |
_getScaleOrigin: function () { | |
var centerOffset = this._centerOffset.subtract(this._delta).divideBy(this._scale); | |
return this._startCenter.add(centerOffset); | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'touchZoom', L.Map.TouchZoom); | |
/* | |
* L.Map.Tap is used to enable mobile hacks like quick taps and long hold. | |
*/ | |
L.Map.mergeOptions({ | |
tap: true, | |
tapTolerance: 15 | |
}); | |
L.Map.Tap = L.Handler.extend({ | |
addHooks: function () { | |
L.DomEvent.on(this._map._container, 'touchstart', this._onDown, this); | |
}, | |
removeHooks: function () { | |
L.DomEvent.off(this._map._container, 'touchstart', this._onDown, this); | |
}, | |
_onDown: function (e) { | |
if (!e.touches) { return; } | |
L.DomEvent.preventDefault(e); | |
this._fireClick = true; | |
// don't simulate click or track longpress if more than 1 touch | |
if (e.touches.length > 1) { | |
this._fireClick = false; | |
clearTimeout(this._holdTimeout); | |
return; | |
} | |
var first = e.touches[0], | |
el = first.target; | |
this._startPos = this._newPos = new L.Point(first.clientX, first.clientY); | |
// if touching a link, highlight it | |
if (el.tagName && el.tagName.toLowerCase() === 'a') { | |
L.DomUtil.addClass(el, 'leaflet-active'); | |
} | |
// simulate long hold but setting a timeout | |
this._holdTimeout = setTimeout(L.bind(function () { | |
if (this._isTapValid()) { | |
this._fireClick = false; | |
this._onUp(); | |
this._simulateEvent('contextmenu', first); | |
} | |
}, this), 1000); | |
L.DomEvent | |
.on(document, 'touchmove', this._onMove, this) | |
.on(document, 'touchend', this._onUp, this); | |
}, | |
_onUp: function (e) { | |
clearTimeout(this._holdTimeout); | |
L.DomEvent | |
.off(document, 'touchmove', this._onMove, this) | |
.off(document, 'touchend', this._onUp, this); | |
if (this._fireClick && e && e.changedTouches) { | |
var first = e.changedTouches[0], | |
el = first.target; | |
if (el && el.tagName && el.tagName.toLowerCase() === 'a') { | |
L.DomUtil.removeClass(el, 'leaflet-active'); | |
} | |
// simulate click if the touch didn't move too much | |
if (this._isTapValid()) { | |
this._simulateEvent('click', first); | |
} | |
} | |
}, | |
_isTapValid: function () { | |
return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance; | |
}, | |
_onMove: function (e) { | |
var first = e.touches[0]; | |
this._newPos = new L.Point(first.clientX, first.clientY); | |
}, | |
_simulateEvent: function (type, e) { | |
var simulatedEvent = document.createEvent('MouseEvents'); | |
simulatedEvent._simulated = true; | |
e.target._simulatedClick = true; | |
simulatedEvent.initMouseEvent( | |
type, true, true, window, 1, | |
e.screenX, e.screenY, | |
e.clientX, e.clientY, | |
false, false, false, false, 0, null); | |
e.target.dispatchEvent(simulatedEvent); | |
} | |
}); | |
if (L.Browser.touch && !L.Browser.pointer) { | |
L.Map.addInitHook('addHandler', 'tap', L.Map.Tap); | |
} | |
/* | |
* L.Handler.ShiftDragZoom is used to add shift-drag zoom interaction to the map | |
* (zoom to a selected bounding box), enabled by default. | |
*/ | |
L.Map.mergeOptions({ | |
boxZoom: true | |
}); | |
L.Map.BoxZoom = L.Handler.extend({ | |
initialize: function (map) { | |
this._map = map; | |
this._container = map._container; | |
this._pane = map._panes.overlayPane; | |
this._moved = false; | |
}, | |
addHooks: function () { | |
L.DomEvent.on(this._container, 'mousedown', this._onMouseDown, this); | |
}, | |
removeHooks: function () { | |
L.DomEvent.off(this._container, 'mousedown', this._onMouseDown); | |
this._moved = false; | |
}, | |
moved: function () { | |
return this._moved; | |
}, | |
_onMouseDown: function (e) { | |
this._moved = false; | |
if (!e.shiftKey || ((e.which !== 1) && (e.button !== 1))) { return false; } | |
L.DomUtil.disableTextSelection(); | |
L.DomUtil.disableImageDrag(); | |
this._startLayerPoint = this._map.mouseEventToLayerPoint(e); | |
L.DomEvent | |
.on(document, 'mousemove', this._onMouseMove, this) | |
.on(document, 'mouseup', this._onMouseUp, this) | |
.on(document, 'keydown', this._onKeyDown, this); | |
}, | |
_onMouseMove: function (e) { | |
if (!this._moved) { | |
this._box = L.DomUtil.create('div', 'leaflet-zoom-box', this._pane); | |
L.DomUtil.setPosition(this._box, this._startLayerPoint); | |
//TODO refactor: move cursor to styles | |
this._container.style.cursor = 'crosshair'; | |
this._map.fire('boxzoomstart'); | |
} | |
var startPoint = this._startLayerPoint, | |
box = this._box, | |
layerPoint = this._map.mouseEventToLayerPoint(e), | |
offset = layerPoint.subtract(startPoint), | |
newPos = new L.Point( | |
Math.min(layerPoint.x, startPoint.x), | |
Math.min(layerPoint.y, startPoint.y)); | |
L.DomUtil.setPosition(box, newPos); | |
this._moved = true; | |
// TODO refactor: remove hardcoded 4 pixels | |
box.style.width = (Math.max(0, Math.abs(offset.x) - 4)) + 'px'; | |
box.style.height = (Math.max(0, Math.abs(offset.y) - 4)) + 'px'; | |
}, | |
_finish: function () { | |
if (this._moved) { | |
this._pane.removeChild(this._box); | |
this._container.style.cursor = ''; | |
} | |
L.DomUtil.enableTextSelection(); | |
L.DomUtil.enableImageDrag(); | |
L.DomEvent | |
.off(document, 'mousemove', this._onMouseMove) | |
.off(document, 'mouseup', this._onMouseUp) | |
.off(document, 'keydown', this._onKeyDown); | |
}, | |
_onMouseUp: function (e) { | |
this._finish(); | |
var map = this._map, | |
layerPoint = map.mouseEventToLayerPoint(e); | |
if (this._startLayerPoint.equals(layerPoint)) { return; } | |
var bounds = new L.LatLngBounds( | |
map.layerPointToLatLng(this._startLayerPoint), | |
map.layerPointToLatLng(layerPoint)); | |
map.fitBounds(bounds); | |
map.fire('boxzoomend', { | |
boxZoomBounds: bounds | |
}); | |
}, | |
_onKeyDown: function (e) { | |
if (e.keyCode === 27) { | |
this._finish(); | |
} | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'boxZoom', L.Map.BoxZoom); | |
/* | |
* L.Map.Keyboard is handling keyboard interaction with the map, enabled by default. | |
*/ | |
L.Map.mergeOptions({ | |
keyboard: true, | |
keyboardPanOffset: 80, | |
keyboardZoomOffset: 1 | |
}); | |
L.Map.Keyboard = L.Handler.extend({ | |
keyCodes: { | |
left: [37], | |
right: [39], | |
down: [40], | |
up: [38], | |
zoomIn: [187, 107, 61, 171], | |
zoomOut: [189, 109, 173] | |
}, | |
initialize: function (map) { | |
this._map = map; | |
this._setPanOffset(map.options.keyboardPanOffset); | |
this._setZoomOffset(map.options.keyboardZoomOffset); | |
}, | |
addHooks: function () { | |
var container = this._map._container; | |
// make the container focusable by tabbing | |
if (container.tabIndex === -1) { | |
container.tabIndex = '0'; | |
} | |
L.DomEvent | |
.on(container, 'focus', this._onFocus, this) | |
.on(container, 'blur', this._onBlur, this) | |
.on(container, 'mousedown', this._onMouseDown, this); | |
this._map | |
.on('focus', this._addHooks, this) | |
.on('blur', this._removeHooks, this); | |
}, | |
removeHooks: function () { | |
this._removeHooks(); | |
var container = this._map._container; | |
L.DomEvent | |
.off(container, 'focus', this._onFocus, this) | |
.off(container, 'blur', this._onBlur, this) | |
.off(container, 'mousedown', this._onMouseDown, this); | |
this._map | |
.off('focus', this._addHooks, this) | |
.off('blur', this._removeHooks, this); | |
}, | |
_onMouseDown: function () { | |
if (this._focused) { return; } | |
var body = document.body, | |
docEl = document.documentElement, | |
top = body.scrollTop || docEl.scrollTop, | |
left = body.scrollLeft || docEl.scrollLeft; | |
this._map._container.focus(); | |
window.scrollTo(left, top); | |
}, | |
_onFocus: function () { | |
this._focused = true; | |
this._map.fire('focus'); | |
}, | |
_onBlur: function () { | |
this._focused = false; | |
this._map.fire('blur'); | |
}, | |
_setPanOffset: function (pan) { | |
var keys = this._panKeys = {}, | |
codes = this.keyCodes, | |
i, len; | |
for (i = 0, len = codes.left.length; i < len; i++) { | |
keys[codes.left[i]] = [-1 * pan, 0]; | |
} | |
for (i = 0, len = codes.right.length; i < len; i++) { | |
keys[codes.right[i]] = [pan, 0]; | |
} | |
for (i = 0, len = codes.down.length; i < len; i++) { | |
keys[codes.down[i]] = [0, pan]; | |
} | |
for (i = 0, len = codes.up.length; i < len; i++) { | |
keys[codes.up[i]] = [0, -1 * pan]; | |
} | |
}, | |
_setZoomOffset: function (zoom) { | |
var keys = this._zoomKeys = {}, | |
codes = this.keyCodes, | |
i, len; | |
for (i = 0, len = codes.zoomIn.length; i < len; i++) { | |
keys[codes.zoomIn[i]] = zoom; | |
} | |
for (i = 0, len = codes.zoomOut.length; i < len; i++) { | |
keys[codes.zoomOut[i]] = -zoom; | |
} | |
}, | |
_addHooks: function () { | |
L.DomEvent.on(document, 'keydown', this._onKeyDown, this); | |
}, | |
_removeHooks: function () { | |
L.DomEvent.off(document, 'keydown', this._onKeyDown, this); | |
}, | |
_onKeyDown: function (e) { | |
var key = e.keyCode, | |
map = this._map; | |
if (key in this._panKeys) { | |
if (map._panAnim && map._panAnim._inProgress) { return; } | |
map.panBy(this._panKeys[key]); | |
if (map.options.maxBounds) { | |
map.panInsideBounds(map.options.maxBounds); | |
} | |
} else if (key in this._zoomKeys) { | |
map.setZoom(map.getZoom() + this._zoomKeys[key]); | |
} else { | |
return; | |
} | |
L.DomEvent.stop(e); | |
} | |
}); | |
L.Map.addInitHook('addHandler', 'keyboard', L.Map.Keyboard); | |
/* | |
* L.Handler.MarkerDrag is used internally by L.Marker to make the markers draggable. | |
*/ | |
L.Handler.MarkerDrag = L.Handler.extend({ | |
initialize: function (marker) { | |
this._marker = marker; | |
}, | |
addHooks: function () { | |
var icon = this._marker._icon; | |
if (!this._draggable) { | |
this._draggable = new L.Draggable(icon, icon); | |
} | |
this._draggable | |
.on('dragstart', this._onDragStart, this) | |
.on('drag', this._onDrag, this) | |
.on('dragend', this._onDragEnd, this); | |
this._draggable.enable(); | |
L.DomUtil.addClass(this._marker._icon, 'leaflet-marker-draggable'); | |
}, | |
removeHooks: function () { | |
this._draggable | |
.off('dragstart', this._onDragStart, this) | |
.off('drag', this._onDrag, this) | |
.off('dragend', this._onDragEnd, this); | |
this._draggable.disable(); | |
L.DomUtil.removeClass(this._marker._icon, 'leaflet-marker-draggable'); | |
}, | |
moved: function () { | |
return this._draggable && this._draggable._moved; | |
}, | |
_onDragStart: function () { | |
this._marker | |
.closePopup() | |
.fire('movestart') | |
.fire('dragstart'); | |
}, | |
_onDrag: function () { | |
var marker = this._marker, | |
shadow = marker._shadow, | |
iconPos = L.DomUtil.getPosition(marker._icon), | |
latlng = marker._map.layerPointToLatLng(iconPos); | |
// update shadow position | |
if (shadow) { | |
L.DomUtil.setPosition(shadow, iconPos); | |
} | |
marker._latlng = latlng; | |
marker | |
.fire('move', {latlng: latlng}) | |
.fire('drag'); | |
}, | |
_onDragEnd: function (e) { | |
this._marker | |
.fire('moveend') | |
.fire('dragend', e); | |
} | |
}); | |
/* | |
* L.Control is a base class for implementing map controls. Handles positioning. | |
* All other controls extend from this class. | |
*/ | |
L.Control = L.Class.extend({ | |
options: { | |
position: 'topright' | |
}, | |
initialize: function (options) { | |
L.setOptions(this, options); | |
}, | |
getPosition: function () { | |
return this.options.position; | |
}, | |
setPosition: function (position) { | |
var map = this._map; | |
if (map) { | |
map.removeControl(this); | |
} | |
this.options.position = position; | |
if (map) { | |
map.addControl(this); | |
} | |
return this; | |
}, | |
getContainer: function () { | |
return this._container; | |
}, | |
addTo: function (map) { | |
this._map = map; | |
var container = this._container = this.onAdd(map), | |
pos = this.getPosition(), | |
corner = map._controlCorners[pos]; | |
L.DomUtil.addClass(container, 'leaflet-control'); | |
if (pos.indexOf('bottom') !== -1) { | |
corner.insertBefore(container, corner.firstChild); | |
} else { | |
corner.appendChild(container); | |
} | |
return this; | |
}, | |
removeFrom: function (map) { | |
var pos = this.getPosition(), | |
corner = map._controlCorners[pos]; | |
corner.removeChild(this._container); | |
this._map = null; | |
if (this.onRemove) { | |
this.onRemove(map); | |
} | |
return this; | |
}, | |
_refocusOnMap: function () { | |
if (this._map) { | |
this._map.getContainer().focus(); | |
} | |
} | |
}); | |
L.control = function (options) { | |
return new L.Control(options); | |
}; | |
// adds control-related methods to L.Map | |
L.Map.include({ | |
addControl: function (control) { | |
control.addTo(this); | |
return this; | |
}, | |
removeControl: function (control) { | |
control.removeFrom(this); | |
return this; | |
}, | |
_initControlPos: function () { | |
var corners = this._controlCorners = {}, | |
l = 'leaflet-', | |
container = this._controlContainer = | |
L.DomUtil.create('div', l + 'control-container', this._container); | |
function createCorner(vSide, hSide) { | |
var className = l + vSide + ' ' + l + hSide; | |
corners[vSide + hSide] = L.DomUtil.create('div', className, container); | |
} | |
createCorner('top', 'left'); | |
createCorner('top', 'right'); | |
createCorner('bottom', 'left'); | |
createCorner('bottom', 'right'); | |
}, | |
_clearControlPos: function () { | |
this._container.removeChild(this._controlContainer); | |
} | |
}); | |
/* | |
* L.Control.Zoom is used for the default zoom buttons on the map. | |
*/ | |
L.Control.Zoom = L.Control.extend({ | |
options: { | |
position: 'topleft', | |
zoomInText: '+', | |
zoomInTitle: 'Zoom in', | |
zoomOutText: '-', | |
zoomOutTitle: 'Zoom out' | |
}, | |
onAdd: function (map) { | |
var zoomName = 'leaflet-control-zoom', | |
container = L.DomUtil.create('div', zoomName + ' leaflet-bar'); | |
this._map = map; | |
this._zoomInButton = this._createButton( | |
this.options.zoomInText, this.options.zoomInTitle, | |
zoomName + '-in', container, this._zoomIn, this); | |
this._zoomOutButton = this._createButton( | |
this.options.zoomOutText, this.options.zoomOutTitle, | |
zoomName + '-out', container, this._zoomOut, this); | |
this._updateDisabled(); | |
map.on('zoomend zoomlevelschange', this._updateDisabled, this); | |
return container; | |
}, | |
onRemove: function (map) { | |
map.off('zoomend zoomlevelschange', this._updateDisabled, this); | |
}, | |
_zoomIn: function (e) { | |
this._map.zoomIn(e.shiftKey ? 3 : 1); | |
}, | |
_zoomOut: function (e) { | |
this._map.zoomOut(e.shiftKey ? 3 : 1); | |
}, | |
_createButton: function (html, title, className, container, fn, context) { | |
var link = L.DomUtil.create('a', className, container); | |
link.innerHTML = html; | |
link.href = '#'; | |
link.title = title; | |
var stop = L.DomEvent.stopPropagation; | |
L.DomEvent | |
.on(link, 'click', stop) | |
.on(link, 'mousedown', stop) | |
.on(link, 'dblclick', stop) | |
.on(link, 'click', L.DomEvent.preventDefault) | |
.on(link, 'click', fn, context) | |
.on(link, 'click', this._refocusOnMap, context); | |
return link; | |
}, | |
_updateDisabled: function () { | |
var map = this._map, | |
className = 'leaflet-disabled'; | |
L.DomUtil.removeClass(this._zoomInButton, className); | |
L.DomUtil.removeClass(this._zoomOutButton, className); | |
if (map._zoom === map.getMinZoom()) { | |
L.DomUtil.addClass(this._zoomOutButton, className); | |
} | |
if (map._zoom === map.getMaxZoom()) { | |
L.DomUtil.addClass(this._zoomInButton, className); | |
} | |
} | |
}); | |
L.Map.mergeOptions({ | |
zoomControl: true | |
}); | |
L.Map.addInitHook(function () { | |
if (this.options.zoomControl) { | |
this.zoomControl = new L.Control.Zoom(); | |
this.addControl(this.zoomControl); | |
} | |
}); | |
L.control.zoom = function (options) { | |
return new L.Control.Zoom(options); | |
}; | |
/* | |
* L.Control.Attribution is used for displaying attribution on the map (added by default). | |
*/ | |
L.Control.Attribution = L.Control.extend({ | |
options: { | |
position: 'bottomright', | |
prefix: '<a href="http://leafletjs.com" title="A JS library for interactive maps">Leaflet</a>' | |
}, | |
initialize: function (options) { | |
L.setOptions(this, options); | |
this._attributions = {}; | |
}, | |
onAdd: function (map) { | |
this._container = L.DomUtil.create('div', 'leaflet-control-attribution'); | |
L.DomEvent.disableClickPropagation(this._container); | |
for (var i in map._layers) { | |
if (map._layers[i].getAttribution) { | |
this.addAttribution(map._layers[i].getAttribution()); | |
} | |
} | |
map | |
.on('layeradd', this._onLayerAdd, this) | |
.on('layerremove', this._onLayerRemove, this); | |
this._update(); | |
return this._container; | |
}, | |
onRemove: function (map) { | |
map | |
.off('layeradd', this._onLayerAdd) | |
.off('layerremove', this._onLayerRemove); | |
}, | |
setPrefix: function (prefix) { | |
this.options.prefix = prefix; | |
this._update(); | |
return this; | |
}, | |
addAttribution: function (text) { | |
if (!text) { return; } | |
if (!this._attributions[text]) { | |
this._attributions[text] = 0; | |
} | |
this._attributions[text]++; | |
this._update(); | |
return this; | |
}, | |
removeAttribution: function (text) { | |
if (!text) { return; } | |
if (this._attributions[text]) { | |
this._attributions[text]--; | |
this._update(); | |
} | |
return this; | |
}, | |
_update: function () { | |
if (!this._map) { return; } | |
var attribs = []; | |
for (var i in this._attributions) { | |
if (this._attributions[i]) { | |
attribs.push(i); | |
} | |
} | |
var prefixAndAttribs = []; | |
if (this.options.prefix) { | |
prefixAndAttribs.push(this.options.prefix); | |
} | |
if (attribs.length) { | |
prefixAndAttribs.push(attribs.join(', ')); | |
} | |
this._container.innerHTML = prefixAndAttribs.join(' | '); | |
}, | |
_onLayerAdd: function (e) { | |
if (e.layer.getAttribution) { | |
this.addAttribution(e.layer.getAttribution()); | |
} | |
}, | |
_onLayerRemove: function (e) { | |
if (e.layer.getAttribution) { | |
this.removeAttribution(e.layer.getAttribution()); | |
} | |
} | |
}); | |
L.Map.mergeOptions({ | |
attributionControl: true | |
}); | |
L.Map.addInitHook(function () { | |
if (this.options.attributionControl) { | |
this.attributionControl = (new L.Control.Attribution()).addTo(this); | |
} | |
}); | |
L.control.attribution = function (options) { | |
return new L.Control.Attribution(options); | |
}; | |
/* | |
* L.Control.Scale is used for displaying metric/imperial scale on the map. | |
*/ | |
L.Control.Scale = L.Control.extend({ | |
options: { | |
position: 'bottomleft', | |
maxWidth: 100, | |
metric: true, | |
imperial: true, | |
updateWhenIdle: false | |
}, | |
onAdd: function (map) { | |
this._map = map; | |
var className = 'leaflet-control-scale', | |
container = L.DomUtil.create('div', className), | |
options = this.options; | |
this._addScales(options, className, container); | |
map.on(options.updateWhenIdle ? 'moveend' : 'move', this._update, this); | |
map.whenReady(this._update, this); | |
return container; | |
}, | |
onRemove: function (map) { | |
map.off(this.options.updateWhenIdle ? 'moveend' : 'move', this._update, this); | |
}, | |
_addScales: function (options, className, container) { | |
if (options.metric) { | |
this._mScale = L.DomUtil.create('div', className + '-line', container); | |
} | |
if (options.imperial) { | |
this._iScale = L.DomUtil.create('div', className + '-line', container); | |
} | |
}, | |
_update: function () { | |
var bounds = this._map.getBounds(), | |
centerLat = bounds.getCenter().lat, | |
halfWorldMeters = 6378137 * Math.PI * Math.cos(centerLat * Math.PI / 180), | |
dist = halfWorldMeters * (bounds.getNorthEast().lng - bounds.getSouthWest().lng) / 180, | |
size = this._map.getSize(), | |
options = this.options, | |
maxMeters = 0; | |
if (size.x > 0) { | |
maxMeters = dist * (options.maxWidth / size.x); | |
} | |
this._updateScales(options, maxMeters); | |
}, | |
_updateScales: function (options, maxMeters) { | |
if (options.metric && maxMeters) { | |
this._updateMetric(maxMeters); | |
} | |
if (options.imperial && maxMeters) { | |
this._updateImperial(maxMeters); | |
} | |
}, | |
_updateMetric: function (maxMeters) { | |
var meters = this._getRoundNum(maxMeters); | |
this._mScale.style.width = this._getScaleWidth(meters / maxMeters) + 'px'; | |
this._mScale.innerHTML = meters < 1000 ? meters + ' m' : (meters / 1000) + ' km'; | |
}, | |
_updateImperial: function (maxMeters) { | |
var maxFeet = maxMeters * 3.2808399, | |
scale = this._iScale, | |
maxMiles, miles, feet; | |
if (maxFeet > 5280) { | |
maxMiles = maxFeet / 5280; | |
miles = this._getRoundNum(maxMiles); | |
scale.style.width = this._getScaleWidth(miles / maxMiles) + 'px'; | |
scale.innerHTML = miles + ' mi'; | |
} else { | |
feet = this._getRoundNum(maxFeet); | |
scale.style.width = this._getScaleWidth(feet / maxFeet) + 'px'; | |
scale.innerHTML = feet + ' ft'; | |
} | |
}, | |
_getScaleWidth: function (ratio) { | |
return Math.round(this.options.maxWidth * ratio) - 10; | |
}, | |
_getRoundNum: function (num) { | |
var pow10 = Math.pow(10, (Math.floor(num) + '').length - 1), | |
d = num / pow10; | |
d = d >= 10 ? 10 : d >= 5 ? 5 : d >= 3 ? 3 : d >= 2 ? 2 : 1; | |
return pow10 * d; | |
} | |
}); | |
L.control.scale = function (options) { | |
return new L.Control.Scale(options); | |
}; | |
/* | |
* L.Control.Layers is a control to allow users to switch between different layers on the map. | |
*/ | |
L.Control.Layers = L.Control.extend({ | |
options: { | |
collapsed: true, | |
position: 'topright', | |
autoZIndex: true | |
}, | |
initialize: function (baseLayers, overlays, options) { | |
L.setOptions(this, options); | |
this._layers = {}; | |
this._lastZIndex = 0; | |
this._handlingClick = false; | |
for (var i in baseLayers) { | |
this._addLayer(baseLayers[i], i); | |
} | |
for (i in overlays) { | |
this._addLayer(overlays[i], i, true); | |
} | |
}, | |
onAdd: function (map) { | |
this._initLayout(); | |
this._update(); | |
map | |
.on('layeradd', this._onLayerChange, this) | |
.on('layerremove', this._onLayerChange, this); | |
return this._container; | |
}, | |
onRemove: function (map) { | |
map | |
.off('layeradd', this._onLayerChange, this) | |
.off('layerremove', this._onLayerChange, this); | |
}, | |
addBaseLayer: function (layer, name) { | |
this._addLayer(layer, name); | |
this._update(); | |
return this; | |
}, | |
addOverlay: function (layer, name) { | |
this._addLayer(layer, name, true); | |
this._update(); | |
return this; | |
}, | |
removeLayer: function (layer) { | |
var id = L.stamp(layer); | |
delete this._layers[id]; | |
this._update(); | |
return this; | |
}, | |
_initLayout: function () { | |
var className = 'leaflet-control-layers', | |
container = this._container = L.DomUtil.create('div', className); | |
//Makes this work on IE10 Touch devices by stopping it from firing a mouseout event when the touch is released | |
container.setAttribute('aria-haspopup', true); | |
if (!L.Browser.touch) { | |
L.DomEvent | |
.disableClickPropagation(container) | |
.disableScrollPropagation(container); | |
} else { | |
L.DomEvent.on(container, 'click', L.DomEvent.stopPropagation); | |
} | |
var form = this._form = L.DomUtil.create('form', className + '-list'); | |
if (this.options.collapsed) { | |
if (!L.Browser.android) { | |
L.DomEvent | |
.on(container, 'mouseover', this._expand, this) | |
.on(container, 'mouseout', this._collapse, this); | |
} | |
var link = this._layersLink = L.DomUtil.create('a', className + '-toggle', container); | |
link.href = '#'; | |
link.title = 'Layers'; | |
if (L.Browser.touch) { | |
L.DomEvent | |
.on(link, 'click', L.DomEvent.stop) | |
.on(link, 'click', this._expand, this); | |
} | |
else { | |
L.DomEvent.on(link, 'focus', this._expand, this); | |
} | |
//Work around for Firefox android issue https://github.com/Leaflet/Leaflet/issues/2033 | |
L.DomEvent.on(form, 'click', function () { | |
setTimeout(L.bind(this._onInputClick, this), 0); | |
}, this); | |
this._map.on('click', this._collapse, this); | |
// TODO keyboard accessibility | |
} else { | |
this._expand(); | |
} | |
this._baseLayersList = L.DomUtil.create('div', className + '-base', form); | |
this._separator = L.DomUtil.create('div', className + '-separator', form); | |
this._overlaysList = L.DomUtil.create('div', className + '-overlays', form); | |
container.appendChild(form); | |
}, | |
_addLayer: function (layer, name, overlay) { | |
var id = L.stamp(layer); | |
this._layers[id] = { | |
layer: layer, | |
name: name, | |
overlay: overlay | |
}; | |
if (this.options.autoZIndex && layer.setZIndex) { | |
this._lastZIndex++; | |
layer.setZIndex(this._lastZIndex); | |
} | |
}, | |
_update: function () { | |
if (!this._container) { | |
return; | |
} | |
this._baseLayersList.innerHTML = ''; | |
this._overlaysList.innerHTML = ''; | |
var baseLayersPresent = false, | |
overlaysPresent = false, | |
i, obj; | |
for (i in this._layers) { | |
obj = this._layers[i]; | |
this._addItem(obj); | |
overlaysPresent = overlaysPresent || obj.overlay; | |
baseLayersPresent = baseLayersPresent || !obj.overlay; | |
} | |
this._separator.style.display = overlaysPresent && baseLayersPresent ? '' : 'none'; | |
}, | |
_onLayerChange: function (e) { | |
var obj = this._layers[L.stamp(e.layer)]; | |
if (!obj) { return; } | |
if (!this._handlingClick) { | |
this._update(); | |
} | |
var type = obj.overlay ? | |
(e.type === 'layeradd' ? 'overlayadd' : 'overlayremove') : | |
(e.type === 'layeradd' ? 'baselayerchange' : null); | |
if (type) { | |
this._map.fire(type, obj); | |
} | |
}, | |
// IE7 bugs out if you create a radio dynamically, so you have to do it this hacky way (see http://bit.ly/PqYLBe) | |
_createRadioElement: function (name, checked) { | |
var radioHtml = '<input type="radio" class="leaflet-control-layers-selector" name="' + name + '"'; | |
if (checked) { | |
radioHtml += ' checked="checked"'; | |
} | |
radioHtml += '/>'; | |
var radioFragment = document.createElement('div'); | |
radioFragment.innerHTML = radioHtml; | |
return radioFragment.firstChild; | |
}, | |
_addItem: function (obj) { | |
var label = document.createElement('label'), | |
input, | |
checked = this._map.hasLayer(obj.layer); | |
if (obj.overlay) { | |
input = document.createElement('input'); | |
input.type = 'checkbox'; | |
input.className = 'leaflet-control-layers-selector'; | |
input.defaultChecked = checked; | |
} else { | |
input = this._createRadioElement('leaflet-base-layers', checked); | |
} | |
input.layerId = L.stamp(obj.layer); | |
L.DomEvent.on(input, 'click', this._onInputClick, this); | |
var name = document.createElement('span'); | |
name.innerHTML = ' ' + obj.name; | |
label.appendChild(input); | |
label.appendChild(name); | |
var container = obj.overlay ? this._overlaysList : this._baseLayersList; | |
container.appendChild(label); | |
return label; | |
}, | |
_onInputClick: function () { | |
var i, input, obj, | |
inputs = this._form.getElementsByTagName('input'), | |
inputsLen = inputs.length; | |
this._handlingClick = true; | |
for (i = 0; i < inputsLen; i++) { | |
input = inputs[i]; | |
obj = this._layers[input.layerId]; | |
if (input.checked && !this._map.hasLayer(obj.layer)) { | |
this._map.addLayer(obj.layer); | |
} else if (!input.checked && this._map.hasLayer(obj.layer)) { | |
this._map.removeLayer(obj.layer); | |
} | |
} | |
this._handlingClick = false; | |
this._refocusOnMap(); | |
}, | |
_expand: function () { | |
L.DomUtil.addClass(this._container, 'leaflet-control-layers-expanded'); | |
}, | |
_collapse: function () { | |
this._container.className = this._container.className.replace(' leaflet-control-layers-expanded', ''); | |
} | |
}); | |
L.control.layers = function (baseLayers, overlays, options) { | |
return new L.Control.Layers(baseLayers, overlays, options); | |
}; | |
/* | |
* L.PosAnimation is used by Leaflet internally for pan animations. | |
*/ | |
L.PosAnimation = L.Class.extend({ | |
includes: L.Mixin.Events, | |
run: function (el, newPos, duration, easeLinearity) { // (HTMLElement, Point[, Number, Number]) | |
this.stop(); | |
this._el = el; | |
this._inProgress = true; | |
this._newPos = newPos; | |
this.fire('start'); | |
el.style[L.DomUtil.TRANSITION] = 'all ' + (duration || 0.25) + | |
's cubic-bezier(0,0,' + (easeLinearity || 0.5) + ',1)'; | |
L.DomEvent.on(el, L.DomUtil.TRANSITION_END, this._onTransitionEnd, this); | |
L.DomUtil.setPosition(el, newPos); | |
// toggle reflow, Chrome flickers for some reason if you don't do this | |
L.Util.falseFn(el.offsetWidth); | |
// there's no native way to track value updates of transitioned properties, so we imitate this | |
this._stepTimer = setInterval(L.bind(this._onStep, this), 50); | |
}, | |
stop: function () { | |
if (!this._inProgress) { return; } | |
// if we just removed the transition property, the element would jump to its final position, | |
// so we need to make it stay at the current position | |
L.DomUtil.setPosition(this._el, this._getPos()); | |
this._onTransitionEnd(); | |
L.Util.falseFn(this._el.offsetWidth); // force reflow in case we are about to start a new animation | |
}, | |
_onStep: function () { | |
var stepPos = this._getPos(); | |
if (!stepPos) { | |
this._onTransitionEnd(); | |
return; | |
} | |
// jshint camelcase: false | |
// make L.DomUtil.getPosition return intermediate position value during animation | |
this._el._leaflet_pos = stepPos; | |
this.fire('step'); | |
}, | |
// you can't easily get intermediate values of properties animated with CSS3 Transitions, | |
// we need to parse computed style (in case of transform it returns matrix string) | |
_transformRe: /([-+]?(?:\d*\.)?\d+)\D*, ([-+]?(?:\d*\.)?\d+)\D*\)/, | |
_getPos: function () { | |
var left, top, matches, | |
el = this._el, | |
style = window.getComputedStyle(el); | |
if (L.Browser.any3d) { | |
matches = style[L.DomUtil.TRANSFORM].match(this._transformRe); | |
if (!matches) { return; } | |
left = parseFloat(matches[1]); | |
top = parseFloat(matches[2]); | |
} else { | |
left = parseFloat(style.left); | |
top = parseFloat(style.top); | |
} | |
return new L.Point(left, top, true); | |
}, | |
_onTransitionEnd: function () { | |
L.DomEvent.off(this._el, L.DomUtil.TRANSITION_END, this._onTransitionEnd, this); | |
if (!this._inProgress) { return; } | |
this._inProgress = false; | |
this._el.style[L.DomUtil.TRANSITION] = ''; | |
// jshint camelcase: false | |
// make sure L.DomUtil.getPosition returns the final position value after animation | |
this._el._leaflet_pos = this._newPos; | |
clearInterval(this._stepTimer); | |
this.fire('step').fire('end'); | |
} | |
}); | |
/* | |
* Extends L.Map to handle panning animations. | |
*/ | |
L.Map.include({ | |
setView: function (center, zoom, options) { | |
zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom); | |
center = this._limitCenter(L.latLng(center), zoom, this.options.maxBounds); | |
options = options || {}; | |
if (this._panAnim) { | |
this._panAnim.stop(); | |
} | |
if (this._loaded && !options.reset && options !== true) { | |
if (options.animate !== undefined) { | |
options.zoom = L.extend({animate: options.animate}, options.zoom); | |
options.pan = L.extend({animate: options.animate}, options.pan); | |
} | |
// try animating pan or zoom | |
var animated = (this._zoom !== zoom) ? | |
this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) : | |
this._tryAnimatedPan(center, options.pan); | |
if (animated) { | |
// prevent resize handler call, the view will refresh after animation anyway | |
clearTimeout(this._sizeTimer); | |
return this; | |
} | |
} | |
// animation didn't start, just reset the map view | |
this._resetView(center, zoom); | |
return this; | |
}, | |
panBy: function (offset, options) { | |
offset = L.point(offset).round(); | |
options = options || {}; | |
if (!offset.x && !offset.y) { | |
return this; | |
} | |
if (!this._panAnim) { | |
this._panAnim = new L.PosAnimation(); | |
this._panAnim.on({ | |
'step': this._onPanTransitionStep, | |
'end': this._onPanTransitionEnd | |
}, this); | |
} | |
// don't fire movestart if animating inertia | |
if (!options.noMoveStart) { | |
this.fire('movestart'); | |
} | |
// animate pan unless animate: false specified | |
if (options.animate !== false) { | |
L.DomUtil.addClass(this._mapPane, 'leaflet-pan-anim'); | |
var newPos = this._getMapPanePos().subtract(offset); | |
this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity); | |
} else { | |
this._rawPanBy(offset); | |
this.fire('move').fire('moveend'); | |
} | |
return this; | |
}, | |
_onPanTransitionStep: function () { | |
this.fire('move'); | |
}, | |
_onPanTransitionEnd: function () { | |
L.DomUtil.removeClass(this._mapPane, 'leaflet-pan-anim'); | |
this.fire('moveend'); | |
}, | |
_tryAnimatedPan: function (center, options) { | |
// difference between the new and current centers in pixels | |
var offset = this._getCenterOffset(center)._floor(); | |
// don't animate too far unless animate: true specified in options | |
if ((options && options.animate) !== true && !this.getSize().contains(offset)) { return false; } | |
this.panBy(offset, options); | |
return true; | |
} | |
}); | |
/* | |
* L.PosAnimation fallback implementation that powers Leaflet pan animations | |
* in browsers that don't support CSS3 Transitions. | |
*/ | |
L.PosAnimation = L.DomUtil.TRANSITION ? L.PosAnimation : L.PosAnimation.extend({ | |
run: function (el, newPos, duration, easeLinearity) { // (HTMLElement, Point[, Number, Number]) | |
this.stop(); | |
this._el = el; | |
this._inProgress = true; | |
this._duration = duration || 0.25; | |
this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2); | |
this._startPos = L.DomUtil.getPosition(el); | |
this._offset = newPos.subtract(this._startPos); | |
this._startTime = +new Date(); | |
this.fire('start'); | |
this._animate(); | |
}, | |
stop: function () { | |
if (!this._inProgress) { return; } | |
this._step(); | |
this._complete(); | |
}, | |
_animate: function () { | |
// animation loop | |
this._animId = L.Util.requestAnimFrame(this._animate, this); | |
this._step(); | |
}, | |
_step: function () { | |
var elapsed = (+new Date()) - this._startTime, | |
duration = this._duration * 1000; | |
if (elapsed < duration) { | |
this._runFrame(this._easeOut(elapsed / duration)); | |
} else { | |
this._runFrame(1); | |
this._complete(); | |
} | |
}, | |
_runFrame: function (progress) { | |
var pos = this._startPos.add(this._offset.multiplyBy(progress)); | |
L.DomUtil.setPosition(this._el, pos); | |
this.fire('step'); | |
}, | |
_complete: function () { | |
L.Util.cancelAnimFrame(this._animId); | |
this._inProgress = false; | |
this.fire('end'); | |
}, | |
_easeOut: function (t) { | |
return 1 - Math.pow(1 - t, this._easeOutPower); | |
} | |
}); | |
/* | |
* Extends L.Map to handle zoom animations. | |
*/ | |
L.Map.mergeOptions({ | |
zoomAnimation: true, | |
zoomAnimationThreshold: 4 | |
}); | |
if (L.DomUtil.TRANSITION) { | |
L.Map.addInitHook(function () { | |
// don't animate on browsers without hardware-accelerated transitions or old Android/Opera | |
this._zoomAnimated = this.options.zoomAnimation && L.DomUtil.TRANSITION && | |
L.Browser.any3d && !L.Browser.android23 && !L.Browser.mobileOpera; | |
// zoom transitions run with the same duration for all layers, so if one of transitionend events | |
// happens after starting zoom animation (propagating to the map pane), we know that it ended globally | |
if (this._zoomAnimated) { | |
L.DomEvent.on(this._mapPane, L.DomUtil.TRANSITION_END, this._catchTransitionEnd, this); | |
} | |
}); | |
} | |
L.Map.include(!L.DomUtil.TRANSITION ? {} : { | |
_catchTransitionEnd: function (e) { | |
if (this._animatingZoom && e.propertyName.indexOf('transform') >= 0) { | |
this._onZoomTransitionEnd(); | |
} | |
}, | |
_nothingToAnimate: function () { | |
return !this._container.getElementsByClassName('leaflet-zoom-animated').length; | |
}, | |
_tryAnimatedZoom: function (center, zoom, options) { | |
if (this._animatingZoom) { return true; } | |
options = options || {}; | |
// don't animate if disabled, not supported or zoom difference is too large | |
if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() || | |
Math.abs(zoom - this._zoom) > this.options.zoomAnimationThreshold) { return false; } | |
// offset is the pixel coords of the zoom origin relative to the current center | |
var scale = this.getZoomScale(zoom), | |
offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale), | |
origin = this._getCenterLayerPoint()._add(offset); | |
// don't animate if the zoom origin isn't within one screen from the current center, unless forced | |
if (options.animate !== true && !this.getSize().contains(offset)) { return false; } | |
this | |
.fire('movestart') | |
.fire('zoomstart'); | |
this._animateZoom(center, zoom, origin, scale, null, true); | |
return true; | |
}, | |
_animateZoom: function (center, zoom, origin, scale, delta, backwards, forTouchZoom) { | |
if (!forTouchZoom) { | |
this._animatingZoom = true; | |
} | |
// put transform transition on all layers with leaflet-zoom-animated class | |
L.DomUtil.addClass(this._mapPane, 'leaflet-zoom-anim'); | |
// remember what center/zoom to set after animation | |
this._animateToCenter = center; | |
this._animateToZoom = zoom; | |
// disable any dragging during animation | |
if (L.Draggable) { | |
L.Draggable._disabled = true; | |
} | |
L.Util.requestAnimFrame(function () { | |
this.fire('zoomanim', { | |
center: center, | |
zoom: zoom, | |
origin: origin, | |
scale: scale, | |
delta: delta, | |
backwards: backwards | |
}); | |
// horrible hack to work around a Chrome bug https://github.com/Leaflet/Leaflet/issues/3689 | |
setTimeout(L.bind(this._onZoomTransitionEnd, this), 250); | |
}, this); | |
}, | |
_onZoomTransitionEnd: function () { | |
if (!this._animatingZoom) { return; } | |
this._animatingZoom = false; | |
L.DomUtil.removeClass(this._mapPane, 'leaflet-zoom-anim'); | |
L.Util.requestAnimFrame(function () { | |
this._resetView(this._animateToCenter, this._animateToZoom, true, true); | |
if (L.Draggable) { | |
L.Draggable._disabled = false; | |
} | |
}, this); | |
} | |
}); | |
/* | |
Zoom animation logic for L.TileLayer. | |
*/ | |
L.TileLayer.include({ | |
_animateZoom: function (e) { | |
if (!this._animating) { | |
this._animating = true; | |
this._prepareBgBuffer(); | |
} | |
var bg = this._bgBuffer, | |
transform = L.DomUtil.TRANSFORM, | |
initialTransform = e.delta ? L.DomUtil.getTranslateString(e.delta) : bg.style[transform], | |
scaleStr = L.DomUtil.getScaleString(e.scale, e.origin); | |
bg.style[transform] = e.backwards ? | |
scaleStr + ' ' + initialTransform : | |
initialTransform + ' ' + scaleStr; | |
}, | |
_endZoomAnim: function () { | |
var front = this._tileContainer, | |
bg = this._bgBuffer; | |
front.style.visibility = ''; | |
front.parentNode.appendChild(front); // Bring to fore | |
// force reflow | |
L.Util.falseFn(bg.offsetWidth); | |
var zoom = this._map.getZoom(); | |
if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { | |
this._clearBgBuffer(); | |
} | |
this._animating = false; | |
}, | |
_clearBgBuffer: function () { | |
var map = this._map; | |
if (map && !map._animatingZoom && !map.touchZoom._zooming) { | |
this._bgBuffer.innerHTML = ''; | |
this._bgBuffer.style[L.DomUtil.TRANSFORM] = ''; | |
} | |
}, | |
_prepareBgBuffer: function () { | |
var front = this._tileContainer, | |
bg = this._bgBuffer; | |
// if foreground layer doesn't have many tiles but bg layer does, | |
// keep the existing bg layer and just zoom it some more | |
var bgLoaded = this._getLoadedTilesPercentage(bg), | |
frontLoaded = this._getLoadedTilesPercentage(front); | |
if (bg && bgLoaded > 0.5 && frontLoaded < 0.5) { | |
front.style.visibility = 'hidden'; | |
this._stopLoadingImages(front); | |
return; | |
} | |
// prepare the buffer to become the front tile pane | |
bg.style.visibility = 'hidden'; | |
bg.style[L.DomUtil.TRANSFORM] = ''; | |
// switch out the current layer to be the new bg layer (and vice-versa) | |
this._tileContainer = bg; | |
bg = this._bgBuffer = front; | |
this._stopLoadingImages(bg); | |
//prevent bg buffer from clearing right after zoom | |
clearTimeout(this._clearBgBufferTimer); | |
}, | |
_getLoadedTilesPercentage: function (container) { | |
var tiles = container.getElementsByTagName('img'), | |
i, len, count = 0; | |
for (i = 0, len = tiles.length; i < len; i++) { | |
if (tiles[i].complete) { | |
count++; | |
} | |
} | |
return count / len; | |
}, | |
// stops loading all tiles in the background layer | |
_stopLoadingImages: function (container) { | |
var tiles = Array.prototype.slice.call(container.getElementsByTagName('img')), | |
i, len, tile; | |
for (i = 0, len = tiles.length; i < len; i++) { | |
tile = tiles[i]; | |
if (!tile.complete) { | |
tile.onload = L.Util.falseFn; | |
tile.onerror = L.Util.falseFn; | |
tile.src = L.Util.emptyImageUrl; | |
tile.parentNode.removeChild(tile); | |
} | |
} | |
} | |
}); | |
/* | |
* Provides L.Map with convenient shortcuts for using browser geolocation features. | |
*/ | |
L.Map.include({ | |
_defaultLocateOptions: { | |
watch: false, | |
setView: false, | |
maxZoom: Infinity, | |
timeout: 10000, | |
maximumAge: 0, | |
enableHighAccuracy: false | |
}, | |
locate: function (/*Object*/ options) { | |
options = this._locateOptions = L.extend(this._defaultLocateOptions, options); | |
if (!navigator.geolocation) { | |
this._handleGeolocationError({ | |
code: 0, | |
message: 'Geolocation not supported.' | |
}); | |
return this; | |
} | |
var onResponse = L.bind(this._handleGeolocationResponse, this), | |
onError = L.bind(this._handleGeolocationError, this); | |
if (options.watch) { | |
this._locationWatchId = | |
navigator.geolocation.watchPosition(onResponse, onError, options); | |
} else { | |
navigator.geolocation.getCurrentPosition(onResponse, onError, options); | |
} | |
return this; | |
}, | |
stopLocate: function () { | |
if (navigator.geolocation) { | |
navigator.geolocation.clearWatch(this._locationWatchId); | |
} | |
if (this._locateOptions) { | |
this._locateOptions.setView = false; | |
} | |
return this; | |
}, | |
_handleGeolocationError: function (error) { | |
var c = error.code, | |
message = error.message || | |
(c === 1 ? 'permission denied' : | |
(c === 2 ? 'position unavailable' : 'timeout')); | |
if (this._locateOptions.setView && !this._loaded) { | |
this.fitWorld(); | |
} | |
this.fire('locationerror', { | |
code: c, | |
message: 'Geolocation error: ' + message + '.' | |
}); | |
}, | |
_handleGeolocationResponse: function (pos) { | |
var lat = pos.coords.latitude, | |
lng = pos.coords.longitude, | |
latlng = new L.LatLng(lat, lng), | |
latAccuracy = 180 * pos.coords.accuracy / 40075017, | |
lngAccuracy = latAccuracy / Math.cos(L.LatLng.DEG_TO_RAD * lat), | |
bounds = L.latLngBounds( | |
[lat - latAccuracy, lng - lngAccuracy], | |
[lat + latAccuracy, lng + lngAccuracy]), | |
options = this._locateOptions; | |
if (options.setView) { | |
var zoom = Math.min(this.getBoundsZoom(bounds), options.maxZoom); | |
this.setView(latlng, zoom); | |
} | |
var data = { | |
latlng: latlng, | |
bounds: bounds, | |
timestamp: pos.timestamp | |
}; | |
for (var i in pos.coords) { | |
if (typeof pos.coords[i] === 'number') { | |
data[i] = pos.coords[i]; | |
} | |
} | |
this.fire('locationfound', data); | |
} | |
}); | |
}(window, document)); | |
},{}],"leaflet-component/leafletMarkerComponent":[function(require,module,exports){ | |
'use strict' | |
const L = require('leaflet'); | |
module.exports = function(fastn, component, type, settings, children) { | |
component.render = function(){ | |
L.Icon.Default.imagePath = 'markers'; | |
component.element = L.marker([ | |
component.gis_lat(), | |
component.gis_lng() | |
], { | |
clickable: true, | |
title: component.title() | |
}); | |
component.element.on('click', function(event){ | |
component.emit('click', event, component.scope()) | |
}); | |
}; | |
function updatePosition(){ | |
if(!component.element){ | |
return; | |
} | |
component.element.setLatLng([ | |
component.gis_lat(), | |
component.gis_lng() | |
]); | |
} | |
function updateTitle(){ | |
if(!component.element){ | |
return; | |
} | |
component.element.setTitle([ | |
component.title() | |
]); | |
} | |
function updateType(){ | |
if(!component.element){ | |
return; | |
} | |
component.element.setType([ | |
component.type() | |
]); | |
} | |
function updateStatus(){ | |
if(!component.element){ | |
return; | |
} | |
component.element.setStatus([ | |
component.status() | |
]); | |
} | |
fastn.property(0, 'value') | |
.addTo(component, 'gis_lat') | |
.on('change', updatePosition); | |
fastn.property(0, 'value') | |
.addTo(component, 'gis_lng') | |
.on('change', updatePosition); | |
fastn.property(0, 'value') | |
.addTo(component, 'title') | |
.on('change', updateTitle); | |
fastn.property(0, 'value') | |
.addTo(component, 'type') | |
.on('change', updateType); | |
fastn.property(0, 'value') | |
.addTo(component, 'status') | |
.on('change', updateStatus); | |
return component; | |
} | |
},{"leaflet":1}]},{},[]) | |
//# sourceMappingURL=data:application/json;base64,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 |
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment