You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5346 lines
164 KiB
5346 lines
164 KiB
(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(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
(function (Buffer){(function (){
|
|
/**
|
|
* 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));
|
|
|
|
} else if ('Null' === name) {
|
|
next_child.ele('null').txt('');
|
|
|
|
}
|
|
}
|
|
|
|
}).call(this)}).call(this,{"isBuffer":require("../node_modules/is-buffer/index.js")})
|
|
},{"../node_modules/is-buffer/index.js":3,"base64-js":2,"xmlbuilder":36}],2:[function(require,module,exports){
|
|
'use strict'
|
|
|
|
exports.byteLength = byteLength
|
|
exports.toByteArray = toByteArray
|
|
exports.fromByteArray = fromByteArray
|
|
|
|
var lookup = []
|
|
var revLookup = []
|
|
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
|
|
|
|
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
|
for (var i = 0, len = code.length; i < len; ++i) {
|
|
lookup[i] = code[i]
|
|
revLookup[code.charCodeAt(i)] = i
|
|
}
|
|
|
|
// Support decoding URL-safe base64 strings, as Node.js does.
|
|
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
|
|
revLookup['-'.charCodeAt(0)] = 62
|
|
revLookup['_'.charCodeAt(0)] = 63
|
|
|
|
function getLens (b64) {
|
|
var len = b64.length
|
|
|
|
if (len % 4 > 0) {
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
}
|
|
|
|
// Trim off extra bytes after placeholder bytes are found
|
|
// See: https://github.com/beatgammit/base64-js/issues/42
|
|
var validLen = b64.indexOf('=')
|
|
if (validLen === -1) validLen = len
|
|
|
|
var placeHoldersLen = validLen === len
|
|
? 0
|
|
: 4 - (validLen % 4)
|
|
|
|
return [validLen, placeHoldersLen]
|
|
}
|
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
function byteLength (b64) {
|
|
var lens = getLens(b64)
|
|
var validLen = lens[0]
|
|
var placeHoldersLen = lens[1]
|
|
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
|
|
}
|
|
|
|
function _byteLength (b64, validLen, placeHoldersLen) {
|
|
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
|
|
}
|
|
|
|
function toByteArray (b64) {
|
|
var tmp
|
|
var lens = getLens(b64)
|
|
var validLen = lens[0]
|
|
var placeHoldersLen = lens[1]
|
|
|
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
|
|
|
|
var curByte = 0
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
var len = placeHoldersLen > 0
|
|
? validLen - 4
|
|
: validLen
|
|
|
|
var i
|
|
for (i = 0; i < len; i += 4) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 18) |
|
|
(revLookup[b64.charCodeAt(i + 1)] << 12) |
|
|
(revLookup[b64.charCodeAt(i + 2)] << 6) |
|
|
revLookup[b64.charCodeAt(i + 3)]
|
|
arr[curByte++] = (tmp >> 16) & 0xFF
|
|
arr[curByte++] = (tmp >> 8) & 0xFF
|
|
arr[curByte++] = tmp & 0xFF
|
|
}
|
|
|
|
if (placeHoldersLen === 2) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 2) |
|
|
(revLookup[b64.charCodeAt(i + 1)] >> 4)
|
|
arr[curByte++] = tmp & 0xFF
|
|
}
|
|
|
|
if (placeHoldersLen === 1) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 10) |
|
|
(revLookup[b64.charCodeAt(i + 1)] << 4) |
|
|
(revLookup[b64.charCodeAt(i + 2)] >> 2)
|
|
arr[curByte++] = (tmp >> 8) & 0xFF
|
|
arr[curByte++] = tmp & 0xFF
|
|
}
|
|
|
|
return arr
|
|
}
|
|
|
|
function tripletToBase64 (num) {
|
|
return lookup[num >> 18 & 0x3F] +
|
|
lookup[num >> 12 & 0x3F] +
|
|
lookup[num >> 6 & 0x3F] +
|
|
lookup[num & 0x3F]
|
|
}
|
|
|
|
function encodeChunk (uint8, start, end) {
|
|
var tmp
|
|
var output = []
|
|
for (var i = start; i < end; i += 3) {
|
|
tmp =
|
|
((uint8[i] << 16) & 0xFF0000) +
|
|
((uint8[i + 1] << 8) & 0xFF00) +
|
|
(uint8[i + 2] & 0xFF)
|
|
output.push(tripletToBase64(tmp))
|
|
}
|
|
return output.join('')
|
|
}
|
|
|
|
function fromByteArray (uint8) {
|
|
var tmp
|
|
var len = uint8.length
|
|
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
|
|
var parts = []
|
|
var maxChunkLength = 16383 // must be multiple of 3
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
|
|
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
|
|
}
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
if (extraBytes === 1) {
|
|
tmp = uint8[len - 1]
|
|
parts.push(
|
|
lookup[tmp >> 2] +
|
|
lookup[(tmp << 4) & 0x3F] +
|
|
'=='
|
|
)
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
|
|
parts.push(
|
|
lookup[tmp >> 10] +
|
|
lookup[(tmp >> 4) & 0x3F] +
|
|
lookup[(tmp << 2) & 0x3F] +
|
|
'='
|
|
)
|
|
}
|
|
|
|
return parts.join('')
|
|
}
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
/*!
|
|
* Determine if an object is a Buffer
|
|
*
|
|
* @author Feross Aboukhadijeh <https://feross.org>
|
|
* @license MIT
|
|
*/
|
|
|
|
// The _isBuffer check is for Safari 5-7 support, because it's missing
|
|
// Object.prototype.constructor. Remove this eventually
|
|
module.exports = function (obj) {
|
|
return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
|
|
}
|
|
|
|
function isBuffer (obj) {
|
|
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
|
|
}
|
|
|
|
// For Node v0.10 support. Remove this eventually.
|
|
function isSlowBuffer (obj) {
|
|
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
|
|
}
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
module.exports = {
|
|
Disconnected: 1,
|
|
Preceding: 2,
|
|
Following: 4,
|
|
Contains: 8,
|
|
ContainedBy: 16,
|
|
ImplementationSpecific: 32
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
module.exports = {
|
|
Element: 1,
|
|
Attribute: 2,
|
|
Text: 3,
|
|
CData: 4,
|
|
EntityReference: 5,
|
|
EntityDeclaration: 6,
|
|
ProcessingInstruction: 7,
|
|
Comment: 8,
|
|
Document: 9,
|
|
DocType: 10,
|
|
DocumentFragment: 11,
|
|
NotationDeclaration: 12,
|
|
// Numeric codes up to 200 are reserved to W3C for possible future use.
|
|
// Following are types internal to this library:
|
|
Declaration: 201,
|
|
Raw: 202,
|
|
AttributeDeclaration: 203,
|
|
ElementDeclaration: 204,
|
|
Dummy: 205
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Copies all enumerable own properties from `sources` to `target`
|
|
var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
assign = function(target, ...sources) {
|
|
var i, key, len, source;
|
|
if (isFunction(Object.assign)) {
|
|
Object.assign.apply(null, arguments);
|
|
} else {
|
|
for (i = 0, len = sources.length; i < len; i++) {
|
|
source = sources[i];
|
|
if (source != null) {
|
|
for (key in source) {
|
|
if (!hasProp.call(source, key)) continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
|
|
// Determines if `val` is a Function object
|
|
isFunction = function(val) {
|
|
return !!val && Object.prototype.toString.call(val) === '[object Function]';
|
|
};
|
|
|
|
// Determines if `val` is an Object
|
|
isObject = function(val) {
|
|
var ref;
|
|
return !!val && ((ref = typeof val) === 'function' || ref === 'object');
|
|
};
|
|
|
|
// Determines if `val` is an Array
|
|
isArray = function(val) {
|
|
if (isFunction(Array.isArray)) {
|
|
return Array.isArray(val);
|
|
} else {
|
|
return Object.prototype.toString.call(val) === '[object Array]';
|
|
}
|
|
};
|
|
|
|
// Determines if `val` is an empty Array or an Object with no own properties
|
|
isEmpty = function(val) {
|
|
var key;
|
|
if (isArray(val)) {
|
|
return !val.length;
|
|
} else {
|
|
for (key in val) {
|
|
if (!hasProp.call(val, key)) continue;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Determines if `val` is a plain Object
|
|
isPlainObject = function(val) {
|
|
var ctor, proto;
|
|
return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
|
|
};
|
|
|
|
// Gets the primitive value of an object
|
|
getValue = function(obj) {
|
|
if (isFunction(obj.valueOf)) {
|
|
return obj.valueOf();
|
|
} else {
|
|
return obj;
|
|
}
|
|
};
|
|
|
|
module.exports.assign = assign;
|
|
|
|
module.exports.isFunction = isFunction;
|
|
|
|
module.exports.isObject = isObject;
|
|
|
|
module.exports.isArray = isArray;
|
|
|
|
module.exports.isEmpty = isEmpty;
|
|
|
|
module.exports.isPlainObject = isPlainObject;
|
|
|
|
module.exports.getValue = getValue;
|
|
|
|
}).call(this);
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
module.exports = {
|
|
None: 0,
|
|
OpenTag: 1,
|
|
InsideTag: 2,
|
|
CloseTag: 3
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLAttribute, XMLNode;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
// Represents an attribute
|
|
module.exports = XMLAttribute = (function() {
|
|
class XMLAttribute {
|
|
// Initializes a new instance of `XMLAttribute`
|
|
|
|
// `parent` the parent node
|
|
// `name` attribute target
|
|
// `value` attribute value
|
|
constructor(parent, name, value) {
|
|
this.parent = parent;
|
|
if (this.parent) {
|
|
this.options = this.parent.options;
|
|
this.stringify = this.parent.stringify;
|
|
}
|
|
if (name == null) {
|
|
throw new Error("Missing attribute name. " + this.debugInfo(name));
|
|
}
|
|
this.name = this.stringify.name(name);
|
|
this.value = this.stringify.attValue(value);
|
|
this.type = NodeType.Attribute;
|
|
// DOM level 3
|
|
this.isId = false;
|
|
this.schemaTypeInfo = null;
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
|
|
// Returns debug string for this node
|
|
debugInfo(name) {
|
|
name = name || this.name;
|
|
if (name == null) {
|
|
return "parent: <" + this.parent.name + ">";
|
|
} else {
|
|
return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
|
|
}
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
if (node.namespaceURI !== this.namespaceURI) {
|
|
return false;
|
|
}
|
|
if (node.prefix !== this.prefix) {
|
|
return false;
|
|
}
|
|
if (node.localName !== this.localName) {
|
|
return false;
|
|
}
|
|
if (node.value !== this.value) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLAttribute.prototype, 'nodeType', {
|
|
get: function() {
|
|
return this.type;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLAttribute.prototype, 'ownerElement', {
|
|
get: function() {
|
|
return this.parent;
|
|
}
|
|
});
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLAttribute.prototype, 'textContent', {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || '';
|
|
}
|
|
});
|
|
|
|
// DOM level 4
|
|
Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', {
|
|
get: function() {
|
|
return '';
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLAttribute.prototype, 'prefix', {
|
|
get: function() {
|
|
return '';
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLAttribute.prototype, 'localName', {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLAttribute.prototype, 'specified', {
|
|
get: function() {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
return XMLAttribute;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],9:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLCData, XMLCharacterData;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLCharacterData = require('./XMLCharacterData');
|
|
|
|
// Represents a CDATA node
|
|
module.exports = XMLCData = class XMLCData extends XMLCharacterData {
|
|
// Initializes a new instance of `XMLCData`
|
|
|
|
// `text` CDATA text
|
|
constructor(parent, text) {
|
|
super(parent);
|
|
if (text == null) {
|
|
throw new Error("Missing CDATA text. " + this.debugInfo());
|
|
}
|
|
this.name = "#cdata-section";
|
|
this.type = NodeType.CData;
|
|
this.value = this.stringify.cdata(text);
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLCharacterData":10}],10:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var XMLCharacterData, XMLNode;
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
// Represents a character data node
|
|
module.exports = XMLCharacterData = (function() {
|
|
class XMLCharacterData extends XMLNode {
|
|
// Initializes a new instance of `XMLCharacterData`
|
|
|
|
constructor(parent) {
|
|
super(parent);
|
|
this.value = '';
|
|
}
|
|
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// DOM level 1 functions to be implemented later
|
|
substringData(offset, count) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
appendData(arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
insertData(offset, arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
deleteData(offset, count) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
replaceData(offset, count, arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
if (!super.isEqualNode(node)) {
|
|
return false;
|
|
}
|
|
if (node.data !== this.data) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLCharacterData.prototype, 'data', {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || '';
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLCharacterData.prototype, 'length', {
|
|
get: function() {
|
|
return this.value.length;
|
|
}
|
|
});
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLCharacterData.prototype, 'textContent', {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || '';
|
|
}
|
|
});
|
|
|
|
return XMLCharacterData;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./XMLNode":27}],11:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLComment;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLCharacterData = require('./XMLCharacterData');
|
|
|
|
// Represents a comment node
|
|
module.exports = XMLComment = class XMLComment extends XMLCharacterData {
|
|
// Initializes a new instance of `XMLComment`
|
|
|
|
// `text` comment text
|
|
constructor(parent, text) {
|
|
super(parent);
|
|
if (text == null) {
|
|
throw new Error("Missing comment text. " + this.debugInfo());
|
|
}
|
|
this.name = "#comment";
|
|
this.type = NodeType.Comment;
|
|
this.value = this.stringify.comment(text);
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.comment(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLCharacterData":10}],12:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
|
|
|
|
XMLDOMErrorHandler = require('./XMLDOMErrorHandler');
|
|
|
|
XMLDOMStringList = require('./XMLDOMStringList');
|
|
|
|
// Implements the DOMConfiguration interface
|
|
module.exports = XMLDOMConfiguration = (function() {
|
|
class XMLDOMConfiguration {
|
|
constructor() {
|
|
var clonedSelf;
|
|
this.defaultParams = {
|
|
"canonical-form": false,
|
|
"cdata-sections": false,
|
|
"comments": false,
|
|
"datatype-normalization": false,
|
|
"element-content-whitespace": true,
|
|
"entities": true,
|
|
"error-handler": new XMLDOMErrorHandler(),
|
|
"infoset": true,
|
|
"validate-if-schema": false,
|
|
"namespaces": true,
|
|
"namespace-declarations": true,
|
|
"normalize-characters": false,
|
|
"schema-location": '',
|
|
"schema-type": '',
|
|
"split-cdata-sections": true,
|
|
"validate": false,
|
|
"well-formed": true
|
|
};
|
|
this.params = clonedSelf = Object.create(this.defaultParams);
|
|
}
|
|
|
|
// Gets the value of a parameter.
|
|
|
|
// `name` name of the parameter
|
|
getParameter(name) {
|
|
if (this.params.hasOwnProperty(name)) {
|
|
return this.params[name];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Checks if setting a parameter to a specific value is supported.
|
|
|
|
// `name` name of the parameter
|
|
// `value` parameter value
|
|
canSetParameter(name, value) {
|
|
return true;
|
|
}
|
|
|
|
// Sets the value of a parameter.
|
|
|
|
// `name` name of the parameter
|
|
// `value` new value or null if the user wishes to unset the parameter
|
|
setParameter(name, value) {
|
|
if (value != null) {
|
|
return this.params[name] = value;
|
|
} else {
|
|
return delete this.params[name];
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
// Returns the list of parameter names
|
|
Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', {
|
|
get: function() {
|
|
return new XMLDOMStringList(Object.keys(this.defaultParams));
|
|
}
|
|
});
|
|
|
|
return XMLDOMConfiguration;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./XMLDOMErrorHandler":13,"./XMLDOMStringList":15}],13:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Represents the error handler for DOM operations
|
|
var XMLDOMErrorHandler;
|
|
|
|
module.exports = XMLDOMErrorHandler = class XMLDOMErrorHandler {
|
|
// Initializes a new instance of `XMLDOMErrorHandler`
|
|
|
|
constructor() {}
|
|
|
|
// Called on the error handler when an error occurs.
|
|
|
|
// `error` the error message as a string
|
|
handleError(error) {
|
|
throw new Error(error);
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Implements the DOMImplementation interface
|
|
var XMLDOMImplementation;
|
|
|
|
module.exports = XMLDOMImplementation = class XMLDOMImplementation {
|
|
// Tests if the DOM implementation implements a specific feature.
|
|
|
|
// `feature` package name of the feature to test. In Level 1, the
|
|
// legal values are "HTML" and "XML" (case-insensitive).
|
|
// `version` version number of the package name to test.
|
|
// In Level 1, this is the string "1.0". If the version is
|
|
// not specified, supporting any version of the feature will
|
|
// cause the method to return true.
|
|
hasFeature(feature, version) {
|
|
return true;
|
|
}
|
|
|
|
// Creates a new document type declaration.
|
|
|
|
// `qualifiedName` qualified name of the document type to be created
|
|
// `publicId` public identifier of the external subset
|
|
// `systemId` system identifier of the external subset
|
|
createDocumentType(qualifiedName, publicId, systemId) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
// Creates a new document.
|
|
|
|
// `namespaceURI` namespace URI of the document element to create
|
|
// `qualifiedName` the qualified name of the document to be created
|
|
// `doctype` the type of document to be created or null
|
|
createDocument(namespaceURI, qualifiedName, doctype) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
// Creates a new HTML document.
|
|
|
|
// `title` document title
|
|
createHTMLDocument(title) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
// Returns a specialized object which implements the specialized APIs
|
|
// of the specified feature and version.
|
|
|
|
// `feature` name of the feature requested.
|
|
// `version` version number of the feature to test
|
|
getFeature(feature, version) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Represents a list of string entries
|
|
var XMLDOMStringList;
|
|
|
|
module.exports = XMLDOMStringList = (function() {
|
|
class XMLDOMStringList {
|
|
// Initializes a new instance of `XMLDOMStringList`
|
|
// This is just a wrapper around an ordinary
|
|
// JS array.
|
|
|
|
// `arr` the array of string values
|
|
constructor(arr) {
|
|
this.arr = arr || [];
|
|
}
|
|
|
|
// Returns the indexth item in the collection.
|
|
|
|
// `index` index into the collection
|
|
item(index) {
|
|
return this.arr[index] || null;
|
|
}
|
|
|
|
// Test if a string is part of this DOMStringList.
|
|
|
|
// `str` the string to look for
|
|
contains(str) {
|
|
return this.arr.indexOf(str) !== -1;
|
|
}
|
|
|
|
};
|
|
|
|
// Returns the number of strings in the list.
|
|
Object.defineProperty(XMLDOMStringList.prototype, 'length', {
|
|
get: function() {
|
|
return this.arr.length;
|
|
}
|
|
});
|
|
|
|
return XMLDOMStringList;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{}],16:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDTDAttList, XMLNode;
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents an attribute list
|
|
module.exports = XMLDTDAttList = class XMLDTDAttList extends XMLNode {
|
|
// Initializes a new instance of `XMLDTDAttList`
|
|
|
|
// `parent` the parent `XMLDocType` element
|
|
// `elementName` the name of the element containing this attribute
|
|
// `attributeName` attribute name
|
|
// `attributeType` type of the attribute
|
|
// `defaultValueType` default value type (either #REQUIRED, #IMPLIED,
|
|
// #FIXED or #DEFAULT)
|
|
// `defaultValue` default value of the attribute
|
|
// (only used for #FIXED or #DEFAULT)
|
|
constructor(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
super(parent);
|
|
if (elementName == null) {
|
|
throw new Error("Missing DTD element name. " + this.debugInfo());
|
|
}
|
|
if (attributeName == null) {
|
|
throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
|
|
}
|
|
if (!attributeType) {
|
|
throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
|
|
}
|
|
if (!defaultValueType) {
|
|
throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
|
|
}
|
|
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. " + this.debugInfo(elementName));
|
|
}
|
|
if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
|
|
throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
|
|
}
|
|
this.elementName = this.stringify.name(elementName);
|
|
this.type = NodeType.AttributeDeclaration;
|
|
this.attributeName = this.stringify.name(attributeName);
|
|
this.attributeType = this.stringify.dtdAttType(attributeType);
|
|
if (defaultValue) {
|
|
this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
|
|
}
|
|
this.defaultValueType = defaultValueType;
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],17:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDTDElement, XMLNode;
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents an attribute
|
|
module.exports = XMLDTDElement = class XMLDTDElement extends XMLNode {
|
|
// Initializes a new instance of `XMLDTDElement`
|
|
|
|
// `parent` the parent `XMLDocType` element
|
|
// `name` element name
|
|
// `value` element content (defaults to #PCDATA)
|
|
constructor(parent, name, value) {
|
|
super(parent);
|
|
if (name == null) {
|
|
throw new Error("Missing DTD element name. " + this.debugInfo());
|
|
}
|
|
if (!value) {
|
|
value = '(#PCDATA)';
|
|
}
|
|
if (Array.isArray(value)) {
|
|
value = '(' + value.join(',') + ')';
|
|
}
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.ElementDeclaration;
|
|
this.value = this.stringify.dtdElementValue(value);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],18:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDTDEntity, XMLNode, isObject;
|
|
|
|
({isObject} = require('./Utility'));
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents an entity declaration in the DTD
|
|
module.exports = XMLDTDEntity = (function() {
|
|
class XMLDTDEntity extends XMLNode {
|
|
// Initializes a new instance of `XMLDTDEntity`
|
|
|
|
// `parent` the parent `XMLDocType` element
|
|
// `pe` whether this is a parameter entity or a general entity
|
|
// defaults to `false` (general entity)
|
|
// `name` the name of the entity
|
|
// `value` internal entity value or an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
// `value.nData` notation declaration
|
|
constructor(parent, pe, name, value) {
|
|
super(parent);
|
|
if (name == null) {
|
|
throw new Error("Missing DTD entity name. " + this.debugInfo(name));
|
|
}
|
|
if (value == null) {
|
|
throw new Error("Missing DTD entity value. " + this.debugInfo(name));
|
|
}
|
|
this.pe = !!pe;
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.EntityDeclaration;
|
|
if (!isObject(value)) {
|
|
this.value = this.stringify.dtdEntityValue(value);
|
|
this.internal = true;
|
|
} else {
|
|
if (!value.pubID && !value.sysID) {
|
|
throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
|
|
}
|
|
if (value.pubID && !value.sysID) {
|
|
throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
|
|
}
|
|
this.internal = false;
|
|
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. " + this.debugInfo(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'publicId', {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'systemId', {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'notationName', {
|
|
get: function() {
|
|
return this.nData || null;
|
|
}
|
|
});
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
return XMLDTDEntity;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./XMLNode":27}],19:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDTDNotation, XMLNode;
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents a NOTATION entry in the DTD
|
|
module.exports = XMLDTDNotation = (function() {
|
|
class XMLDTDNotation extends XMLNode {
|
|
// Initializes a new instance of `XMLDTDNotation`
|
|
|
|
// `parent` the parent `XMLDocType` element
|
|
// `name` the name of the notation
|
|
// `value` an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
constructor(parent, name, value) {
|
|
super(parent);
|
|
if (name == null) {
|
|
throw new Error("Missing DTD notation name. " + this.debugInfo(name));
|
|
}
|
|
if (!value.pubID && !value.sysID) {
|
|
throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
|
|
}
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.NotationDeclaration;
|
|
if (value.pubID != null) {
|
|
this.pubID = this.stringify.dtdPubID(value.pubID);
|
|
}
|
|
if (value.sysID != null) {
|
|
this.sysID = this.stringify.dtdSysID(value.sysID);
|
|
}
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
|
|
return XMLDTDNotation;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],20:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDeclaration, XMLNode, isObject;
|
|
|
|
({isObject} = require('./Utility'));
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents the XML declaration
|
|
module.exports = XMLDeclaration = class XMLDeclaration extends XMLNode {
|
|
// Initializes a new instance of `XMLDeclaration`
|
|
|
|
// `parent` the document object
|
|
|
|
// `version` A version number string, e.g. 1.0
|
|
// `encoding` Encoding declaration, e.g. UTF-8
|
|
// `standalone` standalone document declaration: true or false
|
|
constructor(parent, version, encoding, standalone) {
|
|
super(parent);
|
|
// arguments may also be passed as an object
|
|
if (isObject(version)) {
|
|
({version, encoding, standalone} = version);
|
|
}
|
|
if (!version) {
|
|
version = '1.0';
|
|
}
|
|
this.type = NodeType.Declaration;
|
|
this.version = this.stringify.xmlVersion(version);
|
|
if (encoding != null) {
|
|
this.encoding = this.stringify.xmlEncoding(encoding);
|
|
}
|
|
if (standalone != null) {
|
|
this.standalone = this.stringify.xmlStandalone(standalone);
|
|
}
|
|
}
|
|
|
|
// Converts to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./XMLNode":27}],21:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject;
|
|
|
|
({isObject} = require('./Utility'));
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLDTDAttList = require('./XMLDTDAttList');
|
|
|
|
XMLDTDEntity = require('./XMLDTDEntity');
|
|
|
|
XMLDTDElement = require('./XMLDTDElement');
|
|
|
|
XMLDTDNotation = require('./XMLDTDNotation');
|
|
|
|
XMLNamedNodeMap = require('./XMLNamedNodeMap');
|
|
|
|
// Represents doctype declaration
|
|
module.exports = XMLDocType = (function() {
|
|
class XMLDocType extends XMLNode {
|
|
// Initializes a new instance of `XMLDocType`
|
|
|
|
// `parent` the document object
|
|
|
|
// `pubID` public identifier of the external subset
|
|
// `sysID` system identifier of the external subset
|
|
constructor(parent, pubID, sysID) {
|
|
var child, i, len, ref;
|
|
super(parent);
|
|
this.type = NodeType.DocType;
|
|
// set DTD name to the name of the root node
|
|
if (parent.children) {
|
|
ref = parent.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.Element) {
|
|
this.name = child.name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.documentObject = parent;
|
|
// arguments may also be passed as an object
|
|
if (isObject(pubID)) {
|
|
({pubID, sysID} = pubID);
|
|
}
|
|
if (sysID == null) {
|
|
[sysID, pubID] = [pubID, sysID];
|
|
}
|
|
if (pubID != null) {
|
|
this.pubID = this.stringify.dtdPubID(pubID);
|
|
}
|
|
if (sysID != null) {
|
|
this.sysID = this.stringify.dtdSysID(sysID);
|
|
}
|
|
}
|
|
|
|
// Creates an element type declaration
|
|
|
|
// `name` element name
|
|
// `value` element content (defaults to #PCDATA)
|
|
element(name, value) {
|
|
var child;
|
|
child = new XMLDTDElement(this, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates an attribute declaration
|
|
|
|
// `elementName` the name of the element containing this attribute
|
|
// `attributeName` attribute name
|
|
// `attributeType` type of the attribute (defaults to CDATA)
|
|
// `defaultValueType` default value type (either #REQUIRED, #IMPLIED, #FIXED or
|
|
// #DEFAULT) (defaults to #IMPLIED)
|
|
// `defaultValue` default value of the attribute
|
|
// (only used for #FIXED or #DEFAULT)
|
|
attList(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
var child;
|
|
child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a general entity declaration
|
|
|
|
// `name` the name of the entity
|
|
// `value` internal entity value or an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
// `value.nData` notation declaration
|
|
entity(name, value) {
|
|
var child;
|
|
child = new XMLDTDEntity(this, false, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a parameter entity declaration
|
|
|
|
// `name` the name of the entity
|
|
// `value` internal entity value or an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
pEntity(name, value) {
|
|
var child;
|
|
child = new XMLDTDEntity(this, true, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a NOTATION declaration
|
|
|
|
// `name` the name of the notation
|
|
// `value` an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
notation(name, value) {
|
|
var child;
|
|
child = new XMLDTDNotation(this, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Converts to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.docType(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
// Aliases
|
|
ele(name, value) {
|
|
return this.element(name, value);
|
|
}
|
|
|
|
att(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
}
|
|
|
|
ent(name, value) {
|
|
return this.entity(name, value);
|
|
}
|
|
|
|
pent(name, value) {
|
|
return this.pEntity(name, value);
|
|
}
|
|
|
|
not(name, value) {
|
|
return this.notation(name, value);
|
|
}
|
|
|
|
up() {
|
|
return this.root() || this.documentObject;
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
if (!super.isEqualNode(node)) {
|
|
return false;
|
|
}
|
|
if (node.name !== this.name) {
|
|
return false;
|
|
}
|
|
if (node.publicId !== this.publicId) {
|
|
return false;
|
|
}
|
|
if (node.systemId !== this.systemId) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLDocType.prototype, 'entities', {
|
|
get: function() {
|
|
var child, i, len, nodes, ref;
|
|
nodes = {};
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
if ((child.type === NodeType.EntityDeclaration) && !child.pe) {
|
|
nodes[child.name] = child;
|
|
}
|
|
}
|
|
return new XMLNamedNodeMap(nodes);
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocType.prototype, 'notations', {
|
|
get: function() {
|
|
var child, i, len, nodes, ref;
|
|
nodes = {};
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.NotationDeclaration) {
|
|
nodes[child.name] = child;
|
|
}
|
|
}
|
|
return new XMLNamedNodeMap(nodes);
|
|
}
|
|
});
|
|
|
|
// DOM level 2
|
|
Object.defineProperty(XMLDocType.prototype, 'publicId', {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocType.prototype, 'systemId', {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocType.prototype, 'internalSubset', {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
return XMLDocType;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./XMLDTDAttList":16,"./XMLDTDElement":17,"./XMLDTDEntity":18,"./XMLDTDNotation":19,"./XMLNamedNodeMap":26,"./XMLNode":27}],22:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject;
|
|
|
|
({isPlainObject} = require('./Utility'));
|
|
|
|
XMLDOMImplementation = require('./XMLDOMImplementation');
|
|
|
|
XMLDOMConfiguration = require('./XMLDOMConfiguration');
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLStringifier = require('./XMLStringifier');
|
|
|
|
XMLStringWriter = require('./XMLStringWriter');
|
|
|
|
// Represents an XML builder
|
|
module.exports = XMLDocument = (function() {
|
|
class XMLDocument extends XMLNode {
|
|
// Initializes a new instance of `XMLDocument`
|
|
|
|
// `options.keepNullNodes` whether nodes with null values will be kept
|
|
// or ignored: true or false
|
|
// `options.keepNullAttributes` whether attributes with null values will be
|
|
// kept or ignored: true or false
|
|
// `options.ignoreDecorators` whether decorator strings will be ignored when
|
|
// converting JS objects: true or false
|
|
// `options.separateArrayItems` whether array items are created as separate
|
|
// nodes when passed as an object value: true or false
|
|
// `options.noDoubleEncoding` whether existing html entities are encoded:
|
|
// true or false
|
|
// `options.stringify` a set of functions to use for converting values to
|
|
// strings
|
|
// `options.writer` the default XML writer to use for converting nodes to
|
|
// string. If the default writer is not set, the built-in XMLStringWriter
|
|
// will be used instead.
|
|
constructor(options) {
|
|
super(null);
|
|
this.name = "#document";
|
|
this.type = NodeType.Document;
|
|
this.documentURI = null;
|
|
this.domConfig = new XMLDOMConfiguration();
|
|
options || (options = {});
|
|
if (!options.writer) {
|
|
options.writer = new XMLStringWriter();
|
|
}
|
|
this.options = options;
|
|
this.stringify = new XMLStringifier(options);
|
|
}
|
|
|
|
// Ends the document and passes it to the given XML writer
|
|
|
|
// `writer` is either an XML writer or a plain object to pass to the
|
|
// constructor of the default XML writer. The default writer is assigned when
|
|
// creating the XML document. Following flags are recognized by the
|
|
// built-in XMLStringWriter:
|
|
// `writer.pretty` pretty prints the result
|
|
// `writer.indent` indentation for pretty print
|
|
// `writer.offset` how many indentations to add to every line for pretty print
|
|
// `writer.newline` newline sequence for pretty print
|
|
end(writer) {
|
|
var writerOptions;
|
|
writerOptions = {};
|
|
if (!writer) {
|
|
writer = this.options.writer;
|
|
} else if (isPlainObject(writer)) {
|
|
writerOptions = writer;
|
|
writer = this.options.writer;
|
|
}
|
|
return writer.document(this, writer.filterOptions(writerOptions));
|
|
}
|
|
|
|
// Converts the XML document to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.document(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
// DOM level 1 functions to be implemented later
|
|
createElement(tagName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createDocumentFragment() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createTextNode(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createComment(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createCDATASection(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createProcessingInstruction(target, data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createAttribute(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createEntityReference(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByTagName(tagname) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM level 2 functions to be implemented later
|
|
importNode(importedNode, deep) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createElementNS(namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createAttributeNS(namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByTagNameNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementById(elementId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM level 3 functions to be implemented later
|
|
adoptNode(source) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
normalizeDocument() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
renameNode(node, namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM level 4 functions to be implemented later
|
|
getElementsByClassName(classNames) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createEvent(eventInterface) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createRange() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createNodeIterator(root, whatToShow, filter) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
createTreeWalker(root, whatToShow, filter) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLDocument.prototype, 'implementation', {
|
|
value: new XMLDOMImplementation()
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'doctype', {
|
|
get: function() {
|
|
var child, i, len, ref;
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.DocType) {
|
|
return child;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'documentElement', {
|
|
get: function() {
|
|
return this.rootObject || null;
|
|
}
|
|
});
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLDocument.prototype, 'inputEncoding', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'strictErrorChecking', {
|
|
get: function() {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'xmlEncoding', {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
|
|
return this.children[0].encoding;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'xmlStandalone', {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
|
|
return this.children[0].standalone === 'yes';
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'xmlVersion', {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
|
|
return this.children[0].version;
|
|
} else {
|
|
return "1.0";
|
|
}
|
|
}
|
|
});
|
|
|
|
// DOM level 4
|
|
Object.defineProperty(XMLDocument.prototype, 'URL', {
|
|
get: function() {
|
|
return this.documentURI;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'origin', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'compatMode', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'characterSet', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLDocument.prototype, 'contentType', {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
return XMLDocument;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./XMLDOMConfiguration":12,"./XMLDOMImplementation":14,"./XMLNode":27,"./XMLStringWriter":32,"./XMLStringifier":33}],23:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
({isObject, isFunction, isPlainObject, getValue} = require('./Utility'));
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLDocument = require('./XMLDocument');
|
|
|
|
XMLElement = require('./XMLElement');
|
|
|
|
XMLCData = require('./XMLCData');
|
|
|
|
XMLComment = require('./XMLComment');
|
|
|
|
XMLRaw = require('./XMLRaw');
|
|
|
|
XMLText = require('./XMLText');
|
|
|
|
XMLProcessingInstruction = require('./XMLProcessingInstruction');
|
|
|
|
XMLDeclaration = require('./XMLDeclaration');
|
|
|
|
XMLDocType = require('./XMLDocType');
|
|
|
|
XMLDTDAttList = require('./XMLDTDAttList');
|
|
|
|
XMLDTDEntity = require('./XMLDTDEntity');
|
|
|
|
XMLDTDElement = require('./XMLDTDElement');
|
|
|
|
XMLDTDNotation = require('./XMLDTDNotation');
|
|
|
|
XMLAttribute = require('./XMLAttribute');
|
|
|
|
XMLStringifier = require('./XMLStringifier');
|
|
|
|
XMLStringWriter = require('./XMLStringWriter');
|
|
|
|
WriterState = require('./WriterState');
|
|
|
|
// Represents an XML builder
|
|
module.exports = XMLDocumentCB = class XMLDocumentCB {
|
|
// Initializes a new instance of `XMLDocumentCB`
|
|
|
|
// `options.keepNullNodes` whether nodes with null values will be kept
|
|
// or ignored: true or false
|
|
// `options.keepNullAttributes` whether attributes with null values will be
|
|
// kept or ignored: true or false
|
|
// `options.ignoreDecorators` whether decorator strings will be ignored when
|
|
// converting JS objects: true or false
|
|
// `options.separateArrayItems` whether array items are created as separate
|
|
// nodes when passed as an object value: true or false
|
|
// `options.noDoubleEncoding` whether existing html entities are encoded:
|
|
// true or false
|
|
// `options.stringify` a set of functions to use for converting values to
|
|
// strings
|
|
// `options.writer` the default XML writer to use for converting nodes to
|
|
// string. If the default writer is not set, the built-in XMLStringWriter
|
|
// will be used instead.
|
|
|
|
// `onData` the function to be called when a new chunk of XML is output. The
|
|
// string containing the XML chunk is passed to `onData` as its first
|
|
// argument, and the current indentation level as its second argument.
|
|
// `onEnd` the function to be called when the XML document is completed with
|
|
// `end`. `onEnd` does not receive any arguments.
|
|
constructor(options, onData, onEnd) {
|
|
var writerOptions;
|
|
this.name = "?xml";
|
|
this.type = NodeType.Document;
|
|
options || (options = {});
|
|
writerOptions = {};
|
|
if (!options.writer) {
|
|
options.writer = new XMLStringWriter();
|
|
} else if (isPlainObject(options.writer)) {
|
|
writerOptions = options.writer;
|
|
options.writer = new XMLStringWriter();
|
|
}
|
|
this.options = options;
|
|
this.writer = options.writer;
|
|
this.writerOptions = this.writer.filterOptions(writerOptions);
|
|
this.stringify = new XMLStringifier(options);
|
|
this.onDataCallback = onData || function() {};
|
|
this.onEndCallback = onEnd || function() {};
|
|
this.currentNode = null;
|
|
this.currentLevel = -1;
|
|
this.openTags = {};
|
|
this.documentStarted = false;
|
|
this.documentCompleted = false;
|
|
this.root = null;
|
|
}
|
|
|
|
// Creates a child element node from the given XMLNode
|
|
|
|
// `node` the child node
|
|
createChildNode(node) {
|
|
var att, attName, attributes, child, i, len, ref, ref1;
|
|
switch (node.type) {
|
|
case NodeType.CData:
|
|
this.cdata(node.value);
|
|
break;
|
|
case NodeType.Comment:
|
|
this.comment(node.value);
|
|
break;
|
|
case NodeType.Element:
|
|
attributes = {};
|
|
ref = node.attribs;
|
|
for (attName in ref) {
|
|
if (!hasProp.call(ref, attName)) continue;
|
|
att = ref[attName];
|
|
attributes[attName] = att.value;
|
|
}
|
|
this.node(node.name, attributes);
|
|
break;
|
|
case NodeType.Dummy:
|
|
this.dummy();
|
|
break;
|
|
case NodeType.Raw:
|
|
this.raw(node.value);
|
|
break;
|
|
case NodeType.Text:
|
|
this.text(node.value);
|
|
break;
|
|
case NodeType.ProcessingInstruction:
|
|
this.instruction(node.target, node.value);
|
|
break;
|
|
default:
|
|
throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
|
|
}
|
|
ref1 = node.children;
|
|
// write child nodes recursively
|
|
for (i = 0, len = ref1.length; i < len; i++) {
|
|
child = ref1[i];
|
|
this.createChildNode(child);
|
|
if (child.type === NodeType.Element) {
|
|
this.up();
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Creates a dummy node
|
|
|
|
dummy() {
|
|
// no-op, just return this
|
|
return this;
|
|
}
|
|
|
|
// Creates a node
|
|
|
|
// `name` name of the node
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
node(name, attributes, text) {
|
|
if (name == null) {
|
|
throw new Error("Missing node name.");
|
|
}
|
|
if (this.root && this.currentLevel === -1) {
|
|
throw new Error("Document can only have one root node. " + this.debugInfo(name));
|
|
}
|
|
this.openCurrent();
|
|
name = getValue(name);
|
|
if (attributes == null) {
|
|
attributes = {};
|
|
}
|
|
attributes = getValue(attributes);
|
|
// swap argument order: text <-> attributes
|
|
if (!isObject(attributes)) {
|
|
[text, attributes] = [attributes, text];
|
|
}
|
|
this.currentNode = new XMLElement(this, name, attributes);
|
|
this.currentNode.children = false;
|
|
this.currentLevel++;
|
|
this.openTags[this.currentLevel] = this.currentNode;
|
|
if (text != null) {
|
|
this.text(text);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Creates a child element node or an element type declaration when called
|
|
// inside the DTD
|
|
|
|
// `name` name of the node
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
element(name, attributes, text) {
|
|
var child, i, len, oldValidationFlag, ref, root;
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType) {
|
|
this.dtdElement(...arguments);
|
|
} else {
|
|
if (Array.isArray(name) || isObject(name) || isFunction(name)) {
|
|
oldValidationFlag = this.options.noValidation;
|
|
this.options.noValidation = true;
|
|
root = new XMLDocument(this.options).element('TEMP_ROOT');
|
|
root.element(name);
|
|
this.options.noValidation = oldValidationFlag;
|
|
ref = root.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
this.createChildNode(child);
|
|
if (child.type === NodeType.Element) {
|
|
this.up();
|
|
}
|
|
}
|
|
} else {
|
|
this.node(name, attributes, text);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Adds or modifies an attribute
|
|
|
|
// `name` attribute name
|
|
// `value` attribute value
|
|
attribute(name, value) {
|
|
var attName, attValue;
|
|
if (!this.currentNode || this.currentNode.children) {
|
|
throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
|
|
}
|
|
if (name != null) {
|
|
name = getValue(name);
|
|
}
|
|
if (isObject(name)) { // expand if object
|
|
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.keepNullAttributes && (value == null)) {
|
|
this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
|
|
} else if (value != null) {
|
|
this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Creates a text node
|
|
|
|
// `value` element text
|
|
text(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLText(this, value);
|
|
this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates a CDATA node
|
|
|
|
// `value` element text without CDATA delimiters
|
|
cdata(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLCData(this, value);
|
|
this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates a comment node
|
|
|
|
// `value` comment text
|
|
comment(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLComment(this, value);
|
|
this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Adds unescaped raw text
|
|
|
|
// `value` text
|
|
raw(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLRaw(this, value);
|
|
this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Adds a processing instruction
|
|
|
|
// `target` instruction target
|
|
// `value` instruction value
|
|
instruction(target, value) {
|
|
var i, insTarget, insValue, len, node;
|
|
this.openCurrent();
|
|
if (target != null) {
|
|
target = getValue(target);
|
|
}
|
|
if (value != null) {
|
|
value = getValue(value);
|
|
}
|
|
if (Array.isArray(target)) { // expand if array
|
|
for (i = 0, len = target.length; i < len; i++) {
|
|
insTarget = target[i];
|
|
this.instruction(insTarget);
|
|
}
|
|
} else if (isObject(target)) { // expand if object
|
|
for (insTarget in target) {
|
|
if (!hasProp.call(target, insTarget)) continue;
|
|
insValue = target[insTarget];
|
|
this.instruction(insTarget, insValue);
|
|
}
|
|
} else {
|
|
if (isFunction(value)) {
|
|
value = value.apply();
|
|
}
|
|
node = new XMLProcessingInstruction(this, target, value);
|
|
this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Creates the xml declaration
|
|
|
|
// `version` A version number string, e.g. 1.0
|
|
// `encoding` Encoding declaration, e.g. UTF-8
|
|
// `standalone` standalone document declaration: true or false
|
|
declaration(version, encoding, standalone) {
|
|
var node;
|
|
this.openCurrent();
|
|
if (this.documentStarted) {
|
|
throw new Error("declaration() must be the first node.");
|
|
}
|
|
node = new XMLDeclaration(this, version, encoding, standalone);
|
|
this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates the document type declaration
|
|
|
|
// `root` the name of the root node
|
|
// `pubID` the public identifier of the external subset
|
|
// `sysID` the system identifier of the external subset
|
|
doctype(root, pubID, sysID) {
|
|
this.openCurrent();
|
|
if (root == null) {
|
|
throw new Error("Missing root node name.");
|
|
}
|
|
if (this.root) {
|
|
throw new Error("dtd() must come before the root node.");
|
|
}
|
|
this.currentNode = new XMLDocType(this, pubID, sysID);
|
|
this.currentNode.rootNodeName = root;
|
|
this.currentNode.children = false;
|
|
this.currentLevel++;
|
|
this.openTags[this.currentLevel] = this.currentNode;
|
|
return this;
|
|
}
|
|
|
|
// Creates an element type declaration
|
|
|
|
// `name` element name
|
|
// `value` element content (defaults to #PCDATA)
|
|
dtdElement(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDElement(this, name, value);
|
|
this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates an attribute declaration
|
|
|
|
// `elementName` the name of the element containing this attribute
|
|
// `attributeName` attribute name
|
|
// `attributeType` type of the attribute (defaults to CDATA)
|
|
// `defaultValueType` default value type (either #REQUIRED, #IMPLIED, #FIXED or
|
|
// #DEFAULT) (defaults to #IMPLIED)
|
|
// `defaultValue` default value of the attribute
|
|
// (only used for #FIXED or #DEFAULT)
|
|
attList(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates a general entity declaration
|
|
|
|
// `name` the name of the entity
|
|
// `value` internal entity value or an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
// `value.nData` notation declaration
|
|
entity(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDEntity(this, false, name, value);
|
|
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates a parameter entity declaration
|
|
|
|
// `name` the name of the entity
|
|
// `value` internal entity value or an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
pEntity(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDEntity(this, true, name, value);
|
|
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Creates a NOTATION declaration
|
|
|
|
// `name` the name of the notation
|
|
// `value` an object with external entity details
|
|
// `value.pubID` public identifier
|
|
// `value.sysID` system identifier
|
|
notation(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDNotation(this, name, value);
|
|
this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
}
|
|
|
|
// Gets the parent node
|
|
up() {
|
|
if (this.currentLevel < 0) {
|
|
throw new Error("The document node has no parent.");
|
|
}
|
|
if (this.currentNode) {
|
|
if (this.currentNode.children) {
|
|
this.closeNode(this.currentNode);
|
|
} else {
|
|
this.openNode(this.currentNode);
|
|
}
|
|
this.currentNode = null;
|
|
} else {
|
|
this.closeNode(this.openTags[this.currentLevel]);
|
|
}
|
|
delete this.openTags[this.currentLevel];
|
|
this.currentLevel--;
|
|
return this;
|
|
}
|
|
|
|
// Ends the document
|
|
end() {
|
|
while (this.currentLevel >= 0) {
|
|
this.up();
|
|
}
|
|
return this.onEnd();
|
|
}
|
|
|
|
// Opens the current parent node
|
|
openCurrent() {
|
|
if (this.currentNode) {
|
|
this.currentNode.children = true;
|
|
return this.openNode(this.currentNode);
|
|
}
|
|
}
|
|
|
|
// Writes the opening tag of the current node or the entire node if it has
|
|
// no child nodes
|
|
openNode(node) {
|
|
var att, chunk, name, ref;
|
|
if (!node.isOpen) {
|
|
if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) {
|
|
this.root = node;
|
|
}
|
|
chunk = '';
|
|
if (node.type === NodeType.Element) {
|
|
this.writerOptions.state = WriterState.OpenTag;
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<' + node.name;
|
|
ref = node.attribs;
|
|
for (name in ref) {
|
|
if (!hasProp.call(ref, name)) continue;
|
|
att = ref[name];
|
|
chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
|
|
}
|
|
chunk += (node.children ? '>' : '/>') + this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
this.writerOptions.state = WriterState.InsideTag; // if node.type is NodeType.DocType
|
|
} else {
|
|
this.writerOptions.state = WriterState.OpenTag;
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<!DOCTYPE ' + node.rootNodeName;
|
|
|
|
// external identifier
|
|
if (node.pubID && node.sysID) {
|
|
chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
} else if (node.sysID) {
|
|
chunk += ' SYSTEM "' + node.sysID + '"';
|
|
}
|
|
|
|
// internal subset
|
|
if (node.children) {
|
|
chunk += ' [';
|
|
this.writerOptions.state = WriterState.InsideTag;
|
|
} else {
|
|
this.writerOptions.state = WriterState.CloseTag;
|
|
chunk += '>';
|
|
}
|
|
chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
}
|
|
this.onData(chunk, this.currentLevel);
|
|
return node.isOpen = true;
|
|
}
|
|
}
|
|
|
|
// Writes the closing tag of the current node
|
|
closeNode(node) {
|
|
var chunk;
|
|
if (!node.isClosed) {
|
|
chunk = '';
|
|
this.writerOptions.state = WriterState.CloseTag;
|
|
if (node.type === NodeType.Element) {
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '</' + node.name + '>' + this.writer.endline(node, this.writerOptions, this.currentLevel); // if node.type is NodeType.DocType
|
|
} else {
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + ']>' + this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
}
|
|
this.writerOptions.state = WriterState.None;
|
|
this.onData(chunk, this.currentLevel);
|
|
return node.isClosed = true;
|
|
}
|
|
}
|
|
|
|
// Called when a new chunk of XML is output
|
|
|
|
// `chunk` a string containing the XML chunk
|
|
// `level` current indentation level
|
|
onData(chunk, level) {
|
|
this.documentStarted = true;
|
|
return this.onDataCallback(chunk, level + 1);
|
|
}
|
|
|
|
// Called when the XML document is completed
|
|
onEnd() {
|
|
this.documentCompleted = true;
|
|
return this.onEndCallback();
|
|
}
|
|
|
|
// Returns debug string
|
|
debugInfo(name) {
|
|
if (name == null) {
|
|
return "";
|
|
} else {
|
|
return "node: <" + name + ">";
|
|
}
|
|
}
|
|
|
|
// Node aliases
|
|
ele() {
|
|
return this.element(...arguments);
|
|
}
|
|
|
|
nod(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
}
|
|
|
|
txt(value) {
|
|
return this.text(value);
|
|
}
|
|
|
|
dat(value) {
|
|
return this.cdata(value);
|
|
}
|
|
|
|
com(value) {
|
|
return this.comment(value);
|
|
}
|
|
|
|
ins(target, value) {
|
|
return this.instruction(target, value);
|
|
}
|
|
|
|
dec(version, encoding, standalone) {
|
|
return this.declaration(version, encoding, standalone);
|
|
}
|
|
|
|
dtd(root, pubID, sysID) {
|
|
return this.doctype(root, pubID, sysID);
|
|
}
|
|
|
|
e(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
}
|
|
|
|
n(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
}
|
|
|
|
t(value) {
|
|
return this.text(value);
|
|
}
|
|
|
|
d(value) {
|
|
return this.cdata(value);
|
|
}
|
|
|
|
c(value) {
|
|
return this.comment(value);
|
|
}
|
|
|
|
r(value) {
|
|
return this.raw(value);
|
|
}
|
|
|
|
i(target, value) {
|
|
return this.instruction(target, value);
|
|
}
|
|
|
|
// Attribute aliases
|
|
att() {
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType) {
|
|
return this.attList(...arguments);
|
|
} else {
|
|
return this.attribute(...arguments);
|
|
}
|
|
}
|
|
|
|
a() {
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType) {
|
|
return this.attList(...arguments);
|
|
} else {
|
|
return this.attribute(...arguments);
|
|
}
|
|
}
|
|
|
|
// DTD aliases
|
|
// att() and ele() are defined above
|
|
ent(name, value) {
|
|
return this.entity(name, value);
|
|
}
|
|
|
|
pent(name, value) {
|
|
return this.pEntity(name, value);
|
|
}
|
|
|
|
not(name, value) {
|
|
return this.notation(name, value);
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./WriterState":7,"./XMLAttribute":8,"./XMLCData":9,"./XMLComment":11,"./XMLDTDAttList":16,"./XMLDTDElement":17,"./XMLDTDEntity":18,"./XMLDTDNotation":19,"./XMLDeclaration":20,"./XMLDocType":21,"./XMLDocument":22,"./XMLElement":25,"./XMLProcessingInstruction":29,"./XMLRaw":30,"./XMLStringWriter":32,"./XMLStringifier":33,"./XMLText":34}],24:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLDummy, XMLNode;
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
// Represents a raw node
|
|
module.exports = XMLDummy = class XMLDummy extends XMLNode {
|
|
// Initializes a new instance of `XMLDummy`
|
|
|
|
// `XMLDummy` is a special node representing a node with
|
|
// a null value. Dummy nodes are created while recursively
|
|
// building the XML tree. Simply skipping null values doesn't
|
|
// work because that would break the recursive chain.
|
|
constructor(parent) {
|
|
super(parent);
|
|
this.type = NodeType.Dummy;
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return '';
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],25:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
({isObject, isFunction, getValue} = require('./Utility'));
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLAttribute = require('./XMLAttribute');
|
|
|
|
XMLNamedNodeMap = require('./XMLNamedNodeMap');
|
|
|
|
// Represents an element of the XML document
|
|
module.exports = XMLElement = (function() {
|
|
class XMLElement extends XMLNode {
|
|
// Initializes a new instance of `XMLElement`
|
|
|
|
// `parent` the parent node
|
|
// `name` element name
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
constructor(parent, name, attributes) {
|
|
var child, j, len, ref;
|
|
super(parent);
|
|
if (name == null) {
|
|
throw new Error("Missing element name. " + this.debugInfo());
|
|
}
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.Element;
|
|
this.attribs = {};
|
|
this.schemaTypeInfo = null;
|
|
if (attributes != null) {
|
|
this.attribute(attributes);
|
|
}
|
|
// set properties if this is the root node
|
|
if (parent.type === NodeType.Document) {
|
|
this.isRoot = true;
|
|
this.documentObject = parent;
|
|
parent.rootObject = this;
|
|
// set dtd name
|
|
if (parent.children) {
|
|
ref = parent.children;
|
|
for (j = 0, len = ref.length; j < len; j++) {
|
|
child = ref[j];
|
|
if (child.type === NodeType.DocType) {
|
|
child.name = this.name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
|
|
clone() {
|
|
var att, attName, clonedSelf, ref;
|
|
clonedSelf = Object.create(this);
|
|
// remove document element
|
|
if (clonedSelf.isRoot) {
|
|
clonedSelf.documentObject = null;
|
|
}
|
|
// clone attributes
|
|
clonedSelf.attribs = {};
|
|
ref = this.attribs;
|
|
for (attName in ref) {
|
|
if (!hasProp.call(ref, attName)) continue;
|
|
att = ref[attName];
|
|
clonedSelf.attribs[attName] = att.clone();
|
|
}
|
|
// clone child nodes
|
|
clonedSelf.children = [];
|
|
this.children.forEach(function(child) {
|
|
var clonedChild;
|
|
clonedChild = child.clone();
|
|
clonedChild.parent = clonedSelf;
|
|
return clonedSelf.children.push(clonedChild);
|
|
});
|
|
return clonedSelf;
|
|
}
|
|
|
|
// Adds or modifies an attribute
|
|
|
|
// `name` attribute name
|
|
// `value` attribute value
|
|
attribute(name, value) {
|
|
var attName, attValue;
|
|
if (name != null) {
|
|
name = getValue(name);
|
|
}
|
|
if (isObject(name)) { // expand if object
|
|
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.keepNullAttributes && (value == null)) {
|
|
this.attribs[name] = new XMLAttribute(this, name, "");
|
|
} else if (value != null) {
|
|
this.attribs[name] = new XMLAttribute(this, name, value);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Removes an attribute
|
|
|
|
// `name` attribute name
|
|
removeAttribute(name) {
|
|
var attName, j, len;
|
|
// Also defined in DOM level 1
|
|
// removeAttribute(name) removes an attribute by name.
|
|
if (name == null) {
|
|
throw new Error("Missing attribute name. " + this.debugInfo());
|
|
}
|
|
name = getValue(name);
|
|
if (Array.isArray(name)) { // expand if array
|
|
for (j = 0, len = name.length; j < len; j++) {
|
|
attName = name[j];
|
|
delete this.attribs[attName];
|
|
}
|
|
} else {
|
|
delete this.attribs[name];
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
// `options.allowEmpty` do not self close empty element tags
|
|
toString(options) {
|
|
return this.options.writer.element(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
// Aliases
|
|
att(name, value) {
|
|
return this.attribute(name, value);
|
|
}
|
|
|
|
a(name, value) {
|
|
return this.attribute(name, value);
|
|
}
|
|
|
|
// DOM Level 1
|
|
getAttribute(name) {
|
|
if (this.attribs.hasOwnProperty(name)) {
|
|
return this.attribs[name].value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
setAttribute(name, value) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getAttributeNode(name) {
|
|
if (this.attribs.hasOwnProperty(name)) {
|
|
return this.attribs[name];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
setAttributeNode(newAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
removeAttributeNode(oldAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByTagName(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM Level 2
|
|
getAttributeNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
setAttributeNS(namespaceURI, qualifiedName, value) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
removeAttributeNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getAttributeNodeNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
setAttributeNodeNS(newAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByTagNameNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
hasAttribute(name) {
|
|
return this.attribs.hasOwnProperty(name);
|
|
}
|
|
|
|
hasAttributeNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM Level 3
|
|
setIdAttribute(name, isId) {
|
|
if (this.attribs.hasOwnProperty(name)) {
|
|
return this.attribs[name].isId;
|
|
} else {
|
|
return isId;
|
|
}
|
|
}
|
|
|
|
setIdAttributeNS(namespaceURI, localName, isId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
setIdAttributeNode(idAttr, isId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM Level 4
|
|
getElementsByTagName(tagname) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByTagNameNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getElementsByClassName(classNames) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
var i, j, ref;
|
|
if (!super.isEqualNode(node)) {
|
|
return false;
|
|
}
|
|
if (node.namespaceURI !== this.namespaceURI) {
|
|
return false;
|
|
}
|
|
if (node.prefix !== this.prefix) {
|
|
return false;
|
|
}
|
|
if (node.localName !== this.localName) {
|
|
return false;
|
|
}
|
|
if (node.attribs.length !== this.attribs.length) {
|
|
return false;
|
|
}
|
|
for (i = j = 0, ref = this.attribs.length - 1; (0 <= ref ? j <= ref : j >= ref); i = 0 <= ref ? ++j : --j) {
|
|
if (!this.attribs[i].isEqualNode(node.attribs[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLElement.prototype, 'tagName', {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
|
|
// DOM level 4
|
|
Object.defineProperty(XMLElement.prototype, 'namespaceURI', {
|
|
get: function() {
|
|
return '';
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'prefix', {
|
|
get: function() {
|
|
return '';
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'localName', {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'id', {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'className', {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'classList', {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLElement.prototype, 'attributes', {
|
|
get: function() {
|
|
if (!this.attributeMap || !this.attributeMap.nodes) {
|
|
this.attributeMap = new XMLNamedNodeMap(this.attribs);
|
|
}
|
|
return this.attributeMap;
|
|
}
|
|
});
|
|
|
|
return XMLElement;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./XMLAttribute":8,"./XMLNamedNodeMap":26,"./XMLNode":27}],26:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Represents a map of nodes accessed by a string key
|
|
var XMLNamedNodeMap;
|
|
|
|
module.exports = XMLNamedNodeMap = (function() {
|
|
class XMLNamedNodeMap {
|
|
// Initializes a new instance of `XMLNamedNodeMap`
|
|
// This is just a wrapper around an ordinary
|
|
// JS object.
|
|
|
|
// `nodes` the object containing nodes.
|
|
constructor(nodes) {
|
|
this.nodes = nodes;
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
|
|
clone() {
|
|
// this class should not be cloned since it wraps
|
|
// around a given object. The calling function should check
|
|
// whether the wrapped object is null and supply a new object
|
|
// (from the clone).
|
|
return this.nodes = null;
|
|
}
|
|
|
|
// DOM Level 1
|
|
getNamedItem(name) {
|
|
return this.nodes[name];
|
|
}
|
|
|
|
setNamedItem(node) {
|
|
var oldNode;
|
|
oldNode = this.nodes[node.nodeName];
|
|
this.nodes[node.nodeName] = node;
|
|
return oldNode || null;
|
|
}
|
|
|
|
removeNamedItem(name) {
|
|
var oldNode;
|
|
oldNode = this.nodes[name];
|
|
delete this.nodes[name];
|
|
return oldNode || null;
|
|
}
|
|
|
|
item(index) {
|
|
return this.nodes[Object.keys(this.nodes)[index]] || null;
|
|
}
|
|
|
|
// DOM level 2 functions to be implemented later
|
|
getNamedItemNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
setNamedItemNS(node) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
removeNamedItemNS(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
}
|
|
|
|
};
|
|
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLNamedNodeMap.prototype, 'length', {
|
|
get: function() {
|
|
return Object.keys(this.nodes).length || 0;
|
|
}
|
|
});
|
|
|
|
return XMLNamedNodeMap;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject,
|
|
hasProp = {}.hasOwnProperty,
|
|
splice = [].splice;
|
|
|
|
({isObject, isFunction, isEmpty, getValue} = require('./Utility'));
|
|
|
|
XMLElement = null;
|
|
|
|
XMLCData = null;
|
|
|
|
XMLComment = null;
|
|
|
|
XMLDeclaration = null;
|
|
|
|
XMLDocType = null;
|
|
|
|
XMLRaw = null;
|
|
|
|
XMLText = null;
|
|
|
|
XMLProcessingInstruction = null;
|
|
|
|
XMLDummy = null;
|
|
|
|
NodeType = null;
|
|
|
|
XMLNodeList = null;
|
|
|
|
XMLNamedNodeMap = null;
|
|
|
|
DocumentPosition = null;
|
|
|
|
// Represents a generic XMl element
|
|
module.exports = XMLNode = (function() {
|
|
class XMLNode {
|
|
// Initializes a new instance of `XMLNode`
|
|
|
|
// `parent` the parent node
|
|
constructor(parent1) {
|
|
this.parent = parent1;
|
|
if (this.parent) {
|
|
this.options = this.parent.options;
|
|
this.stringify = this.parent.stringify;
|
|
}
|
|
this.value = null;
|
|
this.children = [];
|
|
this.baseURI = null;
|
|
// first execution, load dependencies that are otherwise
|
|
// circular (so we can't load them at the top)
|
|
if (!XMLElement) {
|
|
XMLElement = require('./XMLElement');
|
|
XMLCData = require('./XMLCData');
|
|
XMLComment = require('./XMLComment');
|
|
XMLDeclaration = require('./XMLDeclaration');
|
|
XMLDocType = require('./XMLDocType');
|
|
XMLRaw = require('./XMLRaw');
|
|
XMLText = require('./XMLText');
|
|
XMLProcessingInstruction = require('./XMLProcessingInstruction');
|
|
XMLDummy = require('./XMLDummy');
|
|
NodeType = require('./NodeType');
|
|
XMLNodeList = require('./XMLNodeList');
|
|
XMLNamedNodeMap = require('./XMLNamedNodeMap');
|
|
DocumentPosition = require('./DocumentPosition');
|
|
}
|
|
}
|
|
|
|
|
|
// Sets the parent node of this node and its children recursively
|
|
|
|
// `parent` the parent node
|
|
setParent(parent) {
|
|
var child, j, len, ref1, results;
|
|
this.parent = parent;
|
|
if (parent) {
|
|
this.options = parent.options;
|
|
this.stringify = parent.stringify;
|
|
}
|
|
ref1 = this.children;
|
|
results = [];
|
|
for (j = 0, len = ref1.length; j < len; j++) {
|
|
child = ref1[j];
|
|
results.push(child.setParent(this));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
// Creates a child element node
|
|
|
|
// `name` node name or an object describing the XML tree
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
element(name, attributes, text) {
|
|
var childNode, item, j, k, key, lastChild, len, len1, val;
|
|
lastChild = null;
|
|
if (attributes === null && (text == null)) {
|
|
[attributes, text] = [{}, null];
|
|
}
|
|
if (attributes == null) {
|
|
attributes = {};
|
|
}
|
|
attributes = getValue(attributes);
|
|
// swap argument order: text <-> attributes
|
|
if (!isObject(attributes)) {
|
|
[text, attributes] = [attributes, text];
|
|
}
|
|
if (name != null) {
|
|
name = getValue(name);
|
|
}
|
|
// expand if array
|
|
if (Array.isArray(name)) {
|
|
for (j = 0, len = name.length; j < len; j++) {
|
|
item = name[j];
|
|
lastChild = this.element(item);
|
|
}
|
|
// evaluate if function
|
|
} else if (isFunction(name)) {
|
|
lastChild = this.element(name.apply());
|
|
// expand if object
|
|
} else if (isObject(name)) {
|
|
for (key in name) {
|
|
if (!hasProp.call(name, key)) continue;
|
|
val = name[key];
|
|
if (isFunction(val)) {
|
|
// evaluate if function
|
|
val = val.apply();
|
|
}
|
|
// assign attributes
|
|
if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
|
|
lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
|
|
// skip empty arrays
|
|
} else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) {
|
|
lastChild = this.dummy();
|
|
// empty objects produce one node
|
|
} else if (isObject(val) && isEmpty(val)) {
|
|
lastChild = this.element(key);
|
|
// skip null and undefined nodes
|
|
} else if (!this.options.keepNullNodes && (val == null)) {
|
|
lastChild = this.dummy();
|
|
|
|
// expand list by creating child nodes
|
|
} else if (!this.options.separateArrayItems && Array.isArray(val)) {
|
|
for (k = 0, len1 = val.length; k < len1; k++) {
|
|
item = val[k];
|
|
childNode = {};
|
|
childNode[key] = item;
|
|
lastChild = this.element(childNode);
|
|
}
|
|
|
|
// expand child nodes under parent
|
|
} else if (isObject(val)) {
|
|
// if the key is #text expand child nodes under this node to support mixed content
|
|
if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {
|
|
lastChild = this.element(val);
|
|
} else {
|
|
lastChild = this.element(key);
|
|
lastChild.element(val);
|
|
}
|
|
} else {
|
|
|
|
// text node
|
|
lastChild = this.element(key, val);
|
|
}
|
|
}
|
|
// skip null nodes
|
|
} else if (!this.options.keepNullNodes && text === null) {
|
|
lastChild = this.dummy();
|
|
} else {
|
|
// text node
|
|
if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
|
|
lastChild = this.text(text);
|
|
// cdata node
|
|
} else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
|
|
lastChild = this.cdata(text);
|
|
// comment node
|
|
} else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
|
|
lastChild = this.comment(text);
|
|
// raw text node
|
|
} else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
|
|
lastChild = this.raw(text);
|
|
// processing instruction
|
|
} else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
|
|
lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
|
|
} else {
|
|
// element node
|
|
lastChild = this.node(name, attributes, text);
|
|
}
|
|
}
|
|
if (lastChild == null) {
|
|
throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
|
|
}
|
|
return lastChild;
|
|
}
|
|
|
|
// Creates a child element node before the current node
|
|
|
|
// `name` node name or an object describing the XML tree
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
insertBefore(name, attributes, text) {
|
|
var child, i, newChild, refChild, removed;
|
|
// DOM level 1
|
|
// insertBefore(newChild, refChild) inserts the child node newChild before refChild
|
|
if (name != null ? name.type : void 0) {
|
|
newChild = name;
|
|
refChild = attributes;
|
|
newChild.setParent(this);
|
|
if (refChild) {
|
|
// temporarily remove children starting *with* refChild
|
|
i = children.indexOf(refChild);
|
|
removed = children.splice(i);
|
|
|
|
// add the new child
|
|
children.push(newChild);
|
|
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(children, removed);
|
|
} else {
|
|
children.push(newChild);
|
|
}
|
|
return newChild;
|
|
} else {
|
|
if (this.isRoot) {
|
|
throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
|
|
}
|
|
|
|
// temporarily remove children starting *with* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i);
|
|
|
|
// add the new child
|
|
child = this.parent.element(name, attributes, text);
|
|
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return child;
|
|
}
|
|
}
|
|
|
|
// Creates a child element node after the current node
|
|
|
|
// `name` node name or an object describing the XML tree
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
insertAfter(name, attributes, text) {
|
|
var child, i, removed;
|
|
if (this.isRoot) {
|
|
throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
|
|
}
|
|
|
|
// temporarily remove children starting *after* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i + 1);
|
|
|
|
// add the new child
|
|
child = this.parent.element(name, attributes, text);
|
|
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return child;
|
|
}
|
|
|
|
// Deletes a child element node
|
|
|
|
remove() {
|
|
var i, ref1;
|
|
if (this.isRoot) {
|
|
throw new Error("Cannot remove the root element. " + this.debugInfo());
|
|
}
|
|
i = this.parent.children.indexOf(this);
|
|
splice.apply(this.parent.children, [i, i - i + 1].concat(ref1 = [])), ref1;
|
|
return this.parent;
|
|
}
|
|
|
|
// Creates a node
|
|
|
|
// `name` name of the node
|
|
// `attributes` an object containing name/value pairs of attributes
|
|
// `text` element text
|
|
node(name, attributes, text) {
|
|
var child;
|
|
if (name != null) {
|
|
name = getValue(name);
|
|
}
|
|
attributes || (attributes = {});
|
|
attributes = getValue(attributes);
|
|
// swap argument order: text <-> attributes
|
|
if (!isObject(attributes)) {
|
|
[text, attributes] = [attributes, text];
|
|
}
|
|
child = new XMLElement(this, name, attributes);
|
|
if (text != null) {
|
|
child.text(text);
|
|
}
|
|
this.children.push(child);
|
|
return child;
|
|
}
|
|
|
|
// Creates a text node
|
|
|
|
// `value` element text
|
|
text(value) {
|
|
var child;
|
|
if (isObject(value)) {
|
|
this.element(value);
|
|
}
|
|
child = new XMLText(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a CDATA node
|
|
|
|
// `value` element text without CDATA delimiters
|
|
cdata(value) {
|
|
var child;
|
|
child = new XMLCData(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a comment node
|
|
|
|
// `value` comment text
|
|
comment(value) {
|
|
var child;
|
|
child = new XMLComment(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Creates a comment node before the current node
|
|
|
|
// `value` comment text
|
|
commentBefore(value) {
|
|
var child, i, removed;
|
|
// temporarily remove children starting *with* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i);
|
|
// add the new child
|
|
child = this.parent.comment(value);
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return this;
|
|
}
|
|
|
|
// Creates a comment node after the current node
|
|
|
|
// `value` comment text
|
|
commentAfter(value) {
|
|
var child, i, removed;
|
|
// temporarily remove children starting *after* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i + 1);
|
|
// add the new child
|
|
child = this.parent.comment(value);
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return this;
|
|
}
|
|
|
|
// Adds unescaped raw text
|
|
|
|
// `value` text
|
|
raw(value) {
|
|
var child;
|
|
child = new XMLRaw(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
}
|
|
|
|
// Adds a dummy node
|
|
dummy() {
|
|
var child;
|
|
child = new XMLDummy(this);
|
|
// Normally when a new node is created it is added to the child node collection.
|
|
// However, dummy nodes are never added to the XML tree. They are created while
|
|
// converting JS objects to XML nodes in order not to break the recursive function
|
|
// chain. They can be thought of as invisible nodes. They can be traversed through
|
|
// by using prev(), next(), up(), etc. functions but they do not exists in the tree.
|
|
|
|
// @children.push child
|
|
return child;
|
|
}
|
|
|
|
// Adds a processing instruction
|
|
|
|
// `target` instruction target
|
|
// `value` instruction value
|
|
instruction(target, value) {
|
|
var insTarget, insValue, instruction, j, len;
|
|
if (target != null) {
|
|
target = getValue(target);
|
|
}
|
|
if (value != null) {
|
|
value = getValue(value);
|
|
}
|
|
if (Array.isArray(target)) { // expand if array
|
|
for (j = 0, len = target.length; j < len; j++) {
|
|
insTarget = target[j];
|
|
this.instruction(insTarget);
|
|
}
|
|
} else if (isObject(target)) { // expand if object
|
|
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.children.push(instruction);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// Creates a processing instruction node before the current node
|
|
|
|
// `target` instruction target
|
|
// `value` instruction value
|
|
instructionBefore(target, value) {
|
|
var child, i, removed;
|
|
// temporarily remove children starting *with* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i);
|
|
// add the new child
|
|
child = this.parent.instruction(target, value);
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return this;
|
|
}
|
|
|
|
// Creates a processing instruction node after the current node
|
|
|
|
// `target` instruction target
|
|
// `value` instruction value
|
|
instructionAfter(target, value) {
|
|
var child, i, removed;
|
|
// temporarily remove children starting *after* this
|
|
i = this.parent.children.indexOf(this);
|
|
removed = this.parent.children.splice(i + 1);
|
|
// add the new child
|
|
child = this.parent.instruction(target, value);
|
|
// add back removed children after new child
|
|
Array.prototype.push.apply(this.parent.children, removed);
|
|
return this;
|
|
}
|
|
|
|
// Creates the xml declaration
|
|
|
|
// `version` A version number string, e.g. 1.0
|
|
// `encoding` Encoding declaration, e.g. UTF-8
|
|
// `standalone` standalone document declaration: true or false
|
|
declaration(version, encoding, standalone) {
|
|
var doc, xmldec;
|
|
doc = this.document();
|
|
xmldec = new XMLDeclaration(doc, version, encoding, standalone);
|
|
// Replace XML declaration if exists, otherwise insert at top
|
|
if (doc.children.length === 0) {
|
|
doc.children.unshift(xmldec);
|
|
} else if (doc.children[0].type === NodeType.Declaration) {
|
|
doc.children[0] = xmldec;
|
|
} else {
|
|
doc.children.unshift(xmldec);
|
|
}
|
|
return doc.root() || doc;
|
|
}
|
|
|
|
// Creates the document type declaration
|
|
|
|
// `pubID` the public identifier of the external subset
|
|
// `sysID` the system identifier of the external subset
|
|
dtd(pubID, sysID) {
|
|
var child, doc, doctype, i, j, k, len, len1, ref1, ref2;
|
|
doc = this.document();
|
|
doctype = new XMLDocType(doc, pubID, sysID);
|
|
ref1 = doc.children;
|
|
// Replace DTD if exists
|
|
for (i = j = 0, len = ref1.length; j < len; i = ++j) {
|
|
child = ref1[i];
|
|
if (child.type === NodeType.DocType) {
|
|
doc.children[i] = doctype;
|
|
return doctype;
|
|
}
|
|
}
|
|
ref2 = doc.children;
|
|
// insert before root node if the root node exists
|
|
for (i = k = 0, len1 = ref2.length; k < len1; i = ++k) {
|
|
child = ref2[i];
|
|
if (child.isRoot) {
|
|
doc.children.splice(i, 0, doctype);
|
|
return doctype;
|
|
}
|
|
}
|
|
// otherwise append to end
|
|
doc.children.push(doctype);
|
|
return doctype;
|
|
}
|
|
|
|
// Gets the parent node
|
|
up() {
|
|
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;
|
|
}
|
|
|
|
// Gets the root node
|
|
root() {
|
|
var node;
|
|
node = this;
|
|
while (node) {
|
|
if (node.type === NodeType.Document) {
|
|
return node.rootObject;
|
|
} else if (node.isRoot) {
|
|
return node;
|
|
} else {
|
|
node = node.parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Gets the node representing the XML document
|
|
document() {
|
|
var node;
|
|
node = this;
|
|
while (node) {
|
|
if (node.type === NodeType.Document) {
|
|
return node;
|
|
} else {
|
|
node = node.parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ends the document and converts string
|
|
end(options) {
|
|
return this.document().end(options);
|
|
}
|
|
|
|
// Gets the previous node
|
|
prev() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
if (i < 1) {
|
|
throw new Error("Already at the first node. " + this.debugInfo());
|
|
}
|
|
return this.parent.children[i - 1];
|
|
}
|
|
|
|
// Gets the next node
|
|
next() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
if (i === -1 || i === this.parent.children.length - 1) {
|
|
throw new Error("Already at the last node. " + this.debugInfo());
|
|
}
|
|
return this.parent.children[i + 1];
|
|
}
|
|
|
|
// Imports cloned root from another XML document
|
|
|
|
// `doc` the XML document to insert nodes from
|
|
importDocument(doc) {
|
|
var child, clonedRoot, j, len, ref1;
|
|
clonedRoot = doc.root().clone();
|
|
clonedRoot.parent = this;
|
|
clonedRoot.isRoot = false;
|
|
this.children.push(clonedRoot);
|
|
// set properties if imported element becomes the root node
|
|
if (this.type === NodeType.Document) {
|
|
clonedRoot.isRoot = true;
|
|
clonedRoot.documentObject = this;
|
|
this.rootObject = clonedRoot;
|
|
// set dtd name
|
|
if (this.children) {
|
|
ref1 = this.children;
|
|
for (j = 0, len = ref1.length; j < len; j++) {
|
|
child = ref1[j];
|
|
if (child.type === NodeType.DocType) {
|
|
child.name = clonedRoot.name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
|
|
// Returns debug string for this node
|
|
debugInfo(name) {
|
|
var ref1, ref2;
|
|
name = name || this.name;
|
|
if ((name == null) && !((ref1 = this.parent) != null ? ref1.name : void 0)) {
|
|
return "";
|
|
} else if (name == null) {
|
|
return "parent: <" + this.parent.name + ">";
|
|
} else if (!((ref2 = this.parent) != null ? ref2.name : void 0)) {
|
|
return "node: <" + name + ">";
|
|
} else {
|
|
return "node: <" + name + ">, parent: <" + this.parent.name + ">";
|
|
}
|
|
}
|
|
|
|
// Aliases
|
|
ele(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
}
|
|
|
|
nod(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
}
|
|
|
|
txt(value) {
|
|
return this.text(value);
|
|
}
|
|
|
|
dat(value) {
|
|
return this.cdata(value);
|
|
}
|
|
|
|
com(value) {
|
|
return this.comment(value);
|
|
}
|
|
|
|
ins(target, value) {
|
|
return this.instruction(target, value);
|
|
}
|
|
|
|
doc() {
|
|
return this.document();
|
|
}
|
|
|
|
dec(version, encoding, standalone) {
|
|
return this.declaration(version, encoding, standalone);
|
|
}
|
|
|
|
e(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
}
|
|
|
|
n(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
}
|
|
|
|
t(value) {
|
|
return this.text(value);
|
|
}
|
|
|
|
d(value) {
|
|
return this.cdata(value);
|
|
}
|
|
|
|
c(value) {
|
|
return this.comment(value);
|
|
}
|
|
|
|
r(value) {
|
|
return this.raw(value);
|
|
}
|
|
|
|
i(target, value) {
|
|
return this.instruction(target, value);
|
|
}
|
|
|
|
u() {
|
|
return this.up();
|
|
}
|
|
|
|
// can be deprecated in a future release
|
|
importXMLBuilder(doc) {
|
|
return this.importDocument(doc);
|
|
}
|
|
|
|
// Adds or modifies an attribute.
|
|
|
|
// `name` attribute name
|
|
// `value` attribute value
|
|
attribute(name, value) {
|
|
throw new Error("attribute() applies to element nodes only.");
|
|
}
|
|
|
|
att(name, value) {
|
|
return this.attribute(name, value);
|
|
}
|
|
|
|
a(name, value) {
|
|
return this.attribute(name, value);
|
|
}
|
|
|
|
// Removes an attribute
|
|
|
|
// `name` attribute name
|
|
removeAttribute(name) {
|
|
throw new Error("attribute() applies to element nodes only.");
|
|
}
|
|
|
|
// DOM level 1 functions to be implemented later
|
|
replaceChild(newChild, oldChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
removeChild(oldChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
appendChild(newChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
hasChildNodes() {
|
|
return this.children.length !== 0;
|
|
}
|
|
|
|
cloneNode(deep) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
normalize() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM level 2
|
|
isSupported(feature, version) {
|
|
return true;
|
|
}
|
|
|
|
hasAttributes() {
|
|
return this.attribs.length !== 0;
|
|
}
|
|
|
|
// DOM level 3 functions to be implemented later
|
|
compareDocumentPosition(other) {
|
|
var ref, res;
|
|
ref = this;
|
|
if (ref === other) {
|
|
return 0;
|
|
} else if (this.document() !== other.document()) {
|
|
res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;
|
|
if (Math.random() < 0.5) {
|
|
res |= DocumentPosition.Preceding;
|
|
} else {
|
|
res |= DocumentPosition.Following;
|
|
}
|
|
return res;
|
|
} else if (ref.isAncestor(other)) {
|
|
return DocumentPosition.Contains | DocumentPosition.Preceding;
|
|
} else if (ref.isDescendant(other)) {
|
|
return DocumentPosition.Contains | DocumentPosition.Following;
|
|
} else if (ref.isPreceding(other)) {
|
|
return DocumentPosition.Preceding;
|
|
} else {
|
|
return DocumentPosition.Following;
|
|
}
|
|
}
|
|
|
|
isSameNode(other) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
lookupPrefix(namespaceURI) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
isDefaultNamespace(namespaceURI) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
lookupNamespaceURI(prefix) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
var i, j, ref1;
|
|
if (node.nodeType !== this.nodeType) {
|
|
return false;
|
|
}
|
|
if (node.children.length !== this.children.length) {
|
|
return false;
|
|
}
|
|
for (i = j = 0, ref1 = this.children.length - 1; (0 <= ref1 ? j <= ref1 : j >= ref1); i = 0 <= ref1 ? ++j : --j) {
|
|
if (!this.children[i].isEqualNode(node.children[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
getFeature(feature, version) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
setUserData(key, data, handler) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
getUserData(key) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// Returns true if other is an inclusive descendant of node,
|
|
// and false otherwise.
|
|
contains(other) {
|
|
if (!other) {
|
|
return false;
|
|
}
|
|
return other === this || this.isDescendant(other);
|
|
}
|
|
|
|
// An object A is called a descendant of an object B, if either A is
|
|
// a child of B or A is a child of an object C that is a descendant of B.
|
|
isDescendant(node) {
|
|
var child, isDescendantChild, j, len, ref1;
|
|
ref1 = this.children;
|
|
for (j = 0, len = ref1.length; j < len; j++) {
|
|
child = ref1[j];
|
|
if (node === child) {
|
|
return true;
|
|
}
|
|
isDescendantChild = child.isDescendant(node);
|
|
if (isDescendantChild) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// An object A is called an ancestor of an object B if and only if
|
|
// B is a descendant of A.
|
|
isAncestor(node) {
|
|
return node.isDescendant(this);
|
|
}
|
|
|
|
// An object A is preceding an object B if A and B are in the
|
|
// same tree and A comes before B in tree order.
|
|
isPreceding(node) {
|
|
var nodePos, thisPos;
|
|
nodePos = this.treePosition(node);
|
|
thisPos = this.treePosition(this);
|
|
if (nodePos === -1 || thisPos === -1) {
|
|
return false;
|
|
} else {
|
|
return nodePos < thisPos;
|
|
}
|
|
}
|
|
|
|
// An object A is folllowing an object B if A and B are in the
|
|
// same tree and A comes after B in tree order.
|
|
isFollowing(node) {
|
|
var nodePos, thisPos;
|
|
nodePos = this.treePosition(node);
|
|
thisPos = this.treePosition(this);
|
|
if (nodePos === -1 || thisPos === -1) {
|
|
return false;
|
|
} else {
|
|
return nodePos > thisPos;
|
|
}
|
|
}
|
|
|
|
// Returns the preorder position of the given node in the tree, or -1
|
|
// if the node is not in the tree.
|
|
treePosition(node) {
|
|
var found, pos;
|
|
pos = 0;
|
|
found = false;
|
|
this.foreachTreeNode(this.document(), function(childNode) {
|
|
pos++;
|
|
if (!found && childNode === node) {
|
|
return found = true;
|
|
}
|
|
});
|
|
if (found) {
|
|
return pos;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
// Depth-first preorder traversal through the XML tree
|
|
foreachTreeNode(node, func) {
|
|
var child, j, len, ref1, res;
|
|
node || (node = this.document());
|
|
ref1 = node.children;
|
|
for (j = 0, len = ref1.length; j < len; j++) {
|
|
child = ref1[j];
|
|
if (res = func(child)) {
|
|
return res;
|
|
} else {
|
|
res = this.foreachTreeNode(child, func);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLNode.prototype, 'nodeName', {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'nodeType', {
|
|
get: function() {
|
|
return this.type;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'nodeValue', {
|
|
get: function() {
|
|
return this.value;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'parentNode', {
|
|
get: function() {
|
|
return this.parent;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'childNodes', {
|
|
get: function() {
|
|
if (!this.childNodeList || !this.childNodeList.nodes) {
|
|
this.childNodeList = new XMLNodeList(this.children);
|
|
}
|
|
return this.childNodeList;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'firstChild', {
|
|
get: function() {
|
|
return this.children[0] || null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'lastChild', {
|
|
get: function() {
|
|
return this.children[this.children.length - 1] || null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'previousSibling', {
|
|
get: function() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
return this.parent.children[i - 1] || null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'nextSibling', {
|
|
get: function() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
return this.parent.children[i + 1] || null;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLNode.prototype, 'ownerDocument', {
|
|
get: function() {
|
|
return this.document() || null;
|
|
}
|
|
});
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLNode.prototype, 'textContent', {
|
|
get: function() {
|
|
var child, j, len, ref1, str;
|
|
if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {
|
|
str = '';
|
|
ref1 = this.children;
|
|
for (j = 0, len = ref1.length; j < len; j++) {
|
|
child = ref1[j];
|
|
if (child.textContent) {
|
|
str += child.textContent;
|
|
}
|
|
}
|
|
return str;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
set: function(value) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
return XMLNode;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./DocumentPosition":4,"./NodeType":5,"./Utility":6,"./XMLCData":9,"./XMLComment":11,"./XMLDeclaration":20,"./XMLDocType":21,"./XMLDummy":24,"./XMLElement":25,"./XMLNamedNodeMap":26,"./XMLNodeList":28,"./XMLProcessingInstruction":29,"./XMLRaw":30,"./XMLText":34}],28:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Represents a list of nodes
|
|
var XMLNodeList;
|
|
|
|
module.exports = XMLNodeList = (function() {
|
|
class XMLNodeList {
|
|
// Initializes a new instance of `XMLNodeList`
|
|
// This is just a wrapper around an ordinary
|
|
// JS array.
|
|
|
|
// `nodes` the array containing nodes.
|
|
constructor(nodes) {
|
|
this.nodes = nodes;
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
|
|
clone() {
|
|
// this class should not be cloned since it wraps
|
|
// around a given array. The calling function should check
|
|
// whether the wrapped array is null and supply a new array
|
|
// (from the clone).
|
|
return this.nodes = null;
|
|
}
|
|
|
|
// DOM Level 1
|
|
item(index) {
|
|
return this.nodes[index] || null;
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 1
|
|
Object.defineProperty(XMLNodeList.prototype, 'length', {
|
|
get: function() {
|
|
return this.nodes.length || 0;
|
|
}
|
|
});
|
|
|
|
return XMLNodeList;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{}],29:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLProcessingInstruction;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLCharacterData = require('./XMLCharacterData');
|
|
|
|
// Represents a processing instruction
|
|
module.exports = XMLProcessingInstruction = class XMLProcessingInstruction extends XMLCharacterData {
|
|
// Initializes a new instance of `XMLProcessingInstruction`
|
|
|
|
// `parent` the parent node
|
|
// `target` instruction target
|
|
// `value` instruction value
|
|
constructor(parent, target, value) {
|
|
super(parent);
|
|
if (target == null) {
|
|
throw new Error("Missing instruction target. " + this.debugInfo());
|
|
}
|
|
this.type = NodeType.ProcessingInstruction;
|
|
this.target = this.stringify.insTarget(target);
|
|
this.name = this.target;
|
|
if (value) {
|
|
this.value = this.stringify.insValue(value);
|
|
}
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
isEqualNode(node) {
|
|
if (!super.isEqualNode(node)) {
|
|
return false;
|
|
}
|
|
if (node.target !== this.target) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLCharacterData":10}],30:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLNode, XMLRaw;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLNode = require('./XMLNode');
|
|
|
|
// Represents a raw node
|
|
module.exports = XMLRaw = class XMLRaw extends XMLNode {
|
|
// Initializes a new instance of `XMLRaw`
|
|
|
|
// `text` raw text
|
|
constructor(parent, text) {
|
|
super(parent);
|
|
if (text == null) {
|
|
throw new Error("Missing raw text. " + this.debugInfo());
|
|
}
|
|
this.type = NodeType.Raw;
|
|
this.value = this.stringify.raw(text);
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.raw(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLNode":27}],31:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, WriterState, XMLStreamWriter, XMLWriterBase,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLWriterBase = require('./XMLWriterBase');
|
|
|
|
WriterState = require('./WriterState');
|
|
|
|
// Prints XML nodes to a stream
|
|
module.exports = XMLStreamWriter = class XMLStreamWriter extends XMLWriterBase {
|
|
// Initializes a new instance of `XMLStreamWriter`
|
|
|
|
// `stream` output stream
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation string
|
|
// `options.newline` newline sequence
|
|
// `options.offset` a fixed number of indentations to add to every line
|
|
// `options.allowEmpty` do not self close empty element tags
|
|
// 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF
|
|
// `options.spaceBeforeSlash` add a space before the closing slash of empty elements
|
|
constructor(stream, options) {
|
|
super(options);
|
|
this.stream = stream;
|
|
}
|
|
|
|
endline(node, options, level) {
|
|
if (node.isLastRootNode && options.state === WriterState.CloseTag) {
|
|
return '';
|
|
} else {
|
|
return super.endline(node, options, level);
|
|
}
|
|
}
|
|
|
|
document(doc, options) {
|
|
var child, i, j, k, len1, len2, ref, ref1, results;
|
|
ref = doc.children;
|
|
// set a flag so that we don't insert a newline after the last root level node
|
|
for (i = j = 0, len1 = ref.length; j < len1; i = ++j) {
|
|
child = ref[i];
|
|
child.isLastRootNode = i === doc.children.length - 1;
|
|
}
|
|
options = this.filterOptions(options);
|
|
ref1 = doc.children;
|
|
results = [];
|
|
for (k = 0, len2 = ref1.length; k < len2; k++) {
|
|
child = ref1[k];
|
|
results.push(this.writeChildNode(child, options, 0));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
cdata(node, options, level) {
|
|
return this.stream.write(super.cdata(node, options, level));
|
|
}
|
|
|
|
comment(node, options, level) {
|
|
return this.stream.write(super.comment(node, options, level));
|
|
}
|
|
|
|
declaration(node, options, level) {
|
|
return this.stream.write(super.declaration(node, options, level));
|
|
}
|
|
|
|
docType(node, options, level) {
|
|
var child, j, len1, ref;
|
|
level || (level = 0);
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
this.stream.write(this.indent(node, options, level));
|
|
this.stream.write('<!DOCTYPE ' + node.root().name);
|
|
// external identifier
|
|
if (node.pubID && node.sysID) {
|
|
this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
|
|
} else if (node.sysID) {
|
|
this.stream.write(' SYSTEM "' + node.sysID + '"');
|
|
}
|
|
// internal subset
|
|
if (node.children.length > 0) {
|
|
this.stream.write(' [');
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.InsideTag;
|
|
ref = node.children;
|
|
for (j = 0, len1 = ref.length; j < len1; j++) {
|
|
child = ref[j];
|
|
this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(']');
|
|
}
|
|
// close tag
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(options.spaceBeforeSlash + '>');
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.None;
|
|
return this.closeNode(node, options, level);
|
|
}
|
|
|
|
element(node, options, level) {
|
|
var att, attLen, child, childNodeCount, firstChildNode, j, len, len1, name, prettySuppressed, r, ratt, ref, ref1, ref2, rline;
|
|
level || (level = 0);
|
|
// open tag
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<' + node.name;
|
|
// attributes
|
|
if (options.pretty && options.width > 0) {
|
|
len = r.length;
|
|
ref = node.attribs;
|
|
for (name in ref) {
|
|
if (!hasProp.call(ref, name)) continue;
|
|
att = ref[name];
|
|
ratt = this.attribute(att, options, level);
|
|
attLen = ratt.length;
|
|
if (len + attLen > options.width) {
|
|
rline = this.indent(node, options, level + 1) + ratt;
|
|
r += this.endline(node, options, level) + rline;
|
|
len = rline.length;
|
|
} else {
|
|
rline = ' ' + ratt;
|
|
r += rline;
|
|
len += rline.length;
|
|
}
|
|
}
|
|
} else {
|
|
ref1 = node.attribs;
|
|
for (name in ref1) {
|
|
if (!hasProp.call(ref1, name)) continue;
|
|
att = ref1[name];
|
|
r += this.attribute(att, options, level);
|
|
}
|
|
}
|
|
this.stream.write(r);
|
|
childNodeCount = node.children.length;
|
|
firstChildNode = childNodeCount === 0 ? null : node.children[0];
|
|
if (childNodeCount === 0 || node.children.every(function(e) {
|
|
return (e.type === NodeType.Text || e.type === NodeType.Raw || e.type === NodeType.CData) && e.value === '';
|
|
})) {
|
|
// empty element
|
|
if (options.allowEmpty) {
|
|
this.stream.write('>');
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write('</' + node.name + '>');
|
|
} else {
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(options.spaceBeforeSlash + '/>');
|
|
}
|
|
} else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw || firstChildNode.type === NodeType.CData) && (firstChildNode.value != null)) {
|
|
// do not indent text-only nodes
|
|
this.stream.write('>');
|
|
options.state = WriterState.InsideTag;
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
this.writeChildNode(firstChildNode, options, level + 1);
|
|
options.suppressPrettyCount--;
|
|
prettySuppressed = false;
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write('</' + node.name + '>');
|
|
} else {
|
|
this.stream.write('>' + this.endline(node, options, level));
|
|
options.state = WriterState.InsideTag;
|
|
ref2 = node.children;
|
|
// inner tags
|
|
for (j = 0, len1 = ref2.length; j < len1; j++) {
|
|
child = ref2[j];
|
|
this.writeChildNode(child, options, level + 1);
|
|
}
|
|
// close tag
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(this.indent(node, options, level) + '</' + node.name + '>');
|
|
}
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.None;
|
|
return this.closeNode(node, options, level);
|
|
}
|
|
|
|
processingInstruction(node, options, level) {
|
|
return this.stream.write(super.processingInstruction(node, options, level));
|
|
}
|
|
|
|
raw(node, options, level) {
|
|
return this.stream.write(super.raw(node, options, level));
|
|
}
|
|
|
|
text(node, options, level) {
|
|
return this.stream.write(super.text(node, options, level));
|
|
}
|
|
|
|
dtdAttList(node, options, level) {
|
|
return this.stream.write(super.dtdAttList(node, options, level));
|
|
}
|
|
|
|
dtdElement(node, options, level) {
|
|
return this.stream.write(super.dtdElement(node, options, level));
|
|
}
|
|
|
|
dtdEntity(node, options, level) {
|
|
return this.stream.write(super.dtdEntity(node, options, level));
|
|
}
|
|
|
|
dtdNotation(node, options, level) {
|
|
return this.stream.write(super.dtdNotation(node, options, level));
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./WriterState":7,"./XMLWriterBase":35}],32:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var XMLStringWriter, XMLWriterBase;
|
|
|
|
XMLWriterBase = require('./XMLWriterBase');
|
|
|
|
// Prints XML nodes as plain text
|
|
module.exports = XMLStringWriter = class XMLStringWriter extends XMLWriterBase {
|
|
// Initializes a new instance of `XMLStringWriter`
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation string
|
|
// `options.newline` newline sequence
|
|
// `options.offset` a fixed number of indentations to add to every line
|
|
// `options.allowEmpty` do not self close empty element tags
|
|
// 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF
|
|
// `options.spaceBeforeSlash` add a space before the closing slash of empty elements
|
|
constructor(options) {
|
|
super(options);
|
|
}
|
|
|
|
document(doc, options) {
|
|
var child, i, len, r, ref;
|
|
options = this.filterOptions(options);
|
|
r = '';
|
|
ref = doc.children;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
child = ref[i];
|
|
r += this.writeChildNode(child, options, 0);
|
|
}
|
|
// remove trailing newline
|
|
if (options.pretty && r.slice(-options.newline.length) === options.newline) {
|
|
r = r.slice(0, -options.newline.length);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./XMLWriterBase":35}],33:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
// Converts values to strings
|
|
var XMLStringifier,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
module.exports = XMLStringifier = (function() {
|
|
class XMLStringifier {
|
|
// Initializes a new instance of `XMLStringifier`
|
|
|
|
// `options.version` The version number string of the XML spec to validate against, e.g. 1.0
|
|
// `options.noDoubleEncoding` whether existing html entities are encoded: true or false
|
|
// `options.stringify` a set of functions to use for converting values to strings
|
|
// `options.noValidation` whether values will be validated and escaped or returned as is
|
|
// `options.invalidCharReplacement` a character to replace invalid characters and disable character validation
|
|
constructor(options) {
|
|
var key, ref, value;
|
|
// Checks whether the given string contains legal characters
|
|
// Fails with an exception on error
|
|
|
|
// `str` the string to check
|
|
this.assertLegalChar = this.assertLegalChar.bind(this);
|
|
// Checks whether the given string contains legal characters for a name
|
|
// Fails with an exception on error
|
|
|
|
// `str` the string to check
|
|
this.assertLegalName = this.assertLegalName.bind(this);
|
|
options || (options = {});
|
|
this.options = options;
|
|
if (!this.options.version) {
|
|
this.options.version = '1.0';
|
|
}
|
|
ref = options.stringify || {};
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key)) continue;
|
|
value = ref[key];
|
|
this[key] = value;
|
|
}
|
|
}
|
|
|
|
// Defaults
|
|
name(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalName('' + val || '');
|
|
}
|
|
|
|
text(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar(this.textEscape('' + val || ''));
|
|
}
|
|
|
|
cdata(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
val = '' + val || '';
|
|
val = val.replace(']]>', ']]]]><![CDATA[>');
|
|
return this.assertLegalChar(val);
|
|
}
|
|
|
|
comment(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
val = '' + val || '';
|
|
if (val.match(/--/)) {
|
|
throw new Error("Comment text cannot contain double-hypen: " + val);
|
|
}
|
|
return this.assertLegalChar(val);
|
|
}
|
|
|
|
raw(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return '' + val || '';
|
|
}
|
|
|
|
attValue(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar(this.attEscape(val = '' + val || ''));
|
|
}
|
|
|
|
insTarget(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
insValue(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
val = '' + val || '';
|
|
if (val.match(/\?>/)) {
|
|
throw new Error("Invalid processing instruction value: " + val);
|
|
}
|
|
return this.assertLegalChar(val);
|
|
}
|
|
|
|
xmlVersion(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
val = '' + val || '';
|
|
if (!val.match(/1\.[0-9]+/)) {
|
|
throw new Error("Invalid version number: " + val);
|
|
}
|
|
return val;
|
|
}
|
|
|
|
xmlEncoding(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
val = '' + val || '';
|
|
if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
|
|
throw new Error("Invalid encoding: " + val);
|
|
}
|
|
return this.assertLegalChar(val);
|
|
}
|
|
|
|
xmlStandalone(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
if (val) {
|
|
return "yes";
|
|
} else {
|
|
return "no";
|
|
}
|
|
}
|
|
|
|
dtdPubID(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdSysID(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdElementValue(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdAttType(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdAttDefault(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdEntityValue(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
dtdNData(val) {
|
|
if (this.options.noValidation) {
|
|
return val;
|
|
}
|
|
return this.assertLegalChar('' + val || '');
|
|
}
|
|
|
|
assertLegalChar(str) {
|
|
var regex, res;
|
|
if (this.options.noValidation) {
|
|
return str;
|
|
}
|
|
if (this.options.version === '1.0') {
|
|
// Valid characters from https://www.w3.org/TR/xml/#charsets
|
|
// any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
|
|
// #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
|
|
// This ES5 compatible Regexp has been generated using the "regenerate" NPM module:
|
|
// let xml_10_InvalidChars = regenerate()
|
|
// .addRange(0x0000, 0x0008)
|
|
// .add(0x000B, 0x000C)
|
|
// .addRange(0x000E, 0x001F)
|
|
// .addRange(0xD800, 0xDFFF)
|
|
// .addRange(0xFFFE, 0xFFFF)
|
|
regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g;
|
|
if (this.options.invalidCharReplacement !== void 0) {
|
|
str = str.replace(regex, this.options.invalidCharReplacement);
|
|
} else if (res = str.match(regex)) {
|
|
throw new Error(`Invalid character in string: ${str} at index ${res.index}`);
|
|
}
|
|
} else if (this.options.version === '1.1') {
|
|
// Valid characters from https://www.w3.org/TR/xml11/#charsets
|
|
// any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
|
|
// [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
|
|
// This ES5 compatible Regexp has been generated using the "regenerate" NPM module:
|
|
// let xml_11_InvalidChars = regenerate()
|
|
// .add(0x0000)
|
|
// .addRange(0xD800, 0xDFFF)
|
|
// .addRange(0xFFFE, 0xFFFF)
|
|
regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g;
|
|
if (this.options.invalidCharReplacement !== void 0) {
|
|
str = str.replace(regex, this.options.invalidCharReplacement);
|
|
} else if (res = str.match(regex)) {
|
|
throw new Error(`Invalid character in string: ${str} at index ${res.index}`);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
assertLegalName(str) {
|
|
var regex;
|
|
if (this.options.noValidation) {
|
|
return str;
|
|
}
|
|
str = this.assertLegalChar(str);
|
|
regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
|
|
if (!str.match(regex)) {
|
|
throw new Error(`Invalid character in name: ${str}`);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// Escapes special characters in text
|
|
|
|
// See http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping
|
|
|
|
// `str` the string to escape
|
|
textEscape(str) {
|
|
var ampregex;
|
|
if (this.options.noValidation) {
|
|
return str;
|
|
}
|
|
ampregex = this.options.noDoubleEncoding ? /(?!&(lt|gt|amp|apos|quot);)&/g : /&/g;
|
|
return str.replace(ampregex, '&').replace(/</g, '<').replace(/>/g, '>').replace(/\r/g, '
');
|
|
}
|
|
|
|
// Escapes special characters in attribute values
|
|
|
|
// See http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping
|
|
|
|
// `str` the string to escape
|
|
attEscape(str) {
|
|
var ampregex;
|
|
if (this.options.noValidation) {
|
|
return str;
|
|
}
|
|
ampregex = this.options.noDoubleEncoding ? /(?!&(lt|gt|amp|apos|quot);)&/g : /&/g;
|
|
return str.replace(ampregex, '&').replace(/</g, '<').replace(/"/g, '"').replace(/\t/g, '	').replace(/\n/g, '
').replace(/\r/g, '
');
|
|
}
|
|
|
|
};
|
|
|
|
// strings to match while converting from JS objects
|
|
XMLStringifier.prototype.convertAttKey = '@';
|
|
|
|
XMLStringifier.prototype.convertPIKey = '?';
|
|
|
|
XMLStringifier.prototype.convertTextKey = '#text';
|
|
|
|
XMLStringifier.prototype.convertCDataKey = '#cdata';
|
|
|
|
XMLStringifier.prototype.convertCommentKey = '#comment';
|
|
|
|
XMLStringifier.prototype.convertRawKey = '#raw';
|
|
|
|
return XMLStringifier;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{}],34:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLText;
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLCharacterData = require('./XMLCharacterData');
|
|
|
|
// Represents a text node
|
|
module.exports = XMLText = (function() {
|
|
class XMLText extends XMLCharacterData {
|
|
// Initializes a new instance of `XMLText`
|
|
|
|
// `text` element text
|
|
constructor(parent, text) {
|
|
super(parent);
|
|
if (text == null) {
|
|
throw new Error("Missing element text. " + this.debugInfo());
|
|
}
|
|
this.name = "#text";
|
|
this.type = NodeType.Text;
|
|
this.value = this.stringify.text(text);
|
|
}
|
|
|
|
// Creates and returns a deep clone of `this`
|
|
clone() {
|
|
return Object.create(this);
|
|
}
|
|
|
|
// Converts the XML fragment to string
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation for pretty print
|
|
// `options.offset` how many indentations to add to every line for pretty print
|
|
// `options.newline` newline sequence for pretty print
|
|
toString(options) {
|
|
return this.options.writer.text(this, this.options.writer.filterOptions(options));
|
|
}
|
|
|
|
// DOM level 1 functions to be implemented later
|
|
splitText(offset) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
// DOM level 3 functions to be implemented later
|
|
replaceWholeText(content) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
|
|
};
|
|
|
|
// DOM level 3
|
|
Object.defineProperty(XMLText.prototype, 'isElementContentWhitespace', {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(XMLText.prototype, 'wholeText', {
|
|
get: function() {
|
|
var next, prev, str;
|
|
str = '';
|
|
prev = this.previousSibling;
|
|
while (prev) {
|
|
str = prev.data + str;
|
|
prev = prev.previousSibling;
|
|
}
|
|
str += this.data;
|
|
next = this.nextSibling;
|
|
while (next) {
|
|
str = str + next.data;
|
|
next = next.nextSibling;
|
|
}
|
|
return str;
|
|
}
|
|
});
|
|
|
|
return XMLText;
|
|
|
|
}).call(this);
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./XMLCharacterData":10}],35:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
({assign} = require('./Utility'));
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
XMLDeclaration = require('./XMLDeclaration');
|
|
|
|
XMLDocType = require('./XMLDocType');
|
|
|
|
XMLCData = require('./XMLCData');
|
|
|
|
XMLComment = require('./XMLComment');
|
|
|
|
XMLElement = require('./XMLElement');
|
|
|
|
XMLRaw = require('./XMLRaw');
|
|
|
|
XMLText = require('./XMLText');
|
|
|
|
XMLProcessingInstruction = require('./XMLProcessingInstruction');
|
|
|
|
XMLDummy = require('./XMLDummy');
|
|
|
|
XMLDTDAttList = require('./XMLDTDAttList');
|
|
|
|
XMLDTDElement = require('./XMLDTDElement');
|
|
|
|
XMLDTDEntity = require('./XMLDTDEntity');
|
|
|
|
XMLDTDNotation = require('./XMLDTDNotation');
|
|
|
|
WriterState = require('./WriterState');
|
|
|
|
// Base class for XML writers
|
|
module.exports = XMLWriterBase = class XMLWriterBase {
|
|
// Initializes a new instance of `XMLWriterBase`
|
|
|
|
// `options.pretty` pretty prints the result
|
|
// `options.indent` indentation string
|
|
// `options.newline` newline sequence
|
|
// `options.offset` a fixed number of indentations to add to every line
|
|
// `options.width` maximum column width
|
|
// `options.allowEmpty` do not self close empty element tags
|
|
// 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF
|
|
// `options.spaceBeforeSlash` add a space before the closing slash of empty elements
|
|
constructor(options) {
|
|
var key, ref, value;
|
|
options || (options = {});
|
|
this.options = options;
|
|
ref = options.writer || {};
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key)) continue;
|
|
value = ref[key];
|
|
this["_" + key] = this[key];
|
|
this[key] = value;
|
|
}
|
|
}
|
|
|
|
// Filters writer options and provides defaults
|
|
|
|
// `options` writer options
|
|
filterOptions(options) {
|
|
var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
|
|
options || (options = {});
|
|
options = assign({}, this.options, options);
|
|
filteredOptions = {
|
|
writer: this
|
|
};
|
|
filteredOptions.pretty = options.pretty || false;
|
|
filteredOptions.allowEmpty = options.allowEmpty || false;
|
|
filteredOptions.indent = (ref = options.indent) != null ? ref : ' ';
|
|
filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\n';
|
|
filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
|
|
filteredOptions.width = (ref3 = options.width) != null ? ref3 : 0;
|
|
filteredOptions.dontPrettyTextNodes = (ref4 = (ref5 = options.dontPrettyTextNodes) != null ? ref5 : options.dontprettytextnodes) != null ? ref4 : 0;
|
|
filteredOptions.spaceBeforeSlash = (ref6 = (ref7 = options.spaceBeforeSlash) != null ? ref7 : options.spacebeforeslash) != null ? ref6 : '';
|
|
if (filteredOptions.spaceBeforeSlash === true) {
|
|
filteredOptions.spaceBeforeSlash = ' ';
|
|
}
|
|
filteredOptions.suppressPrettyCount = 0;
|
|
filteredOptions.user = {};
|
|
filteredOptions.state = WriterState.None;
|
|
return filteredOptions;
|
|
}
|
|
|
|
// Returns the indentation string for the current level
|
|
|
|
// `node` current node
|
|
// `options` writer options
|
|
// `level` current indentation level
|
|
indent(node, options, level) {
|
|
var indentLevel;
|
|
if (!options.pretty || options.suppressPrettyCount) {
|
|
return '';
|
|
} else if (options.pretty) {
|
|
indentLevel = (level || 0) + options.offset + 1;
|
|
if (indentLevel > 0) {
|
|
return new Array(indentLevel).join(options.indent);
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
// Returns the newline string
|
|
|
|
// `node` current node
|
|
// `options` writer options
|
|
// `level` current indentation level
|
|
endline(node, options, level) {
|
|
if (!options.pretty || options.suppressPrettyCount) {
|
|
return '';
|
|
} else {
|
|
return options.newline;
|
|
}
|
|
}
|
|
|
|
attribute(att, options, level) {
|
|
var r;
|
|
this.openAttribute(att, options, level);
|
|
if (options.pretty && options.width > 0) {
|
|
r = att.name + '="' + att.value + '"';
|
|
} else {
|
|
r = ' ' + att.name + '="' + att.value + '"';
|
|
}
|
|
this.closeAttribute(att, options, level);
|
|
return r;
|
|
}
|
|
|
|
cdata(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<![CDATA[';
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += ']]>' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
comment(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<!-- ';
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += ' -->' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
declaration(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<?xml';
|
|
options.state = WriterState.InsideTag;
|
|
r += ' version="' + node.version + '"';
|
|
if (node.encoding != null) {
|
|
r += ' encoding="' + node.encoding + '"';
|
|
}
|
|
if (node.standalone != null) {
|
|
r += ' standalone="' + node.standalone + '"';
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '?>';
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
docType(node, options, level) {
|
|
var child, i, len1, r, ref;
|
|
level || (level = 0);
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
r += '<!DOCTYPE ' + node.root().name;
|
|
// external identifier
|
|
if (node.pubID && node.sysID) {
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
} else if (node.sysID) {
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
}
|
|
// internal subset
|
|
if (node.children.length > 0) {
|
|
r += ' [';
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
ref = node.children;
|
|
for (i = 0, len1 = ref.length; i < len1; i++) {
|
|
child = ref[i];
|
|
r += this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += ']';
|
|
}
|
|
// close tag
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '>';
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
element(node, options, level) {
|
|
var att, attLen, child, childNodeCount, firstChildNode, i, j, len, len1, len2, name, prettySuppressed, r, ratt, ref, ref1, ref2, ref3, rline;
|
|
level || (level = 0);
|
|
prettySuppressed = false;
|
|
// open tag
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<' + node.name;
|
|
// attributes
|
|
if (options.pretty && options.width > 0) {
|
|
len = r.length;
|
|
ref = node.attribs;
|
|
for (name in ref) {
|
|
if (!hasProp.call(ref, name)) continue;
|
|
att = ref[name];
|
|
ratt = this.attribute(att, options, level);
|
|
attLen = ratt.length;
|
|
if (len + attLen > options.width) {
|
|
rline = this.indent(node, options, level + 1) + ratt;
|
|
r += this.endline(node, options, level) + rline;
|
|
len = rline.length;
|
|
} else {
|
|
rline = ' ' + ratt;
|
|
r += rline;
|
|
len += rline.length;
|
|
}
|
|
}
|
|
} else {
|
|
ref1 = node.attribs;
|
|
for (name in ref1) {
|
|
if (!hasProp.call(ref1, name)) continue;
|
|
att = ref1[name];
|
|
r += this.attribute(att, options, level);
|
|
}
|
|
}
|
|
childNodeCount = node.children.length;
|
|
firstChildNode = childNodeCount === 0 ? null : node.children[0];
|
|
if (childNodeCount === 0 || node.children.every(function(e) {
|
|
return (e.type === NodeType.Text || e.type === NodeType.Raw || e.type === NodeType.CData) && e.value === '';
|
|
})) {
|
|
// empty element
|
|
if (options.allowEmpty) {
|
|
r += '>';
|
|
options.state = WriterState.CloseTag;
|
|
r += '</' + node.name + '>' + this.endline(node, options, level);
|
|
} else {
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level);
|
|
}
|
|
} else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw || firstChildNode.type === NodeType.CData) && (firstChildNode.value != null)) {
|
|
// do not indent text-only nodes
|
|
r += '>';
|
|
options.state = WriterState.InsideTag;
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
r += this.writeChildNode(firstChildNode, options, level + 1);
|
|
options.suppressPrettyCount--;
|
|
prettySuppressed = false;
|
|
options.state = WriterState.CloseTag;
|
|
r += '</' + node.name + '>' + this.endline(node, options, level);
|
|
} else {
|
|
// if ANY are a text node, then suppress pretty now
|
|
if (options.dontPrettyTextNodes) {
|
|
ref2 = node.children;
|
|
for (i = 0, len1 = ref2.length; i < len1; i++) {
|
|
child = ref2[i];
|
|
if ((child.type === NodeType.Text || child.type === NodeType.Raw || child.type === NodeType.CData) && (child.value != null)) {
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// close the opening tag, after dealing with newline
|
|
r += '>' + this.endline(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
ref3 = node.children;
|
|
// inner tags
|
|
for (j = 0, len2 = ref3.length; j < len2; j++) {
|
|
child = ref3[j];
|
|
r += this.writeChildNode(child, options, level + 1);
|
|
}
|
|
// close tag
|
|
options.state = WriterState.CloseTag;
|
|
r += this.indent(node, options, level) + '</' + node.name + '>';
|
|
if (prettySuppressed) {
|
|
options.suppressPrettyCount--;
|
|
}
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
}
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
writeChildNode(node, options, level) {
|
|
switch (node.type) {
|
|
case NodeType.CData:
|
|
return this.cdata(node, options, level);
|
|
case NodeType.Comment:
|
|
return this.comment(node, options, level);
|
|
case NodeType.Element:
|
|
return this.element(node, options, level);
|
|
case NodeType.Raw:
|
|
return this.raw(node, options, level);
|
|
case NodeType.Text:
|
|
return this.text(node, options, level);
|
|
case NodeType.ProcessingInstruction:
|
|
return this.processingInstruction(node, options, level);
|
|
case NodeType.Dummy:
|
|
return '';
|
|
case NodeType.Declaration:
|
|
return this.declaration(node, options, level);
|
|
case NodeType.DocType:
|
|
return this.docType(node, options, level);
|
|
case NodeType.AttributeDeclaration:
|
|
return this.dtdAttList(node, options, level);
|
|
case NodeType.ElementDeclaration:
|
|
return this.dtdElement(node, options, level);
|
|
case NodeType.EntityDeclaration:
|
|
return this.dtdEntity(node, options, level);
|
|
case NodeType.NotationDeclaration:
|
|
return this.dtdNotation(node, options, level);
|
|
default:
|
|
throw new Error("Unknown XML node type: " + node.constructor.name);
|
|
}
|
|
}
|
|
|
|
processingInstruction(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<?';
|
|
options.state = WriterState.InsideTag;
|
|
r += node.target;
|
|
if (node.value) {
|
|
r += ' ' + node.value;
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '?>';
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
raw(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
text(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
dtdAttList(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<!ATTLIST';
|
|
options.state = WriterState.InsideTag;
|
|
r += ' ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
|
|
if (node.defaultValueType !== '#DEFAULT') {
|
|
r += ' ' + node.defaultValueType;
|
|
}
|
|
if (node.defaultValue) {
|
|
r += ' "' + node.defaultValue + '"';
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
dtdElement(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<!ELEMENT';
|
|
options.state = WriterState.InsideTag;
|
|
r += ' ' + node.name + ' ' + node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
dtdEntity(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<!ENTITY';
|
|
options.state = WriterState.InsideTag;
|
|
if (node.pe) {
|
|
r += ' %';
|
|
}
|
|
r += ' ' + node.name;
|
|
if (node.value) {
|
|
r += ' "' + node.value + '"';
|
|
} else {
|
|
if (node.pubID && node.sysID) {
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
} else if (node.sysID) {
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
}
|
|
if (node.nData) {
|
|
r += ' NDATA ' + node.nData;
|
|
}
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
dtdNotation(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + '<!NOTATION';
|
|
options.state = WriterState.InsideTag;
|
|
r += ' ' + node.name;
|
|
if (node.pubID && node.sysID) {
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
} else if (node.pubID) {
|
|
r += ' PUBLIC "' + node.pubID + '"';
|
|
} else if (node.sysID) {
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
}
|
|
|
|
openNode(node, options, level) {}
|
|
|
|
closeNode(node, options, level) {}
|
|
|
|
openAttribute(att, options, level) {}
|
|
|
|
closeAttribute(att, options, level) {}
|
|
|
|
};
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./WriterState":7,"./XMLCData":9,"./XMLComment":11,"./XMLDTDAttList":16,"./XMLDTDElement":17,"./XMLDTDEntity":18,"./XMLDTDNotation":19,"./XMLDeclaration":20,"./XMLDocType":21,"./XMLDummy":24,"./XMLElement":25,"./XMLProcessingInstruction":29,"./XMLRaw":30,"./XMLText":34}],36:[function(require,module,exports){
|
|
// Generated by CoffeeScript 2.4.1
|
|
(function() {
|
|
var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction;
|
|
|
|
({assign, isFunction} = require('./Utility'));
|
|
|
|
XMLDOMImplementation = require('./XMLDOMImplementation');
|
|
|
|
XMLDocument = require('./XMLDocument');
|
|
|
|
XMLDocumentCB = require('./XMLDocumentCB');
|
|
|
|
XMLStringWriter = require('./XMLStringWriter');
|
|
|
|
XMLStreamWriter = require('./XMLStreamWriter');
|
|
|
|
NodeType = require('./NodeType');
|
|
|
|
WriterState = require('./WriterState');
|
|
|
|
// Creates a new document and returns the root node for
|
|
// chain-building the document tree
|
|
|
|
// `name` name of the root element
|
|
|
|
// `xmldec.version` A version number string, e.g. 1.0
|
|
// `xmldec.encoding` Encoding declaration, e.g. UTF-8
|
|
// `xmldec.standalone` standalone document declaration: true or false
|
|
|
|
// `doctype.pubID` public identifier of the external subset
|
|
// `doctype.sysID` system identifier of the external subset
|
|
|
|
// `options.headless` whether XML declaration and doctype will be included:
|
|
// true or false
|
|
// `options.keepNullNodes` whether nodes with null values will be kept
|
|
// or ignored: true or false
|
|
// `options.keepNullAttributes` whether attributes with null values will be
|
|
// kept or ignored: true or false
|
|
// `options.ignoreDecorators` whether decorator strings will be ignored when
|
|
// converting JS objects: true or false
|
|
// `options.separateArrayItems` whether array items are created as separate
|
|
// nodes when passed as an object value: true or false
|
|
// `options.noDoubleEncoding` whether existing html entities are encoded:
|
|
// true or false
|
|
// `options.stringify` a set of functions to use for converting values to
|
|
// strings
|
|
// `options.writer` the default XML writer to use for converting nodes to
|
|
// string. If the default writer is not set, the built-in XMLStringWriter
|
|
// will be used instead.
|
|
module.exports.create = function(name, xmldec, doctype, options) {
|
|
var doc, root;
|
|
if (name == null) {
|
|
throw new Error("Root element needs a name.");
|
|
}
|
|
options = assign({}, xmldec, doctype, options);
|
|
// create the document node
|
|
doc = new XMLDocument(options);
|
|
// add the root node
|
|
root = doc.element(name);
|
|
// prolog
|
|
if (!options.headless) {
|
|
doc.declaration(options);
|
|
if ((options.pubID != null) || (options.sysID != null)) {
|
|
doc.dtd(options);
|
|
}
|
|
}
|
|
return root;
|
|
};
|
|
|
|
// Creates a new document and returns the document node for
|
|
// chain-building the document tree
|
|
|
|
// `options.keepNullNodes` whether nodes with null values will be kept
|
|
// or ignored: true or false
|
|
// `options.keepNullAttributes` whether attributes with null values will be
|
|
// kept or ignored: true or false
|
|
// `options.ignoreDecorators` whether decorator strings will be ignored when
|
|
// converting JS objects: true or false
|
|
// `options.separateArrayItems` whether array items are created as separate
|
|
// nodes when passed as an object value: true or false
|
|
// `options.noDoubleEncoding` whether existing html entities are encoded:
|
|
// true or false
|
|
// `options.stringify` a set of functions to use for converting values to
|
|
// strings
|
|
// `options.writer` the default XML writer to use for converting nodes to
|
|
// string. If the default writer is not set, the built-in XMLStringWriter
|
|
// will be used instead.
|
|
|
|
// `onData` the function to be called when a new chunk of XML is output. The
|
|
// string containing the XML chunk is passed to `onData` as its single
|
|
// argument.
|
|
// `onEnd` the function to be called when the XML document is completed with
|
|
// `end`. `onEnd` does not receive any arguments.
|
|
module.exports.begin = function(options, onData, onEnd) {
|
|
if (isFunction(options)) {
|
|
[onData, onEnd] = [options, onData];
|
|
options = {};
|
|
}
|
|
if (onData) {
|
|
return new XMLDocumentCB(options, onData, onEnd);
|
|
} else {
|
|
return new XMLDocument(options);
|
|
}
|
|
};
|
|
|
|
module.exports.stringWriter = function(options) {
|
|
return new XMLStringWriter(options);
|
|
};
|
|
|
|
module.exports.streamWriter = function(stream, options) {
|
|
return new XMLStreamWriter(stream, options);
|
|
};
|
|
|
|
module.exports.implementation = new XMLDOMImplementation();
|
|
|
|
module.exports.nodeType = NodeType;
|
|
|
|
module.exports.writerState = WriterState;
|
|
|
|
}).call(this);
|
|
|
|
},{"./NodeType":5,"./Utility":6,"./WriterState":7,"./XMLDOMImplementation":14,"./XMLDocument":22,"./XMLDocumentCB":23,"./XMLStreamWriter":31,"./XMLStringWriter":32}]},{},[1])(1)
|
|
});
|