A tiny, super fast, namespace awaresax-style XML parser written in plain JavaScript.

• (optional) entity decoding and attribute parsing
• (optional) namespace aware
• element / attribute normalization in namespaced mode
• tiny (2.6Kb minified + gzipped)
• pretty damn fast

var{  Parser}=require('saxen');varparser=newParser();// enable namespace parsing: element prefixes will// automatically adjusted to the ones configured here// elements in other namespaces will still be processedparser.ns({'http://foo':'foo','http://bar':'bar'});parser.on('openTag',function(elementName,attrGetter,decodeEntities,selfClosing,getContext){elementName;// with prefix, i.e. foo:blubvarattrs=attrGetter();// { 'bar:aa': 'A', ... }});parser.parse('<blub xmlns="http://foo" xmlns:bar="http://bar" bar:aa="A" />');

We support the following parse hooks:

• openTag(elementName, attrGetter, decodeEntities, selfClosing, contextGetter)
• closeTag(elementName, decodeEntities, selfClosing, contextGetter)
• error(err, contextGetter)
• warn(warning, contextGetter)
• text(value, decodeEntities, contextGetter)
• cdata(value, contextGetter)
• comment(value, decodeEntities, contextGetter)
• attention(str, decodeEntities, contextGetter)
• question(str, contextGetter)

In contrast toerror,warn receives recoverable errors, such as malformed attributes.

Inproxy mode,openTag andcloseTag a view of the current element replaces the raw element name. In addition element attributes are not passed as a getter toopenTag. Instead, they get exposed via theelement.attrs:

• openTag(element, decodeEntities, selfClosing, contextGetter)
• closeTag(element, selfClosing, contextGetter)

In namespace mode, the parser will adjust tag and attribute namespace prefixes beforepassing the elements name toopenTag orcloseTag. To do that, you need toconfigure default prefixes for wellknown namespaces:

parser.ns({'http://foo':'foo','http://bar':'bar'});

To skip the adjustment and still process namespace information:

parser.ns();

In this mode, the first argument passed toopenTag andcloseTag is an object that exposes more internal XML parse state. This needs to be explicity enabled by instantiating the parser with{ proxy: true }.

// instantiate parser with proxy=truevarparser=newParser({proxy:true});parser.ns({'http://foo-ns':'foo'});parser.on('openTag',function(el,decodeEntities,selfClosing,getContext){el.originalName;// rootel.name;// foo:rootel.attrs;// { 'xmlns:foo': ..., id: '1' }el.ns;// { xmlns: 'foo', foo: 'foo', foo$uri: 'http://foo-ns' }});parser.parse('<root xmlns:foo="http://foo-ns" />')

Proxy mode comes with a performance penelty of roughly five percent.

Caution! For performance reasons the exposed element is a simple view into the current parser state. Because of that, it will change with the parser advancing and cannot be cached. If you would like to retain a persistent copy of the values, create a shallow clone:

parser.on('openTag',function(el){varcopy=Object.assign({},el);// copy, ready to keep around});

/saxen/ lacks some features known in other XML parsers such assax-js:

• no support for parsing loose documents, such as arbitrary HTML snippets
• no support for text trimming
• no automatic entity decoding
• no automatic attribute parsing

...and that is ok ❤.

We build on the awesome work done byeasysax.

/saxen/ is named afterSachsen, a federal state of Germany. So geht sächsisch!

MIT