feat: update MCP config and TOOLS.md with calendar/contacts note
This commit is contained in:
root
55
.agents/skills/dingtalk-api/node_modules/sax/LICENSE.md
generated
vendored
Normal file
55
.agents/skills/dingtalk-api/node_modules/sax/LICENSE.md
generated
vendored
Normal file
@@ -0,0 +1,55 @@
|
||||
# Blue Oak Model License
|
||||
|
||||
Version 1.0.0
|
||||
|
||||
## Purpose
|
||||
|
||||
This license gives everyone as much permission to work with
|
||||
this software as possible, while protecting contributors
|
||||
from liability.
|
||||
|
||||
## Acceptance
|
||||
|
||||
In order to receive this license, you must agree to its
|
||||
rules. The rules of this license are both obligations
|
||||
under that agreement and conditions to your license.
|
||||
You must not do anything with this software that triggers
|
||||
a rule that you cannot or will not follow.
|
||||
|
||||
## Copyright
|
||||
|
||||
Each contributor licenses you to do everything with this
|
||||
software that would otherwise infringe that contributor's
|
||||
copyright in it.
|
||||
|
||||
## Notices
|
||||
|
||||
You must ensure that everyone who gets a copy of
|
||||
any part of this software from you, with or without
|
||||
changes, also gets the text of this license or a link to
|
||||
<https://blueoakcouncil.org/license/1.0.0>.
|
||||
|
||||
## Excuse
|
||||
|
||||
If anyone notifies you in writing that you have not
|
||||
complied with [Notices](#notices), you can keep your
|
||||
license by taking all practical steps to comply within 30
|
||||
days after the notice. If you do not do so, your license
|
||||
ends immediately.
|
||||
|
||||
## Patent
|
||||
|
||||
Each contributor licenses you to do everything with this
|
||||
software that would otherwise infringe any patent claims
|
||||
they can license or become able to license.
|
||||
|
||||
## Reliability
|
||||
|
||||
No contributor can revoke this license.
|
||||
|
||||
## No Liability
|
||||
|
||||
***As far as the law allows, this software comes as is,
|
||||
without any warranty or condition, and no contributor
|
||||
will be liable to anyone for any damages related to this
|
||||
software or this license, under any kind of legal claim.***
|
||||
227
.agents/skills/dingtalk-api/node_modules/sax/README.md
generated
vendored
Normal file
227
.agents/skills/dingtalk-api/node_modules/sax/README.md
generated
vendored
Normal file
@@ -0,0 +1,227 @@
|
||||
# sax js
|
||||
|
||||
A sax-style parser for XML and HTML.
|
||||
|
||||
Designed with [node](http://nodejs.org/) in mind, but should work fine in
|
||||
the browser or other CommonJS implementations.
|
||||
|
||||
## What This Is
|
||||
|
||||
- A very simple tool to parse through an XML string.
|
||||
- A stepping stone to a streaming HTML parser.
|
||||
- A handy way to deal with RSS and other mostly-ok-but-kinda-broken XML
|
||||
docs.
|
||||
|
||||
## What This Is (probably) Not
|
||||
|
||||
- An HTML Parser - That's a fine goal, but this isn't it. It's just
|
||||
XML.
|
||||
- A DOM Builder - You can use it to build an object model out of XML,
|
||||
but it doesn't do that out of the box.
|
||||
- XSLT - No DOM = no querying.
|
||||
- 100% Compliant with (some other SAX implementation) - Most SAX
|
||||
implementations are in Java and do a lot more than this does.
|
||||
- An XML Validator - It does a little validation when in strict mode, but
|
||||
not much.
|
||||
- A Schema-Aware XSD Thing - Schemas are an exercise in fetishistic
|
||||
masochism.
|
||||
- A DTD-aware Thing - Fetching DTDs is a much bigger job.
|
||||
|
||||
## Regarding `<!DOCTYPE`s and `<!ENTITY`s
|
||||
|
||||
The parser will handle the basic XML entities in text nodes and attribute
|
||||
values: `& < > ' "`. It's possible to define additional
|
||||
entities in XML by putting them in the DTD. This parser doesn't do anything
|
||||
with that. If you want to listen to the `ondoctype` event, and then fetch
|
||||
the doctypes, and read the entities and add them to `parser.ENTITIES`, then
|
||||
be my guest.
|
||||
|
||||
Unknown entities will fail in strict mode, and in loose mode, will pass
|
||||
through unmolested.
|
||||
|
||||
## Usage
|
||||
|
||||
```javascript
|
||||
var sax = require('./lib/sax'),
|
||||
strict = true, // set to false for html-mode
|
||||
parser = sax.parser(strict)
|
||||
|
||||
parser.onerror = function (e) {
|
||||
// an error happened.
|
||||
}
|
||||
parser.ontext = function (t) {
|
||||
// got some text. t is the string of text.
|
||||
}
|
||||
parser.onopentag = function (node) {
|
||||
// opened a tag. node has "name" and "attributes"
|
||||
}
|
||||
parser.onattribute = function (attr) {
|
||||
// an attribute. attr has "name" and "value"
|
||||
}
|
||||
parser.onend = function () {
|
||||
// parser stream is done, and ready to have more stuff written to it.
|
||||
}
|
||||
|
||||
parser.write('<xml>Hello, <who name="world">world</who>!</xml>').close()
|
||||
|
||||
// stream usage
|
||||
// takes the same options as the parser
|
||||
var saxStream = require('sax').createStream(strict, options)
|
||||
saxStream.on('error', function (e) {
|
||||
// unhandled errors will throw, since this is a proper node
|
||||
// event emitter.
|
||||
console.error('error!', e)
|
||||
// clear the error
|
||||
this._parser.error = null
|
||||
this._parser.resume()
|
||||
})
|
||||
saxStream.on('opentag', function (node) {
|
||||
// same object as above
|
||||
})
|
||||
// pipe is supported, and it's readable/writable
|
||||
// same chunks coming in also go out.
|
||||
fs.createReadStream('file.xml')
|
||||
.pipe(saxStream)
|
||||
.pipe(fs.createWriteStream('file-copy.xml'))
|
||||
```
|
||||
|
||||
## Arguments
|
||||
|
||||
Pass the following arguments to the parser function. All are optional.
|
||||
|
||||
`strict` - Boolean. Whether or not to be a jerk. Default: `false`.
|
||||
|
||||
`opt` - Object bag of settings regarding string formatting. All default to `false`.
|
||||
|
||||
Settings supported:
|
||||
|
||||
- `trim` - Boolean. Whether or not to trim text and comment nodes.
|
||||
- `normalize` - Boolean. If true, then turn any whitespace into a single
|
||||
space.
|
||||
- `lowercase` - Boolean. If true, then lowercase tag names and attribute names
|
||||
in loose mode, rather than uppercasing them.
|
||||
- `xmlns` - Boolean. If true, then namespaces are supported.
|
||||
- `position` - Boolean. If false, then don't track line/col/position.
|
||||
- `strictEntities` - Boolean. If true, only parse [predefined XML
|
||||
entities](http://www.w3.org/TR/REC-xml/#sec-predefined-ent)
|
||||
(`&`, `'`, `>`, `<`, and `"`)
|
||||
- `unquotedAttributeValues` - Boolean. If true, then unquoted
|
||||
attribute values are allowed. Defaults to `false` when `strict`
|
||||
is true, `true` otherwise.
|
||||
|
||||
## Methods
|
||||
|
||||
`write` - Write bytes onto the stream. You don't have to do this all at
|
||||
once. You can keep writing as much as you want.
|
||||
|
||||
`close` - Close the stream. Once closed, no more data may be written until
|
||||
it is done processing the buffer, which is signaled by the `end` event.
|
||||
|
||||
`resume` - To gracefully handle errors, assign a listener to the `error`
|
||||
event. Then, when the error is taken care of, you can call `resume` to
|
||||
continue parsing. Otherwise, the parser will not continue while in an error
|
||||
state.
|
||||
|
||||
## Members
|
||||
|
||||
At all times, the parser object will have the following members:
|
||||
|
||||
`line`, `column`, `position` - Indications of the position in the XML
|
||||
document where the parser currently is looking.
|
||||
|
||||
`startTagPosition` - Indicates the position where the current tag starts.
|
||||
|
||||
`closed` - Boolean indicating whether or not the parser can be written to.
|
||||
If it's `true`, then wait for the `ready` event to write again.
|
||||
|
||||
`strict` - Boolean indicating whether or not the parser is a jerk.
|
||||
|
||||
`opt` - Any options passed into the constructor.
|
||||
|
||||
`tag` - The current tag being dealt with.
|
||||
|
||||
And a bunch of other stuff that you probably shouldn't touch.
|
||||
|
||||
## Events
|
||||
|
||||
All events emit with a single argument. To listen to an event, assign a
|
||||
function to `on<eventname>`. Functions get executed in the this-context of
|
||||
the parser object. The list of supported events are also in the exported
|
||||
`EVENTS` array.
|
||||
|
||||
When using the stream interface, assign handlers using the EventEmitter
|
||||
`on` function in the normal fashion.
|
||||
|
||||
`error` - Indication that something bad happened. The error will be hanging
|
||||
out on `parser.error`, and must be deleted before parsing can continue. By
|
||||
listening to this event, you can keep an eye on that kind of stuff. Note:
|
||||
this happens _much_ more in strict mode. Argument: instance of `Error`.
|
||||
|
||||
`text` - Text node. Argument: string of text.
|
||||
|
||||
`doctype` - The `<!DOCTYPE` declaration. Argument: doctype string.
|
||||
|
||||
`processinginstruction` - Stuff like `<?xml foo="blerg" ?>`. Argument:
|
||||
object with `name` and `body` members. Attributes are not parsed, as
|
||||
processing instructions have implementation dependent semantics.
|
||||
|
||||
`sgmldeclaration` - Random SGML declarations. Stuff like `<!ENTITY p>`
|
||||
would trigger this kind of event. This is a weird thing to support, so it
|
||||
might go away at some point. SAX isn't intended to be used to parse SGML,
|
||||
after all.
|
||||
|
||||
`opentagstart` - Emitted immediately when the tag name is available,
|
||||
but before any attributes are encountered. Argument: object with a
|
||||
`name` field and an empty `attributes` set. Note that this is the
|
||||
same object that will later be emitted in the `opentag` event.
|
||||
|
||||
`opentag` - An opening tag. Argument: object with `name` and `attributes`.
|
||||
In non-strict mode, tag names are uppercased, unless the `lowercase`
|
||||
option is set. If the `xmlns` option is set, then it will contain
|
||||
namespace binding information on the `ns` member, and will have a
|
||||
`local`, `prefix`, and `uri` member.
|
||||
|
||||
`closetag` - A closing tag. In loose mode, tags are auto-closed if their
|
||||
parent closes. In strict mode, well-formedness is enforced. Note that
|
||||
self-closing tags will have `closeTag` emitted immediately after `openTag`.
|
||||
Argument: tag name.
|
||||
|
||||
`attribute` - An attribute node. Argument: object with `name` and `value`.
|
||||
In non-strict mode, attribute names are uppercased, unless the `lowercase`
|
||||
option is set. If the `xmlns` option is set, it will also contains namespace
|
||||
information.
|
||||
|
||||
`comment` - A comment node. Argument: the string of the comment.
|
||||
|
||||
`opencdata` - The opening tag of a `<![CDATA[` block.
|
||||
|
||||
`cdata` - The text of a `<![CDATA[` block. Since `<![CDATA[` blocks can get
|
||||
quite large, this event may fire multiple times for a single block, if it
|
||||
is broken up into multiple `write()`s. Argument: the string of random
|
||||
character data.
|
||||
|
||||
`closecdata` - The closing tag (`]]>`) of a `<![CDATA[` block.
|
||||
|
||||
`opennamespace` - If the `xmlns` option is set, then this event will
|
||||
signal the start of a new namespace binding.
|
||||
|
||||
`closenamespace` - If the `xmlns` option is set, then this event will
|
||||
signal the end of a namespace binding.
|
||||
|
||||
`end` - Indication that the closed stream has ended.
|
||||
|
||||
`ready` - Indication that the stream has reset, and is ready to be written
|
||||
to.
|
||||
|
||||
`noscript` - In non-strict mode, `<script>` tags trigger a `"script"`
|
||||
event, and their contents are not checked for special xml characters.
|
||||
If you pass `noscript: true`, then this behavior is suppressed.
|
||||
|
||||
## Reporting Problems
|
||||
|
||||
It's best to write a failing test if you find an issue. I will always
|
||||
accept pull requests with failing tests if they demonstrate intended
|
||||
behavior, but it is very hard to figure out what issue you're describing
|
||||
without a test. Writing a test is also the best way for you yourself
|
||||
to figure out if you really understand the issue you think you have with
|
||||
sax-js.
|
||||
1704
.agents/skills/dingtalk-api/node_modules/sax/lib/sax.js
generated
vendored
Normal file
1704
.agents/skills/dingtalk-api/node_modules/sax/lib/sax.js
generated
vendored
Normal file
@@ -0,0 +1,1704 @@
|
||||
;(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)
|
||||
}
|
||||
|
||||
// disallow unquoted attribute values if not otherwise configured
|
||||
// and strict mode is true
|
||||
if (parser.opt.unquotedAttributeValues === undefined) {
|
||||
parser.opt.unquotedAttributeValues = !strict
|
||||
}
|
||||
|
||||
// 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 () {}
|
||||
}
|
||||
if (!Stream) 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) {
|
||||
this._decoder = new TextDecoder('utf8')
|
||||
}
|
||||
data = this._decoder.decode(data, { stream: true })
|
||||
}
|
||||
|
||||
this._parser.write(data.toString())
|
||||
this.emit('data', data)
|
||||
return true
|
||||
}
|
||||
|
||||
SAXStream.prototype.end = function (chunk) {
|
||||
if (chunk && chunk.length) {
|
||||
this.write(chunk)
|
||||
}
|
||||
// Flush any remaining decoded data from the TextDecoder
|
||||
if (this._decoder) {
|
||||
var remaining = this._decoder.decode()
|
||||
if (remaining) {
|
||||
this._parser.write(remaining)
|
||||
this.emit('data', remaining)
|
||||
}
|
||||
}
|
||||
this._parser.end()
|
||||
return true
|
||||
}
|
||||
|
||||
SAXStream.prototype.on = function (ev, handler) {
|
||||
var me = this
|
||||
if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
|
||||
me._parser['on' + ev] = function () {
|
||||
var args =
|
||||
arguments.length === 1 ?
|
||||
[arguments[0]]
|
||||
: Array.apply(null, arguments)
|
||||
args.splice(0, 0, ev)
|
||||
me.emit.apply(me, args)
|
||||
}
|
||||
}
|
||||
|
||||
return Stream.prototype.on.call(me, ev, handler)
|
||||
}
|
||||
|
||||
// this really needs to be replaced with character classes.
|
||||
// XML allows all manner of ridiculous numbers and digits.
|
||||
var CDATA = '[CDATA['
|
||||
var DOCTYPE = 'DOCTYPE'
|
||||
var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'
|
||||
var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'
|
||||
var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
|
||||
|
||||
// http://www.w3.org/TR/REC-xml/#NT-NameStartChar
|
||||
// This implementation works on strings, a single character at a time
|
||||
// as such, it cannot ever support astral-plane characters (10000-EFFFF)
|
||||
// without a significant breaking change to either this parser, or the
|
||||
// JavaScript language. Implementation of an emoji-capable xml parser
|
||||
// is left as an exercise for the reader.
|
||||
var nameStart =
|
||||
/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
|
||||
|
||||
var nameBody =
|
||||
/[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
|
||||
|
||||
var entityStart =
|
||||
/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
|
||||
var entityBody =
|
||||
/[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
|
||||
|
||||
function isWhitespace(c) {
|
||||
return c === ' ' || c === '\n' || c === '\r' || c === '\t'
|
||||
}
|
||||
|
||||
function isQuote(c) {
|
||||
return c === '"' || c === "'"
|
||||
}
|
||||
|
||||
function isAttribEnd(c) {
|
||||
return c === '>' || isWhitespace(c)
|
||||
}
|
||||
|
||||
function isMatch(regex, c) {
|
||||
return regex.test(c)
|
||||
}
|
||||
|
||||
function notMatch(regex, c) {
|
||||
return !isMatch(regex, c)
|
||||
}
|
||||
|
||||
var S = 0
|
||||
sax.STATE = {
|
||||
BEGIN: S++, // leading byte order mark or whitespace
|
||||
BEGIN_WHITESPACE: S++, // leading whitespace
|
||||
TEXT: S++, // general stuff
|
||||
TEXT_ENTITY: S++, // & and such.
|
||||
OPEN_WAKA: S++, // <
|
||||
SGML_DECL: S++, // <!BLARG
|
||||
SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
|
||||
DOCTYPE: S++, // <!DOCTYPE
|
||||
DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
|
||||
DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
|
||||
DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
|
||||
COMMENT_STARTING: S++, // <!-
|
||||
COMMENT: S++, // <!--
|
||||
COMMENT_ENDING: S++, // <!-- blah -
|
||||
COMMENT_ENDED: S++, // <!-- blah --
|
||||
CDATA: S++, // <![CDATA[ something
|
||||
CDATA_ENDING: S++, // ]
|
||||
CDATA_ENDING_2: S++, // ]]
|
||||
PROC_INST: S++, // <?hi
|
||||
PROC_INST_BODY: S++, // <?hi there
|
||||
PROC_INST_ENDING: S++, // <?hi "there" ?
|
||||
OPEN_TAG: S++, // <strong
|
||||
OPEN_TAG_SLASH: S++, // <strong /
|
||||
ATTRIB: S++, // <a
|
||||
ATTRIB_NAME: S++, // <a foo
|
||||
ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
|
||||
ATTRIB_VALUE: S++, // <a foo=
|
||||
ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
|
||||
ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
|
||||
ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
|
||||
ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="""
|
||||
ATTRIB_VALUE_ENTITY_U: S++, // <foo bar="
|
||||
CLOSE_TAG: S++, // </a
|
||||
CLOSE_TAG_SAW_WHITE: S++, // </a >
|
||||
SCRIPT: S++, // <script> ...
|
||||
SCRIPT_ENDING: S++, // <script> ... <
|
||||
}
|
||||
|
||||
sax.XML_ENTITIES = {
|
||||
amp: '&',
|
||||
gt: '>',
|
||||
lt: '<',
|
||||
quot: '"',
|
||||
apos: "'",
|
||||
}
|
||||
|
||||
sax.ENTITIES = {
|
||||
amp: '&',
|
||||
gt: '>',
|
||||
lt: '<',
|
||||
quot: '"',
|
||||
apos: "'",
|
||||
AElig: 198,
|
||||
Aacute: 193,
|
||||
Acirc: 194,
|
||||
Agrave: 192,
|
||||
Aring: 197,
|
||||
Atilde: 195,
|
||||
Auml: 196,
|
||||
Ccedil: 199,
|
||||
ETH: 208,
|
||||
Eacute: 201,
|
||||
Ecirc: 202,
|
||||
Egrave: 200,
|
||||
Euml: 203,
|
||||
Iacute: 205,
|
||||
Icirc: 206,
|
||||
Igrave: 204,
|
||||
Iuml: 207,
|
||||
Ntilde: 209,
|
||||
Oacute: 211,
|
||||
Ocirc: 212,
|
||||
Ograve: 210,
|
||||
Oslash: 216,
|
||||
Otilde: 213,
|
||||
Ouml: 214,
|
||||
THORN: 222,
|
||||
Uacute: 218,
|
||||
Ucirc: 219,
|
||||
Ugrave: 217,
|
||||
Uuml: 220,
|
||||
Yacute: 221,
|
||||
aacute: 225,
|
||||
acirc: 226,
|
||||
aelig: 230,
|
||||
agrave: 224,
|
||||
aring: 229,
|
||||
atilde: 227,
|
||||
auml: 228,
|
||||
ccedil: 231,
|
||||
eacute: 233,
|
||||
ecirc: 234,
|
||||
egrave: 232,
|
||||
eth: 240,
|
||||
euml: 235,
|
||||
iacute: 237,
|
||||
icirc: 238,
|
||||
igrave: 236,
|
||||
iuml: 239,
|
||||
ntilde: 241,
|
||||
oacute: 243,
|
||||
ocirc: 244,
|
||||
ograve: 242,
|
||||
oslash: 248,
|
||||
otilde: 245,
|
||||
ouml: 246,
|
||||
szlig: 223,
|
||||
thorn: 254,
|
||||
uacute: 250,
|
||||
ucirc: 251,
|
||||
ugrave: 249,
|
||||
uuml: 252,
|
||||
yacute: 253,
|
||||
yuml: 255,
|
||||
copy: 169,
|
||||
reg: 174,
|
||||
nbsp: 160,
|
||||
iexcl: 161,
|
||||
cent: 162,
|
||||
pound: 163,
|
||||
curren: 164,
|
||||
yen: 165,
|
||||
brvbar: 166,
|
||||
sect: 167,
|
||||
uml: 168,
|
||||
ordf: 170,
|
||||
laquo: 171,
|
||||
not: 172,
|
||||
shy: 173,
|
||||
macr: 175,
|
||||
deg: 176,
|
||||
plusmn: 177,
|
||||
sup1: 185,
|
||||
sup2: 178,
|
||||
sup3: 179,
|
||||
acute: 180,
|
||||
micro: 181,
|
||||
para: 182,
|
||||
middot: 183,
|
||||
cedil: 184,
|
||||
ordm: 186,
|
||||
raquo: 187,
|
||||
frac14: 188,
|
||||
frac12: 189,
|
||||
frac34: 190,
|
||||
iquest: 191,
|
||||
times: 215,
|
||||
divide: 247,
|
||||
OElig: 338,
|
||||
oelig: 339,
|
||||
Scaron: 352,
|
||||
scaron: 353,
|
||||
Yuml: 376,
|
||||
fnof: 402,
|
||||
circ: 710,
|
||||
tilde: 732,
|
||||
Alpha: 913,
|
||||
Beta: 914,
|
||||
Gamma: 915,
|
||||
Delta: 916,
|
||||
Epsilon: 917,
|
||||
Zeta: 918,
|
||||
Eta: 919,
|
||||
Theta: 920,
|
||||
Iota: 921,
|
||||
Kappa: 922,
|
||||
Lambda: 923,
|
||||
Mu: 924,
|
||||
Nu: 925,
|
||||
Xi: 926,
|
||||
Omicron: 927,
|
||||
Pi: 928,
|
||||
Rho: 929,
|
||||
Sigma: 931,
|
||||
Tau: 932,
|
||||
Upsilon: 933,
|
||||
Phi: 934,
|
||||
Chi: 935,
|
||||
Psi: 936,
|
||||
Omega: 937,
|
||||
alpha: 945,
|
||||
beta: 946,
|
||||
gamma: 947,
|
||||
delta: 948,
|
||||
epsilon: 949,
|
||||
zeta: 950,
|
||||
eta: 951,
|
||||
theta: 952,
|
||||
iota: 953,
|
||||
kappa: 954,
|
||||
lambda: 955,
|
||||
mu: 956,
|
||||
nu: 957,
|
||||
xi: 958,
|
||||
omicron: 959,
|
||||
pi: 960,
|
||||
rho: 961,
|
||||
sigmaf: 962,
|
||||
sigma: 963,
|
||||
tau: 964,
|
||||
upsilon: 965,
|
||||
phi: 966,
|
||||
chi: 967,
|
||||
psi: 968,
|
||||
omega: 969,
|
||||
thetasym: 977,
|
||||
upsih: 978,
|
||||
piv: 982,
|
||||
ensp: 8194,
|
||||
emsp: 8195,
|
||||
thinsp: 8201,
|
||||
zwnj: 8204,
|
||||
zwj: 8205,
|
||||
lrm: 8206,
|
||||
rlm: 8207,
|
||||
ndash: 8211,
|
||||
mdash: 8212,
|
||||
lsquo: 8216,
|
||||
rsquo: 8217,
|
||||
sbquo: 8218,
|
||||
ldquo: 8220,
|
||||
rdquo: 8221,
|
||||
bdquo: 8222,
|
||||
dagger: 8224,
|
||||
Dagger: 8225,
|
||||
bull: 8226,
|
||||
hellip: 8230,
|
||||
permil: 8240,
|
||||
prime: 8242,
|
||||
Prime: 8243,
|
||||
lsaquo: 8249,
|
||||
rsaquo: 8250,
|
||||
oline: 8254,
|
||||
frasl: 8260,
|
||||
euro: 8364,
|
||||
image: 8465,
|
||||
weierp: 8472,
|
||||
real: 8476,
|
||||
trade: 8482,
|
||||
alefsym: 8501,
|
||||
larr: 8592,
|
||||
uarr: 8593,
|
||||
rarr: 8594,
|
||||
darr: 8595,
|
||||
harr: 8596,
|
||||
crarr: 8629,
|
||||
lArr: 8656,
|
||||
uArr: 8657,
|
||||
rArr: 8658,
|
||||
dArr: 8659,
|
||||
hArr: 8660,
|
||||
forall: 8704,
|
||||
part: 8706,
|
||||
exist: 8707,
|
||||
empty: 8709,
|
||||
nabla: 8711,
|
||||
isin: 8712,
|
||||
notin: 8713,
|
||||
ni: 8715,
|
||||
prod: 8719,
|
||||
sum: 8721,
|
||||
minus: 8722,
|
||||
lowast: 8727,
|
||||
radic: 8730,
|
||||
prop: 8733,
|
||||
infin: 8734,
|
||||
ang: 8736,
|
||||
and: 8743,
|
||||
or: 8744,
|
||||
cap: 8745,
|
||||
cup: 8746,
|
||||
int: 8747,
|
||||
there4: 8756,
|
||||
sim: 8764,
|
||||
cong: 8773,
|
||||
asymp: 8776,
|
||||
ne: 8800,
|
||||
equiv: 8801,
|
||||
le: 8804,
|
||||
ge: 8805,
|
||||
sub: 8834,
|
||||
sup: 8835,
|
||||
nsub: 8836,
|
||||
sube: 8838,
|
||||
supe: 8839,
|
||||
oplus: 8853,
|
||||
otimes: 8855,
|
||||
perp: 8869,
|
||||
sdot: 8901,
|
||||
lceil: 8968,
|
||||
rceil: 8969,
|
||||
lfloor: 8970,
|
||||
rfloor: 8971,
|
||||
lang: 9001,
|
||||
rang: 9002,
|
||||
loz: 9674,
|
||||
spades: 9824,
|
||||
clubs: 9827,
|
||||
hearts: 9829,
|
||||
diams: 9830,
|
||||
}
|
||||
|
||||
Object.keys(sax.ENTITIES).forEach(function (key) {
|
||||
var e = sax.ENTITIES[key]
|
||||
var s = typeof e === 'number' ? String.fromCharCode(e) : e
|
||||
sax.ENTITIES[key] = s
|
||||
})
|
||||
|
||||
for (var s in sax.STATE) {
|
||||
sax.STATE[sax.STATE[s]] = s
|
||||
}
|
||||
|
||||
// shorthand
|
||||
S = sax.STATE
|
||||
|
||||
function emit(parser, event, data) {
|
||||
parser[event] && parser[event](data)
|
||||
}
|
||||
|
||||
function emitNode(parser, nodeType, data) {
|
||||
if (parser.textNode) closeText(parser)
|
||||
emit(parser, nodeType, data)
|
||||
}
|
||||
|
||||
function closeText(parser) {
|
||||
parser.textNode = textopts(parser.opt, parser.textNode)
|
||||
if (parser.textNode) emit(parser, 'ontext', parser.textNode)
|
||||
parser.textNode = ''
|
||||
}
|
||||
|
||||
function textopts(opt, text) {
|
||||
if (opt.trim) text = text.trim()
|
||||
if (opt.normalize) text = text.replace(/\s+/g, ' ')
|
||||
return text
|
||||
}
|
||||
|
||||
function error(parser, er) {
|
||||
closeText(parser)
|
||||
if (parser.trackPosition) {
|
||||
er +=
|
||||
'\nLine: ' +
|
||||
parser.line +
|
||||
'\nColumn: ' +
|
||||
parser.column +
|
||||
'\nChar: ' +
|
||||
parser.c
|
||||
}
|
||||
er = new Error(er)
|
||||
parser.error = er
|
||||
emit(parser, 'onerror', er)
|
||||
return parser
|
||||
}
|
||||
|
||||
function end(parser) {
|
||||
if (parser.sawRoot && !parser.closedRoot)
|
||||
strictFail(parser, 'Unclosed root tag')
|
||||
if (
|
||||
parser.state !== S.BEGIN &&
|
||||
parser.state !== S.BEGIN_WHITESPACE &&
|
||||
parser.state !== S.TEXT
|
||||
) {
|
||||
error(parser, 'Unexpected end')
|
||||
}
|
||||
closeText(parser)
|
||||
parser.c = ''
|
||||
parser.closed = true
|
||||
emit(parser, 'onend')
|
||||
SAXParser.call(parser, parser.strict, parser.opt)
|
||||
return parser
|
||||
}
|
||||
|
||||
function strictFail(parser, message) {
|
||||
if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
|
||||
throw new Error('bad call to strictFail')
|
||||
}
|
||||
if (parser.strict) {
|
||||
error(parser, message)
|
||||
}
|
||||
}
|
||||
|
||||
function newTag(parser) {
|
||||
if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
|
||||
var parent = parser.tags[parser.tags.length - 1] || parser
|
||||
var tag = (parser.tag = { name: parser.tagName, attributes: {} })
|
||||
|
||||
// will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
|
||||
if (parser.opt.xmlns) {
|
||||
tag.ns = parent.ns
|
||||
}
|
||||
parser.attribList.length = 0
|
||||
emitNode(parser, 'onopentagstart', tag)
|
||||
}
|
||||
|
||||
function qname(name, attribute) {
|
||||
var i = name.indexOf(':')
|
||||
var qualName = i < 0 ? ['', name] : name.split(':')
|
||||
var prefix = qualName[0]
|
||||
var local = qualName[1]
|
||||
|
||||
// <x "xmlns"="http://foo">
|
||||
if (attribute && name === 'xmlns') {
|
||||
prefix = 'xmlns'
|
||||
local = ''
|
||||
}
|
||||
|
||||
return { prefix: prefix, local: local }
|
||||
}
|
||||
|
||||
function attrib(parser) {
|
||||
if (!parser.strict) {
|
||||
parser.attribName = parser.attribName[parser.looseCase]()
|
||||
}
|
||||
|
||||
if (
|
||||
parser.attribList.indexOf(parser.attribName) !== -1 ||
|
||||
parser.tag.attributes.hasOwnProperty(parser.attribName)
|
||||
) {
|
||||
parser.attribName = parser.attribValue = ''
|
||||
return
|
||||
}
|
||||
|
||||
if (parser.opt.xmlns) {
|
||||
var qn = qname(parser.attribName, true)
|
||||
var prefix = qn.prefix
|
||||
var local = qn.local
|
||||
|
||||
if (prefix === 'xmlns') {
|
||||
// namespace binding attribute. push the binding into scope
|
||||
if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
|
||||
strictFail(
|
||||
parser,
|
||||
'xml: prefix must be bound to ' +
|
||||
XML_NAMESPACE +
|
||||
'\n' +
|
||||
'Actual: ' +
|
||||
parser.attribValue
|
||||
)
|
||||
} else if (
|
||||
local === 'xmlns' &&
|
||||
parser.attribValue !== XMLNS_NAMESPACE
|
||||
) {
|
||||
strictFail(
|
||||
parser,
|
||||
'xmlns: prefix must be bound to ' +
|
||||
XMLNS_NAMESPACE +
|
||||
'\n' +
|
||||
'Actual: ' +
|
||||
parser.attribValue
|
||||
)
|
||||
} else {
|
||||
var tag = parser.tag
|
||||
var parent = parser.tags[parser.tags.length - 1] || parser
|
||||
if (tag.ns === parent.ns) {
|
||||
tag.ns = Object.create(parent.ns)
|
||||
}
|
||||
tag.ns[local] = parser.attribValue
|
||||
}
|
||||
}
|
||||
|
||||
// defer onattribute events until all attributes have been seen
|
||||
// so any new bindings can take effect. preserve attribute order
|
||||
// so deferred events can be emitted in document order
|
||||
parser.attribList.push([parser.attribName, parser.attribValue])
|
||||
} else {
|
||||
// in non-xmlns mode, we can emit the event right away
|
||||
parser.tag.attributes[parser.attribName] = parser.attribValue
|
||||
emitNode(parser, 'onattribute', {
|
||||
name: parser.attribName,
|
||||
value: parser.attribValue,
|
||||
})
|
||||
}
|
||||
|
||||
parser.attribName = parser.attribValue = ''
|
||||
}
|
||||
|
||||
function openTag(parser, selfClosing) {
|
||||
if (parser.opt.xmlns) {
|
||||
// emit namespace binding events
|
||||
var tag = parser.tag
|
||||
|
||||
// add namespace info to tag
|
||||
var qn = qname(parser.tagName)
|
||||
tag.prefix = qn.prefix
|
||||
tag.local = qn.local
|
||||
tag.uri = tag.ns[qn.prefix] || ''
|
||||
|
||||
if (tag.prefix && !tag.uri) {
|
||||
strictFail(
|
||||
parser,
|
||||
'Unbound namespace prefix: ' + JSON.stringify(parser.tagName)
|
||||
)
|
||||
tag.uri = qn.prefix
|
||||
}
|
||||
|
||||
var parent = parser.tags[parser.tags.length - 1] || parser
|
||||
if (tag.ns && parent.ns !== tag.ns) {
|
||||
Object.keys(tag.ns).forEach(function (p) {
|
||||
emitNode(parser, 'onopennamespace', {
|
||||
prefix: p,
|
||||
uri: tag.ns[p],
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// handle deferred onattribute events
|
||||
// Note: do not apply default ns to attributes:
|
||||
// http://www.w3.org/TR/REC-xml-names/#defaulting
|
||||
for (var i = 0, l = parser.attribList.length; i < l; i++) {
|
||||
var nv = parser.attribList[i]
|
||||
var name = nv[0]
|
||||
var value = nv[1]
|
||||
var qualName = qname(name, true)
|
||||
var prefix = qualName.prefix
|
||||
var local = qualName.local
|
||||
var uri = prefix === '' ? '' : tag.ns[prefix] || ''
|
||||
var a = {
|
||||
name: name,
|
||||
value: value,
|
||||
prefix: prefix,
|
||||
local: local,
|
||||
uri: uri,
|
||||
}
|
||||
|
||||
// if there's any attributes with an undefined namespace,
|
||||
// then fail on them now.
|
||||
if (prefix && prefix !== 'xmlns' && !uri) {
|
||||
strictFail(
|
||||
parser,
|
||||
'Unbound namespace prefix: ' + JSON.stringify(prefix)
|
||||
)
|
||||
a.uri = prefix
|
||||
}
|
||||
parser.tag.attributes[name] = a
|
||||
emitNode(parser, 'onattribute', a)
|
||||
}
|
||||
parser.attribList.length = 0
|
||||
}
|
||||
|
||||
parser.tag.isSelfClosing = !!selfClosing
|
||||
|
||||
// process the tag
|
||||
parser.sawRoot = true
|
||||
parser.tags.push(parser.tag)
|
||||
emitNode(parser, 'onopentag', parser.tag)
|
||||
if (!selfClosing) {
|
||||
// special case for <script> in non-strict mode.
|
||||
if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
|
||||
parser.state = S.SCRIPT
|
||||
} else {
|
||||
parser.state = S.TEXT
|
||||
}
|
||||
parser.tag = null
|
||||
parser.tagName = ''
|
||||
}
|
||||
parser.attribName = parser.attribValue = ''
|
||||
parser.attribList.length = 0
|
||||
}
|
||||
|
||||
function closeTag(parser) {
|
||||
if (!parser.tagName) {
|
||||
strictFail(parser, 'Weird empty close tag.')
|
||||
parser.textNode += '</>'
|
||||
parser.state = S.TEXT
|
||||
return
|
||||
}
|
||||
|
||||
if (parser.script) {
|
||||
if (parser.tagName !== 'script') {
|
||||
parser.script += '</' + parser.tagName + '>'
|
||||
parser.tagName = ''
|
||||
parser.state = S.SCRIPT
|
||||
return
|
||||
}
|
||||
emitNode(parser, 'onscript', parser.script)
|
||||
parser.script = ''
|
||||
}
|
||||
|
||||
// first make sure that the closing tag actually exists.
|
||||
// <a><b></c></b></a> will close everything, otherwise.
|
||||
var t = parser.tags.length
|
||||
var tagName = parser.tagName
|
||||
if (!parser.strict) {
|
||||
tagName = tagName[parser.looseCase]()
|
||||
}
|
||||
var closeTo = tagName
|
||||
while (t--) {
|
||||
var close = parser.tags[t]
|
||||
if (close.name !== closeTo) {
|
||||
// fail the first time in strict mode
|
||||
strictFail(parser, 'Unexpected close tag')
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// didn't find it. we already failed for strict, so just abort.
|
||||
if (t < 0) {
|
||||
strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
|
||||
parser.textNode += '</' + parser.tagName + '>'
|
||||
parser.state = S.TEXT
|
||||
return
|
||||
}
|
||||
parser.tagName = tagName
|
||||
var s = parser.tags.length
|
||||
while (s-- > t) {
|
||||
var tag = (parser.tag = parser.tags.pop())
|
||||
parser.tagName = parser.tag.name
|
||||
emitNode(parser, 'onclosetag', parser.tagName)
|
||||
|
||||
var x = {}
|
||||
for (var i in tag.ns) {
|
||||
x[i] = tag.ns[i]
|
||||
}
|
||||
|
||||
var parent = parser.tags[parser.tags.length - 1] || parser
|
||||
if (parser.opt.xmlns && tag.ns !== parent.ns) {
|
||||
// remove namespace bindings introduced by tag
|
||||
Object.keys(tag.ns).forEach(function (p) {
|
||||
var n = tag.ns[p]
|
||||
emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })
|
||||
})
|
||||
}
|
||||
}
|
||||
if (t === 0) parser.closedRoot = true
|
||||
parser.tagName = parser.attribValue = parser.attribName = ''
|
||||
parser.attribList.length = 0
|
||||
parser.state = S.TEXT
|
||||
}
|
||||
|
||||
function parseEntity(parser) {
|
||||
var entity = parser.entity
|
||||
var entityLC = entity.toLowerCase()
|
||||
var num
|
||||
var numStr = ''
|
||||
|
||||
if (parser.ENTITIES[entity]) {
|
||||
return parser.ENTITIES[entity]
|
||||
}
|
||||
if (parser.ENTITIES[entityLC]) {
|
||||
return parser.ENTITIES[entityLC]
|
||||
}
|
||||
entity = entityLC
|
||||
if (entity.charAt(0) === '#') {
|
||||
if (entity.charAt(1) === 'x') {
|
||||
entity = entity.slice(2)
|
||||
num = parseInt(entity, 16)
|
||||
numStr = num.toString(16)
|
||||
} else {
|
||||
entity = entity.slice(1)
|
||||
num = parseInt(entity, 10)
|
||||
numStr = num.toString(10)
|
||||
}
|
||||
}
|
||||
entity = entity.replace(/^0+/, '')
|
||||
if (
|
||||
isNaN(num) ||
|
||||
numStr.toLowerCase() !== entity ||
|
||||
num < 0 ||
|
||||
num > 0x10ffff
|
||||
) {
|
||||
strictFail(parser, 'Invalid character entity')
|
||||
return '&' + parser.entity + ';'
|
||||
}
|
||||
|
||||
return String.fromCodePoint(num)
|
||||
}
|
||||
|
||||
function beginWhiteSpace(parser, c) {
|
||||
if (c === '<') {
|
||||
parser.state = S.OPEN_WAKA
|
||||
parser.startTagPosition = parser.position
|
||||
} else if (!isWhitespace(c)) {
|
||||
// have to process this as a text node.
|
||||
// weird, but happens.
|
||||
strictFail(parser, 'Non-whitespace before first tag.')
|
||||
parser.textNode = c
|
||||
parser.state = S.TEXT
|
||||
}
|
||||
}
|
||||
|
||||
function charAt(chunk, i) {
|
||||
var result = ''
|
||||
if (i < chunk.length) {
|
||||
result = chunk.charAt(i)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
function write(chunk) {
|
||||
var parser = this
|
||||
if (this.error) {
|
||||
throw this.error
|
||||
}
|
||||
if (parser.closed) {
|
||||
return error(
|
||||
parser,
|
||||
'Cannot write after close. Assign an onready handler.'
|
||||
)
|
||||
}
|
||||
if (chunk === null) {
|
||||
return end(parser)
|
||||
}
|
||||
if (typeof chunk === 'object') {
|
||||
chunk = chunk.toString()
|
||||
}
|
||||
var i = 0
|
||||
var c = ''
|
||||
while (true) {
|
||||
c = charAt(chunk, i++)
|
||||
parser.c = c
|
||||
|
||||
if (!c) {
|
||||
break
|
||||
}
|
||||
|
||||
if (parser.trackPosition) {
|
||||
parser.position++
|
||||
if (c === '\n') {
|
||||
parser.line++
|
||||
parser.column = 0
|
||||
} else {
|
||||
parser.column++
|
||||
}
|
||||
}
|
||||
|
||||
switch (parser.state) {
|
||||
case S.BEGIN:
|
||||
parser.state = S.BEGIN_WHITESPACE
|
||||
if (c === '\uFEFF') {
|
||||
continue
|
||||
}
|
||||
beginWhiteSpace(parser, c)
|
||||
continue
|
||||
|
||||
case S.BEGIN_WHITESPACE:
|
||||
beginWhiteSpace(parser, c)
|
||||
continue
|
||||
|
||||
case S.TEXT:
|
||||
if (parser.sawRoot && !parser.closedRoot) {
|
||||
var starti = i - 1
|
||||
while (c && c !== '<' && c !== '&') {
|
||||
c = charAt(chunk, i++)
|
||||
if (c && parser.trackPosition) {
|
||||
parser.position++
|
||||
if (c === '\n') {
|
||||
parser.line++
|
||||
parser.column = 0
|
||||
} else {
|
||||
parser.column++
|
||||
}
|
||||
}
|
||||
}
|
||||
parser.textNode += chunk.substring(starti, i - 1)
|
||||
}
|
||||
if (
|
||||
c === '<' &&
|
||||
!(parser.sawRoot && parser.closedRoot && !parser.strict)
|
||||
) {
|
||||
parser.state = S.OPEN_WAKA
|
||||
parser.startTagPosition = parser.position
|
||||
} else {
|
||||
if (
|
||||
!isWhitespace(c) &&
|
||||
(!parser.sawRoot || parser.closedRoot)
|
||||
) {
|
||||
strictFail(parser, 'Text data outside of root node.')
|
||||
}
|
||||
if (c === '&') {
|
||||
parser.state = S.TEXT_ENTITY
|
||||
} else {
|
||||
parser.textNode += c
|
||||
}
|
||||
}
|
||||
continue
|
||||
|
||||
case S.SCRIPT:
|
||||
// only non-strict
|
||||
if (c === '<') {
|
||||
parser.state = S.SCRIPT_ENDING
|
||||
} else {
|
||||
parser.script += c
|
||||
}
|
||||
continue
|
||||
|
||||
case S.SCRIPT_ENDING:
|
||||
if (c === '/') {
|
||||
parser.state = S.CLOSE_TAG
|
||||
} else {
|
||||
parser.script += '<' + c
|
||||
parser.state = S.SCRIPT
|
||||
}
|
||||
continue
|
||||
|
||||
case S.OPEN_WAKA:
|
||||
// either a /, ?, !, or text is coming next.
|
||||
if (c === '!') {
|
||||
parser.state = S.SGML_DECL
|
||||
parser.sgmlDecl = ''
|
||||
} else if (isWhitespace(c)) {
|
||||
// wait for it...
|
||||
} else if (isMatch(nameStart, c)) {
|
||||
parser.state = S.OPEN_TAG
|
||||
parser.tagName = c
|
||||
} else if (c === '/') {
|
||||
parser.state = S.CLOSE_TAG
|
||||
parser.tagName = ''
|
||||
} else if (c === '?') {
|
||||
parser.state = S.PROC_INST
|
||||
parser.procInstName = parser.procInstBody = ''
|
||||
} else {
|
||||
strictFail(parser, 'Unencoded <')
|
||||
// if there was some whitespace, then add that in.
|
||||
if (parser.startTagPosition + 1 < parser.position) {
|
||||
var pad = parser.position - parser.startTagPosition
|
||||
c = new Array(pad).join(' ') + c
|
||||
}
|
||||
parser.textNode += '<' + c
|
||||
parser.state = S.TEXT
|
||||
}
|
||||
continue
|
||||
|
||||
case S.SGML_DECL:
|
||||
if (parser.sgmlDecl + c === '--') {
|
||||
parser.state = S.COMMENT
|
||||
parser.comment = ''
|
||||
parser.sgmlDecl = ''
|
||||
continue
|
||||
}
|
||||
|
||||
if (
|
||||
parser.doctype &&
|
||||
parser.doctype !== true &&
|
||||
parser.sgmlDecl
|
||||
) {
|
||||
parser.state = S.DOCTYPE_DTD
|
||||
parser.doctype += '<!' + parser.sgmlDecl + c
|
||||
parser.sgmlDecl = ''
|
||||
} else if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
|
||||
emitNode(parser, 'onopencdata')
|
||||
parser.state = S.CDATA
|
||||
parser.sgmlDecl = ''
|
||||
parser.cdata = ''
|
||||
} else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
|
||||
parser.state = S.DOCTYPE
|
||||
if (parser.doctype || parser.sawRoot) {
|
||||
strictFail(
|
||||
parser,
|
||||
'Inappropriately located doctype declaration'
|
||||
)
|
||||
}
|
||||
parser.doctype = ''
|
||||
parser.sgmlDecl = ''
|
||||
} else if (c === '>') {
|
||||
emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)
|
||||
parser.sgmlDecl = ''
|
||||
parser.state = S.TEXT
|
||||
} else if (isQuote(c)) {
|
||||
parser.state = S.SGML_DECL_QUOTED
|
||||
parser.sgmlDecl += c
|
||||
} else {
|
||||
parser.sgmlDecl += c
|
||||
}
|
||||
continue
|
||||
|
||||
case S.SGML_DECL_QUOTED:
|
||||
if (c === parser.q) {
|
||||
parser.state = S.SGML_DECL
|
||||
parser.q = ''
|
||||
}
|
||||
parser.sgmlDecl += c
|
||||
continue
|
||||
|
||||
case S.DOCTYPE:
|
||||
if (c === '>') {
|
||||
parser.state = S.TEXT
|
||||
emitNode(parser, 'ondoctype', parser.doctype)
|
||||
parser.doctype = true // just remember that we saw it.
|
||||
} else {
|
||||
parser.doctype += c
|
||||
if (c === '[') {
|
||||
parser.state = S.DOCTYPE_DTD
|
||||
} else if (isQuote(c)) {
|
||||
parser.state = S.DOCTYPE_QUOTED
|
||||
parser.q = c
|
||||
}
|
||||
}
|
||||
continue
|
||||
|
||||
case S.DOCTYPE_QUOTED:
|
||||
parser.doctype += c
|
||||
if (c === parser.q) {
|
||||
parser.q = ''
|
||||
parser.state = S.DOCTYPE
|
||||
}
|
||||
continue
|
||||
|
||||
case S.DOCTYPE_DTD:
|
||||
if (c === ']') {
|
||||
parser.doctype += c
|
||||
parser.state = S.DOCTYPE
|
||||
} else if (c === '<') {
|
||||
parser.state = S.OPEN_WAKA
|
||||
parser.startTagPosition = parser.position
|
||||
} else if (isQuote(c)) {
|
||||
parser.doctype += c
|
||||
parser.state = S.DOCTYPE_DTD_QUOTED
|
||||
parser.q = c
|
||||
} else {
|
||||
parser.doctype += 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 if (parser.doctype && parser.doctype !== true) {
|
||||
parser.state = S.DOCTYPE_DTD
|
||||
} else {
|
||||
parser.state = S.TEXT
|
||||
}
|
||||
continue
|
||||
|
||||
case S.CDATA:
|
||||
var starti = i - 1
|
||||
while (c && c !== ']') {
|
||||
c = charAt(chunk, i++)
|
||||
if (c && parser.trackPosition) {
|
||||
parser.position++
|
||||
if (c === '\n') {
|
||||
parser.line++
|
||||
parser.column = 0
|
||||
} else {
|
||||
parser.column++
|
||||
}
|
||||
}
|
||||
}
|
||||
parser.cdata += chunk.substring(starti, i - 1)
|
||||
if (c === ']') {
|
||||
parser.state = S.CDATA_ENDING
|
||||
}
|
||||
continue
|
||||
|
||||
case S.CDATA_ENDING:
|
||||
if (c === ']') {
|
||||
parser.state = S.CDATA_ENDING_2
|
||||
} else {
|
||||
parser.cdata += ']' + c
|
||||
parser.state = S.CDATA
|
||||
}
|
||||
continue
|
||||
|
||||
case S.CDATA_ENDING_2:
|
||||
if (c === '>') {
|
||||
if (parser.cdata) {
|
||||
emitNode(parser, 'oncdata', parser.cdata)
|
||||
}
|
||||
emitNode(parser, 'onclosecdata')
|
||||
parser.cdata = ''
|
||||
parser.state = S.TEXT
|
||||
} else if (c === ']') {
|
||||
parser.cdata += ']'
|
||||
} else {
|
||||
parser.cdata += ']]' + c
|
||||
parser.state = S.CDATA
|
||||
}
|
||||
continue
|
||||
|
||||
case S.PROC_INST:
|
||||
if (c === '?') {
|
||||
parser.state = S.PROC_INST_ENDING
|
||||
} else if (isWhitespace(c)) {
|
||||
parser.state = S.PROC_INST_BODY
|
||||
} else {
|
||||
parser.procInstName += c
|
||||
}
|
||||
continue
|
||||
|
||||
case S.PROC_INST_BODY:
|
||||
if (!parser.procInstBody && isWhitespace(c)) {
|
||||
continue
|
||||
} else if (c === '?') {
|
||||
parser.state = S.PROC_INST_ENDING
|
||||
} else {
|
||||
parser.procInstBody += c
|
||||
}
|
||||
continue
|
||||
|
||||
case S.PROC_INST_ENDING:
|
||||
if (c === '>') {
|
||||
emitNode(parser, 'onprocessinginstruction', {
|
||||
name: parser.procInstName,
|
||||
body: parser.procInstBody,
|
||||
})
|
||||
parser.procInstName = parser.procInstBody = ''
|
||||
parser.state = S.TEXT
|
||||
} else {
|
||||
parser.procInstBody += '?' + c
|
||||
parser.state = S.PROC_INST_BODY
|
||||
}
|
||||
continue
|
||||
|
||||
case S.OPEN_TAG:
|
||||
if (isMatch(nameBody, c)) {
|
||||
parser.tagName += c
|
||||
} else {
|
||||
newTag(parser)
|
||||
if (c === '>') {
|
||||
openTag(parser)
|
||||
} else if (c === '/') {
|
||||
parser.state = S.OPEN_TAG_SLASH
|
||||
} else {
|
||||
if (!isWhitespace(c)) {
|
||||
strictFail(parser, 'Invalid character in tag name')
|
||||
}
|
||||
parser.state = S.ATTRIB
|
||||
}
|
||||
}
|
||||
continue
|
||||
|
||||
case S.OPEN_TAG_SLASH:
|
||||
if (c === '>') {
|
||||
openTag(parser, true)
|
||||
closeTag(parser)
|
||||
} else {
|
||||
strictFail(
|
||||
parser,
|
||||
'Forward-slash in opening tag not followed by >'
|
||||
)
|
||||
parser.state = S.ATTRIB
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB:
|
||||
// haven't read the attribute name yet.
|
||||
if (isWhitespace(c)) {
|
||||
continue
|
||||
} else if (c === '>') {
|
||||
openTag(parser)
|
||||
} else if (c === '/') {
|
||||
parser.state = S.OPEN_TAG_SLASH
|
||||
} else if (isMatch(nameStart, c)) {
|
||||
parser.attribName = c
|
||||
parser.attribValue = ''
|
||||
parser.state = S.ATTRIB_NAME
|
||||
} else {
|
||||
strictFail(parser, 'Invalid attribute name')
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB_NAME:
|
||||
if (c === '=') {
|
||||
parser.state = S.ATTRIB_VALUE
|
||||
} else if (c === '>') {
|
||||
strictFail(parser, 'Attribute without value')
|
||||
parser.attribValue = parser.attribName
|
||||
attrib(parser)
|
||||
openTag(parser)
|
||||
} else if (isWhitespace(c)) {
|
||||
parser.state = S.ATTRIB_NAME_SAW_WHITE
|
||||
} else if (isMatch(nameBody, c)) {
|
||||
parser.attribName += c
|
||||
} else {
|
||||
strictFail(parser, 'Invalid attribute name')
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB_NAME_SAW_WHITE:
|
||||
if (c === '=') {
|
||||
parser.state = S.ATTRIB_VALUE
|
||||
} else if (isWhitespace(c)) {
|
||||
continue
|
||||
} else {
|
||||
strictFail(parser, 'Attribute without value')
|
||||
parser.tag.attributes[parser.attribName] = ''
|
||||
parser.attribValue = ''
|
||||
emitNode(parser, 'onattribute', {
|
||||
name: parser.attribName,
|
||||
value: '',
|
||||
})
|
||||
parser.attribName = ''
|
||||
if (c === '>') {
|
||||
openTag(parser)
|
||||
} else if (isMatch(nameStart, c)) {
|
||||
parser.attribName = c
|
||||
parser.state = S.ATTRIB_NAME
|
||||
} else {
|
||||
strictFail(parser, 'Invalid attribute name')
|
||||
parser.state = S.ATTRIB
|
||||
}
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB_VALUE:
|
||||
if (isWhitespace(c)) {
|
||||
continue
|
||||
} else if (isQuote(c)) {
|
||||
parser.q = c
|
||||
parser.state = S.ATTRIB_VALUE_QUOTED
|
||||
} else {
|
||||
if (!parser.opt.unquotedAttributeValues) {
|
||||
error(parser, 'Unquoted attribute value')
|
||||
}
|
||||
parser.state = S.ATTRIB_VALUE_UNQUOTED
|
||||
parser.attribValue = c
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB_VALUE_QUOTED:
|
||||
if (c !== parser.q) {
|
||||
if (c === '&') {
|
||||
parser.state = S.ATTRIB_VALUE_ENTITY_Q
|
||||
} else {
|
||||
parser.attribValue += c
|
||||
}
|
||||
continue
|
||||
}
|
||||
attrib(parser)
|
||||
parser.q = ''
|
||||
parser.state = S.ATTRIB_VALUE_CLOSED
|
||||
continue
|
||||
|
||||
case S.ATTRIB_VALUE_CLOSED:
|
||||
if (isWhitespace(c)) {
|
||||
parser.state = S.ATTRIB
|
||||
} else if (c === '>') {
|
||||
openTag(parser)
|
||||
} else if (c === '/') {
|
||||
parser.state = S.OPEN_TAG_SLASH
|
||||
} else if (isMatch(nameStart, c)) {
|
||||
strictFail(parser, 'No whitespace between attributes')
|
||||
parser.attribName = c
|
||||
parser.attribValue = ''
|
||||
parser.state = S.ATTRIB_NAME
|
||||
} else {
|
||||
strictFail(parser, 'Invalid attribute name')
|
||||
}
|
||||
continue
|
||||
|
||||
case S.ATTRIB_VALUE_UNQUOTED:
|
||||
if (!isAttribEnd(c)) {
|
||||
if (c === '&') {
|
||||
parser.state = S.ATTRIB_VALUE_ENTITY_U
|
||||
} else {
|
||||
parser.attribValue += c
|
||||
}
|
||||
continue
|
||||
}
|
||||
attrib(parser)
|
||||
if (c === '>') {
|
||||
openTag(parser)
|
||||
} else {
|
||||
parser.state = S.ATTRIB
|
||||
}
|
||||
continue
|
||||
|
||||
case S.CLOSE_TAG:
|
||||
if (!parser.tagName) {
|
||||
if (isWhitespace(c)) {
|
||||
continue
|
||||
} else if (notMatch(nameStart, c)) {
|
||||
if (parser.script) {
|
||||
parser.script += '</' + c
|
||||
parser.state = S.SCRIPT
|
||||
} else {
|
||||
strictFail(parser, 'Invalid tagname in closing tag.')
|
||||
}
|
||||
} else {
|
||||
parser.tagName = c
|
||||
}
|
||||
} else if (c === '>') {
|
||||
closeTag(parser)
|
||||
} else if (isMatch(nameBody, c)) {
|
||||
parser.tagName += c
|
||||
} else if (parser.script) {
|
||||
parser.script += '</' + parser.tagName + c
|
||||
parser.tagName = ''
|
||||
parser.state = S.SCRIPT
|
||||
} else {
|
||||
if (!isWhitespace(c)) {
|
||||
strictFail(parser, 'Invalid tagname in closing tag')
|
||||
}
|
||||
parser.state = S.CLOSE_TAG_SAW_WHITE
|
||||
}
|
||||
continue
|
||||
|
||||
case S.CLOSE_TAG_SAW_WHITE:
|
||||
if (isWhitespace(c)) {
|
||||
continue
|
||||
}
|
||||
if (c === '>') {
|
||||
closeTag(parser)
|
||||
} else {
|
||||
strictFail(parser, 'Invalid characters in closing tag')
|
||||
}
|
||||
continue
|
||||
|
||||
case S.TEXT_ENTITY:
|
||||
case S.ATTRIB_VALUE_ENTITY_Q:
|
||||
case S.ATTRIB_VALUE_ENTITY_U:
|
||||
var returnState
|
||||
var buffer
|
||||
switch (parser.state) {
|
||||
case S.TEXT_ENTITY:
|
||||
returnState = S.TEXT
|
||||
buffer = 'textNode'
|
||||
break
|
||||
|
||||
case S.ATTRIB_VALUE_ENTITY_Q:
|
||||
returnState = S.ATTRIB_VALUE_QUOTED
|
||||
buffer = 'attribValue'
|
||||
break
|
||||
|
||||
case S.ATTRIB_VALUE_ENTITY_U:
|
||||
returnState = S.ATTRIB_VALUE_UNQUOTED
|
||||
buffer = 'attribValue'
|
||||
break
|
||||
}
|
||||
|
||||
if (c === ';') {
|
||||
var parsedEntity = parseEntity(parser)
|
||||
if (
|
||||
parser.opt.unparsedEntities &&
|
||||
!Object.values(sax.XML_ENTITIES).includes(parsedEntity)
|
||||
) {
|
||||
parser.entity = ''
|
||||
parser.state = returnState
|
||||
parser.write(parsedEntity)
|
||||
} else {
|
||||
parser[buffer] += parsedEntity
|
||||
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: /* istanbul ignore next */ {
|
||||
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)
|
||||
31
.agents/skills/dingtalk-api/node_modules/sax/package.json
generated
vendored
Normal file
31
.agents/skills/dingtalk-api/node_modules/sax/package.json
generated
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
{
|
||||
"name": "sax",
|
||||
"description": "An evented streaming XML parser in JavaScript",
|
||||
"author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
|
||||
"version": "1.4.4",
|
||||
"main": "lib/sax.js",
|
||||
"license": "BlueOak-1.0.0",
|
||||
"scripts": {
|
||||
"test": "tap",
|
||||
"preversion": "npm test",
|
||||
"postversion": "npm publish",
|
||||
"postpublish": "git push origin --all; git push origin --tags",
|
||||
"format": "prettier --write . --log-level warn"
|
||||
},
|
||||
"repository": "git://github.com/isaacs/sax-js.git",
|
||||
"files": [
|
||||
"lib/sax.js",
|
||||
"LICENSE",
|
||||
"README.md"
|
||||
],
|
||||
"devDependencies": {
|
||||
"prettier": "^3.6.2",
|
||||
"tap": "^21.1.3"
|
||||
},
|
||||
"tap": {
|
||||
"allow-incomplete-coverage": true
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=11.0.0"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user