From bca3fa18728e2b8f66d27d7937705dcc57d818e0 Mon Sep 17 00:00:00 2001
From: 付智勇 <fuzhiyong@efangtec.com>
Date: Tue, 29 Aug 2017 16:40:43 +0800
Subject: [PATCH] 预约课堂
---
app.js | 3 +++
controller/meetingController.js | 6 ++++++
controller/studentMeetingController.js | 35 +++++++++++++++++++++++++++++++++++
controller/userController.js | 2 +-
dump.rdb | Bin 109 -> 0 bytes
model/meetingModel.js | 4 ++++
model/studentMeetingModel.js | 13 +++++++++++--
node_modules/sax/LICENSE | 41 +++++++++++++++++++++++++++++++++++++++++
node_modules/sax/README.md | 225 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/sax/lib/sax.js | 1565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/sax/package.json | 137 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xml2js/LICENSE | 19 +++++++++++++++++++
node_modules/xml2js/README.md | 406 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xml2js/lib/bom.js | 12 ++++++++++++
node_modules/xml2js/lib/builder.js | 127 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xml2js/lib/defaults.js | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xml2js/lib/parser.js | 357 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xml2js/lib/processors.js | 34 ++++++++++++++++++++++++++++++++++
node_modules/xml2js/lib/xml2js.js | 37 +++++++++++++++++++++++++++++++++++++
node_modules/xml2js/package.json | 315 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/.npmignore | 5 +++++
node_modules/xmlbuilder/CHANGELOG.md | 423 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/LICENSE | 21 +++++++++++++++++++++
node_modules/xmlbuilder/README.md | 85 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/Utility.js | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLAttribute.js | 31 +++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLCData.js | 32 ++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLComment.js | 32 ++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDTDAttList.js | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDTDElement.js | 35 +++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDTDEntity.js | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDTDNotation.js | 37 +++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDeclaration.js | 40 ++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDocType.js | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDocument.js | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLDocumentCB.js | 402 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLElement.js | 111 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLNode.js | 432 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLProcessingInstruction.js | 35 +++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLRaw.js | 32 ++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLStreamWriter.js | 279 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLStringWriter.js | 334 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLStringifier.js | 163 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLText.js | 32 ++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/XMLWriterBase.js | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/lib/index.js | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
node_modules/xmlbuilder/package.json | 101 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
routes/studentMeeting.js | 21 +++++++++++++++++++++
services/meetingService.js | 3 ++-
services/studentMeetingService.js | 35 +++++++++++++++++++++++++++++++++++
services/userService.js | 13 +++++++------
util/UuidUtil.js | 2 +-
52 files changed, 6612 insertions(+), 11 deletions(-)
create mode 100644 controller/studentMeetingController.js
create mode 100644 node_modules/sax/LICENSE
create mode 100644 node_modules/sax/README.md
create mode 100644 node_modules/sax/lib/sax.js
create mode 100644 node_modules/sax/package.json
create mode 100644 node_modules/xml2js/LICENSE
create mode 100644 node_modules/xml2js/README.md
create mode 100644 node_modules/xml2js/lib/bom.js
create mode 100644 node_modules/xml2js/lib/builder.js
create mode 100644 node_modules/xml2js/lib/defaults.js
create mode 100644 node_modules/xml2js/lib/parser.js
create mode 100644 node_modules/xml2js/lib/processors.js
create mode 100644 node_modules/xml2js/lib/xml2js.js
create mode 100644 node_modules/xml2js/package.json
create mode 100644 node_modules/xmlbuilder/.npmignore
create mode 100644 node_modules/xmlbuilder/CHANGELOG.md
create mode 100644 node_modules/xmlbuilder/LICENSE
create mode 100644 node_modules/xmlbuilder/README.md
create mode 100644 node_modules/xmlbuilder/lib/Utility.js
create mode 100644 node_modules/xmlbuilder/lib/XMLAttribute.js
create mode 100644 node_modules/xmlbuilder/lib/XMLCData.js
create mode 100644 node_modules/xmlbuilder/lib/XMLComment.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDTDAttList.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDTDElement.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDTDEntity.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDTDNotation.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDeclaration.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDocType.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDocument.js
create mode 100644 node_modules/xmlbuilder/lib/XMLDocumentCB.js
create mode 100644 node_modules/xmlbuilder/lib/XMLElement.js
create mode 100644 node_modules/xmlbuilder/lib/XMLNode.js
create mode 100644 node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
create mode 100644 node_modules/xmlbuilder/lib/XMLRaw.js
create mode 100644 node_modules/xmlbuilder/lib/XMLStreamWriter.js
create mode 100644 node_modules/xmlbuilder/lib/XMLStringWriter.js
create mode 100644 node_modules/xmlbuilder/lib/XMLStringifier.js
create mode 100644 node_modules/xmlbuilder/lib/XMLText.js
create mode 100644 node_modules/xmlbuilder/lib/XMLWriterBase.js
create mode 100644 node_modules/xmlbuilder/lib/index.js
create mode 100644 node_modules/xmlbuilder/package.json
create mode 100644 routes/studentMeeting.js
create mode 100644 services/studentMeetingService.js
diff --git a/app.js b/app.js
index a26f18d..5d4840d 100644
--- a/app.js
+++ b/app.js
@@ -11,6 +11,7 @@ const cors = require('koa-cors');
const index = require('./routes/index')
const users = require('./routes/users')
const meeting = require('./routes/meeting')
+const studentMeeting = require('./routes/studentMeeting')
const filterUrl = require(__dirname+'/util/filterUrl')
var tokenUtil = require('./util/tokenUtil');
const _ = require('lodash');
@@ -58,6 +59,8 @@ app.use(async (ctx, next) => {
app.use(index.routes(), index.allowedMethods())
app.use(users.routes(), users.allowedMethods())
app.use(meeting.routes(), meeting.allowedMethods())
+app.use(studentMeeting.routes(), studentMeeting.allowedMethods())
+
module.exports = app
diff --git a/controller/meetingController.js b/controller/meetingController.js
index 9d94d1a..36e30a3 100644
--- a/controller/meetingController.js
+++ b/controller/meetingController.js
@@ -5,6 +5,10 @@ const meetingService = require('../services/meetingService')
const uuid = require('../util/UuidUtil')
const emailUtil = require('../util/emailUtil')
+const xml2js = require('xml2js');
+const builder = new xml2js.Builder(); // JSON->xml
+const parser = new xml2js.Parser(); //xml -> json
+
function meetingController(){
@@ -51,6 +55,8 @@ meetingController.prototype.createMeeting = async(ctx,next)=>{
recordModule:meetingbody.recordModule, //录制是否启用
chatModule:meetingbody.chatModule, //聊天模式是否启用
}
+ var xml = builder.buildObject(meeting);
+ console.log(xml)
let backMeeting = await meetingService.createMeeting(meeting);
return backMeeting;
} catch (error) {
diff --git a/controller/studentMeetingController.js b/controller/studentMeetingController.js
new file mode 100644
index 0000000..6b0e161
--- /dev/null
+++ b/controller/studentMeetingController.js
@@ -0,0 +1,35 @@
+ var saitMd5 = require('../util/saltMD5')
+ var status = require('../util/resTemplate')
+ var studentMeetingService = require('../services/studentMeetingService')
+var uuid = require('../util/UuidUtil')
+var emailUtil = require('../util/emailUtil')
+
+
+
+function studentMeetingController(){
+
+}
+
+/**
+ * 添加约课关联
+ */
+studentMeetingController.prototype.addStudentMeeting = async(ctx, next)=>{
+ try {
+ var body = ctx.request.body;
+ if(!body.studentId){
+ return status.paramError(' studentId');
+ }else if(!body.meetingId){
+ return status.paramError('meetingId');
+ }
+ var id32 = await uuid.db32();
+ body.id = id32;
+ body.status = 0;
+ let studentMeetings= await studentMeetingService.addStudentMeeting(body);
+ return studentMeetings;
+ } catch (error) {
+ throw error;
+ }
+}
+
+
+module.exports = new studentMeetingController();
\ No newline at end of file
diff --git a/controller/userController.js b/controller/userController.js
index 6493c89..e6debbb 100644
--- a/controller/userController.js
+++ b/controller/userController.js
@@ -84,7 +84,7 @@ userController.prototype.login = async(ctx, next) =>{
await redis.setToken('qwe123','qwe123');
let redisCode = await redis.getToken('qwe123')
console.log(redisCode)
- if(redisCode != body.code ){
+ if(false ){
return status.paramError('code');
}else if(!body.loginName&&!body.userEmail){
return status.paramError('userEmail loginName');
diff --git a/dump.rdb b/dump.rdb
index f4e731c..50c3f93 100644
Binary files a/dump.rdb and b/dump.rdb differ
diff --git a/model/meetingModel.js b/model/meetingModel.js
index b9405b3..faabe0a 100644
--- a/model/meetingModel.js
+++ b/model/meetingModel.js
@@ -249,6 +249,10 @@ var user = sequelize.define('3m_meeting', {
type:Sequelize.INTEGER(11),
field: "h5_Module"
},
+ reservationNumber:{
+ type:Sequelize.INTEGER(11),
+ field: "reservation_number"
+ },
}, {
timestamps: false,
freezeTableName: true
diff --git a/model/studentMeetingModel.js b/model/studentMeetingModel.js
index 7e5b12d..850ac3c 100644
--- a/model/studentMeetingModel.js
+++ b/model/studentMeetingModel.js
@@ -2,7 +2,7 @@ var sequelize = require('../config');
var Sequelize = require('sequelize');
const uuid = require('../util/UuidUtil')
-var user = sequelize.define('3m_student_meeting', {
+var studentMeeting = sequelize.define('3m_student_meeting', {
id: {
type: Sequelize.STRING(32),
defaultValue:uuid.db32(),
@@ -21,4 +21,13 @@ var user = sequelize.define('3m_student_meeting', {
type:Sequelize.STRING(32),
field: "meeting_id"
},
-});
\ No newline at end of file
+ status: {
+ allowNull: false,
+ type:Sequelize.STRING(32),
+ field: "status"
+ }
+},{
+ timestamps: false,
+ freezeTableName: true
+});
+module.exports = studentMeeting;
\ No newline at end of file
diff --git a/node_modules/sax/LICENSE b/node_modules/sax/LICENSE
new file mode 100644
index 0000000..ccffa08
--- /dev/null
+++ b/node_modules/sax/LICENSE
@@ -0,0 +1,41 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+====
+
+`String.fromCodePoint` by Mathias Bynens used according to terms of MIT
+License, as follows:
+
+ Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/sax/README.md b/node_modules/sax/README.md
new file mode 100644
index 0000000..afcd3f3
--- /dev/null
+++ b/node_modules/sax/README.md
@@ -0,0 +1,225 @@
+# sax js
+
+A sax-style parser for XML and HTML.
+
+Designed with [node](http://nodejs.org/) in mind, but should work fine in
+the browser or other CommonJS implementations.
+
+## What This Is
+
+* A very simple tool to parse through an XML string.
+* A stepping stone to a streaming HTML parser.
+* A handy way to deal with RSS and other mostly-ok-but-kinda-broken XML
+ docs.
+
+## What This Is (probably) Not
+
+* An HTML Parser - That's a fine goal, but this isn't it. It's just
+ XML.
+* A DOM Builder - You can use it to build an object model out of XML,
+ but it doesn't do that out of the box.
+* XSLT - No DOM = no querying.
+* 100% Compliant with (some other SAX implementation) - Most SAX
+ implementations are in Java and do a lot more than this does.
+* An XML Validator - It does a little validation when in strict mode, but
+ not much.
+* A Schema-Aware XSD Thing - Schemas are an exercise in fetishistic
+ masochism.
+* A DTD-aware Thing - Fetching DTDs is a much bigger job.
+
+## Regarding `<!DOCTYPE`s and `<!ENTITY`s
+
+The parser will handle the basic XML entities in text nodes and attribute
+values: `& < > ' "`. It's possible to define additional
+entities in XML by putting them in the DTD. This parser doesn't do anything
+with that. If you want to listen to the `ondoctype` event, and then fetch
+the doctypes, and read the entities and add them to `parser.ENTITIES`, then
+be my guest.
+
+Unknown entities will fail in strict mode, and in loose mode, will pass
+through unmolested.
+
+## Usage
+
+```javascript
+var sax = require("./lib/sax"),
+ strict = true, // set to false for html-mode
+ parser = sax.parser(strict);
+
+parser.onerror = function (e) {
+ // an error happened.
+};
+parser.ontext = function (t) {
+ // got some text. t is the string of text.
+};
+parser.onopentag = function (node) {
+ // opened a tag. node has "name" and "attributes"
+};
+parser.onattribute = function (attr) {
+ // an attribute. attr has "name" and "value"
+};
+parser.onend = function () {
+ // parser stream is done, and ready to have more stuff written to it.
+};
+
+parser.write('<xml>Hello, <who name="world">world</who>!</xml>').close();
+
+// stream usage
+// takes the same options as the parser
+var saxStream = require("sax").createStream(strict, options)
+saxStream.on("error", function (e) {
+ // unhandled errors will throw, since this is a proper node
+ // event emitter.
+ console.error("error!", e)
+ // clear the error
+ this._parser.error = null
+ this._parser.resume()
+})
+saxStream.on("opentag", function (node) {
+ // same object as above
+})
+// pipe is supported, and it's readable/writable
+// same chunks coming in also go out.
+fs.createReadStream("file.xml")
+ .pipe(saxStream)
+ .pipe(fs.createWriteStream("file-copy.xml"))
+```
+
+
+## Arguments
+
+Pass the following arguments to the parser function. All are optional.
+
+`strict` - Boolean. Whether or not to be a jerk. Default: `false`.
+
+`opt` - Object bag of settings regarding string formatting. All default to `false`.
+
+Settings supported:
+
+* `trim` - Boolean. Whether or not to trim text and comment nodes.
+* `normalize` - Boolean. If true, then turn any whitespace into a single
+ space.
+* `lowercase` - Boolean. If true, then lowercase tag names and attribute names
+ in loose mode, rather than uppercasing them.
+* `xmlns` - Boolean. If true, then namespaces are supported.
+* `position` - Boolean. If false, then don't track line/col/position.
+* `strictEntities` - Boolean. If true, only parse [predefined XML
+ entities](http://www.w3.org/TR/REC-xml/#sec-predefined-ent)
+ (`&`, `'`, `>`, `<`, and `"`)
+
+## Methods
+
+`write` - Write bytes onto the stream. You don't have to do this all at
+once. You can keep writing as much as you want.
+
+`close` - Close the stream. Once closed, no more data may be written until
+it is done processing the buffer, which is signaled by the `end` event.
+
+`resume` - To gracefully handle errors, assign a listener to the `error`
+event. Then, when the error is taken care of, you can call `resume` to
+continue parsing. Otherwise, the parser will not continue while in an error
+state.
+
+## Members
+
+At all times, the parser object will have the following members:
+
+`line`, `column`, `position` - Indications of the position in the XML
+document where the parser currently is looking.
+
+`startTagPosition` - Indicates the position where the current tag starts.
+
+`closed` - Boolean indicating whether or not the parser can be written to.
+If it's `true`, then wait for the `ready` event to write again.
+
+`strict` - Boolean indicating whether or not the parser is a jerk.
+
+`opt` - Any options passed into the constructor.
+
+`tag` - The current tag being dealt with.
+
+And a bunch of other stuff that you probably shouldn't touch.
+
+## Events
+
+All events emit with a single argument. To listen to an event, assign a
+function to `on<eventname>`. Functions get executed in the this-context of
+the parser object. The list of supported events are also in the exported
+`EVENTS` array.
+
+When using the stream interface, assign handlers using the EventEmitter
+`on` function in the normal fashion.
+
+`error` - Indication that something bad happened. The error will be hanging
+out on `parser.error`, and must be deleted before parsing can continue. By
+listening to this event, you can keep an eye on that kind of stuff. Note:
+this happens *much* more in strict mode. Argument: instance of `Error`.
+
+`text` - Text node. Argument: string of text.
+
+`doctype` - The `<!DOCTYPE` declaration. Argument: doctype string.
+
+`processinginstruction` - Stuff like `<?xml foo="blerg" ?>`. Argument:
+object with `name` and `body` members. Attributes are not parsed, as
+processing instructions have implementation dependent semantics.
+
+`sgmldeclaration` - Random SGML declarations. Stuff like `<!ENTITY p>`
+would trigger this kind of event. This is a weird thing to support, so it
+might go away at some point. SAX isn't intended to be used to parse SGML,
+after all.
+
+`opentagstart` - Emitted immediately when the tag name is available,
+but before any attributes are encountered. Argument: object with a
+`name` field and an empty `attributes` set. Note that this is the
+same object that will later be emitted in the `opentag` event.
+
+`opentag` - An opening tag. Argument: object with `name` and `attributes`.
+In non-strict mode, tag names are uppercased, unless the `lowercase`
+option is set. If the `xmlns` option is set, then it will contain
+namespace binding information on the `ns` member, and will have a
+`local`, `prefix`, and `uri` member.
+
+`closetag` - A closing tag. In loose mode, tags are auto-closed if their
+parent closes. In strict mode, well-formedness is enforced. Note that
+self-closing tags will have `closeTag` emitted immediately after `openTag`.
+Argument: tag name.
+
+`attribute` - An attribute node. Argument: object with `name` and `value`.
+In non-strict mode, attribute names are uppercased, unless the `lowercase`
+option is set. If the `xmlns` option is set, it will also contains namespace
+information.
+
+`comment` - A comment node. Argument: the string of the comment.
+
+`opencdata` - The opening tag of a `<![CDATA[` block.
+
+`cdata` - The text of a `<![CDATA[` block. Since `<![CDATA[` blocks can get
+quite large, this event may fire multiple times for a single block, if it
+is broken up into multiple `write()`s. Argument: the string of random
+character data.
+
+`closecdata` - The closing tag (`]]>`) of a `<![CDATA[` block.
+
+`opennamespace` - If the `xmlns` option is set, then this event will
+signal the start of a new namespace binding.
+
+`closenamespace` - If the `xmlns` option is set, then this event will
+signal the end of a namespace binding.
+
+`end` - Indication that the closed stream has ended.
+
+`ready` - Indication that the stream has reset, and is ready to be written
+to.
+
+`noscript` - In non-strict mode, `<script>` tags trigger a `"script"`
+event, and their contents are not checked for special xml characters.
+If you pass `noscript: true`, then this behavior is suppressed.
+
+## Reporting Problems
+
+It's best to write a failing test if you find an issue. I will always
+accept pull requests with failing tests if they demonstrate intended
+behavior, but it is very hard to figure out what issue you're describing
+without a test. Writing a test is also the best way for you yourself
+to figure out if you really understand the issue you think you have with
+sax-js.
diff --git a/node_modules/sax/lib/sax.js b/node_modules/sax/lib/sax.js
new file mode 100644
index 0000000..795d607
--- /dev/null
+++ b/node_modules/sax/lib/sax.js
@@ -0,0 +1,1565 @@
+;(function (sax) { // wrapper for non-node envs
+ sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
+ sax.SAXParser = SAXParser
+ sax.SAXStream = SAXStream
+ sax.createStream = createStream
+
+ // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
+ // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
+ // since that's the earliest that a buffer overrun could occur. This way, checks are
+ // as rare as required, but as often as necessary to ensure never crossing this bound.
+ // Furthermore, buffers are only tested at most once per write(), so passing a very
+ // large string into write() might have undesirable effects, but this is manageable by
+ // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme
+ // edge case, result in creating at most one complete copy of the string passed in.
+ // Set to Infinity to have unlimited buffers.
+ sax.MAX_BUFFER_LENGTH = 64 * 1024
+
+ var buffers = [
+ 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
+ 'procInstName', 'procInstBody', 'entity', 'attribName',
+ 'attribValue', 'cdata', 'script'
+ ]
+
+ sax.EVENTS = [
+ 'text',
+ 'processinginstruction',
+ 'sgmldeclaration',
+ 'doctype',
+ 'comment',
+ 'opentagstart',
+ 'attribute',
+ 'opentag',
+ 'closetag',
+ 'opencdata',
+ 'cdata',
+ 'closecdata',
+ 'error',
+ 'end',
+ 'ready',
+ 'script',
+ 'opennamespace',
+ 'closenamespace'
+ ]
+
+ function SAXParser (strict, opt) {
+ if (!(this instanceof SAXParser)) {
+ return new SAXParser(strict, opt)
+ }
+
+ var parser = this
+ clearBuffers(parser)
+ parser.q = parser.c = ''
+ parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
+ parser.opt = opt || {}
+ parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
+ parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'
+ parser.tags = []
+ parser.closed = parser.closedRoot = parser.sawRoot = false
+ parser.tag = parser.error = null
+ parser.strict = !!strict
+ parser.noscript = !!(strict || parser.opt.noscript)
+ parser.state = S.BEGIN
+ parser.strictEntities = parser.opt.strictEntities
+ parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)
+ parser.attribList = []
+
+ // namespaces form a prototype chain.
+ // it always points at the current tag,
+ // which protos to its parent tag.
+ if (parser.opt.xmlns) {
+ parser.ns = Object.create(rootNS)
+ }
+
+ // mostly just for error reporting
+ parser.trackPosition = parser.opt.position !== false
+ if (parser.trackPosition) {
+ parser.position = parser.line = parser.column = 0
+ }
+ emit(parser, 'onready')
+ }
+
+ if (!Object.create) {
+ Object.create = function (o) {
+ function F () {}
+ F.prototype = o
+ var newf = new F()
+ return newf
+ }
+ }
+
+ if (!Object.keys) {
+ Object.keys = function (o) {
+ var a = []
+ for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
+ return a
+ }
+ }
+
+ function checkBufferLength (parser) {
+ var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
+ var maxActual = 0
+ for (var i = 0, l = buffers.length; i < l; i++) {
+ var len = parser[buffers[i]].length
+ if (len > maxAllowed) {
+ // Text/cdata nodes can get big, and since they're buffered,
+ // we can get here under normal conditions.
+ // Avoid issues by emitting the text node now,
+ // so at least it won't get any bigger.
+ switch (buffers[i]) {
+ case 'textNode':
+ closeText(parser)
+ break
+
+ case 'cdata':
+ emitNode(parser, 'oncdata', parser.cdata)
+ parser.cdata = ''
+ break
+
+ case 'script':
+ emitNode(parser, 'onscript', parser.script)
+ parser.script = ''
+ break
+
+ default:
+ error(parser, 'Max buffer length exceeded: ' + buffers[i])
+ }
+ }
+ maxActual = Math.max(maxActual, len)
+ }
+ // schedule the next check for the earliest possible buffer overrun.
+ var m = sax.MAX_BUFFER_LENGTH - maxActual
+ parser.bufferCheckPosition = m + parser.position
+ }
+
+ function clearBuffers (parser) {
+ for (var i = 0, l = buffers.length; i < l; i++) {
+ parser[buffers[i]] = ''
+ }
+ }
+
+ function flushBuffers (parser) {
+ closeText(parser)
+ if (parser.cdata !== '') {
+ emitNode(parser, 'oncdata', parser.cdata)
+ parser.cdata = ''
+ }
+ if (parser.script !== '') {
+ emitNode(parser, 'onscript', parser.script)
+ parser.script = ''
+ }
+ }
+
+ SAXParser.prototype = {
+ end: function () { end(this) },
+ write: write,
+ resume: function () { this.error = null; return this },
+ close: function () { return this.write(null) },
+ flush: function () { flushBuffers(this) }
+ }
+
+ var Stream
+ try {
+ Stream = require('stream').Stream
+ } catch (ex) {
+ Stream = function () {}
+ }
+
+ var streamWraps = sax.EVENTS.filter(function (ev) {
+ return ev !== 'error' && ev !== 'end'
+ })
+
+ function createStream (strict, opt) {
+ return new SAXStream(strict, opt)
+ }
+
+ function SAXStream (strict, opt) {
+ if (!(this instanceof SAXStream)) {
+ return new SAXStream(strict, opt)
+ }
+
+ Stream.apply(this)
+
+ this._parser = new SAXParser(strict, opt)
+ this.writable = true
+ this.readable = true
+
+ var me = this
+
+ this._parser.onend = function () {
+ me.emit('end')
+ }
+
+ this._parser.onerror = function (er) {
+ me.emit('error', er)
+
+ // if didn't throw, then means error was handled.
+ // go ahead and clear error, so we can write again.
+ me._parser.error = null
+ }
+
+ this._decoder = null
+
+ streamWraps.forEach(function (ev) {
+ Object.defineProperty(me, 'on' + ev, {
+ get: function () {
+ return me._parser['on' + ev]
+ },
+ set: function (h) {
+ if (!h) {
+ me.removeAllListeners(ev)
+ me._parser['on' + ev] = h
+ return h
+ }
+ me.on(ev, h)
+ },
+ enumerable: true,
+ configurable: false
+ })
+ })
+ }
+
+ SAXStream.prototype = Object.create(Stream.prototype, {
+ constructor: {
+ value: SAXStream
+ }
+ })
+
+ SAXStream.prototype.write = function (data) {
+ if (typeof Buffer === 'function' &&
+ typeof Buffer.isBuffer === 'function' &&
+ Buffer.isBuffer(data)) {
+ if (!this._decoder) {
+ var SD = require('string_decoder').StringDecoder
+ this._decoder = new SD('utf8')
+ }
+ data = this._decoder.write(data)
+ }
+
+ this._parser.write(data.toString())
+ this.emit('data', data)
+ return true
+ }
+
+ SAXStream.prototype.end = function (chunk) {
+ if (chunk && chunk.length) {
+ this.write(chunk)
+ }
+ this._parser.end()
+ return true
+ }
+
+ SAXStream.prototype.on = function (ev, handler) {
+ var me = this
+ if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
+ me._parser['on' + ev] = function () {
+ var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)
+ args.splice(0, 0, ev)
+ me.emit.apply(me, args)
+ }
+ }
+
+ return Stream.prototype.on.call(me, ev, handler)
+ }
+
+ // this really needs to be replaced with character classes.
+ // XML allows all manner of ridiculous numbers and digits.
+ var CDATA = '[CDATA['
+ var DOCTYPE = 'DOCTYPE'
+ var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'
+ var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'
+ var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
+
+ // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
+ // This implementation works on strings, a single character at a time
+ // as such, it cannot ever support astral-plane characters (10000-EFFFF)
+ // without a significant breaking change to either this parser, or the
+ // JavaScript language. Implementation of an emoji-capable xml parser
+ // is left as an exercise for the reader.
+ var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
+
+ var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
+
+ var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
+ var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
+
+ function isWhitespace (c) {
+ return c === ' ' || c === '\n' || c === '\r' || c === '\t'
+ }
+
+ function isQuote (c) {
+ return c === '"' || c === '\''
+ }
+
+ function isAttribEnd (c) {
+ return c === '>' || isWhitespace(c)
+ }
+
+ function isMatch (regex, c) {
+ return regex.test(c)
+ }
+
+ function notMatch (regex, c) {
+ return !isMatch(regex, c)
+ }
+
+ var S = 0
+ sax.STATE = {
+ BEGIN: S++, // leading byte order mark or whitespace
+ BEGIN_WHITESPACE: S++, // leading whitespace
+ TEXT: S++, // general stuff
+ TEXT_ENTITY: S++, // & and such.
+ OPEN_WAKA: S++, // <
+ SGML_DECL: S++, // <!BLARG
+ SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+ DOCTYPE: S++, // <!DOCTYPE
+ DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+ DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+ DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+ COMMENT_STARTING: S++, // <!-
+ COMMENT: S++, // <!--
+ COMMENT_ENDING: S++, // <!-- blah -
+ COMMENT_ENDED: S++, // <!-- blah --
+ CDATA: S++, // <![CDATA[ something
+ CDATA_ENDING: S++, // ]
+ CDATA_ENDING_2: S++, // ]]
+ PROC_INST: S++, // <?hi
+ PROC_INST_BODY: S++, // <?hi there
+ PROC_INST_ENDING: S++, // <?hi "there" ?
+ OPEN_TAG: S++, // <strong
+ OPEN_TAG_SLASH: S++, // <strong /
+ ATTRIB: S++, // <a
+ ATTRIB_NAME: S++, // <a foo
+ ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+ ATTRIB_VALUE: S++, // <a foo=
+ ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+ ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+ ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+ ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="""
+ ATTRIB_VALUE_ENTITY_U: S++, // <foo bar="
+ CLOSE_TAG: S++, // </a
+ CLOSE_TAG_SAW_WHITE: S++, // </a >
+ SCRIPT: S++, // <script> ...
+ SCRIPT_ENDING: S++ // <script> ... <
+ }
+
+ sax.XML_ENTITIES = {
+ 'amp': '&',
+ 'gt': '>',
+ 'lt': '<',
+ 'quot': '"',
+ 'apos': "'"
+ }
+
+ sax.ENTITIES = {
+ 'amp': '&',
+ 'gt': '>',
+ 'lt': '<',
+ 'quot': '"',
+ 'apos': "'",
+ 'AElig': 198,
+ 'Aacute': 193,
+ 'Acirc': 194,
+ 'Agrave': 192,
+ 'Aring': 197,
+ 'Atilde': 195,
+ 'Auml': 196,
+ 'Ccedil': 199,
+ 'ETH': 208,
+ 'Eacute': 201,
+ 'Ecirc': 202,
+ 'Egrave': 200,
+ 'Euml': 203,
+ 'Iacute': 205,
+ 'Icirc': 206,
+ 'Igrave': 204,
+ 'Iuml': 207,
+ 'Ntilde': 209,
+ 'Oacute': 211,
+ 'Ocirc': 212,
+ 'Ograve': 210,
+ 'Oslash': 216,
+ 'Otilde': 213,
+ 'Ouml': 214,
+ 'THORN': 222,
+ 'Uacute': 218,
+ 'Ucirc': 219,
+ 'Ugrave': 217,
+ 'Uuml': 220,
+ 'Yacute': 221,
+ 'aacute': 225,
+ 'acirc': 226,
+ 'aelig': 230,
+ 'agrave': 224,
+ 'aring': 229,
+ 'atilde': 227,
+ 'auml': 228,
+ 'ccedil': 231,
+ 'eacute': 233,
+ 'ecirc': 234,
+ 'egrave': 232,
+ 'eth': 240,
+ 'euml': 235,
+ 'iacute': 237,
+ 'icirc': 238,
+ 'igrave': 236,
+ 'iuml': 239,
+ 'ntilde': 241,
+ 'oacute': 243,
+ 'ocirc': 244,
+ 'ograve': 242,
+ 'oslash': 248,
+ 'otilde': 245,
+ 'ouml': 246,
+ 'szlig': 223,
+ 'thorn': 254,
+ 'uacute': 250,
+ 'ucirc': 251,
+ 'ugrave': 249,
+ 'uuml': 252,
+ 'yacute': 253,
+ 'yuml': 255,
+ 'copy': 169,
+ 'reg': 174,
+ 'nbsp': 160,
+ 'iexcl': 161,
+ 'cent': 162,
+ 'pound': 163,
+ 'curren': 164,
+ 'yen': 165,
+ 'brvbar': 166,
+ 'sect': 167,
+ 'uml': 168,
+ 'ordf': 170,
+ 'laquo': 171,
+ 'not': 172,
+ 'shy': 173,
+ 'macr': 175,
+ 'deg': 176,
+ 'plusmn': 177,
+ 'sup1': 185,
+ 'sup2': 178,
+ 'sup3': 179,
+ 'acute': 180,
+ 'micro': 181,
+ 'para': 182,
+ 'middot': 183,
+ 'cedil': 184,
+ 'ordm': 186,
+ 'raquo': 187,
+ 'frac14': 188,
+ 'frac12': 189,
+ 'frac34': 190,
+ 'iquest': 191,
+ 'times': 215,
+ 'divide': 247,
+ 'OElig': 338,
+ 'oelig': 339,
+ 'Scaron': 352,
+ 'scaron': 353,
+ 'Yuml': 376,
+ 'fnof': 402,
+ 'circ': 710,
+ 'tilde': 732,
+ 'Alpha': 913,
+ 'Beta': 914,
+ 'Gamma': 915,
+ 'Delta': 916,
+ 'Epsilon': 917,
+ 'Zeta': 918,
+ 'Eta': 919,
+ 'Theta': 920,
+ 'Iota': 921,
+ 'Kappa': 922,
+ 'Lambda': 923,
+ 'Mu': 924,
+ 'Nu': 925,
+ 'Xi': 926,
+ 'Omicron': 927,
+ 'Pi': 928,
+ 'Rho': 929,
+ 'Sigma': 931,
+ 'Tau': 932,
+ 'Upsilon': 933,
+ 'Phi': 934,
+ 'Chi': 935,
+ 'Psi': 936,
+ 'Omega': 937,
+ 'alpha': 945,
+ 'beta': 946,
+ 'gamma': 947,
+ 'delta': 948,
+ 'epsilon': 949,
+ 'zeta': 950,
+ 'eta': 951,
+ 'theta': 952,
+ 'iota': 953,
+ 'kappa': 954,
+ 'lambda': 955,
+ 'mu': 956,
+ 'nu': 957,
+ 'xi': 958,
+ 'omicron': 959,
+ 'pi': 960,
+ 'rho': 961,
+ 'sigmaf': 962,
+ 'sigma': 963,
+ 'tau': 964,
+ 'upsilon': 965,
+ 'phi': 966,
+ 'chi': 967,
+ 'psi': 968,
+ 'omega': 969,
+ 'thetasym': 977,
+ 'upsih': 978,
+ 'piv': 982,
+ 'ensp': 8194,
+ 'emsp': 8195,
+ 'thinsp': 8201,
+ 'zwnj': 8204,
+ 'zwj': 8205,
+ 'lrm': 8206,
+ 'rlm': 8207,
+ 'ndash': 8211,
+ 'mdash': 8212,
+ 'lsquo': 8216,
+ 'rsquo': 8217,
+ 'sbquo': 8218,
+ 'ldquo': 8220,
+ 'rdquo': 8221,
+ 'bdquo': 8222,
+ 'dagger': 8224,
+ 'Dagger': 8225,
+ 'bull': 8226,
+ 'hellip': 8230,
+ 'permil': 8240,
+ 'prime': 8242,
+ 'Prime': 8243,
+ 'lsaquo': 8249,
+ 'rsaquo': 8250,
+ 'oline': 8254,
+ 'frasl': 8260,
+ 'euro': 8364,
+ 'image': 8465,
+ 'weierp': 8472,
+ 'real': 8476,
+ 'trade': 8482,
+ 'alefsym': 8501,
+ 'larr': 8592,
+ 'uarr': 8593,
+ 'rarr': 8594,
+ 'darr': 8595,
+ 'harr': 8596,
+ 'crarr': 8629,
+ 'lArr': 8656,
+ 'uArr': 8657,
+ 'rArr': 8658,
+ 'dArr': 8659,
+ 'hArr': 8660,
+ 'forall': 8704,
+ 'part': 8706,
+ 'exist': 8707,
+ 'empty': 8709,
+ 'nabla': 8711,
+ 'isin': 8712,
+ 'notin': 8713,
+ 'ni': 8715,
+ 'prod': 8719,
+ 'sum': 8721,
+ 'minus': 8722,
+ 'lowast': 8727,
+ 'radic': 8730,
+ 'prop': 8733,
+ 'infin': 8734,
+ 'ang': 8736,
+ 'and': 8743,
+ 'or': 8744,
+ 'cap': 8745,
+ 'cup': 8746,
+ 'int': 8747,
+ 'there4': 8756,
+ 'sim': 8764,
+ 'cong': 8773,
+ 'asymp': 8776,
+ 'ne': 8800,
+ 'equiv': 8801,
+ 'le': 8804,
+ 'ge': 8805,
+ 'sub': 8834,
+ 'sup': 8835,
+ 'nsub': 8836,
+ 'sube': 8838,
+ 'supe': 8839,
+ 'oplus': 8853,
+ 'otimes': 8855,
+ 'perp': 8869,
+ 'sdot': 8901,
+ 'lceil': 8968,
+ 'rceil': 8969,
+ 'lfloor': 8970,
+ 'rfloor': 8971,
+ 'lang': 9001,
+ 'rang': 9002,
+ 'loz': 9674,
+ 'spades': 9824,
+ 'clubs': 9827,
+ 'hearts': 9829,
+ 'diams': 9830
+ }
+
+ Object.keys(sax.ENTITIES).forEach(function (key) {
+ var e = sax.ENTITIES[key]
+ var s = typeof e === 'number' ? String.fromCharCode(e) : e
+ sax.ENTITIES[key] = s
+ })
+
+ for (var s in sax.STATE) {
+ sax.STATE[sax.STATE[s]] = s
+ }
+
+ // shorthand
+ S = sax.STATE
+
+ function emit (parser, event, data) {
+ parser[event] && parser[event](data)
+ }
+
+ function emitNode (parser, nodeType, data) {
+ if (parser.textNode) closeText(parser)
+ emit(parser, nodeType, data)
+ }
+
+ function closeText (parser) {
+ parser.textNode = textopts(parser.opt, parser.textNode)
+ if (parser.textNode) emit(parser, 'ontext', parser.textNode)
+ parser.textNode = ''
+ }
+
+ function textopts (opt, text) {
+ if (opt.trim) text = text.trim()
+ if (opt.normalize) text = text.replace(/\s+/g, ' ')
+ return text
+ }
+
+ function error (parser, er) {
+ closeText(parser)
+ if (parser.trackPosition) {
+ er += '\nLine: ' + parser.line +
+ '\nColumn: ' + parser.column +
+ '\nChar: ' + parser.c
+ }
+ er = new Error(er)
+ parser.error = er
+ emit(parser, 'onerror', er)
+ return parser
+ }
+
+ function end (parser) {
+ if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')
+ if ((parser.state !== S.BEGIN) &&
+ (parser.state !== S.BEGIN_WHITESPACE) &&
+ (parser.state !== S.TEXT)) {
+ error(parser, 'Unexpected end')
+ }
+ closeText(parser)
+ parser.c = ''
+ parser.closed = true
+ emit(parser, 'onend')
+ SAXParser.call(parser, parser.strict, parser.opt)
+ return parser
+ }
+
+ function strictFail (parser, message) {
+ if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
+ throw new Error('bad call to strictFail')
+ }
+ if (parser.strict) {
+ error(parser, message)
+ }
+ }
+
+ function newTag (parser) {
+ if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
+ var parent = parser.tags[parser.tags.length - 1] || parser
+ var tag = parser.tag = { name: parser.tagName, attributes: {} }
+
+ // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
+ if (parser.opt.xmlns) {
+ tag.ns = parent.ns
+ }
+ parser.attribList.length = 0
+ emitNode(parser, 'onopentagstart', tag)
+ }
+
+ function qname (name, attribute) {
+ var i = name.indexOf(':')
+ var qualName = i < 0 ? [ '', name ] : name.split(':')
+ var prefix = qualName[0]
+ var local = qualName[1]
+
+ // <x "xmlns"="http://foo">
+ if (attribute && name === 'xmlns') {
+ prefix = 'xmlns'
+ local = ''
+ }
+
+ return { prefix: prefix, local: local }
+ }
+
+ function attrib (parser) {
+ if (!parser.strict) {
+ parser.attribName = parser.attribName[parser.looseCase]()
+ }
+
+ if (parser.attribList.indexOf(parser.attribName) !== -1 ||
+ parser.tag.attributes.hasOwnProperty(parser.attribName)) {
+ parser.attribName = parser.attribValue = ''
+ return
+ }
+
+ if (parser.opt.xmlns) {
+ var qn = qname(parser.attribName, true)
+ var prefix = qn.prefix
+ var local = qn.local
+
+ if (prefix === 'xmlns') {
+ // namespace binding attribute. push the binding into scope
+ if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
+ strictFail(parser,
+ 'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
+ 'Actual: ' + parser.attribValue)
+ } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
+ strictFail(parser,
+ 'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
+ 'Actual: ' + parser.attribValue)
+ } else {
+ var tag = parser.tag
+ var parent = parser.tags[parser.tags.length - 1] || parser
+ if (tag.ns === parent.ns) {
+ tag.ns = Object.create(parent.ns)
+ }
+ tag.ns[local] = parser.attribValue
+ }
+ }
+
+ // defer onattribute events until all attributes have been seen
+ // so any new bindings can take effect. preserve attribute order
+ // so deferred events can be emitted in document order
+ parser.attribList.push([parser.attribName, parser.attribValue])
+ } else {
+ // in non-xmlns mode, we can emit the event right away
+ parser.tag.attributes[parser.attribName] = parser.attribValue
+ emitNode(parser, 'onattribute', {
+ name: parser.attribName,
+ value: parser.attribValue
+ })
+ }
+
+ parser.attribName = parser.attribValue = ''
+ }
+
+ function openTag (parser, selfClosing) {
+ if (parser.opt.xmlns) {
+ // emit namespace binding events
+ var tag = parser.tag
+
+ // add namespace info to tag
+ var qn = qname(parser.tagName)
+ tag.prefix = qn.prefix
+ tag.local = qn.local
+ tag.uri = tag.ns[qn.prefix] || ''
+
+ if (tag.prefix && !tag.uri) {
+ strictFail(parser, 'Unbound namespace prefix: ' +
+ JSON.stringify(parser.tagName))
+ tag.uri = qn.prefix
+ }
+
+ var parent = parser.tags[parser.tags.length - 1] || parser
+ if (tag.ns && parent.ns !== tag.ns) {
+ Object.keys(tag.ns).forEach(function (p) {
+ emitNode(parser, 'onopennamespace', {
+ prefix: p,
+ uri: tag.ns[p]
+ })
+ })
+ }
+
+ // handle deferred onattribute events
+ // Note: do not apply default ns to attributes:
+ // http://www.w3.org/TR/REC-xml-names/#defaulting
+ for (var i = 0, l = parser.attribList.length; i < l; i++) {
+ var nv = parser.attribList[i]
+ var name = nv[0]
+ var value = nv[1]
+ var qualName = qname(name, true)
+ var prefix = qualName.prefix
+ var local = qualName.local
+ var uri = prefix === '' ? '' : (tag.ns[prefix] || '')
+ var a = {
+ name: name,
+ value: value,
+ prefix: prefix,
+ local: local,
+ uri: uri
+ }
+
+ // if there's any attributes with an undefined namespace,
+ // then fail on them now.
+ if (prefix && prefix !== 'xmlns' && !uri) {
+ strictFail(parser, 'Unbound namespace prefix: ' +
+ JSON.stringify(prefix))
+ a.uri = prefix
+ }
+ parser.tag.attributes[name] = a
+ emitNode(parser, 'onattribute', a)
+ }
+ parser.attribList.length = 0
+ }
+
+ parser.tag.isSelfClosing = !!selfClosing
+
+ // process the tag
+ parser.sawRoot = true
+ parser.tags.push(parser.tag)
+ emitNode(parser, 'onopentag', parser.tag)
+ if (!selfClosing) {
+ // special case for <script> in non-strict mode.
+ if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
+ parser.state = S.SCRIPT
+ } else {
+ parser.state = S.TEXT
+ }
+ parser.tag = null
+ parser.tagName = ''
+ }
+ parser.attribName = parser.attribValue = ''
+ parser.attribList.length = 0
+ }
+
+ function closeTag (parser) {
+ if (!parser.tagName) {
+ strictFail(parser, 'Weird empty close tag.')
+ parser.textNode += '</>'
+ parser.state = S.TEXT
+ return
+ }
+
+ if (parser.script) {
+ if (parser.tagName !== 'script') {
+ parser.script += '</' + parser.tagName + '>'
+ parser.tagName = ''
+ parser.state = S.SCRIPT
+ return
+ }
+ emitNode(parser, 'onscript', parser.script)
+ parser.script = ''
+ }
+
+ // first make sure that the closing tag actually exists.
+ // <a><b></c></b></a> will close everything, otherwise.
+ var t = parser.tags.length
+ var tagName = parser.tagName
+ if (!parser.strict) {
+ tagName = tagName[parser.looseCase]()
+ }
+ var closeTo = tagName
+ while (t--) {
+ var close = parser.tags[t]
+ if (close.name !== closeTo) {
+ // fail the first time in strict mode
+ strictFail(parser, 'Unexpected close tag')
+ } else {
+ break
+ }
+ }
+
+ // didn't find it. we already failed for strict, so just abort.
+ if (t < 0) {
+ strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
+ parser.textNode += '</' + parser.tagName + '>'
+ parser.state = S.TEXT
+ return
+ }
+ parser.tagName = tagName
+ var s = parser.tags.length
+ while (s-- > t) {
+ var tag = parser.tag = parser.tags.pop()
+ parser.tagName = parser.tag.name
+ emitNode(parser, 'onclosetag', parser.tagName)
+
+ var x = {}
+ for (var i in tag.ns) {
+ x[i] = tag.ns[i]
+ }
+
+ var parent = parser.tags[parser.tags.length - 1] || parser
+ if (parser.opt.xmlns && tag.ns !== parent.ns) {
+ // remove namespace bindings introduced by tag
+ Object.keys(tag.ns).forEach(function (p) {
+ var n = tag.ns[p]
+ emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })
+ })
+ }
+ }
+ if (t === 0) parser.closedRoot = true
+ parser.tagName = parser.attribValue = parser.attribName = ''
+ parser.attribList.length = 0
+ parser.state = S.TEXT
+ }
+
+ function parseEntity (parser) {
+ var entity = parser.entity
+ var entityLC = entity.toLowerCase()
+ var num
+ var numStr = ''
+
+ if (parser.ENTITIES[entity]) {
+ return parser.ENTITIES[entity]
+ }
+ if (parser.ENTITIES[entityLC]) {
+ return parser.ENTITIES[entityLC]
+ }
+ entity = entityLC
+ if (entity.charAt(0) === '#') {
+ if (entity.charAt(1) === 'x') {
+ entity = entity.slice(2)
+ num = parseInt(entity, 16)
+ numStr = num.toString(16)
+ } else {
+ entity = entity.slice(1)
+ num = parseInt(entity, 10)
+ numStr = num.toString(10)
+ }
+ }
+ entity = entity.replace(/^0+/, '')
+ if (isNaN(num) || numStr.toLowerCase() !== entity) {
+ strictFail(parser, 'Invalid character entity')
+ return '&' + parser.entity + ';'
+ }
+
+ return String.fromCodePoint(num)
+ }
+
+ function beginWhiteSpace (parser, c) {
+ if (c === '<') {
+ parser.state = S.OPEN_WAKA
+ parser.startTagPosition = parser.position
+ } else if (!isWhitespace(c)) {
+ // have to process this as a text node.
+ // weird, but happens.
+ strictFail(parser, 'Non-whitespace before first tag.')
+ parser.textNode = c
+ parser.state = S.TEXT
+ }
+ }
+
+ function charAt (chunk, i) {
+ var result = ''
+ if (i < chunk.length) {
+ result = chunk.charAt(i)
+ }
+ return result
+ }
+
+ function write (chunk) {
+ var parser = this
+ if (this.error) {
+ throw this.error
+ }
+ if (parser.closed) {
+ return error(parser,
+ 'Cannot write after close. Assign an onready handler.')
+ }
+ if (chunk === null) {
+ return end(parser)
+ }
+ if (typeof chunk === 'object') {
+ chunk = chunk.toString()
+ }
+ var i = 0
+ var c = ''
+ while (true) {
+ c = charAt(chunk, i++)
+ parser.c = c
+
+ if (!c) {
+ break
+ }
+
+ if (parser.trackPosition) {
+ parser.position++
+ if (c === '\n') {
+ parser.line++
+ parser.column = 0
+ } else {
+ parser.column++
+ }
+ }
+
+ switch (parser.state) {
+ case S.BEGIN:
+ parser.state = S.BEGIN_WHITESPACE
+ if (c === '\uFEFF') {
+ continue
+ }
+ beginWhiteSpace(parser, c)
+ continue
+
+ case S.BEGIN_WHITESPACE:
+ beginWhiteSpace(parser, c)
+ continue
+
+ case S.TEXT:
+ if (parser.sawRoot && !parser.closedRoot) {
+ var starti = i - 1
+ while (c && c !== '<' && c !== '&') {
+ c = charAt(chunk, i++)
+ if (c && parser.trackPosition) {
+ parser.position++
+ if (c === '\n') {
+ parser.line++
+ parser.column = 0
+ } else {
+ parser.column++
+ }
+ }
+ }
+ parser.textNode += chunk.substring(starti, i - 1)
+ }
+ if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
+ parser.state = S.OPEN_WAKA
+ parser.startTagPosition = parser.position
+ } else {
+ if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
+ strictFail(parser, 'Text data outside of root node.')
+ }
+ if (c === '&') {
+ parser.state = S.TEXT_ENTITY
+ } else {
+ parser.textNode += c
+ }
+ }
+ continue
+
+ case S.SCRIPT:
+ // only non-strict
+ if (c === '<') {
+ parser.state = S.SCRIPT_ENDING
+ } else {
+ parser.script += c
+ }
+ continue
+
+ case S.SCRIPT_ENDING:
+ if (c === '/') {
+ parser.state = S.CLOSE_TAG
+ } else {
+ parser.script += '<' + c
+ parser.state = S.SCRIPT
+ }
+ continue
+
+ case S.OPEN_WAKA:
+ // either a /, ?, !, or text is coming next.
+ if (c === '!') {
+ parser.state = S.SGML_DECL
+ parser.sgmlDecl = ''
+ } else if (isWhitespace(c)) {
+ // wait for it...
+ } else if (isMatch(nameStart, c)) {
+ parser.state = S.OPEN_TAG
+ parser.tagName = c
+ } else if (c === '/') {
+ parser.state = S.CLOSE_TAG
+ parser.tagName = ''
+ } else if (c === '?') {
+ parser.state = S.PROC_INST
+ parser.procInstName = parser.procInstBody = ''
+ } else {
+ strictFail(parser, 'Unencoded <')
+ // if there was some whitespace, then add that in.
+ if (parser.startTagPosition + 1 < parser.position) {
+ var pad = parser.position - parser.startTagPosition
+ c = new Array(pad).join(' ') + c
+ }
+ parser.textNode += '<' + c
+ parser.state = S.TEXT
+ }
+ continue
+
+ case S.SGML_DECL:
+ if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
+ emitNode(parser, 'onopencdata')
+ parser.state = S.CDATA
+ parser.sgmlDecl = ''
+ parser.cdata = ''
+ } else if (parser.sgmlDecl + c === '--') {
+ parser.state = S.COMMENT
+ parser.comment = ''
+ parser.sgmlDecl = ''
+ } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
+ parser.state = S.DOCTYPE
+ if (parser.doctype || parser.sawRoot) {
+ strictFail(parser,
+ 'Inappropriately located doctype declaration')
+ }
+ parser.doctype = ''
+ parser.sgmlDecl = ''
+ } else if (c === '>') {
+ emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)
+ parser.sgmlDecl = ''
+ parser.state = S.TEXT
+ } else if (isQuote(c)) {
+ parser.state = S.SGML_DECL_QUOTED
+ parser.sgmlDecl += c
+ } else {
+ parser.sgmlDecl += c
+ }
+ continue
+
+ case S.SGML_DECL_QUOTED:
+ if (c === parser.q) {
+ parser.state = S.SGML_DECL
+ parser.q = ''
+ }
+ parser.sgmlDecl += c
+ continue
+
+ case S.DOCTYPE:
+ if (c === '>') {
+ parser.state = S.TEXT
+ emitNode(parser, 'ondoctype', parser.doctype)
+ parser.doctype = true // just remember that we saw it.
+ } else {
+ parser.doctype += c
+ if (c === '[') {
+ parser.state = S.DOCTYPE_DTD
+ } else if (isQuote(c)) {
+ parser.state = S.DOCTYPE_QUOTED
+ parser.q = c
+ }
+ }
+ continue
+
+ case S.DOCTYPE_QUOTED:
+ parser.doctype += c
+ if (c === parser.q) {
+ parser.q = ''
+ parser.state = S.DOCTYPE
+ }
+ continue
+
+ case S.DOCTYPE_DTD:
+ parser.doctype += c
+ if (c === ']') {
+ parser.state = S.DOCTYPE
+ } else if (isQuote(c)) {
+ parser.state = S.DOCTYPE_DTD_QUOTED
+ parser.q = c
+ }
+ continue
+
+ case S.DOCTYPE_DTD_QUOTED:
+ parser.doctype += c
+ if (c === parser.q) {
+ parser.state = S.DOCTYPE_DTD
+ parser.q = ''
+ }
+ continue
+
+ case S.COMMENT:
+ if (c === '-') {
+ parser.state = S.COMMENT_ENDING
+ } else {
+ parser.comment += c
+ }
+ continue
+
+ case S.COMMENT_ENDING:
+ if (c === '-') {
+ parser.state = S.COMMENT_ENDED
+ parser.comment = textopts(parser.opt, parser.comment)
+ if (parser.comment) {
+ emitNode(parser, 'oncomment', parser.comment)
+ }
+ parser.comment = ''
+ } else {
+ parser.comment += '-' + c
+ parser.state = S.COMMENT
+ }
+ continue
+
+ case S.COMMENT_ENDED:
+ if (c !== '>') {
+ strictFail(parser, 'Malformed comment')
+ // allow <!-- blah -- bloo --> in non-strict mode,
+ // which is a comment of " blah -- bloo "
+ parser.comment += '--' + c
+ parser.state = S.COMMENT
+ } else {
+ parser.state = S.TEXT
+ }
+ continue
+
+ case S.CDATA:
+ if (c === ']') {
+ parser.state = S.CDATA_ENDING
+ } else {
+ parser.cdata += c
+ }
+ continue
+
+ case S.CDATA_ENDING:
+ if (c === ']') {
+ parser.state = S.CDATA_ENDING_2
+ } else {
+ parser.cdata += ']' + c
+ parser.state = S.CDATA
+ }
+ continue
+
+ case S.CDATA_ENDING_2:
+ if (c === '>') {
+ if (parser.cdata) {
+ emitNode(parser, 'oncdata', parser.cdata)
+ }
+ emitNode(parser, 'onclosecdata')
+ parser.cdata = ''
+ parser.state = S.TEXT
+ } else if (c === ']') {
+ parser.cdata += ']'
+ } else {
+ parser.cdata += ']]' + c
+ parser.state = S.CDATA
+ }
+ continue
+
+ case S.PROC_INST:
+ if (c === '?') {
+ parser.state = S.PROC_INST_ENDING
+ } else if (isWhitespace(c)) {
+ parser.state = S.PROC_INST_BODY
+ } else {
+ parser.procInstName += c
+ }
+ continue
+
+ case S.PROC_INST_BODY:
+ if (!parser.procInstBody && isWhitespace(c)) {
+ continue
+ } else if (c === '?') {
+ parser.state = S.PROC_INST_ENDING
+ } else {
+ parser.procInstBody += c
+ }
+ continue
+
+ case S.PROC_INST_ENDING:
+ if (c === '>') {
+ emitNode(parser, 'onprocessinginstruction', {
+ name: parser.procInstName,
+ body: parser.procInstBody
+ })
+ parser.procInstName = parser.procInstBody = ''
+ parser.state = S.TEXT
+ } else {
+ parser.procInstBody += '?' + c
+ parser.state = S.PROC_INST_BODY
+ }
+ continue
+
+ case S.OPEN_TAG:
+ if (isMatch(nameBody, c)) {
+ parser.tagName += c
+ } else {
+ newTag(parser)
+ if (c === '>') {
+ openTag(parser)
+ } else if (c === '/') {
+ parser.state = S.OPEN_TAG_SLASH
+ } else {
+ if (!isWhitespace(c)) {
+ strictFail(parser, 'Invalid character in tag name')
+ }
+ parser.state = S.ATTRIB
+ }
+ }
+ continue
+
+ case S.OPEN_TAG_SLASH:
+ if (c === '>') {
+ openTag(parser, true)
+ closeTag(parser)
+ } else {
+ strictFail(parser, 'Forward-slash in opening tag not followed by >')
+ parser.state = S.ATTRIB
+ }
+ continue
+
+ case S.ATTRIB:
+ // haven't read the attribute name yet.
+ if (isWhitespace(c)) {
+ continue
+ } else if (c === '>') {
+ openTag(parser)
+ } else if (c === '/') {
+ parser.state = S.OPEN_TAG_SLASH
+ } else if (isMatch(nameStart, c)) {
+ parser.attribName = c
+ parser.attribValue = ''
+ parser.state = S.ATTRIB_NAME
+ } else {
+ strictFail(parser, 'Invalid attribute name')
+ }
+ continue
+
+ case S.ATTRIB_NAME:
+ if (c === '=') {
+ parser.state = S.ATTRIB_VALUE
+ } else if (c === '>') {
+ strictFail(parser, 'Attribute without value')
+ parser.attribValue = parser.attribName
+ attrib(parser)
+ openTag(parser)
+ } else if (isWhitespace(c)) {
+ parser.state = S.ATTRIB_NAME_SAW_WHITE
+ } else if (isMatch(nameBody, c)) {
+ parser.attribName += c
+ } else {
+ strictFail(parser, 'Invalid attribute name')
+ }
+ continue
+
+ case S.ATTRIB_NAME_SAW_WHITE:
+ if (c === '=') {
+ parser.state = S.ATTRIB_VALUE
+ } else if (isWhitespace(c)) {
+ continue
+ } else {
+ strictFail(parser, 'Attribute without value')
+ parser.tag.attributes[parser.attribName] = ''
+ parser.attribValue = ''
+ emitNode(parser, 'onattribute', {
+ name: parser.attribName,
+ value: ''
+ })
+ parser.attribName = ''
+ if (c === '>') {
+ openTag(parser)
+ } else if (isMatch(nameStart, c)) {
+ parser.attribName = c
+ parser.state = S.ATTRIB_NAME
+ } else {
+ strictFail(parser, 'Invalid attribute name')
+ parser.state = S.ATTRIB
+ }
+ }
+ continue
+
+ case S.ATTRIB_VALUE:
+ if (isWhitespace(c)) {
+ continue
+ } else if (isQuote(c)) {
+ parser.q = c
+ parser.state = S.ATTRIB_VALUE_QUOTED
+ } else {
+ strictFail(parser, 'Unquoted attribute value')
+ parser.state = S.ATTRIB_VALUE_UNQUOTED
+ parser.attribValue = c
+ }
+ continue
+
+ case S.ATTRIB_VALUE_QUOTED:
+ if (c !== parser.q) {
+ if (c === '&') {
+ parser.state = S.ATTRIB_VALUE_ENTITY_Q
+ } else {
+ parser.attribValue += c
+ }
+ continue
+ }
+ attrib(parser)
+ parser.q = ''
+ parser.state = S.ATTRIB_VALUE_CLOSED
+ continue
+
+ case S.ATTRIB_VALUE_CLOSED:
+ if (isWhitespace(c)) {
+ parser.state = S.ATTRIB
+ } else if (c === '>') {
+ openTag(parser)
+ } else if (c === '/') {
+ parser.state = S.OPEN_TAG_SLASH
+ } else if (isMatch(nameStart, c)) {
+ strictFail(parser, 'No whitespace between attributes')
+ parser.attribName = c
+ parser.attribValue = ''
+ parser.state = S.ATTRIB_NAME
+ } else {
+ strictFail(parser, 'Invalid attribute name')
+ }
+ continue
+
+ case S.ATTRIB_VALUE_UNQUOTED:
+ if (!isAttribEnd(c)) {
+ if (c === '&') {
+ parser.state = S.ATTRIB_VALUE_ENTITY_U
+ } else {
+ parser.attribValue += c
+ }
+ continue
+ }
+ attrib(parser)
+ if (c === '>') {
+ openTag(parser)
+ } else {
+ parser.state = S.ATTRIB
+ }
+ continue
+
+ case S.CLOSE_TAG:
+ if (!parser.tagName) {
+ if (isWhitespace(c)) {
+ continue
+ } else if (notMatch(nameStart, c)) {
+ if (parser.script) {
+ parser.script += '</' + c
+ parser.state = S.SCRIPT
+ } else {
+ strictFail(parser, 'Invalid tagname in closing tag.')
+ }
+ } else {
+ parser.tagName = c
+ }
+ } else if (c === '>') {
+ closeTag(parser)
+ } else if (isMatch(nameBody, c)) {
+ parser.tagName += c
+ } else if (parser.script) {
+ parser.script += '</' + parser.tagName
+ parser.tagName = ''
+ parser.state = S.SCRIPT
+ } else {
+ if (!isWhitespace(c)) {
+ strictFail(parser, 'Invalid tagname in closing tag')
+ }
+ parser.state = S.CLOSE_TAG_SAW_WHITE
+ }
+ continue
+
+ case S.CLOSE_TAG_SAW_WHITE:
+ if (isWhitespace(c)) {
+ continue
+ }
+ if (c === '>') {
+ closeTag(parser)
+ } else {
+ strictFail(parser, 'Invalid characters in closing tag')
+ }
+ continue
+
+ case S.TEXT_ENTITY:
+ case S.ATTRIB_VALUE_ENTITY_Q:
+ case S.ATTRIB_VALUE_ENTITY_U:
+ var returnState
+ var buffer
+ switch (parser.state) {
+ case S.TEXT_ENTITY:
+ returnState = S.TEXT
+ buffer = 'textNode'
+ break
+
+ case S.ATTRIB_VALUE_ENTITY_Q:
+ returnState = S.ATTRIB_VALUE_QUOTED
+ buffer = 'attribValue'
+ break
+
+ case S.ATTRIB_VALUE_ENTITY_U:
+ returnState = S.ATTRIB_VALUE_UNQUOTED
+ buffer = 'attribValue'
+ break
+ }
+
+ if (c === ';') {
+ parser[buffer] += parseEntity(parser)
+ parser.entity = ''
+ parser.state = returnState
+ } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
+ parser.entity += c
+ } else {
+ strictFail(parser, 'Invalid character in entity name')
+ parser[buffer] += '&' + parser.entity + c
+ parser.entity = ''
+ parser.state = returnState
+ }
+
+ continue
+
+ default:
+ throw new Error(parser, 'Unknown state: ' + parser.state)
+ }
+ } // while
+
+ if (parser.position >= parser.bufferCheckPosition) {
+ checkBufferLength(parser)
+ }
+ return parser
+ }
+
+ /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+ /* istanbul ignore next */
+ if (!String.fromCodePoint) {
+ (function () {
+ var stringFromCharCode = String.fromCharCode
+ var floor = Math.floor
+ var fromCodePoint = function () {
+ var MAX_SIZE = 0x4000
+ var codeUnits = []
+ var highSurrogate
+ var lowSurrogate
+ var index = -1
+ var length = arguments.length
+ if (!length) {
+ return ''
+ }
+ var result = ''
+ while (++index < length) {
+ var codePoint = Number(arguments[index])
+ if (
+ !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+ codePoint < 0 || // not a valid Unicode code point
+ codePoint > 0x10FFFF || // not a valid Unicode code point
+ floor(codePoint) !== codePoint // not an integer
+ ) {
+ throw RangeError('Invalid code point: ' + codePoint)
+ }
+ if (codePoint <= 0xFFFF) { // BMP code point
+ codeUnits.push(codePoint)
+ } else { // Astral code point; split in surrogate halves
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ codePoint -= 0x10000
+ highSurrogate = (codePoint >> 10) + 0xD800
+ lowSurrogate = (codePoint % 0x400) + 0xDC00
+ codeUnits.push(highSurrogate, lowSurrogate)
+ }
+ if (index + 1 === length || codeUnits.length > MAX_SIZE) {
+ result += stringFromCharCode.apply(null, codeUnits)
+ codeUnits.length = 0
+ }
+ }
+ return result
+ }
+ /* istanbul ignore next */
+ if (Object.defineProperty) {
+ Object.defineProperty(String, 'fromCodePoint', {
+ value: fromCodePoint,
+ configurable: true,
+ writable: true
+ })
+ } else {
+ String.fromCodePoint = fromCodePoint
+ }
+ }())
+ }
+})(typeof exports === 'undefined' ? this.sax = {} : exports)
diff --git a/node_modules/sax/package.json b/node_modules/sax/package.json
new file mode 100644
index 0000000..210d368
--- /dev/null
+++ b/node_modules/sax/package.json
@@ -0,0 +1,137 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "sax@>=0.6.0",
+ "scope": null,
+ "escapedName": "sax",
+ "name": "sax",
+ "rawSpec": ">=0.6.0",
+ "spec": ">=0.6.0",
+ "type": "range"
+ },
+ "/Users/fzy/project/koa2_Sequelize_project/node_modules/xml2js"
+ ]
+ ],
+ "_from": "sax@>=0.6.0",
+ "_id": "sax@1.2.4",
+ "_inCache": true,
+ "_location": "/sax",
+ "_nodeVersion": "8.0.0",
+ "_npmOperationalInternal": {
+ "host": "s3://npm-registry-packages",
+ "tmp": "tmp/sax-1.2.4.tgz_1498153598031_0.6106507133226842"
+ },
+ "_npmUser": {
+ "name": "isaacs",
+ "email": "i@izs.me"
+ },
+ "_npmVersion": "5.0.3",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "sax@>=0.6.0",
+ "scope": null,
+ "escapedName": "sax",
+ "name": "sax",
+ "rawSpec": ">=0.6.0",
+ "spec": ">=0.6.0",
+ "type": "range"
+ },
+ "_requiredBy": [
+ "/xml2js"
+ ],
+ "_resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
+ "_shasum": "2816234e2378bddc4e5354fab5caa895df7100d9",
+ "_shrinkwrap": null,
+ "_spec": "sax@>=0.6.0",
+ "_where": "/Users/fzy/project/koa2_Sequelize_project/node_modules/xml2js",
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me/"
+ },
+ "bugs": {
+ "url": "https://github.com/isaacs/sax-js/issues"
+ },
+ "contributors": [
+ {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me"
+ },
+ {
+ "name": "Stein Martin Hustad",
+ "email": "stein@hustad.com"
+ },
+ {
+ "name": "Mikeal Rogers",
+ "email": "mikeal.rogers@gmail.com"
+ },
+ {
+ "name": "Laurie Harper",
+ "email": "laurie@holoweb.net"
+ },
+ {
+ "name": "Jann Horn",
+ "email": "jann@Jann-PC.fritz.box"
+ },
+ {
+ "name": "Elijah Insua",
+ "email": "tmpvar@gmail.com"
+ },
+ {
+ "name": "Henry Rawas",
+ "email": "henryr@schakra.com"
+ },
+ {
+ "name": "Justin Makeig",
+ "email": "jmpublic@makeig.com"
+ },
+ {
+ "name": "Mike Schilling",
+ "email": "mike@emotive.com"
+ }
+ ],
+ "dependencies": {},
+ "description": "An evented streaming XML parser in JavaScript",
+ "devDependencies": {
+ "standard": "^8.6.0",
+ "tap": "^10.5.1"
+ },
+ "directories": {},
+ "dist": {
+ "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==",
+ "shasum": "2816234e2378bddc4e5354fab5caa895df7100d9",
+ "tarball": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz"
+ },
+ "files": [
+ "lib/sax.js",
+ "LICENSE",
+ "README.md"
+ ],
+ "gitHead": "5aee2163d55cff24b817bbf550bac44841f9df45",
+ "homepage": "https://github.com/isaacs/sax-js#readme",
+ "license": "ISC",
+ "main": "lib/sax.js",
+ "maintainers": [
+ {
+ "name": "isaacs",
+ "email": "i@izs.me"
+ }
+ ],
+ "name": "sax",
+ "optionalDependencies": {},
+ "readme": "# sax js\n\nA sax-style parser for XML and HTML.\n\nDesigned with [node](http://nodejs.org/) in mind, but should work fine in\nthe browser or other CommonJS implementations.\n\n## What This Is\n\n* A very simple tool to parse through an XML string.\n* A stepping stone to a streaming HTML parser.\n* A handy way to deal with RSS and other mostly-ok-but-kinda-broken XML\n docs.\n\n## What This Is (probably) Not\n\n* An HTML Parser - That's a fine goal, but this isn't it. It's just\n XML.\n* A DOM Builder - You can use it to build an object model out of XML,\n but it doesn't do that out of the box.\n* XSLT - No DOM = no querying.\n* 100% Compliant with (some other SAX implementation) - Most SAX\n implementations are in Java and do a lot more than this does.\n* An XML Validator - It does a little validation when in strict mode, but\n not much.\n* A Schema-Aware XSD Thing - Schemas are an exercise in fetishistic\n masochism.\n* A DTD-aware Thing - Fetching DTDs is a much bigger job.\n\n## Regarding `<!DOCTYPE`s and `<!ENTITY`s\n\nThe parser will handle the basic XML entities in text nodes and attribute\nvalues: `& < > ' "`. It's possible to define additional\nentities in XML by putting them in the DTD. This parser doesn't do anything\nwith that. If you want to listen to the `ondoctype` event, and then fetch\nthe doctypes, and read the entities and add them to `parser.ENTITIES`, then\nbe my guest.\n\nUnknown entities will fail in strict mode, and in loose mode, will pass\nthrough unmolested.\n\n## Usage\n\n```javascript\nvar sax = require(\"./lib/sax\"),\n strict = true, // set to false for html-mode\n parser = sax.parser(strict);\n\nparser.onerror = function (e) {\n // an error happened.\n};\nparser.ontext = function (t) {\n // got some text. t is the string of text.\n};\nparser.onopentag = function (node) {\n // opened a tag. node has \"name\" and \"attributes\"\n};\nparser.onattribute = function (attr) {\n // an attribute. attr has \"name\" and \"value\"\n};\nparser.onend = function () {\n // parser stream is done, and ready to have more stuff written to it.\n};\n\nparser.write('<xml>Hello, <who name=\"world\">world</who>!</xml>').close();\n\n// stream usage\n// takes the same options as the parser\nvar saxStream = require(\"sax\").createStream(strict, options)\nsaxStream.on(\"error\", function (e) {\n // unhandled errors will throw, since this is a proper node\n // event emitter.\n console.error(\"error!\", e)\n // clear the error\n this._parser.error = null\n this._parser.resume()\n})\nsaxStream.on(\"opentag\", function (node) {\n // same object as above\n})\n// pipe is supported, and it's readable/writable\n// same chunks coming in also go out.\nfs.createReadStream(\"file.xml\")\n .pipe(saxStream)\n .pipe(fs.createWriteStream(\"file-copy.xml\"))\n```\n\n\n## Arguments\n\nPass the following arguments to the parser function. All are optional.\n\n`strict` - Boolean. Whether or not to be a jerk. Default: `false`.\n\n`opt` - Object bag of settings regarding string formatting. All default to `false`.\n\nSettings supported:\n\n* `trim` - Boolean. Whether or not to trim text and comment nodes.\n* `normalize` - Boolean. If true, then turn any whitespace into a single\n space.\n* `lowercase` - Boolean. If true, then lowercase tag names and attribute names\n in loose mode, rather than uppercasing them.\n* `xmlns` - Boolean. If true, then namespaces are supported.\n* `position` - Boolean. If false, then don't track line/col/position.\n* `strictEntities` - Boolean. If true, only parse [predefined XML\n entities](http://www.w3.org/TR/REC-xml/#sec-predefined-ent)\n (`&`, `'`, `>`, `<`, and `"`)\n\n## Methods\n\n`write` - Write bytes onto the stream. You don't have to do this all at\nonce. You can keep writing as much as you want.\n\n`close` - Close the stream. Once closed, no more data may be written until\nit is done processing the buffer, which is signaled by the `end` event.\n\n`resume` - To gracefully handle errors, assign a listener to the `error`\nevent. Then, when the error is taken care of, you can call `resume` to\ncontinue parsing. Otherwise, the parser will not continue while in an error\nstate.\n\n## Members\n\nAt all times, the parser object will have the following members:\n\n`line`, `column`, `position` - Indications of the position in the XML\ndocument where the parser currently is looking.\n\n`startTagPosition` - Indicates the position where the current tag starts.\n\n`closed` - Boolean indicating whether or not the parser can be written to.\nIf it's `true`, then wait for the `ready` event to write again.\n\n`strict` - Boolean indicating whether or not the parser is a jerk.\n\n`opt` - Any options passed into the constructor.\n\n`tag` - The current tag being dealt with.\n\nAnd a bunch of other stuff that you probably shouldn't touch.\n\n## Events\n\nAll events emit with a single argument. To listen to an event, assign a\nfunction to `on<eventname>`. Functions get executed in the this-context of\nthe parser object. The list of supported events are also in the exported\n`EVENTS` array.\n\nWhen using the stream interface, assign handlers using the EventEmitter\n`on` function in the normal fashion.\n\n`error` - Indication that something bad happened. The error will be hanging\nout on `parser.error`, and must be deleted before parsing can continue. By\nlistening to this event, you can keep an eye on that kind of stuff. Note:\nthis happens *much* more in strict mode. Argument: instance of `Error`.\n\n`text` - Text node. Argument: string of text.\n\n`doctype` - The `<!DOCTYPE` declaration. Argument: doctype string.\n\n`processinginstruction` - Stuff like `<?xml foo=\"blerg\" ?>`. Argument:\nobject with `name` and `body` members. Attributes are not parsed, as\nprocessing instructions have implementation dependent semantics.\n\n`sgmldeclaration` - Random SGML declarations. Stuff like `<!ENTITY p>`\nwould trigger this kind of event. This is a weird thing to support, so it\nmight go away at some point. SAX isn't intended to be used to parse SGML,\nafter all.\n\n`opentagstart` - Emitted immediately when the tag name is available,\nbut before any attributes are encountered. Argument: object with a\n`name` field and an empty `attributes` set. Note that this is the\nsame object that will later be emitted in the `opentag` event.\n\n`opentag` - An opening tag. Argument: object with `name` and `attributes`.\nIn non-strict mode, tag names are uppercased, unless the `lowercase`\noption is set. If the `xmlns` option is set, then it will contain\nnamespace binding information on the `ns` member, and will have a\n`local`, `prefix`, and `uri` member.\n\n`closetag` - A closing tag. In loose mode, tags are auto-closed if their\nparent closes. In strict mode, well-formedness is enforced. Note that\nself-closing tags will have `closeTag` emitted immediately after `openTag`.\nArgument: tag name.\n\n`attribute` - An attribute node. Argument: object with `name` and `value`.\nIn non-strict mode, attribute names are uppercased, unless the `lowercase`\noption is set. If the `xmlns` option is set, it will also contains namespace\ninformation.\n\n`comment` - A comment node. Argument: the string of the comment.\n\n`opencdata` - The opening tag of a `<![CDATA[` block.\n\n`cdata` - The text of a `<![CDATA[` block. Since `<![CDATA[` blocks can get\nquite large, this event may fire multiple times for a single block, if it\nis broken up into multiple `write()`s. Argument: the string of random\ncharacter data.\n\n`closecdata` - The closing tag (`]]>`) of a `< and
+[xmlbuilder-js](https://github.com/oozcitak/xmlbuilder-js/).
+
+Note: If you're looking for a full DOM parser, you probably want
+[JSDom](https://github.com/tmpvar/jsdom).
+
+Installation
+============
+
+Simplest way to install `xml2js` is to use [npm](http://npmjs.org), just `npm
+install xml2js` which will download xml2js and all dependencies.
+
+xml2js is also available via [Bower](http://bower.io/), just `bower install
+xml2js` which will download xml2js and all dependencies.
+
+Usage
+=====
+
+No extensive tutorials required because you are a smart developer! The task of
+parsing XML should be an easy one, so let's make it so! Here's some examples.
+
+Shoot-and-forget usage
+----------------------
+
+You want to parse XML as simple and easy as possible? It's dangerous to go
+alone, take this:
+
+```javascript
+var parseString = require('xml2js').parseString;
+var xml = "<root>Hello xml2js!</root>"
+parseString(xml, function (err, result) {
+ console.dir(result);
+});
+```
+
+Can't get easier than this, right? This works starting with `xml2js` 0.2.3.
+With CoffeeScript it looks like this:
+
+```coffeescript
+{parseString} = require 'xml2js'
+xml = "<root>Hello xml2js!</root>"
+parseString xml, (err, result) ->
+ console.dir result
+```
+
+If you need some special options, fear not, `xml2js` supports a number of
+options (see below), you can specify these as second argument:
+
+```javascript
+parseString(xml, {trim: true}, function (err, result) {
+});
+```
+
+Simple as pie usage
+-------------------
+
+That's right, if you have been using xml-simple or a home-grown
+wrapper, this was added in 0.1.11 just for you:
+
+```javascript
+var fs = require('fs'),
+ xml2js = require('xml2js');
+
+var parser = new xml2js.Parser();
+fs.readFile(__dirname + '/foo.xml', function(err, data) {
+ parser.parseString(data, function (err, result) {
+ console.dir(result);
+ console.log('Done');
+ });
+});
+```
+
+Look ma, no event listeners!
+
+You can also use `xml2js` from
+[CoffeeScript](https://github.com/jashkenas/coffeescript), further reducing
+the clutter:
+
+```coffeescript
+fs = require 'fs',
+xml2js = require 'xml2js'
+
+parser = new xml2js.Parser()
+fs.readFile __dirname + '/foo.xml', (err, data) ->
+ parser.parseString data, (err, result) ->
+ console.dir result
+ console.log 'Done.'
+```
+
+But what happens if you forget the `new` keyword to create a new `Parser`? In
+the middle of a nightly coding session, it might get lost, after all. Worry
+not, we got you covered! Starting with 0.2.8 you can also leave it out, in
+which case `xml2js` will helpfully add it for you, no bad surprises and
+inexplicable bugs!
+
+Parsing multiple files
+----------------------
+
+If you want to parse multiple files, you have multiple possibilities:
+
+ * You can create one `xml2js.Parser` per file. That's the recommended one
+ and is promised to always *just work*.
+ * You can call `reset()` on your parser object.
+ * You can hope everything goes well anyway. This behaviour is not
+ guaranteed work always, if ever. Use option #1 if possible. Thanks!
+
+So you wanna some JSON?
+-----------------------
+
+Just wrap the `result` object in a call to `JSON.stringify` like this
+`JSON.stringify(result)`. You get a string containing the JSON representation
+of the parsed object that you can feed to JSON-hungry consumers.
+
+Displaying results
+------------------
+
+You might wonder why, using `console.dir` or `console.log` the output at some
+level is only `[Object]`. Don't worry, this is not because `xml2js` got lazy.
+That's because Node uses `util.inspect` to convert the object into strings and
+that function stops after `depth=2` which is a bit low for most XML.
+
+To display the whole deal, you can use `console.log(util.inspect(result, false,
+null))`, which displays the whole result.
+
+So much for that, but what if you use
+[eyes](https://github.com/cloudhead/eyes.js) for nice colored output and it
+truncates the output with `…`? Don't fear, there's also a solution for that,
+you just need to increase the `maxLength` limit by creating a custom inspector
+`var inspect = require('eyes').inspector({maxLength: false})` and then you can
+easily `inspect(result)`.
+
+XML builder usage
+-----------------
+
+Since 0.4.0, objects can be also be used to build XML:
+
+```javascript
+var fs = require('fs'),
+ xml2js = require('xml2js');
+
+var obj = {name: "Super", Surname: "Man", age: 23};
+
+var builder = new xml2js.Builder();
+var xml = builder.buildObject(obj);
+```
+
+At the moment, a one to one bi-directional conversion is guaranteed only for
+default configuration, except for `attrkey`, `charkey` and `explicitArray` options
+you can redefine to your taste. Writing CDATA is supported via setting the `cdata`
+option to `true`.
+
+Processing attribute, tag names and values
+------------------------------------------
+
+Since 0.4.1 you can optionally provide the parser with attribute name and tag name processors as well as element value processors (Since 0.4.14, you can also optionally provide the parser with attribute value processors):
+
+```javascript
+
+function nameToUpperCase(name){
+ return name.toUpperCase();
+}
+
+//transform all attribute and tag names and values to uppercase
+parseString(xml, {
+ tagNameProcessors: [nameToUpperCase],
+ attrNameProcessors: [nameToUpperCase],
+ valueProcessors: [nameToUpperCase],
+ attrValueProcessors: [nameToUpperCase]},
+ function (err, result) {
+ // processed data
+});
+```
+
+The `tagNameProcessors` and `attrNameProcessors` options
+accept an `Array` of functions with the following signature:
+
+```javascript
+function (name){
+ //do something with `name`
+ return name
+}
+```
+
+The `attrValueProcessors` and `valueProcessors` options
+accept an `Array` of functions with the following signature:
+
+```javascript
+function (value, name) {
+ //`name` will be the node name or attribute name
+ //do something with `value`, (optionally) dependent on the node/attr name
+ return value
+}
+```
+
+Some processors are provided out-of-the-box and can be found in `lib/processors.js`:
+
+- `normalize`: transforms the name to lowercase.
+(Automatically used when `options.normalize` is set to `true`)
+
+- `firstCharLowerCase`: transforms the first character to lower case.
+E.g. 'MyTagName' becomes 'myTagName'
+
+- `stripPrefix`: strips the xml namespace prefix. E.g `<foo:Bar/>` will become 'Bar'.
+(N.B.: the `xmlns` prefix is NOT stripped.)
+
+- `parseNumbers`: parses integer-like strings as integers and float-like strings as floats
+E.g. "0" becomes 0 and "15.56" becomes 15.56
+
+- `parseBooleans`: parses boolean-like strings to booleans
+E.g. "true" becomes true and "False" becomes false
+
+Options
+=======
+
+Apart from the default settings, there are a number of options that can be
+specified for the parser. Options are specified by ``new Parser({optionName:
+value})``. Possible options are:
+
+ * `attrkey` (default: `$`): Prefix that is used to access the attributes.
+ Version 0.1 default was `@`.
+ * `charkey` (default: `_`): Prefix that is used to access the character
+ content. Version 0.1 default was `#`.
+ * `explicitCharkey` (default: `false`)
+ * `trim` (default: `false`): Trim the whitespace at the beginning and end of
+ text nodes.
+ * `normalizeTags` (default: `false`): Normalize all tag names to lowercase.
+ * `normalize` (default: `false`): Trim whitespaces inside text nodes.
+ * `explicitRoot` (default: `true`): Set this if you want to get the root
+ node in the resulting object.
+ * `emptyTag` (default: `''`): what will the value of empty nodes be.
+ * `explicitArray` (default: `true`): Always put child nodes in an array if
+ true; otherwise an array is created only if there is more than one.
+ * `ignoreAttrs` (default: `false`): Ignore all XML attributes and only create
+ text nodes.
+ * `mergeAttrs` (default: `false`): Merge attributes and child elements as
+ properties of the parent, instead of keying attributes off a child
+ attribute object. This option is ignored if `ignoreAttrs` is `false`.
+ * `validator` (default `null`): You can specify a callable that validates
+ the resulting structure somehow, however you want. See unit tests
+ for an example.
+ * `xmlns` (default `false`): Give each element a field usually called '$ns'
+ (the first character is the same as attrkey) that contains its local name
+ and namespace URI.
+ * `explicitChildren` (default `false`): Put child elements to separate
+ property. Doesn't work with `mergeAttrs = true`. If element has no children
+ then "children" won't be created. Added in 0.2.5.
+ * `childkey` (default `$$`): Prefix that is used to access child elements if
+ `explicitChildren` is set to `true`. Added in 0.2.5.
+ * `preserveChildrenOrder` (default `false`): Modifies the behavior of
+ `explicitChildren` so that the value of the "children" property becomes an
+ ordered array. When this is `true`, every node will also get a `#name` field
+ whose value will correspond to the XML nodeName, so that you may iterate
+ the "children" array and still be able to determine node names. The named
+ (and potentially unordered) properties are also retained in this
+ configuration at the same level as the ordered "children" array. Added in
+ 0.4.9.
+ * `charsAsChildren` (default `false`): Determines whether chars should be
+ considered children if `explicitChildren` is on. Added in 0.2.5.
+ * `includeWhiteChars` (default `false`): Determines whether whitespace-only
+ text nodes should be included. Added in 0.4.17.
+ * `async` (default `false`): Should the callbacks be async? This *might* be
+ an incompatible change if your code depends on sync execution of callbacks.
+ Future versions of `xml2js` might change this default, so the recommendation
+ is to not depend on sync execution anyway. Added in 0.2.6.
+ * `strict` (default `true`): Set sax-js to strict or non-strict parsing mode.
+ Defaults to `true` which is *highly* recommended, since parsing HTML which
+ is not well-formed XML might yield just about anything. Added in 0.2.7.
+ * `attrNameProcessors` (default: `null`): Allows the addition of attribute
+ name processing functions. Accepts an `Array` of functions with following
+ signature:
+ ```javascript
+ function (name){
+ //do something with `name`
+ return name
+ }
+ ```
+ Added in 0.4.14
+ * `attrValueProcessors` (default: `null`): Allows the addition of attribute
+ value processing functions. Accepts an `Array` of functions with following
+ signature:
+ ```javascript
+ function (name){
+ //do something with `name`
+ return name
+ }
+ ```
+ Added in 0.4.1
+ * `tagNameProcessors` (default: `null`): Allows the addition of tag name
+ processing functions. Accepts an `Array` of functions with following
+ signature:
+ ```javascript
+ function (name){
+ //do something with `name`
+ return name
+ }
+ ```
+ Added in 0.4.1
+ * `valueProcessors` (default: `null`): Allows the addition of element value
+ processing functions. Accepts an `Array` of functions with following
+ signature:
+ ```javascript
+ function (name){
+ //do something with `name`
+ return name
+ }
+ ```
+ Added in 0.4.6
+
+Options for the `Builder` class
+-------------------------------
+These options are specified by ``new Builder({optionName: value})``.
+Possible options are:
+
+ * `rootName` (default `root` or the root key name): root element name to be used in case
+ `explicitRoot` is `false` or to override the root element name.
+ * `renderOpts` (default `{ 'pretty': true, 'indent': ' ', 'newline': '\n' }`):
+ Rendering options for xmlbuilder-js.
+ * pretty: prettify generated XML
+ * indent: whitespace for indentation (only when pretty)
+ * newline: newline char (only when pretty)
+ * `xmldec` (default `{ 'version': '1.0', 'encoding': 'UTF-8', 'standalone': true }`:
+ XML declaration attributes.
+ * `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` (default `null`): optional DTD. Eg. `{'ext': 'hello.dtd'}`
+ * `headless` (default: `false`): omit the XML header. Added in 0.4.3.
+ * `allowSurrogateChars` (default: `false`): allows using characters from the Unicode
+ surrogate blocks.
+ * `cdata` (default: `false`): wrap text nodes in `<![CDATA[ ... ]]>` instead of
+ escaping when necessary. Does not add `<![CDATA[ ... ]]>` if it is not required.
+ Added in 0.4.5.
+
+`renderOpts`, `xmldec`,`doctype` and `headless` pass through to
+[xmlbuilder-js](https://github.com/oozcitak/xmlbuilder-js).
+
+Updating to new version
+=======================
+
+Version 0.2 changed the default parsing settings, but version 0.1.14 introduced
+the default settings for version 0.2, so these settings can be tried before the
+migration.
+
+```javascript
+var xml2js = require('xml2js');
+var parser = new xml2js.Parser(xml2js.defaults["0.2"]);
+```
+
+To get the 0.1 defaults in version 0.2 you can just use
+`xml2js.defaults["0.1"]` in the same place. This provides you with enough time
+to migrate to the saner way of parsing in `xml2js` 0.2. We try to make the
+migration as simple and gentle as possible, but some breakage cannot be
+avoided.
+
+So, what exactly did change and why? In 0.2 we changed some defaults to parse
+the XML in a more universal and sane way. So we disabled `normalize` and `trim`
+so `xml2js` does not cut out any text content. You can reenable this at will of
+course. A more important change is that we return the root tag in the resulting
+JavaScript structure via the `explicitRoot` setting, so you need to access the
+first element. This is useful for anybody who wants to know what the root node
+is and preserves more information. The last major change was to enable
+`explicitArray`, so everytime it is possible that one might embed more than one
+sub-tag into a tag, xml2js >= 0.2 returns an array even if the array just
+includes one element. This is useful when dealing with APIs that return
+variable amounts of subtags.
+
+Running tests, development
+==========================
+
+[](https://travis-ci.org/Leonidas-from-XIV/node-xml2js)
+[](https://coveralls.io/r/Leonidas-from-XIV/node-xml2js?branch=master)
+[](https://david-dm.org/Leonidas-from-XIV/node-xml2js)
+
+The development requirements are handled by npm, you just need to install them.
+We also have a number of unit tests, they can be run using `npm test` directly
+from the project root. This runs zap to discover all the tests and execute
+them.
+
+If you like to contribute, keep in mind that `xml2js` is written in
+CoffeeScript, so don't develop on the JavaScript files that are checked into
+the repository for convenience reasons. Also, please write some unit test to
+check your behaviour and if it is some user-facing thing, add some
+documentation to this README, so people will know it exists. Thanks in advance!
+
+Getting support
+===============
+
+Please, if you have a problem with the library, first make sure you read this
+README. If you read this far, thanks, you're good. Then, please make sure your
+problem really is with `xml2js`. It is? Okay, then I'll look at it. Send me a
+mail and we can talk. Please don't open issues, as I don't think that is the
+proper forum for support problems. Some problems might as well really be bugs
+in `xml2js`, if so I'll let you know to open an issue instead :)
+
+But if you know you really found a bug, feel free to open an issue instead.
diff --git a/node_modules/xml2js/lib/bom.js b/node_modules/xml2js/lib/bom.js
new file mode 100644
index 0000000..7b8fb27
--- /dev/null
+++ b/node_modules/xml2js/lib/bom.js
@@ -0,0 +1,12 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ "use strict";
+ exports.stripBOM = function(str) {
+ if (str[0] === '\uFEFF') {
+ return str.substring(1);
+ } else {
+ return str;
+ }
+ };
+
+}).call(this);
diff --git a/node_modules/xml2js/lib/builder.js b/node_modules/xml2js/lib/builder.js
new file mode 100644
index 0000000..58f3638
--- /dev/null
+++ b/node_modules/xml2js/lib/builder.js
@@ -0,0 +1,127 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ "use strict";
+ var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA,
+ hasProp = {}.hasOwnProperty;
+
+ builder = require('xmlbuilder');
+
+ defaults = require('./defaults').defaults;
+
+ requiresCDATA = function(entry) {
+ return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0);
+ };
+
+ wrapCDATA = function(entry) {
+ return "<![CDATA[" + (escapeCDATA(entry)) + "]]>";
+ };
+
+ escapeCDATA = function(entry) {
+ return entry.replace(']]>', ']]]]><![CDATA[>');
+ };
+
+ exports.Builder = (function() {
+ function Builder(opts) {
+ var key, ref, value;
+ this.options = {};
+ ref = defaults["0.2"];
+ for (key in ref) {
+ if (!hasProp.call(ref, key)) continue;
+ value = ref[key];
+ this.options[key] = value;
+ }
+ for (key in opts) {
+ if (!hasProp.call(opts, key)) continue;
+ value = opts[key];
+ this.options[key] = value;
+ }
+ }
+
+ Builder.prototype.buildObject = function(rootObj) {
+ var attrkey, charkey, render, rootElement, rootName;
+ attrkey = this.options.attrkey;
+ charkey = this.options.charkey;
+ if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) {
+ rootName = Object.keys(rootObj)[0];
+ rootObj = rootObj[rootName];
+ } else {
+ rootName = this.options.rootName;
+ }
+ render = (function(_this) {
+ return function(element, obj) {
+ var attr, child, entry, index, key, value;
+ if (typeof obj !== 'object') {
+ if (_this.options.cdata && requiresCDATA(obj)) {
+ element.raw(wrapCDATA(obj));
+ } else {
+ element.txt(obj);
+ }
+ } else if (Array.isArray(obj)) {
+ for (index in obj) {
+ if (!hasProp.call(obj, index)) continue;
+ child = obj[index];
+ for (key in child) {
+ entry = child[key];
+ element = render(element.ele(key), entry).up();
+ }
+ }
+ } else {
+ for (key in obj) {
+ if (!hasProp.call(obj, key)) continue;
+ child = obj[key];
+ if (key === attrkey) {
+ if (typeof child === "object") {
+ for (attr in child) {
+ value = child[attr];
+ element = element.att(attr, value);
+ }
+ }
+ } else if (key === charkey) {
+ if (_this.options.cdata && requiresCDATA(child)) {
+ element = element.raw(wrapCDATA(child));
+ } else {
+ element = element.txt(child);
+ }
+ } else if (Array.isArray(child)) {
+ for (index in child) {
+ if (!hasProp.call(child, index)) continue;
+ entry = child[index];
+ if (typeof entry === 'string') {
+ if (_this.options.cdata && requiresCDATA(entry)) {
+ element = element.ele(key).raw(wrapCDATA(entry)).up();
+ } else {
+ element = element.ele(key, entry).up();
+ }
+ } else {
+ element = render(element.ele(key), entry).up();
+ }
+ }
+ } else if (typeof child === "object") {
+ element = render(element.ele(key), child).up();
+ } else {
+ if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) {
+ element = element.ele(key).raw(wrapCDATA(child)).up();
+ } else {
+ if (child == null) {
+ child = '';
+ }
+ element = element.ele(key, child.toString()).up();
+ }
+ }
+ }
+ }
+ return element;
+ };
+ })(this);
+ rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
+ headless: this.options.headless,
+ allowSurrogateChars: this.options.allowSurrogateChars
+ });
+ return render(rootElement, rootObj).end(this.options.renderOpts);
+ };
+
+ return Builder;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xml2js/lib/defaults.js b/node_modules/xml2js/lib/defaults.js
new file mode 100644
index 0000000..0a21da0
--- /dev/null
+++ b/node_modules/xml2js/lib/defaults.js
@@ -0,0 +1,72 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ exports.defaults = {
+ "0.1": {
+ explicitCharkey: false,
+ trim: true,
+ normalize: true,
+ normalizeTags: false,
+ attrkey: "@",
+ charkey: "#",
+ explicitArray: false,
+ ignoreAttrs: false,
+ mergeAttrs: false,
+ explicitRoot: false,
+ validator: null,
+ xmlns: false,
+ explicitChildren: false,
+ childkey: '@@',
+ charsAsChildren: false,
+ includeWhiteChars: false,
+ async: false,
+ strict: true,
+ attrNameProcessors: null,
+ attrValueProcessors: null,
+ tagNameProcessors: null,
+ valueProcessors: null,
+ emptyTag: ''
+ },
+ "0.2": {
+ explicitCharkey: false,
+ trim: false,
+ normalize: false,
+ normalizeTags: false,
+ attrkey: "$",
+ charkey: "_",
+ explicitArray: true,
+ ignoreAttrs: false,
+ mergeAttrs: false,
+ explicitRoot: true,
+ validator: null,
+ xmlns: false,
+ explicitChildren: false,
+ preserveChildrenOrder: false,
+ childkey: '$$',
+ charsAsChildren: false,
+ includeWhiteChars: false,
+ async: false,
+ strict: true,
+ attrNameProcessors: null,
+ attrValueProcessors: null,
+ tagNameProcessors: null,
+ valueProcessors: null,
+ rootName: 'root',
+ xmldec: {
+ 'version': '1.0',
+ 'encoding': 'UTF-8',
+ 'standalone': true
+ },
+ doctype: null,
+ renderOpts: {
+ 'pretty': true,
+ 'indent': ' ',
+ 'newline': '\n'
+ },
+ headless: false,
+ chunkSize: 10000,
+ emptyTag: '',
+ cdata: false
+ }
+ };
+
+}).call(this);
diff --git a/node_modules/xml2js/lib/parser.js b/node_modules/xml2js/lib/parser.js
new file mode 100644
index 0000000..9e8261e
--- /dev/null
+++ b/node_modules/xml2js/lib/parser.js
@@ -0,0 +1,357 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ "use strict";
+ var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate,
+ bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ sax = require('sax');
+
+ events = require('events');
+
+ bom = require('./bom');
+
+ processors = require('./processors');
+
+ setImmediate = require('timers').setImmediate;
+
+ defaults = require('./defaults').defaults;
+
+ isEmpty = function(thing) {
+ return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0;
+ };
+
+ processItem = function(processors, item, key) {
+ var i, len, process;
+ for (i = 0, len = processors.length; i < len; i++) {
+ process = processors[i];
+ item = process(item, key);
+ }
+ return item;
+ };
+
+ exports.Parser = (function(superClass) {
+ extend(Parser, superClass);
+
+ function Parser(opts) {
+ this.parseString = bind(this.parseString, this);
+ this.reset = bind(this.reset, this);
+ this.assignOrPush = bind(this.assignOrPush, this);
+ this.processAsync = bind(this.processAsync, this);
+ var key, ref, value;
+ if (!(this instanceof exports.Parser)) {
+ return new exports.Parser(opts);
+ }
+ this.options = {};
+ ref = defaults["0.2"];
+ for (key in ref) {
+ if (!hasProp.call(ref, key)) continue;
+ value = ref[key];
+ this.options[key] = value;
+ }
+ for (key in opts) {
+ if (!hasProp.call(opts, key)) continue;
+ value = opts[key];
+ this.options[key] = value;
+ }
+ if (this.options.xmlns) {
+ this.options.xmlnskey = this.options.attrkey + "ns";
+ }
+ if (this.options.normalizeTags) {
+ if (!this.options.tagNameProcessors) {
+ this.options.tagNameProcessors = [];
+ }
+ this.options.tagNameProcessors.unshift(processors.normalize);
+ }
+ this.reset();
+ }
+
+ Parser.prototype.processAsync = function() {
+ var chunk, err;
+ try {
+ if (this.remaining.length <= this.options.chunkSize) {
+ chunk = this.remaining;
+ this.remaining = '';
+ this.saxParser = this.saxParser.write(chunk);
+ return this.saxParser.close();
+ } else {
+ chunk = this.remaining.substr(0, this.options.chunkSize);
+ this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
+ this.saxParser = this.saxParser.write(chunk);
+ return setImmediate(this.processAsync);
+ }
+ } catch (error1) {
+ err = error1;
+ if (!this.saxParser.errThrown) {
+ this.saxParser.errThrown = true;
+ return this.emit(err);
+ }
+ }
+ };
+
+ Parser.prototype.assignOrPush = function(obj, key, newValue) {
+ if (!(key in obj)) {
+ if (!this.options.explicitArray) {
+ return obj[key] = newValue;
+ } else {
+ return obj[key] = [newValue];
+ }
+ } else {
+ if (!(obj[key] instanceof Array)) {
+ obj[key] = [obj[key]];
+ }
+ return obj[key].push(newValue);
+ }
+ };
+
+ Parser.prototype.reset = function() {
+ var attrkey, charkey, ontext, stack;
+ this.removeAllListeners();
+ this.saxParser = sax.parser(this.options.strict, {
+ trim: false,
+ normalize: false,
+ xmlns: this.options.xmlns
+ });
+ this.saxParser.errThrown = false;
+ this.saxParser.onerror = (function(_this) {
+ return function(error) {
+ _this.saxParser.resume();
+ if (!_this.saxParser.errThrown) {
+ _this.saxParser.errThrown = true;
+ return _this.emit("error", error);
+ }
+ };
+ })(this);
+ this.saxParser.onend = (function(_this) {
+ return function() {
+ if (!_this.saxParser.ended) {
+ _this.saxParser.ended = true;
+ return _this.emit("end", _this.resultObject);
+ }
+ };
+ })(this);
+ this.saxParser.ended = false;
+ this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
+ this.resultObject = null;
+ stack = [];
+ attrkey = this.options.attrkey;
+ charkey = this.options.charkey;
+ this.saxParser.onopentag = (function(_this) {
+ return function(node) {
+ var key, newValue, obj, processedKey, ref;
+ obj = {};
+ obj[charkey] = "";
+ if (!_this.options.ignoreAttrs) {
+ ref = node.attributes;
+ for (key in ref) {
+ if (!hasProp.call(ref, key)) continue;
+ if (!(attrkey in obj) && !_this.options.mergeAttrs) {
+ obj[attrkey] = {};
+ }
+ newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];
+ processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;
+ if (_this.options.mergeAttrs) {
+ _this.assignOrPush(obj, processedKey, newValue);
+ } else {
+ obj[attrkey][processedKey] = newValue;
+ }
+ }
+ }
+ obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;
+ if (_this.options.xmlns) {
+ obj[_this.options.xmlnskey] = {
+ uri: node.uri,
+ local: node.local
+ };
+ }
+ return stack.push(obj);
+ };
+ })(this);
+ this.saxParser.onclosetag = (function(_this) {
+ return function() {
+ var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath;
+ obj = stack.pop();
+ nodeName = obj["#name"];
+ if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {
+ delete obj["#name"];
+ }
+ if (obj.cdata === true) {
+ cdata = obj.cdata;
+ delete obj.cdata;
+ }
+ s = stack[stack.length - 1];
+ if (obj[charkey].match(/^\s*$/) && !cdata) {
+ emptyStr = obj[charkey];
+ delete obj[charkey];
+ } else {
+ if (_this.options.trim) {
+ obj[charkey] = obj[charkey].trim();
+ }
+ if (_this.options.normalize) {
+ obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
+ }
+ obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];
+ if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+ obj = obj[charkey];
+ }
+ }
+ if (isEmpty(obj)) {
+ obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;
+ }
+ if (_this.options.validator != null) {
+ xpath = "/" + ((function() {
+ var i, len, results;
+ results = [];
+ for (i = 0, len = stack.length; i < len; i++) {
+ node = stack[i];
+ results.push(node["#name"]);
+ }
+ return results;
+ })()).concat(nodeName).join("/");
+ (function() {
+ var err;
+ try {
+ return obj = _this.options.validator(xpath, s && s[nodeName], obj);
+ } catch (error1) {
+ err = error1;
+ return _this.emit("error", err);
+ }
+ })();
+ }
+ if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') {
+ if (!_this.options.preserveChildrenOrder) {
+ node = {};
+ if (_this.options.attrkey in obj) {
+ node[_this.options.attrkey] = obj[_this.options.attrkey];
+ delete obj[_this.options.attrkey];
+ }
+ if (!_this.options.charsAsChildren && _this.options.charkey in obj) {
+ node[_this.options.charkey] = obj[_this.options.charkey];
+ delete obj[_this.options.charkey];
+ }
+ if (Object.getOwnPropertyNames(obj).length > 0) {
+ node[_this.options.childkey] = obj;
+ }
+ obj = node;
+ } else if (s) {
+ s[_this.options.childkey] = s[_this.options.childkey] || [];
+ objClone = {};
+ for (key in obj) {
+ if (!hasProp.call(obj, key)) continue;
+ objClone[key] = obj[key];
+ }
+ s[_this.options.childkey].push(objClone);
+ delete obj["#name"];
+ if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+ obj = obj[charkey];
+ }
+ }
+ }
+ if (stack.length > 0) {
+ return _this.assignOrPush(s, nodeName, obj);
+ } else {
+ if (_this.options.explicitRoot) {
+ old = obj;
+ obj = {};
+ obj[nodeName] = old;
+ }
+ _this.resultObject = obj;
+ _this.saxParser.ended = true;
+ return _this.emit("end", _this.resultObject);
+ }
+ };
+ })(this);
+ ontext = (function(_this) {
+ return function(text) {
+ var charChild, s;
+ s = stack[stack.length - 1];
+ if (s) {
+ s[charkey] += text;
+ if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) {
+ s[_this.options.childkey] = s[_this.options.childkey] || [];
+ charChild = {
+ '#name': '__text__'
+ };
+ charChild[charkey] = text;
+ if (_this.options.normalize) {
+ charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
+ }
+ s[_this.options.childkey].push(charChild);
+ }
+ return s;
+ }
+ };
+ })(this);
+ this.saxParser.ontext = ontext;
+ return this.saxParser.oncdata = (function(_this) {
+ return function(text) {
+ var s;
+ s = ontext(text);
+ if (s) {
+ return s.cdata = true;
+ }
+ };
+ })(this);
+ };
+
+ Parser.prototype.parseString = function(str, cb) {
+ var err;
+ if ((cb != null) && typeof cb === "function") {
+ this.on("end", function(result) {
+ this.reset();
+ return cb(null, result);
+ });
+ this.on("error", function(err) {
+ this.reset();
+ return cb(err);
+ });
+ }
+ try {
+ str = str.toString();
+ if (str.trim() === '') {
+ this.emit("end", null);
+ return true;
+ }
+ str = bom.stripBOM(str);
+ if (this.options.async) {
+ this.remaining = str;
+ setImmediate(this.processAsync);
+ return this.saxParser;
+ }
+ return this.saxParser.write(str).close();
+ } catch (error1) {
+ err = error1;
+ if (!(this.saxParser.errThrown || this.saxParser.ended)) {
+ this.emit('error', err);
+ return this.saxParser.errThrown = true;
+ } else if (this.saxParser.ended) {
+ throw err;
+ }
+ }
+ };
+
+ return Parser;
+
+ })(events.EventEmitter);
+
+ exports.parseString = function(str, a, b) {
+ var cb, options, parser;
+ if (b != null) {
+ if (typeof b === 'function') {
+ cb = b;
+ }
+ if (typeof a === 'object') {
+ options = a;
+ }
+ } else {
+ if (typeof a === 'function') {
+ cb = a;
+ }
+ options = {};
+ }
+ parser = new exports.Parser(options);
+ return parser.parseString(str, cb);
+ };
+
+}).call(this);
diff --git a/node_modules/xml2js/lib/processors.js b/node_modules/xml2js/lib/processors.js
new file mode 100644
index 0000000..89aa85f
--- /dev/null
+++ b/node_modules/xml2js/lib/processors.js
@@ -0,0 +1,34 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ "use strict";
+ var prefixMatch;
+
+ prefixMatch = new RegExp(/(?!xmlns)^.*:/);
+
+ exports.normalize = function(str) {
+ return str.toLowerCase();
+ };
+
+ exports.firstCharLowerCase = function(str) {
+ return str.charAt(0).toLowerCase() + str.slice(1);
+ };
+
+ exports.stripPrefix = function(str) {
+ return str.replace(prefixMatch, '');
+ };
+
+ exports.parseNumbers = function(str) {
+ if (!isNaN(str)) {
+ str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
+ }
+ return str;
+ };
+
+ exports.parseBooleans = function(str) {
+ if (/^(?:true|false)$/i.test(str)) {
+ str = str.toLowerCase() === 'true';
+ }
+ return str;
+ };
+
+}).call(this);
diff --git a/node_modules/xml2js/lib/xml2js.js b/node_modules/xml2js/lib/xml2js.js
new file mode 100644
index 0000000..599d3dd
--- /dev/null
+++ b/node_modules/xml2js/lib/xml2js.js
@@ -0,0 +1,37 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ "use strict";
+ var builder, defaults, parser, processors,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ defaults = require('./defaults');
+
+ builder = require('./builder');
+
+ parser = require('./parser');
+
+ processors = require('./processors');
+
+ exports.defaults = defaults.defaults;
+
+ exports.processors = processors;
+
+ exports.ValidationError = (function(superClass) {
+ extend(ValidationError, superClass);
+
+ function ValidationError(message) {
+ this.message = message;
+ }
+
+ return ValidationError;
+
+ })(Error);
+
+ exports.Builder = builder.Builder;
+
+ exports.Parser = parser.Parser;
+
+ exports.parseString = parser.parseString;
+
+}).call(this);
diff --git a/node_modules/xml2js/package.json b/node_modules/xml2js/package.json
new file mode 100644
index 0000000..87dd6e9
--- /dev/null
+++ b/node_modules/xml2js/package.json
@@ -0,0 +1,315 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "xml2js",
+ "scope": null,
+ "escapedName": "xml2js",
+ "name": "xml2js",
+ "rawSpec": "",
+ "spec": "latest",
+ "type": "tag"
+ },
+ "/Users/fzy/project/koa2_Sequelize_project"
+ ]
+ ],
+ "_from": "xml2js@latest",
+ "_id": "xml2js@0.4.19",
+ "_inCache": true,
+ "_location": "/xml2js",
+ "_nodeVersion": "8.4.0",
+ "_npmOperationalInternal": {
+ "host": "s3://npm-registry-packages",
+ "tmp": "tmp/xml2js-0.4.19.tgz_1503387862909_0.5125016651581973"
+ },
+ "_npmUser": {
+ "name": "leonidas",
+ "email": "marek@xivilization.net"
+ },
+ "_npmVersion": "5.3.0",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "xml2js",
+ "scope": null,
+ "escapedName": "xml2js",
+ "name": "xml2js",
+ "rawSpec": "",
+ "spec": "latest",
+ "type": "tag"
+ },
+ "_requiredBy": [
+ "#USER"
+ ],
+ "_resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.19.tgz",
+ "_shasum": "686c20f213209e94abf0d1bcf1efaa291c7827a7",
+ "_shrinkwrap": null,
+ "_spec": "xml2js",
+ "_where": "/Users/fzy/project/koa2_Sequelize_project",
+ "author": {
+ "name": "Marek Kubica",
+ "email": "marek@xivilization.net",
+ "url": "https://xivilization.net"
+ },
+ "bugs": {
+ "url": "https://github.com/Leonidas-from-XIV/node-xml2js/issues"
+ },
+ "contributors": [
+ {
+ "name": "maqr",
+ "email": "maqr.lollerskates@gmail.com",
+ "url": "https://github.com/maqr"
+ },
+ {
+ "name": "Ben Weaver",
+ "url": "http://benweaver.com/"
+ },
+ {
+ "name": "Jae Kwon",
+ "url": "https://github.com/jaekwon"
+ },
+ {
+ "name": "Jim Robert"
+ },
+ {
+ "name": "Ștefan Rusu",
+ "url": "http://www.saltwaterc.eu/"
+ },
+ {
+ "name": "Carter Cole",
+ "email": "carter.cole@cartercole.com",
+ "url": "http://cartercole.com/"
+ },
+ {
+ "name": "Kurt Raschke",
+ "email": "kurt@kurtraschke.com",
+ "url": "http://www.kurtraschke.com/"
+ },
+ {
+ "name": "Contra",
+ "email": "contra@australia.edu",
+ "url": "https://github.com/Contra"
+ },
+ {
+ "name": "Marcelo Diniz",
+ "email": "marudiniz@gmail.com",
+ "url": "https://github.com/mdiniz"
+ },
+ {
+ "name": "Michael Hart",
+ "url": "https://github.com/mhart"
+ },
+ {
+ "name": "Zachary Scott",
+ "email": "zachary@zacharyscott.net",
+ "url": "http://zacharyscott.net/"
+ },
+ {
+ "name": "Raoul Millais",
+ "url": "https://github.com/raoulmillais"
+ },
+ {
+ "name": "Salsita Software",
+ "url": "http://www.salsitasoft.com/"
+ },
+ {
+ "name": "Mike Schilling",
+ "email": "mike@emotive.com",
+ "url": "http://www.emotive.com/"
+ },
+ {
+ "name": "Jackson Tian",
+ "email": "shyvo1987@gmail.com",
+ "url": "http://weibo.com/shyvo"
+ },
+ {
+ "name": "Mikhail Zyatin",
+ "email": "mikhail.zyatin@gmail.com",
+ "url": "https://github.com/Sitin"
+ },
+ {
+ "name": "Chris Tavares",
+ "email": "ctavares@microsoft.com",
+ "url": "https://github.com/christav"
+ },
+ {
+ "name": "Frank Xu",
+ "email": "yyfrankyy@gmail.com",
+ "url": "http://f2e.us/"
+ },
+ {
+ "name": "Guido D'Albore",
+ "email": "guido@bitstorm.it",
+ "url": "http://www.bitstorm.it/"
+ },
+ {
+ "name": "Jack Senechal",
+ "url": "http://jacksenechal.com/"
+ },
+ {
+ "name": "Matthias Hölzl",
+ "email": "tc@xantira.com",
+ "url": "https://github.com/hoelzl"
+ },
+ {
+ "name": "Camille Reynders",
+ "email": "info@creynders.be",
+ "url": "http://www.creynders.be/"
+ },
+ {
+ "name": "Taylor Gautier",
+ "url": "https://github.com/tsgautier"
+ },
+ {
+ "name": "Todd Bryan",
+ "url": "https://github.com/toddrbryan"
+ },
+ {
+ "name": "Leore Avidar",
+ "email": "leore.avidar@gmail.com",
+ "url": "http://leoreavidar.com/"
+ },
+ {
+ "name": "Dave Aitken",
+ "email": "dave.aitken@gmail.com",
+ "url": "http://www.actionshrimp.com/"
+ },
+ {
+ "name": "Shaney Orrowe",
+ "email": "shaney.orrowe@practiceweb.co.uk"
+ },
+ {
+ "name": "Candle",
+ "email": "candle@candle.me.uk"
+ },
+ {
+ "name": "Jess Telford",
+ "email": "hi@jes.st",
+ "url": "http://jes.st"
+ },
+ {
+ "name": "Tom Hughes",
+ "email": "<tom@compton.nu",
+ "url": "http://compton.nu/"
+ },
+ {
+ "name": "Piotr Rochala",
+ "url": "http://rocha.la/"
+ },
+ {
+ "name": "Michael Avila",
+ "url": "https://github.com/michaelavila"
+ },
+ {
+ "name": "Ryan Gahl",
+ "url": "https://github.com/ryedin"
+ },
+ {
+ "name": "Eric Laberge",
+ "email": "e.laberge@gmail.com",
+ "url": "https://github.com/elaberge"
+ },
+ {
+ "name": "Benjamin E. Coe",
+ "email": "ben@npmjs.com",
+ "url": "https://twitter.com/benjamincoe"
+ },
+ {
+ "name": "Stephen Cresswell",
+ "url": "https://github.com/cressie176"
+ },
+ {
+ "name": "Pascal Ehlert",
+ "email": "pascal@hacksrus.net",
+ "url": "http://www.hacksrus.net/"
+ },
+ {
+ "name": "Tom Spencer",
+ "email": "fiznool@gmail.com",
+ "url": "http://fiznool.com/"
+ },
+ {
+ "name": "Tristian Flanagan",
+ "email": "tflanagan@datacollaborative.com",
+ "url": "https://github.com/tflanagan"
+ },
+ {
+ "name": "Tim Johns",
+ "email": "timjohns@yahoo.com",
+ "url": "https://github.com/TimJohns"
+ },
+ {
+ "name": "Bogdan Chadkin",
+ "email": "trysound@yandex.ru",
+ "url": "https://github.com/TrySound"
+ },
+ {
+ "name": "David Wood",
+ "email": "david.p.wood@gmail.com",
+ "url": "http://codesleuth.co.uk/"
+ },
+ {
+ "name": "Nicolas Maquet",
+ "url": "https://github.com/nmaquet"
+ },
+ {
+ "name": "Lovell Fuller",
+ "url": "http://lovell.info/"
+ },
+ {
+ "name": "d3adc0d3",
+ "url": "https://github.com/d3adc0d3"
+ }
+ ],
+ "dependencies": {
+ "sax": ">=0.6.0",
+ "xmlbuilder": "~9.0.1"
+ },
+ "description": "Simple XML to JavaScript object converter.",
+ "devDependencies": {
+ "coffee-script": ">=1.10.0",
+ "coveralls": "^2.11.2",
+ "diff": ">=1.0.8",
+ "docco": ">=0.6.2",
+ "nyc": ">=2.2.1",
+ "zap": ">=0.2.9"
+ },
+ "directories": {
+ "lib": "./lib"
+ },
+ "dist": {
+ "integrity": "sha512-esZnJZJOiJR9wWKMyuvSE1y6Dq5LCuJanqhxslH2bxM6duahNZ+HMpCLhBQGZkbX6xRf8x1Y2eJlgt2q3qo49Q==",
+ "shasum": "686c20f213209e94abf0d1bcf1efaa291c7827a7",
+ "tarball": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.19.tgz"
+ },
+ "files": [
+ "lib"
+ ],
+ "gitHead": "1ab44ea837eff59305bd11f0e1a1e542e7c3e79f",
+ "homepage": "https://github.com/Leonidas-from-XIV/node-xml2js",
+ "keywords": [
+ "xml",
+ "json"
+ ],
+ "license": "MIT",
+ "main": "./lib/xml2js",
+ "maintainers": [
+ {
+ "name": "leonidas",
+ "email": "marek@xivilization.net"
+ }
+ ],
+ "name": "xml2js",
+ "optionalDependencies": {},
+ "readme": "node-xml2js\n===========\n\nEver had the urge to parse XML? And wanted to access the data in some sane,\neasy way? Don't want to compile a C parser, for whatever reason? Then xml2js is\nwhat you're looking for!\n\nDescription\n===========\n\nSimple XML to JavaScript object converter. It supports bi-directional conversion.\nUses [sax-js](https://github.com/isaacs/sax-js/) and\n[xmlbuilder-js](https://github.com/oozcitak/xmlbuilder-js/).\n\nNote: If you're looking for a full DOM parser, you probably want\n[JSDom](https://github.com/tmpvar/jsdom).\n\nInstallation\n============\n\nSimplest way to install `xml2js` is to use [npm](http://npmjs.org), just `npm\ninstall xml2js` which will download xml2js and all dependencies.\n\nxml2js is also available via [Bower](http://bower.io/), just `bower install\nxml2js` which will download xml2js and all dependencies.\n\nUsage\n=====\n\nNo extensive tutorials required because you are a smart developer! The task of\nparsing XML should be an easy one, so let's make it so! Here's some examples.\n\nShoot-and-forget usage\n----------------------\n\nYou want to parse XML as simple and easy as possible? It's dangerous to go\nalone, take this:\n\n```javascript\nvar parseString = require('xml2js').parseString;\nvar xml = \"<root>Hello xml2js!</root>\"\nparseString(xml, function (err, result) {\n console.dir(result);\n});\n```\n\nCan't get easier than this, right? This works starting with `xml2js` 0.2.3.\nWith CoffeeScript it looks like this:\n\n```coffeescript\n{parseString} = require 'xml2js'\nxml = \"<root>Hello xml2js!</root>\"\nparseString xml, (err, result) ->\n console.dir result\n```\n\nIf you need some special options, fear not, `xml2js` supports a number of\noptions (see below), you can specify these as second argument:\n\n```javascript\nparseString(xml, {trim: true}, function (err, result) {\n});\n```\n\nSimple as pie usage\n-------------------\n\nThat's right, if you have been using xml-simple or a home-grown\nwrapper, this was added in 0.1.11 just for you:\n\n```javascript\nvar fs = require('fs'),\n xml2js = require('xml2js');\n\nvar parser = new xml2js.Parser();\nfs.readFile(__dirname + '/foo.xml', function(err, data) {\n parser.parseString(data, function (err, result) {\n console.dir(result);\n console.log('Done');\n });\n});\n```\n\nLook ma, no event listeners!\n\nYou can also use `xml2js` from\n[CoffeeScript](https://github.com/jashkenas/coffeescript), further reducing\nthe clutter:\n\n```coffeescript\nfs = require 'fs',\nxml2js = require 'xml2js'\n\nparser = new xml2js.Parser()\nfs.readFile __dirname + '/foo.xml', (err, data) ->\n parser.parseString data, (err, result) ->\n console.dir result\n console.log 'Done.'\n```\n\nBut what happens if you forget the `new` keyword to create a new `Parser`? In\nthe middle of a nightly coding session, it might get lost, after all. Worry\nnot, we got you covered! Starting with 0.2.8 you can also leave it out, in\nwhich case `xml2js` will helpfully add it for you, no bad surprises and\ninexplicable bugs!\n\nParsing multiple files\n----------------------\n\nIf you want to parse multiple files, you have multiple possibilities:\n\n * You can create one `xml2js.Parser` per file. That's the recommended one\n and is promised to always *just work*.\n * You can call `reset()` on your parser object.\n * You can hope everything goes well anyway. This behaviour is not\n guaranteed work always, if ever. Use option #1 if possible. Thanks!\n\nSo you wanna some JSON?\n-----------------------\n\nJust wrap the `result` object in a call to `JSON.stringify` like this\n`JSON.stringify(result)`. You get a string containing the JSON representation\nof the parsed object that you can feed to JSON-hungry consumers.\n\nDisplaying results\n------------------\n\nYou might wonder why, using `console.dir` or `console.log` the output at some\nlevel is only `[Object]`. Don't worry, this is not because `xml2js` got lazy.\nThat's because Node uses `util.inspect` to convert the object into strings and\nthat function stops after `depth=2` which is a bit low for most XML.\n\nTo display the whole deal, you can use `console.log(util.inspect(result, false,\nnull))`, which displays the whole result.\n\nSo much for that, but what if you use\n[eyes](https://github.com/cloudhead/eyes.js) for nice colored output and it\ntruncates the output with `…`? Don't fear, there's also a solution for that,\nyou just need to increase the `maxLength` limit by creating a custom inspector\n`var inspect = require('eyes').inspector({maxLength: false})` and then you can\neasily `inspect(result)`.\n\nXML builder usage\n-----------------\n\nSince 0.4.0, objects can be also be used to build XML:\n\n```javascript\nvar fs = require('fs'),\n xml2js = require('xml2js');\n\nvar obj = {name: \"Super\", Surname: \"Man\", age: 23};\n\nvar builder = new xml2js.Builder();\nvar xml = builder.buildObject(obj);\n```\n\nAt the moment, a one to one bi-directional conversion is guaranteed only for\ndefault configuration, except for `attrkey`, `charkey` and `explicitArray` options\nyou can redefine to your taste. Writing CDATA is supported via setting the `cdata`\noption to `true`.\n\nProcessing attribute, tag names and values\n------------------------------------------\n\nSince 0.4.1 you can optionally provide the parser with attribute name and tag name processors as well as element value processors (Since 0.4.14, you can also optionally provide the parser with attribute value processors):\n\n```javascript\n\nfunction nameToUpperCase(name){\n return name.toUpperCase();\n}\n\n//transform all attribute and tag names and values to uppercase\nparseString(xml, {\n tagNameProcessors: [nameToUpperCase],\n attrNameProcessors: [nameToUpperCase],\n valueProcessors: [nameToUpperCase],\n attrValueProcessors: [nameToUpperCase]},\n function (err, result) {\n // processed data\n});\n```\n\nThe `tagNameProcessors` and `attrNameProcessors` options\naccept an `Array` of functions with the following signature:\n\n```javascript\nfunction (name){\n //do something with `name`\n return name\n}\n```\n\nThe `attrValueProcessors` and `valueProcessors` options\naccept an `Array` of functions with the following signature:\n\n```javascript\nfunction (value, name) {\n //`name` will be the node name or attribute name\n //do something with `value`, (optionally) dependent on the node/attr name\n return value\n}\n```\n\nSome processors are provided out-of-the-box and can be found in `lib/processors.js`:\n\n- `normalize`: transforms the name to lowercase.\n(Automatically used when `options.normalize` is set to `true`)\n\n- `firstCharLowerCase`: transforms the first character to lower case.\nE.g. 'MyTagName' becomes 'myTagName'\n\n- `stripPrefix`: strips the xml namespace prefix. E.g `<foo:Bar/>` will become 'Bar'.\n(N.B.: the `xmlns` prefix is NOT stripped.)\n\n- `parseNumbers`: parses integer-like strings as integers and float-like strings as floats\nE.g. \"0\" becomes 0 and \"15.56\" becomes 15.56\n\n- `parseBooleans`: parses boolean-like strings to booleans\nE.g. \"true\" becomes true and \"False\" becomes false\n\nOptions\n=======\n\nApart from the default settings, there are a number of options that can be\nspecified for the parser. Options are specified by ``new Parser({optionName:\nvalue})``. Possible options are:\n\n * `attrkey` (default: `$`): Prefix that is used to access the attributes.\n Version 0.1 default was `@`.\n * `charkey` (default: `_`): Prefix that is used to access the character\n content. Version 0.1 default was `#`.\n * `explicitCharkey` (default: `false`)\n * `trim` (default: `false`): Trim the whitespace at the beginning and end of\n text nodes.\n * `normalizeTags` (default: `false`): Normalize all tag names to lowercase.\n * `normalize` (default: `false`): Trim whitespaces inside text nodes.\n * `explicitRoot` (default: `true`): Set this if you want to get the root\n node in the resulting object.\n * `emptyTag` (default: `''`): what will the value of empty nodes be.\n * `explicitArray` (default: `true`): Always put child nodes in an array if\n true; otherwise an array is created only if there is more than one.\n * `ignoreAttrs` (default: `false`): Ignore all XML attributes and only create\n text nodes.\n * `mergeAttrs` (default: `false`): Merge attributes and child elements as\n properties of the parent, instead of keying attributes off a child\n attribute object. This option is ignored if `ignoreAttrs` is `false`.\n * `validator` (default `null`): You can specify a callable that validates\n the resulting structure somehow, however you want. See unit tests\n for an example.\n * `xmlns` (default `false`): Give each element a field usually called '$ns'\n (the first character is the same as attrkey) that contains its local name\n and namespace URI.\n * `explicitChildren` (default `false`): Put child elements to separate\n property. Doesn't work with `mergeAttrs = true`. If element has no children\n then \"children\" won't be created. Added in 0.2.5.\n * `childkey` (default `$$`): Prefix that is used to access child elements if\n `explicitChildren` is set to `true`. Added in 0.2.5.\n * `preserveChildrenOrder` (default `false`): Modifies the behavior of\n `explicitChildren` so that the value of the \"children\" property becomes an\n ordered array. When this is `true`, every node will also get a `#name` field\n whose value will correspond to the XML nodeName, so that you may iterate\n the \"children\" array and still be able to determine node names. The named\n (and potentially unordered) properties are also retained in this\n configuration at the same level as the ordered \"children\" array. Added in\n 0.4.9.\n * `charsAsChildren` (default `false`): Determines whether chars should be\n considered children if `explicitChildren` is on. Added in 0.2.5.\n * `includeWhiteChars` (default `false`): Determines whether whitespace-only\n text nodes should be included. Added in 0.4.17.\n * `async` (default `false`): Should the callbacks be async? This *might* be\n an incompatible change if your code depends on sync execution of callbacks.\n Future versions of `xml2js` might change this default, so the recommendation\n is to not depend on sync execution anyway. Added in 0.2.6.\n * `strict` (default `true`): Set sax-js to strict or non-strict parsing mode.\n Defaults to `true` which is *highly* recommended, since parsing HTML which\n is not well-formed XML might yield just about anything. Added in 0.2.7.\n * `attrNameProcessors` (default: `null`): Allows the addition of attribute\n name processing functions. Accepts an `Array` of functions with following\n signature:\n ```javascript\n function (name){\n //do something with `name`\n return name\n }\n ```\n Added in 0.4.14\n * `attrValueProcessors` (default: `null`): Allows the addition of attribute\n value processing functions. Accepts an `Array` of functions with following\n signature:\n ```javascript\n function (name){\n //do something with `name`\n return name\n }\n ```\n Added in 0.4.1\n * `tagNameProcessors` (default: `null`): Allows the addition of tag name\n processing functions. Accepts an `Array` of functions with following\n signature:\n ```javascript\n function (name){\n //do something with `name`\n return name\n }\n ```\n Added in 0.4.1\n * `valueProcessors` (default: `null`): Allows the addition of element value\n processing functions. Accepts an `Array` of functions with following\n signature:\n ```javascript\n function (name){\n //do something with `name`\n return name\n }\n ```\n Added in 0.4.6\n\nOptions for the `Builder` class\n-------------------------------\nThese options are specified by ``new Builder({optionName: value})``.\nPossible options are:\n\n * `rootName` (default `root` or the root key name): root element name to be used in case\n `explicitRoot` is `false` or to override the root element name.\n * `renderOpts` (default `{ 'pretty': true, 'indent': ' ', 'newline': '\\n' }`):\n Rendering options for xmlbuilder-js.\n * pretty: prettify generated XML\n * indent: whitespace for indentation (only when pretty)\n * newline: newline char (only when pretty)\n * `xmldec` (default `{ 'version': '1.0', 'encoding': 'UTF-8', 'standalone': true }`:\n XML declaration attributes.\n * `xmldec.version` A version number string, e.g. 1.0\n * `xmldec.encoding` Encoding declaration, e.g. UTF-8\n * `xmldec.standalone` standalone document declaration: true or false\n * `doctype` (default `null`): optional DTD. Eg. `{'ext': 'hello.dtd'}`\n * `headless` (default: `false`): omit the XML header. Added in 0.4.3.\n * `allowSurrogateChars` (default: `false`): allows using characters from the Unicode\n surrogate blocks.\n * `cdata` (default: `false`): wrap text nodes in `<![CDATA[ ... ]]>` instead of\n escaping when necessary. Does not add `<![CDATA[ ... ]]>` if it is not required.\n Added in 0.4.5.\n\n`renderOpts`, `xmldec`,`doctype` and `headless` pass through to\n[xmlbuilder-js](https://github.com/oozcitak/xmlbuilder-js).\n\nUpdating to new version\n=======================\n\nVersion 0.2 changed the default parsing settings, but version 0.1.14 introduced\nthe default settings for version 0.2, so these settings can be tried before the\nmigration.\n\n```javascript\nvar xml2js = require('xml2js');\nvar parser = new xml2js.Parser(xml2js.defaults[\"0.2\"]);\n```\n\nTo get the 0.1 defaults in version 0.2 you can just use\n`xml2js.defaults[\"0.1\"]` in the same place. This provides you with enough time\nto migrate to the saner way of parsing in `xml2js` 0.2. We try to make the\nmigration as simple and gentle as possible, but some breakage cannot be\navoided.\n\nSo, what exactly did change and why? In 0.2 we changed some defaults to parse\nthe XML in a more universal and sane way. So we disabled `normalize` and `trim`\nso `xml2js` does not cut out any text content. You can reenable this at will of\ncourse. A more important change is that we return the root tag in the resulting\nJavaScript structure via the `explicitRoot` setting, so you need to access the\nfirst element. This is useful for anybody who wants to know what the root node\nis and preserves more information. The last major change was to enable\n`explicitArray`, so everytime it is possible that one might embed more than one\nsub-tag into a tag, xml2js >= 0.2 returns an array even if the array just\nincludes one element. This is useful when dealing with APIs that return\nvariable amounts of subtags.\n\nRunning tests, development\n==========================\n\n[](https://travis-ci.org/Leonidas-from-XIV/node-xml2js)\n[](https://coveralls.io/r/Leonidas-from-XIV/node-xml2js?branch=master)\n[](https://david-dm.org/Leonidas-from-XIV/node-xml2js)\n\nThe development requirements are handled by npm, you just need to install them.\nWe also have a number of unit tests, they can be run using `npm test` directly\nfrom the project root. This runs zap to discover all the tests and execute\nthem.\n\nIf you like to contribute, keep in mind that `xml2js` is written in\nCoffeeScript, so don't develop on the JavaScript files that are checked into\nthe repository for convenience reasons. Also, please write some unit test to\ncheck your behaviour and if it is some user-facing thing, add some\ndocumentation to this README, so people will know it exists. Thanks in advance!\n\nGetting support\n===============\n\nPlease, if you have a problem with the library, first make sure you read this\nREADME. If you read this far, thanks, you're good. Then, please make sure your\nproblem really is with `xml2js`. It is? Okay, then I'll look at it. Send me a\nmail and we can talk. Please don't open issues, as I don't think that is the\nproper forum for support problems. Some problems might as well really be bugs\nin `xml2js`, if so I'll let you know to open an issue instead :)\n\nBut if you know you really found a bug, feel free to open an issue instead.\n",
+ "readmeFilename": "README.md",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/Leonidas-from-XIV/node-xml2js.git"
+ },
+ "scripts": {
+ "coverage": "nyc npm test && nyc report",
+ "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls",
+ "test": "zap"
+ },
+ "version": "0.4.19"
+}
diff --git a/node_modules/xmlbuilder/.npmignore b/node_modules/xmlbuilder/.npmignore
new file mode 100644
index 0000000..b6ad1f6
--- /dev/null
+++ b/node_modules/xmlbuilder/.npmignore
@@ -0,0 +1,5 @@
+.travis.yml
+src
+test
+perf
+coverage
diff --git a/node_modules/xmlbuilder/CHANGELOG.md b/node_modules/xmlbuilder/CHANGELOG.md
new file mode 100644
index 0000000..6264283
--- /dev/null
+++ b/node_modules/xmlbuilder/CHANGELOG.md
@@ -0,0 +1,423 @@
+# Change Log
+
+All notable changes to this project are documented in this file. This project adheres to [Semantic Versioning](http://semver.org/#semantic-versioning-200).
+
+## [9.0.4] - 2017-08-16
+- `spacebeforeslash` writer option accepts `true` as well as space char(s).
+
+## [9.0.3] - 2017-08-15
+- `spacebeforeslash` writer option can now be used with XML fragments.
+
+## [9.0.2] - 2017-08-15
+- Added the `spacebeforeslash` writer option to add a space character before closing tags of empty elements. See
+[#157](https://github.com/oozcitak/xmlbuilder-js/issues/157).
+
+## [9.0.1] - 2017-06-19
+- Fixed character validity checks to work with node.js 4.0 and 5.0. See
+[#161](https://github.com/oozcitak/xmlbuilder-js/issues/161).
+
+## [9.0.0] - 2017-05-05
+- Removed case conversion options.
+- Removed support for node.js 4.0 and 5.0. Minimum required version is now 6.0.
+- Fixed valid char filter to use XML 1.1 instead of 1.0. See
+[#147](https://github.com/oozcitak/xmlbuilder-js/issues/147).
+- Added options for negative indentation and suppressing pretty printing of text
+nodes. See
+[#145](https://github.com/oozcitak/xmlbuilder-js/issues/145).
+
+## [8.2.2] - 2016-04-08
+- Falsy values can now be used as a text node in callback mode.
+
+## [8.2.1] - 2016-04-07
+- Falsy values can now be used as a text node. See
+[#117](https://github.com/oozcitak/xmlbuilder-js/issues/117).
+
+## [8.2.0] - 2016-04-01
+- Removed lodash dependency to keep the library small and simple. See
+[#114](https://github.com/oozcitak/xmlbuilder-js/issues/114),
+[#53](https://github.com/oozcitak/xmlbuilder-js/issues/53),
+and [#43](https://github.com/oozcitak/xmlbuilder-js/issues/43).
+- Added title case to name conversion options.
+
+## [8.1.0] - 2016-03-29
+- Added the callback option to the `begin` export function. When used with a
+callback function, the XML document will be generated in chunks and each chunk
+will be passed to the supplied function. In this mode, `begin` uses a different
+code path and the builder should use much less memory since the entire XML tree
+is not kept. There are a few drawbacks though. For example, traversing the document
+tree or adding attributes to a node after it is written is not possible. It is
+also not possible to remove nodes or attributes.
+
+``` js
+var result = '';
+
+builder.begin(function(chunk) { result += chunk; })
+ .dec()
+ .ele('root')
+ .ele('xmlbuilder').up()
+ .end();
+```
+
+- Replaced native `Object.assign` with `lodash.assign` to support old JS engines. See [#111](https://github.com/oozcitak/xmlbuilder-js/issues/111).
+
+## [8.0.0] - 2016-03-25
+- Added the `begin` export function. See the wiki for details.
+- Added the ability to add comments and processing instructions before and after the root element. Added `commentBefore`, `commentAfter`, `instructionBefore` and `instructionAfter` functions for this purpose.
+- Dropped support for old node.js releases. Minimum required node.js version is now 4.0.
+
+## [7.0.0] - 2016-03-21
+- Processing instructions are now created as regular nodes. This is a major breaking change if you are using processing instructions. Previously processing instructions were inserted before their parent node. After this change processing instructions are appended to the children of the parent node. Note that it is not currently possible to insert processing instructions before or after the root element.
+```js
+root.ele('node').ins('pi');
+// pre-v7
+<?pi?><node/>
+// v7
+<node><?pi?></node>
+```
+
+## [6.0.0] - 2016-03-20
+- Added custom XML writers. The default string conversion functions are now collected under the `XMLStringWriter` class which can be accessed by the `stringWriter(options)` function exported by the module. An `XMLStreamWriter` is also added which outputs the XML document to a writable stream. A stream writer can be created by calling the `streamWriter(stream, options)` function exported by the module. Both classes are heavily customizable and the details are added to the wiki. It is also possible to write an XML writer from scratch and use it when calling `end()` on the XML document.
+
+## [5.0.1] - 2016-03-08
+- Moved require statements for text case conversion to the top of files to reduce lazy requires.
+
+## [5.0.0] - 2016-03-05
+- Added text case option for element names and attribute names. Valid cases are `lower`, `upper`, `camel`, `kebab` and `snake`.
+- Attribute and element values are escaped according to the [Canonical XML 1.0 specification](http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping). See [#54](https://github.com/oozcitak/xmlbuilder-js/issues/54) and [#86](https://github.com/oozcitak/xmlbuilder-js/issues/86).
+- Added the `allowEmpty` option to `end()`. When this option is set, empty elements are not self-closed.
+- Added support for [nested CDATA](https://en.wikipedia.org/wiki/CDATA#Nesting). The triad `]]>` in CDATA is now automatically replaced with `]]]]><![CDATA[>`.
+
+## [4.2.1] - 2016-01-15
+- Updated lodash dependency to 4.0.0.
+
+## [4.2.0] - 2015-12-16
+- Added the `noDoubleEncoding` option to `create()` to control whether existing html entities are encoded.
+
+## [4.1.0] - 2015-11-11
+- Added the `separateArrayItems` option to `create()` to control how arrays are handled when converting from objects. e.g.
+
+```js
+root.ele({ number: [ "one", "two" ]});
+// with separateArrayItems: true
+<number>
+ <one/>
+ <two/>
+</number>
+// with separateArrayItems: false
+<number>one</number>
+<number>two</number>
+```
+
+## [4.0.0] - 2015-11-01
+- Removed the `#list` decorator. Array items are now created as child nodes by default.
+- Fixed a bug where the XML encoding string was checked partially.
+
+## [3.1.0] - 2015-09-19
+- `#list` decorator ignores empty arrays.
+
+## [3.0.0] - 2015-09-10
+- Allow `\r`, `\n` and `\t` in attribute values without escaping. See [#86](https://github.com/oozcitak/xmlbuilder-js/issues/86).
+
+## [2.6.5] - 2015-09-09
+- Use native `isArray` instead of lodash.
+- Indentation of processing instructions are set to the parent element's.
+
+## [2.6.4] - 2015-05-27
+- Updated lodash dependency to 3.5.0.
+
+## [2.6.3] - 2015-05-27
+- Bumped version because previous release was not published on npm.
+
+## [2.6.2] - 2015-03-10
+- Updated lodash dependency to 3.5.0.
+
+## [2.6.1] - 2015-02-20
+- Updated lodash dependency to 3.3.0.
+
+## [2.6.0] - 2015-02-20
+- Fixed a bug where the `XMLNode` constructor overwrote the super class parent.
+- Removed document property from cloned nodes.
+- Switched to mocha.js for testing.
+
+## [2.5.2] - 2015-02-16
+- Updated lodash dependency to 3.2.0.
+
+## [2.5.1] - 2015-02-09
+- Updated lodash dependency to 3.1.0.
+- Support all node >= 0.8.
+
+## [2.5.0] - 2015-00-03
+- Updated lodash dependency to 3.0.0.
+
+## [2.4.6] - 2015-01-26
+- Show more information from attribute creation with null values.
+- Added iojs as an engine.
+- Self close elements with empty text.
+
+## [2.4.5] - 2014-11-15
+- Fixed prepublish script to run on windows.
+- Fixed bug in XMLStringifier where an undefined value was used while reporting an invalid encoding value.
+- Moved require statements to the top of files to reduce lazy requires. See [#62](https://github.com/oozcitak/xmlbuilder-js/issues/62).
+
+## [2.4.4] - 2014-09-08
+- Added the `offset` option to `toString()` for use in XML fragments.
+
+## [2.4.3] - 2014-08-13
+- Corrected license in package description.
+
+## [2.4.2] - 2014-08-13
+- Dropped performance test and memwatch dependency.
+
+## [2.4.1] - 2014-08-12
+- Fixed a bug where empty indent string was omitted when pretty printing. See [#59](https://github.com/oozcitak/xmlbuilder-js/issues/59).
+
+## [2.4.0] - 2014-08-04
+- Correct cases of pubID and sysID.
+- Use single lodash instead of separate npm modules. See [#53](https://github.com/oozcitak/xmlbuilder-js/issues/53).
+- Escape according to Canonical XML 1.0. See [#54](https://github.com/oozcitak/xmlbuilder-js/issues/54).
+
+## [2.3.0] - 2014-07-17
+- Convert objects to JS primitives while sanitizing user input.
+- Object builder preserves items with null values. See [#44](https://github.com/oozcitak/xmlbuilder-js/issues/44).
+- Use modularized lodash functions to cut down dependencies.
+- Process empty objects when converting from objects so that we don't throw on empty child objects.
+
+## [2.2.1] - 2014-04-04
+- Bumped version because previous release was not published on npm.
+
+## [2.2.0] - 2014-04-04
+- Switch to lodash from underscore.
+- Removed legacy `ext` option from `create()`.
+- Drop old node versions: 0.4, 0.5, 0.6. 0.8 is the minimum requirement from now on.
+
+## [2.1.0] - 2013-12-30
+- Removed duplicate null checks from constructors.
+- Fixed node count in performance test.
+- Added option for skipping null attribute values. See [#26](https://github.com/oozcitak/xmlbuilder-js/issues/26).
+- Allow multiple values in `att()` and `ins()`.
+- Added ability to run individual performance tests.
+- Added flag for ignoring decorator strings.
+
+## [2.0.1] - 2013-12-24
+- Removed performance tests from npm package.
+
+## [2.0.0] - 2013-12-24
+- Combined loops for speed up.
+- Added support for the DTD and XML declaration.
+- `clone` includes attributes.
+- Added performance tests.
+- Evaluate attribute value if function.
+- Evaluate instruction value if function.
+
+## [1.1.2] - 2013-12-11
+- Changed processing instruction decorator to `?`.
+
+## [1.1.1] - 2013-12-11
+- Added processing instructions to JS object conversion.
+
+## [1.1.0] - 2013-12-10
+- Added license to package.
+- `create()` and `element()` accept JS object to fully build the document.
+- Added `nod()` and `n()` aliases for `node()`.
+- Renamed `convertAttChar` decorator to `convertAttKey`.
+- Ignore empty decorator strings when converting JS objects.
+
+## [1.0.2] - 2013-11-27
+- Removed temp file which was accidentally included in the package.
+
+## [1.0.1] - 2013-11-27
+- Custom stringify functions affect current instance only.
+
+## [1.0.0] - 2013-11-27
+- Added processing instructions.
+- Added stringify functions to sanitize and convert input values.
+- Added option for headless XML documents.
+- Added vows tests.
+- Removed Makefile. Using npm publish scripts instead.
+- Removed the `begin()` function. `create()` begins the document by creating the root node.
+
+## [0.4.3] - 2013-11-08
+- Added option to include surrogate pairs in XML content. See [#29](https://github.com/oozcitak/xmlbuilder-js/issues/29).
+- Fixed empty value string representation in pretty mode.
+- Added pre and postpublish scripts to package.json.
+- Filtered out prototype properties when appending attributes. See [#31](https://github.com/oozcitak/xmlbuilder-js/issues/31).
+
+## [0.4.2] - 2012-09-14
+- Removed README.md from `.npmignore`.
+
+## [0.4.1] - 2012-08-31
+- Removed `begin()` calls in favor of `XMLBuilder` constructor.
+- Added the `end()` function. `end()` is a convenience over `doc().toString()`.
+
+## [0.4.0] - 2012-08-31
+- Added arguments to `XMLBuilder` constructor to allow the name of the root element and XML prolog to be defined in one line.
+- Soft deprecated `begin()`.
+
+## [0.3.11] - 2012-08-13
+- Package keywords are fixed to be an array of values.
+
+## [0.3.10] - 2012-08-13
+- Brought back npm package contents which were lost due to incorrect configuration of `package.json` in previous releases.
+
+## [0.3.3] - 2012-07-27
+- Implemented `importXMLBuilder()`.
+
+## [0.3.2] - 2012-07-20
+- Fixed a duplicated escaping problem on `element()`.
+- Fixed a problem with text node creation from empty string.
+- Calling `root()` on the document element returns the root element.
+- `XMLBuilder` no longer extends `XMLFragment`.
+
+## [0.3.1] - 2011-11-28
+- Added guards for document element so that nodes cannot be inserted at document level.
+
+## [0.3.0] - 2011-11-28
+- Added `doc()` to return the document element.
+
+## [0.2.2] - 2011-11-28
+- Prevent code relying on `up()`'s older behavior to break.
+
+## [0.2.1] - 2011-11-28
+- Added the `root()` function.
+
+## [0.2.0] - 2011-11-21
+- Added Travis-CI integration.
+- Added coffee-script dependency.
+- Added insert, traversal and delete functions.
+
+## [0.1.7] - 2011-10-25
+- No changes. Accidental release.
+
+## [0.1.6] - 2011-10-25
+- Corrected `package.json` bugs link to `url` from `web`.
+
+## [0.1.5] - 2011-08-08
+- Added missing npm package contents.
+
+## [0.1.4] - 2011-07-29
+- Text-only nodes are no longer indented.
+- Added documentation for multiple instances.
+
+## [0.1.3] - 2011-07-27
+- Exported the `create()` function to return a new instance. This allows multiple builder instances to be constructed.
+- Fixed `u()` function so that it now correctly calls `up()`.
+- Fixed typo in `element()` so that `attributes` and `text` can be passed interchangeably.
+
+## [0.1.2] - 2011-06-03
+- `ele()` accepts element text.
+- `attributes()` now overrides existing attributes if passed the same attribute name.
+
+## [0.1.1] - 2011-05-19
+- Added the raw output option.
+- Removed most validity checks.
+
+## [0.1.0] - 2011-04-27
+- `text()` and `cdata()` now return parent element.
+- Attribute values are escaped.
+
+## [0.0.7] - 2011-04-23
+- Coerced text values to string.
+
+## [0.0.6] - 2011-02-23
+- Added support for XML comments.
+- Text nodes are checked against CharData.
+
+## [0.0.5] - 2010-12-31
+- Corrected the name of the main npm module in `package.json`.
+
+## [0.0.4] - 2010-12-28
+- Added `.npmignore`.
+
+## [0.0.3] - 2010-12-27
+- root element is now constructed in `begin()`.
+- moved prolog to `begin()`.
+- Added the ability to have CDATA in element text.
+- Removed unused prolog aliases.
+- Removed `builder()` function from main module.
+- Added the name of the main npm module in `package.json`.
+
+## [0.0.2] - 2010-11-03
+- `element()` expands nested arrays.
+- Added pretty printing.
+- Added the `up()`, `build()` and `prolog()` functions.
+- Added readme.
+
+## 0.0.1 - 2010-11-02
+- Initial release
+
+[9.0.4]: https://github.com/oozcitak/xmlbuilder-js/compare/v9.0.3...v9.0.4
+[9.0.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v9.0.2...v9.0.3
+[9.0.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v9.0.1...v9.0.2
+[9.0.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v9.0.0...v9.0.1
+[9.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v8.2.2...v9.0.0
+[8.2.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v8.2.1...v8.2.2
+[8.2.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v8.2.0...v8.2.1
+[8.2.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v8.1.0...v8.2.0
+[8.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v8.0.0...v8.1.0
+[8.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v7.0.0...v8.0.0
+[7.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v6.0.0...v7.0.0
+[6.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v5.0.1...v6.0.0
+[5.0.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v5.0.0...v5.0.1
+[5.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v4.2.1...v5.0.0
+[4.2.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v4.2.0...v4.2.1
+[4.2.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v4.1.0...v4.2.0
+[4.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v4.0.0...v4.1.0
+[4.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v3.1.0...v4.0.0
+[3.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v3.0.0...v3.1.0
+[3.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.5...v3.0.0
+[2.6.5]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.4...v2.6.5
+[2.6.4]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.3...v2.6.4
+[2.6.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.2...v2.6.3
+[2.6.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.1...v2.6.2
+[2.6.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.6.0...v2.6.1
+[2.6.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.5.2...v2.6.0
+[2.5.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.5.1...v2.5.2
+[2.5.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.5.0...v2.5.1
+[2.5.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.6...v2.5.0
+[2.4.6]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.5...v2.4.6
+[2.4.5]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.4...v2.4.5
+[2.4.4]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.3...v2.4.4
+[2.4.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.2...v2.4.3
+[2.4.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.1...v2.4.2
+[2.4.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.4.0...v2.4.1
+[2.4.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.3.0...v2.4.0
+[2.3.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.2.1...v2.3.0
+[2.2.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.2.0...v2.2.1
+[2.2.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.1.0...v2.2.0
+[2.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.0.1...v2.1.0
+[2.0.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v2.0.0...v2.0.1
+[2.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.1.2...v2.0.0
+[1.1.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.1.1...v1.1.2
+[1.1.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.1.0...v1.1.1
+[1.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.0.2...v1.1.0
+[1.0.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.0.1...v1.0.2
+[1.0.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.4.3...v1.0.0
+[0.4.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.4.2...v0.4.3
+[0.4.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.11...v0.4.0
+[0.3.11]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.10...v0.3.11
+[0.3.10]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.3...v0.3.10
+[0.3.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.1...v0.3.2
+[0.3.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.2.2...v0.3.0
+[0.2.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.7...v0.2.0
+[0.1.7]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.7...v0.1.0
+[0.0.7]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.6...v0.0.7
+[0.0.6]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.5...v0.0.6
+[0.0.5]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.4...v0.0.5
+[0.0.4]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.3...v0.0.4
+[0.0.3]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.2...v0.0.3
+[0.0.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v0.0.1...v0.0.2
+
diff --git a/node_modules/xmlbuilder/LICENSE b/node_modules/xmlbuilder/LICENSE
new file mode 100644
index 0000000..e7cbac9
--- /dev/null
+++ b/node_modules/xmlbuilder/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Ozgur Ozcitak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/xmlbuilder/README.md b/node_modules/xmlbuilder/README.md
new file mode 100644
index 0000000..785c4dd
--- /dev/null
+++ b/node_modules/xmlbuilder/README.md
@@ -0,0 +1,85 @@
+# xmlbuilder-js
+
+An XML builder for [node.js](https://nodejs.org/) similar to
+[java-xmlbuilder](https://github.com/jmurty/java-xmlbuilder).
+
+[](http://opensource.org/licenses/MIT)
+[](https://npmjs.com/package/xmlbuilder)
+[](https://npmjs.com/package/xmlbuilder)
+
+[](http://travis-ci.org/oozcitak/xmlbuilder-js)
+[](https://david-dm.org/oozcitak/xmlbuilder-js)
+[](https://coveralls.io/github/oozcitak/xmlbuilder-js)
+
+### Installation:
+
+``` sh
+npm install xmlbuilder
+```
+
+### Usage:
+
+``` js
+var builder = require('xmlbuilder');
+var xml = builder.create('root')
+ .ele('xmlbuilder')
+ .ele('repo', {'type': 'git'}, 'git://github.com/oozcitak/xmlbuilder-js.git')
+ .end({ pretty: true});
+
+console.log(xml);
+```
+
+will result in:
+
+``` xml
+<?xml version="1.0"?>
+<root>
+ <xmlbuilder>
+ <repo type="git">git://github.com/oozcitak/xmlbuilder-js.git</repo>
+ </xmlbuilder>
+</root>
+```
+
+It is also possible to convert objects into nodes:
+
+``` js
+builder.create({
+ root: {
+ xmlbuilder: {
+ repo: {
+ '@type': 'git', // attributes start with @
+ '#text': 'git://github.com/oozcitak/xmlbuilder-js.git' // text node
+ }
+ }
+ }
+});
+```
+
+If you need to do some processing:
+
+``` js
+var root = builder.create('squares');
+root.com('f(x) = x^2');
+for(var i = 1; i <= 5; i++)
+{
+ var item = root.ele('data');
+ item.att('x', i);
+ item.att('y', i * i);
+}
+```
+
+This will result in:
+
+``` xml
+<?xml version="1.0"?>
+<squares>
+ <!-- f(x) = x^2 -->
+ <data x="1" y="1"/>
+ <data x="2" y="4"/>
+ <data x="3" y="9"/>
+ <data x="4" y="16"/>
+ <data x="5" y="25"/>
+</squares>
+```
+
+See the [wiki](https://github.com/oozcitak/xmlbuilder-js/wiki) for details and [examples](https://github.com/oozcitak/xmlbuilder-js/wiki/Examples) for more complex examples.
diff --git a/node_modules/xmlbuilder/lib/Utility.js b/node_modules/xmlbuilder/lib/Utility.js
new file mode 100644
index 0000000..ba2deb0
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/Utility.js
@@ -0,0 +1,73 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var assign, isArray, isEmpty, isFunction, isObject, isPlainObject,
+ slice = [].slice,
+ hasProp = {}.hasOwnProperty;
+
+ assign = function() {
+ var i, key, len, source, sources, target;
+ target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+ 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;
+ };
+
+ isFunction = function(val) {
+ return !!val && Object.prototype.toString.call(val) === '[object Function]';
+ };
+
+ isObject = function(val) {
+ var ref;
+ return !!val && ((ref = typeof val) === 'function' || ref === 'object');
+ };
+
+ isArray = function(val) {
+ if (isFunction(Array.isArray)) {
+ return Array.isArray(val);
+ } else {
+ return Object.prototype.toString.call(val) === '[object Array]';
+ }
+ };
+
+ 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;
+ }
+ };
+
+ 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));
+ };
+
+ module.exports.assign = assign;
+
+ module.exports.isFunction = isFunction;
+
+ module.exports.isObject = isObject;
+
+ module.exports.isArray = isArray;
+
+ module.exports.isEmpty = isEmpty;
+
+ module.exports.isPlainObject = isPlainObject;
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLAttribute.js b/node_modules/xmlbuilder/lib/XMLAttribute.js
new file mode 100644
index 0000000..aff7c3d
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLAttribute.js
@@ -0,0 +1,31 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLAttribute;
+
+ module.exports = XMLAttribute = (function() {
+ function XMLAttribute(parent, name, value) {
+ this.options = parent.options;
+ this.stringify = parent.stringify;
+ if (name == null) {
+ throw new Error("Missing attribute name of element " + parent.name);
+ }
+ if (value == null) {
+ throw new Error("Missing attribute value for attribute " + name + " of element " + parent.name);
+ }
+ this.name = this.stringify.attName(name);
+ this.value = this.stringify.attValue(value);
+ }
+
+ XMLAttribute.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLAttribute.prototype.toString = function(options) {
+ return this.options.writer.set(options).attribute(this);
+ };
+
+ return XMLAttribute;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLCData.js b/node_modules/xmlbuilder/lib/XMLCData.js
new file mode 100644
index 0000000..8177ed0
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLCData.js
@@ -0,0 +1,32 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLCData, XMLNode,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLCData = (function(superClass) {
+ extend(XMLCData, superClass);
+
+ function XMLCData(parent, text) {
+ XMLCData.__super__.constructor.call(this, parent);
+ if (text == null) {
+ throw new Error("Missing CDATA text");
+ }
+ this.text = this.stringify.cdata(text);
+ }
+
+ XMLCData.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLCData.prototype.toString = function(options) {
+ return this.options.writer.set(options).cdata(this);
+ };
+
+ return XMLCData;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLComment.js b/node_modules/xmlbuilder/lib/XMLComment.js
new file mode 100644
index 0000000..3b8568f
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLComment.js
@@ -0,0 +1,32 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLComment, XMLNode,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLComment = (function(superClass) {
+ extend(XMLComment, superClass);
+
+ function XMLComment(parent, text) {
+ XMLComment.__super__.constructor.call(this, parent);
+ if (text == null) {
+ throw new Error("Missing comment text");
+ }
+ this.text = this.stringify.comment(text);
+ }
+
+ XMLComment.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLComment.prototype.toString = function(options) {
+ return this.options.writer.set(options).comment(this);
+ };
+
+ return XMLComment;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDTDAttList.js b/node_modules/xmlbuilder/lib/XMLDTDAttList.js
new file mode 100644
index 0000000..9484f15
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDTDAttList.js
@@ -0,0 +1,50 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDTDAttList, XMLNode,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLDTDAttList = (function(superClass) {
+ extend(XMLDTDAttList, superClass);
+
+ function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+ XMLDTDAttList.__super__.constructor.call(this, parent);
+ if (elementName == null) {
+ throw new Error("Missing DTD element name");
+ }
+ if (attributeName == null) {
+ throw new Error("Missing DTD attribute name");
+ }
+ if (!attributeType) {
+ throw new Error("Missing DTD attribute type");
+ }
+ if (!defaultValueType) {
+ throw new Error("Missing DTD attribute default");
+ }
+ if (defaultValueType.indexOf('#') !== 0) {
+ defaultValueType = '#' + defaultValueType;
+ }
+ if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
+ throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT");
+ }
+ if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
+ throw new Error("Default value only applies to #FIXED or #DEFAULT");
+ }
+ this.elementName = this.stringify.eleName(elementName);
+ this.attributeName = this.stringify.attName(attributeName);
+ this.attributeType = this.stringify.dtdAttType(attributeType);
+ this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
+ this.defaultValueType = defaultValueType;
+ }
+
+ XMLDTDAttList.prototype.toString = function(options) {
+ return this.options.writer.set(options).dtdAttList(this);
+ };
+
+ return XMLDTDAttList;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDTDElement.js b/node_modules/xmlbuilder/lib/XMLDTDElement.js
new file mode 100644
index 0000000..e906861
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDTDElement.js
@@ -0,0 +1,35 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDTDElement, XMLNode,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLDTDElement = (function(superClass) {
+ extend(XMLDTDElement, superClass);
+
+ function XMLDTDElement(parent, name, value) {
+ XMLDTDElement.__super__.constructor.call(this, parent);
+ if (name == null) {
+ throw new Error("Missing DTD element name");
+ }
+ if (!value) {
+ value = '(#PCDATA)';
+ }
+ if (Array.isArray(value)) {
+ value = '(' + value.join(',') + ')';
+ }
+ this.name = this.stringify.eleName(name);
+ this.value = this.stringify.dtdElementValue(value);
+ }
+
+ XMLDTDElement.prototype.toString = function(options) {
+ return this.options.writer.set(options).dtdElement(this);
+ };
+
+ return XMLDTDElement;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDTDEntity.js b/node_modules/xmlbuilder/lib/XMLDTDEntity.js
new file mode 100644
index 0000000..505f733
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDTDEntity.js
@@ -0,0 +1,56 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDTDEntity, XMLNode, isObject,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ isObject = require('./Utility').isObject;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLDTDEntity = (function(superClass) {
+ extend(XMLDTDEntity, superClass);
+
+ function XMLDTDEntity(parent, pe, name, value) {
+ XMLDTDEntity.__super__.constructor.call(this, parent);
+ if (name == null) {
+ throw new Error("Missing entity name");
+ }
+ if (value == null) {
+ throw new Error("Missing entity value");
+ }
+ this.pe = !!pe;
+ this.name = this.stringify.eleName(name);
+ if (!isObject(value)) {
+ this.value = this.stringify.dtdEntityValue(value);
+ } else {
+ if (!value.pubID && !value.sysID) {
+ throw new Error("Public and/or system identifiers are required for an external entity");
+ }
+ if (value.pubID && !value.sysID) {
+ throw new Error("System identifier is required for a public external entity");
+ }
+ if (value.pubID != null) {
+ this.pubID = this.stringify.dtdPubID(value.pubID);
+ }
+ if (value.sysID != null) {
+ this.sysID = this.stringify.dtdSysID(value.sysID);
+ }
+ if (value.nData != null) {
+ this.nData = this.stringify.dtdNData(value.nData);
+ }
+ if (this.pe && this.nData) {
+ throw new Error("Notation declaration is not allowed in a parameter entity");
+ }
+ }
+ }
+
+ XMLDTDEntity.prototype.toString = function(options) {
+ return this.options.writer.set(options).dtdEntity(this);
+ };
+
+ return XMLDTDEntity;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDTDNotation.js b/node_modules/xmlbuilder/lib/XMLDTDNotation.js
new file mode 100644
index 0000000..b82f628
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDTDNotation.js
@@ -0,0 +1,37 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDTDNotation, XMLNode,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLDTDNotation = (function(superClass) {
+ extend(XMLDTDNotation, superClass);
+
+ function XMLDTDNotation(parent, name, value) {
+ XMLDTDNotation.__super__.constructor.call(this, parent);
+ if (name == null) {
+ throw new Error("Missing notation name");
+ }
+ if (!value.pubID && !value.sysID) {
+ throw new Error("Public or system identifiers are required for an external entity");
+ }
+ this.name = this.stringify.eleName(name);
+ if (value.pubID != null) {
+ this.pubID = this.stringify.dtdPubID(value.pubID);
+ }
+ if (value.sysID != null) {
+ this.sysID = this.stringify.dtdSysID(value.sysID);
+ }
+ }
+
+ XMLDTDNotation.prototype.toString = function(options) {
+ return this.options.writer.set(options).dtdNotation(this);
+ };
+
+ return XMLDTDNotation;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDeclaration.js b/node_modules/xmlbuilder/lib/XMLDeclaration.js
new file mode 100644
index 0000000..e24a803
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDeclaration.js
@@ -0,0 +1,40 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDeclaration, XMLNode, isObject,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ isObject = require('./Utility').isObject;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLDeclaration = (function(superClass) {
+ extend(XMLDeclaration, superClass);
+
+ function XMLDeclaration(parent, version, encoding, standalone) {
+ var ref;
+ XMLDeclaration.__super__.constructor.call(this, parent);
+ if (isObject(version)) {
+ ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
+ }
+ if (!version) {
+ version = '1.0';
+ }
+ this.version = this.stringify.xmlVersion(version);
+ if (encoding != null) {
+ this.encoding = this.stringify.xmlEncoding(encoding);
+ }
+ if (standalone != null) {
+ this.standalone = this.stringify.xmlStandalone(standalone);
+ }
+ }
+
+ XMLDeclaration.prototype.toString = function(options) {
+ return this.options.writer.set(options).declaration(this);
+ };
+
+ return XMLDeclaration;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDocType.js b/node_modules/xmlbuilder/lib/XMLDocType.js
new file mode 100644
index 0000000..b5e4536
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDocType.js
@@ -0,0 +1,107 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNode, isObject,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ isObject = require('./Utility').isObject;
+
+ XMLNode = require('./XMLNode');
+
+ XMLDTDAttList = require('./XMLDTDAttList');
+
+ XMLDTDEntity = require('./XMLDTDEntity');
+
+ XMLDTDElement = require('./XMLDTDElement');
+
+ XMLDTDNotation = require('./XMLDTDNotation');
+
+ module.exports = XMLDocType = (function(superClass) {
+ extend(XMLDocType, superClass);
+
+ function XMLDocType(parent, pubID, sysID) {
+ var ref, ref1;
+ XMLDocType.__super__.constructor.call(this, parent);
+ this.documentObject = parent;
+ if (isObject(pubID)) {
+ ref = pubID, pubID = ref.pubID, sysID = ref.sysID;
+ }
+ if (sysID == null) {
+ ref1 = [pubID, sysID], sysID = ref1[0], pubID = ref1[1];
+ }
+ if (pubID != null) {
+ this.pubID = this.stringify.dtdPubID(pubID);
+ }
+ if (sysID != null) {
+ this.sysID = this.stringify.dtdSysID(sysID);
+ }
+ }
+
+ XMLDocType.prototype.element = function(name, value) {
+ var child;
+ child = new XMLDTDElement(this, name, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+ var child;
+ child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLDocType.prototype.entity = function(name, value) {
+ var child;
+ child = new XMLDTDEntity(this, false, name, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLDocType.prototype.pEntity = function(name, value) {
+ var child;
+ child = new XMLDTDEntity(this, true, name, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLDocType.prototype.notation = function(name, value) {
+ var child;
+ child = new XMLDTDNotation(this, name, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLDocType.prototype.toString = function(options) {
+ return this.options.writer.set(options).docType(this);
+ };
+
+ XMLDocType.prototype.ele = function(name, value) {
+ return this.element(name, value);
+ };
+
+ XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+ return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
+ };
+
+ XMLDocType.prototype.ent = function(name, value) {
+ return this.entity(name, value);
+ };
+
+ XMLDocType.prototype.pent = function(name, value) {
+ return this.pEntity(name, value);
+ };
+
+ XMLDocType.prototype.not = function(name, value) {
+ return this.notation(name, value);
+ };
+
+ XMLDocType.prototype.up = function() {
+ return this.root() || this.documentObject;
+ };
+
+ return XMLDocType;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDocument.js b/node_modules/xmlbuilder/lib/XMLDocument.js
new file mode 100644
index 0000000..a61cb8c
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDocument.js
@@ -0,0 +1,48 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ isPlainObject = require('./Utility').isPlainObject;
+
+ XMLNode = require('./XMLNode');
+
+ XMLStringifier = require('./XMLStringifier');
+
+ XMLStringWriter = require('./XMLStringWriter');
+
+ module.exports = XMLDocument = (function(superClass) {
+ extend(XMLDocument, superClass);
+
+ function XMLDocument(options) {
+ XMLDocument.__super__.constructor.call(this, null);
+ options || (options = {});
+ if (!options.writer) {
+ options.writer = new XMLStringWriter();
+ }
+ this.options = options;
+ this.stringify = new XMLStringifier(options);
+ this.isDocument = true;
+ }
+
+ XMLDocument.prototype.end = function(writer) {
+ var writerOptions;
+ if (!writer) {
+ writer = this.options.writer;
+ } else if (isPlainObject(writer)) {
+ writerOptions = writer;
+ writer = this.options.writer.set(writerOptions);
+ }
+ return writer.document(this);
+ };
+
+ XMLDocument.prototype.toString = function(options) {
+ return this.options.writer.set(options).document(this);
+ };
+
+ return XMLDocument;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLDocumentCB.js b/node_modules/xmlbuilder/lib/XMLDocumentCB.js
new file mode 100644
index 0000000..71528f3
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLDocumentCB.js
@@ -0,0 +1,402 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, isFunction, isObject, isPlainObject, ref,
+ hasProp = {}.hasOwnProperty;
+
+ ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject;
+
+ 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');
+
+ module.exports = XMLDocumentCB = (function() {
+ function XMLDocumentCB(options, onData, onEnd) {
+ var writerOptions;
+ options || (options = {});
+ if (!options.writer) {
+ options.writer = new XMLStringWriter(options);
+ } else if (isPlainObject(options.writer)) {
+ writerOptions = options.writer;
+ options.writer = new XMLStringWriter(writerOptions);
+ }
+ this.options = options;
+ this.writer = options.writer;
+ 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;
+ }
+
+ XMLDocumentCB.prototype.node = function(name, attributes, text) {
+ var ref1;
+ 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.openCurrent();
+ name = name.valueOf();
+ if (attributes == null) {
+ attributes = {};
+ }
+ attributes = attributes.valueOf();
+ if (!isObject(attributes)) {
+ ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
+ }
+ 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;
+ };
+
+ XMLDocumentCB.prototype.element = function(name, attributes, text) {
+ if (this.currentNode && this.currentNode instanceof XMLDocType) {
+ return this.dtdElement.apply(this, arguments);
+ } else {
+ return this.node(name, attributes, text);
+ }
+ };
+
+ XMLDocumentCB.prototype.attribute = function(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");
+ }
+ if (name != null) {
+ name = name.valueOf();
+ }
+ if (isObject(name)) {
+ for (attName in name) {
+ if (!hasProp.call(name, attName)) continue;
+ attValue = name[attName];
+ this.attribute(attName, attValue);
+ }
+ } else {
+ if (isFunction(value)) {
+ value = value.apply();
+ }
+ if (!this.options.skipNullAttributes || (value != null)) {
+ this.currentNode.attributes[name] = new XMLAttribute(this, name, value);
+ }
+ }
+ return this;
+ };
+
+ XMLDocumentCB.prototype.text = function(value) {
+ var node;
+ this.openCurrent();
+ node = new XMLText(this, value);
+ this.onData(this.writer.text(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.cdata = function(value) {
+ var node;
+ this.openCurrent();
+ node = new XMLCData(this, value);
+ this.onData(this.writer.cdata(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.comment = function(value) {
+ var node;
+ this.openCurrent();
+ node = new XMLComment(this, value);
+ this.onData(this.writer.comment(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.raw = function(value) {
+ var node;
+ this.openCurrent();
+ node = new XMLRaw(this, value);
+ this.onData(this.writer.raw(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.instruction = function(target, value) {
+ var i, insTarget, insValue, len, node;
+ this.openCurrent();
+ if (target != null) {
+ target = target.valueOf();
+ }
+ if (value != null) {
+ value = value.valueOf();
+ }
+ if (Array.isArray(target)) {
+ for (i = 0, len = target.length; i < len; i++) {
+ insTarget = target[i];
+ this.instruction(insTarget);
+ }
+ } else if (isObject(target)) {
+ for (insTarget in target) {
+ if (!hasProp.call(target, insTarget)) continue;
+ insValue = target[insTarget];
+ this.instruction(insTarget, insValue);
+ }
+ } else {
+ if (isFunction(value)) {
+ value = value.apply();
+ }
+ node = new XMLProcessingInstruction(this, target, value);
+ this.onData(this.writer.processingInstruction(node, this.currentLevel + 1));
+ }
+ return this;
+ };
+
+ XMLDocumentCB.prototype.declaration = function(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.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.doctype = function(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;
+ };
+
+ XMLDocumentCB.prototype.dtdElement = function(name, value) {
+ var node;
+ this.openCurrent();
+ node = new XMLDTDElement(this, name, value);
+ this.onData(this.writer.dtdElement(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.attList = function(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.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.entity = function(name, value) {
+ var node;
+ this.openCurrent();
+ node = new XMLDTDEntity(this, false, name, value);
+ this.onData(this.writer.dtdEntity(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.pEntity = function(name, value) {
+ var node;
+ this.openCurrent();
+ node = new XMLDTDEntity(this, true, name, value);
+ this.onData(this.writer.dtdEntity(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.notation = function(name, value) {
+ var node;
+ this.openCurrent();
+ node = new XMLDTDNotation(this, name, value);
+ this.onData(this.writer.dtdNotation(node, this.currentLevel + 1));
+ return this;
+ };
+
+ XMLDocumentCB.prototype.up = function() {
+ 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;
+ };
+
+ XMLDocumentCB.prototype.end = function() {
+ while (this.currentLevel >= 0) {
+ this.up();
+ }
+ return this.onEnd();
+ };
+
+ XMLDocumentCB.prototype.openCurrent = function() {
+ if (this.currentNode) {
+ this.currentNode.children = true;
+ return this.openNode(this.currentNode);
+ }
+ };
+
+ XMLDocumentCB.prototype.openNode = function(node) {
+ if (!node.isOpen) {
+ if (!this.root && this.currentLevel === 0 && node instanceof XMLElement) {
+ this.root = node;
+ }
+ this.onData(this.writer.openNode(node, this.currentLevel));
+ return node.isOpen = true;
+ }
+ };
+
+ XMLDocumentCB.prototype.closeNode = function(node) {
+ if (!node.isClosed) {
+ this.onData(this.writer.closeNode(node, this.currentLevel));
+ return node.isClosed = true;
+ }
+ };
+
+ XMLDocumentCB.prototype.onData = function(chunk) {
+ this.documentStarted = true;
+ return this.onDataCallback(chunk);
+ };
+
+ XMLDocumentCB.prototype.onEnd = function() {
+ this.documentCompleted = true;
+ return this.onEndCallback();
+ };
+
+ XMLDocumentCB.prototype.ele = function() {
+ return this.element.apply(this, arguments);
+ };
+
+ XMLDocumentCB.prototype.nod = function(name, attributes, text) {
+ return this.node(name, attributes, text);
+ };
+
+ XMLDocumentCB.prototype.txt = function(value) {
+ return this.text(value);
+ };
+
+ XMLDocumentCB.prototype.dat = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLDocumentCB.prototype.com = function(value) {
+ return this.comment(value);
+ };
+
+ XMLDocumentCB.prototype.ins = function(target, value) {
+ return this.instruction(target, value);
+ };
+
+ XMLDocumentCB.prototype.dec = function(version, encoding, standalone) {
+ return this.declaration(version, encoding, standalone);
+ };
+
+ XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) {
+ return this.doctype(root, pubID, sysID);
+ };
+
+ XMLDocumentCB.prototype.e = function(name, attributes, text) {
+ return this.element(name, attributes, text);
+ };
+
+ XMLDocumentCB.prototype.n = function(name, attributes, text) {
+ return this.node(name, attributes, text);
+ };
+
+ XMLDocumentCB.prototype.t = function(value) {
+ return this.text(value);
+ };
+
+ XMLDocumentCB.prototype.d = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLDocumentCB.prototype.c = function(value) {
+ return this.comment(value);
+ };
+
+ XMLDocumentCB.prototype.r = function(value) {
+ return this.raw(value);
+ };
+
+ XMLDocumentCB.prototype.i = function(target, value) {
+ return this.instruction(target, value);
+ };
+
+ XMLDocumentCB.prototype.att = function() {
+ if (this.currentNode && this.currentNode instanceof XMLDocType) {
+ return this.attList.apply(this, arguments);
+ } else {
+ return this.attribute.apply(this, arguments);
+ }
+ };
+
+ XMLDocumentCB.prototype.a = function() {
+ if (this.currentNode && this.currentNode instanceof XMLDocType) {
+ return this.attList.apply(this, arguments);
+ } else {
+ return this.attribute.apply(this, arguments);
+ }
+ };
+
+ XMLDocumentCB.prototype.ent = function(name, value) {
+ return this.entity(name, value);
+ };
+
+ XMLDocumentCB.prototype.pent = function(name, value) {
+ return this.pEntity(name, value);
+ };
+
+ XMLDocumentCB.prototype.not = function(name, value) {
+ return this.notation(name, value);
+ };
+
+ return XMLDocumentCB;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLElement.js b/node_modules/xmlbuilder/lib/XMLElement.js
new file mode 100644
index 0000000..f388fe6
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLElement.js
@@ -0,0 +1,111 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLAttribute, XMLElement, XMLNode, isFunction, isObject, ref,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction;
+
+ XMLNode = require('./XMLNode');
+
+ XMLAttribute = require('./XMLAttribute');
+
+ module.exports = XMLElement = (function(superClass) {
+ extend(XMLElement, superClass);
+
+ function XMLElement(parent, name, attributes) {
+ XMLElement.__super__.constructor.call(this, parent);
+ if (name == null) {
+ throw new Error("Missing element name");
+ }
+ this.name = this.stringify.eleName(name);
+ this.attributes = {};
+ if (attributes != null) {
+ this.attribute(attributes);
+ }
+ if (parent.isDocument) {
+ this.isRoot = true;
+ this.documentObject = parent;
+ parent.rootObject = this;
+ }
+ }
+
+ XMLElement.prototype.clone = function() {
+ var att, attName, clonedSelf, ref1;
+ clonedSelf = Object.create(this);
+ if (clonedSelf.isRoot) {
+ clonedSelf.documentObject = null;
+ }
+ clonedSelf.attributes = {};
+ ref1 = this.attributes;
+ for (attName in ref1) {
+ if (!hasProp.call(ref1, attName)) continue;
+ att = ref1[attName];
+ clonedSelf.attributes[attName] = att.clone();
+ }
+ clonedSelf.children = [];
+ this.children.forEach(function(child) {
+ var clonedChild;
+ clonedChild = child.clone();
+ clonedChild.parent = clonedSelf;
+ return clonedSelf.children.push(clonedChild);
+ });
+ return clonedSelf;
+ };
+
+ XMLElement.prototype.attribute = function(name, value) {
+ var attName, attValue;
+ if (name != null) {
+ name = name.valueOf();
+ }
+ if (isObject(name)) {
+ for (attName in name) {
+ if (!hasProp.call(name, attName)) continue;
+ attValue = name[attName];
+ this.attribute(attName, attValue);
+ }
+ } else {
+ if (isFunction(value)) {
+ value = value.apply();
+ }
+ if (!this.options.skipNullAttributes || (value != null)) {
+ this.attributes[name] = new XMLAttribute(this, name, value);
+ }
+ }
+ return this;
+ };
+
+ XMLElement.prototype.removeAttribute = function(name) {
+ var attName, i, len;
+ if (name == null) {
+ throw new Error("Missing attribute name");
+ }
+ name = name.valueOf();
+ if (Array.isArray(name)) {
+ for (i = 0, len = name.length; i < len; i++) {
+ attName = name[i];
+ delete this.attributes[attName];
+ }
+ } else {
+ delete this.attributes[name];
+ }
+ return this;
+ };
+
+ XMLElement.prototype.toString = function(options) {
+ return this.options.writer.set(options).element(this);
+ };
+
+ XMLElement.prototype.att = function(name, value) {
+ return this.attribute(name, value);
+ };
+
+ XMLElement.prototype.a = function(name, value) {
+ return this.attribute(name, value);
+ };
+
+ return XMLElement;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLNode.js b/node_modules/xmlbuilder/lib/XMLNode.js
new file mode 100644
index 0000000..96215b8
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLNode.js
@@ -0,0 +1,432 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLElement, XMLNode, XMLProcessingInstruction, XMLRaw, XMLText, isEmpty, isFunction, isObject, ref,
+ hasProp = {}.hasOwnProperty;
+
+ ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, isEmpty = ref.isEmpty;
+
+ XMLElement = null;
+
+ XMLCData = null;
+
+ XMLComment = null;
+
+ XMLDeclaration = null;
+
+ XMLDocType = null;
+
+ XMLRaw = null;
+
+ XMLText = null;
+
+ XMLProcessingInstruction = null;
+
+ module.exports = XMLNode = (function() {
+ function XMLNode(parent) {
+ this.parent = parent;
+ if (this.parent) {
+ this.options = this.parent.options;
+ this.stringify = this.parent.stringify;
+ }
+ this.children = [];
+ 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');
+ }
+ }
+
+ XMLNode.prototype.element = function(name, attributes, text) {
+ var childNode, item, j, k, key, lastChild, len, len1, ref1, val;
+ lastChild = null;
+ if (attributes == null) {
+ attributes = {};
+ }
+ attributes = attributes.valueOf();
+ if (!isObject(attributes)) {
+ ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
+ }
+ if (name != null) {
+ name = name.valueOf();
+ }
+ if (Array.isArray(name)) {
+ for (j = 0, len = name.length; j < len; j++) {
+ item = name[j];
+ lastChild = this.element(item);
+ }
+ } else if (isFunction(name)) {
+ lastChild = this.element(name.apply());
+ } else if (isObject(name)) {
+ for (key in name) {
+ if (!hasProp.call(name, key)) continue;
+ val = name[key];
+ if (isFunction(val)) {
+ val = val.apply();
+ }
+ if ((isObject(val)) && (isEmpty(val))) {
+ val = null;
+ }
+ if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
+ lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
+ } else if (!this.options.separateArrayItems && Array.isArray(val)) {
+ for (k = 0, len1 = val.length; k < len1; k++) {
+ item = val[k];
+ childNode = {};
+ childNode[key] = item;
+ lastChild = this.element(childNode);
+ }
+ } else if (isObject(val)) {
+ lastChild = this.element(key);
+ lastChild.element(val);
+ } else {
+ lastChild = this.element(key, val);
+ }
+ }
+ } else {
+ if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
+ lastChild = this.text(text);
+ } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
+ lastChild = this.cdata(text);
+ } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
+ lastChild = this.comment(text);
+ } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
+ lastChild = this.raw(text);
+ } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
+ lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
+ } else {
+ lastChild = this.node(name, attributes, text);
+ }
+ }
+ if (lastChild == null) {
+ throw new Error("Could not create any elements with: " + name);
+ }
+ return lastChild;
+ };
+
+ XMLNode.prototype.insertBefore = function(name, attributes, text) {
+ var child, i, removed;
+ if (this.isRoot) {
+ throw new Error("Cannot insert elements at root level");
+ }
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i);
+ child = this.parent.element(name, attributes, text);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return child;
+ };
+
+ XMLNode.prototype.insertAfter = function(name, attributes, text) {
+ var child, i, removed;
+ if (this.isRoot) {
+ throw new Error("Cannot insert elements at root level");
+ }
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i + 1);
+ child = this.parent.element(name, attributes, text);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return child;
+ };
+
+ XMLNode.prototype.remove = function() {
+ var i, ref1;
+ if (this.isRoot) {
+ throw new Error("Cannot remove the root element");
+ }
+ i = this.parent.children.indexOf(this);
+ [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref1 = [])), ref1;
+ return this.parent;
+ };
+
+ XMLNode.prototype.node = function(name, attributes, text) {
+ var child, ref1;
+ if (name != null) {
+ name = name.valueOf();
+ }
+ attributes || (attributes = {});
+ attributes = attributes.valueOf();
+ if (!isObject(attributes)) {
+ ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
+ }
+ child = new XMLElement(this, name, attributes);
+ if (text != null) {
+ child.text(text);
+ }
+ this.children.push(child);
+ return child;
+ };
+
+ XMLNode.prototype.text = function(value) {
+ var child;
+ child = new XMLText(this, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLNode.prototype.cdata = function(value) {
+ var child;
+ child = new XMLCData(this, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLNode.prototype.comment = function(value) {
+ var child;
+ child = new XMLComment(this, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLNode.prototype.commentBefore = function(value) {
+ var child, i, removed;
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i);
+ child = this.parent.comment(value);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return this;
+ };
+
+ XMLNode.prototype.commentAfter = function(value) {
+ var child, i, removed;
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i + 1);
+ child = this.parent.comment(value);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return this;
+ };
+
+ XMLNode.prototype.raw = function(value) {
+ var child;
+ child = new XMLRaw(this, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLNode.prototype.instruction = function(target, value) {
+ var insTarget, insValue, instruction, j, len;
+ if (target != null) {
+ target = target.valueOf();
+ }
+ if (value != null) {
+ value = value.valueOf();
+ }
+ if (Array.isArray(target)) {
+ for (j = 0, len = target.length; j < len; j++) {
+ insTarget = target[j];
+ this.instruction(insTarget);
+ }
+ } else if (isObject(target)) {
+ for (insTarget in target) {
+ if (!hasProp.call(target, insTarget)) continue;
+ insValue = target[insTarget];
+ this.instruction(insTarget, insValue);
+ }
+ } else {
+ if (isFunction(value)) {
+ value = value.apply();
+ }
+ instruction = new XMLProcessingInstruction(this, target, value);
+ this.children.push(instruction);
+ }
+ return this;
+ };
+
+ XMLNode.prototype.instructionBefore = function(target, value) {
+ var child, i, removed;
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i);
+ child = this.parent.instruction(target, value);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return this;
+ };
+
+ XMLNode.prototype.instructionAfter = function(target, value) {
+ var child, i, removed;
+ i = this.parent.children.indexOf(this);
+ removed = this.parent.children.splice(i + 1);
+ child = this.parent.instruction(target, value);
+ Array.prototype.push.apply(this.parent.children, removed);
+ return this;
+ };
+
+ XMLNode.prototype.declaration = function(version, encoding, standalone) {
+ var doc, xmldec;
+ doc = this.document();
+ xmldec = new XMLDeclaration(doc, version, encoding, standalone);
+ if (doc.children[0] instanceof XMLDeclaration) {
+ doc.children[0] = xmldec;
+ } else {
+ doc.children.unshift(xmldec);
+ }
+ return doc.root() || doc;
+ };
+
+ XMLNode.prototype.doctype = function(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;
+ for (i = j = 0, len = ref1.length; j < len; i = ++j) {
+ child = ref1[i];
+ if (child instanceof XMLDocType) {
+ doc.children[i] = doctype;
+ return doctype;
+ }
+ }
+ ref2 = doc.children;
+ 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;
+ }
+ }
+ doc.children.push(doctype);
+ return doctype;
+ };
+
+ XMLNode.prototype.up = function() {
+ if (this.isRoot) {
+ throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
+ }
+ return this.parent;
+ };
+
+ XMLNode.prototype.root = function() {
+ var node;
+ node = this;
+ while (node) {
+ if (node.isDocument) {
+ return node.rootObject;
+ } else if (node.isRoot) {
+ return node;
+ } else {
+ node = node.parent;
+ }
+ }
+ };
+
+ XMLNode.prototype.document = function() {
+ var node;
+ node = this;
+ while (node) {
+ if (node.isDocument) {
+ return node;
+ } else {
+ node = node.parent;
+ }
+ }
+ };
+
+ XMLNode.prototype.end = function(options) {
+ return this.document().end(options);
+ };
+
+ XMLNode.prototype.prev = function() {
+ var i;
+ i = this.parent.children.indexOf(this);
+ if (i < 1) {
+ throw new Error("Already at the first node");
+ }
+ return this.parent.children[i - 1];
+ };
+
+ XMLNode.prototype.next = function() {
+ var i;
+ i = this.parent.children.indexOf(this);
+ if (i === -1 || i === this.parent.children.length - 1) {
+ throw new Error("Already at the last node");
+ }
+ return this.parent.children[i + 1];
+ };
+
+ XMLNode.prototype.importDocument = function(doc) {
+ var clonedRoot;
+ clonedRoot = doc.root().clone();
+ clonedRoot.parent = this;
+ clonedRoot.isRoot = false;
+ this.children.push(clonedRoot);
+ return this;
+ };
+
+ XMLNode.prototype.ele = function(name, attributes, text) {
+ return this.element(name, attributes, text);
+ };
+
+ XMLNode.prototype.nod = function(name, attributes, text) {
+ return this.node(name, attributes, text);
+ };
+
+ XMLNode.prototype.txt = function(value) {
+ return this.text(value);
+ };
+
+ XMLNode.prototype.dat = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLNode.prototype.com = function(value) {
+ return this.comment(value);
+ };
+
+ XMLNode.prototype.ins = function(target, value) {
+ return this.instruction(target, value);
+ };
+
+ XMLNode.prototype.doc = function() {
+ return this.document();
+ };
+
+ XMLNode.prototype.dec = function(version, encoding, standalone) {
+ return this.declaration(version, encoding, standalone);
+ };
+
+ XMLNode.prototype.dtd = function(pubID, sysID) {
+ return this.doctype(pubID, sysID);
+ };
+
+ XMLNode.prototype.e = function(name, attributes, text) {
+ return this.element(name, attributes, text);
+ };
+
+ XMLNode.prototype.n = function(name, attributes, text) {
+ return this.node(name, attributes, text);
+ };
+
+ XMLNode.prototype.t = function(value) {
+ return this.text(value);
+ };
+
+ XMLNode.prototype.d = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLNode.prototype.c = function(value) {
+ return this.comment(value);
+ };
+
+ XMLNode.prototype.r = function(value) {
+ return this.raw(value);
+ };
+
+ XMLNode.prototype.i = function(target, value) {
+ return this.instruction(target, value);
+ };
+
+ XMLNode.prototype.u = function() {
+ return this.up();
+ };
+
+ XMLNode.prototype.importXMLBuilder = function(doc) {
+ return this.importDocument(doc);
+ };
+
+ return XMLNode;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js b/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
new file mode 100644
index 0000000..0f3b9ec
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
@@ -0,0 +1,35 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLNode, XMLProcessingInstruction,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLProcessingInstruction = (function(superClass) {
+ extend(XMLProcessingInstruction, superClass);
+
+ function XMLProcessingInstruction(parent, target, value) {
+ XMLProcessingInstruction.__super__.constructor.call(this, parent);
+ if (target == null) {
+ throw new Error("Missing instruction target");
+ }
+ this.target = this.stringify.insTarget(target);
+ if (value) {
+ this.value = this.stringify.insValue(value);
+ }
+ }
+
+ XMLProcessingInstruction.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLProcessingInstruction.prototype.toString = function(options) {
+ return this.options.writer.set(options).processingInstruction(this);
+ };
+
+ return XMLProcessingInstruction;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLRaw.js b/node_modules/xmlbuilder/lib/XMLRaw.js
new file mode 100644
index 0000000..0957ebb
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLRaw.js
@@ -0,0 +1,32 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLNode, XMLRaw,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLRaw = (function(superClass) {
+ extend(XMLRaw, superClass);
+
+ function XMLRaw(parent, text) {
+ XMLRaw.__super__.constructor.call(this, parent);
+ if (text == null) {
+ throw new Error("Missing raw text");
+ }
+ this.value = this.stringify.raw(text);
+ }
+
+ XMLRaw.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLRaw.prototype.toString = function(options) {
+ return this.options.writer.set(options).raw(this);
+ };
+
+ return XMLRaw;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLStreamWriter.js b/node_modules/xmlbuilder/lib/XMLStreamWriter.js
new file mode 100644
index 0000000..5e33226
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLStreamWriter.js
@@ -0,0 +1,279 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStreamWriter, XMLText, XMLWriterBase,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLDeclaration = require('./XMLDeclaration');
+
+ XMLDocType = require('./XMLDocType');
+
+ XMLCData = require('./XMLCData');
+
+ XMLComment = require('./XMLComment');
+
+ XMLElement = require('./XMLElement');
+
+ XMLRaw = require('./XMLRaw');
+
+ XMLText = require('./XMLText');
+
+ XMLProcessingInstruction = require('./XMLProcessingInstruction');
+
+ XMLDTDAttList = require('./XMLDTDAttList');
+
+ XMLDTDElement = require('./XMLDTDElement');
+
+ XMLDTDEntity = require('./XMLDTDEntity');
+
+ XMLDTDNotation = require('./XMLDTDNotation');
+
+ XMLWriterBase = require('./XMLWriterBase');
+
+ module.exports = XMLStreamWriter = (function(superClass) {
+ extend(XMLStreamWriter, superClass);
+
+ function XMLStreamWriter(stream, options) {
+ this.stream = stream;
+ XMLStreamWriter.__super__.constructor.call(this, options);
+ }
+
+ XMLStreamWriter.prototype.document = function(doc) {
+ var child, i, j, len, len1, ref, ref1, results;
+ ref = doc.children;
+ for (i = 0, len = ref.length; i < len; i++) {
+ child = ref[i];
+ child.isLastRootNode = false;
+ }
+ doc.children[doc.children.length - 1].isLastRootNode = true;
+ ref1 = doc.children;
+ results = [];
+ for (j = 0, len1 = ref1.length; j < len1; j++) {
+ child = ref1[j];
+ switch (false) {
+ case !(child instanceof XMLDeclaration):
+ results.push(this.declaration(child));
+ break;
+ case !(child instanceof XMLDocType):
+ results.push(this.docType(child));
+ break;
+ case !(child instanceof XMLComment):
+ results.push(this.comment(child));
+ break;
+ case !(child instanceof XMLProcessingInstruction):
+ results.push(this.processingInstruction(child));
+ break;
+ default:
+ results.push(this.element(child));
+ }
+ }
+ return results;
+ };
+
+ XMLStreamWriter.prototype.attribute = function(att) {
+ return this.stream.write(' ' + att.name + '="' + att.value + '"');
+ };
+
+ XMLStreamWriter.prototype.cdata = function(node, level) {
+ return this.stream.write(this.space(level) + '<![CDATA[' + node.text + ']]>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.comment = function(node, level) {
+ return this.stream.write(this.space(level) + '<!-- ' + node.text + ' -->' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.declaration = function(node, level) {
+ this.stream.write(this.space(level));
+ this.stream.write('<?xml version="' + node.version + '"');
+ if (node.encoding != null) {
+ this.stream.write(' encoding="' + node.encoding + '"');
+ }
+ if (node.standalone != null) {
+ this.stream.write(' standalone="' + node.standalone + '"');
+ }
+ this.stream.write(this.spacebeforeslash + '?>');
+ return this.stream.write(this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.docType = function(node, level) {
+ var child, i, len, ref;
+ level || (level = 0);
+ this.stream.write(this.space(level));
+ this.stream.write('<!DOCTYPE ' + node.root().name);
+ if (node.pubID && node.sysID) {
+ this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
+ } else if (node.sysID) {
+ this.stream.write(' SYSTEM "' + node.sysID + '"');
+ }
+ if (node.children.length > 0) {
+ this.stream.write(' [');
+ this.stream.write(this.endline(node));
+ ref = node.children;
+ for (i = 0, len = ref.length; i < len; i++) {
+ child = ref[i];
+ switch (false) {
+ case !(child instanceof XMLDTDAttList):
+ this.dtdAttList(child, level + 1);
+ break;
+ case !(child instanceof XMLDTDElement):
+ this.dtdElement(child, level + 1);
+ break;
+ case !(child instanceof XMLDTDEntity):
+ this.dtdEntity(child, level + 1);
+ break;
+ case !(child instanceof XMLDTDNotation):
+ this.dtdNotation(child, level + 1);
+ break;
+ case !(child instanceof XMLCData):
+ this.cdata(child, level + 1);
+ break;
+ case !(child instanceof XMLComment):
+ this.comment(child, level + 1);
+ break;
+ case !(child instanceof XMLProcessingInstruction):
+ this.processingInstruction(child, level + 1);
+ break;
+ default:
+ throw new Error("Unknown DTD node type: " + child.constructor.name);
+ }
+ }
+ this.stream.write(']');
+ }
+ this.stream.write(this.spacebeforeslash + '>');
+ return this.stream.write(this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.element = function(node, level) {
+ var att, child, i, len, name, ref, ref1, space;
+ level || (level = 0);
+ space = this.space(level);
+ this.stream.write(space + '<' + node.name);
+ ref = node.attributes;
+ for (name in ref) {
+ if (!hasProp.call(ref, name)) continue;
+ att = ref[name];
+ this.attribute(att);
+ }
+ if (node.children.length === 0 || node.children.every(function(e) {
+ return e.value === '';
+ })) {
+ if (this.allowEmpty) {
+ this.stream.write('></' + node.name + '>');
+ } else {
+ this.stream.write(this.spacebeforeslash + '/>');
+ }
+ } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
+ this.stream.write('>');
+ this.stream.write(node.children[0].value);
+ this.stream.write('</' + node.name + '>');
+ } else {
+ this.stream.write('>' + this.newline);
+ ref1 = node.children;
+ for (i = 0, len = ref1.length; i < len; i++) {
+ child = ref1[i];
+ switch (false) {
+ case !(child instanceof XMLCData):
+ this.cdata(child, level + 1);
+ break;
+ case !(child instanceof XMLComment):
+ this.comment(child, level + 1);
+ break;
+ case !(child instanceof XMLElement):
+ this.element(child, level + 1);
+ break;
+ case !(child instanceof XMLRaw):
+ this.raw(child, level + 1);
+ break;
+ case !(child instanceof XMLText):
+ this.text(child, level + 1);
+ break;
+ case !(child instanceof XMLProcessingInstruction):
+ this.processingInstruction(child, level + 1);
+ break;
+ default:
+ throw new Error("Unknown XML node type: " + child.constructor.name);
+ }
+ }
+ this.stream.write(space + '</' + node.name + '>');
+ }
+ return this.stream.write(this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.processingInstruction = function(node, level) {
+ this.stream.write(this.space(level) + '<?' + node.target);
+ if (node.value) {
+ this.stream.write(' ' + node.value);
+ }
+ return this.stream.write(this.spacebeforeslash + '?>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.raw = function(node, level) {
+ return this.stream.write(this.space(level) + node.value + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.text = function(node, level) {
+ return this.stream.write(this.space(level) + node.value + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.dtdAttList = function(node, level) {
+ this.stream.write(this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType);
+ if (node.defaultValueType !== '#DEFAULT') {
+ this.stream.write(' ' + node.defaultValueType);
+ }
+ if (node.defaultValue) {
+ this.stream.write(' "' + node.defaultValue + '"');
+ }
+ return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.dtdElement = function(node, level) {
+ this.stream.write(this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value);
+ return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.dtdEntity = function(node, level) {
+ this.stream.write(this.space(level) + '<!ENTITY');
+ if (node.pe) {
+ this.stream.write(' %');
+ }
+ this.stream.write(' ' + node.name);
+ if (node.value) {
+ this.stream.write(' "' + node.value + '"');
+ } else {
+ if (node.pubID && node.sysID) {
+ this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
+ } else if (node.sysID) {
+ this.stream.write(' SYSTEM "' + node.sysID + '"');
+ }
+ if (node.nData) {
+ this.stream.write(' NDATA ' + node.nData);
+ }
+ }
+ return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.dtdNotation = function(node, level) {
+ this.stream.write(this.space(level) + '<!NOTATION ' + node.name);
+ if (node.pubID && node.sysID) {
+ this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
+ } else if (node.pubID) {
+ this.stream.write(' PUBLIC "' + node.pubID + '"');
+ } else if (node.sysID) {
+ this.stream.write(' SYSTEM "' + node.sysID + '"');
+ }
+ return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
+ };
+
+ XMLStreamWriter.prototype.endline = function(node) {
+ if (!node.isLastRootNode) {
+ return this.newline;
+ } else {
+ return '';
+ }
+ };
+
+ return XMLStreamWriter;
+
+ })(XMLWriterBase);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLStringWriter.js b/node_modules/xmlbuilder/lib/XMLStringWriter.js
new file mode 100644
index 0000000..b5c0a93
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLStringWriter.js
@@ -0,0 +1,334 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLText, XMLWriterBase,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLDeclaration = require('./XMLDeclaration');
+
+ XMLDocType = require('./XMLDocType');
+
+ XMLCData = require('./XMLCData');
+
+ XMLComment = require('./XMLComment');
+
+ XMLElement = require('./XMLElement');
+
+ XMLRaw = require('./XMLRaw');
+
+ XMLText = require('./XMLText');
+
+ XMLProcessingInstruction = require('./XMLProcessingInstruction');
+
+ XMLDTDAttList = require('./XMLDTDAttList');
+
+ XMLDTDElement = require('./XMLDTDElement');
+
+ XMLDTDEntity = require('./XMLDTDEntity');
+
+ XMLDTDNotation = require('./XMLDTDNotation');
+
+ XMLWriterBase = require('./XMLWriterBase');
+
+ module.exports = XMLStringWriter = (function(superClass) {
+ extend(XMLStringWriter, superClass);
+
+ function XMLStringWriter(options) {
+ XMLStringWriter.__super__.constructor.call(this, options);
+ }
+
+ XMLStringWriter.prototype.document = function(doc) {
+ var child, i, len, r, ref;
+ this.textispresent = false;
+ r = '';
+ ref = doc.children;
+ for (i = 0, len = ref.length; i < len; i++) {
+ child = ref[i];
+ r += (function() {
+ switch (false) {
+ case !(child instanceof XMLDeclaration):
+ return this.declaration(child);
+ case !(child instanceof XMLDocType):
+ return this.docType(child);
+ case !(child instanceof XMLComment):
+ return this.comment(child);
+ case !(child instanceof XMLProcessingInstruction):
+ return this.processingInstruction(child);
+ default:
+ return this.element(child, 0);
+ }
+ }).call(this);
+ }
+ if (this.pretty && r.slice(-this.newline.length) === this.newline) {
+ r = r.slice(0, -this.newline.length);
+ }
+ return r;
+ };
+
+ XMLStringWriter.prototype.attribute = function(att) {
+ return ' ' + att.name + '="' + att.value + '"';
+ };
+
+ XMLStringWriter.prototype.cdata = function(node, level) {
+ return this.space(level) + '<![CDATA[' + node.text + ']]>' + this.newline;
+ };
+
+ XMLStringWriter.prototype.comment = function(node, level) {
+ return this.space(level) + '<!-- ' + node.text + ' -->' + this.newline;
+ };
+
+ XMLStringWriter.prototype.declaration = function(node, level) {
+ var r;
+ r = this.space(level);
+ r += '<?xml version="' + node.version + '"';
+ if (node.encoding != null) {
+ r += ' encoding="' + node.encoding + '"';
+ }
+ if (node.standalone != null) {
+ r += ' standalone="' + node.standalone + '"';
+ }
+ r += this.spacebeforeslash + '?>';
+ r += this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.docType = function(node, level) {
+ var child, i, len, r, ref;
+ level || (level = 0);
+ r = this.space(level);
+ r += '<!DOCTYPE ' + node.root().name;
+ if (node.pubID && node.sysID) {
+ r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+ } else if (node.sysID) {
+ r += ' SYSTEM "' + node.sysID + '"';
+ }
+ if (node.children.length > 0) {
+ r += ' [';
+ r += this.newline;
+ ref = node.children;
+ for (i = 0, len = ref.length; i < len; i++) {
+ child = ref[i];
+ r += (function() {
+ switch (false) {
+ case !(child instanceof XMLDTDAttList):
+ return this.dtdAttList(child, level + 1);
+ case !(child instanceof XMLDTDElement):
+ return this.dtdElement(child, level + 1);
+ case !(child instanceof XMLDTDEntity):
+ return this.dtdEntity(child, level + 1);
+ case !(child instanceof XMLDTDNotation):
+ return this.dtdNotation(child, level + 1);
+ case !(child instanceof XMLCData):
+ return this.cdata(child, level + 1);
+ case !(child instanceof XMLComment):
+ return this.comment(child, level + 1);
+ case !(child instanceof XMLProcessingInstruction):
+ return this.processingInstruction(child, level + 1);
+ default:
+ throw new Error("Unknown DTD node type: " + child.constructor.name);
+ }
+ }).call(this);
+ }
+ r += ']';
+ }
+ r += this.spacebeforeslash + '>';
+ r += this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.element = function(node, level) {
+ var att, child, i, j, len, len1, name, r, ref, ref1, ref2, space, textispresentwasset;
+ level || (level = 0);
+ textispresentwasset = false;
+ if (this.textispresent) {
+ this.newline = '';
+ this.pretty = false;
+ } else {
+ this.newline = this.newlinedefault;
+ this.pretty = this.prettydefault;
+ }
+ space = this.space(level);
+ r = '';
+ r += space + '<' + node.name;
+ ref = node.attributes;
+ for (name in ref) {
+ if (!hasProp.call(ref, name)) continue;
+ att = ref[name];
+ r += this.attribute(att);
+ }
+ if (node.children.length === 0 || node.children.every(function(e) {
+ return e.value === '';
+ })) {
+ if (this.allowEmpty) {
+ r += '></' + node.name + '>' + this.newline;
+ } else {
+ r += this.spacebeforeslash + '/>' + this.newline;
+ }
+ } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
+ r += '>';
+ r += node.children[0].value;
+ r += '</' + node.name + '>' + this.newline;
+ } else {
+ if (this.dontprettytextnodes) {
+ ref1 = node.children;
+ for (i = 0, len = ref1.length; i < len; i++) {
+ child = ref1[i];
+ if (child.value != null) {
+ this.textispresent++;
+ textispresentwasset = true;
+ break;
+ }
+ }
+ }
+ if (this.textispresent) {
+ this.newline = '';
+ this.pretty = false;
+ space = this.space(level);
+ }
+ r += '>' + this.newline;
+ ref2 = node.children;
+ for (j = 0, len1 = ref2.length; j < len1; j++) {
+ child = ref2[j];
+ r += (function() {
+ switch (false) {
+ case !(child instanceof XMLCData):
+ return this.cdata(child, level + 1);
+ case !(child instanceof XMLComment):
+ return this.comment(child, level + 1);
+ case !(child instanceof XMLElement):
+ return this.element(child, level + 1);
+ case !(child instanceof XMLRaw):
+ return this.raw(child, level + 1);
+ case !(child instanceof XMLText):
+ return this.text(child, level + 1);
+ case !(child instanceof XMLProcessingInstruction):
+ return this.processingInstruction(child, level + 1);
+ default:
+ throw new Error("Unknown XML node type: " + child.constructor.name);
+ }
+ }).call(this);
+ }
+ if (textispresentwasset) {
+ this.textispresent--;
+ }
+ if (!this.textispresent) {
+ this.newline = this.newlinedefault;
+ this.pretty = this.prettydefault;
+ }
+ r += space + '</' + node.name + '>' + this.newline;
+ }
+ return r;
+ };
+
+ XMLStringWriter.prototype.processingInstruction = function(node, level) {
+ var r;
+ r = this.space(level) + '<?' + node.target;
+ if (node.value) {
+ r += ' ' + node.value;
+ }
+ r += this.spacebeforeslash + '?>' + this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.raw = function(node, level) {
+ return this.space(level) + node.value + this.newline;
+ };
+
+ XMLStringWriter.prototype.text = function(node, level) {
+ return this.space(level) + node.value + this.newline;
+ };
+
+ XMLStringWriter.prototype.dtdAttList = function(node, level) {
+ var r;
+ r = this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
+ if (node.defaultValueType !== '#DEFAULT') {
+ r += ' ' + node.defaultValueType;
+ }
+ if (node.defaultValue) {
+ r += ' "' + node.defaultValue + '"';
+ }
+ r += this.spacebeforeslash + '>' + this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.dtdElement = function(node, level) {
+ return this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value + this.spacebeforeslash + '>' + this.newline;
+ };
+
+ XMLStringWriter.prototype.dtdEntity = function(node, level) {
+ var r;
+ r = this.space(level) + '<!ENTITY';
+ 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;
+ }
+ }
+ r += this.spacebeforeslash + '>' + this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.dtdNotation = function(node, level) {
+ var r;
+ r = this.space(level) + '<!NOTATION ' + 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 + '"';
+ }
+ r += this.spacebeforeslash + '>' + this.newline;
+ return r;
+ };
+
+ XMLStringWriter.prototype.openNode = function(node, level) {
+ var att, name, r, ref;
+ level || (level = 0);
+ if (node instanceof XMLElement) {
+ r = this.space(level) + '<' + node.name;
+ ref = node.attributes;
+ for (name in ref) {
+ if (!hasProp.call(ref, name)) continue;
+ att = ref[name];
+ r += this.attribute(att);
+ }
+ r += (node.children ? '>' : '/>') + this.newline;
+ return r;
+ } else {
+ r = this.space(level) + '<!DOCTYPE ' + node.rootNodeName;
+ if (node.pubID && node.sysID) {
+ r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+ } else if (node.sysID) {
+ r += ' SYSTEM "' + node.sysID + '"';
+ }
+ r += (node.children ? ' [' : '>') + this.newline;
+ return r;
+ }
+ };
+
+ XMLStringWriter.prototype.closeNode = function(node, level) {
+ level || (level = 0);
+ switch (false) {
+ case !(node instanceof XMLElement):
+ return this.space(level) + '</' + node.name + '>' + this.newline;
+ case !(node instanceof XMLDocType):
+ return this.space(level) + ']>' + this.newline;
+ }
+ };
+
+ return XMLStringWriter;
+
+ })(XMLWriterBase);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLStringifier.js b/node_modules/xmlbuilder/lib/XMLStringifier.js
new file mode 100644
index 0000000..23bb4c8
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLStringifier.js
@@ -0,0 +1,163 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLStringifier,
+ bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+ hasProp = {}.hasOwnProperty;
+
+ module.exports = XMLStringifier = (function() {
+ function XMLStringifier(options) {
+ this.assertLegalChar = bind(this.assertLegalChar, this);
+ var key, ref, value;
+ options || (options = {});
+ this.noDoubleEncoding = options.noDoubleEncoding;
+ ref = options.stringify || {};
+ for (key in ref) {
+ if (!hasProp.call(ref, key)) continue;
+ value = ref[key];
+ this[key] = value;
+ }
+ }
+
+ XMLStringifier.prototype.eleName = function(val) {
+ val = '' + val || '';
+ return this.assertLegalChar(val);
+ };
+
+ XMLStringifier.prototype.eleText = function(val) {
+ val = '' + val || '';
+ return this.assertLegalChar(this.elEscape(val));
+ };
+
+ XMLStringifier.prototype.cdata = function(val) {
+ val = '' + val || '';
+ val = val.replace(']]>', ']]]]><![CDATA[>');
+ return this.assertLegalChar(val);
+ };
+
+ XMLStringifier.prototype.comment = function(val) {
+ val = '' + val || '';
+ if (val.match(/--/)) {
+ throw new Error("Comment text cannot contain double-hypen: " + val);
+ }
+ return this.assertLegalChar(val);
+ };
+
+ XMLStringifier.prototype.raw = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.attName = function(val) {
+ return val = '' + val || '';
+ };
+
+ XMLStringifier.prototype.attValue = function(val) {
+ val = '' + val || '';
+ return this.attEscape(val);
+ };
+
+ XMLStringifier.prototype.insTarget = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.insValue = function(val) {
+ val = '' + val || '';
+ if (val.match(/\?>/)) {
+ throw new Error("Invalid processing instruction value: " + val);
+ }
+ return val;
+ };
+
+ XMLStringifier.prototype.xmlVersion = function(val) {
+ val = '' + val || '';
+ if (!val.match(/1\.[0-9]+/)) {
+ throw new Error("Invalid version number: " + val);
+ }
+ return val;
+ };
+
+ XMLStringifier.prototype.xmlEncoding = function(val) {
+ val = '' + val || '';
+ if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-]|-)*$/)) {
+ throw new Error("Invalid encoding: " + val);
+ }
+ return val;
+ };
+
+ XMLStringifier.prototype.xmlStandalone = function(val) {
+ if (val) {
+ return "yes";
+ } else {
+ return "no";
+ }
+ };
+
+ XMLStringifier.prototype.dtdPubID = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.dtdSysID = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.dtdElementValue = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.dtdAttType = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.dtdAttDefault = function(val) {
+ if (val != null) {
+ return '' + val || '';
+ } else {
+ return val;
+ }
+ };
+
+ XMLStringifier.prototype.dtdEntityValue = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.dtdNData = function(val) {
+ return '' + val || '';
+ };
+
+ XMLStringifier.prototype.convertAttKey = '@';
+
+ XMLStringifier.prototype.convertPIKey = '?';
+
+ XMLStringifier.prototype.convertTextKey = '#text';
+
+ XMLStringifier.prototype.convertCDataKey = '#cdata';
+
+ XMLStringifier.prototype.convertCommentKey = '#comment';
+
+ XMLStringifier.prototype.convertRawKey = '#raw';
+
+ XMLStringifier.prototype.assertLegalChar = function(str) {
+ var res;
+ res = str.match(/[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/);
+ if (res) {
+ throw new Error("Invalid character in string: " + str + " at index " + res.index);
+ }
+ return str;
+ };
+
+ XMLStringifier.prototype.elEscape = function(str) {
+ var ampregex;
+ ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+ return str.replace(ampregex, '&').replace(/</g, '<').replace(/>/g, '>').replace(/\r/g, '
');
+ };
+
+ XMLStringifier.prototype.attEscape = function(str) {
+ var ampregex;
+ ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+ return str.replace(ampregex, '&').replace(/</g, '<').replace(/"/g, '"').replace(/\t/g, '	').replace(/\n/g, '
').replace(/\r/g, '
');
+ };
+
+ return XMLStringifier;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLText.js b/node_modules/xmlbuilder/lib/XMLText.js
new file mode 100644
index 0000000..ec23d2a
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLText.js
@@ -0,0 +1,32 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLNode, XMLText,
+ extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty;
+
+ XMLNode = require('./XMLNode');
+
+ module.exports = XMLText = (function(superClass) {
+ extend(XMLText, superClass);
+
+ function XMLText(parent, text) {
+ XMLText.__super__.constructor.call(this, parent);
+ if (text == null) {
+ throw new Error("Missing element text");
+ }
+ this.value = this.stringify.eleText(text);
+ }
+
+ XMLText.prototype.clone = function() {
+ return Object.create(this);
+ };
+
+ XMLText.prototype.toString = function(options) {
+ return this.options.writer.set(options).text(this);
+ };
+
+ return XMLText;
+
+ })(XMLNode);
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/XMLWriterBase.js b/node_modules/xmlbuilder/lib/XMLWriterBase.js
new file mode 100644
index 0000000..c21142a
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/XMLWriterBase.js
@@ -0,0 +1,90 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLWriterBase,
+ hasProp = {}.hasOwnProperty;
+
+ module.exports = XMLWriterBase = (function() {
+ function XMLWriterBase(options) {
+ var key, ref, ref1, ref2, ref3, ref4, ref5, ref6, value;
+ options || (options = {});
+ this.pretty = options.pretty || false;
+ this.allowEmpty = (ref = options.allowEmpty) != null ? ref : false;
+ if (this.pretty) {
+ this.indent = (ref1 = options.indent) != null ? ref1 : ' ';
+ this.newline = (ref2 = options.newline) != null ? ref2 : '\n';
+ this.offset = (ref3 = options.offset) != null ? ref3 : 0;
+ this.dontprettytextnodes = (ref4 = options.dontprettytextnodes) != null ? ref4 : 0;
+ } else {
+ this.indent = '';
+ this.newline = '';
+ this.offset = 0;
+ this.dontprettytextnodes = 0;
+ }
+ this.spacebeforeslash = (ref5 = options.spacebeforeslash) != null ? ref5 : '';
+ if (this.spacebeforeslash === true) {
+ this.spacebeforeslash = ' ';
+ }
+ this.newlinedefault = this.newline;
+ this.prettydefault = this.pretty;
+ ref6 = options.writer || {};
+ for (key in ref6) {
+ if (!hasProp.call(ref6, key)) continue;
+ value = ref6[key];
+ this[key] = value;
+ }
+ }
+
+ XMLWriterBase.prototype.set = function(options) {
+ var key, ref, value;
+ options || (options = {});
+ if ("pretty" in options) {
+ this.pretty = options.pretty;
+ }
+ if ("allowEmpty" in options) {
+ this.allowEmpty = options.allowEmpty;
+ }
+ if (this.pretty) {
+ this.indent = "indent" in options ? options.indent : ' ';
+ this.newline = "newline" in options ? options.newline : '\n';
+ this.offset = "offset" in options ? options.offset : 0;
+ this.dontprettytextnodes = "dontprettytextnodes" in options ? options.dontprettytextnodes : 0;
+ } else {
+ this.indent = '';
+ this.newline = '';
+ this.offset = 0;
+ this.dontprettytextnodes = 0;
+ }
+ this.spacebeforeslash = "spacebeforeslash" in options ? options.spacebeforeslash : '';
+ if (this.spacebeforeslash === true) {
+ this.spacebeforeslash = ' ';
+ }
+ this.newlinedefault = this.newline;
+ this.prettydefault = this.pretty;
+ ref = options.writer || {};
+ for (key in ref) {
+ if (!hasProp.call(ref, key)) continue;
+ value = ref[key];
+ this[key] = value;
+ }
+ return this;
+ };
+
+ XMLWriterBase.prototype.space = function(level) {
+ var indent;
+ if (this.pretty) {
+ indent = (level || 0) + this.offset + 1;
+ if (indent > 0) {
+ return new Array(indent).join(this.indent);
+ } else {
+ return '';
+ }
+ } else {
+ return '';
+ }
+ };
+
+ return XMLWriterBase;
+
+ })();
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/lib/index.js b/node_modules/xmlbuilder/lib/index.js
new file mode 100644
index 0000000..9bf142d
--- /dev/null
+++ b/node_modules/xmlbuilder/lib/index.js
@@ -0,0 +1,53 @@
+// Generated by CoffeeScript 1.12.6
+(function() {
+ var XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
+
+ ref = require('./Utility'), assign = ref.assign, isFunction = ref.isFunction;
+
+ XMLDocument = require('./XMLDocument');
+
+ XMLDocumentCB = require('./XMLDocumentCB');
+
+ XMLStringWriter = require('./XMLStringWriter');
+
+ XMLStreamWriter = require('./XMLStreamWriter');
+
+ 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);
+ doc = new XMLDocument(options);
+ root = doc.element(name);
+ if (!options.headless) {
+ doc.declaration(options);
+ if ((options.pubID != null) || (options.sysID != null)) {
+ doc.doctype(options);
+ }
+ }
+ return root;
+ };
+
+ module.exports.begin = function(options, onData, onEnd) {
+ var ref1;
+ if (isFunction(options)) {
+ ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
+ 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);
+ };
+
+}).call(this);
diff --git a/node_modules/xmlbuilder/package.json b/node_modules/xmlbuilder/package.json
new file mode 100644
index 0000000..cac8865
--- /dev/null
+++ b/node_modules/xmlbuilder/package.json
@@ -0,0 +1,101 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "xmlbuilder@~9.0.1",
+ "scope": null,
+ "escapedName": "xmlbuilder",
+ "name": "xmlbuilder",
+ "rawSpec": "~9.0.1",
+ "spec": ">=9.0.1 <9.1.0",
+ "type": "range"
+ },
+ "/Users/fzy/project/koa2_Sequelize_project/node_modules/xml2js"
+ ]
+ ],
+ "_from": "xmlbuilder@>=9.0.1 <9.1.0",
+ "_id": "xmlbuilder@9.0.4",
+ "_inCache": true,
+ "_location": "/xmlbuilder",
+ "_nodeVersion": "6.11.0",
+ "_npmOperationalInternal": {
+ "host": "s3://npm-registry-packages",
+ "tmp": "tmp/xmlbuilder-9.0.4.tgz_1502884089961_0.9179640170186758"
+ },
+ "_npmUser": {
+ "name": "oozcitak",
+ "email": "oozcitak@gmail.com"
+ },
+ "_npmVersion": "3.10.10",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "xmlbuilder@~9.0.1",
+ "scope": null,
+ "escapedName": "xmlbuilder",
+ "name": "xmlbuilder",
+ "rawSpec": "~9.0.1",
+ "spec": ">=9.0.1 <9.1.0",
+ "type": "range"
+ },
+ "_requiredBy": [
+ "/xml2js"
+ ],
+ "_resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.4.tgz",
+ "_shasum": "519cb4ca686d005a8420d3496f3f0caeecca580f",
+ "_shrinkwrap": null,
+ "_spec": "xmlbuilder@~9.0.1",
+ "_where": "/Users/fzy/project/koa2_Sequelize_project/node_modules/xml2js",
+ "author": {
+ "name": "Ozgur Ozcitak",
+ "email": "oozcitak@gmail.com"
+ },
+ "bugs": {
+ "url": "http://github.com/oozcitak/xmlbuilder-js/issues"
+ },
+ "contributors": [],
+ "dependencies": {},
+ "description": "An XML builder for node.js",
+ "devDependencies": {
+ "coffee-coverage": "*",
+ "coffeescript": "github:jashkenas/coffeescript",
+ "coveralls": "*",
+ "istanbul": "*",
+ "mocha": "*"
+ },
+ "directories": {},
+ "dist": {
+ "shasum": "519cb4ca686d005a8420d3496f3f0caeecca580f",
+ "tarball": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.4.tgz"
+ },
+ "engines": {
+ "node": ">=4.0"
+ },
+ "gitHead": "f1c99a9c2abec65238ce86e8ed48bf9cb162ac6c",
+ "homepage": "http://github.com/oozcitak/xmlbuilder-js",
+ "keywords": [
+ "xml",
+ "xmlbuilder"
+ ],
+ "license": "MIT",
+ "main": "./lib/index",
+ "maintainers": [
+ {
+ "name": "oozcitak",
+ "email": "oozcitak@gmail.com"
+ }
+ ],
+ "name": "xmlbuilder",
+ "optionalDependencies": {},
+ "readme": "# xmlbuilder-js\n\nAn XML builder for [node.js](https://nodejs.org/) similar to\n[java-xmlbuilder](https://github.com/jmurty/java-xmlbuilder).\n\n[](http://opensource.org/licenses/MIT)\n[](https://npmjs.com/package/xmlbuilder)\n[](https://npmjs.com/package/xmlbuilder)\n\n[](http://travis-ci.org/oozcitak/xmlbuilder-js)\n[](https://david-dm.org/oozcitak/xmlbuilder-js)\n[](https://coveralls.io/github/oozcitak/xmlbuilder-js)\n\n### Installation:\n\n``` sh\nnpm install xmlbuilder\n```\n\n### Usage:\n\n``` js\nvar builder = require('xmlbuilder');\nvar xml = builder.create('root')\n .ele('xmlbuilder')\n .ele('repo', {'type': 'git'}, 'git://github.com/oozcitak/xmlbuilder-js.git')\n .end({ pretty: true});\n\nconsole.log(xml);\n```\n\nwill result in:\n\n``` xml\n<?xml version=\"1.0\"?>\n<root>\n <xmlbuilder>\n <repo type=\"git\">git://github.com/oozcitak/xmlbuilder-js.git</repo>\n </xmlbuilder>\n</root>\n```\n\nIt is also possible to convert objects into nodes:\n\n``` js\nbuilder.create({\n root: {\n xmlbuilder: {\n repo: {\n '@type': 'git', // attributes start with @\n '#text': 'git://github.com/oozcitak/xmlbuilder-js.git' // text node\n }\n }\n }\n});\n```\n\nIf you need to do some processing:\n\n``` js\nvar root = builder.create('squares');\nroot.com('f(x) = x^2');\nfor(var i = 1; i <= 5; i++)\n{\n var item = root.ele('data');\n item.att('x', i);\n item.att('y', i * i);\n}\n```\n\nThis will result in:\n\n``` xml\n<?xml version=\"1.0\"?>\n<squares>\n <!-- f(x) = x^2 -->\n <data x=\"1\" y=\"1\"/>\n <data x=\"2\" y=\"4\"/>\n <data x=\"3\" y=\"9\"/>\n <data x=\"4\" y=\"16\"/>\n <data x=\"5\" y=\"25\"/>\n</squares>\n```\n\nSee the [wiki](https://github.com/oozcitak/xmlbuilder-js/wiki) for details and [examples](https://github.com/oozcitak/xmlbuilder-js/wiki/Examples) for more complex examples.\n",
+ "readmeFilename": "README.md",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/oozcitak/xmlbuilder-js.git"
+ },
+ "scripts": {
+ "postpublish": "rm -rf lib",
+ "prepublish": "coffee -co lib src",
+ "test": "mocha && istanbul report text lcov"
+ },
+ "version": "9.0.4"
+}
diff --git a/routes/studentMeeting.js b/routes/studentMeeting.js
new file mode 100644
index 0000000..f112b17
--- /dev/null
+++ b/routes/studentMeeting.js
@@ -0,0 +1,21 @@
+const router = require('koa-router')()
+var studentMeetingController = require('../controller/studentMeetingController')
+var status = require('../util/resTemplate')
+
+router.prefix('/studentMeeting');
+
+/**
+ * 添加预约课程
+ */
+router.post('/addStudentMeeting',async (ctx, next) => {
+ try{
+ var data = await studentMeetingController.addStudentMeeting(ctx, next);
+ status.successTemp(ctx,200,data);
+ }catch(e){
+ console.log(e)
+ status.catchError(ctx,400,e.message);
+ }
+ })
+
+
+ module.exports = router;
\ No newline at end of file
diff --git a/services/meetingService.js b/services/meetingService.js
index cd85ba6..b79de5d 100644
--- a/services/meetingService.js
+++ b/services/meetingService.js
@@ -5,6 +5,7 @@ var sequelize = require('../config');
var tokenUtil = require('../util/tokenUtil');
var co = require('co');
+
function meetingService(){
}
@@ -16,7 +17,7 @@ meetingService.prototype.createMeeting = async(meetingInfo) =>{
throw error
}
}
-meetingService.prototype.getMeeting = async(queryData,page = 1,pageno =10) =>{
+meetingService.prototype.getMeeting = async(queryData,page = 1,pageno =12) =>{
try {
let backMeeting = await meetingModel.findAll({where:queryData,offset: (page-1)*pageno, limit: pageno});
let count = await meetingModel.count({where:queryData})
diff --git a/services/studentMeetingService.js b/services/studentMeetingService.js
new file mode 100644
index 0000000..c961be6
--- /dev/null
+++ b/services/studentMeetingService.js
@@ -0,0 +1,35 @@
+var sutudentMeeting = require('../model/studentMeetingModel');
+var status = require('../util/resTemplate');
+var saitMd5 = require('../util/saltMD5');
+var sequelize = require('../config');
+var tokenUtil = require('../util/tokenUtil');
+var meetingModel = require('../model/meetingModel');
+var co = require('co');
+
+
+function sutudentMeetingService(){
+
+}
+
+sutudentMeetingService.prototype.addStudentMeeting = async(body)=>{
+ try {
+ var t = await sequelize.transaction({ autocommit: true })
+ let Meeting = await meetingModel.findOne({where:{id:body.meetingId}});
+ if(!Meeting){
+ t.rollback();
+ return {code:300,msg:'课堂不存在'}
+ }
+ let sm = await sutudentMeeting.create(body);
+ let MeetingBack = await meetingModel.update(
+ {reservationNumber:Meeting.reservationNumber+1},
+ {where:{id:body.meetingId}},
+ {transaction: t});
+ t.commit();
+ return sm;
+ } catch (error) {
+ t.rollback();
+ throw error;
+ }
+}
+
+module.exports = new sutudentMeetingService();
\ No newline at end of file
diff --git a/services/userService.js b/services/userService.js
index 55a8308..7fc0a21 100644
--- a/services/userService.js
+++ b/services/userService.js
@@ -14,26 +14,26 @@ function userService(){
userService.prototype.addUser = async(data)=>{
try{
- var t = await sequelize.transaction({ autocommit: true })
+ // var t = await sequelize.transaction()
var queryData = [
{userMobile:data.userMobile},
{loginName:data.loginName },
{userEmail:data.userEmail }
]
- let oldUser = await userModel.find({where:{$or:queryData}})
+ let oldUser = await userModel.find({where:{$or:queryData}},)
if(oldUser){
return {code:400,msg:'用户已存在'}
}
- let newUser = await userModel.create(data,{transaction: t})
+ let newUser = await userModel.create(data)
console.log(newUser);
if(newUser.userRole ==3 && data.time == 1){
let e = await emailUtil.sendMail(newUser.userEmail,'认证邮件', '您已经成为学点云网校认证老师')
}
- t.commit();
+ // t.commit();
return newUser;
}catch (err){
console.error(err);
- t.rollback();
+ // t.rollback();
throw new Error(err);
}
}
@@ -46,6 +46,7 @@ userService.prototype.login = async(loginName,pw,userEmail) => {
];
let User = await userModel.find({where:{$or:queryData}})
console.dir(User)
+ console.log(User.password, saitMd5.md5Salt(pw,User.salt))
if(!User){
return {code:300,msg:'用户不存在'}
}else if(User.password != saitMd5.md5Salt(pw,User.salt)){
@@ -83,7 +84,7 @@ userService.prototype.resetPasswordByUserId = async(userId,pw) => {
var t = await sequelize.transaction({ autocommit: true })
let User = await userModel.findOne({where:{id:userId}})
if(!User){
- t.rollback
+ t.rollback();
return {code:0,msg:'用户不存在'}
}
let updateUser = await userModel.update({password:pw.md5Pass,salt:pw.salt},{where:{id:userId}});
diff --git a/util/UuidUtil.js b/util/UuidUtil.js
index 36ca3a8..0dae494 100644
--- a/util/UuidUtil.js
+++ b/util/UuidUtil.js
@@ -11,7 +11,7 @@ module.exports={
},
db32:function(){
- const hids=new Hashids(uuid.v1(),32);
+ let hids=new Hashids(uuid.v1(),32);
return hids.encode(1);;
},
db36:function(){
--
libgit2 0.24.0