You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by sg...@apache.org on 2014/09/30 09:46:14 UTC
[28/38] CB-7666 Merge node_modules and move to package root
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/elementtree/node_modules/sax/README.md
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/elementtree/node_modules/sax/README.md b/template/cordova/node_modules/elementtree/node_modules/sax/README.md
deleted file mode 100644
index 9c63dc4..0000000
--- a/template/cordova/node_modules/elementtree/node_modules/sax/README.md
+++ /dev/null
@@ -1,213 +0,0 @@
-# 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
-
- 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.createReadStream("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.
-* `lowercasetags` - Boolean. If true, then lowercase tags in loose mode,
- rather than uppercasing them.
-* `xmlns` - Boolean. If true, then namespaces are supported.
-
-## 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.
-
-`opentag` - An opening tag. Argument: object with `name` and `attributes`.
-In non-strict mode, tag names are uppercased, unless the `lowercasetags`
-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`,
-and also namespace information if the `xmlns` option flag is set.
-
-`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.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/elementtree/node_modules/sax/lib/sax.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/elementtree/node_modules/sax/lib/sax.js b/template/cordova/node_modules/elementtree/node_modules/sax/lib/sax.js
deleted file mode 100644
index 17fb08e..0000000
--- a/template/cordova/node_modules/elementtree/node_modules/sax/lib/sax.js
+++ /dev/null
@@ -1,1006 +0,0 @@
-// wrapper for non-node envs
-;(function (sax) {
-
-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 = // for discoverability.
- [ "text"
- , "processinginstruction"
- , "sgmldeclaration"
- , "doctype"
- , "comment"
- , "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.tagCase = parser.opt.lowercasetags ? "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.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.position = parser.line = parser.column = 0
- emit(parser, "onready")
-}
-
-if (!Object.create) Object.create = function (o) {
- function f () { this.__proto__ = o }
- f.prototype = o
- return new f
-}
-
-if (!Object.getPrototypeOf) Object.getPrototypeOf = function (o) {
- return o.__proto__
-}
-
-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)
- , 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.
- parser.bufferCheckPosition = (sax.MAX_BUFFER_LENGTH - maxActual)
- + parser.position
-}
-
-function clearBuffers (parser) {
- for (var i = 0, l = buffers.length; i < l; i ++) {
- parser[buffers[i]] = ""
- }
-}
-
-SAXParser.prototype =
- { end: function () { end(this) }
- , write: write
- , resume: function () { this.error = null; return this }
- , close: function () { return this.write(null) }
- , end: function () { return this.write(null) }
- }
-
-try {
- var Stream = require("stream").Stream
-} catch (ex) {
- var 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(me)
-
- 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
- }
-
- streamWraps.forEach(function (ev) {
- Object.defineProperty(me, "on" + ev, {
- get: function () { return me._parser["on" + ev] },
- set: function (h) {
- if (!h) {
- me.removeAllListeners(ev)
- return me._parser["on"+ev] = h
- }
- me.on(ev, h)
- },
- enumerable: true,
- configurable: false
- })
- })
-}
-
-SAXStream.prototype = Object.create(Stream.prototype,
- { constructor: { value: SAXStream } })
-
-SAXStream.prototype.write = function (data) {
- this._parser.write(data.toString())
- this.emit("data", data)
- return true
-}
-
-SAXStream.prototype.end = function (chunk) {
- if (chunk && chunk.length) this._parser.write(chunk.toString())
- 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)
-}
-
-
-
-// character classes and tokens
-var whitespace = "\r\n\t "
- // this really needs to be replaced with character classes.
- // XML allows all manner of ridiculous numbers and digits.
- , number = "0124356789"
- , letter = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
- // (Letter | "_" | ":")
- , nameStart = letter+"_:"
- , nameBody = nameStart+number+"-."
- , quote = "'\""
- , entity = number+letter+"#"
- , attribEnd = whitespace + ">"
- , CDATA = "[CDATA["
- , DOCTYPE = "DOCTYPE"
- , XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
- , XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
- , rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
-
-// turn all the string character sets into character class objects.
-whitespace = charClass(whitespace)
-number = charClass(number)
-letter = charClass(letter)
-nameStart = charClass(nameStart)
-nameBody = charClass(nameBody)
-quote = charClass(quote)
-entity = charClass(entity)
-attribEnd = charClass(attribEnd)
-
-function charClass (str) {
- return str.split("").reduce(function (s, c) {
- s[c] = true
- return s
- }, {})
-}
-
-function is (charclass, c) {
- return charclass[c]
-}
-
-function not (charclass, c) {
- return !charclass[c]
-}
-
-var S = 0
-sax.STATE =
-{ BEGIN : S++
-, 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_QUOTED : 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_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.ENTITIES =
-{ "apos" : "'"
-, "quot" : "\""
-, "amp" : "&"
-, "gt" : ">"
-, "lt" : "<"
-}
-
-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)
- 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.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 (parser.strict) error(parser, message)
-}
-
-function newTag (parser) {
- if (!parser.strict) parser.tagName = parser.tagName[parser.tagCase]()
- var parent = parser.tags[parser.tags.length - 1] || parser
- , 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
-}
-
-function qname (name) {
- var i = name.indexOf(":")
- , qualName = i < 0 ? [ "", name ] : name.split(":")
- , prefix = qualName[0]
- , local = qualName[1]
-
- // <x "xmlns"="http://foo">
- if (name === "xmlns") {
- prefix = "xmlns"
- local = ""
- }
-
- return { prefix: prefix, local: local }
-}
-
-function attrib (parser) {
- if (parser.opt.xmlns) {
- var qn = qname(parser.attribName)
- , prefix = qn.prefix
- , 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
- , 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] || qn.prefix
-
- if (tag.prefix && !tag.uri) {
- strictFail(parser, "Unbound namespace prefix: "
- + JSON.stringify(parser.tagName))
- }
-
- 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
- for (var i = 0, l = parser.attribList.length; i < l; i ++) {
- var nv = parser.attribList[i]
- var name = nv[0]
- , value = nv[1]
- , qualName = qname(name)
- , prefix = qualName.prefix
- , local = qualName.local
- , uri = tag.ns[prefix] || ""
- , 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
- }
-
- // 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
- }
- // 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.tagCase]()
- 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.toLowerCase()
- , num
- , numStr = ""
- if (parser.ENTITIES[entity]) return parser.ENTITIES[entity]
- 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 (numStr.toLowerCase() !== entity) {
- strictFail(parser, "Invalid character entity")
- return "&"+parser.entity + ";"
- }
- return String.fromCharCode(num)
-}
-
-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)
- var i = 0, c = ""
- while (parser.c = c = chunk.charAt(i++)) {
- parser.position ++
- if (c === "\n") {
- parser.line ++
- parser.column = 0
- } else parser.column ++
- switch (parser.state) {
-
- case S.BEGIN:
- if (c === "<") parser.state = S.OPEN_WAKA
- else if (not(whitespace,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
- }
- continue
-
- case S.TEXT:
- if (parser.sawRoot && !parser.closedRoot) {
- var starti = i-1
- while (c && c!=="<" && c!=="&") {
- c = chunk.charAt(i++)
- if (c) {
- parser.position ++
- if (c === "\n") {
- parser.line ++
- parser.column = 0
- } else parser.column ++
- }
- }
- parser.textNode += chunk.substring(starti, i-1)
- }
- if (c === "<") parser.state = S.OPEN_WAKA
- else {
- if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot))
- strictFail("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 === "/") {
- emitNode(parser, "onscript", parser.script)
- parser.state = S.CLOSE_TAG
- parser.script = ""
- parser.tagName = ""
- } 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 (is(whitespace, c)) {
- // wait for it...
- } else if (is(nameStart,c)) {
- parser.startTagPosition = parser.position - 1
- parser.state = S.OPEN_TAG
- parser.tagName = c
- } else if (c === "/") {
- parser.startTagPosition = parser.position - 1
- parser.state = S.CLOSE_TAG
- parser.tagName = ""
- } else if (c === "?") {
- parser.state = S.PROC_INST
- parser.procInstName = parser.procInstBody = ""
- } else {
- strictFail(parser, "Unencoded <")
- 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 (is(quote, 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 (is(quote, 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 (is(quote,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 (is(whitespace, c)) parser.state = S.PROC_INST_BODY
- else parser.procInstName += c
- continue
-
- case S.PROC_INST_BODY:
- if (!parser.procInstBody && is(whitespace, c)) continue
- else if (c === "?") parser.state = S.PROC_INST_ENDING
- else if (is(quote, c)) {
- parser.state = S.PROC_INST_QUOTED
- parser.q = c
- parser.procInstBody += c
- } 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.PROC_INST_QUOTED:
- parser.procInstBody += c
- if (c === parser.q) {
- parser.state = S.PROC_INST_BODY
- parser.q = ""
- }
- continue
-
- case S.OPEN_TAG:
- if (is(nameBody, c)) parser.tagName += c
- else {
- newTag(parser)
- if (c === ">") openTag(parser)
- else if (c === "/") parser.state = S.OPEN_TAG_SLASH
- else {
- if (not(whitespace, 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 (is(whitespace, c)) continue
- else if (c === ">") openTag(parser)
- else if (c === "/") parser.state = S.OPEN_TAG_SLASH
- else if (is(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 (is(whitespace, c)) parser.state = S.ATTRIB_NAME_SAW_WHITE
- else if (is(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 (is(whitespace, 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 (is(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 (is(whitespace, c)) continue
- else if (is(quote, 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
- continue
-
- case S.ATTRIB_VALUE_UNQUOTED:
- if (not(attribEnd,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 (is(whitespace, c)) continue
- else if (not(nameStart, c)) strictFail(parser,
- "Invalid tagname in closing tag.")
- else parser.tagName = c
- }
- else if (c === ">") closeTag(parser)
- else if (is(nameBody, c)) parser.tagName += c
- else {
- if (not(whitespace, c)) strictFail(parser,
- "Invalid tagname in closing tag")
- parser.state = S.CLOSE_TAG_SAW_WHITE
- }
- continue
-
- case S.CLOSE_TAG_SAW_WHITE:
- if (is(whitespace, c)) continue
- if (c === ">") closeTag(parser)
- else strictFail("Invalid characters in closing tag")
- continue
-
- case S.TEXT_ENTITY:
- case S.ATTRIB_VALUE_ENTITY_Q:
- case S.ATTRIB_VALUE_ENTITY_U:
- switch(parser.state) {
- case S.TEXT_ENTITY:
- var returnState = S.TEXT, buffer = "textNode"
- break
-
- case S.ATTRIB_VALUE_ENTITY_Q:
- var returnState = S.ATTRIB_VALUE_QUOTED, buffer = "attribValue"
- break
-
- case S.ATTRIB_VALUE_ENTITY_U:
- var returnState = S.ATTRIB_VALUE_UNQUOTED, buffer = "attribValue"
- break
- }
- if (c === ";") {
- parser[buffer] += parseEntity(parser)
- parser.entity = ""
- parser.state = returnState
- }
- else if (is(entity, c)) parser.entity += c
- else {
- strictFail("Invalid character entity")
- parser[buffer] += "&" + parser.entity + c
- parser.entity = ""
- parser.state = returnState
- }
- continue
-
- default:
- throw new Error(parser, "Unknown state: " + parser.state)
- }
- } // while
- // cdata blocks can get very big under normal conditions. emit and move on.
- // if (parser.state === S.CDATA && parser.cdata) {
- // emitNode(parser, "oncdata", parser.cdata)
- // parser.cdata = ""
- // }
- if (parser.position >= parser.bufferCheckPosition) checkBufferLength(parser)
- return parser
-}
-
-})(typeof exports === "undefined" ? sax = {} : exports)
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/elementtree/node_modules/sax/package.json
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/elementtree/node_modules/sax/package.json b/template/cordova/node_modules/elementtree/node_modules/sax/package.json
deleted file mode 100644
index f5ad5bb..0000000
--- a/template/cordova/node_modules/elementtree/node_modules/sax/package.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "name": "sax",
- "description": "An evented streaming XML parser in JavaScript",
- "author": {
- "name": "Isaac Z. Schlueter",
- "email": "i@izs.me",
- "url": "http://blog.izs.me/"
- },
- "version": "0.3.5",
- "main": "lib/sax.js",
- "license": {
- "type": "MIT",
- "url": "https://raw.github.com/isaacs/sax-js/master/LICENSE"
- },
- "scripts": {
- "test": "node test/index.js"
- },
- "repository": {
- "type": "git",
- "url": "git://github.com/isaacs/sax-js.git"
- },
- "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"
- }
- ],
- "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 var sax = require(\"./lib/sax\"),\n strict = true, // set to false for html-mode\n parser = sax.parser(strict);\n\n parser.onerror = function (e) {\n // an error happened.\n };\n parser.ontext = function (t) {\n // got some text. t is the string of text.\n };\n parser.onopentag = function (node) {\n // opened a tag. node has \"name\" and \"attributes\"\n };\n parser.onattr
ibute = function (attr) {\n // an attribute. attr has \"name\" and \"value\"\n };\n parser.onend = function () {\n // parser stream is done, and ready to have more stuff written to it.\n };\n\n parser.write('<xml>Hello, <who name=\"world\">world</who>!</xml>').close();\n\n // stream usage\n // takes the same options as the parser\n var saxStream = require(\"sax\").createStream(strict, options)\n saxStream.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 })\n saxStream.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.\n fs.createReadStream(\"file.xml\")\n .pipe(saxStream)\n .pipe(fs.createReadStream(\"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* `lowercasetags` - Boolean. If true, then lowercase tags in loose mode, \n rather than uppercasing them.\n* `xmlns` - Boolean. If true, then namespaces are supported.\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 ar
e 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 t
o parse SGML,\nafter all.\n\n`opentag` - An opening tag. Argument: object with `name` and `attributes`.\nIn non-strict mode, tag names are uppercased, unless the `lowercasetags`\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`,\nand also namespace information if the `xmlns` option flag is set.\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 f
or 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 `<![CDATA[` block.\n\n`opennamespace` - If the `xmlns` option is set, then this event will\nsignal the start of a new namespace binding.\n\n`closenamespace` - If the `xmlns` option is set, then this event will\nsignal the end of a namespace binding.\n\n`end` - Indication that the closed stream has ended.\n\n`ready` - Indication that the stream has reset, and is ready to be written\nto.\n\n`noscript` - In non-strict mode, `<script>` tags trigger a `\"script\"`\nevent, and their contents are not checked for special xml characters.\nIf you pass `noscript: true`, then this behavior is suppressed.\n\n## Reporting Problems\n\nIt's best to write a failing test if you find an issue. I will always\naccept pull requests with failing tests if they demonstrate intended\nbehavior, but it is very hard to figure out what issue you're descr
ibing\nwithout a test. Writing a test is also the best way for you yourself\nto figure out if you really understand the issue you think you have with\nsax-js.\n",
- "readmeFilename": "README.md",
- "bugs": {
- "url": "https://github.com/isaacs/sax-js/issues"
- },
- "homepage": "https://github.com/isaacs/sax-js",
- "_id": "sax@0.3.5",
- "_from": "sax@0.3.5"
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/elementtree/package.json
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/elementtree/package.json b/template/cordova/node_modules/elementtree/package.json
deleted file mode 100644
index 749a8d7..0000000
--- a/template/cordova/node_modules/elementtree/package.json
+++ /dev/null
@@ -1,59 +0,0 @@
-{
- "author": {
- "name": "Rackspace US, Inc."
- },
- "contributors": [
- {
- "name": "Paul Querna",
- "email": "paul.querna@rackspace.com"
- },
- {
- "name": "Tomaz Muraus",
- "email": "tomaz.muraus@rackspace.com"
- }
- ],
- "name": "elementtree",
- "description": "XML Serialization and Parsing module based on Python's ElementTree.",
- "version": "0.1.5",
- "keywords": [
- "xml",
- "sax",
- "parser",
- "seralization",
- "elementtree"
- ],
- "homepage": "https://github.com/racker/node-elementtree",
- "repository": {
- "type": "git",
- "url": "git://github.com/racker/node-elementtree.git"
- },
- "main": "lib/elementtree.js",
- "directories": {
- "lib": "lib"
- },
- "scripts": {
- "test": "make test"
- },
- "engines": {
- "node": ">= 0.4.0"
- },
- "dependencies": {
- "sax": "0.3.5"
- },
- "devDependencies": {
- "whiskey": "0.6.8"
- },
- "licenses": [
- {
- "type": "Apache",
- "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
- }
- ],
- "readme": "node-elementtree\n====================\n\nnode-elementtree is a [Node.js](http://nodejs.org) XML parser and serializer based upon the [Python ElementTree v1.3](http://effbot.org/zone/element-index.htm) module.\n\nInstallation\n====================\n\n $ npm install elementtree\n \nUsing the library\n====================\n\nFor the usage refer to the Python ElementTree library documentation - [http://effbot.org/zone/element-index.htm#usage](http://effbot.org/zone/element-index.htm#usage).\n\nSupported XPath expressions in `find`, `findall` and `findtext` methods are listed on [http://effbot.org/zone/element-xpath.htm](http://effbot.org/zone/element-xpath.htm).\n\nBuild status\n====================\n\n[](http://travis-ci.org/racker/node-elementtree)\n\n\nLicense\n====================\n\nnode-elementtree is distributed under the [Apache license](http://www.apache.org/licenses/LICENSE-2.0.html).\
n",
- "readmeFilename": "README.md",
- "bugs": {
- "url": "https://github.com/racker/node-elementtree/issues"
- },
- "_id": "elementtree@0.1.5",
- "_from": "elementtree@0.1.5"
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/.npmignore
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/.npmignore b/template/cordova/node_modules/nopt/.npmignore
deleted file mode 100644
index 3c3629e..0000000
--- a/template/cordova/node_modules/nopt/.npmignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/LICENSE
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/LICENSE b/template/cordova/node_modules/nopt/LICENSE
deleted file mode 100644
index 05a4010..0000000
--- a/template/cordova/node_modules/nopt/LICENSE
+++ /dev/null
@@ -1,23 +0,0 @@
-Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
-All rights reserved.
-
-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.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/README.md
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/README.md b/template/cordova/node_modules/nopt/README.md
deleted file mode 100644
index 5aba088..0000000
--- a/template/cordova/node_modules/nopt/README.md
+++ /dev/null
@@ -1,209 +0,0 @@
-If you want to write an option parser, and have it be good, there are
-two ways to do it. The Right Way, and the Wrong Way.
-
-The Wrong Way is to sit down and write an option parser. We've all done
-that.
-
-The Right Way is to write some complex configurable program with so many
-options that you go half-insane just trying to manage them all, and put
-it off with duct-tape solutions until you see exactly to the core of the
-problem, and finally snap and write an awesome option parser.
-
-If you want to write an option parser, don't write an option parser.
-Write a package manager, or a source control system, or a service
-restarter, or an operating system. You probably won't end up with a
-good one of those, but if you don't give up, and you are relentless and
-diligent enough in your procrastination, you may just end up with a very
-nice option parser.
-
-## USAGE
-
- // my-program.js
- var nopt = require("nopt")
- , Stream = require("stream").Stream
- , path = require("path")
- , knownOpts = { "foo" : [String, null]
- , "bar" : [Stream, Number]
- , "baz" : path
- , "bloo" : [ "big", "medium", "small" ]
- , "flag" : Boolean
- , "pick" : Boolean
- , "many" : [String, Array]
- }
- , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
- , "b7" : ["--bar", "7"]
- , "m" : ["--bloo", "medium"]
- , "p" : ["--pick"]
- , "f" : ["--flag"]
- }
- // everything is optional.
- // knownOpts and shorthands default to {}
- // arg list defaults to process.argv
- // slice defaults to 2
- , parsed = nopt(knownOpts, shortHands, process.argv, 2)
- console.log(parsed)
-
-This would give you support for any of the following:
-
-```bash
-$ node my-program.js --foo "blerp" --no-flag
-{ "foo" : "blerp", "flag" : false }
-
-$ node my-program.js ---bar 7 --foo "Mr. Hand" --flag
-{ bar: 7, foo: "Mr. Hand", flag: true }
-
-$ node my-program.js --foo "blerp" -f -----p
-{ foo: "blerp", flag: true, pick: true }
-
-$ node my-program.js -fp --foofoo
-{ foo: "Mr. Foo", flag: true, pick: true }
-
-$ node my-program.js --foofoo -- -fp # -- stops the flag parsing.
-{ foo: "Mr. Foo", argv: { remain: ["-fp"] } }
-
-$ node my-program.js --blatzk -fp # unknown opts are ok.
-{ blatzk: true, flag: true, pick: true }
-
-$ node my-program.js --blatzk=1000 -fp # but you need to use = if they have a value
-{ blatzk: 1000, flag: true, pick: true }
-
-$ node my-program.js --no-blatzk -fp # unless they start with "no-"
-{ blatzk: false, flag: true, pick: true }
-
-$ node my-program.js --baz b/a/z # known paths are resolved.
-{ baz: "/Users/isaacs/b/a/z" }
-
-# if Array is one of the types, then it can take many
-# values, and will always be an array. The other types provided
-# specify what types are allowed in the list.
-
-$ node my-program.js --many 1 --many null --many foo
-{ many: ["1", "null", "foo"] }
-
-$ node my-program.js --many foo
-{ many: ["foo"] }
-```
-
-Read the tests at the bottom of `lib/nopt.js` for more examples of
-what this puppy can do.
-
-## Types
-
-The following types are supported, and defined on `nopt.typeDefs`
-
-* String: A normal string. No parsing is done.
-* path: A file system path. Gets resolved against cwd if not absolute.
-* url: A url. If it doesn't parse, it isn't accepted.
-* Number: Must be numeric.
-* Date: Must parse as a date. If it does, and `Date` is one of the options,
- then it will return a Date object, not a string.
-* Boolean: Must be either `true` or `false`. If an option is a boolean,
- then it does not need a value, and its presence will imply `true` as
- the value. To negate boolean flags, do `--no-whatever` or `--whatever
- false`
-* NaN: Means that the option is strictly not allowed. Any value will
- fail.
-* Stream: An object matching the "Stream" class in node. Valuable
- for use when validating programmatically. (npm uses this to let you
- supply any WriteStream on the `outfd` and `logfd` config options.)
-* Array: If `Array` is specified as one of the types, then the value
- will be parsed as a list of options. This means that multiple values
- can be specified, and that the value will always be an array.
-
-If a type is an array of values not on this list, then those are
-considered valid values. For instance, in the example above, the
-`--bloo` option can only be one of `"big"`, `"medium"`, or `"small"`,
-and any other value will be rejected.
-
-When parsing unknown fields, `"true"`, `"false"`, and `"null"` will be
-interpreted as their JavaScript equivalents.
-
-You can also mix types and values, or multiple types, in a list. For
-instance `{ blah: [Number, null] }` would allow a value to be set to
-either a Number or null. When types are ordered, this implies a
-preference, and the first type that can be used to properly interpret
-the value will be used.
-
-To define a new type, add it to `nopt.typeDefs`. Each item in that
-hash is an object with a `type` member and a `validate` method. The
-`type` member is an object that matches what goes in the type list. The
-`validate` method is a function that gets called with `validate(data,
-key, val)`. Validate methods should assign `data[key]` to the valid
-value of `val` if it can be handled properly, or return boolean
-`false` if it cannot.
-
-You can also call `nopt.clean(data, types, typeDefs)` to clean up a
-config object and remove its invalid properties.
-
-## Error Handling
-
-By default, nopt outputs a warning to standard error when invalid
-options are found. You can change this behavior by assigning a method
-to `nopt.invalidHandler`. This method will be called with
-the offending `nopt.invalidHandler(key, val, types)`.
-
-If no `nopt.invalidHandler` is assigned, then it will console.error
-its whining. If it is assigned to boolean `false` then the warning is
-suppressed.
-
-## Abbreviations
-
-Yes, they are supported. If you define options like this:
-
-```javascript
-{ "foolhardyelephants" : Boolean
-, "pileofmonkeys" : Boolean }
-```
-
-Then this will work:
-
-```bash
-node program.js --foolhar --pil
-node program.js --no-f --pileofmon
-# etc.
-```
-
-## Shorthands
-
-Shorthands are a hash of shorter option names to a snippet of args that
-they expand to.
-
-If multiple one-character shorthands are all combined, and the
-combination does not unambiguously match any other option or shorthand,
-then they will be broken up into their constituent parts. For example:
-
-```json
-{ "s" : ["--loglevel", "silent"]
-, "g" : "--global"
-, "f" : "--force"
-, "p" : "--parseable"
-, "l" : "--long"
-}
-```
-
-```bash
-npm ls -sgflp
-# just like doing this:
-npm ls --loglevel silent --global --force --long --parseable
-```
-
-## The Rest of the args
-
-The config object returned by nopt is given a special member called
-`argv`, which is an object with the following fields:
-
-* `remain`: The remaining args after all the parsing has occurred.
-* `original`: The args as they originally appeared.
-* `cooked`: The args after flags and shorthands are expanded.
-
-## Slicing
-
-Node programs are called with more or less the exact argv as it appears
-in C land, after the v8 and node-specific options have been plucked off.
-As such, `argv[0]` is always `node` and `argv[1]` is always the
-JavaScript program being run.
-
-That's usually not very useful to you. So they're sliced off by
-default. If you want them, then you can pass in `0` as the last
-argument, or any other number that you'd like to slice off the start of
-the list.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/bin/nopt.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/bin/nopt.js b/template/cordova/node_modules/nopt/bin/nopt.js
deleted file mode 100644
index 3232d4c..0000000
--- a/template/cordova/node_modules/nopt/bin/nopt.js
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-var nopt = require("../lib/nopt")
- , path = require("path")
- , types = { num: Number
- , bool: Boolean
- , help: Boolean
- , list: Array
- , "num-list": [Number, Array]
- , "str-list": [String, Array]
- , "bool-list": [Boolean, Array]
- , str: String
- , clear: Boolean
- , config: Boolean
- , length: Number
- , file: path
- }
- , shorthands = { s: [ "--str", "astring" ]
- , b: [ "--bool" ]
- , nb: [ "--no-bool" ]
- , tft: [ "--bool-list", "--no-bool-list", "--bool-list", "true" ]
- , "?": ["--help"]
- , h: ["--help"]
- , H: ["--help"]
- , n: [ "--num", "125" ]
- , c: ["--config"]
- , l: ["--length"]
- , f: ["--file"]
- }
- , parsed = nopt( types
- , shorthands
- , process.argv
- , 2 )
-
-console.log("parsed", parsed)
-
-if (parsed.help) {
- console.log("")
- console.log("nopt cli tester")
- console.log("")
- console.log("types")
- console.log(Object.keys(types).map(function M (t) {
- var type = types[t]
- if (Array.isArray(type)) {
- return [t, type.map(function (type) { return type.name })]
- }
- return [t, type && type.name]
- }).reduce(function (s, i) {
- s[i[0]] = i[1]
- return s
- }, {}))
- console.log("")
- console.log("shorthands")
- console.log(shorthands)
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/examples/my-program.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/examples/my-program.js b/template/cordova/node_modules/nopt/examples/my-program.js
deleted file mode 100644
index 142447e..0000000
--- a/template/cordova/node_modules/nopt/examples/my-program.js
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-
-//process.env.DEBUG_NOPT = 1
-
-// my-program.js
-var nopt = require("../lib/nopt")
- , Stream = require("stream").Stream
- , path = require("path")
- , knownOpts = { "foo" : [String, null]
- , "bar" : [Stream, Number]
- , "baz" : path
- , "bloo" : [ "big", "medium", "small" ]
- , "flag" : Boolean
- , "pick" : Boolean
- }
- , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
- , "b7" : ["--bar", "7"]
- , "m" : ["--bloo", "medium"]
- , "p" : ["--pick"]
- , "f" : ["--flag", "true"]
- , "g" : ["--flag"]
- , "s" : "--flag"
- }
- // everything is optional.
- // knownOpts and shorthands default to {}
- // arg list defaults to process.argv
- // slice defaults to 2
- , parsed = nopt(knownOpts, shortHands, process.argv, 2)
-
-console.log("parsed =\n"+ require("util").inspect(parsed))
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/lib/nopt.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/lib/nopt.js b/template/cordova/node_modules/nopt/lib/nopt.js
deleted file mode 100644
index 5309a00..0000000
--- a/template/cordova/node_modules/nopt/lib/nopt.js
+++ /dev/null
@@ -1,414 +0,0 @@
-// info about each config option.
-
-var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
- ? function () { console.error.apply(console, arguments) }
- : function () {}
-
-var url = require("url")
- , path = require("path")
- , Stream = require("stream").Stream
- , abbrev = require("abbrev")
-
-module.exports = exports = nopt
-exports.clean = clean
-
-exports.typeDefs =
- { String : { type: String, validate: validateString }
- , Boolean : { type: Boolean, validate: validateBoolean }
- , url : { type: url, validate: validateUrl }
- , Number : { type: Number, validate: validateNumber }
- , path : { type: path, validate: validatePath }
- , Stream : { type: Stream, validate: validateStream }
- , Date : { type: Date, validate: validateDate }
- }
-
-function nopt (types, shorthands, args, slice) {
- args = args || process.argv
- types = types || {}
- shorthands = shorthands || {}
- if (typeof slice !== "number") slice = 2
-
- debug(types, shorthands, args, slice)
-
- args = args.slice(slice)
- var data = {}
- , key
- , remain = []
- , cooked = args
- , original = args.slice(0)
-
- parse(args, data, remain, types, shorthands)
- // now data is full
- clean(data, types, exports.typeDefs)
- data.argv = {remain:remain,cooked:cooked,original:original}
- Object.defineProperty(data.argv, 'toString', { value: function () {
- return this.original.map(JSON.stringify).join(" ")
- }, enumerable: false })
- return data
-}
-
-function clean (data, types, typeDefs) {
- typeDefs = typeDefs || exports.typeDefs
- var remove = {}
- , typeDefault = [false, true, null, String, Array]
-
- Object.keys(data).forEach(function (k) {
- if (k === "argv") return
- var val = data[k]
- , isArray = Array.isArray(val)
- , type = types[k]
- if (!isArray) val = [val]
- if (!type) type = typeDefault
- if (type === Array) type = typeDefault.concat(Array)
- if (!Array.isArray(type)) type = [type]
-
- debug("val=%j", val)
- debug("types=", type)
- val = val.map(function (val) {
- // if it's an unknown value, then parse false/true/null/numbers/dates
- if (typeof val === "string") {
- debug("string %j", val)
- val = val.trim()
- if ((val === "null" && ~type.indexOf(null))
- || (val === "true" &&
- (~type.indexOf(true) || ~type.indexOf(Boolean)))
- || (val === "false" &&
- (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
- val = JSON.parse(val)
- debug("jsonable %j", val)
- } else if (~type.indexOf(Number) && !isNaN(val)) {
- debug("convert to number", val)
- val = +val
- } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
- debug("convert to date", val)
- val = new Date(val)
- }
- }
-
- if (!types.hasOwnProperty(k)) {
- return val
- }
-
- // allow `--no-blah` to set 'blah' to null if null is allowed
- if (val === false && ~type.indexOf(null) &&
- !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
- val = null
- }
-
- var d = {}
- d[k] = val
- debug("prevalidated val", d, val, types[k])
- if (!validate(d, k, val, types[k], typeDefs)) {
- if (exports.invalidHandler) {
- exports.invalidHandler(k, val, types[k], data)
- } else if (exports.invalidHandler !== false) {
- debug("invalid: "+k+"="+val, types[k])
- }
- return remove
- }
- debug("validated val", d, val, types[k])
- return d[k]
- }).filter(function (val) { return val !== remove })
-
- if (!val.length) delete data[k]
- else if (isArray) {
- debug(isArray, data[k], val)
- data[k] = val
- } else data[k] = val[0]
-
- debug("k=%s val=%j", k, val, data[k])
- })
-}
-
-function validateString (data, k, val) {
- data[k] = String(val)
-}
-
-function validatePath (data, k, val) {
- if (val === true) return false
- if (val === null) return true
-
- val = String(val)
- var homePattern = process.platform === 'win32' ? /^~(\/|\\)/ : /^~\//
- if (val.match(homePattern) && process.env.HOME) {
- val = path.resolve(process.env.HOME, val.substr(2))
- }
- data[k] = path.resolve(String(val))
- return true
-}
-
-function validateNumber (data, k, val) {
- debug("validate Number %j %j %j", k, val, isNaN(val))
- if (isNaN(val)) return false
- data[k] = +val
-}
-
-function validateDate (data, k, val) {
- debug("validate Date %j %j %j", k, val, Date.parse(val))
- var s = Date.parse(val)
- if (isNaN(s)) return false
- data[k] = new Date(val)
-}
-
-function validateBoolean (data, k, val) {
- if (val instanceof Boolean) val = val.valueOf()
- else if (typeof val === "string") {
- if (!isNaN(val)) val = !!(+val)
- else if (val === "null" || val === "false") val = false
- else val = true
- } else val = !!val
- data[k] = val
-}
-
-function validateUrl (data, k, val) {
- val = url.parse(String(val))
- if (!val.host) return false
- data[k] = val.href
-}
-
-function validateStream (data, k, val) {
- if (!(val instanceof Stream)) return false
- data[k] = val
-}
-
-function validate (data, k, val, type, typeDefs) {
- // arrays are lists of types.
- if (Array.isArray(type)) {
- for (var i = 0, l = type.length; i < l; i ++) {
- if (type[i] === Array) continue
- if (validate(data, k, val, type[i], typeDefs)) return true
- }
- delete data[k]
- return false
- }
-
- // an array of anything?
- if (type === Array) return true
-
- // NaN is poisonous. Means that something is not allowed.
- if (type !== type) {
- debug("Poison NaN", k, val, type)
- delete data[k]
- return false
- }
-
- // explicit list of values
- if (val === type) {
- debug("Explicitly allowed %j", val)
- // if (isArray) (data[k] = data[k] || []).push(val)
- // else data[k] = val
- data[k] = val
- return true
- }
-
- // now go through the list of typeDefs, validate against each one.
- var ok = false
- , types = Object.keys(typeDefs)
- for (var i = 0, l = types.length; i < l; i ++) {
- debug("test type %j %j %j", k, val, types[i])
- var t = typeDefs[types[i]]
- if (t && type === t.type) {
- var d = {}
- ok = false !== t.validate(d, k, val)
- val = d[k]
- if (ok) {
- // if (isArray) (data[k] = data[k] || []).push(val)
- // else data[k] = val
- data[k] = val
- break
- }
- }
- }
- debug("OK? %j (%j %j %j)", ok, k, val, types[i])
-
- if (!ok) delete data[k]
- return ok
-}
-
-function parse (args, data, remain, types, shorthands) {
- debug("parse", args, data, remain)
-
- var key = null
- , abbrevs = abbrev(Object.keys(types))
- , shortAbbr = abbrev(Object.keys(shorthands))
-
- for (var i = 0; i < args.length; i ++) {
- var arg = args[i]
- debug("arg", arg)
-
- if (arg.match(/^-{2,}$/)) {
- // done with keys.
- // the rest are args.
- remain.push.apply(remain, args.slice(i + 1))
- args[i] = "--"
- break
- }
- var hadEq = false
- if (arg.charAt(0) === "-" && arg.length > 1) {
- if (arg.indexOf("=") !== -1) {
- hadEq = true
- var v = arg.split("=")
- arg = v.shift()
- v = v.join("=")
- args.splice.apply(args, [i, 1].concat([arg, v]))
- }
-
- // see if it's a shorthand
- // if so, splice and back up to re-parse it.
- var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs)
- debug("arg=%j shRes=%j", arg, shRes)
- if (shRes) {
- debug(arg, shRes)
- args.splice.apply(args, [i, 1].concat(shRes))
- if (arg !== shRes[0]) {
- i --
- continue
- }
- }
- arg = arg.replace(/^-+/, "")
- var no = null
- while (arg.toLowerCase().indexOf("no-") === 0) {
- no = !no
- arg = arg.substr(3)
- }
-
- if (abbrevs[arg]) arg = abbrevs[arg]
-
- var isArray = types[arg] === Array ||
- Array.isArray(types[arg]) && types[arg].indexOf(Array) !== -1
-
- // allow unknown things to be arrays if specified multiple times.
- if (!types.hasOwnProperty(arg) && data.hasOwnProperty(arg)) {
- if (!Array.isArray(data[arg]))
- data[arg] = [data[arg]]
- isArray = true
- }
-
- var val
- , la = args[i + 1]
-
- var isBool = typeof no === 'boolean' ||
- types[arg] === Boolean ||
- Array.isArray(types[arg]) && types[arg].indexOf(Boolean) !== -1 ||
- (typeof types[arg] === 'undefined' && !hadEq) ||
- (la === "false" &&
- (types[arg] === null ||
- Array.isArray(types[arg]) && ~types[arg].indexOf(null)))
-
- if (isBool) {
- // just set and move along
- val = !no
- // however, also support --bool true or --bool false
- if (la === "true" || la === "false") {
- val = JSON.parse(la)
- la = null
- if (no) val = !val
- i ++
- }
-
- // also support "foo":[Boolean, "bar"] and "--foo bar"
- if (Array.isArray(types[arg]) && la) {
- if (~types[arg].indexOf(la)) {
- // an explicit type
- val = la
- i ++
- } else if ( la === "null" && ~types[arg].indexOf(null) ) {
- // null allowed
- val = null
- i ++
- } else if ( !la.match(/^-{2,}[^-]/) &&
- !isNaN(la) &&
- ~types[arg].indexOf(Number) ) {
- // number
- val = +la
- i ++
- } else if ( !la.match(/^-[^-]/) && ~types[arg].indexOf(String) ) {
- // string
- val = la
- i ++
- }
- }
-
- if (isArray) (data[arg] = data[arg] || []).push(val)
- else data[arg] = val
-
- continue
- }
-
- if (types[arg] === String && la === undefined)
- la = ""
-
- if (la && la.match(/^-{2,}$/)) {
- la = undefined
- i --
- }
-
- val = la === undefined ? true : la
- if (isArray) (data[arg] = data[arg] || []).push(val)
- else data[arg] = val
-
- i ++
- continue
- }
- remain.push(arg)
- }
-}
-
-function resolveShort (arg, shorthands, shortAbbr, abbrevs) {
- // handle single-char shorthands glommed together, like
- // npm ls -glp, but only if there is one dash, and only if
- // all of the chars are single-char shorthands, and it's
- // not a match to some other abbrev.
- arg = arg.replace(/^-+/, '')
-
- // if it's an exact known option, then don't go any further
- if (abbrevs[arg] === arg)
- return null
-
- // if it's an exact known shortopt, same deal
- if (shorthands[arg]) {
- // make it an array, if it's a list of words
- if (shorthands[arg] && !Array.isArray(shorthands[arg]))
- shorthands[arg] = shorthands[arg].split(/\s+/)
-
- return shorthands[arg]
- }
-
- // first check to see if this arg is a set of single-char shorthands
- var singles = shorthands.___singles
- if (!singles) {
- singles = Object.keys(shorthands).filter(function (s) {
- return s.length === 1
- }).reduce(function (l,r) {
- l[r] = true
- return l
- }, {})
- shorthands.___singles = singles
- debug('shorthand singles', singles)
- }
-
- var chrs = arg.split("").filter(function (c) {
- return singles[c]
- })
-
- if (chrs.join("") === arg) return chrs.map(function (c) {
- return shorthands[c]
- }).reduce(function (l, r) {
- return l.concat(r)
- }, [])
-
-
- // if it's an arg abbrev, and not a literal shorthand, then prefer the arg
- if (abbrevs[arg] && !shorthands[arg])
- return null
-
- // if it's an abbr for a shorthand, then use that
- if (shortAbbr[arg])
- arg = shortAbbr[arg]
-
- // make it an array, if it's a list of words
- if (shorthands[arg] && !Array.isArray(shorthands[arg]))
- shorthands[arg] = shorthands[arg].split(/\s+/)
-
- return shorthands[arg]
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/CONTRIBUTING.md b/template/cordova/node_modules/nopt/node_modules/abbrev/CONTRIBUTING.md
deleted file mode 100644
index 2f30261..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/CONTRIBUTING.md
+++ /dev/null
@@ -1,3 +0,0 @@
- To get started, <a
- href="http://www.clahub.com/agreements/isaacs/abbrev-js">sign the
- Contributor License Agreement</a>.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/LICENSE
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/LICENSE b/template/cordova/node_modules/nopt/node_modules/abbrev/LICENSE
deleted file mode 100644
index 05a4010..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/LICENSE
+++ /dev/null
@@ -1,23 +0,0 @@
-Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
-All rights reserved.
-
-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.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/README.md
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/README.md b/template/cordova/node_modules/nopt/node_modules/abbrev/README.md
deleted file mode 100644
index 99746fe..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/README.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# abbrev-js
-
-Just like [ruby's Abbrev](http://apidock.com/ruby/Abbrev).
-
-Usage:
-
- var abbrev = require("abbrev");
- abbrev("foo", "fool", "folding", "flop");
-
- // returns:
- { fl: 'flop'
- , flo: 'flop'
- , flop: 'flop'
- , fol: 'folding'
- , fold: 'folding'
- , foldi: 'folding'
- , foldin: 'folding'
- , folding: 'folding'
- , foo: 'foo'
- , fool: 'fool'
- }
-
-This is handy for command-line scripts, or other cases where you want to be able to accept shorthands.
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/abbrev.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/abbrev.js b/template/cordova/node_modules/nopt/node_modules/abbrev/abbrev.js
deleted file mode 100644
index 69cfeac..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/abbrev.js
+++ /dev/null
@@ -1,62 +0,0 @@
-
-module.exports = exports = abbrev.abbrev = abbrev
-
-abbrev.monkeyPatch = monkeyPatch
-
-function monkeyPatch () {
- Object.defineProperty(Array.prototype, 'abbrev', {
- value: function () { return abbrev(this) },
- enumerable: false, configurable: true, writable: true
- })
-
- Object.defineProperty(Object.prototype, 'abbrev', {
- value: function () { return abbrev(Object.keys(this)) },
- enumerable: false, configurable: true, writable: true
- })
-}
-
-function abbrev (list) {
- if (arguments.length !== 1 || !Array.isArray(list)) {
- list = Array.prototype.slice.call(arguments, 0)
- }
- for (var i = 0, l = list.length, args = [] ; i < l ; i ++) {
- args[i] = typeof list[i] === "string" ? list[i] : String(list[i])
- }
-
- // sort them lexicographically, so that they're next to their nearest kin
- args = args.sort(lexSort)
-
- // walk through each, seeing how much it has in common with the next and previous
- var abbrevs = {}
- , prev = ""
- for (var i = 0, l = args.length ; i < l ; i ++) {
- var current = args[i]
- , next = args[i + 1] || ""
- , nextMatches = true
- , prevMatches = true
- if (current === next) continue
- for (var j = 0, cl = current.length ; j < cl ; j ++) {
- var curChar = current.charAt(j)
- nextMatches = nextMatches && curChar === next.charAt(j)
- prevMatches = prevMatches && curChar === prev.charAt(j)
- if (!nextMatches && !prevMatches) {
- j ++
- break
- }
- }
- prev = current
- if (j === cl) {
- abbrevs[current] = current
- continue
- }
- for (var a = current.substr(0, j) ; j <= cl ; j ++) {
- abbrevs[a] = current
- a += current.charAt(j)
- }
- }
- return abbrevs
-}
-
-function lexSort (a, b) {
- return a === b ? 0 : a > b ? 1 : -1
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/package.json
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/package.json b/template/cordova/node_modules/nopt/node_modules/abbrev/package.json
deleted file mode 100644
index b189020..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/package.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
- "name": "abbrev",
- "version": "1.0.5",
- "description": "Like ruby's abbrev module, but in js",
- "author": {
- "name": "Isaac Z. Schlueter",
- "email": "i@izs.me"
- },
- "main": "abbrev.js",
- "scripts": {
- "test": "node test.js"
- },
- "repository": {
- "type": "git",
- "url": "http://github.com/isaacs/abbrev-js"
- },
- "license": {
- "type": "MIT",
- "url": "https://github.com/isaacs/abbrev-js/raw/master/LICENSE"
- },
- "readme": "# abbrev-js\n\nJust like [ruby's Abbrev](http://apidock.com/ruby/Abbrev).\n\nUsage:\n\n var abbrev = require(\"abbrev\");\n abbrev(\"foo\", \"fool\", \"folding\", \"flop\");\n \n // returns:\n { fl: 'flop'\n , flo: 'flop'\n , flop: 'flop'\n , fol: 'folding'\n , fold: 'folding'\n , foldi: 'folding'\n , foldin: 'folding'\n , folding: 'folding'\n , foo: 'foo'\n , fool: 'fool'\n }\n\nThis is handy for command-line scripts, or other cases where you want to be able to accept shorthands.\n",
- "readmeFilename": "README.md",
- "bugs": {
- "url": "https://github.com/isaacs/abbrev-js/issues"
- },
- "homepage": "https://github.com/isaacs/abbrev-js",
- "_id": "abbrev@1.0.5",
- "_from": "abbrev@1"
-}
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/52c99052/template/cordova/node_modules/nopt/node_modules/abbrev/test.js
----------------------------------------------------------------------
diff --git a/template/cordova/node_modules/nopt/node_modules/abbrev/test.js b/template/cordova/node_modules/nopt/node_modules/abbrev/test.js
deleted file mode 100644
index d5a7303..0000000
--- a/template/cordova/node_modules/nopt/node_modules/abbrev/test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-var abbrev = require('./abbrev.js')
-var assert = require("assert")
-var util = require("util")
-
-console.log("TAP Version 13")
-var count = 0
-
-function test (list, expect) {
- count++
- var actual = abbrev(list)
- assert.deepEqual(actual, expect,
- "abbrev("+util.inspect(list)+") === " + util.inspect(expect) + "\n"+
- "actual: "+util.inspect(actual))
- actual = abbrev.apply(exports, list)
- assert.deepEqual(abbrev.apply(exports, list), expect,
- "abbrev("+list.map(JSON.stringify).join(",")+") === " + util.inspect(expect) + "\n"+
- "actual: "+util.inspect(actual))
- console.log('ok - ' + list.join(' '))
-}
-
-test([ "ruby", "ruby", "rules", "rules", "rules" ],
-{ rub: 'ruby'
-, ruby: 'ruby'
-, rul: 'rules'
-, rule: 'rules'
-, rules: 'rules'
-})
-test(["fool", "foom", "pool", "pope"],
-{ fool: 'fool'
-, foom: 'foom'
-, poo: 'pool'
-, pool: 'pool'
-, pop: 'pope'
-, pope: 'pope'
-})
-test(["a", "ab", "abc", "abcd", "abcde", "acde"],
-{ a: 'a'
-, ab: 'ab'
-, abc: 'abc'
-, abcd: 'abcd'
-, abcde: 'abcde'
-, ac: 'acde'
-, acd: 'acde'
-, acde: 'acde'
-})
-
-console.log("0..%d", count)