| // 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.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.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 () { 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]] = "" |
| } |
| } |
| |
| 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) } |
| } |
| |
| 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(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) |
| 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) { |
| 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) |
| } |
| |
| |
| |
| // 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 | "_" | ":") |
| , 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) |
| |
| // 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-]/ |
| |
| 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 isRegExp (c) { |
| return Object.prototype.toString.call(c) === '[object RegExp]' |
| } |
| |
| function is (charclass, c) { |
| return isRegExp(charclass) ? !!c.match(charclass) : charclass[c] |
| } |
| |
| function not (charclass, c) { |
| return !is(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_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.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.closedRoot) strictFail(parser, "Unclosed root tag") |
| if ((parser.state !== S.BEGIN) && (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 |
| , 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, attribute) { |
| var i = name.indexOf(":") |
| , qualName = i < 0 ? [ "", name ] : name.split(":") |
| , prefix = qualName[0] |
| , 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)) { |
| return parser.attribName = parser.attribValue = "" |
| } |
| |
| if (parser.opt.xmlns) { |
| var qn = qname(parser.attribName, true) |
| , 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] || "" |
| |
| 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] |
| , value = nv[1] |
| , qualName = qname(name, true) |
| , prefix = qualName.prefix |
| , local = qualName.local |
| , uri = prefix == "" ? "" : (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 |
| } |
| |
| 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 |
| , entityLC = entity.toLowerCase() |
| , num |
| , 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 (numStr.toLowerCase() !== entity) { |
| strictFail(parser, "Invalid character entity") |
| return "&"+parser.entity + ";" |
| } |
| |
| return String.fromCodePoint(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++)) { |
| if (parser.trackPosition) { |
| 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 |
| parser.startTagPosition = parser.position |
| } 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.trackPosition) { |
| 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 |
| parser.startTagPosition = parser.position |
| } else { |
| if (not(whitespace, 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 (is(whitespace, c)) { |
| // wait for it... |
| } else if (is(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 (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 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 (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 (c === ">") { |
| strictFail(parser, "Attribute without value") |
| parser.attribValue = parser.attribName |
| attrib(parser) |
| openTag(parser) |
| } |
| 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_VALUE_CLOSED |
| continue |
| |
| case S.ATTRIB_VALUE_CLOSED: |
| if (is(whitespace, c)) { |
| parser.state = S.ATTRIB |
| } else if (c === ">") openTag(parser) |
| else if (c === "/") parser.state = S.OPEN_TAG_SLASH |
| else if (is(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 (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)) { |
| 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 (is(nameBody, c)) parser.tagName += c |
| else if (parser.script) { |
| parser.script += "</" + parser.tagName |
| parser.tagName = "" |
| parser.state = S.SCRIPT |
| } 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(parser, "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(parser, "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 |
| } |
| |
| /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ |
| 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; |
| }; |
| if (Object.defineProperty) { |
| Object.defineProperty(String, 'fromCodePoint', { |
| 'value': fromCodePoint, |
| 'configurable': true, |
| 'writable': true |
| }); |
| } else { |
| String.fromCodePoint = fromCodePoint; |
| } |
| }()); |
| } |
| |
| })(typeof exports === "undefined" ? sax = {} : exports) |
