diff options
Diffstat (limited to 'node_modules/sax/lib/sax.js')
| -rw-r--r-- | node_modules/sax/lib/sax.js | 1581 |
1 files changed, 0 insertions, 1581 deletions
diff --git a/node_modules/sax/lib/sax.js b/node_modules/sax/lib/sax.js deleted file mode 100644 index db0d4c316..000000000 --- a/node_modules/sax/lib/sax.js +++ /dev/null @@ -1,1581 +0,0 @@ -;(function (sax) { // wrapper for non-node envs - sax.parser = function (strict, opt) { return new SAXParser(strict, opt) } - sax.SAXParser = SAXParser - sax.SAXStream = SAXStream - sax.createStream = createStream - - // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns. - // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)), - // since that's the earliest that a buffer overrun could occur. This way, checks are - // as rare as required, but as often as necessary to ensure never crossing this bound. - // Furthermore, buffers are only tested at most once per write(), so passing a very - // large string into write() might have undesirable effects, but this is manageable by - // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme - // edge case, result in creating at most one complete copy of the string passed in. - // Set to Infinity to have unlimited buffers. - sax.MAX_BUFFER_LENGTH = 64 * 1024 - - var buffers = [ - 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype', - 'procInstName', 'procInstBody', 'entity', 'attribName', - 'attribValue', 'cdata', 'script' - ] - - sax.EVENTS = [ - 'text', - 'processinginstruction', - 'sgmldeclaration', - 'doctype', - 'comment', - 'opentagstart', - 'attribute', - 'opentag', - 'closetag', - 'opencdata', - 'cdata', - 'closecdata', - 'error', - 'end', - 'ready', - 'script', - 'opennamespace', - 'closenamespace' - ] - - function SAXParser (strict, opt) { - if (!(this instanceof SAXParser)) { - return new SAXParser(strict, opt) - } - - var parser = this - clearBuffers(parser) - parser.q = parser.c = '' - parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH - parser.opt = opt || {} - parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags - parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase' - parser.tags = [] - parser.closed = parser.closedRoot = parser.sawRoot = false - parser.tag = parser.error = null - parser.strict = !!strict - parser.noscript = !!(strict || parser.opt.noscript) - parser.state = S.BEGIN - parser.strictEntities = parser.opt.strictEntities - parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES) - parser.attribList = [] - - // namespaces form a prototype chain. - // it always points at the current tag, - // which protos to its parent tag. - if (parser.opt.xmlns) { - parser.ns = Object.create(rootNS) - } - - // mostly just for error reporting - parser.trackPosition = parser.opt.position !== false - if (parser.trackPosition) { - parser.position = parser.line = parser.column = 0 - } - emit(parser, 'onready') - } - - if (!Object.create) { - Object.create = function (o) { - function F () {} - F.prototype = o - var newf = new F() - return newf - } - } - - if (!Object.keys) { - Object.keys = function (o) { - var a = [] - for (var i in o) if (o.hasOwnProperty(i)) a.push(i) - return a - } - } - - function checkBufferLength (parser) { - var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10) - var maxActual = 0 - for (var i = 0, l = buffers.length; i < l; i++) { - var len = parser[buffers[i]].length - if (len > maxAllowed) { - // Text/cdata nodes can get big, and since they're buffered, - // we can get here under normal conditions. - // Avoid issues by emitting the text node now, - // so at least it won't get any bigger. - switch (buffers[i]) { - case 'textNode': - closeText(parser) - break - - case 'cdata': - emitNode(parser, 'oncdata', parser.cdata) - parser.cdata = '' - break - - case 'script': - emitNode(parser, 'onscript', parser.script) - parser.script = '' - break - - default: - error(parser, 'Max buffer length exceeded: ' + buffers[i]) - } - } - maxActual = Math.max(maxActual, len) - } - // schedule the next check for the earliest possible buffer overrun. - var m = sax.MAX_BUFFER_LENGTH - maxActual - parser.bufferCheckPosition = m + parser.position - } - - function clearBuffers (parser) { - for (var i = 0, l = buffers.length; i < l; i++) { - parser[buffers[i]] = '' - } - } - - function flushBuffers (parser) { - closeText(parser) - if (parser.cdata !== '') { - emitNode(parser, 'oncdata', parser.cdata) - parser.cdata = '' - } - if (parser.script !== '') { - emitNode(parser, 'onscript', parser.script) - parser.script = '' - } - } - - SAXParser.prototype = { - end: function () { end(this) }, - write: write, - resume: function () { this.error = null; return this }, - close: function () { return this.write(null) }, - flush: function () { flushBuffers(this) } - } - - var Stream - try { - Stream = require('stream').Stream - } catch (ex) { - Stream = function () {} - } - - var streamWraps = sax.EVENTS.filter(function (ev) { - return ev !== 'error' && ev !== 'end' - }) - - function createStream (strict, opt) { - return new SAXStream(strict, opt) - } - - function SAXStream (strict, opt) { - if (!(this instanceof SAXStream)) { - return new SAXStream(strict, opt) - } - - Stream.apply(this) - - this._parser = new SAXParser(strict, opt) - this.writable = true - this.readable = true - - var me = this - - this._parser.onend = function () { - me.emit('end') - } - - this._parser.onerror = function (er) { - me.emit('error', er) - - // if didn't throw, then means error was handled. - // go ahead and clear error, so we can write again. - me._parser.error = null - } - - this._decoder = null - - streamWraps.forEach(function (ev) { - Object.defineProperty(me, 'on' + ev, { - get: function () { - return me._parser['on' + ev] - }, - set: function (h) { - if (!h) { - me.removeAllListeners(ev) - me._parser['on' + ev] = h - return h - } - me.on(ev, h) - }, - enumerable: true, - configurable: false - }) - }) - } - - SAXStream.prototype = Object.create(Stream.prototype, { - constructor: { - value: SAXStream - } - }) - - SAXStream.prototype.write = function (data) { - if (typeof Buffer === 'function' && - typeof Buffer.isBuffer === 'function' && - Buffer.isBuffer(data)) { - if (!this._decoder) { - var SD = require('string_decoder').StringDecoder - this._decoder = new SD('utf8') - } - data = this._decoder.write(data) - } - - this._parser.write(data.toString()) - this.emit('data', data) - return true - } - - SAXStream.prototype.end = function (chunk) { - if (chunk && chunk.length) { - this.write(chunk) - } - this._parser.end() - return true - } - - SAXStream.prototype.on = function (ev, handler) { - var me = this - if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) { - me._parser['on' + ev] = function () { - var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments) - args.splice(0, 0, ev) - me.emit.apply(me, args) - } - } - - return Stream.prototype.on.call(me, ev, handler) - } - - // 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. - - // (Letter | "_" | ":") - var quote = '\'"' - var attribEnd = whitespace + '>' - var CDATA = '[CDATA[' - var DOCTYPE = 'DOCTYPE' - var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace' - var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/' - var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE } - - // turn all the string character sets into character class objects. - whitespace = charClass(whitespace) - - // http://www.w3.org/TR/REC-xml/#NT-NameStartChar - // This implementation works on strings, a single character at a time - // as such, it cannot ever support astral-plane characters (10000-EFFFF) - // without a significant breaking change to either this parser, or the - // JavaScript language. Implementation of an emoji-capable xml parser - // is left as an exercise for the reader. - var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ - - var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ - - var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ - var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ - - quote = charClass(quote) - attribEnd = charClass(attribEnd) - - function charClass (str) { - return str.split('').reduce(function (s, c) { - s[c] = true - return s - }, {}) - } - - function isMatch (regex, c) { - return regex.test(c) - } - - function is (charclass, c) { - return charclass[c] - } - - function notMatch (regex, c) { - return !isMatch(regex, c) - } - - function not (charclass, c) { - return !is(charclass, c) - } - - var S = 0 - sax.STATE = { - BEGIN: S++, // leading byte order mark or whitespace - BEGIN_WHITESPACE: S++, // leading whitespace - TEXT: S++, // general stuff - TEXT_ENTITY: S++, // & and such. - OPEN_WAKA: S++, // < - SGML_DECL: S++, // <!BLARG - SGML_DECL_QUOTED: S++, // <!BLARG foo "bar - DOCTYPE: S++, // <!DOCTYPE - DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah - DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ... - DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo - COMMENT_STARTING: S++, // <!- - COMMENT: S++, // <!-- - COMMENT_ENDING: S++, // <!-- blah - - COMMENT_ENDED: S++, // <!-- blah -- - CDATA: S++, // <![CDATA[ something - CDATA_ENDING: S++, // ] - CDATA_ENDING_2: S++, // ]] - PROC_INST: S++, // <?hi - PROC_INST_BODY: S++, // <?hi there - PROC_INST_ENDING: S++, // <?hi "there" ? - OPEN_TAG: S++, // <strong - OPEN_TAG_SLASH: S++, // <strong / - ATTRIB: S++, // <a - ATTRIB_NAME: S++, // <a foo - ATTRIB_NAME_SAW_WHITE: S++, // <a foo _ - ATTRIB_VALUE: S++, // <a foo= - ATTRIB_VALUE_QUOTED: S++, // <a foo="bar - ATTRIB_VALUE_CLOSED: S++, // <a foo="bar" - ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar - ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar=""" - ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=" - CLOSE_TAG: S++, // </a - CLOSE_TAG_SAW_WHITE: S++, // </a > - SCRIPT: S++, // <script> ... - SCRIPT_ENDING: S++ // <script> ... < - } - - sax.XML_ENTITIES = { - 'amp': '&', - 'gt': '>', - 'lt': '<', - 'quot': '"', - 'apos': "'" - } - - sax.ENTITIES = { - 'amp': '&', - 'gt': '>', - 'lt': '<', - 'quot': '"', - 'apos': "'", - 'AElig': 198, - 'Aacute': 193, - 'Acirc': 194, - 'Agrave': 192, - 'Aring': 197, - 'Atilde': 195, - 'Auml': 196, - 'Ccedil': 199, - 'ETH': 208, - 'Eacute': 201, - 'Ecirc': 202, - 'Egrave': 200, - 'Euml': 203, - 'Iacute': 205, - 'Icirc': 206, - 'Igrave': 204, - 'Iuml': 207, - 'Ntilde': 209, - 'Oacute': 211, - 'Ocirc': 212, - 'Ograve': 210, - 'Oslash': 216, - 'Otilde': 213, - 'Ouml': 214, - 'THORN': 222, - 'Uacute': 218, - 'Ucirc': 219, - 'Ugrave': 217, - 'Uuml': 220, - 'Yacute': 221, - 'aacute': 225, - 'acirc': 226, - 'aelig': 230, - 'agrave': 224, - 'aring': 229, - 'atilde': 227, - 'auml': 228, - 'ccedil': 231, - 'eacute': 233, - 'ecirc': 234, - 'egrave': 232, - 'eth': 240, - 'euml': 235, - 'iacute': 237, - 'icirc': 238, - 'igrave': 236, - 'iuml': 239, - 'ntilde': 241, - 'oacute': 243, - 'ocirc': 244, - 'ograve': 242, - 'oslash': 248, - 'otilde': 245, - 'ouml': 246, - 'szlig': 223, - 'thorn': 254, - 'uacute': 250, - 'ucirc': 251, - 'ugrave': 249, - 'uuml': 252, - 'yacute': 253, - 'yuml': 255, - 'copy': 169, - 'reg': 174, - 'nbsp': 160, - 'iexcl': 161, - 'cent': 162, - 'pound': 163, - 'curren': 164, - 'yen': 165, - 'brvbar': 166, - 'sect': 167, - 'uml': 168, - 'ordf': 170, - 'laquo': 171, - 'not': 172, - 'shy': 173, - 'macr': 175, - 'deg': 176, - 'plusmn': 177, - 'sup1': 185, - 'sup2': 178, - 'sup3': 179, - 'acute': 180, - 'micro': 181, - 'para': 182, - 'middot': 183, - 'cedil': 184, - 'ordm': 186, - 'raquo': 187, - 'frac14': 188, - 'frac12': 189, - 'frac34': 190, - 'iquest': 191, - 'times': 215, - 'divide': 247, - 'OElig': 338, - 'oelig': 339, - 'Scaron': 352, - 'scaron': 353, - 'Yuml': 376, - 'fnof': 402, - 'circ': 710, - 'tilde': 732, - 'Alpha': 913, - 'Beta': 914, - 'Gamma': 915, - 'Delta': 916, - 'Epsilon': 917, - 'Zeta': 918, - 'Eta': 919, - 'Theta': 920, - 'Iota': 921, - 'Kappa': 922, - 'Lambda': 923, - 'Mu': 924, - 'Nu': 925, - 'Xi': 926, - 'Omicron': 927, - 'Pi': 928, - 'Rho': 929, - 'Sigma': 931, - 'Tau': 932, - 'Upsilon': 933, - 'Phi': 934, - 'Chi': 935, - 'Psi': 936, - 'Omega': 937, - 'alpha': 945, - 'beta': 946, - 'gamma': 947, - 'delta': 948, - 'epsilon': 949, - 'zeta': 950, - 'eta': 951, - 'theta': 952, - 'iota': 953, - 'kappa': 954, - 'lambda': 955, - 'mu': 956, - 'nu': 957, - 'xi': 958, - 'omicron': 959, - 'pi': 960, - 'rho': 961, - 'sigmaf': 962, - 'sigma': 963, - 'tau': 964, - 'upsilon': 965, - 'phi': 966, - 'chi': 967, - 'psi': 968, - 'omega': 969, - 'thetasym': 977, - 'upsih': 978, - 'piv': 982, - 'ensp': 8194, - 'emsp': 8195, - 'thinsp': 8201, - 'zwnj': 8204, - 'zwj': 8205, - 'lrm': 8206, - 'rlm': 8207, - 'ndash': 8211, - 'mdash': 8212, - 'lsquo': 8216, - 'rsquo': 8217, - 'sbquo': 8218, - 'ldquo': 8220, - 'rdquo': 8221, - 'bdquo': 8222, - 'dagger': 8224, - 'Dagger': 8225, - 'bull': 8226, - 'hellip': 8230, - 'permil': 8240, - 'prime': 8242, - 'Prime': 8243, - 'lsaquo': 8249, - 'rsaquo': 8250, - 'oline': 8254, - 'frasl': 8260, - 'euro': 8364, - 'image': 8465, - 'weierp': 8472, - 'real': 8476, - 'trade': 8482, - 'alefsym': 8501, - 'larr': 8592, - 'uarr': 8593, - 'rarr': 8594, - 'darr': 8595, - 'harr': 8596, - 'crarr': 8629, - 'lArr': 8656, - 'uArr': 8657, - 'rArr': 8658, - 'dArr': 8659, - 'hArr': 8660, - 'forall': 8704, - 'part': 8706, - 'exist': 8707, - 'empty': 8709, - 'nabla': 8711, - 'isin': 8712, - 'notin': 8713, - 'ni': 8715, - 'prod': 8719, - 'sum': 8721, - 'minus': 8722, - 'lowast': 8727, - 'radic': 8730, - 'prop': 8733, - 'infin': 8734, - 'ang': 8736, - 'and': 8743, - 'or': 8744, - 'cap': 8745, - 'cup': 8746, - 'int': 8747, - 'there4': 8756, - 'sim': 8764, - 'cong': 8773, - 'asymp': 8776, - 'ne': 8800, - 'equiv': 8801, - 'le': 8804, - 'ge': 8805, - 'sub': 8834, - 'sup': 8835, - 'nsub': 8836, - 'sube': 8838, - 'supe': 8839, - 'oplus': 8853, - 'otimes': 8855, - 'perp': 8869, - 'sdot': 8901, - 'lceil': 8968, - 'rceil': 8969, - 'lfloor': 8970, - 'rfloor': 8971, - 'lang': 9001, - 'rang': 9002, - 'loz': 9674, - 'spades': 9824, - 'clubs': 9827, - 'hearts': 9829, - 'diams': 9830 - } - - Object.keys(sax.ENTITIES).forEach(function (key) { - var e = sax.ENTITIES[key] - var s = typeof e === 'number' ? String.fromCharCode(e) : e - sax.ENTITIES[key] = s - }) - - for (var s in sax.STATE) { - sax.STATE[sax.STATE[s]] = s - } - - // shorthand - S = sax.STATE - - function emit (parser, event, data) { - parser[event] && parser[event](data) - } - - function emitNode (parser, nodeType, data) { - if (parser.textNode) closeText(parser) - emit(parser, nodeType, data) - } - - function closeText (parser) { - parser.textNode = textopts(parser.opt, parser.textNode) - if (parser.textNode) emit(parser, 'ontext', parser.textNode) - parser.textNode = '' - } - - function textopts (opt, text) { - if (opt.trim) text = text.trim() - if (opt.normalize) text = text.replace(/\s+/g, ' ') - return text - } - - function error (parser, er) { - closeText(parser) - if (parser.trackPosition) { - er += '\nLine: ' + parser.line + - '\nColumn: ' + parser.column + - '\nChar: ' + parser.c - } - er = new Error(er) - parser.error = er - emit(parser, 'onerror', er) - return parser - } - - function end (parser) { - if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag') - if ((parser.state !== S.BEGIN) && - (parser.state !== S.BEGIN_WHITESPACE) && - (parser.state !== S.TEXT)) { - error(parser, 'Unexpected end') - } - closeText(parser) - parser.c = '' - parser.closed = true - emit(parser, 'onend') - SAXParser.call(parser, parser.strict, parser.opt) - return parser - } - - function strictFail (parser, message) { - if (typeof parser !== 'object' || !(parser instanceof SAXParser)) { - throw new Error('bad call to strictFail') - } - if (parser.strict) { - error(parser, message) - } - } - - function newTag (parser) { - if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]() - var parent = parser.tags[parser.tags.length - 1] || parser - var tag = parser.tag = { name: parser.tagName, attributes: {} } - - // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar" - if (parser.opt.xmlns) { - tag.ns = parent.ns - } - parser.attribList.length = 0 - emitNode(parser, 'onopentagstart', tag) - } - - function qname (name, attribute) { - var i = name.indexOf(':') - var qualName = i < 0 ? [ '', name ] : name.split(':') - var prefix = qualName[0] - var local = qualName[1] - - // <x "xmlns"="http://foo"> - if (attribute && name === 'xmlns') { - prefix = 'xmlns' - local = '' - } - - return { prefix: prefix, local: local } - } - - function attrib (parser) { - if (!parser.strict) { - parser.attribName = parser.attribName[parser.looseCase]() - } - - if (parser.attribList.indexOf(parser.attribName) !== -1 || - parser.tag.attributes.hasOwnProperty(parser.attribName)) { - parser.attribName = parser.attribValue = '' - return - } - - if (parser.opt.xmlns) { - var qn = qname(parser.attribName, true) - var prefix = qn.prefix - var local = qn.local - - if (prefix === 'xmlns') { - // namespace binding attribute. push the binding into scope - if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) { - strictFail(parser, - 'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' + - 'Actual: ' + parser.attribValue) - } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) { - strictFail(parser, - 'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' + - 'Actual: ' + parser.attribValue) - } else { - var tag = parser.tag - var parent = parser.tags[parser.tags.length - 1] || parser - if (tag.ns === parent.ns) { - tag.ns = Object.create(parent.ns) - } - tag.ns[local] = parser.attribValue - } - } - - // defer onattribute events until all attributes have been seen - // so any new bindings can take effect. preserve attribute order - // so deferred events can be emitted in document order - parser.attribList.push([parser.attribName, parser.attribValue]) - } else { - // in non-xmlns mode, we can emit the event right away - parser.tag.attributes[parser.attribName] = parser.attribValue - emitNode(parser, 'onattribute', { - name: parser.attribName, - value: parser.attribValue - }) - } - - parser.attribName = parser.attribValue = '' - } - - function openTag (parser, selfClosing) { - if (parser.opt.xmlns) { - // emit namespace binding events - var tag = parser.tag - - // add namespace info to tag - var qn = qname(parser.tagName) - tag.prefix = qn.prefix - tag.local = qn.local - tag.uri = tag.ns[qn.prefix] || '' - - if (tag.prefix && !tag.uri) { - strictFail(parser, 'Unbound namespace prefix: ' + - JSON.stringify(parser.tagName)) - tag.uri = qn.prefix - } - - var parent = parser.tags[parser.tags.length - 1] || parser - if (tag.ns && parent.ns !== tag.ns) { - Object.keys(tag.ns).forEach(function (p) { - emitNode(parser, 'onopennamespace', { - prefix: p, - uri: tag.ns[p] - }) - }) - } - - // handle deferred onattribute events - // Note: do not apply default ns to attributes: - // http://www.w3.org/TR/REC-xml-names/#defaulting - for (var i = 0, l = parser.attribList.length; i < l; i++) { - var nv = parser.attribList[i] - var name = nv[0] - var value = nv[1] - var qualName = qname(name, true) - var prefix = qualName.prefix - var local = qualName.local - var uri = prefix === '' ? '' : (tag.ns[prefix] || '') - var a = { - name: name, - value: value, - prefix: prefix, - local: local, - uri: uri - } - - // if there's any attributes with an undefined namespace, - // then fail on them now. - if (prefix && prefix !== 'xmlns' && !uri) { - strictFail(parser, 'Unbound namespace prefix: ' + - JSON.stringify(prefix)) - a.uri = prefix - } - parser.tag.attributes[name] = a - emitNode(parser, 'onattribute', a) - } - parser.attribList.length = 0 - } - - parser.tag.isSelfClosing = !!selfClosing - - // process the tag - parser.sawRoot = true - parser.tags.push(parser.tag) - emitNode(parser, 'onopentag', parser.tag) - if (!selfClosing) { - // special case for <script> in non-strict mode. - if (!parser.noscript && parser.tagName.toLowerCase() === 'script') { - parser.state = S.SCRIPT - } else { - parser.state = S.TEXT - } - parser.tag = null - parser.tagName = '' - } - parser.attribName = parser.attribValue = '' - parser.attribList.length = 0 - } - - function closeTag (parser) { - if (!parser.tagName) { - strictFail(parser, 'Weird empty close tag.') - parser.textNode += '</>' - parser.state = S.TEXT - return - } - - if (parser.script) { - if (parser.tagName !== 'script') { - parser.script += '</' + parser.tagName + '>' - parser.tagName = '' - parser.state = S.SCRIPT - return - } - emitNode(parser, 'onscript', parser.script) - parser.script = '' - } - - // first make sure that the closing tag actually exists. - // <a><b></c></b></a> will close everything, otherwise. - var t = parser.tags.length - var tagName = parser.tagName - if (!parser.strict) { - tagName = tagName[parser.looseCase]() - } - var closeTo = tagName - while (t--) { - var close = parser.tags[t] - if (close.name !== closeTo) { - // fail the first time in strict mode - strictFail(parser, 'Unexpected close tag') - } else { - break - } - } - - // didn't find it. we already failed for strict, so just abort. - if (t < 0) { - strictFail(parser, 'Unmatched closing tag: ' + parser.tagName) - parser.textNode += '</' + parser.tagName + '>' - parser.state = S.TEXT - return - } - parser.tagName = tagName - var s = parser.tags.length - while (s-- > t) { - var tag = parser.tag = parser.tags.pop() - parser.tagName = parser.tag.name - emitNode(parser, 'onclosetag', parser.tagName) - - var x = {} - for (var i in tag.ns) { - x[i] = tag.ns[i] - } - - var parent = parser.tags[parser.tags.length - 1] || parser - if (parser.opt.xmlns && tag.ns !== parent.ns) { - // remove namespace bindings introduced by tag - Object.keys(tag.ns).forEach(function (p) { - var n = tag.ns[p] - emitNode(parser, 'onclosenamespace', { prefix: p, uri: n }) - }) - } - } - if (t === 0) parser.closedRoot = true - parser.tagName = parser.attribValue = parser.attribName = '' - parser.attribList.length = 0 - parser.state = S.TEXT - } - - function parseEntity (parser) { - var entity = parser.entity - var entityLC = entity.toLowerCase() - var num - var numStr = '' - - if (parser.ENTITIES[entity]) { - return parser.ENTITIES[entity] - } - if (parser.ENTITIES[entityLC]) { - return parser.ENTITIES[entityLC] - } - entity = entityLC - if (entity.charAt(0) === '#') { - if (entity.charAt(1) === 'x') { - entity = entity.slice(2) - num = parseInt(entity, 16) - numStr = num.toString(16) - } else { - entity = entity.slice(1) - num = parseInt(entity, 10) - numStr = num.toString(10) - } - } - entity = entity.replace(/^0+/, '') - if (numStr.toLowerCase() !== entity) { - strictFail(parser, 'Invalid character entity') - return '&' + parser.entity + ';' - } - - return String.fromCodePoint(num) - } - - function beginWhiteSpace (parser, c) { - if (c === '<') { - parser.state = S.OPEN_WAKA - parser.startTagPosition = parser.position - } else if (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 - } - } - - function charAt (chunk, i) { - var result = '' - if (i < chunk.length) { - result = chunk.charAt(i) - } - return result - } - - function write (chunk) { - var parser = this - if (this.error) { - throw this.error - } - if (parser.closed) { - return error(parser, - 'Cannot write after close. Assign an onready handler.') - } - if (chunk === null) { - return end(parser) - } - if (typeof chunk === 'object') { - chunk = chunk.toString() - } - var i = 0 - var c = '' - while (true) { - c = charAt(chunk, i++) - parser.c = c - - if (!c) { - break - } - - if (parser.trackPosition) { - parser.position++ - if (c === '\n') { - parser.line++ - parser.column = 0 - } else { - parser.column++ - } - } - - switch (parser.state) { - case S.BEGIN: - parser.state = S.BEGIN_WHITESPACE - if (c === '\uFEFF') { - continue - } - beginWhiteSpace(parser, c) - continue - - case S.BEGIN_WHITESPACE: - beginWhiteSpace(parser, c) - continue - - case S.TEXT: - if (parser.sawRoot && !parser.closedRoot) { - var starti = i - 1 - while (c && c !== '<' && c !== '&') { - c = charAt(chunk, i++) - if (c && parser.trackPosition) { - parser.position++ - if (c === '\n') { - parser.line++ - parser.column = 0 - } else { - parser.column++ - } - } - } - parser.textNode += chunk.substring(starti, i - 1) - } - if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) { - parser.state = S.OPEN_WAKA - parser.startTagPosition = parser.position - } else { - if (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 (isMatch(nameStart, c)) { - parser.state = S.OPEN_TAG - parser.tagName = c - } else if (c === '/') { - parser.state = S.CLOSE_TAG - parser.tagName = '' - } else if (c === '?') { - parser.state = S.PROC_INST - parser.procInstName = parser.procInstBody = '' - } else { - strictFail(parser, 'Unencoded <') - // if there was some whitespace, then add that in. - if (parser.startTagPosition + 1 < parser.position) { - var pad = parser.position - parser.startTagPosition - c = new Array(pad).join(' ') + c - } - parser.textNode += '<' + c - parser.state = S.TEXT - } - continue - - case S.SGML_DECL: - if ((parser.sgmlDecl + c).toUpperCase() === CDATA) { - emitNode(parser, 'onopencdata') - parser.state = S.CDATA - parser.sgmlDecl = '' - parser.cdata = '' - } else if (parser.sgmlDecl + c === '--') { - parser.state = S.COMMENT - parser.comment = '' - parser.sgmlDecl = '' - } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) { - parser.state = S.DOCTYPE - if (parser.doctype || parser.sawRoot) { - strictFail(parser, - 'Inappropriately located doctype declaration') - } - parser.doctype = '' - parser.sgmlDecl = '' - } else if (c === '>') { - emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl) - parser.sgmlDecl = '' - parser.state = S.TEXT - } else if (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 (isMatch(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 (isMatch(nameStart, c)) { - parser.attribName = c - parser.attribValue = '' - parser.state = S.ATTRIB_NAME - } else { - strictFail(parser, 'Invalid attribute name') - } - continue - - case S.ATTRIB_NAME: - if (c === '=') { - parser.state = S.ATTRIB_VALUE - } else if (c === '>') { - strictFail(parser, 'Attribute without value') - parser.attribValue = parser.attribName - attrib(parser) - openTag(parser) - } else if (is(whitespace, c)) { - parser.state = S.ATTRIB_NAME_SAW_WHITE - } else if (isMatch(nameBody, c)) { - parser.attribName += c - } else { - strictFail(parser, 'Invalid attribute name') - } - continue - - case S.ATTRIB_NAME_SAW_WHITE: - if (c === '=') { - parser.state = S.ATTRIB_VALUE - } else if (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 (isMatch(nameStart, c)) { - parser.attribName = c - parser.state = S.ATTRIB_NAME - } else { - strictFail(parser, 'Invalid attribute name') - parser.state = S.ATTRIB - } - } - continue - - case S.ATTRIB_VALUE: - if (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 (isMatch(nameStart, c)) { - strictFail(parser, 'No whitespace between attributes') - parser.attribName = c - parser.attribValue = '' - parser.state = S.ATTRIB_NAME - } else { - strictFail(parser, 'Invalid attribute name') - } - continue - - case S.ATTRIB_VALUE_UNQUOTED: - if (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 (notMatch(nameStart, c)) { - if (parser.script) { - parser.script += '</' + c - parser.state = S.SCRIPT - } else { - strictFail(parser, 'Invalid tagname in closing tag.') - } - } else { - parser.tagName = c - } - } else if (c === '>') { - closeTag(parser) - } else if (isMatch(nameBody, c)) { - parser.tagName += c - } else if (parser.script) { - parser.script += '</' + parser.tagName - parser.tagName = '' - parser.state = S.SCRIPT - } else { - if (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: - var returnState - var buffer - switch (parser.state) { - case S.TEXT_ENTITY: - returnState = S.TEXT - buffer = 'textNode' - break - - case S.ATTRIB_VALUE_ENTITY_Q: - returnState = S.ATTRIB_VALUE_QUOTED - buffer = 'attribValue' - break - - case S.ATTRIB_VALUE_ENTITY_U: - returnState = S.ATTRIB_VALUE_UNQUOTED - buffer = 'attribValue' - break - } - - if (c === ';') { - parser[buffer] += parseEntity(parser) - parser.entity = '' - parser.state = returnState - } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) { - parser.entity += c - } else { - strictFail(parser, 'Invalid character in entity name') - parser[buffer] += '&' + parser.entity + c - parser.entity = '' - parser.state = returnState - } - - continue - - default: - throw new Error(parser, 'Unknown state: ' + parser.state) - } - } // while - - if (parser.position >= parser.bufferCheckPosition) { - checkBufferLength(parser) - } - return parser - } - - /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ - /* istanbul ignore next */ - if (!String.fromCodePoint) { - (function () { - var stringFromCharCode = String.fromCharCode - var floor = Math.floor - var fromCodePoint = function () { - var MAX_SIZE = 0x4000 - var codeUnits = [] - var highSurrogate - var lowSurrogate - var index = -1 - var length = arguments.length - if (!length) { - return '' - } - var result = '' - while (++index < length) { - var codePoint = Number(arguments[index]) - if ( - !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` - codePoint < 0 || // not a valid Unicode code point - codePoint > 0x10FFFF || // not a valid Unicode code point - floor(codePoint) !== codePoint // not an integer - ) { - throw RangeError('Invalid code point: ' + codePoint) - } - if (codePoint <= 0xFFFF) { // BMP code point - codeUnits.push(codePoint) - } else { // Astral code point; split in surrogate halves - // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae - codePoint -= 0x10000 - highSurrogate = (codePoint >> 10) + 0xD800 - lowSurrogate = (codePoint % 0x400) + 0xDC00 - codeUnits.push(highSurrogate, lowSurrogate) - } - if (index + 1 === length || codeUnits.length > MAX_SIZE) { - result += stringFromCharCode.apply(null, codeUnits) - codeUnits.length = 0 - } - } - return result - } - /* istanbul ignore next */ - if (Object.defineProperty) { - Object.defineProperty(String, 'fromCodePoint', { - value: fromCodePoint, - configurable: true, - writable: true - }) - } else { - String.fromCodePoint = fromCodePoint - } - }()) - } -})(typeof exports === 'undefined' ? this.sax = {} : exports) |