7987 lines
227 KiB
JavaScript
7987 lines
227 KiB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.plist = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||
(function (Buffer){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var base64 = require('base64-js');
|
||
var xmlbuilder = require('xmlbuilder');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
exports.build = build;
|
||
|
||
/**
|
||
* Accepts a `Date` instance and returns an ISO date string.
|
||
*
|
||
* @param {Date} d - Date instance to serialize
|
||
* @returns {String} ISO date string representation of `d`
|
||
* @api private
|
||
*/
|
||
|
||
function ISODateString(d){
|
||
function pad(n){
|
||
return n < 10 ? '0' + n : n;
|
||
}
|
||
return d.getUTCFullYear()+'-'
|
||
+ pad(d.getUTCMonth()+1)+'-'
|
||
+ pad(d.getUTCDate())+'T'
|
||
+ pad(d.getUTCHours())+':'
|
||
+ pad(d.getUTCMinutes())+':'
|
||
+ pad(d.getUTCSeconds())+'Z';
|
||
}
|
||
|
||
/**
|
||
* Returns the internal "type" of `obj` via the
|
||
* `Object.prototype.toString()` trick.
|
||
*
|
||
* @param {Mixed} obj - any value
|
||
* @returns {String} the internal "type" name
|
||
* @api private
|
||
*/
|
||
|
||
var toString = Object.prototype.toString;
|
||
function type (obj) {
|
||
var m = toString.call(obj).match(/\[object (.*)\]/);
|
||
return m ? m[1] : m;
|
||
}
|
||
|
||
/**
|
||
* Generate an XML plist string from the input object `obj`.
|
||
*
|
||
* @param {Object} obj - the object to convert
|
||
* @param {Object} [opts] - optional options object
|
||
* @returns {String} converted plist XML string
|
||
* @api public
|
||
*/
|
||
|
||
function build (obj, opts) {
|
||
var XMLHDR = {
|
||
version: '1.0',
|
||
encoding: 'UTF-8'
|
||
};
|
||
|
||
var XMLDTD = {
|
||
pubid: '-//Apple//DTD PLIST 1.0//EN',
|
||
sysid: 'http://www.apple.com/DTDs/PropertyList-1.0.dtd'
|
||
};
|
||
|
||
var doc = xmlbuilder.create('plist');
|
||
|
||
doc.dec(XMLHDR.version, XMLHDR.encoding, XMLHDR.standalone);
|
||
doc.dtd(XMLDTD.pubid, XMLDTD.sysid);
|
||
doc.att('version', '1.0');
|
||
|
||
walk_obj(obj, doc);
|
||
|
||
if (!opts) opts = {};
|
||
// default `pretty` to `true`
|
||
opts.pretty = opts.pretty !== false;
|
||
return doc.end(opts);
|
||
}
|
||
|
||
/**
|
||
* depth first, recursive traversal of a javascript object. when complete,
|
||
* next_child contains a reference to the build XML object.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function walk_obj(next, next_child) {
|
||
var tag_type, i, prop;
|
||
var name = type(next);
|
||
|
||
if ('Undefined' == name) {
|
||
return;
|
||
} else if (Array.isArray(next)) {
|
||
next_child = next_child.ele('array');
|
||
for (i = 0; i < next.length; i++) {
|
||
walk_obj(next[i], next_child);
|
||
}
|
||
|
||
} else if (Buffer.isBuffer(next)) {
|
||
next_child.ele('data').raw(next.toString('base64'));
|
||
|
||
} else if ('Object' == name) {
|
||
next_child = next_child.ele('dict');
|
||
for (prop in next) {
|
||
if (next.hasOwnProperty(prop)) {
|
||
next_child.ele('key').txt(prop);
|
||
walk_obj(next[prop], next_child);
|
||
}
|
||
}
|
||
|
||
} else if ('Number' == name) {
|
||
// detect if this is an integer or real
|
||
// TODO: add an ability to force one way or another via a "cast"
|
||
tag_type = (next % 1 === 0) ? 'integer' : 'real';
|
||
next_child.ele(tag_type).txt(next.toString());
|
||
|
||
} else if ('Date' == name) {
|
||
next_child.ele('date').txt(ISODateString(new Date(next)));
|
||
|
||
} else if ('Boolean' == name) {
|
||
next_child.ele(next ? 'true' : 'false');
|
||
|
||
} else if ('String' == name) {
|
||
next_child.ele('string').txt(next);
|
||
|
||
} else if ('ArrayBuffer' == name) {
|
||
next_child.ele('data').raw(base64.fromByteArray(next));
|
||
|
||
} else if (next && next.buffer && 'ArrayBuffer' == type(next.buffer)) {
|
||
// a typed array
|
||
next_child.ele('data').raw(base64.fromByteArray(new Uint8Array(next.buffer), next_child));
|
||
|
||
}
|
||
}
|
||
|
||
}).call(this,{"isBuffer":require("../node_modules/is-buffer/index.js")})
|
||
},{"../node_modules/is-buffer/index.js":10,"base64-js":5,"xmlbuilder":87}],2:[function(require,module,exports){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var fs = require('fs');
|
||
var parse = require('./parse');
|
||
var deprecate = require('util-deprecate');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
exports.parseFile = deprecate(parseFile, '`parseFile()` is deprecated. ' +
|
||
'Use `parseString()` instead.');
|
||
exports.parseFileSync = deprecate(parseFileSync, '`parseFileSync()` is deprecated. ' +
|
||
'Use `parseStringSync()` instead.');
|
||
|
||
/**
|
||
* Parses file `filename` as a .plist file.
|
||
* Invokes `fn` callback function when done.
|
||
*
|
||
* @param {String} filename - name of the file to read
|
||
* @param {Function} fn - callback function
|
||
* @api public
|
||
* @deprecated use parseString() instead
|
||
*/
|
||
|
||
function parseFile (filename, fn) {
|
||
fs.readFile(filename, { encoding: 'utf8' }, onread);
|
||
function onread (err, inxml) {
|
||
if (err) return fn(err);
|
||
parse.parseString(inxml, fn);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parses file `filename` as a .plist file.
|
||
* Returns a when done.
|
||
*
|
||
* @param {String} filename - name of the file to read
|
||
* @param {Function} fn - callback function
|
||
* @api public
|
||
* @deprecated use parseStringSync() instead
|
||
*/
|
||
|
||
function parseFileSync (filename) {
|
||
var inxml = fs.readFileSync(filename, 'utf8');
|
||
return parse.parseStringSync(inxml);
|
||
}
|
||
|
||
},{"./parse":3,"fs":6,"util-deprecate":70}],3:[function(require,module,exports){
|
||
(function (Buffer){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var deprecate = require('util-deprecate');
|
||
var DOMParser = require('xmldom').DOMParser;
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
exports.parse = parse;
|
||
exports.parseString = deprecate(parseString, '`parseString()` is deprecated. ' +
|
||
'It\'s not actually async. Use `parse()` instead.');
|
||
exports.parseStringSync = deprecate(parseStringSync, '`parseStringSync()` is ' +
|
||
'deprecated. Use `parse()` instead.');
|
||
|
||
/**
|
||
* We ignore raw text (usually whitespace), <!-- xml comments -->,
|
||
* and raw CDATA nodes.
|
||
*
|
||
* @param {Element} node
|
||
* @returns {Boolean}
|
||
* @api private
|
||
*/
|
||
|
||
function shouldIgnoreNode (node) {
|
||
return node.nodeType === 3 // text
|
||
|| node.nodeType === 8 // comment
|
||
|| node.nodeType === 4; // cdata
|
||
}
|
||
|
||
|
||
/**
|
||
* Parses a Plist XML string. Returns an Object.
|
||
*
|
||
* @param {String} xml - the XML String to decode
|
||
* @returns {Mixed} the decoded value from the Plist XML
|
||
* @api public
|
||
*/
|
||
|
||
function parse (xml) {
|
||
var doc = new DOMParser().parseFromString(xml);
|
||
if (doc.documentElement.nodeName !== 'plist') {
|
||
throw new Error('malformed document. First element should be <plist>');
|
||
}
|
||
var plist = parsePlistXML(doc.documentElement);
|
||
|
||
// the root <plist> node gets interpreted as an Array,
|
||
// so pull out the inner data first
|
||
if (plist.length == 1) plist = plist[0];
|
||
|
||
return plist;
|
||
}
|
||
|
||
/**
|
||
* Parses a Plist XML string. Returns an Object. Takes a `callback` function.
|
||
*
|
||
* @param {String} xml - the XML String to decode
|
||
* @param {Function} callback - callback function
|
||
* @returns {Mixed} the decoded value from the Plist XML
|
||
* @api public
|
||
* @deprecated not actually async. use parse() instead
|
||
*/
|
||
|
||
function parseString (xml, callback) {
|
||
var doc, error, plist;
|
||
try {
|
||
doc = new DOMParser().parseFromString(xml);
|
||
plist = parsePlistXML(doc.documentElement);
|
||
} catch(e) {
|
||
error = e;
|
||
}
|
||
callback(error, plist);
|
||
}
|
||
|
||
/**
|
||
* Parses a Plist XML string. Returns an Object.
|
||
*
|
||
* @param {String} xml - the XML String to decode
|
||
* @param {Function} callback - callback function
|
||
* @returns {Mixed} the decoded value from the Plist XML
|
||
* @api public
|
||
* @deprecated use parse() instead
|
||
*/
|
||
|
||
function parseStringSync (xml) {
|
||
var doc = new DOMParser().parseFromString(xml);
|
||
var plist;
|
||
if (doc.documentElement.nodeName !== 'plist') {
|
||
throw new Error('malformed document. First element should be <plist>');
|
||
}
|
||
plist = parsePlistXML(doc.documentElement);
|
||
|
||
// if the plist is an array with 1 element, pull it out of the array
|
||
if (plist.length == 1) {
|
||
plist = plist[0];
|
||
}
|
||
return plist;
|
||
}
|
||
|
||
/**
|
||
* Convert an XML based plist document into a JSON representation.
|
||
*
|
||
* @param {Object} xml_node - current XML node in the plist
|
||
* @returns {Mixed} built up JSON object
|
||
* @api private
|
||
*/
|
||
|
||
function parsePlistXML (node) {
|
||
var i, new_obj, key, val, new_arr, res, d;
|
||
|
||
if (!node)
|
||
return null;
|
||
|
||
if (node.nodeName === 'plist') {
|
||
new_arr = [];
|
||
for (i=0; i < node.childNodes.length; i++) {
|
||
// ignore comment nodes (text)
|
||
if (!shouldIgnoreNode(node.childNodes[i])) {
|
||
new_arr.push( parsePlistXML(node.childNodes[i]));
|
||
}
|
||
}
|
||
return new_arr;
|
||
|
||
} else if (node.nodeName === 'dict') {
|
||
new_obj = {};
|
||
key = null;
|
||
for (i=0; i < node.childNodes.length; i++) {
|
||
// ignore comment nodes (text)
|
||
if (!shouldIgnoreNode(node.childNodes[i])) {
|
||
if (key === null) {
|
||
key = parsePlistXML(node.childNodes[i]);
|
||
} else {
|
||
new_obj[key] = parsePlistXML(node.childNodes[i]);
|
||
key = null;
|
||
}
|
||
}
|
||
}
|
||
return new_obj;
|
||
|
||
} else if (node.nodeName === 'array') {
|
||
new_arr = [];
|
||
for (i=0; i < node.childNodes.length; i++) {
|
||
// ignore comment nodes (text)
|
||
if (!shouldIgnoreNode(node.childNodes[i])) {
|
||
res = parsePlistXML(node.childNodes[i]);
|
||
if (null != res) new_arr.push(res);
|
||
}
|
||
}
|
||
return new_arr;
|
||
|
||
} else if (node.nodeName === '#text') {
|
||
// TODO: what should we do with text types? (CDATA sections)
|
||
|
||
} else if (node.nodeName === 'key') {
|
||
return node.childNodes[0].nodeValue;
|
||
|
||
} else if (node.nodeName === 'string') {
|
||
res = '';
|
||
for (d=0; d < node.childNodes.length; d++) {
|
||
res += node.childNodes[d].nodeValue;
|
||
}
|
||
return res;
|
||
|
||
} else if (node.nodeName === 'integer') {
|
||
// parse as base 10 integer
|
||
return parseInt(node.childNodes[0].nodeValue, 10);
|
||
|
||
} else if (node.nodeName === 'real') {
|
||
res = '';
|
||
for (d=0; d < node.childNodes.length; d++) {
|
||
if (node.childNodes[d].nodeType === 3) {
|
||
res += node.childNodes[d].nodeValue;
|
||
}
|
||
}
|
||
return parseFloat(res);
|
||
|
||
} else if (node.nodeName === 'data') {
|
||
res = '';
|
||
for (d=0; d < node.childNodes.length; d++) {
|
||
if (node.childNodes[d].nodeType === 3) {
|
||
res += node.childNodes[d].nodeValue.replace(/\s+/g, '');
|
||
}
|
||
}
|
||
|
||
// decode base64 data to a Buffer instance
|
||
return new Buffer(res, 'base64');
|
||
|
||
} else if (node.nodeName === 'date') {
|
||
return new Date(node.childNodes[0].nodeValue);
|
||
|
||
} else if (node.nodeName === 'true') {
|
||
return true;
|
||
|
||
} else if (node.nodeName === 'false') {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
}).call(this,require("buffer").Buffer)
|
||
},{"buffer":7,"util-deprecate":70,"xmldom":88}],4:[function(require,module,exports){
|
||
|
||
var i;
|
||
|
||
/**
|
||
* Parser functions.
|
||
*/
|
||
|
||
var parserFunctions = require('./parse');
|
||
for (i in parserFunctions) exports[i] = parserFunctions[i];
|
||
|
||
/**
|
||
* Builder functions.
|
||
*/
|
||
|
||
var builderFunctions = require('./build');
|
||
for (i in builderFunctions) exports[i] = builderFunctions[i];
|
||
|
||
/**
|
||
* Add Node.js-specific functions (they're deprecated…).
|
||
*/
|
||
|
||
var nodeFunctions = require('./node');
|
||
for (i in nodeFunctions) exports[i] = nodeFunctions[i];
|
||
|
||
},{"./build":1,"./node":2,"./parse":3}],5:[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))
|
||
|
||
},{}],6:[function(require,module,exports){
|
||
|
||
},{}],7:[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 */
|
||
|
||
var base64 = require('base64-js')
|
||
var ieee754 = require('ieee754')
|
||
var isArray = require('is-array')
|
||
|
||
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)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
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
|
||
|
||
// pre-set for values that may exist in the future
|
||
Buffer.prototype.length = undefined
|
||
Buffer.prototype.parent = undefined
|
||
|
||
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 : {})
|
||
},{"base64-js":5,"ieee754":8,"is-array":9}],8:[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
|
||
}
|
||
|
||
},{}],9:[function(require,module,exports){
|
||
|
||
/**
|
||
* isArray
|
||
*/
|
||
|
||
var isArray = Array.isArray;
|
||
|
||
/**
|
||
* toString
|
||
*/
|
||
|
||
var str = Object.prototype.toString;
|
||
|
||
/**
|
||
* Whether or not the given `val`
|
||
* is an array.
|
||
*
|
||
* example:
|
||
*
|
||
* isArray([]);
|
||
* // > true
|
||
* isArray(arguments);
|
||
* // > false
|
||
* isArray('');
|
||
* // > false
|
||
*
|
||
* @param {mixed} val
|
||
* @return {bool}
|
||
*/
|
||
|
||
module.exports = isArray || function (val) {
|
||
return !! val && '[object Array]' == str.call(val);
|
||
};
|
||
|
||
},{}],10:[function(require,module,exports){
|
||
/**
|
||
* Determine if an object is Buffer
|
||
*
|
||
* Author: Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
||
* License: MIT
|
||
*
|
||
* `npm install is-buffer`
|
||
*/
|
||
|
||
module.exports = function (obj) {
|
||
return !!(obj != null &&
|
||
(obj._isBuffer || // For Safari 5-7 (missing Object.prototype.constructor)
|
||
(obj.constructor &&
|
||
typeof obj.constructor.isBuffer === 'function' &&
|
||
obj.constructor.isBuffer(obj))
|
||
))
|
||
}
|
||
|
||
},{}],11:[function(require,module,exports){
|
||
/**
|
||
* Gets the last element of `array`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Array
|
||
* @param {Array} array The array to query.
|
||
* @returns {*} Returns the last element of `array`.
|
||
* @example
|
||
*
|
||
* _.last([1, 2, 3]);
|
||
* // => 3
|
||
*/
|
||
function last(array) {
|
||
var length = array ? array.length : 0;
|
||
return length ? array[length - 1] : undefined;
|
||
}
|
||
|
||
module.exports = last;
|
||
|
||
},{}],12:[function(require,module,exports){
|
||
var arrayEvery = require('../internal/arrayEvery'),
|
||
baseCallback = require('../internal/baseCallback'),
|
||
baseEvery = require('../internal/baseEvery'),
|
||
isArray = require('../lang/isArray'),
|
||
isIterateeCall = require('../internal/isIterateeCall');
|
||
|
||
/**
|
||
* Checks if `predicate` returns truthy for **all** elements of `collection`.
|
||
* The predicate is bound to `thisArg` and invoked with three arguments:
|
||
* (value, index|key, collection).
|
||
*
|
||
* If a property name is provided for `predicate` the created `_.property`
|
||
* style callback returns the property value of the given element.
|
||
*
|
||
* If a value is also provided for `thisArg` the created `_.matchesProperty`
|
||
* style callback returns `true` for elements that have a matching property
|
||
* value, else `false`.
|
||
*
|
||
* If an object is provided for `predicate` the created `_.matches` style
|
||
* callback returns `true` for elements that have the properties of the given
|
||
* object, else `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias all
|
||
* @category Collection
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function|Object|string} [predicate=_.identity] The function invoked
|
||
* per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `predicate`.
|
||
* @returns {boolean} Returns `true` if all elements pass the predicate check,
|
||
* else `false`.
|
||
* @example
|
||
*
|
||
* _.every([true, 1, null, 'yes'], Boolean);
|
||
* // => false
|
||
*
|
||
* var users = [
|
||
* { 'user': 'barney', 'active': false },
|
||
* { 'user': 'fred', 'active': false }
|
||
* ];
|
||
*
|
||
* // using the `_.matches` callback shorthand
|
||
* _.every(users, { 'user': 'barney', 'active': false });
|
||
* // => false
|
||
*
|
||
* // using the `_.matchesProperty` callback shorthand
|
||
* _.every(users, 'active', false);
|
||
* // => true
|
||
*
|
||
* // using the `_.property` callback shorthand
|
||
* _.every(users, 'active');
|
||
* // => false
|
||
*/
|
||
function every(collection, predicate, thisArg) {
|
||
var func = isArray(collection) ? arrayEvery : baseEvery;
|
||
if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
|
||
predicate = undefined;
|
||
}
|
||
if (typeof predicate != 'function' || thisArg !== undefined) {
|
||
predicate = baseCallback(predicate, thisArg, 3);
|
||
}
|
||
return func(collection, predicate);
|
||
}
|
||
|
||
module.exports = every;
|
||
|
||
},{"../internal/arrayEvery":14,"../internal/baseCallback":18,"../internal/baseEvery":22,"../internal/isIterateeCall":47,"../lang/isArray":56}],13:[function(require,module,exports){
|
||
/** Used as the `TypeError` message for "Functions" methods. */
|
||
var FUNC_ERROR_TEXT = 'Expected a function';
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeMax = Math.max;
|
||
|
||
/**
|
||
* Creates a function that invokes `func` with the `this` binding of the
|
||
* created function and arguments from `start` and beyond provided as an array.
|
||
*
|
||
* **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Function
|
||
* @param {Function} func The function to apply a rest parameter to.
|
||
* @param {number} [start=func.length-1] The start position of the rest parameter.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var say = _.restParam(function(what, names) {
|
||
* return what + ' ' + _.initial(names).join(', ') +
|
||
* (_.size(names) > 1 ? ', & ' : '') + _.last(names);
|
||
* });
|
||
*
|
||
* say('hello', 'fred', 'barney', 'pebbles');
|
||
* // => 'hello fred, barney, & pebbles'
|
||
*/
|
||
function restParam(func, start) {
|
||
if (typeof func != 'function') {
|
||
throw new TypeError(FUNC_ERROR_TEXT);
|
||
}
|
||
start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
|
||
return function() {
|
||
var args = arguments,
|
||
index = -1,
|
||
length = nativeMax(args.length - start, 0),
|
||
rest = Array(length);
|
||
|
||
while (++index < length) {
|
||
rest[index] = args[start + index];
|
||
}
|
||
switch (start) {
|
||
case 0: return func.call(this, rest);
|
||
case 1: return func.call(this, args[0], rest);
|
||
case 2: return func.call(this, args[0], args[1], rest);
|
||
}
|
||
var otherArgs = Array(start + 1);
|
||
index = -1;
|
||
while (++index < start) {
|
||
otherArgs[index] = args[index];
|
||
}
|
||
otherArgs[start] = rest;
|
||
return func.apply(this, otherArgs);
|
||
};
|
||
}
|
||
|
||
module.exports = restParam;
|
||
|
||
},{}],14:[function(require,module,exports){
|
||
/**
|
||
* A specialized version of `_.every` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {boolean} Returns `true` if all elements pass the predicate check,
|
||
* else `false`.
|
||
*/
|
||
function arrayEvery(array, predicate) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
while (++index < length) {
|
||
if (!predicate(array[index], index, array)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = arrayEvery;
|
||
|
||
},{}],15:[function(require,module,exports){
|
||
/**
|
||
* A specialized version of `_.some` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {boolean} Returns `true` if any element passes the predicate check,
|
||
* else `false`.
|
||
*/
|
||
function arraySome(array, predicate) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
while (++index < length) {
|
||
if (predicate(array[index], index, array)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = arraySome;
|
||
|
||
},{}],16:[function(require,module,exports){
|
||
var keys = require('../object/keys');
|
||
|
||
/**
|
||
* A specialized version of `_.assign` for customizing assigned values without
|
||
* support for argument juggling, multiple sources, and `this` binding `customizer`
|
||
* functions.
|
||
*
|
||
* @private
|
||
* @param {Object} object The destination object.
|
||
* @param {Object} source The source object.
|
||
* @param {Function} customizer The function to customize assigned values.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function assignWith(object, source, customizer) {
|
||
var index = -1,
|
||
props = keys(source),
|
||
length = props.length;
|
||
|
||
while (++index < length) {
|
||
var key = props[index],
|
||
value = object[key],
|
||
result = customizer(value, source[key], key, object, source);
|
||
|
||
if ((result === result ? (result !== value) : (value === value)) ||
|
||
(value === undefined && !(key in object))) {
|
||
object[key] = result;
|
||
}
|
||
}
|
||
return object;
|
||
}
|
||
|
||
module.exports = assignWith;
|
||
|
||
},{"../object/keys":65}],17:[function(require,module,exports){
|
||
var baseCopy = require('./baseCopy'),
|
||
keys = require('../object/keys');
|
||
|
||
/**
|
||
* The base implementation of `_.assign` without support for argument juggling,
|
||
* multiple sources, and `customizer` functions.
|
||
*
|
||
* @private
|
||
* @param {Object} object The destination object.
|
||
* @param {Object} source The source object.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseAssign(object, source) {
|
||
return source == null
|
||
? object
|
||
: baseCopy(source, keys(source), object);
|
||
}
|
||
|
||
module.exports = baseAssign;
|
||
|
||
},{"../object/keys":65,"./baseCopy":19}],18:[function(require,module,exports){
|
||
var baseMatches = require('./baseMatches'),
|
||
baseMatchesProperty = require('./baseMatchesProperty'),
|
||
bindCallback = require('./bindCallback'),
|
||
identity = require('../utility/identity'),
|
||
property = require('../utility/property');
|
||
|
||
/**
|
||
* The base implementation of `_.callback` which supports specifying the
|
||
* number of arguments to provide to `func`.
|
||
*
|
||
* @private
|
||
* @param {*} [func=_.identity] The value to convert to a callback.
|
||
* @param {*} [thisArg] The `this` binding of `func`.
|
||
* @param {number} [argCount] The number of arguments to provide to `func`.
|
||
* @returns {Function} Returns the callback.
|
||
*/
|
||
function baseCallback(func, thisArg, argCount) {
|
||
var type = typeof func;
|
||
if (type == 'function') {
|
||
return thisArg === undefined
|
||
? func
|
||
: bindCallback(func, thisArg, argCount);
|
||
}
|
||
if (func == null) {
|
||
return identity;
|
||
}
|
||
if (type == 'object') {
|
||
return baseMatches(func);
|
||
}
|
||
return thisArg === undefined
|
||
? property(func)
|
||
: baseMatchesProperty(func, thisArg);
|
||
}
|
||
|
||
module.exports = baseCallback;
|
||
|
||
},{"../utility/identity":68,"../utility/property":69,"./baseMatches":29,"./baseMatchesProperty":30,"./bindCallback":35}],19:[function(require,module,exports){
|
||
/**
|
||
* Copies properties of `source` to `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} source The object to copy properties from.
|
||
* @param {Array} props The property names to copy.
|
||
* @param {Object} [object={}] The object to copy properties to.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseCopy(source, props, object) {
|
||
object || (object = {});
|
||
|
||
var index = -1,
|
||
length = props.length;
|
||
|
||
while (++index < length) {
|
||
var key = props[index];
|
||
object[key] = source[key];
|
||
}
|
||
return object;
|
||
}
|
||
|
||
module.exports = baseCopy;
|
||
|
||
},{}],20:[function(require,module,exports){
|
||
var isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* The base implementation of `_.create` without support for assigning
|
||
* properties to the created object.
|
||
*
|
||
* @private
|
||
* @param {Object} prototype The object to inherit from.
|
||
* @returns {Object} Returns the new object.
|
||
*/
|
||
var baseCreate = (function() {
|
||
function object() {}
|
||
return function(prototype) {
|
||
if (isObject(prototype)) {
|
||
object.prototype = prototype;
|
||
var result = new object;
|
||
object.prototype = undefined;
|
||
}
|
||
return result || {};
|
||
};
|
||
}());
|
||
|
||
module.exports = baseCreate;
|
||
|
||
},{"../lang/isObject":60}],21:[function(require,module,exports){
|
||
var baseForOwn = require('./baseForOwn'),
|
||
createBaseEach = require('./createBaseEach');
|
||
|
||
/**
|
||
* The base implementation of `_.forEach` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array|Object|string} Returns `collection`.
|
||
*/
|
||
var baseEach = createBaseEach(baseForOwn);
|
||
|
||
module.exports = baseEach;
|
||
|
||
},{"./baseForOwn":24,"./createBaseEach":37}],22:[function(require,module,exports){
|
||
var baseEach = require('./baseEach');
|
||
|
||
/**
|
||
* The base implementation of `_.every` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {boolean} Returns `true` if all elements pass the predicate check,
|
||
* else `false`
|
||
*/
|
||
function baseEvery(collection, predicate) {
|
||
var result = true;
|
||
baseEach(collection, function(value, index, collection) {
|
||
result = !!predicate(value, index, collection);
|
||
return result;
|
||
});
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseEvery;
|
||
|
||
},{"./baseEach":21}],23:[function(require,module,exports){
|
||
var createBaseFor = require('./createBaseFor');
|
||
|
||
/**
|
||
* The base implementation of `baseForIn` and `baseForOwn` which iterates
|
||
* over `object` properties returned by `keysFunc` invoking `iteratee` for
|
||
* each property. Iteratee functions may exit iteration early by explicitly
|
||
* returning `false`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @param {Function} keysFunc The function to get the keys of `object`.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
var baseFor = createBaseFor();
|
||
|
||
module.exports = baseFor;
|
||
|
||
},{"./createBaseFor":38}],24:[function(require,module,exports){
|
||
var baseFor = require('./baseFor'),
|
||
keys = require('../object/keys');
|
||
|
||
/**
|
||
* The base implementation of `_.forOwn` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseForOwn(object, iteratee) {
|
||
return baseFor(object, iteratee, keys);
|
||
}
|
||
|
||
module.exports = baseForOwn;
|
||
|
||
},{"../object/keys":65,"./baseFor":23}],25:[function(require,module,exports){
|
||
var toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `get` without support for string paths
|
||
* and default values.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @param {Array} path The path of the property to get.
|
||
* @param {string} [pathKey] The key representation of path.
|
||
* @returns {*} Returns the resolved value.
|
||
*/
|
||
function baseGet(object, path, pathKey) {
|
||
if (object == null) {
|
||
return;
|
||
}
|
||
if (pathKey !== undefined && pathKey in toObject(object)) {
|
||
path = [pathKey];
|
||
}
|
||
var index = 0,
|
||
length = path.length;
|
||
|
||
while (object != null && index < length) {
|
||
object = object[path[index++]];
|
||
}
|
||
return (index && index == length) ? object : undefined;
|
||
}
|
||
|
||
module.exports = baseGet;
|
||
|
||
},{"./toObject":53}],26:[function(require,module,exports){
|
||
var baseIsEqualDeep = require('./baseIsEqualDeep'),
|
||
isObject = require('../lang/isObject'),
|
||
isObjectLike = require('./isObjectLike');
|
||
|
||
/**
|
||
* The base implementation of `_.isEqual` without support for `this` binding
|
||
* `customizer` functions.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to compare.
|
||
* @param {*} other The other value to compare.
|
||
* @param {Function} [customizer] The function to customize comparing values.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
||
*/
|
||
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
|
||
if (value === other) {
|
||
return true;
|
||
}
|
||
if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
|
||
return value !== value && other !== other;
|
||
}
|
||
return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
|
||
}
|
||
|
||
module.exports = baseIsEqual;
|
||
|
||
},{"../lang/isObject":60,"./baseIsEqualDeep":27,"./isObjectLike":50}],27:[function(require,module,exports){
|
||
var equalArrays = require('./equalArrays'),
|
||
equalByTag = require('./equalByTag'),
|
||
equalObjects = require('./equalObjects'),
|
||
isArray = require('../lang/isArray'),
|
||
isTypedArray = require('../lang/isTypedArray');
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]',
|
||
arrayTag = '[object Array]',
|
||
objectTag = '[object Object]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqual` for arrays and objects which performs
|
||
* deep comparisons and tracks traversed objects enabling objects with circular
|
||
* references to be compared.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing objects.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA=[]] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB=[]] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var objIsArr = isArray(object),
|
||
othIsArr = isArray(other),
|
||
objTag = arrayTag,
|
||
othTag = arrayTag;
|
||
|
||
if (!objIsArr) {
|
||
objTag = objToString.call(object);
|
||
if (objTag == argsTag) {
|
||
objTag = objectTag;
|
||
} else if (objTag != objectTag) {
|
||
objIsArr = isTypedArray(object);
|
||
}
|
||
}
|
||
if (!othIsArr) {
|
||
othTag = objToString.call(other);
|
||
if (othTag == argsTag) {
|
||
othTag = objectTag;
|
||
} else if (othTag != objectTag) {
|
||
othIsArr = isTypedArray(other);
|
||
}
|
||
}
|
||
var objIsObj = objTag == objectTag,
|
||
othIsObj = othTag == objectTag,
|
||
isSameTag = objTag == othTag;
|
||
|
||
if (isSameTag && !(objIsArr || objIsObj)) {
|
||
return equalByTag(object, other, objTag);
|
||
}
|
||
if (!isLoose) {
|
||
var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
|
||
othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
|
||
|
||
if (objIsWrapped || othIsWrapped) {
|
||
return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
|
||
}
|
||
}
|
||
if (!isSameTag) {
|
||
return false;
|
||
}
|
||
// Assume cyclic values are equal.
|
||
// For more information on detecting circular references see https://es5.github.io/#JO.
|
||
stackA || (stackA = []);
|
||
stackB || (stackB = []);
|
||
|
||
var length = stackA.length;
|
||
while (length--) {
|
||
if (stackA[length] == object) {
|
||
return stackB[length] == other;
|
||
}
|
||
}
|
||
// Add `object` and `other` to the stack of traversed objects.
|
||
stackA.push(object);
|
||
stackB.push(other);
|
||
|
||
var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);
|
||
|
||
stackA.pop();
|
||
stackB.pop();
|
||
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseIsEqualDeep;
|
||
|
||
},{"../lang/isArray":56,"../lang/isTypedArray":62,"./equalArrays":39,"./equalByTag":40,"./equalObjects":41}],28:[function(require,module,exports){
|
||
var baseIsEqual = require('./baseIsEqual'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `_.isMatch` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to inspect.
|
||
* @param {Array} matchData The propery names, values, and compare flags to match.
|
||
* @param {Function} [customizer] The function to customize comparing objects.
|
||
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
|
||
*/
|
||
function baseIsMatch(object, matchData, customizer) {
|
||
var index = matchData.length,
|
||
length = index,
|
||
noCustomizer = !customizer;
|
||
|
||
if (object == null) {
|
||
return !length;
|
||
}
|
||
object = toObject(object);
|
||
while (index--) {
|
||
var data = matchData[index];
|
||
if ((noCustomizer && data[2])
|
||
? data[1] !== object[data[0]]
|
||
: !(data[0] in object)
|
||
) {
|
||
return false;
|
||
}
|
||
}
|
||
while (++index < length) {
|
||
data = matchData[index];
|
||
var key = data[0],
|
||
objValue = object[key],
|
||
srcValue = data[1];
|
||
|
||
if (noCustomizer && data[2]) {
|
||
if (objValue === undefined && !(key in object)) {
|
||
return false;
|
||
}
|
||
} else {
|
||
var result = customizer ? customizer(objValue, srcValue, key) : undefined;
|
||
if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = baseIsMatch;
|
||
|
||
},{"./baseIsEqual":26,"./toObject":53}],29:[function(require,module,exports){
|
||
var baseIsMatch = require('./baseIsMatch'),
|
||
getMatchData = require('./getMatchData'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `_.matches` which does not clone `source`.
|
||
*
|
||
* @private
|
||
* @param {Object} source The object of property values to match.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseMatches(source) {
|
||
var matchData = getMatchData(source);
|
||
if (matchData.length == 1 && matchData[0][2]) {
|
||
var key = matchData[0][0],
|
||
value = matchData[0][1];
|
||
|
||
return function(object) {
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
return object[key] === value && (value !== undefined || (key in toObject(object)));
|
||
};
|
||
}
|
||
return function(object) {
|
||
return baseIsMatch(object, matchData);
|
||
};
|
||
}
|
||
|
||
module.exports = baseMatches;
|
||
|
||
},{"./baseIsMatch":28,"./getMatchData":43,"./toObject":53}],30:[function(require,module,exports){
|
||
var baseGet = require('./baseGet'),
|
||
baseIsEqual = require('./baseIsEqual'),
|
||
baseSlice = require('./baseSlice'),
|
||
isArray = require('../lang/isArray'),
|
||
isKey = require('./isKey'),
|
||
isStrictComparable = require('./isStrictComparable'),
|
||
last = require('../array/last'),
|
||
toObject = require('./toObject'),
|
||
toPath = require('./toPath');
|
||
|
||
/**
|
||
* The base implementation of `_.matchesProperty` which does not clone `srcValue`.
|
||
*
|
||
* @private
|
||
* @param {string} path The path of the property to get.
|
||
* @param {*} srcValue The value to compare.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseMatchesProperty(path, srcValue) {
|
||
var isArr = isArray(path),
|
||
isCommon = isKey(path) && isStrictComparable(srcValue),
|
||
pathKey = (path + '');
|
||
|
||
path = toPath(path);
|
||
return function(object) {
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
var key = pathKey;
|
||
object = toObject(object);
|
||
if ((isArr || !isCommon) && !(key in object)) {
|
||
object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
key = last(path);
|
||
object = toObject(object);
|
||
}
|
||
return object[key] === srcValue
|
||
? (srcValue !== undefined || (key in object))
|
||
: baseIsEqual(srcValue, object[key], undefined, true);
|
||
};
|
||
}
|
||
|
||
module.exports = baseMatchesProperty;
|
||
|
||
},{"../array/last":11,"../lang/isArray":56,"./baseGet":25,"./baseIsEqual":26,"./baseSlice":33,"./isKey":48,"./isStrictComparable":51,"./toObject":53,"./toPath":54}],31:[function(require,module,exports){
|
||
/**
|
||
* The base implementation of `_.property` without support for deep paths.
|
||
*
|
||
* @private
|
||
* @param {string} key The key of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseProperty(key) {
|
||
return function(object) {
|
||
return object == null ? undefined : object[key];
|
||
};
|
||
}
|
||
|
||
module.exports = baseProperty;
|
||
|
||
},{}],32:[function(require,module,exports){
|
||
var baseGet = require('./baseGet'),
|
||
toPath = require('./toPath');
|
||
|
||
/**
|
||
* A specialized version of `baseProperty` which supports deep paths.
|
||
*
|
||
* @private
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function basePropertyDeep(path) {
|
||
var pathKey = (path + '');
|
||
path = toPath(path);
|
||
return function(object) {
|
||
return baseGet(object, path, pathKey);
|
||
};
|
||
}
|
||
|
||
module.exports = basePropertyDeep;
|
||
|
||
},{"./baseGet":25,"./toPath":54}],33:[function(require,module,exports){
|
||
/**
|
||
* The base implementation of `_.slice` without an iteratee call guard.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to slice.
|
||
* @param {number} [start=0] The start position.
|
||
* @param {number} [end=array.length] The end position.
|
||
* @returns {Array} Returns the slice of `array`.
|
||
*/
|
||
function baseSlice(array, start, end) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
start = start == null ? 0 : (+start || 0);
|
||
if (start < 0) {
|
||
start = -start > length ? 0 : (length + start);
|
||
}
|
||
end = (end === undefined || end > length) ? length : (+end || 0);
|
||
if (end < 0) {
|
||
end += length;
|
||
}
|
||
length = start > end ? 0 : ((end - start) >>> 0);
|
||
start >>>= 0;
|
||
|
||
var result = Array(length);
|
||
while (++index < length) {
|
||
result[index] = array[index + start];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseSlice;
|
||
|
||
},{}],34:[function(require,module,exports){
|
||
/**
|
||
* Converts `value` to a string if it's not one. An empty string is returned
|
||
* for `null` or `undefined` values.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {string} Returns the string.
|
||
*/
|
||
function baseToString(value) {
|
||
return value == null ? '' : (value + '');
|
||
}
|
||
|
||
module.exports = baseToString;
|
||
|
||
},{}],35:[function(require,module,exports){
|
||
var identity = require('../utility/identity');
|
||
|
||
/**
|
||
* A specialized version of `baseCallback` which only supports `this` binding
|
||
* and specifying the number of arguments to provide to `func`.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to bind.
|
||
* @param {*} thisArg The `this` binding of `func`.
|
||
* @param {number} [argCount] The number of arguments to provide to `func`.
|
||
* @returns {Function} Returns the callback.
|
||
*/
|
||
function bindCallback(func, thisArg, argCount) {
|
||
if (typeof func != 'function') {
|
||
return identity;
|
||
}
|
||
if (thisArg === undefined) {
|
||
return func;
|
||
}
|
||
switch (argCount) {
|
||
case 1: return function(value) {
|
||
return func.call(thisArg, value);
|
||
};
|
||
case 3: return function(value, index, collection) {
|
||
return func.call(thisArg, value, index, collection);
|
||
};
|
||
case 4: return function(accumulator, value, index, collection) {
|
||
return func.call(thisArg, accumulator, value, index, collection);
|
||
};
|
||
case 5: return function(value, other, key, object, source) {
|
||
return func.call(thisArg, value, other, key, object, source);
|
||
};
|
||
}
|
||
return function() {
|
||
return func.apply(thisArg, arguments);
|
||
};
|
||
}
|
||
|
||
module.exports = bindCallback;
|
||
|
||
},{"../utility/identity":68}],36:[function(require,module,exports){
|
||
var bindCallback = require('./bindCallback'),
|
||
isIterateeCall = require('./isIterateeCall'),
|
||
restParam = require('../function/restParam');
|
||
|
||
/**
|
||
* Creates a `_.assign`, `_.defaults`, or `_.merge` function.
|
||
*
|
||
* @private
|
||
* @param {Function} assigner The function to assign values.
|
||
* @returns {Function} Returns the new assigner function.
|
||
*/
|
||
function createAssigner(assigner) {
|
||
return restParam(function(object, sources) {
|
||
var index = -1,
|
||
length = object == null ? 0 : sources.length,
|
||
customizer = length > 2 ? sources[length - 2] : undefined,
|
||
guard = length > 2 ? sources[2] : undefined,
|
||
thisArg = length > 1 ? sources[length - 1] : undefined;
|
||
|
||
if (typeof customizer == 'function') {
|
||
customizer = bindCallback(customizer, thisArg, 5);
|
||
length -= 2;
|
||
} else {
|
||
customizer = typeof thisArg == 'function' ? thisArg : undefined;
|
||
length -= (customizer ? 1 : 0);
|
||
}
|
||
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
||
customizer = length < 3 ? undefined : customizer;
|
||
length = 1;
|
||
}
|
||
while (++index < length) {
|
||
var source = sources[index];
|
||
if (source) {
|
||
assigner(object, source, customizer);
|
||
}
|
||
}
|
||
return object;
|
||
});
|
||
}
|
||
|
||
module.exports = createAssigner;
|
||
|
||
},{"../function/restParam":13,"./bindCallback":35,"./isIterateeCall":47}],37:[function(require,module,exports){
|
||
var getLength = require('./getLength'),
|
||
isLength = require('./isLength'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* Creates a `baseEach` or `baseEachRight` function.
|
||
*
|
||
* @private
|
||
* @param {Function} eachFunc The function to iterate over a collection.
|
||
* @param {boolean} [fromRight] Specify iterating from right to left.
|
||
* @returns {Function} Returns the new base function.
|
||
*/
|
||
function createBaseEach(eachFunc, fromRight) {
|
||
return function(collection, iteratee) {
|
||
var length = collection ? getLength(collection) : 0;
|
||
if (!isLength(length)) {
|
||
return eachFunc(collection, iteratee);
|
||
}
|
||
var index = fromRight ? length : -1,
|
||
iterable = toObject(collection);
|
||
|
||
while ((fromRight ? index-- : ++index < length)) {
|
||
if (iteratee(iterable[index], index, iterable) === false) {
|
||
break;
|
||
}
|
||
}
|
||
return collection;
|
||
};
|
||
}
|
||
|
||
module.exports = createBaseEach;
|
||
|
||
},{"./getLength":42,"./isLength":49,"./toObject":53}],38:[function(require,module,exports){
|
||
var toObject = require('./toObject');
|
||
|
||
/**
|
||
* Creates a base function for `_.forIn` or `_.forInRight`.
|
||
*
|
||
* @private
|
||
* @param {boolean} [fromRight] Specify iterating from right to left.
|
||
* @returns {Function} Returns the new base function.
|
||
*/
|
||
function createBaseFor(fromRight) {
|
||
return function(object, iteratee, keysFunc) {
|
||
var iterable = toObject(object),
|
||
props = keysFunc(object),
|
||
length = props.length,
|
||
index = fromRight ? length : -1;
|
||
|
||
while ((fromRight ? index-- : ++index < length)) {
|
||
var key = props[index];
|
||
if (iteratee(iterable[key], key, iterable) === false) {
|
||
break;
|
||
}
|
||
}
|
||
return object;
|
||
};
|
||
}
|
||
|
||
module.exports = createBaseFor;
|
||
|
||
},{"./toObject":53}],39:[function(require,module,exports){
|
||
var arraySome = require('./arraySome');
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for arrays with support for
|
||
* partial deep comparisons.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to compare.
|
||
* @param {Array} other The other array to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing arrays.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
|
||
*/
|
||
function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var index = -1,
|
||
arrLength = array.length,
|
||
othLength = other.length;
|
||
|
||
if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
|
||
return false;
|
||
}
|
||
// Ignore non-index properties.
|
||
while (++index < arrLength) {
|
||
var arrValue = array[index],
|
||
othValue = other[index],
|
||
result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;
|
||
|
||
if (result !== undefined) {
|
||
if (result) {
|
||
continue;
|
||
}
|
||
return false;
|
||
}
|
||
// Recursively compare arrays (susceptible to call stack limits).
|
||
if (isLoose) {
|
||
if (!arraySome(other, function(othValue) {
|
||
return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
||
})) {
|
||
return false;
|
||
}
|
||
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = equalArrays;
|
||
|
||
},{"./arraySome":15}],40:[function(require,module,exports){
|
||
/** `Object#toString` result references. */
|
||
var boolTag = '[object Boolean]',
|
||
dateTag = '[object Date]',
|
||
errorTag = '[object Error]',
|
||
numberTag = '[object Number]',
|
||
regexpTag = '[object RegExp]',
|
||
stringTag = '[object String]';
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for comparing objects of
|
||
* the same `toStringTag`.
|
||
*
|
||
* **Note:** This function only supports comparing values with tags of
|
||
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {string} tag The `toStringTag` of the objects to compare.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function equalByTag(object, other, tag) {
|
||
switch (tag) {
|
||
case boolTag:
|
||
case dateTag:
|
||
// Coerce dates and booleans to numbers, dates to milliseconds and booleans
|
||
// to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
|
||
return +object == +other;
|
||
|
||
case errorTag:
|
||
return object.name == other.name && object.message == other.message;
|
||
|
||
case numberTag:
|
||
// Treat `NaN` vs. `NaN` as equal.
|
||
return (object != +object)
|
||
? other != +other
|
||
: object == +other;
|
||
|
||
case regexpTag:
|
||
case stringTag:
|
||
// Coerce regexes to strings and treat strings primitives and string
|
||
// objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
|
||
return object == (other + '');
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = equalByTag;
|
||
|
||
},{}],41:[function(require,module,exports){
|
||
var keys = require('../object/keys');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for objects with support for
|
||
* partial deep comparisons.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing values.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var objProps = keys(object),
|
||
objLength = objProps.length,
|
||
othProps = keys(other),
|
||
othLength = othProps.length;
|
||
|
||
if (objLength != othLength && !isLoose) {
|
||
return false;
|
||
}
|
||
var index = objLength;
|
||
while (index--) {
|
||
var key = objProps[index];
|
||
if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
|
||
return false;
|
||
}
|
||
}
|
||
var skipCtor = isLoose;
|
||
while (++index < objLength) {
|
||
key = objProps[index];
|
||
var objValue = object[key],
|
||
othValue = other[key],
|
||
result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;
|
||
|
||
// Recursively compare objects (susceptible to call stack limits).
|
||
if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
|
||
return false;
|
||
}
|
||
skipCtor || (skipCtor = key == 'constructor');
|
||
}
|
||
if (!skipCtor) {
|
||
var objCtor = object.constructor,
|
||
othCtor = other.constructor;
|
||
|
||
// Non `Object` object instances with different constructors are not equal.
|
||
if (objCtor != othCtor &&
|
||
('constructor' in object && 'constructor' in other) &&
|
||
!(typeof objCtor == 'function' && objCtor instanceof objCtor &&
|
||
typeof othCtor == 'function' && othCtor instanceof othCtor)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = equalObjects;
|
||
|
||
},{"../object/keys":65}],42:[function(require,module,exports){
|
||
var baseProperty = require('./baseProperty');
|
||
|
||
/**
|
||
* Gets the "length" property value of `object`.
|
||
*
|
||
* **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
|
||
* that affects Safari on at least iOS 8.1-8.3 ARM64.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {*} Returns the "length" value.
|
||
*/
|
||
var getLength = baseProperty('length');
|
||
|
||
module.exports = getLength;
|
||
|
||
},{"./baseProperty":31}],43:[function(require,module,exports){
|
||
var isStrictComparable = require('./isStrictComparable'),
|
||
pairs = require('../object/pairs');
|
||
|
||
/**
|
||
* Gets the propery names, values, and compare flags of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the match data of `object`.
|
||
*/
|
||
function getMatchData(object) {
|
||
var result = pairs(object),
|
||
length = result.length;
|
||
|
||
while (length--) {
|
||
result[length][2] = isStrictComparable(result[length][1]);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = getMatchData;
|
||
|
||
},{"../object/pairs":67,"./isStrictComparable":51}],44:[function(require,module,exports){
|
||
var isNative = require('../lang/isNative');
|
||
|
||
/**
|
||
* Gets the native function at `key` of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @param {string} key The key of the method to get.
|
||
* @returns {*} Returns the function if it's native, else `undefined`.
|
||
*/
|
||
function getNative(object, key) {
|
||
var value = object == null ? undefined : object[key];
|
||
return isNative(value) ? value : undefined;
|
||
}
|
||
|
||
module.exports = getNative;
|
||
|
||
},{"../lang/isNative":59}],45:[function(require,module,exports){
|
||
var getLength = require('./getLength'),
|
||
isLength = require('./isLength');
|
||
|
||
/**
|
||
* Checks if `value` is array-like.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
||
*/
|
||
function isArrayLike(value) {
|
||
return value != null && isLength(getLength(value));
|
||
}
|
||
|
||
module.exports = isArrayLike;
|
||
|
||
},{"./getLength":42,"./isLength":49}],46:[function(require,module,exports){
|
||
/** Used to detect unsigned integer values. */
|
||
var reIsUint = /^\d+$/;
|
||
|
||
/**
|
||
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
||
* of an array-like value.
|
||
*/
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like index.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
||
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
||
*/
|
||
function isIndex(value, length) {
|
||
value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
|
||
length = length == null ? MAX_SAFE_INTEGER : length;
|
||
return value > -1 && value % 1 == 0 && value < length;
|
||
}
|
||
|
||
module.exports = isIndex;
|
||
|
||
},{}],47:[function(require,module,exports){
|
||
var isArrayLike = require('./isArrayLike'),
|
||
isIndex = require('./isIndex'),
|
||
isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Checks if the provided arguments are from an iteratee call.
|
||
*
|
||
* @private
|
||
* @param {*} value The potential iteratee value argument.
|
||
* @param {*} index The potential iteratee index or key argument.
|
||
* @param {*} object The potential iteratee object argument.
|
||
* @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
|
||
*/
|
||
function isIterateeCall(value, index, object) {
|
||
if (!isObject(object)) {
|
||
return false;
|
||
}
|
||
var type = typeof index;
|
||
if (type == 'number'
|
||
? (isArrayLike(object) && isIndex(index, object.length))
|
||
: (type == 'string' && index in object)) {
|
||
var other = object[index];
|
||
return value === value ? (value === other) : (other !== other);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = isIterateeCall;
|
||
|
||
},{"../lang/isObject":60,"./isArrayLike":45,"./isIndex":46}],48:[function(require,module,exports){
|
||
var isArray = require('../lang/isArray'),
|
||
toObject = require('./toObject');
|
||
|
||
/** Used to match property names within property paths. */
|
||
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,
|
||
reIsPlainProp = /^\w*$/;
|
||
|
||
/**
|
||
* Checks if `value` is a property name and not a property path.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @param {Object} [object] The object to query keys on.
|
||
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
|
||
*/
|
||
function isKey(value, object) {
|
||
var type = typeof value;
|
||
if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {
|
||
return true;
|
||
}
|
||
if (isArray(value)) {
|
||
return false;
|
||
}
|
||
var result = !reIsDeepProp.test(value);
|
||
return result || (object != null && value in toObject(object));
|
||
}
|
||
|
||
module.exports = isKey;
|
||
|
||
},{"../lang/isArray":56,"./toObject":53}],49:[function(require,module,exports){
|
||
/**
|
||
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
||
* of an array-like value.
|
||
*/
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like length.
|
||
*
|
||
* **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
||
*/
|
||
function isLength(value) {
|
||
return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
module.exports = isLength;
|
||
|
||
},{}],50:[function(require,module,exports){
|
||
/**
|
||
* Checks if `value` is object-like.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
||
*/
|
||
function isObjectLike(value) {
|
||
return !!value && typeof value == 'object';
|
||
}
|
||
|
||
module.exports = isObjectLike;
|
||
|
||
},{}],51:[function(require,module,exports){
|
||
var isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` if suitable for strict
|
||
* equality comparisons, else `false`.
|
||
*/
|
||
function isStrictComparable(value) {
|
||
return value === value && !isObject(value);
|
||
}
|
||
|
||
module.exports = isStrictComparable;
|
||
|
||
},{"../lang/isObject":60}],52:[function(require,module,exports){
|
||
var isArguments = require('../lang/isArguments'),
|
||
isArray = require('../lang/isArray'),
|
||
isIndex = require('./isIndex'),
|
||
isLength = require('./isLength'),
|
||
keysIn = require('../object/keysIn');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* A fallback implementation of `Object.keys` which creates an array of the
|
||
* own enumerable property names of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
*/
|
||
function shimKeys(object) {
|
||
var props = keysIn(object),
|
||
propsLength = props.length,
|
||
length = propsLength && object.length;
|
||
|
||
var allowIndexes = !!length && isLength(length) &&
|
||
(isArray(object) || isArguments(object));
|
||
|
||
var index = -1,
|
||
result = [];
|
||
|
||
while (++index < propsLength) {
|
||
var key = props[index];
|
||
if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = shimKeys;
|
||
|
||
},{"../lang/isArguments":55,"../lang/isArray":56,"../object/keysIn":66,"./isIndex":46,"./isLength":49}],53:[function(require,module,exports){
|
||
var isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Converts `value` to an object if it's not one.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {Object} Returns the object.
|
||
*/
|
||
function toObject(value) {
|
||
return isObject(value) ? value : Object(value);
|
||
}
|
||
|
||
module.exports = toObject;
|
||
|
||
},{"../lang/isObject":60}],54:[function(require,module,exports){
|
||
var baseToString = require('./baseToString'),
|
||
isArray = require('../lang/isArray');
|
||
|
||
/** Used to match property names within property paths. */
|
||
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;
|
||
|
||
/** Used to match backslashes in property paths. */
|
||
var reEscapeChar = /\\(\\)?/g;
|
||
|
||
/**
|
||
* Converts `value` to property path array if it's not one.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {Array} Returns the property path array.
|
||
*/
|
||
function toPath(value) {
|
||
if (isArray(value)) {
|
||
return value;
|
||
}
|
||
var result = [];
|
||
baseToString(value).replace(rePropName, function(match, number, quote, string) {
|
||
result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
|
||
});
|
||
return result;
|
||
}
|
||
|
||
module.exports = toPath;
|
||
|
||
},{"../lang/isArray":56,"./baseToString":34}],55:[function(require,module,exports){
|
||
var isArrayLike = require('../internal/isArrayLike'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/** Native method references. */
|
||
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
||
|
||
/**
|
||
* Checks if `value` is classified as an `arguments` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArguments(function() { return arguments; }());
|
||
* // => true
|
||
*
|
||
* _.isArguments([1, 2, 3]);
|
||
* // => false
|
||
*/
|
||
function isArguments(value) {
|
||
return isObjectLike(value) && isArrayLike(value) &&
|
||
hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
|
||
}
|
||
|
||
module.exports = isArguments;
|
||
|
||
},{"../internal/isArrayLike":45,"../internal/isObjectLike":50}],56:[function(require,module,exports){
|
||
var getNative = require('../internal/getNative'),
|
||
isLength = require('../internal/isLength'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** `Object#toString` result references. */
|
||
var arrayTag = '[object Array]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeIsArray = getNative(Array, 'isArray');
|
||
|
||
/**
|
||
* Checks if `value` is classified as an `Array` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArray([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isArray(function() { return arguments; }());
|
||
* // => false
|
||
*/
|
||
var isArray = nativeIsArray || function(value) {
|
||
return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
|
||
};
|
||
|
||
module.exports = isArray;
|
||
|
||
},{"../internal/getNative":44,"../internal/isLength":49,"../internal/isObjectLike":50}],57:[function(require,module,exports){
|
||
var isArguments = require('./isArguments'),
|
||
isArray = require('./isArray'),
|
||
isArrayLike = require('../internal/isArrayLike'),
|
||
isFunction = require('./isFunction'),
|
||
isObjectLike = require('../internal/isObjectLike'),
|
||
isString = require('./isString'),
|
||
keys = require('../object/keys');
|
||
|
||
/**
|
||
* Checks if `value` is empty. A value is considered empty unless it's an
|
||
* `arguments` object, array, string, or jQuery-like collection with a length
|
||
* greater than `0` or an object with own enumerable properties.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {Array|Object|string} value The value to inspect.
|
||
* @returns {boolean} Returns `true` if `value` is empty, else `false`.
|
||
* @example
|
||
*
|
||
* _.isEmpty(null);
|
||
* // => true
|
||
*
|
||
* _.isEmpty(true);
|
||
* // => true
|
||
*
|
||
* _.isEmpty(1);
|
||
* // => true
|
||
*
|
||
* _.isEmpty([1, 2, 3]);
|
||
* // => false
|
||
*
|
||
* _.isEmpty({ 'a': 1 });
|
||
* // => false
|
||
*/
|
||
function isEmpty(value) {
|
||
if (value == null) {
|
||
return true;
|
||
}
|
||
if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) ||
|
||
(isObjectLike(value) && isFunction(value.splice)))) {
|
||
return !value.length;
|
||
}
|
||
return !keys(value).length;
|
||
}
|
||
|
||
module.exports = isEmpty;
|
||
|
||
},{"../internal/isArrayLike":45,"../internal/isObjectLike":50,"../object/keys":65,"./isArguments":55,"./isArray":56,"./isFunction":58,"./isString":61}],58:[function(require,module,exports){
|
||
var isObject = require('./isObject');
|
||
|
||
/** `Object#toString` result references. */
|
||
var funcTag = '[object Function]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a `Function` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isFunction(_);
|
||
* // => true
|
||
*
|
||
* _.isFunction(/abc/);
|
||
* // => false
|
||
*/
|
||
function isFunction(value) {
|
||
// The use of `Object#toString` avoids issues with the `typeof` operator
|
||
// in older versions of Chrome and Safari which return 'function' for regexes
|
||
// and Safari 8 which returns 'object' for typed array constructors.
|
||
return isObject(value) && objToString.call(value) == funcTag;
|
||
}
|
||
|
||
module.exports = isFunction;
|
||
|
||
},{"./isObject":60}],59:[function(require,module,exports){
|
||
var isFunction = require('./isFunction'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** Used to detect host constructors (Safari > 5). */
|
||
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to resolve the decompiled source of functions. */
|
||
var fnToString = Function.prototype.toString;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/** Used to detect if a method is native. */
|
||
var reIsNative = RegExp('^' +
|
||
fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
|
||
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
||
);
|
||
|
||
/**
|
||
* Checks if `value` is a native function.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
|
||
* @example
|
||
*
|
||
* _.isNative(Array.prototype.push);
|
||
* // => true
|
||
*
|
||
* _.isNative(_);
|
||
* // => false
|
||
*/
|
||
function isNative(value) {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
if (isFunction(value)) {
|
||
return reIsNative.test(fnToString.call(value));
|
||
}
|
||
return isObjectLike(value) && reIsHostCtor.test(value);
|
||
}
|
||
|
||
module.exports = isNative;
|
||
|
||
},{"../internal/isObjectLike":50,"./isFunction":58}],60:[function(require,module,exports){
|
||
/**
|
||
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
|
||
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
||
* @example
|
||
*
|
||
* _.isObject({});
|
||
* // => true
|
||
*
|
||
* _.isObject([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isObject(1);
|
||
* // => false
|
||
*/
|
||
function isObject(value) {
|
||
// Avoid a V8 JIT bug in Chrome 19-20.
|
||
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
|
||
var type = typeof value;
|
||
return !!value && (type == 'object' || type == 'function');
|
||
}
|
||
|
||
module.exports = isObject;
|
||
|
||
},{}],61:[function(require,module,exports){
|
||
var isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** `Object#toString` result references. */
|
||
var stringTag = '[object String]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a `String` primitive or object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isString('abc');
|
||
* // => true
|
||
*
|
||
* _.isString(1);
|
||
* // => false
|
||
*/
|
||
function isString(value) {
|
||
return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);
|
||
}
|
||
|
||
module.exports = isString;
|
||
|
||
},{"../internal/isObjectLike":50}],62:[function(require,module,exports){
|
||
var isLength = require('../internal/isLength'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]',
|
||
arrayTag = '[object Array]',
|
||
boolTag = '[object Boolean]',
|
||
dateTag = '[object Date]',
|
||
errorTag = '[object Error]',
|
||
funcTag = '[object Function]',
|
||
mapTag = '[object Map]',
|
||
numberTag = '[object Number]',
|
||
objectTag = '[object Object]',
|
||
regexpTag = '[object RegExp]',
|
||
setTag = '[object Set]',
|
||
stringTag = '[object String]',
|
||
weakMapTag = '[object WeakMap]';
|
||
|
||
var arrayBufferTag = '[object ArrayBuffer]',
|
||
float32Tag = '[object Float32Array]',
|
||
float64Tag = '[object Float64Array]',
|
||
int8Tag = '[object Int8Array]',
|
||
int16Tag = '[object Int16Array]',
|
||
int32Tag = '[object Int32Array]',
|
||
uint8Tag = '[object Uint8Array]',
|
||
uint8ClampedTag = '[object Uint8ClampedArray]',
|
||
uint16Tag = '[object Uint16Array]',
|
||
uint32Tag = '[object Uint32Array]';
|
||
|
||
/** Used to identify `toStringTag` values of typed arrays. */
|
||
var typedArrayTags = {};
|
||
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
||
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
||
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
||
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
||
typedArrayTags[uint32Tag] = true;
|
||
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
||
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
||
typedArrayTags[dateTag] = typedArrayTags[errorTag] =
|
||
typedArrayTags[funcTag] = typedArrayTags[mapTag] =
|
||
typedArrayTags[numberTag] = typedArrayTags[objectTag] =
|
||
typedArrayTags[regexpTag] = typedArrayTags[setTag] =
|
||
typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a typed array.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isTypedArray(new Uint8Array);
|
||
* // => true
|
||
*
|
||
* _.isTypedArray([]);
|
||
* // => false
|
||
*/
|
||
function isTypedArray(value) {
|
||
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
|
||
}
|
||
|
||
module.exports = isTypedArray;
|
||
|
||
},{"../internal/isLength":49,"../internal/isObjectLike":50}],63:[function(require,module,exports){
|
||
var assignWith = require('../internal/assignWith'),
|
||
baseAssign = require('../internal/baseAssign'),
|
||
createAssigner = require('../internal/createAssigner');
|
||
|
||
/**
|
||
* Assigns own enumerable properties of source object(s) to the destination
|
||
* object. Subsequent sources overwrite property assignments of previous sources.
|
||
* If `customizer` is provided it's invoked to produce the assigned values.
|
||
* The `customizer` is bound to `thisArg` and invoked with five arguments:
|
||
* (objectValue, sourceValue, key, object, source).
|
||
*
|
||
* **Note:** This method mutates `object` and is based on
|
||
* [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias extend
|
||
* @category Object
|
||
* @param {Object} object The destination object.
|
||
* @param {...Object} [sources] The source objects.
|
||
* @param {Function} [customizer] The function to customize assigned values.
|
||
* @param {*} [thisArg] The `this` binding of `customizer`.
|
||
* @returns {Object} Returns `object`.
|
||
* @example
|
||
*
|
||
* _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
|
||
* // => { 'user': 'fred', 'age': 40 }
|
||
*
|
||
* // using a customizer callback
|
||
* var defaults = _.partialRight(_.assign, function(value, other) {
|
||
* return _.isUndefined(value) ? other : value;
|
||
* });
|
||
*
|
||
* defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
|
||
* // => { 'user': 'barney', 'age': 36 }
|
||
*/
|
||
var assign = createAssigner(function(object, source, customizer) {
|
||
return customizer
|
||
? assignWith(object, source, customizer)
|
||
: baseAssign(object, source);
|
||
});
|
||
|
||
module.exports = assign;
|
||
|
||
},{"../internal/assignWith":16,"../internal/baseAssign":17,"../internal/createAssigner":36}],64:[function(require,module,exports){
|
||
var baseAssign = require('../internal/baseAssign'),
|
||
baseCreate = require('../internal/baseCreate'),
|
||
isIterateeCall = require('../internal/isIterateeCall');
|
||
|
||
/**
|
||
* Creates an object that inherits from the given `prototype` object. If a
|
||
* `properties` object is provided its own enumerable properties are assigned
|
||
* to the created object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} prototype The object to inherit from.
|
||
* @param {Object} [properties] The properties to assign to the object.
|
||
* @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
|
||
* @returns {Object} Returns the new object.
|
||
* @example
|
||
*
|
||
* function Shape() {
|
||
* this.x = 0;
|
||
* this.y = 0;
|
||
* }
|
||
*
|
||
* function Circle() {
|
||
* Shape.call(this);
|
||
* }
|
||
*
|
||
* Circle.prototype = _.create(Shape.prototype, {
|
||
* 'constructor': Circle
|
||
* });
|
||
*
|
||
* var circle = new Circle;
|
||
* circle instanceof Circle;
|
||
* // => true
|
||
*
|
||
* circle instanceof Shape;
|
||
* // => true
|
||
*/
|
||
function create(prototype, properties, guard) {
|
||
var result = baseCreate(prototype);
|
||
if (guard && isIterateeCall(prototype, properties, guard)) {
|
||
properties = undefined;
|
||
}
|
||
return properties ? baseAssign(result, properties) : result;
|
||
}
|
||
|
||
module.exports = create;
|
||
|
||
},{"../internal/baseAssign":17,"../internal/baseCreate":20,"../internal/isIterateeCall":47}],65:[function(require,module,exports){
|
||
var getNative = require('../internal/getNative'),
|
||
isArrayLike = require('../internal/isArrayLike'),
|
||
isObject = require('../lang/isObject'),
|
||
shimKeys = require('../internal/shimKeys');
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeKeys = getNative(Object, 'keys');
|
||
|
||
/**
|
||
* Creates an array of the own enumerable property names of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects. See the
|
||
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
|
||
* for more details.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.keys(new Foo);
|
||
* // => ['a', 'b'] (iteration order is not guaranteed)
|
||
*
|
||
* _.keys('hi');
|
||
* // => ['0', '1']
|
||
*/
|
||
var keys = !nativeKeys ? shimKeys : function(object) {
|
||
var Ctor = object == null ? undefined : object.constructor;
|
||
if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
|
||
(typeof object != 'function' && isArrayLike(object))) {
|
||
return shimKeys(object);
|
||
}
|
||
return isObject(object) ? nativeKeys(object) : [];
|
||
};
|
||
|
||
module.exports = keys;
|
||
|
||
},{"../internal/getNative":44,"../internal/isArrayLike":45,"../internal/shimKeys":52,"../lang/isObject":60}],66:[function(require,module,exports){
|
||
var isArguments = require('../lang/isArguments'),
|
||
isArray = require('../lang/isArray'),
|
||
isIndex = require('../internal/isIndex'),
|
||
isLength = require('../internal/isLength'),
|
||
isObject = require('../lang/isObject');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Creates an array of the own and inherited enumerable property names of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.keysIn(new Foo);
|
||
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
|
||
*/
|
||
function keysIn(object) {
|
||
if (object == null) {
|
||
return [];
|
||
}
|
||
if (!isObject(object)) {
|
||
object = Object(object);
|
||
}
|
||
var length = object.length;
|
||
length = (length && isLength(length) &&
|
||
(isArray(object) || isArguments(object)) && length) || 0;
|
||
|
||
var Ctor = object.constructor,
|
||
index = -1,
|
||
isProto = typeof Ctor == 'function' && Ctor.prototype === object,
|
||
result = Array(length),
|
||
skipIndexes = length > 0;
|
||
|
||
while (++index < length) {
|
||
result[index] = (index + '');
|
||
}
|
||
for (var key in object) {
|
||
if (!(skipIndexes && isIndex(key, length)) &&
|
||
!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = keysIn;
|
||
|
||
},{"../internal/isIndex":46,"../internal/isLength":49,"../lang/isArguments":55,"../lang/isArray":56,"../lang/isObject":60}],67:[function(require,module,exports){
|
||
var keys = require('./keys'),
|
||
toObject = require('../internal/toObject');
|
||
|
||
/**
|
||
* Creates a two dimensional array of the key-value pairs for `object`,
|
||
* e.g. `[[key1, value1], [key2, value2]]`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the new array of key-value pairs.
|
||
* @example
|
||
*
|
||
* _.pairs({ 'barney': 36, 'fred': 40 });
|
||
* // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)
|
||
*/
|
||
function pairs(object) {
|
||
object = toObject(object);
|
||
|
||
var index = -1,
|
||
props = keys(object),
|
||
length = props.length,
|
||
result = Array(length);
|
||
|
||
while (++index < length) {
|
||
var key = props[index];
|
||
result[index] = [key, object[key]];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = pairs;
|
||
|
||
},{"../internal/toObject":53,"./keys":65}],68:[function(require,module,exports){
|
||
/**
|
||
* This method returns the first argument provided to it.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Utility
|
||
* @param {*} value Any value.
|
||
* @returns {*} Returns `value`.
|
||
* @example
|
||
*
|
||
* var object = { 'user': 'fred' };
|
||
*
|
||
* _.identity(object) === object;
|
||
* // => true
|
||
*/
|
||
function identity(value) {
|
||
return value;
|
||
}
|
||
|
||
module.exports = identity;
|
||
|
||
},{}],69:[function(require,module,exports){
|
||
var baseProperty = require('../internal/baseProperty'),
|
||
basePropertyDeep = require('../internal/basePropertyDeep'),
|
||
isKey = require('../internal/isKey');
|
||
|
||
/**
|
||
* Creates a function that returns the property value at `path` on a
|
||
* given object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Utility
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': { 'b': { 'c': 2 } } },
|
||
* { 'a': { 'b': { 'c': 1 } } }
|
||
* ];
|
||
*
|
||
* _.map(objects, _.property('a.b.c'));
|
||
* // => [2, 1]
|
||
*
|
||
* _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
|
||
* // => [1, 2]
|
||
*/
|
||
function property(path) {
|
||
return isKey(path) ? baseProperty(path) : basePropertyDeep(path);
|
||
}
|
||
|
||
module.exports = property;
|
||
|
||
},{"../internal/baseProperty":31,"../internal/basePropertyDeep":32,"../internal/isKey":48}],70:[function(require,module,exports){
|
||
(function (global){
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = deprecate;
|
||
|
||
/**
|
||
* Mark that a method should not be used.
|
||
* Returns a modified function which warns once by default.
|
||
*
|
||
* If `localStorage.noDeprecation = true` is set, then it is a no-op.
|
||
*
|
||
* If `localStorage.throwDeprecation = true` is set, then deprecated functions
|
||
* will throw an Error when invoked.
|
||
*
|
||
* If `localStorage.traceDeprecation = true` is set, then deprecated functions
|
||
* will invoke `console.trace()` instead of `console.error()`.
|
||
*
|
||
* @param {Function} fn - the function to deprecate
|
||
* @param {String} msg - the string to print to the console when `fn` is invoked
|
||
* @returns {Function} a new "deprecated" version of `fn`
|
||
* @api public
|
||
*/
|
||
|
||
function deprecate (fn, msg) {
|
||
if (config('noDeprecation')) {
|
||
return fn;
|
||
}
|
||
|
||
var warned = false;
|
||
function deprecated() {
|
||
if (!warned) {
|
||
if (config('throwDeprecation')) {
|
||
throw new Error(msg);
|
||
} else if (config('traceDeprecation')) {
|
||
console.trace(msg);
|
||
} else {
|
||
console.warn(msg);
|
||
}
|
||
warned = true;
|
||
}
|
||
return fn.apply(this, arguments);
|
||
}
|
||
|
||
return deprecated;
|
||
}
|
||
|
||
/**
|
||
* Checks `localStorage` for boolean values for the given `name`.
|
||
*
|
||
* @param {String} name
|
||
* @returns {Boolean}
|
||
* @api private
|
||
*/
|
||
|
||
function config (name) {
|
||
// accessing global.localStorage can trigger a DOMException in sandboxed iframes
|
||
try {
|
||
if (!global.localStorage) return false;
|
||
} catch (_) {
|
||
return false;
|
||
}
|
||
var val = global.localStorage[name];
|
||
if (null == val) return false;
|
||
return String(val).toLowerCase() === 'true';
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
},{}],71:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLAttribute, create;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
module.exports = XMLAttribute = (function() {
|
||
function XMLAttribute(parent, name, value) {
|
||
this.stringify = parent.stringify;
|
||
if (name == null) {
|
||
throw new Error("Missing attribute name of element " + parent.name);
|
||
}
|
||
if (value == null) {
|
||
throw new Error("Missing attribute value for attribute " + name + " of element " + parent.name);
|
||
}
|
||
this.name = this.stringify.attName(name);
|
||
this.value = this.stringify.attValue(value);
|
||
}
|
||
|
||
XMLAttribute.prototype.clone = function() {
|
||
return create(XMLAttribute.prototype, this);
|
||
};
|
||
|
||
XMLAttribute.prototype.toString = function(options, level) {
|
||
return ' ' + this.name + '="' + this.value + '"';
|
||
};
|
||
|
||
return XMLAttribute;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/object/create":64}],72:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLBuilder, XMLDeclaration, XMLDocType, XMLElement, XMLStringifier;
|
||
|
||
XMLStringifier = require('./XMLStringifier');
|
||
|
||
XMLDeclaration = require('./XMLDeclaration');
|
||
|
||
XMLDocType = require('./XMLDocType');
|
||
|
||
XMLElement = require('./XMLElement');
|
||
|
||
module.exports = XMLBuilder = (function() {
|
||
function XMLBuilder(name, options) {
|
||
var root, temp;
|
||
if (name == null) {
|
||
throw new Error("Root element needs a name");
|
||
}
|
||
if (options == null) {
|
||
options = {};
|
||
}
|
||
this.options = options;
|
||
this.stringify = new XMLStringifier(options);
|
||
temp = new XMLElement(this, 'doc');
|
||
root = temp.element(name);
|
||
root.isRoot = true;
|
||
root.documentObject = this;
|
||
this.rootObject = root;
|
||
if (!options.headless) {
|
||
root.declaration(options);
|
||
if ((options.pubID != null) || (options.sysID != null)) {
|
||
root.doctype(options);
|
||
}
|
||
}
|
||
}
|
||
|
||
XMLBuilder.prototype.root = function() {
|
||
return this.rootObject;
|
||
};
|
||
|
||
XMLBuilder.prototype.end = function(options) {
|
||
return this.toString(options);
|
||
};
|
||
|
||
XMLBuilder.prototype.toString = function(options) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
r = '';
|
||
if (this.xmldec != null) {
|
||
r += this.xmldec.toString(options);
|
||
}
|
||
if (this.doctype != null) {
|
||
r += this.doctype.toString(options);
|
||
}
|
||
r += this.rootObject.toString(options);
|
||
if (pretty && r.slice(-newline.length) === newline) {
|
||
r = r.slice(0, -newline.length);
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLBuilder;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLDeclaration":79,"./XMLDocType":80,"./XMLElement":81,"./XMLStringifier":85}],73:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLCData, XMLNode, create,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
module.exports = XMLCData = (function(superClass) {
|
||
extend(XMLCData, superClass);
|
||
|
||
function XMLCData(parent, text) {
|
||
XMLCData.__super__.constructor.call(this, parent);
|
||
if (text == null) {
|
||
throw new Error("Missing CDATA text");
|
||
}
|
||
this.text = this.stringify.cdata(text);
|
||
}
|
||
|
||
XMLCData.prototype.clone = function() {
|
||
return create(XMLCData.prototype, this);
|
||
};
|
||
|
||
XMLCData.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<![CDATA[' + this.text + ']]>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLCData;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLNode":82,"lodash/object/create":64}],74:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLComment, XMLNode, create,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
module.exports = XMLComment = (function(superClass) {
|
||
extend(XMLComment, superClass);
|
||
|
||
function XMLComment(parent, text) {
|
||
XMLComment.__super__.constructor.call(this, parent);
|
||
if (text == null) {
|
||
throw new Error("Missing comment text");
|
||
}
|
||
this.text = this.stringify.comment(text);
|
||
}
|
||
|
||
XMLComment.prototype.clone = function() {
|
||
return create(XMLComment.prototype, this);
|
||
};
|
||
|
||
XMLComment.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!-- ' + this.text + ' -->';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLComment;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLNode":82,"lodash/object/create":64}],75:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLDTDAttList, create;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
module.exports = XMLDTDAttList = (function() {
|
||
function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
||
this.stringify = parent.stringify;
|
||
if (elementName == null) {
|
||
throw new Error("Missing DTD element name");
|
||
}
|
||
if (attributeName == null) {
|
||
throw new Error("Missing DTD attribute name");
|
||
}
|
||
if (!attributeType) {
|
||
throw new Error("Missing DTD attribute type");
|
||
}
|
||
if (!defaultValueType) {
|
||
throw new Error("Missing DTD attribute default");
|
||
}
|
||
if (defaultValueType.indexOf('#') !== 0) {
|
||
defaultValueType = '#' + defaultValueType;
|
||
}
|
||
if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
|
||
throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT");
|
||
}
|
||
if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
|
||
throw new Error("Default value only applies to #FIXED or #DEFAULT");
|
||
}
|
||
this.elementName = this.stringify.eleName(elementName);
|
||
this.attributeName = this.stringify.attName(attributeName);
|
||
this.attributeType = this.stringify.dtdAttType(attributeType);
|
||
this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
|
||
this.defaultValueType = defaultValueType;
|
||
}
|
||
|
||
XMLDTDAttList.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!ATTLIST ' + this.elementName + ' ' + this.attributeName + ' ' + this.attributeType;
|
||
if (this.defaultValueType !== '#DEFAULT') {
|
||
r += ' ' + this.defaultValueType;
|
||
}
|
||
if (this.defaultValue) {
|
||
r += ' "' + this.defaultValue + '"';
|
||
}
|
||
r += '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLDTDAttList;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/object/create":64}],76:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLDTDElement, create;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
module.exports = XMLDTDElement = (function() {
|
||
function XMLDTDElement(parent, name, value) {
|
||
this.stringify = parent.stringify;
|
||
if (name == null) {
|
||
throw new Error("Missing DTD element name");
|
||
}
|
||
if (!value) {
|
||
value = '(#PCDATA)';
|
||
}
|
||
if (Array.isArray(value)) {
|
||
value = '(' + value.join(',') + ')';
|
||
}
|
||
this.name = this.stringify.eleName(name);
|
||
this.value = this.stringify.dtdElementValue(value);
|
||
}
|
||
|
||
XMLDTDElement.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!ELEMENT ' + this.name + ' ' + this.value + '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLDTDElement;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/object/create":64}],77:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLDTDEntity, create, isObject;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
isObject = require('lodash/lang/isObject');
|
||
|
||
module.exports = XMLDTDEntity = (function() {
|
||
function XMLDTDEntity(parent, pe, name, value) {
|
||
this.stringify = parent.stringify;
|
||
if (name == null) {
|
||
throw new Error("Missing entity name");
|
||
}
|
||
if (value == null) {
|
||
throw new Error("Missing entity value");
|
||
}
|
||
this.pe = !!pe;
|
||
this.name = this.stringify.eleName(name);
|
||
if (!isObject(value)) {
|
||
this.value = this.stringify.dtdEntityValue(value);
|
||
} else {
|
||
if (!value.pubID && !value.sysID) {
|
||
throw new Error("Public and/or system identifiers are required for an external entity");
|
||
}
|
||
if (value.pubID && !value.sysID) {
|
||
throw new Error("System identifier is required for a public external entity");
|
||
}
|
||
if (value.pubID != null) {
|
||
this.pubID = this.stringify.dtdPubID(value.pubID);
|
||
}
|
||
if (value.sysID != null) {
|
||
this.sysID = this.stringify.dtdSysID(value.sysID);
|
||
}
|
||
if (value.nData != null) {
|
||
this.nData = this.stringify.dtdNData(value.nData);
|
||
}
|
||
if (this.pe && this.nData) {
|
||
throw new Error("Notation declaration is not allowed in a parameter entity");
|
||
}
|
||
}
|
||
}
|
||
|
||
XMLDTDEntity.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!ENTITY';
|
||
if (this.pe) {
|
||
r += ' %';
|
||
}
|
||
r += ' ' + this.name;
|
||
if (this.value) {
|
||
r += ' "' + this.value + '"';
|
||
} else {
|
||
if (this.pubID && this.sysID) {
|
||
r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
|
||
} else if (this.sysID) {
|
||
r += ' SYSTEM "' + this.sysID + '"';
|
||
}
|
||
if (this.nData) {
|
||
r += ' NDATA ' + this.nData;
|
||
}
|
||
}
|
||
r += '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLDTDEntity;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/lang/isObject":60,"lodash/object/create":64}],78:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLDTDNotation, create;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
module.exports = XMLDTDNotation = (function() {
|
||
function XMLDTDNotation(parent, name, value) {
|
||
this.stringify = parent.stringify;
|
||
if (name == null) {
|
||
throw new Error("Missing notation name");
|
||
}
|
||
if (!value.pubID && !value.sysID) {
|
||
throw new Error("Public or system identifiers are required for an external entity");
|
||
}
|
||
this.name = this.stringify.eleName(name);
|
||
if (value.pubID != null) {
|
||
this.pubID = this.stringify.dtdPubID(value.pubID);
|
||
}
|
||
if (value.sysID != null) {
|
||
this.sysID = this.stringify.dtdSysID(value.sysID);
|
||
}
|
||
}
|
||
|
||
XMLDTDNotation.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!NOTATION ' + this.name;
|
||
if (this.pubID && this.sysID) {
|
||
r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
|
||
} else if (this.pubID) {
|
||
r += ' PUBLIC "' + this.pubID + '"';
|
||
} else if (this.sysID) {
|
||
r += ' SYSTEM "' + this.sysID + '"';
|
||
}
|
||
r += '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLDTDNotation;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/object/create":64}],79:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLDeclaration, XMLNode, create, isObject,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
isObject = require('lodash/lang/isObject');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
module.exports = XMLDeclaration = (function(superClass) {
|
||
extend(XMLDeclaration, superClass);
|
||
|
||
function XMLDeclaration(parent, version, encoding, standalone) {
|
||
var ref;
|
||
XMLDeclaration.__super__.constructor.call(this, parent);
|
||
if (isObject(version)) {
|
||
ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
|
||
}
|
||
if (!version) {
|
||
version = '1.0';
|
||
}
|
||
this.version = this.stringify.xmlVersion(version);
|
||
if (encoding != null) {
|
||
this.encoding = this.stringify.xmlEncoding(encoding);
|
||
}
|
||
if (standalone != null) {
|
||
this.standalone = this.stringify.xmlStandalone(standalone);
|
||
}
|
||
}
|
||
|
||
XMLDeclaration.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<?xml';
|
||
r += ' version="' + this.version + '"';
|
||
if (this.encoding != null) {
|
||
r += ' encoding="' + this.encoding + '"';
|
||
}
|
||
if (this.standalone != null) {
|
||
r += ' standalone="' + this.standalone + '"';
|
||
}
|
||
r += '?>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLDeclaration;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLNode":82,"lodash/lang/isObject":60,"lodash/object/create":64}],80:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLProcessingInstruction, create, isObject;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
isObject = require('lodash/lang/isObject');
|
||
|
||
XMLCData = require('./XMLCData');
|
||
|
||
XMLComment = require('./XMLComment');
|
||
|
||
XMLDTDAttList = require('./XMLDTDAttList');
|
||
|
||
XMLDTDEntity = require('./XMLDTDEntity');
|
||
|
||
XMLDTDElement = require('./XMLDTDElement');
|
||
|
||
XMLDTDNotation = require('./XMLDTDNotation');
|
||
|
||
XMLProcessingInstruction = require('./XMLProcessingInstruction');
|
||
|
||
module.exports = XMLDocType = (function() {
|
||
function XMLDocType(parent, pubID, sysID) {
|
||
var ref, ref1;
|
||
this.documentObject = parent;
|
||
this.stringify = this.documentObject.stringify;
|
||
this.children = [];
|
||
if (isObject(pubID)) {
|
||
ref = pubID, pubID = ref.pubID, sysID = ref.sysID;
|
||
}
|
||
if (sysID == null) {
|
||
ref1 = [pubID, sysID], sysID = ref1[0], pubID = ref1[1];
|
||
}
|
||
if (pubID != null) {
|
||
this.pubID = this.stringify.dtdPubID(pubID);
|
||
}
|
||
if (sysID != null) {
|
||
this.sysID = this.stringify.dtdSysID(sysID);
|
||
}
|
||
}
|
||
|
||
XMLDocType.prototype.element = function(name, value) {
|
||
var child;
|
||
child = new XMLDTDElement(this, name, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
||
var child;
|
||
child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.entity = function(name, value) {
|
||
var child;
|
||
child = new XMLDTDEntity(this, false, name, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.pEntity = function(name, value) {
|
||
var child;
|
||
child = new XMLDTDEntity(this, true, name, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.notation = function(name, value) {
|
||
var child;
|
||
child = new XMLDTDNotation(this, name, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.cdata = function(value) {
|
||
var child;
|
||
child = new XMLCData(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.comment = function(value) {
|
||
var child;
|
||
child = new XMLComment(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.instruction = function(target, value) {
|
||
var child;
|
||
child = new XMLProcessingInstruction(this, target, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLDocType.prototype.root = function() {
|
||
return this.documentObject.root();
|
||
};
|
||
|
||
XMLDocType.prototype.document = function() {
|
||
return this.documentObject;
|
||
};
|
||
|
||
XMLDocType.prototype.toString = function(options, level) {
|
||
var child, i, indent, len, newline, offset, pretty, r, ref, ref1, ref2, ref3, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<!DOCTYPE ' + this.root().name;
|
||
if (this.pubID && this.sysID) {
|
||
r += ' PUBLIC "' + this.pubID + '" "' + this.sysID + '"';
|
||
} else if (this.sysID) {
|
||
r += ' SYSTEM "' + this.sysID + '"';
|
||
}
|
||
if (this.children.length > 0) {
|
||
r += ' [';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
ref3 = this.children;
|
||
for (i = 0, len = ref3.length; i < len; i++) {
|
||
child = ref3[i];
|
||
r += child.toString(options, level + 1);
|
||
}
|
||
r += ']';
|
||
}
|
||
r += '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
XMLDocType.prototype.ele = function(name, value) {
|
||
return this.element(name, value);
|
||
};
|
||
|
||
XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
||
return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
||
};
|
||
|
||
XMLDocType.prototype.ent = function(name, value) {
|
||
return this.entity(name, value);
|
||
};
|
||
|
||
XMLDocType.prototype.pent = function(name, value) {
|
||
return this.pEntity(name, value);
|
||
};
|
||
|
||
XMLDocType.prototype.not = function(name, value) {
|
||
return this.notation(name, value);
|
||
};
|
||
|
||
XMLDocType.prototype.dat = function(value) {
|
||
return this.cdata(value);
|
||
};
|
||
|
||
XMLDocType.prototype.com = function(value) {
|
||
return this.comment(value);
|
||
};
|
||
|
||
XMLDocType.prototype.ins = function(target, value) {
|
||
return this.instruction(target, value);
|
||
};
|
||
|
||
XMLDocType.prototype.up = function() {
|
||
return this.root();
|
||
};
|
||
|
||
XMLDocType.prototype.doc = function() {
|
||
return this.document();
|
||
};
|
||
|
||
return XMLDocType;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLCData":73,"./XMLComment":74,"./XMLDTDAttList":75,"./XMLDTDElement":76,"./XMLDTDEntity":77,"./XMLDTDNotation":78,"./XMLProcessingInstruction":83,"lodash/lang/isObject":60,"lodash/object/create":64}],81:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLAttribute, XMLElement, XMLNode, XMLProcessingInstruction, create, every, isFunction, isObject,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
isObject = require('lodash/lang/isObject');
|
||
|
||
isFunction = require('lodash/lang/isFunction');
|
||
|
||
every = require('lodash/collection/every');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
XMLAttribute = require('./XMLAttribute');
|
||
|
||
XMLProcessingInstruction = require('./XMLProcessingInstruction');
|
||
|
||
module.exports = XMLElement = (function(superClass) {
|
||
extend(XMLElement, superClass);
|
||
|
||
function XMLElement(parent, name, attributes) {
|
||
XMLElement.__super__.constructor.call(this, parent);
|
||
if (name == null) {
|
||
throw new Error("Missing element name");
|
||
}
|
||
this.name = this.stringify.eleName(name);
|
||
this.children = [];
|
||
this.instructions = [];
|
||
this.attributes = {};
|
||
if (attributes != null) {
|
||
this.attribute(attributes);
|
||
}
|
||
}
|
||
|
||
XMLElement.prototype.clone = function() {
|
||
var att, attName, clonedSelf, i, len, pi, ref, ref1;
|
||
clonedSelf = create(XMLElement.prototype, this);
|
||
if (clonedSelf.isRoot) {
|
||
clonedSelf.documentObject = null;
|
||
}
|
||
clonedSelf.attributes = {};
|
||
ref = this.attributes;
|
||
for (attName in ref) {
|
||
if (!hasProp.call(ref, attName)) continue;
|
||
att = ref[attName];
|
||
clonedSelf.attributes[attName] = att.clone();
|
||
}
|
||
clonedSelf.instructions = [];
|
||
ref1 = this.instructions;
|
||
for (i = 0, len = ref1.length; i < len; i++) {
|
||
pi = ref1[i];
|
||
clonedSelf.instructions.push(pi.clone());
|
||
}
|
||
clonedSelf.children = [];
|
||
this.children.forEach(function(child) {
|
||
var clonedChild;
|
||
clonedChild = child.clone();
|
||
clonedChild.parent = clonedSelf;
|
||
return clonedSelf.children.push(clonedChild);
|
||
});
|
||
return clonedSelf;
|
||
};
|
||
|
||
XMLElement.prototype.attribute = function(name, value) {
|
||
var attName, attValue;
|
||
if (name != null) {
|
||
name = name.valueOf();
|
||
}
|
||
if (isObject(name)) {
|
||
for (attName in name) {
|
||
if (!hasProp.call(name, attName)) continue;
|
||
attValue = name[attName];
|
||
this.attribute(attName, attValue);
|
||
}
|
||
} else {
|
||
if (isFunction(value)) {
|
||
value = value.apply();
|
||
}
|
||
if (!this.options.skipNullAttributes || (value != null)) {
|
||
this.attributes[name] = new XMLAttribute(this, name, value);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
|
||
XMLElement.prototype.removeAttribute = function(name) {
|
||
var attName, i, len;
|
||
if (name == null) {
|
||
throw new Error("Missing attribute name");
|
||
}
|
||
name = name.valueOf();
|
||
if (Array.isArray(name)) {
|
||
for (i = 0, len = name.length; i < len; i++) {
|
||
attName = name[i];
|
||
delete this.attributes[attName];
|
||
}
|
||
} else {
|
||
delete this.attributes[name];
|
||
}
|
||
return this;
|
||
};
|
||
|
||
XMLElement.prototype.instruction = function(target, value) {
|
||
var i, insTarget, insValue, instruction, len;
|
||
if (target != null) {
|
||
target = target.valueOf();
|
||
}
|
||
if (value != null) {
|
||
value = value.valueOf();
|
||
}
|
||
if (Array.isArray(target)) {
|
||
for (i = 0, len = target.length; i < len; i++) {
|
||
insTarget = target[i];
|
||
this.instruction(insTarget);
|
||
}
|
||
} else if (isObject(target)) {
|
||
for (insTarget in target) {
|
||
if (!hasProp.call(target, insTarget)) continue;
|
||
insValue = target[insTarget];
|
||
this.instruction(insTarget, insValue);
|
||
}
|
||
} else {
|
||
if (isFunction(value)) {
|
||
value = value.apply();
|
||
}
|
||
instruction = new XMLProcessingInstruction(this, target, value);
|
||
this.instructions.push(instruction);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
XMLElement.prototype.toString = function(options, level) {
|
||
var att, child, i, indent, instruction, j, len, len1, name, newline, offset, pretty, r, ref, ref1, ref2, ref3, ref4, ref5, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
ref3 = this.instructions;
|
||
for (i = 0, len = ref3.length; i < len; i++) {
|
||
instruction = ref3[i];
|
||
r += instruction.toString(options, level);
|
||
}
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<' + this.name;
|
||
ref4 = this.attributes;
|
||
for (name in ref4) {
|
||
if (!hasProp.call(ref4, name)) continue;
|
||
att = ref4[name];
|
||
r += att.toString(options);
|
||
}
|
||
if (this.children.length === 0 || every(this.children, function(e) {
|
||
return e.value === '';
|
||
})) {
|
||
r += '/>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
} else if (pretty && this.children.length === 1 && (this.children[0].value != null)) {
|
||
r += '>';
|
||
r += this.children[0].value;
|
||
r += '</' + this.name + '>';
|
||
r += newline;
|
||
} else {
|
||
r += '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
ref5 = this.children;
|
||
for (j = 0, len1 = ref5.length; j < len1; j++) {
|
||
child = ref5[j];
|
||
r += child.toString(options, level + 1);
|
||
}
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '</' + this.name + '>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
}
|
||
return r;
|
||
};
|
||
|
||
XMLElement.prototype.att = function(name, value) {
|
||
return this.attribute(name, value);
|
||
};
|
||
|
||
XMLElement.prototype.ins = function(target, value) {
|
||
return this.instruction(target, value);
|
||
};
|
||
|
||
XMLElement.prototype.a = function(name, value) {
|
||
return this.attribute(name, value);
|
||
};
|
||
|
||
XMLElement.prototype.i = function(target, value) {
|
||
return this.instruction(target, value);
|
||
};
|
||
|
||
return XMLElement;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLAttribute":71,"./XMLNode":82,"./XMLProcessingInstruction":83,"lodash/collection/every":12,"lodash/lang/isFunction":58,"lodash/lang/isObject":60,"lodash/object/create":64}],82:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLElement, XMLNode, XMLRaw, XMLText, isEmpty, isFunction, isObject,
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
isObject = require('lodash/lang/isObject');
|
||
|
||
isFunction = require('lodash/lang/isFunction');
|
||
|
||
isEmpty = require('lodash/lang/isEmpty');
|
||
|
||
XMLElement = null;
|
||
|
||
XMLCData = null;
|
||
|
||
XMLComment = null;
|
||
|
||
XMLDeclaration = null;
|
||
|
||
XMLDocType = null;
|
||
|
||
XMLRaw = null;
|
||
|
||
XMLText = null;
|
||
|
||
module.exports = XMLNode = (function() {
|
||
function XMLNode(parent) {
|
||
this.parent = parent;
|
||
this.options = this.parent.options;
|
||
this.stringify = this.parent.stringify;
|
||
if (XMLElement === null) {
|
||
XMLElement = require('./XMLElement');
|
||
XMLCData = require('./XMLCData');
|
||
XMLComment = require('./XMLComment');
|
||
XMLDeclaration = require('./XMLDeclaration');
|
||
XMLDocType = require('./XMLDocType');
|
||
XMLRaw = require('./XMLRaw');
|
||
XMLText = require('./XMLText');
|
||
}
|
||
}
|
||
|
||
XMLNode.prototype.element = function(name, attributes, text) {
|
||
var childNode, item, j, k, key, lastChild, len, len1, ref, val;
|
||
lastChild = null;
|
||
if (attributes == null) {
|
||
attributes = {};
|
||
}
|
||
attributes = attributes.valueOf();
|
||
if (!isObject(attributes)) {
|
||
ref = [attributes, text], text = ref[0], attributes = ref[1];
|
||
}
|
||
if (name != null) {
|
||
name = name.valueOf();
|
||
}
|
||
if (Array.isArray(name)) {
|
||
for (j = 0, len = name.length; j < len; j++) {
|
||
item = name[j];
|
||
lastChild = this.element(item);
|
||
}
|
||
} else if (isFunction(name)) {
|
||
lastChild = this.element(name.apply());
|
||
} else if (isObject(name)) {
|
||
for (key in name) {
|
||
if (!hasProp.call(name, key)) continue;
|
||
val = name[key];
|
||
if (isFunction(val)) {
|
||
val = val.apply();
|
||
}
|
||
if ((isObject(val)) && (isEmpty(val))) {
|
||
val = null;
|
||
}
|
||
if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
|
||
lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && key.indexOf(this.stringify.convertPIKey) === 0) {
|
||
lastChild = this.instruction(key.substr(this.stringify.convertPIKey.length), val);
|
||
} else if (Array.isArray(val)) {
|
||
for (k = 0, len1 = val.length; k < len1; k++) {
|
||
item = val[k];
|
||
childNode = {};
|
||
childNode[key] = item;
|
||
lastChild = this.element(childNode);
|
||
}
|
||
} else if (isObject(val)) {
|
||
lastChild = this.element(key);
|
||
lastChild.element(val);
|
||
} else {
|
||
lastChild = this.element(key, val);
|
||
}
|
||
}
|
||
} else {
|
||
if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
|
||
lastChild = this.text(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
|
||
lastChild = this.cdata(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
|
||
lastChild = this.comment(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
|
||
lastChild = this.raw(text);
|
||
} else {
|
||
lastChild = this.node(name, attributes, text);
|
||
}
|
||
}
|
||
if (lastChild == null) {
|
||
throw new Error("Could not create any elements with: " + name);
|
||
}
|
||
return lastChild;
|
||
};
|
||
|
||
XMLNode.prototype.insertBefore = function(name, attributes, text) {
|
||
var child, i, removed;
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot insert elements at root level");
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i);
|
||
child = this.parent.element(name, attributes, text);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.insertAfter = function(name, attributes, text) {
|
||
var child, i, removed;
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot insert elements at root level");
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i + 1);
|
||
child = this.parent.element(name, attributes, text);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.remove = function() {
|
||
var i, ref;
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot remove the root element");
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
[].splice.apply(this.parent.children, [i, i - i + 1].concat(ref = [])), ref;
|
||
return this.parent;
|
||
};
|
||
|
||
XMLNode.prototype.node = function(name, attributes, text) {
|
||
var child, ref;
|
||
if (name != null) {
|
||
name = name.valueOf();
|
||
}
|
||
if (attributes == null) {
|
||
attributes = {};
|
||
}
|
||
attributes = attributes.valueOf();
|
||
if (!isObject(attributes)) {
|
||
ref = [attributes, text], text = ref[0], attributes = ref[1];
|
||
}
|
||
child = new XMLElement(this, name, attributes);
|
||
if (text != null) {
|
||
child.text(text);
|
||
}
|
||
this.children.push(child);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.text = function(value) {
|
||
var child;
|
||
child = new XMLText(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.cdata = function(value) {
|
||
var child;
|
||
child = new XMLCData(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.comment = function(value) {
|
||
var child;
|
||
child = new XMLComment(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.raw = function(value) {
|
||
var child;
|
||
child = new XMLRaw(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.declaration = function(version, encoding, standalone) {
|
||
var doc, xmldec;
|
||
doc = this.document();
|
||
xmldec = new XMLDeclaration(doc, version, encoding, standalone);
|
||
doc.xmldec = xmldec;
|
||
return doc.root();
|
||
};
|
||
|
||
XMLNode.prototype.doctype = function(pubID, sysID) {
|
||
var doc, doctype;
|
||
doc = this.document();
|
||
doctype = new XMLDocType(doc, pubID, sysID);
|
||
doc.doctype = doctype;
|
||
return doctype;
|
||
};
|
||
|
||
XMLNode.prototype.up = function() {
|
||
if (this.isRoot) {
|
||
throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
|
||
}
|
||
return this.parent;
|
||
};
|
||
|
||
XMLNode.prototype.root = function() {
|
||
var child;
|
||
if (this.isRoot) {
|
||
return this;
|
||
}
|
||
child = this.parent;
|
||
while (!child.isRoot) {
|
||
child = child.parent;
|
||
}
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.document = function() {
|
||
return this.root().documentObject;
|
||
};
|
||
|
||
XMLNode.prototype.end = function(options) {
|
||
return this.document().toString(options);
|
||
};
|
||
|
||
XMLNode.prototype.prev = function() {
|
||
var i;
|
||
if (this.isRoot) {
|
||
throw new Error("Root node has no siblings");
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
if (i < 1) {
|
||
throw new Error("Already at the first node");
|
||
}
|
||
return this.parent.children[i - 1];
|
||
};
|
||
|
||
XMLNode.prototype.next = function() {
|
||
var i;
|
||
if (this.isRoot) {
|
||
throw new Error("Root node has no siblings");
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
if (i === -1 || i === this.parent.children.length - 1) {
|
||
throw new Error("Already at the last node");
|
||
}
|
||
return this.parent.children[i + 1];
|
||
};
|
||
|
||
XMLNode.prototype.importXMLBuilder = function(xmlbuilder) {
|
||
var clonedRoot;
|
||
clonedRoot = xmlbuilder.root().clone();
|
||
clonedRoot.parent = this;
|
||
clonedRoot.isRoot = false;
|
||
this.children.push(clonedRoot);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.ele = function(name, attributes, text) {
|
||
return this.element(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.nod = function(name, attributes, text) {
|
||
return this.node(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.txt = function(value) {
|
||
return this.text(value);
|
||
};
|
||
|
||
XMLNode.prototype.dat = function(value) {
|
||
return this.cdata(value);
|
||
};
|
||
|
||
XMLNode.prototype.com = function(value) {
|
||
return this.comment(value);
|
||
};
|
||
|
||
XMLNode.prototype.doc = function() {
|
||
return this.document();
|
||
};
|
||
|
||
XMLNode.prototype.dec = function(version, encoding, standalone) {
|
||
return this.declaration(version, encoding, standalone);
|
||
};
|
||
|
||
XMLNode.prototype.dtd = function(pubID, sysID) {
|
||
return this.doctype(pubID, sysID);
|
||
};
|
||
|
||
XMLNode.prototype.e = function(name, attributes, text) {
|
||
return this.element(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.n = function(name, attributes, text) {
|
||
return this.node(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.t = function(value) {
|
||
return this.text(value);
|
||
};
|
||
|
||
XMLNode.prototype.d = function(value) {
|
||
return this.cdata(value);
|
||
};
|
||
|
||
XMLNode.prototype.c = function(value) {
|
||
return this.comment(value);
|
||
};
|
||
|
||
XMLNode.prototype.r = function(value) {
|
||
return this.raw(value);
|
||
};
|
||
|
||
XMLNode.prototype.u = function() {
|
||
return this.up();
|
||
};
|
||
|
||
return XMLNode;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLCData":73,"./XMLComment":74,"./XMLDeclaration":79,"./XMLDocType":80,"./XMLElement":81,"./XMLRaw":84,"./XMLText":86,"lodash/lang/isEmpty":57,"lodash/lang/isFunction":58,"lodash/lang/isObject":60}],83:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLProcessingInstruction, create;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
module.exports = XMLProcessingInstruction = (function() {
|
||
function XMLProcessingInstruction(parent, target, value) {
|
||
this.stringify = parent.stringify;
|
||
if (target == null) {
|
||
throw new Error("Missing instruction target");
|
||
}
|
||
this.target = this.stringify.insTarget(target);
|
||
if (value) {
|
||
this.value = this.stringify.insValue(value);
|
||
}
|
||
}
|
||
|
||
XMLProcessingInstruction.prototype.clone = function() {
|
||
return create(XMLProcessingInstruction.prototype, this);
|
||
};
|
||
|
||
XMLProcessingInstruction.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += '<?';
|
||
r += this.target;
|
||
if (this.value) {
|
||
r += ' ' + this.value;
|
||
}
|
||
r += '?>';
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLProcessingInstruction;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{"lodash/object/create":64}],84:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLNode, XMLRaw, create,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
module.exports = XMLRaw = (function(superClass) {
|
||
extend(XMLRaw, superClass);
|
||
|
||
function XMLRaw(parent, text) {
|
||
XMLRaw.__super__.constructor.call(this, parent);
|
||
if (text == null) {
|
||
throw new Error("Missing raw text");
|
||
}
|
||
this.value = this.stringify.raw(text);
|
||
}
|
||
|
||
XMLRaw.prototype.clone = function() {
|
||
return create(XMLRaw.prototype, this);
|
||
};
|
||
|
||
XMLRaw.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += this.value;
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLRaw;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLNode":82,"lodash/object/create":64}],85:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLStringifier,
|
||
bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
module.exports = XMLStringifier = (function() {
|
||
function XMLStringifier(options) {
|
||
this.assertLegalChar = bind(this.assertLegalChar, this);
|
||
var key, ref, value;
|
||
this.allowSurrogateChars = options != null ? options.allowSurrogateChars : void 0;
|
||
ref = (options != null ? options.stringify : void 0) || {};
|
||
for (key in ref) {
|
||
if (!hasProp.call(ref, key)) continue;
|
||
value = ref[key];
|
||
this[key] = value;
|
||
}
|
||
}
|
||
|
||
XMLStringifier.prototype.eleName = function(val) {
|
||
val = '' + val || '';
|
||
return this.assertLegalChar(val);
|
||
};
|
||
|
||
XMLStringifier.prototype.eleText = function(val) {
|
||
val = '' + val || '';
|
||
return this.assertLegalChar(this.elEscape(val));
|
||
};
|
||
|
||
XMLStringifier.prototype.cdata = function(val) {
|
||
val = '' + val || '';
|
||
if (val.match(/]]>/)) {
|
||
throw new Error("Invalid CDATA text: " + val);
|
||
}
|
||
return this.assertLegalChar(val);
|
||
};
|
||
|
||
XMLStringifier.prototype.comment = function(val) {
|
||
val = '' + val || '';
|
||
if (val.match(/--/)) {
|
||
throw new Error("Comment text cannot contain double-hypen: " + val);
|
||
}
|
||
return this.assertLegalChar(val);
|
||
};
|
||
|
||
XMLStringifier.prototype.raw = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.attName = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.attValue = function(val) {
|
||
val = '' + val || '';
|
||
return this.attEscape(val);
|
||
};
|
||
|
||
XMLStringifier.prototype.insTarget = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.insValue = function(val) {
|
||
val = '' + val || '';
|
||
if (val.match(/\?>/)) {
|
||
throw new Error("Invalid processing instruction value: " + val);
|
||
}
|
||
return val;
|
||
};
|
||
|
||
XMLStringifier.prototype.xmlVersion = function(val) {
|
||
val = '' + val || '';
|
||
if (!val.match(/1\.[0-9]+/)) {
|
||
throw new Error("Invalid version number: " + val);
|
||
}
|
||
return val;
|
||
};
|
||
|
||
XMLStringifier.prototype.xmlEncoding = function(val) {
|
||
val = '' + val || '';
|
||
if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-]|-)*$/)) {
|
||
throw new Error("Invalid encoding: " + val);
|
||
}
|
||
return val;
|
||
};
|
||
|
||
XMLStringifier.prototype.xmlStandalone = function(val) {
|
||
if (val) {
|
||
return "yes";
|
||
} else {
|
||
return "no";
|
||
}
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdPubID = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdSysID = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdElementValue = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdAttType = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdAttDefault = function(val) {
|
||
if (val != null) {
|
||
return '' + val || '';
|
||
} else {
|
||
return val;
|
||
}
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdEntityValue = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.dtdNData = function(val) {
|
||
return '' + val || '';
|
||
};
|
||
|
||
XMLStringifier.prototype.convertAttKey = '@';
|
||
|
||
XMLStringifier.prototype.convertPIKey = '?';
|
||
|
||
XMLStringifier.prototype.convertTextKey = '#text';
|
||
|
||
XMLStringifier.prototype.convertCDataKey = '#cdata';
|
||
|
||
XMLStringifier.prototype.convertCommentKey = '#comment';
|
||
|
||
XMLStringifier.prototype.convertRawKey = '#raw';
|
||
|
||
XMLStringifier.prototype.assertLegalChar = function(str) {
|
||
var chars, chr;
|
||
if (this.allowSurrogateChars) {
|
||
chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]/;
|
||
} else {
|
||
chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/;
|
||
}
|
||
chr = str.match(chars);
|
||
if (chr) {
|
||
throw new Error("Invalid character (" + chr + ") in string: " + str + " at index " + chr.index);
|
||
}
|
||
return str;
|
||
};
|
||
|
||
XMLStringifier.prototype.elEscape = function(str) {
|
||
return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/\r/g, '
');
|
||
};
|
||
|
||
XMLStringifier.prototype.attEscape = function(str) {
|
||
return str.replace(/&/g, '&').replace(/</g, '<').replace(/"/g, '"');
|
||
};
|
||
|
||
return XMLStringifier;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
},{}],86:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLNode, XMLText, create,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
create = require('lodash/object/create');
|
||
|
||
XMLNode = require('./XMLNode');
|
||
|
||
module.exports = XMLText = (function(superClass) {
|
||
extend(XMLText, superClass);
|
||
|
||
function XMLText(parent, text) {
|
||
XMLText.__super__.constructor.call(this, parent);
|
||
if (text == null) {
|
||
throw new Error("Missing element text");
|
||
}
|
||
this.value = this.stringify.eleText(text);
|
||
}
|
||
|
||
XMLText.prototype.clone = function() {
|
||
return create(XMLText.prototype, this);
|
||
};
|
||
|
||
XMLText.prototype.toString = function(options, level) {
|
||
var indent, newline, offset, pretty, r, ref, ref1, ref2, space;
|
||
pretty = (options != null ? options.pretty : void 0) || false;
|
||
indent = (ref = options != null ? options.indent : void 0) != null ? ref : ' ';
|
||
offset = (ref1 = options != null ? options.offset : void 0) != null ? ref1 : 0;
|
||
newline = (ref2 = options != null ? options.newline : void 0) != null ? ref2 : '\n';
|
||
level || (level = 0);
|
||
space = new Array(level + offset + 1).join(indent);
|
||
r = '';
|
||
if (pretty) {
|
||
r += space;
|
||
}
|
||
r += this.value;
|
||
if (pretty) {
|
||
r += newline;
|
||
}
|
||
return r;
|
||
};
|
||
|
||
return XMLText;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLNode":82,"lodash/object/create":64}],87:[function(require,module,exports){
|
||
// Generated by CoffeeScript 1.9.1
|
||
(function() {
|
||
var XMLBuilder, assign;
|
||
|
||
assign = require('lodash/object/assign');
|
||
|
||
XMLBuilder = require('./XMLBuilder');
|
||
|
||
module.exports.create = function(name, xmldec, doctype, options) {
|
||
options = assign({}, xmldec, doctype, options);
|
||
return new XMLBuilder(name, options).root();
|
||
};
|
||
|
||
}).call(this);
|
||
|
||
},{"./XMLBuilder":72,"lodash/object/assign":63}],88:[function(require,module,exports){
|
||
function DOMParser(options){
|
||
this.options = options ||{locator:{}};
|
||
|
||
}
|
||
DOMParser.prototype.parseFromString = function(source,mimeType){
|
||
var options = this.options;
|
||
var sax = new XMLReader();
|
||
var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
|
||
var errorHandler = options.errorHandler;
|
||
var locator = options.locator;
|
||
var defaultNSMap = options.xmlns||{};
|
||
var entityMap = {'lt':'<','gt':'>','amp':'&','quot':'"','apos':"'"}
|
||
if(locator){
|
||
domBuilder.setDocumentLocator(locator)
|
||
}
|
||
|
||
sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
|
||
sax.domBuilder = options.domBuilder || domBuilder;
|
||
if(/\/x?html?$/.test(mimeType)){
|
||
entityMap.nbsp = '\xa0';
|
||
entityMap.copy = '\xa9';
|
||
defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
|
||
}
|
||
if(source){
|
||
sax.parse(source,defaultNSMap,entityMap);
|
||
}else{
|
||
sax.errorHandler.error("invalid document source");
|
||
}
|
||
return domBuilder.document;
|
||
}
|
||
function buildErrorHandler(errorImpl,domBuilder,locator){
|
||
if(!errorImpl){
|
||
if(domBuilder instanceof DOMHandler){
|
||
return domBuilder;
|
||
}
|
||
errorImpl = domBuilder ;
|
||
}
|
||
var errorHandler = {}
|
||
var isCallback = errorImpl instanceof Function;
|
||
locator = locator||{}
|
||
function build(key){
|
||
var fn = errorImpl[key];
|
||
if(!fn){
|
||
if(isCallback){
|
||
fn = errorImpl.length == 2?function(msg){errorImpl(key,msg)}:errorImpl;
|
||
}else{
|
||
var i=arguments.length;
|
||
while(--i){
|
||
if(fn = errorImpl[arguments[i]]){
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
errorHandler[key] = fn && function(msg){
|
||
fn(msg+_locator(locator));
|
||
}||function(){};
|
||
}
|
||
build('warning','warn');
|
||
build('error','warn','warning');
|
||
build('fatalError','warn','warning','error');
|
||
return errorHandler;
|
||
}
|
||
/**
|
||
* +ContentHandler+ErrorHandler
|
||
* +LexicalHandler+EntityResolver2
|
||
* -DeclHandler-DTDHandler
|
||
*
|
||
* DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
|
||
* DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
|
||
*/
|
||
function DOMHandler() {
|
||
this.cdata = false;
|
||
}
|
||
function position(locator,node){
|
||
node.lineNumber = locator.lineNumber;
|
||
node.columnNumber = locator.columnNumber;
|
||
}
|
||
/**
|
||
* @see org.xml.sax.ContentHandler#startDocument
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
|
||
*/
|
||
DOMHandler.prototype = {
|
||
startDocument : function() {
|
||
this.document = new DOMImplementation().createDocument(null, null, null);
|
||
if (this.locator) {
|
||
this.document.documentURI = this.locator.systemId;
|
||
}
|
||
},
|
||
startElement:function(namespaceURI, localName, qName, attrs) {
|
||
var doc = this.document;
|
||
var el = doc.createElementNS(namespaceURI, qName||localName);
|
||
var len = attrs.length;
|
||
appendElement(this, el);
|
||
this.currentElement = el;
|
||
|
||
this.locator && position(this.locator,el)
|
||
for (var i = 0 ; i < len; i++) {
|
||
var namespaceURI = attrs.getURI(i);
|
||
var value = attrs.getValue(i);
|
||
var qName = attrs.getQName(i);
|
||
var attr = doc.createAttributeNS(namespaceURI, qName);
|
||
if( attr.getOffset){
|
||
position(attr.getOffset(1),attr)
|
||
}
|
||
attr.value = attr.nodeValue = value;
|
||
el.setAttributeNode(attr)
|
||
}
|
||
},
|
||
endElement:function(namespaceURI, localName, qName) {
|
||
var current = this.currentElement
|
||
var tagName = current.tagName;
|
||
this.currentElement = current.parentNode;
|
||
},
|
||
startPrefixMapping:function(prefix, uri) {
|
||
},
|
||
endPrefixMapping:function(prefix) {
|
||
},
|
||
processingInstruction:function(target, data) {
|
||
var ins = this.document.createProcessingInstruction(target, data);
|
||
this.locator && position(this.locator,ins)
|
||
appendElement(this, ins);
|
||
},
|
||
ignorableWhitespace:function(ch, start, length) {
|
||
},
|
||
characters:function(chars, start, length) {
|
||
chars = _toString.apply(this,arguments)
|
||
//console.log(chars)
|
||
if(this.currentElement && chars){
|
||
if (this.cdata) {
|
||
var charNode = this.document.createCDATASection(chars);
|
||
this.currentElement.appendChild(charNode);
|
||
} else {
|
||
var charNode = this.document.createTextNode(chars);
|
||
this.currentElement.appendChild(charNode);
|
||
}
|
||
this.locator && position(this.locator,charNode)
|
||
}
|
||
},
|
||
skippedEntity:function(name) {
|
||
},
|
||
endDocument:function() {
|
||
this.document.normalize();
|
||
},
|
||
setDocumentLocator:function (locator) {
|
||
if(this.locator = locator){// && !('lineNumber' in locator)){
|
||
locator.lineNumber = 0;
|
||
}
|
||
},
|
||
//LexicalHandler
|
||
comment:function(chars, start, length) {
|
||
chars = _toString.apply(this,arguments)
|
||
var comm = this.document.createComment(chars);
|
||
this.locator && position(this.locator,comm)
|
||
appendElement(this, comm);
|
||
},
|
||
|
||
startCDATA:function() {
|
||
//used in characters() methods
|
||
this.cdata = true;
|
||
},
|
||
endCDATA:function() {
|
||
this.cdata = false;
|
||
},
|
||
|
||
startDTD:function(name, publicId, systemId) {
|
||
var impl = this.document.implementation;
|
||
if (impl && impl.createDocumentType) {
|
||
var dt = impl.createDocumentType(name, publicId, systemId);
|
||
this.locator && position(this.locator,dt)
|
||
appendElement(this, dt);
|
||
}
|
||
},
|
||
/**
|
||
* @see org.xml.sax.ErrorHandler
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
|
||
*/
|
||
warning:function(error) {
|
||
console.warn(error,_locator(this.locator));
|
||
},
|
||
error:function(error) {
|
||
console.error(error,_locator(this.locator));
|
||
},
|
||
fatalError:function(error) {
|
||
console.error(error,_locator(this.locator));
|
||
throw error;
|
||
}
|
||
}
|
||
function _locator(l){
|
||
if(l){
|
||
return '\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'
|
||
}
|
||
}
|
||
function _toString(chars,start,length){
|
||
if(typeof chars == 'string'){
|
||
return chars.substr(start,length)
|
||
}else{//java sax connect width xmldom on rhino(what about: "? && !(chars instanceof String)")
|
||
if(chars.length >= start+length || start){
|
||
return new java.lang.String(chars,start,length)+'';
|
||
}
|
||
return chars;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html
|
||
* used method of org.xml.sax.ext.LexicalHandler:
|
||
* #comment(chars, start, length)
|
||
* #startCDATA()
|
||
* #endCDATA()
|
||
* #startDTD(name, publicId, systemId)
|
||
*
|
||
*
|
||
* IGNORED method of org.xml.sax.ext.LexicalHandler:
|
||
* #endDTD()
|
||
* #startEntity(name)
|
||
* #endEntity(name)
|
||
*
|
||
*
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html
|
||
* IGNORED method of org.xml.sax.ext.DeclHandler
|
||
* #attributeDecl(eName, aName, type, mode, value)
|
||
* #elementDecl(name, model)
|
||
* #externalEntityDecl(name, publicId, systemId)
|
||
* #internalEntityDecl(name, value)
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html
|
||
* IGNORED method of org.xml.sax.EntityResolver2
|
||
* #resolveEntity(String name,String publicId,String baseURI,String systemId)
|
||
* #resolveEntity(publicId, systemId)
|
||
* #getExternalSubset(name, baseURI)
|
||
* @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html
|
||
* IGNORED method of org.xml.sax.DTDHandler
|
||
* #notationDecl(name, publicId, systemId) {};
|
||
* #unparsedEntityDecl(name, publicId, systemId, notationName) {};
|
||
*/
|
||
"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g,function(key){
|
||
DOMHandler.prototype[key] = function(){return null}
|
||
})
|
||
|
||
/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
|
||
function appendElement (hander,node) {
|
||
if (!hander.currentElement) {
|
||
hander.document.appendChild(node);
|
||
} else {
|
||
hander.currentElement.appendChild(node);
|
||
}
|
||
}//appendChild and setAttributeNS are preformance key
|
||
|
||
if(typeof require == 'function'){
|
||
var XMLReader = require('./sax').XMLReader;
|
||
var DOMImplementation = exports.DOMImplementation = require('./dom').DOMImplementation;
|
||
exports.XMLSerializer = require('./dom').XMLSerializer ;
|
||
exports.DOMParser = DOMParser;
|
||
}
|
||
|
||
},{"./dom":89,"./sax":90}],89:[function(require,module,exports){
|
||
/*
|
||
* DOM Level 2
|
||
* Object DOMException
|
||
* @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
|
||
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
|
||
*/
|
||
|
||
function copy(src,dest){
|
||
for(var p in src){
|
||
dest[p] = src[p];
|
||
}
|
||
}
|
||
/**
|
||
^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
|
||
^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
|
||
*/
|
||
function _extends(Class,Super){
|
||
var pt = Class.prototype;
|
||
if(Object.create){
|
||
var ppt = Object.create(Super.prototype)
|
||
pt.__proto__ = ppt;
|
||
}
|
||
if(!(pt instanceof Super)){
|
||
function t(){};
|
||
t.prototype = Super.prototype;
|
||
t = new t();
|
||
copy(pt,t);
|
||
Class.prototype = pt = t;
|
||
}
|
||
if(pt.constructor != Class){
|
||
if(typeof Class != 'function'){
|
||
console.error("unknow Class:"+Class)
|
||
}
|
||
pt.constructor = Class
|
||
}
|
||
}
|
||
var htmlns = 'http://www.w3.org/1999/xhtml' ;
|
||
// Node Types
|
||
var NodeType = {}
|
||
var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
|
||
var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
|
||
var TEXT_NODE = NodeType.TEXT_NODE = 3;
|
||
var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
|
||
var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
|
||
var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
|
||
var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
|
||
var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
|
||
var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
|
||
var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
|
||
var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
|
||
var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
|
||
|
||
// ExceptionCode
|
||
var ExceptionCode = {}
|
||
var ExceptionMessage = {};
|
||
var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = ((ExceptionMessage[1]="Index size error"),1);
|
||
var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = ((ExceptionMessage[2]="DOMString size error"),2);
|
||
var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = ((ExceptionMessage[3]="Hierarchy request error"),3);
|
||
var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = ((ExceptionMessage[4]="Wrong document"),4);
|
||
var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = ((ExceptionMessage[5]="Invalid character"),5);
|
||
var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = ((ExceptionMessage[6]="No data allowed"),6);
|
||
var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ((ExceptionMessage[7]="No modification allowed"),7);
|
||
var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = ((ExceptionMessage[8]="Not found"),8);
|
||
var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = ((ExceptionMessage[9]="Not supported"),9);
|
||
var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = ((ExceptionMessage[10]="Attribute in use"),10);
|
||
//level2
|
||
var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = ((ExceptionMessage[11]="Invalid state"),11);
|
||
var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = ((ExceptionMessage[12]="Syntax error"),12);
|
||
var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = ((ExceptionMessage[13]="Invalid modification"),13);
|
||
var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = ((ExceptionMessage[14]="Invalid namespace"),14);
|
||
var INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = ((ExceptionMessage[15]="Invalid access"),15);
|
||
|
||
|
||
function DOMException(code, message) {
|
||
if(message instanceof Error){
|
||
var error = message;
|
||
}else{
|
||
error = this;
|
||
Error.call(this, ExceptionMessage[code]);
|
||
this.message = ExceptionMessage[code];
|
||
if(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
|
||
}
|
||
error.code = code;
|
||
if(message) this.message = this.message + ": " + message;
|
||
return error;
|
||
};
|
||
DOMException.prototype = Error.prototype;
|
||
copy(ExceptionCode,DOMException)
|
||
/**
|
||
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
|
||
* The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
|
||
* The items in the NodeList are accessible via an integral index, starting from 0.
|
||
*/
|
||
function NodeList() {
|
||
};
|
||
NodeList.prototype = {
|
||
/**
|
||
* The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
|
||
* @standard level1
|
||
*/
|
||
length:0,
|
||
/**
|
||
* Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
|
||
* @standard level1
|
||
* @param index unsigned long
|
||
* Index into the collection.
|
||
* @return Node
|
||
* The node at the indexth position in the NodeList, or null if that is not a valid index.
|
||
*/
|
||
item: function(index) {
|
||
return this[index] || null;
|
||
}
|
||
};
|
||
function LiveNodeList(node,refresh){
|
||
this._node = node;
|
||
this._refresh = refresh
|
||
_updateLiveList(this);
|
||
}
|
||
function _updateLiveList(list){
|
||
var inc = list._node._inc || list._node.ownerDocument._inc;
|
||
if(list._inc != inc){
|
||
var ls = list._refresh(list._node);
|
||
//console.log(ls.length)
|
||
__set__(list,'length',ls.length);
|
||
copy(ls,list);
|
||
list._inc = inc;
|
||
}
|
||
}
|
||
LiveNodeList.prototype.item = function(i){
|
||
_updateLiveList(this);
|
||
return this[i];
|
||
}
|
||
|
||
_extends(LiveNodeList,NodeList);
|
||
/**
|
||
*
|
||
* Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. Note that NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes.
|
||
* NamedNodeMap objects in the DOM are live.
|
||
* used for attributes or DocumentType entities
|
||
*/
|
||
function NamedNodeMap() {
|
||
};
|
||
|
||
function _findNodeIndex(list,node){
|
||
var i = list.length;
|
||
while(i--){
|
||
if(list[i] === node){return i}
|
||
}
|
||
}
|
||
|
||
function _addNamedNode(el,list,newAttr,oldAttr){
|
||
if(oldAttr){
|
||
list[_findNodeIndex(list,oldAttr)] = newAttr;
|
||
}else{
|
||
list[list.length++] = newAttr;
|
||
}
|
||
if(el){
|
||
newAttr.ownerElement = el;
|
||
var doc = el.ownerDocument;
|
||
if(doc){
|
||
oldAttr && _onRemoveAttribute(doc,el,oldAttr);
|
||
_onAddAttribute(doc,el,newAttr);
|
||
}
|
||
}
|
||
}
|
||
function _removeNamedNode(el,list,attr){
|
||
var i = _findNodeIndex(list,attr);
|
||
if(i>=0){
|
||
var lastIndex = list.length-1
|
||
while(i<lastIndex){
|
||
list[i] = list[++i]
|
||
}
|
||
list.length = lastIndex;
|
||
if(el){
|
||
var doc = el.ownerDocument;
|
||
if(doc){
|
||
_onRemoveAttribute(doc,el,attr);
|
||
attr.ownerElement = null;
|
||
}
|
||
}
|
||
}else{
|
||
throw DOMException(NOT_FOUND_ERR,new Error())
|
||
}
|
||
}
|
||
NamedNodeMap.prototype = {
|
||
length:0,
|
||
item:NodeList.prototype.item,
|
||
getNamedItem: function(key) {
|
||
// if(key.indexOf(':')>0 || key == 'xmlns'){
|
||
// return null;
|
||
// }
|
||
var i = this.length;
|
||
while(i--){
|
||
var attr = this[i];
|
||
if(attr.nodeName == key){
|
||
return attr;
|
||
}
|
||
}
|
||
},
|
||
setNamedItem: function(attr) {
|
||
var el = attr.ownerElement;
|
||
if(el && el!=this._ownerElement){
|
||
throw new DOMException(INUSE_ATTRIBUTE_ERR);
|
||
}
|
||
var oldAttr = this.getNamedItem(attr.nodeName);
|
||
_addNamedNode(this._ownerElement,this,attr,oldAttr);
|
||
return oldAttr;
|
||
},
|
||
/* returns Node */
|
||
setNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR
|
||
var el = attr.ownerElement, oldAttr;
|
||
if(el && el!=this._ownerElement){
|
||
throw new DOMException(INUSE_ATTRIBUTE_ERR);
|
||
}
|
||
oldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);
|
||
_addNamedNode(this._ownerElement,this,attr,oldAttr);
|
||
return oldAttr;
|
||
},
|
||
|
||
/* returns Node */
|
||
removeNamedItem: function(key) {
|
||
var attr = this.getNamedItem(key);
|
||
_removeNamedNode(this._ownerElement,this,attr);
|
||
return attr;
|
||
|
||
|
||
},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
|
||
|
||
//for level2
|
||
removeNamedItemNS:function(namespaceURI,localName){
|
||
var attr = this.getNamedItemNS(namespaceURI,localName);
|
||
_removeNamedNode(this._ownerElement,this,attr);
|
||
return attr;
|
||
},
|
||
getNamedItemNS: function(namespaceURI, localName) {
|
||
var i = this.length;
|
||
while(i--){
|
||
var node = this[i];
|
||
if(node.localName == localName && node.namespaceURI == namespaceURI){
|
||
return node;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
};
|
||
/**
|
||
* @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490
|
||
*/
|
||
function DOMImplementation(/* Object */ features) {
|
||
this._features = {};
|
||
if (features) {
|
||
for (var feature in features) {
|
||
this._features = features[feature];
|
||
}
|
||
}
|
||
};
|
||
|
||
DOMImplementation.prototype = {
|
||
hasFeature: function(/* string */ feature, /* string */ version) {
|
||
var versions = this._features[feature.toLowerCase()];
|
||
if (versions && (!version || version in versions)) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
createDocument:function(namespaceURI, qualifiedName, doctype){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR,WRONG_DOCUMENT_ERR
|
||
var doc = new Document();
|
||
doc.doctype = doctype;
|
||
if(doctype){
|
||
doc.appendChild(doctype);
|
||
}
|
||
doc.implementation = this;
|
||
doc.childNodes = new NodeList();
|
||
if(qualifiedName){
|
||
var root = doc.createElementNS(namespaceURI,qualifiedName);
|
||
doc.appendChild(root);
|
||
}
|
||
return doc;
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
createDocumentType:function(qualifiedName, publicId, systemId){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR
|
||
var node = new DocumentType();
|
||
node.name = qualifiedName;
|
||
node.nodeName = qualifiedName;
|
||
node.publicId = publicId;
|
||
node.systemId = systemId;
|
||
// Introduced in DOM Level 2:
|
||
//readonly attribute DOMString internalSubset;
|
||
|
||
//TODO:..
|
||
// readonly attribute NamedNodeMap entities;
|
||
// readonly attribute NamedNodeMap notations;
|
||
return node;
|
||
}
|
||
};
|
||
|
||
|
||
/**
|
||
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
|
||
*/
|
||
|
||
function Node() {
|
||
};
|
||
|
||
Node.prototype = {
|
||
firstChild : null,
|
||
lastChild : null,
|
||
previousSibling : null,
|
||
nextSibling : null,
|
||
attributes : null,
|
||
parentNode : null,
|
||
childNodes : null,
|
||
ownerDocument : null,
|
||
nodeValue : null,
|
||
namespaceURI : null,
|
||
prefix : null,
|
||
localName : null,
|
||
// Modified in DOM Level 2:
|
||
insertBefore:function(newChild, refChild){//raises
|
||
return _insertBefore(this,newChild,refChild);
|
||
},
|
||
replaceChild:function(newChild, oldChild){//raises
|
||
this.insertBefore(newChild,oldChild);
|
||
if(oldChild){
|
||
this.removeChild(oldChild);
|
||
}
|
||
},
|
||
removeChild:function(oldChild){
|
||
return _removeChild(this,oldChild);
|
||
},
|
||
appendChild:function(newChild){
|
||
return this.insertBefore(newChild,null);
|
||
},
|
||
hasChildNodes:function(){
|
||
return this.firstChild != null;
|
||
},
|
||
cloneNode:function(deep){
|
||
return cloneNode(this.ownerDocument||this,this,deep);
|
||
},
|
||
// Modified in DOM Level 2:
|
||
normalize:function(){
|
||
var child = this.firstChild;
|
||
while(child){
|
||
var next = child.nextSibling;
|
||
if(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){
|
||
this.removeChild(next);
|
||
child.appendData(next.data);
|
||
}else{
|
||
child.normalize();
|
||
child = next;
|
||
}
|
||
}
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
isSupported:function(feature, version){
|
||
return this.ownerDocument.implementation.hasFeature(feature,version);
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
hasAttributes:function(){
|
||
return this.attributes.length>0;
|
||
},
|
||
lookupPrefix:function(namespaceURI){
|
||
var el = this;
|
||
while(el){
|
||
var map = el._nsMap;
|
||
//console.dir(map)
|
||
if(map){
|
||
for(var n in map){
|
||
if(map[n] == namespaceURI){
|
||
return n;
|
||
}
|
||
}
|
||
}
|
||
el = el.nodeType == 2?el.ownerDocument : el.parentNode;
|
||
}
|
||
return null;
|
||
},
|
||
// Introduced in DOM Level 3:
|
||
lookupNamespaceURI:function(prefix){
|
||
var el = this;
|
||
while(el){
|
||
var map = el._nsMap;
|
||
//console.dir(map)
|
||
if(map){
|
||
if(prefix in map){
|
||
return map[prefix] ;
|
||
}
|
||
}
|
||
el = el.nodeType == 2?el.ownerDocument : el.parentNode;
|
||
}
|
||
return null;
|
||
},
|
||
// Introduced in DOM Level 3:
|
||
isDefaultNamespace:function(namespaceURI){
|
||
var prefix = this.lookupPrefix(namespaceURI);
|
||
return prefix == null;
|
||
}
|
||
};
|
||
|
||
|
||
function _xmlEncoder(c){
|
||
return c == '<' && '<' ||
|
||
c == '>' && '>' ||
|
||
c == '&' && '&' ||
|
||
c == '"' && '"' ||
|
||
'&#'+c.charCodeAt()+';'
|
||
}
|
||
|
||
|
||
copy(NodeType,Node);
|
||
copy(NodeType,Node.prototype);
|
||
|
||
/**
|
||
* @param callback return true for continue,false for break
|
||
* @return boolean true: break visit;
|
||
*/
|
||
function _visitNode(node,callback){
|
||
if(callback(node)){
|
||
return true;
|
||
}
|
||
if(node = node.firstChild){
|
||
do{
|
||
if(_visitNode(node,callback)){return true}
|
||
}while(node=node.nextSibling)
|
||
}
|
||
}
|
||
|
||
|
||
|
||
function Document(){
|
||
}
|
||
function _onAddAttribute(doc,el,newAttr){
|
||
doc && doc._inc++;
|
||
var ns = newAttr.namespaceURI ;
|
||
if(ns == 'http://www.w3.org/2000/xmlns/'){
|
||
//update namespace
|
||
el._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value
|
||
}
|
||
}
|
||
function _onRemoveAttribute(doc,el,newAttr,remove){
|
||
doc && doc._inc++;
|
||
var ns = newAttr.namespaceURI ;
|
||
if(ns == 'http://www.w3.org/2000/xmlns/'){
|
||
//update namespace
|
||
delete el._nsMap[newAttr.prefix?newAttr.localName:'']
|
||
}
|
||
}
|
||
function _onUpdateChild(doc,el,newChild){
|
||
if(doc && doc._inc){
|
||
doc._inc++;
|
||
//update childNodes
|
||
var cs = el.childNodes;
|
||
if(newChild){
|
||
cs[cs.length++] = newChild;
|
||
}else{
|
||
//console.log(1)
|
||
var child = el.firstChild;
|
||
var i = 0;
|
||
while(child){
|
||
cs[i++] = child;
|
||
child =child.nextSibling;
|
||
}
|
||
cs.length = i;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* attributes;
|
||
* children;
|
||
*
|
||
* writeable properties:
|
||
* nodeValue,Attr:value,CharacterData:data
|
||
* prefix
|
||
*/
|
||
function _removeChild(parentNode,child){
|
||
var previous = child.previousSibling;
|
||
var next = child.nextSibling;
|
||
if(previous){
|
||
previous.nextSibling = next;
|
||
}else{
|
||
parentNode.firstChild = next
|
||
}
|
||
if(next){
|
||
next.previousSibling = previous;
|
||
}else{
|
||
parentNode.lastChild = previous;
|
||
}
|
||
_onUpdateChild(parentNode.ownerDocument,parentNode);
|
||
return child;
|
||
}
|
||
/**
|
||
* preformance key(refChild == null)
|
||
*/
|
||
function _insertBefore(parentNode,newChild,nextChild){
|
||
var cp = newChild.parentNode;
|
||
if(cp){
|
||
cp.removeChild(newChild);//remove and update
|
||
}
|
||
if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
|
||
var newFirst = newChild.firstChild;
|
||
if (newFirst == null) {
|
||
return newChild;
|
||
}
|
||
var newLast = newChild.lastChild;
|
||
}else{
|
||
newFirst = newLast = newChild;
|
||
}
|
||
var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
|
||
|
||
newFirst.previousSibling = pre;
|
||
newLast.nextSibling = nextChild;
|
||
|
||
|
||
if(pre){
|
||
pre.nextSibling = newFirst;
|
||
}else{
|
||
parentNode.firstChild = newFirst;
|
||
}
|
||
if(nextChild == null){
|
||
parentNode.lastChild = newLast;
|
||
}else{
|
||
nextChild.previousSibling = newLast;
|
||
}
|
||
do{
|
||
newFirst.parentNode = parentNode;
|
||
}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))
|
||
_onUpdateChild(parentNode.ownerDocument||parentNode,parentNode);
|
||
//console.log(parentNode.lastChild.nextSibling == null)
|
||
if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
|
||
newChild.firstChild = newChild.lastChild = null;
|
||
}
|
||
return newChild;
|
||
}
|
||
function _appendSingleChild(parentNode,newChild){
|
||
var cp = newChild.parentNode;
|
||
if(cp){
|
||
var pre = parentNode.lastChild;
|
||
cp.removeChild(newChild);//remove and update
|
||
var pre = parentNode.lastChild;
|
||
}
|
||
var pre = parentNode.lastChild;
|
||
newChild.parentNode = parentNode;
|
||
newChild.previousSibling = pre;
|
||
newChild.nextSibling = null;
|
||
if(pre){
|
||
pre.nextSibling = newChild;
|
||
}else{
|
||
parentNode.firstChild = newChild;
|
||
}
|
||
parentNode.lastChild = newChild;
|
||
_onUpdateChild(parentNode.ownerDocument,parentNode,newChild);
|
||
return newChild;
|
||
//console.log("__aa",parentNode.lastChild.nextSibling == null)
|
||
}
|
||
Document.prototype = {
|
||
//implementation : null,
|
||
nodeName : '#document',
|
||
nodeType : DOCUMENT_NODE,
|
||
doctype : null,
|
||
documentElement : null,
|
||
_inc : 1,
|
||
|
||
insertBefore : function(newChild, refChild){//raises
|
||
if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
|
||
var child = newChild.firstChild;
|
||
while(child){
|
||
var next = child.nextSibling;
|
||
this.insertBefore(child,refChild);
|
||
child = next;
|
||
}
|
||
return newChild;
|
||
}
|
||
if(this.documentElement == null && newChild.nodeType == 1){
|
||
this.documentElement = newChild;
|
||
}
|
||
|
||
return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
|
||
},
|
||
removeChild : function(oldChild){
|
||
if(this.documentElement == oldChild){
|
||
this.documentElement = null;
|
||
}
|
||
return _removeChild(this,oldChild);
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
importNode : function(importedNode,deep){
|
||
return importNode(this,importedNode,deep);
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
getElementById : function(id){
|
||
var rtv = null;
|
||
_visitNode(this.documentElement,function(node){
|
||
if(node.nodeType == 1){
|
||
if(node.getAttribute('id') == id){
|
||
rtv = node;
|
||
return true;
|
||
}
|
||
}
|
||
})
|
||
return rtv;
|
||
},
|
||
|
||
//document factory method:
|
||
createElement : function(tagName){
|
||
var node = new Element();
|
||
node.ownerDocument = this;
|
||
node.nodeName = tagName;
|
||
node.tagName = tagName;
|
||
node.childNodes = new NodeList();
|
||
var attrs = node.attributes = new NamedNodeMap();
|
||
attrs._ownerElement = node;
|
||
return node;
|
||
},
|
||
createDocumentFragment : function(){
|
||
var node = new DocumentFragment();
|
||
node.ownerDocument = this;
|
||
node.childNodes = new NodeList();
|
||
return node;
|
||
},
|
||
createTextNode : function(data){
|
||
var node = new Text();
|
||
node.ownerDocument = this;
|
||
node.appendData(data)
|
||
return node;
|
||
},
|
||
createComment : function(data){
|
||
var node = new Comment();
|
||
node.ownerDocument = this;
|
||
node.appendData(data)
|
||
return node;
|
||
},
|
||
createCDATASection : function(data){
|
||
var node = new CDATASection();
|
||
node.ownerDocument = this;
|
||
node.appendData(data)
|
||
return node;
|
||
},
|
||
createProcessingInstruction : function(target,data){
|
||
var node = new ProcessingInstruction();
|
||
node.ownerDocument = this;
|
||
node.tagName = node.target = target;
|
||
node.nodeValue= node.data = data;
|
||
return node;
|
||
},
|
||
createAttribute : function(name){
|
||
var node = new Attr();
|
||
node.ownerDocument = this;
|
||
node.name = name;
|
||
node.nodeName = name;
|
||
node.localName = name;
|
||
node.specified = true;
|
||
return node;
|
||
},
|
||
createEntityReference : function(name){
|
||
var node = new EntityReference();
|
||
node.ownerDocument = this;
|
||
node.nodeName = name;
|
||
return node;
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
createElementNS : function(namespaceURI,qualifiedName){
|
||
var node = new Element();
|
||
var pl = qualifiedName.split(':');
|
||
var attrs = node.attributes = new NamedNodeMap();
|
||
node.childNodes = new NodeList();
|
||
node.ownerDocument = this;
|
||
node.nodeName = qualifiedName;
|
||
node.tagName = qualifiedName;
|
||
node.namespaceURI = namespaceURI;
|
||
if(pl.length == 2){
|
||
node.prefix = pl[0];
|
||
node.localName = pl[1];
|
||
}else{
|
||
//el.prefix = null;
|
||
node.localName = qualifiedName;
|
||
}
|
||
attrs._ownerElement = node;
|
||
return node;
|
||
},
|
||
// Introduced in DOM Level 2:
|
||
createAttributeNS : function(namespaceURI,qualifiedName){
|
||
var node = new Attr();
|
||
var pl = qualifiedName.split(':');
|
||
node.ownerDocument = this;
|
||
node.nodeName = qualifiedName;
|
||
node.name = qualifiedName;
|
||
node.namespaceURI = namespaceURI;
|
||
node.specified = true;
|
||
if(pl.length == 2){
|
||
node.prefix = pl[0];
|
||
node.localName = pl[1];
|
||
}else{
|
||
//el.prefix = null;
|
||
node.localName = qualifiedName;
|
||
}
|
||
return node;
|
||
}
|
||
};
|
||
_extends(Document,Node);
|
||
|
||
|
||
function Element() {
|
||
this._nsMap = {};
|
||
};
|
||
Element.prototype = {
|
||
nodeType : ELEMENT_NODE,
|
||
hasAttribute : function(name){
|
||
return this.getAttributeNode(name)!=null;
|
||
},
|
||
getAttribute : function(name){
|
||
var attr = this.getAttributeNode(name);
|
||
return attr && attr.value || '';
|
||
},
|
||
getAttributeNode : function(name){
|
||
return this.attributes.getNamedItem(name);
|
||
},
|
||
setAttribute : function(name, value){
|
||
var attr = this.ownerDocument.createAttribute(name);
|
||
attr.value = attr.nodeValue = "" + value;
|
||
this.setAttributeNode(attr)
|
||
},
|
||
removeAttribute : function(name){
|
||
var attr = this.getAttributeNode(name)
|
||
attr && this.removeAttributeNode(attr);
|
||
},
|
||
|
||
//four real opeartion method
|
||
appendChild:function(newChild){
|
||
if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
|
||
return this.insertBefore(newChild,null);
|
||
}else{
|
||
return _appendSingleChild(this,newChild);
|
||
}
|
||
},
|
||
setAttributeNode : function(newAttr){
|
||
return this.attributes.setNamedItem(newAttr);
|
||
},
|
||
setAttributeNodeNS : function(newAttr){
|
||
return this.attributes.setNamedItemNS(newAttr);
|
||
},
|
||
removeAttributeNode : function(oldAttr){
|
||
return this.attributes.removeNamedItem(oldAttr.nodeName);
|
||
},
|
||
//get real attribute name,and remove it by removeAttributeNode
|
||
removeAttributeNS : function(namespaceURI, localName){
|
||
var old = this.getAttributeNodeNS(namespaceURI, localName);
|
||
old && this.removeAttributeNode(old);
|
||
},
|
||
|
||
hasAttributeNS : function(namespaceURI, localName){
|
||
return this.getAttributeNodeNS(namespaceURI, localName)!=null;
|
||
},
|
||
getAttributeNS : function(namespaceURI, localName){
|
||
var attr = this.getAttributeNodeNS(namespaceURI, localName);
|
||
return attr && attr.value || '';
|
||
},
|
||
setAttributeNS : function(namespaceURI, qualifiedName, value){
|
||
var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
|
||
attr.value = attr.nodeValue = value;
|
||
this.setAttributeNode(attr)
|
||
},
|
||
getAttributeNodeNS : function(namespaceURI, localName){
|
||
return this.attributes.getNamedItemNS(namespaceURI, localName);
|
||
},
|
||
|
||
getElementsByTagName : function(tagName){
|
||
return new LiveNodeList(this,function(base){
|
||
var ls = [];
|
||
_visitNode(base,function(node){
|
||
if(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){
|
||
ls.push(node);
|
||
}
|
||
});
|
||
return ls;
|
||
});
|
||
},
|
||
getElementsByTagNameNS : function(namespaceURI, localName){
|
||
return new LiveNodeList(this,function(base){
|
||
var ls = [];
|
||
_visitNode(base,function(node){
|
||
if(node !== base && node.nodeType === ELEMENT_NODE && node.namespaceURI === namespaceURI && (localName === '*' || node.localName == localName)){
|
||
ls.push(node);
|
||
}
|
||
});
|
||
return ls;
|
||
});
|
||
}
|
||
};
|
||
Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
|
||
Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
|
||
|
||
|
||
_extends(Element,Node);
|
||
function Attr() {
|
||
};
|
||
Attr.prototype.nodeType = ATTRIBUTE_NODE;
|
||
_extends(Attr,Node);
|
||
|
||
|
||
function CharacterData() {
|
||
};
|
||
CharacterData.prototype = {
|
||
data : '',
|
||
substringData : function(offset, count) {
|
||
return this.data.substring(offset, offset+count);
|
||
},
|
||
appendData: function(text) {
|
||
text = this.data+text;
|
||
this.nodeValue = this.data = text;
|
||
this.length = text.length;
|
||
},
|
||
insertData: function(offset,text) {
|
||
this.replaceData(offset,0,text);
|
||
|
||
},
|
||
appendChild:function(newChild){
|
||
//if(!(newChild instanceof CharacterData)){
|
||
throw new Error(ExceptionMessage[3])
|
||
//}
|
||
return Node.prototype.appendChild.apply(this,arguments)
|
||
},
|
||
deleteData: function(offset, count) {
|
||
this.replaceData(offset,count,"");
|
||
},
|
||
replaceData: function(offset, count, text) {
|
||
var start = this.data.substring(0,offset);
|
||
var end = this.data.substring(offset+count);
|
||
text = start + text + end;
|
||
this.nodeValue = this.data = text;
|
||
this.length = text.length;
|
||
}
|
||
}
|
||
_extends(CharacterData,Node);
|
||
function Text() {
|
||
};
|
||
Text.prototype = {
|
||
nodeName : "#text",
|
||
nodeType : TEXT_NODE,
|
||
splitText : function(offset) {
|
||
var text = this.data;
|
||
var newText = text.substring(offset);
|
||
text = text.substring(0, offset);
|
||
this.data = this.nodeValue = text;
|
||
this.length = text.length;
|
||
var newNode = this.ownerDocument.createTextNode(newText);
|
||
if(this.parentNode){
|
||
this.parentNode.insertBefore(newNode, this.nextSibling);
|
||
}
|
||
return newNode;
|
||
}
|
||
}
|
||
_extends(Text,CharacterData);
|
||
function Comment() {
|
||
};
|
||
Comment.prototype = {
|
||
nodeName : "#comment",
|
||
nodeType : COMMENT_NODE
|
||
}
|
||
_extends(Comment,CharacterData);
|
||
|
||
function CDATASection() {
|
||
};
|
||
CDATASection.prototype = {
|
||
nodeName : "#cdata-section",
|
||
nodeType : CDATA_SECTION_NODE
|
||
}
|
||
_extends(CDATASection,CharacterData);
|
||
|
||
|
||
function DocumentType() {
|
||
};
|
||
DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
|
||
_extends(DocumentType,Node);
|
||
|
||
function Notation() {
|
||
};
|
||
Notation.prototype.nodeType = NOTATION_NODE;
|
||
_extends(Notation,Node);
|
||
|
||
function Entity() {
|
||
};
|
||
Entity.prototype.nodeType = ENTITY_NODE;
|
||
_extends(Entity,Node);
|
||
|
||
function EntityReference() {
|
||
};
|
||
EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
|
||
_extends(EntityReference,Node);
|
||
|
||
function DocumentFragment() {
|
||
};
|
||
DocumentFragment.prototype.nodeName = "#document-fragment";
|
||
DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
|
||
_extends(DocumentFragment,Node);
|
||
|
||
|
||
function ProcessingInstruction() {
|
||
}
|
||
ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
|
||
_extends(ProcessingInstruction,Node);
|
||
function XMLSerializer(){}
|
||
XMLSerializer.prototype.serializeToString = function(node){
|
||
var buf = [];
|
||
serializeToString(node,buf);
|
||
return buf.join('');
|
||
}
|
||
Node.prototype.toString =function(){
|
||
return XMLSerializer.prototype.serializeToString(this);
|
||
}
|
||
function serializeToString(node,buf){
|
||
switch(node.nodeType){
|
||
case ELEMENT_NODE:
|
||
var attrs = node.attributes;
|
||
var len = attrs.length;
|
||
var child = node.firstChild;
|
||
var nodeName = node.tagName;
|
||
var isHTML = htmlns === node.namespaceURI
|
||
buf.push('<',nodeName);
|
||
for(var i=0;i<len;i++){
|
||
serializeToString(attrs.item(i),buf,isHTML);
|
||
}
|
||
if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
|
||
buf.push('>');
|
||
//if is cdata child node
|
||
if(isHTML && /^script$/i.test(nodeName)){
|
||
if(child){
|
||
buf.push(child.data);
|
||
}
|
||
}else{
|
||
while(child){
|
||
serializeToString(child,buf);
|
||
child = child.nextSibling;
|
||
}
|
||
}
|
||
buf.push('</',nodeName,'>');
|
||
}else{
|
||
buf.push('/>');
|
||
}
|
||
return;
|
||
case DOCUMENT_NODE:
|
||
case DOCUMENT_FRAGMENT_NODE:
|
||
var child = node.firstChild;
|
||
while(child){
|
||
serializeToString(child,buf);
|
||
child = child.nextSibling;
|
||
}
|
||
return;
|
||
case ATTRIBUTE_NODE:
|
||
return buf.push(' ',node.name,'="',node.value.replace(/[<&"]/g,_xmlEncoder),'"');
|
||
case TEXT_NODE:
|
||
return buf.push(node.data.replace(/[<&]/g,_xmlEncoder));
|
||
case CDATA_SECTION_NODE:
|
||
return buf.push( '<![CDATA[',node.data,']]>');
|
||
case COMMENT_NODE:
|
||
return buf.push( "<!--",node.data,"-->");
|
||
case DOCUMENT_TYPE_NODE:
|
||
var pubid = node.publicId;
|
||
var sysid = node.systemId;
|
||
buf.push('<!DOCTYPE ',node.name);
|
||
if(pubid){
|
||
buf.push(' PUBLIC "',pubid);
|
||
if (sysid && sysid!='.') {
|
||
buf.push( '" "',sysid);
|
||
}
|
||
buf.push('">');
|
||
}else if(sysid && sysid!='.'){
|
||
buf.push(' SYSTEM "',sysid,'">');
|
||
}else{
|
||
var sub = node.internalSubset;
|
||
if(sub){
|
||
buf.push(" [",sub,"]");
|
||
}
|
||
buf.push(">");
|
||
}
|
||
return;
|
||
case PROCESSING_INSTRUCTION_NODE:
|
||
return buf.push( "<?",node.target," ",node.data,"?>");
|
||
case ENTITY_REFERENCE_NODE:
|
||
return buf.push( '&',node.nodeName,';');
|
||
//case ENTITY_NODE:
|
||
//case NOTATION_NODE:
|
||
default:
|
||
buf.push('??',node.nodeName);
|
||
}
|
||
}
|
||
function importNode(doc,node,deep){
|
||
var node2;
|
||
switch (node.nodeType) {
|
||
case ELEMENT_NODE:
|
||
node2 = node.cloneNode(false);
|
||
node2.ownerDocument = doc;
|
||
//var attrs = node2.attributes;
|
||
//var len = attrs.length;
|
||
//for(var i=0;i<len;i++){
|
||
//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
|
||
//}
|
||
case DOCUMENT_FRAGMENT_NODE:
|
||
break;
|
||
case ATTRIBUTE_NODE:
|
||
deep = true;
|
||
break;
|
||
//case ENTITY_REFERENCE_NODE:
|
||
//case PROCESSING_INSTRUCTION_NODE:
|
||
////case TEXT_NODE:
|
||
//case CDATA_SECTION_NODE:
|
||
//case COMMENT_NODE:
|
||
// deep = false;
|
||
// break;
|
||
//case DOCUMENT_NODE:
|
||
//case DOCUMENT_TYPE_NODE:
|
||
//cannot be imported.
|
||
//case ENTITY_NODE:
|
||
//case NOTATION_NODE：
|
||
//can not hit in level3
|
||
//default:throw e;
|
||
}
|
||
if(!node2){
|
||
node2 = node.cloneNode(false);//false
|
||
}
|
||
node2.ownerDocument = doc;
|
||
node2.parentNode = null;
|
||
if(deep){
|
||
var child = node.firstChild;
|
||
while(child){
|
||
node2.appendChild(importNode(doc,child,deep));
|
||
child = child.nextSibling;
|
||
}
|
||
}
|
||
return node2;
|
||
}
|
||
//
|
||
//var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
|
||
// attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
|
||
function cloneNode(doc,node,deep){
|
||
var node2 = new node.constructor();
|
||
for(var n in node){
|
||
var v = node[n];
|
||
if(typeof v != 'object' ){
|
||
if(v != node2[n]){
|
||
node2[n] = v;
|
||
}
|
||
}
|
||
}
|
||
if(node.childNodes){
|
||
node2.childNodes = new NodeList();
|
||
}
|
||
node2.ownerDocument = doc;
|
||
switch (node2.nodeType) {
|
||
case ELEMENT_NODE:
|
||
var attrs = node.attributes;
|
||
var attrs2 = node2.attributes = new NamedNodeMap();
|
||
var len = attrs.length
|
||
attrs2._ownerElement = node2;
|
||
for(var i=0;i<len;i++){
|
||
node2.setAttributeNode(cloneNode(doc,attrs.item(i),true));
|
||
}
|
||
break;;
|
||
case ATTRIBUTE_NODE:
|
||
deep = true;
|
||
}
|
||
if(deep){
|
||
var child = node.firstChild;
|
||
while(child){
|
||
node2.appendChild(cloneNode(doc,child,deep));
|
||
child = child.nextSibling;
|
||
}
|
||
}
|
||
return node2;
|
||
}
|
||
|
||
function __set__(object,key,value){
|
||
object[key] = value
|
||
}
|
||
//do dynamic
|
||
try{
|
||
if(Object.defineProperty){
|
||
Object.defineProperty(LiveNodeList.prototype,'length',{
|
||
get:function(){
|
||
_updateLiveList(this);
|
||
return this.$$length;
|
||
}
|
||
});
|
||
Object.defineProperty(Node.prototype,'textContent',{
|
||
get:function(){
|
||
return getTextContent(this);
|
||
},
|
||
set:function(data){
|
||
switch(this.nodeType){
|
||
case 1:
|
||
case 11:
|
||
while(this.firstChild){
|
||
this.removeChild(this.firstChild);
|
||
}
|
||
if(data || String(data)){
|
||
this.appendChild(this.ownerDocument.createTextNode(data));
|
||
}
|
||
break;
|
||
default:
|
||
//TODO:
|
||
this.data = data;
|
||
this.value = value;
|
||
this.nodeValue = data;
|
||
}
|
||
}
|
||
})
|
||
|
||
function getTextContent(node){
|
||
switch(node.nodeType){
|
||
case 1:
|
||
case 11:
|
||
var buf = [];
|
||
node = node.firstChild;
|
||
while(node){
|
||
if(node.nodeType!==7 && node.nodeType !==8){
|
||
buf.push(getTextContent(node));
|
||
}
|
||
node = node.nextSibling;
|
||
}
|
||
return buf.join('');
|
||
default:
|
||
return node.nodeValue;
|
||
}
|
||
}
|
||
__set__ = function(object,key,value){
|
||
//console.log(value)
|
||
object['$$'+key] = value
|
||
}
|
||
}
|
||
}catch(e){//ie8
|
||
}
|
||
|
||
if(typeof require == 'function'){
|
||
exports.DOMImplementation = DOMImplementation;
|
||
exports.XMLSerializer = XMLSerializer;
|
||
}
|
||
|
||
},{}],90:[function(require,module,exports){
|
||
//[4] NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
|
||
//[4a] NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
|
||
//[5] Name ::= NameStartChar (NameChar)*
|
||
var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]///\u10000-\uEFFFF
|
||
var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\u00B7\u0300-\u036F\\ux203F-\u2040]");
|
||
var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
|
||
//var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
|
||
//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
|
||
|
||
//S_TAG, S_ATTR, S_EQ, S_V
|
||
//S_ATTR_S, S_E, S_S, S_C
|
||
var S_TAG = 0;//tag name offerring
|
||
var S_ATTR = 1;//attr name offerring
|
||
var S_ATTR_S=2;//attr name end and space offer
|
||
var S_EQ = 3;//=space?
|
||
var S_V = 4;//attr value(no quot value only)
|
||
var S_E = 5;//attr value end and no space(quot end)
|
||
var S_S = 6;//(attr value end || tag end ) && (space offer)
|
||
var S_C = 7;//closed el<el />
|
||
|
||
function XMLReader(){
|
||
|
||
}
|
||
|
||
XMLReader.prototype = {
|
||
parse:function(source,defaultNSMap,entityMap){
|
||
var domBuilder = this.domBuilder;
|
||
domBuilder.startDocument();
|
||
_copy(defaultNSMap ,defaultNSMap = {})
|
||
parse(source,defaultNSMap,entityMap,
|
||
domBuilder,this.errorHandler);
|
||
domBuilder.endDocument();
|
||
}
|
||
}
|
||
function parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){
|
||
function fixedFromCharCode(code) {
|
||
// String.prototype.fromCharCode does not supports
|
||
// > 2 bytes unicode chars directly
|
||
if (code > 0xffff) {
|
||
code -= 0x10000;
|
||
var surrogate1 = 0xd800 + (code >> 10)
|
||
, surrogate2 = 0xdc00 + (code & 0x3ff);
|
||
|
||
return String.fromCharCode(surrogate1, surrogate2);
|
||
} else {
|
||
return String.fromCharCode(code);
|
||
}
|
||
}
|
||
function entityReplacer(a){
|
||
var k = a.slice(1,-1);
|
||
if(k in entityMap){
|
||
return entityMap[k];
|
||
}else if(k.charAt(0) === '#'){
|
||
return fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))
|
||
}else{
|
||
errorHandler.error('entity not found:'+a);
|
||
return a;
|
||
}
|
||
}
|
||
function appendText(end){//has some bugs
|
||
var xt = source.substring(start,end).replace(/&#?\w+;/g,entityReplacer);
|
||
locator&&position(start);
|
||
domBuilder.characters(xt,0,end-start);
|
||
start = end
|
||
}
|
||
function position(start,m){
|
||
while(start>=endPos && (m = linePattern.exec(source))){
|
||
startPos = m.index;
|
||
endPos = startPos + m[0].length;
|
||
locator.lineNumber++;
|
||
//console.log('line++:',locator,startPos,endPos)
|
||
}
|
||
locator.columnNumber = start-startPos+1;
|
||
}
|
||
var startPos = 0;
|
||
var endPos = 0;
|
||
var linePattern = /.+(?:\r\n?|\n)|.*$/g
|
||
var locator = domBuilder.locator;
|
||
|
||
var parseStack = [{currentNSMap:defaultNSMapCopy}]
|
||
var closeMap = {};
|
||
var start = 0;
|
||
while(true){
|
||
var i = source.indexOf('<',start);
|
||
if(i<0){
|
||
if(!source.substr(start).match(/^\s*$/)){
|
||
var doc = domBuilder.document;
|
||
var text = doc.createTextNode(source.substr(start));
|
||
doc.appendChild(text);
|
||
domBuilder.currentElement = text;
|
||
}
|
||
return;
|
||
}
|
||
if(i>start){
|
||
appendText(i);
|
||
}
|
||
switch(source.charAt(i+1)){
|
||
case '/':
|
||
var end = source.indexOf('>',i+3);
|
||
var tagName = source.substring(i+2,end);
|
||
var config = parseStack.pop();
|
||
var localNSMap = config.localNSMap;
|
||
|
||
if(config.tagName != tagName){
|
||
errorHandler.fatalError("end tag name: "+tagName+' is not match the current start tagName:'+config.tagName );
|
||
}
|
||
domBuilder.endElement(config.uri,config.localName,tagName);
|
||
if(localNSMap){
|
||
for(var prefix in localNSMap){
|
||
domBuilder.endPrefixMapping(prefix) ;
|
||
}
|
||
}
|
||
end++;
|
||
break;
|
||
// end elment
|
||
case '?':// <?...?>
|
||
locator&&position(i);
|
||
end = parseInstruction(source,i,domBuilder);
|
||
break;
|
||
case '!':// <!doctype,<![CDATA,<!--
|
||
locator&&position(i);
|
||
end = parseDCC(source,i,domBuilder,errorHandler);
|
||
break;
|
||
default:
|
||
try{
|
||
locator&&position(i);
|
||
|
||
var el = new ElementAttributes();
|
||
|
||
//elStartEnd
|
||
var end = parseElementStartPart(source,i,el,entityReplacer,errorHandler);
|
||
var len = el.length;
|
||
//position fixed
|
||
if(len && locator){
|
||
var backup = copyLocator(locator,{});
|
||
for(var i = 0;i<len;i++){
|
||
var a = el[i];
|
||
position(a.offset);
|
||
a.offset = copyLocator(locator,{});
|
||
}
|
||
copyLocator(backup,locator);
|
||
}
|
||
if(!el.closed && fixSelfClosed(source,end,el.tagName,closeMap)){
|
||
el.closed = true;
|
||
if(!entityMap.nbsp){
|
||
errorHandler.warning('unclosed xml attribute');
|
||
}
|
||
}
|
||
appendElement(el,domBuilder,parseStack);
|
||
|
||
|
||
if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
|
||
end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder)
|
||
}else{
|
||
end++;
|
||
}
|
||
}catch(e){
|
||
errorHandler.error('element parse error: '+e);
|
||
end = -1;
|
||
}
|
||
|
||
}
|
||
if(end<0){
|
||
//TODO: 这里有可能sax回退，有位置错误风险
|
||
appendText(i+1);
|
||
}else{
|
||
start = end;
|
||
}
|
||
}
|
||
}
|
||
function copyLocator(f,t){
|
||
t.lineNumber = f.lineNumber;
|
||
t.columnNumber = f.columnNumber;
|
||
return t;
|
||
|
||
}
|
||
|
||
/**
|
||
* @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
|
||
* @return end of the elementStartPart(end of elementEndPart for selfClosed el)
|
||
*/
|
||
function parseElementStartPart(source,start,el,entityReplacer,errorHandler){
|
||
var attrName;
|
||
var value;
|
||
var p = ++start;
|
||
var s = S_TAG;//status
|
||
while(true){
|
||
var c = source.charAt(p);
|
||
switch(c){
|
||
case '=':
|
||
if(s === S_ATTR){//attrName
|
||
attrName = source.slice(start,p);
|
||
s = S_EQ;
|
||
}else if(s === S_ATTR_S){
|
||
s = S_EQ;
|
||
}else{
|
||
//fatalError: equal must after attrName or space after attrName
|
||
throw new Error('attribute equal must after attrName');
|
||
}
|
||
break;
|
||
case '\'':
|
||
case '"':
|
||
if(s === S_EQ){//equal
|
||
start = p+1;
|
||
p = source.indexOf(c,start)
|
||
if(p>0){
|
||
value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
|
||
el.add(attrName,value,start-1);
|
||
s = S_E;
|
||
}else{
|
||
//fatalError: no end quot match
|
||
throw new Error('attribute value no end \''+c+'\' match');
|
||
}
|
||
}else if(s == S_V){
|
||
value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
|
||
//console.log(attrName,value,start,p)
|
||
el.add(attrName,value,start);
|
||
//console.dir(el)
|
||
errorHandler.warning('attribute "'+attrName+'" missed start quot('+c+')!!');
|
||
start = p+1;
|
||
s = S_E
|
||
}else{
|
||
//fatalError: no equal before
|
||
throw new Error('attribute value must after "="');
|
||
}
|
||
break;
|
||
case '/':
|
||
switch(s){
|
||
case S_TAG:
|
||
el.setTagName(source.slice(start,p));
|
||
case S_E:
|
||
case S_S:
|
||
case S_C:
|
||
s = S_C;
|
||
el.closed = true;
|
||
case S_V:
|
||
case S_ATTR:
|
||
case S_ATTR_S:
|
||
break;
|
||
//case S_EQ:
|
||
default:
|
||
throw new Error("attribute invalid close char('/')")
|
||
}
|
||
break;
|
||
case ''://end document
|
||
//throw new Error('unexpected end of input')
|
||
errorHandler.error('unexpected end of input');
|
||
case '>':
|
||
switch(s){
|
||
case S_TAG:
|
||
el.setTagName(source.slice(start,p));
|
||
case S_E:
|
||
case S_S:
|
||
case S_C:
|
||
break;//normal
|
||
case S_V://Compatible state
|
||
case S_ATTR:
|
||
value = source.slice(start,p);
|
||
if(value.slice(-1) === '/'){
|
||
el.closed = true;
|
||
value = value.slice(0,-1)
|
||
}
|
||
case S_ATTR_S:
|
||
if(s === S_ATTR_S){
|
||
value = attrName;
|
||
}
|
||
if(s == S_V){
|
||
errorHandler.warning('attribute "'+value+'" missed quot(")!!');
|
||
el.add(attrName,value.replace(/&#?\w+;/g,entityReplacer),start)
|
||
}else{
|
||
errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!')
|
||
el.add(value,value,start)
|
||
}
|
||
break;
|
||
case S_EQ:
|
||
throw new Error('attribute value missed!!');
|
||
}
|
||
// console.log(tagName,tagNamePattern,tagNamePattern.test(tagName))
|
||
return p;
|
||
/*xml space '\x20' | #x9 | #xD | #xA; */
|
||
case '\u0080':
|
||
c = ' ';
|
||
default:
|
||
if(c<= ' '){//space
|
||
switch(s){
|
||
case S_TAG:
|
||
el.setTagName(source.slice(start,p));//tagName
|
||
s = S_S;
|
||
break;
|
||
case S_ATTR:
|
||
attrName = source.slice(start,p)
|
||
s = S_ATTR_S;
|
||
break;
|
||
case S_V:
|
||
var value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
|
||
errorHandler.warning('attribute "'+value+'" missed quot(")!!');
|
||
el.add(attrName,value,start)
|
||
case S_E:
|
||
s = S_S;
|
||
break;
|
||
//case S_S:
|
||
//case S_EQ:
|
||
//case S_ATTR_S:
|
||
// void();break;
|
||
//case S_C:
|
||
//ignore warning
|
||
}
|
||
}else{//not space
|
||
//S_TAG, S_ATTR, S_EQ, S_V
|
||
//S_ATTR_S, S_E, S_S, S_C
|
||
switch(s){
|
||
//case S_TAG:void();break;
|
||
//case S_ATTR:void();break;
|
||
//case S_V:void();break;
|
||
case S_ATTR_S:
|
||
errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead!!')
|
||
el.add(attrName,attrName,start);
|
||
start = p;
|
||
s = S_ATTR;
|
||
break;
|
||
case S_E:
|
||
errorHandler.warning('attribute space is required"'+attrName+'"!!')
|
||
case S_S:
|
||
s = S_ATTR;
|
||
start = p;
|
||
break;
|
||
case S_EQ:
|
||
s = S_V;
|
||
start = p;
|
||
break;
|
||
case S_C:
|
||
throw new Error("elements closed character '/' and '>' must be connected to");
|
||
}
|
||
}
|
||
}
|
||
p++;
|
||
}
|
||
}
|
||
/**
|
||
* @return end of the elementStartPart(end of elementEndPart for selfClosed el)
|
||
*/
|
||
function appendElement(el,domBuilder,parseStack){
|
||
var tagName = el.tagName;
|
||
var localNSMap = null;
|
||
var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
|
||
var i = el.length;
|
||
while(i--){
|
||
var a = el[i];
|
||
var qName = a.qName;
|
||
var value = a.value;
|
||
var nsp = qName.indexOf(':');
|
||
if(nsp>0){
|
||
var prefix = a.prefix = qName.slice(0,nsp);
|
||
var localName = qName.slice(nsp+1);
|
||
var nsPrefix = prefix === 'xmlns' && localName
|
||
}else{
|
||
localName = qName;
|
||
prefix = null
|
||
nsPrefix = qName === 'xmlns' && ''
|
||
}
|
||
//can not set prefix,because prefix !== ''
|
||
a.localName = localName ;
|
||
//prefix == null for no ns prefix attribute
|
||
if(nsPrefix !== false){//hack!!
|
||
if(localNSMap == null){
|
||
localNSMap = {}
|
||
//console.log(currentNSMap,0)
|
||
_copy(currentNSMap,currentNSMap={})
|
||
//console.log(currentNSMap,1)
|
||
}
|
||
currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
|
||
a.uri = 'http://www.w3.org/2000/xmlns/'
|
||
domBuilder.startPrefixMapping(nsPrefix, value)
|
||
}
|
||
}
|
||
var i = el.length;
|
||
while(i--){
|
||
a = el[i];
|
||
var prefix = a.prefix;
|
||
if(prefix){//no prefix attribute has no namespace
|
||
if(prefix === 'xml'){
|
||
a.uri = 'http://www.w3.org/XML/1998/namespace';
|
||
}if(prefix !== 'xmlns'){
|
||
a.uri = currentNSMap[prefix]
|
||
|
||
//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}
|
||
}
|
||
}
|
||
}
|
||
var nsp = tagName.indexOf(':');
|
||
if(nsp>0){
|
||
prefix = el.prefix = tagName.slice(0,nsp);
|
||
localName = el.localName = tagName.slice(nsp+1);
|
||
}else{
|
||
prefix = null;//important!!
|
||
localName = el.localName = tagName;
|
||
}
|
||
//no prefix element has default namespace
|
||
var ns = el.uri = currentNSMap[prefix || ''];
|
||
domBuilder.startElement(ns,localName,tagName,el);
|
||
//endPrefixMapping and startPrefixMapping have not any help for dom builder
|
||
//localNSMap = null
|
||
if(el.closed){
|
||
domBuilder.endElement(ns,localName,tagName);
|
||
if(localNSMap){
|
||
for(prefix in localNSMap){
|
||
domBuilder.endPrefixMapping(prefix)
|
||
}
|
||
}
|
||
}else{
|
||
el.currentNSMap = currentNSMap;
|
||
el.localNSMap = localNSMap;
|
||
parseStack.push(el);
|
||
}
|
||
}
|
||
function parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){
|
||
if(/^(?:script|textarea)$/i.test(tagName)){
|
||
var elEndStart = source.indexOf('</'+tagName+'>',elStartEnd);
|
||
var text = source.substring(elStartEnd+1,elEndStart);
|
||
if(/[&<]/.test(text)){
|
||
if(/^script$/i.test(tagName)){
|
||
//if(!/\]\]>/.test(text)){
|
||
//lexHandler.startCDATA();
|
||
domBuilder.characters(text,0,text.length);
|
||
//lexHandler.endCDATA();
|
||
return elEndStart;
|
||
//}
|
||
}//}else{//text area
|
||
text = text.replace(/&#?\w+;/g,entityReplacer);
|
||
domBuilder.characters(text,0,text.length);
|
||
return elEndStart;
|
||
//}
|
||
|
||
}
|
||
}
|
||
return elStartEnd+1;
|
||
}
|
||
function fixSelfClosed(source,elStartEnd,tagName,closeMap){
|
||
//if(tagName in closeMap){
|
||
var pos = closeMap[tagName];
|
||
if(pos == null){
|
||
//console.log(tagName)
|
||
pos = closeMap[tagName] = source.lastIndexOf('</'+tagName+'>')
|
||
}
|
||
return pos<elStartEnd;
|
||
//}
|
||
}
|
||
function _copy(source,target){
|
||
for(var n in source){target[n] = source[n]}
|
||
}
|
||
function parseDCC(source,start,domBuilder,errorHandler){//sure start with '<!'
|
||
var next= source.charAt(start+2)
|
||
switch(next){
|
||
case '-':
|
||
if(source.charAt(start + 3) === '-'){
|
||
var end = source.indexOf('-->',start+4);
|
||
//append comment source.substring(4,end)//<!--
|
||
if(end>start){
|
||
domBuilder.comment(source,start+4,end-start-4);
|
||
return end+3;
|
||
}else{
|
||
errorHandler.error("Unclosed comment");
|
||
return -1;
|
||
}
|
||
}else{
|
||
//error
|
||
return -1;
|
||
}
|
||
default:
|
||
if(source.substr(start+3,6) == 'CDATA['){
|
||
var end = source.indexOf(']]>',start+9);
|
||
domBuilder.startCDATA();
|
||
domBuilder.characters(source,start+9,end-start-9);
|
||
domBuilder.endCDATA()
|
||
return end+3;
|
||
}
|
||
//<!DOCTYPE
|
||
//startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId)
|
||
var matchs = split(source,start);
|
||
var len = matchs.length;
|
||
if(len>1 && /!doctype/i.test(matchs[0][0])){
|
||
var name = matchs[1][0];
|
||
var pubid = len>3 && /^public$/i.test(matchs[2][0]) && matchs[3][0]
|
||
var sysid = len>4 && matchs[4][0];
|
||
var lastMatch = matchs[len-1]
|
||
domBuilder.startDTD(name,pubid && pubid.replace(/^(['"])(.*?)\1$/,'$2'),
|
||
sysid && sysid.replace(/^(['"])(.*?)\1$/,'$2'));
|
||
domBuilder.endDTD();
|
||
|
||
return lastMatch.index+lastMatch[0].length
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
|
||
function parseInstruction(source,start,domBuilder){
|
||
var end = source.indexOf('?>',start);
|
||
if(end){
|
||
var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
|
||
if(match){
|
||
var len = match[0].length;
|
||
domBuilder.processingInstruction(match[1], match[2]) ;
|
||
return end+2;
|
||
}else{//error
|
||
return -1;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/**
|
||
* @param source
|
||
*/
|
||
function ElementAttributes(source){
|
||
|
||
}
|
||
ElementAttributes.prototype = {
|
||
setTagName:function(tagName){
|
||
if(!tagNamePattern.test(tagName)){
|
||
throw new Error('invalid tagName:'+tagName)
|
||
}
|
||
this.tagName = tagName
|
||
},
|
||
add:function(qName,value,offset){
|
||
if(!tagNamePattern.test(qName)){
|
||
throw new Error('invalid attribute:'+qName)
|
||
}
|
||
this[this.length++] = {qName:qName,value:value,offset:offset}
|
||
},
|
||
length:0,
|
||
getLocalName:function(i){return this[i].localName},
|
||
getOffset:function(i){return this[i].offset},
|
||
getQName:function(i){return this[i].qName},
|
||
getURI:function(i){return this[i].uri},
|
||
getValue:function(i){return this[i].value}
|
||
// ,getIndex:function(uri, localName)){
|
||
// if(localName){
|
||
//
|
||
// }else{
|
||
// var qName = uri
|
||
// }
|
||
// },
|
||
// getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
|
||
// getType:function(uri,localName){}
|
||
// getType:function(i){},
|
||
}
|
||
|
||
|
||
|
||
|
||
function _set_proto_(thiz,parent){
|
||
thiz.__proto__ = parent;
|
||
return thiz;
|
||
}
|
||
if(!(_set_proto_({},_set_proto_.prototype) instanceof _set_proto_)){
|
||
_set_proto_ = function(thiz,parent){
|
||
function p(){};
|
||
p.prototype = parent;
|
||
p = new p();
|
||
for(parent in thiz){
|
||
p[parent] = thiz[parent];
|
||
}
|
||
return p;
|
||
}
|
||
}
|
||
|
||
function split(source,start){
|
||
var match;
|
||
var buf = [];
|
||
var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
|
||
reg.lastIndex = start;
|
||
reg.exec(source);//skip <
|
||
while(match = reg.exec(source)){
|
||
buf.push(match);
|
||
if(match[1])return buf;
|
||
}
|
||
}
|
||
|
||
if(typeof require == 'function'){
|
||
exports.XMLReader = XMLReader;
|
||
}
|
||
|
||
|
||
},{}]},{},[4])(4)
|
||
}); |