projen 0.98.32 → 0.98.34

package/node_modules/xmlbuilder2/lib/writers/BaseWriter.js

@@ -1,56 +1,27 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var interfaces_1 = require("@oozcitak/dom/lib/dom/interfaces");
-var LocalNameSet_1 = require("@oozcitak/dom/lib/serializer/LocalNameSet");
-var NamespacePrefixMap_1 = require("@oozcitak/dom/lib/serializer/NamespacePrefixMap");
-var infra_1 = require("@oozcitak/infra");
-var algorithm_1 = require("@oozcitak/dom/lib/algorithm");
-var constants_1 = require("../constants");
+exports.BaseWriter = void 0;
+const interfaces_1 = require("@oozcitak/dom/lib/dom/interfaces");
+const LocalNameSet_1 = require("@oozcitak/dom/lib/serializer/LocalNameSet");
+const NamespacePrefixMap_1 = require("@oozcitak/dom/lib/serializer/NamespacePrefixMap");
+const infra_1 = require("@oozcitak/infra");
+const algorithm_1 = require("@oozcitak/dom/lib/algorithm");
+const constants_1 = require("../constants");
 /**
  * Pre-serializes XML nodes.
  */
-var BaseWriter = /** @class */ (function () {
+class BaseWriter {
+    static _VoidElementNames = new Set(['area', 'base', 'basefont',
+        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
+        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
+    _builderOptions;
+    _writerOptions;
     /**
      * Initializes a new instance of `BaseWriter`.
      *
      * @param builderOptions - XML builder options
      */
-    function BaseWriter(builderOptions) {
-        /**
-         * Gets the current depth of the XML tree.
-         */
-        this.level = 0;
+    constructor(builderOptions) {
         this._builderOptions = builderOptions;
     }
     /**
@@ -60,7 +31,7 @@ var BaseWriter = /** @class */ (function () {
      * @param encoding - encoding declaration
      * @param standalone - standalone document declaration
      */
-    BaseWriter.prototype.declaration = function (version, encoding, standalone) { };
+    declaration(version, encoding, standalone) { }
     /**
      * Used by derived classes to serialize a DocType node.
      *
@@ -68,39 +39,39 @@ var BaseWriter = /** @class */ (function () {
      * @param publicId - public identifier
      * @param systemId - system identifier
      */
-    BaseWriter.prototype.docType = function (name, publicId, systemId) { };
+    docType(name, publicId, systemId) { }
     /**
      * Used by derived classes to serialize a comment node.
      *
      * @param data - node data
      */
-    BaseWriter.prototype.comment = function (data) { };
+    comment(data) { }
     /**
      * Used by derived classes to serialize a text node.
      *
      * @param data - node data
      */
-    BaseWriter.prototype.text = function (data) { };
+    text(data) { }
     /**
      * Used by derived classes to serialize a processing instruction node.
      *
      * @param target - instruction target
      * @param data - node data
      */
-    BaseWriter.prototype.instruction = function (target, data) { };
+    instruction(target, data) { }
     /**
      * Used by derived classes to serialize a CData section node.
      *
      * @param data - node data
      */
-    BaseWriter.prototype.cdata = function (data) { };
+    cdata(data) { }
     /**
      * Used by derived classes to serialize the beginning of the opening tag of an
      * element node.
      *
      * @param name - node name
      */
-    BaseWriter.prototype.openTagBegin = function (name) { };
+    openTagBegin(name) { }
     /**
      * Used by derived classes to serialize the ending of the opening tag of an
      * element node.
@@ -109,55 +80,52 @@ var BaseWriter = /** @class */ (function () {
      * @param selfClosing - whether the element node is self closing
      * @param voidElement - whether the element node is a HTML void element
      */
-    BaseWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { };
+    openTagEnd(name, selfClosing, voidElement) { }
     /**
      * Used by derived classes to serialize the closing tag of an element node.
      *
      * @param name - node name
      */
-    BaseWriter.prototype.closeTag = function (name) { };
+    closeTag(name) { }
     /**
      * Used by derived classes to serialize attributes or namespace declarations.
      *
      * @param attributes - attribute array
      */
-    BaseWriter.prototype.attributes = function (attributes) {
-        var e_1, _a;
-        try {
-            for (var attributes_1 = __values(attributes), attributes_1_1 = attributes_1.next(); !attributes_1_1.done; attributes_1_1 = attributes_1.next()) {
-                var attr = attributes_1_1.value;
-                this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]);
-            }
+    attributes(attributes) {
+        for (const attr of attributes) {
+            this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]);
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (attributes_1_1 && !attributes_1_1.done && (_a = attributes_1.return)) _a.call(attributes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
+    }
     /**
      * Used by derived classes to serialize an attribute or namespace declaration.
      *
      * @param name - node name
      * @param value - node value
      */
-    BaseWriter.prototype.attribute = function (name, value) { };
+    attribute(name, value) { }
     /**
      * Used by derived classes to perform any pre-processing steps before starting
      * serializing an element node.
      *
      * @param name - node name
      */
-    BaseWriter.prototype.beginElement = function (name) { };
+    beginElement(name) { }
     /**
      * Used by derived classes to perform any post-processing steps after
      * completing serializing an element node.
      *
      * @param name - node name
      */
-    BaseWriter.prototype.endElement = function (name) { };
+    endElement(name) { }
+    /**
+     * Gets the current depth of the XML tree.
+     */
+    level = 0;
+    /**
+     * Gets the current XML node.
+     */
+    currentNode;
     /**
      * Produces an XML serialization of the given node. The pre-serializer inserts
      * namespace declarations where necessary and produces qualified names for
@@ -166,8 +134,8 @@ var BaseWriter = /** @class */ (function () {
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype.serializeNode = function (node, requireWellFormed) {
-        var hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces);
+    serializeNode(node, requireWellFormed) {
+        const hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces);
         this.level = 0;
         this.currentNode = node;
         if (hasNamespaces) {
@@ -187,10 +155,10 @@ var BaseWriter = /** @class */ (function () {
              * serialize a node's namespaceURI (or the namespaceURI of one of node's
              * attributes). See the generate a prefix algorithm.
              */
-            var namespace = null;
-            var prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
+            let namespace = null;
+            const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
             prefixMap.set("xml", infra_1.namespace.XML);
-            var prefixIndex = { value: 1 };
+            const prefixIndex = { value: 1 };
             /**
              * 5. Return the result of running the XML serialization algorithm on node
              * passing the context namespace namespace, namespace prefix map prefix map,
@@ -204,7 +172,7 @@ var BaseWriter = /** @class */ (function () {
         else {
             this._serializeNode(node, requireWellFormed);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a node.
      *
@@ -214,7 +182,7 @@ var BaseWriter = /** @class */ (function () {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeNodeNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+    _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
         this.currentNode = node;
         switch (node.nodeType) {
             case interfaces_1.NodeType.Element:
@@ -242,16 +210,16 @@ var BaseWriter = /** @class */ (function () {
                 this._serializeCData(node, requireWellFormed);
                 break;
             default:
-                throw new Error("Unknown node type: " + node.nodeType);
+                throw new Error(`Unknown node type: ${node.nodeType}`);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeNode = function (node, requireWellFormed) {
+    _serializeNode(node, requireWellFormed) {
         this.currentNode = node;
         switch (node.nodeType) {
             case interfaces_1.NodeType.Element:
@@ -279,9 +247,9 @@ var BaseWriter = /** @class */ (function () {
                 this._serializeCData(node, requireWellFormed);
                 break;
             default:
-                throw new Error("Unknown node type: " + node.nodeType);
+                throw new Error(`Unknown node type: ${node.nodeType}`);
         }
-    };
+    }
     /**
      * Produces an XML serialization of an element node.
      *
@@ -291,9 +259,8 @@ var BaseWriter = /** @class */ (function () {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeElementNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        var e_2, _a;
-        var attributes = [];
+    _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+        const attributes = [];
         /**
          * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
          *
@@ -303,7 +270,7 @@ var BaseWriter = /** @class */ (function () {
          * serialization of this node would not be a well-formed element.
          */
         if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !algorithm_1.xml_isName(node.localName))) {
+            !(0, algorithm_1.xml_isName)(node.localName))) {
             throw new Error("Node local name contains invalid characters (well-formed required).");
         }
         /**
@@ -336,14 +303,14 @@ var BaseWriter = /** @class */ (function () {
          * 9. Let inherited ns be a copy of namespace.
          * 10. Let ns be the value of node's namespaceURI attribute.
          */
-        var qualifiedName = '';
-        var skipEndTag = false;
-        var ignoreNamespaceDefinitionAttribute = false;
-        var map = prefixMap.copy();
-        var localPrefixesMap = {};
-        var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
-        var inheritedNS = namespace;
-        var ns = node.namespaceURI;
+        let qualifiedName = '';
+        let skipEndTag = false;
+        let ignoreNamespaceDefinitionAttribute = false;
+        let map = prefixMap.copy();
+        let localPrefixesMap = {};
+        let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
+        let inheritedNS = namespace;
+        let ns = node.namespaceURI;
         /** 11. If inherited ns is equal to ns, then: */
         if (inheritedNS === ns) {
             /**
@@ -380,14 +347,14 @@ var BaseWriter = /** @class */ (function () {
              * prefix string prefix from map given namespace ns. The above may return
              * null if no namespace key ns exists in map.
              */
-            var prefix = node.prefix;
+            let prefix = node.prefix;
             /**
              * We don't need to run "retrieving a preferred prefix string" algorithm if
              * the element has no prefix and its namespace matches to the default
              * namespace.
              * See: https://github.com/web-platform-tests/wpt/pull/16703
              */
-            var candidatePrefix = null;
+            let candidatePrefix = null;
             if (prefix !== null || ns !== localDefaultNamespace) {
                 candidatePrefix = map.get(prefix, ns);
             }
@@ -564,7 +531,7 @@ var BaseWriter = /** @class */ (function () {
          * attributes given map, prefix index, local prefixes map, ignore namespace
          * definition attribute flag, and require well-formed flag.
          */
-        attributes.push.apply(attributes, __spread(this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed)));
+        attributes.push(...this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed));
         this.attributes(attributes);
         /**
          * 14. If ns is the HTML namespace, and the node's list of children is
@@ -581,7 +548,7 @@ var BaseWriter = /** @class */ (function () {
          * tag flag to true.
          * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
          */
-        var isHTML = (ns === infra_1.namespace.HTML);
+        const isHTML = (ns === infra_1.namespace.HTML);
         if (isHTML && node.childNodes.length === 0 &&
             BaseWriter._VoidElementNames.has(node.localName)) {
             this.openTagEnd(qualifiedName, true, true);
@@ -621,20 +588,10 @@ var BaseWriter = /** @class */ (function () {
             // TODO: serialize template contents
         }
         else {
-            try {
-                for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var childNode = _c.value;
-                    this.level++;
-                    this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
-                    this.level--;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_2) throw e_2.error; }
+            for (const childNode of node.childNodes) {
+                this.level++;
+                this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
+                this.level--;
             }
         }
         /**
@@ -646,15 +603,14 @@ var BaseWriter = /** @class */ (function () {
          */
         this.closeTag(qualifiedName);
         this.endElement(qualifiedName);
-    };
+    }
     /**
      * Produces an XML serialization of an element node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeElement = function (node, requireWellFormed) {
-        var e_3, _a;
+    _serializeElement(node, requireWellFormed) {
         /**
          * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
          *
@@ -664,7 +620,7 @@ var BaseWriter = /** @class */ (function () {
          * serialization of this node would not be a well-formed element.
          */
         if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !algorithm_1.xml_isName(node.localName))) {
+            !(0, algorithm_1.xml_isName)(node.localName))) {
             throw new Error("Node local name contains invalid characters (well-formed required).");
         }
         /**
@@ -697,7 +653,7 @@ var BaseWriter = /** @class */ (function () {
          * 9. Let inherited ns be a copy of namespace.
          * 10. Let ns be the value of node's namespaceURI attribute.
          */
-        var skipEndTag = false;
+        let skipEndTag = false;
         /** 11. If inherited ns is equal to ns, then: */
         /**
          * 11.1. If local default namespace is not null, then set ignore
@@ -709,7 +665,7 @@ var BaseWriter = /** @class */ (function () {
          * 11.3. Otherwise, append to qualified name the value of node's
          * localName. The node's prefix if it exists, is dropped.
          */
-        var qualifiedName = node.localName;
+        const qualifiedName = node.localName;
         /** 11.4. Append the value of qualified name to markup. */
         this.beginElement(qualifiedName);
         this.openTagBegin(qualifiedName);
@@ -718,7 +674,7 @@ var BaseWriter = /** @class */ (function () {
          * attributes given map, prefix index, local prefixes map, ignore namespace
          * definition attribute flag, and require well-formed flag.
          */
-        var attributes = this._serializeAttributes(node, requireWellFormed);
+        const attributes = this._serializeAttributes(node, requireWellFormed);
         this.attributes(attributes);
         /**
          * 14. If ns is the HTML namespace, and the node's list of children is
@@ -749,35 +705,25 @@ var BaseWriter = /** @class */ (function () {
          */
         if (skipEndTag)
             return;
-        try {
-            /**
-             * 18. If ns is the HTML namespace, and the node's localName matches the
-             * string "template", then this is a template element. Append to markup the
-             * result of XML serializing a DocumentFragment node given the template
-             * element's template contents (a DocumentFragment), providing inherited
-             * ns, map, prefix index, and the require well-formed flag.
-             *
-             * _Note:_ This allows template content to round-trip, given the rules for
-             * parsing XHTML documents.
-             *
-             * 19. Otherwise, append to markup the result of running the XML
-             * serialization algorithm on each of node's children, in tree order,
-             * providing inherited ns, map, prefix index, and the require well-formed
-             * flag.
-             */
-            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var childNode = _c.value;
-                this.level++;
-                this._serializeNode(childNode, requireWellFormed);
-                this.level--;
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_3) throw e_3.error; }
+        /**
+         * 18. If ns is the HTML namespace, and the node's localName matches the
+         * string "template", then this is a template element. Append to markup the
+         * result of XML serializing a DocumentFragment node given the template
+         * element's template contents (a DocumentFragment), providing inherited
+         * ns, map, prefix index, and the require well-formed flag.
+         *
+         * _Note:_ This allows template content to round-trip, given the rules for
+         * parsing XHTML documents.
+         *
+         * 19. Otherwise, append to markup the result of running the XML
+         * serialization algorithm on each of node's children, in tree order,
+         * providing inherited ns, map, prefix index, and the require well-formed
+         * flag.
+         */
+        for (const childNode of node._children) {
+            this.level++;
+            this._serializeNode(childNode, requireWellFormed);
+            this.level--;
         }
         /**
          * 20. Append the following to markup, in the order listed:
@@ -788,7 +734,7 @@ var BaseWriter = /** @class */ (function () {
          */
         this.closeTag(qualifiedName);
         this.endElement(qualifiedName);
-    };
+    }
     /**
      * Produces an XML serialization of a document node.
      *
@@ -798,8 +744,7 @@ var BaseWriter = /** @class */ (function () {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeDocumentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        var e_4, _a;
+    _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
         /**
          * If the require well-formed flag is set (its value is true), and this node
          * has no documentElement (the documentElement attribute's value is null),
@@ -809,42 +754,31 @@ var BaseWriter = /** @class */ (function () {
         if (requireWellFormed && node.documentElement === null) {
             throw new Error("Missing document element (well-formed required).");
         }
-        try {
-            /**
-             * Otherwise, run the following steps:
-             * 1. Let serialized document be an empty string.
-             * 2. For each child child of node, in tree order, run the XML
-             * serialization algorithm on the child passing along the provided
-             * arguments, and append the result to serialized document.
-             *
-             * _Note:_ This will serialize any number of ProcessingInstruction and
-             * Comment nodes both before and after the Document's documentElement node,
-             * including at most one DocumentType node. (Text nodes are not allowed as
-             * children of the Document.)
-             *
-             * 3. Return the value of serialized document.
-            */
-            for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var childNode = _c.value;
-                this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_4) throw e_4.error; }
+        /**
+         * Otherwise, run the following steps:
+         * 1. Let serialized document be an empty string.
+         * 2. For each child child of node, in tree order, run the XML
+         * serialization algorithm on the child passing along the provided
+         * arguments, and append the result to serialized document.
+         *
+         * _Note:_ This will serialize any number of ProcessingInstruction and
+         * Comment nodes both before and after the Document's documentElement node,
+         * including at most one DocumentType node. (Text nodes are not allowed as
+         * children of the Document.)
+         *
+         * 3. Return the value of serialized document.
+        */
+        for (const childNode of node.childNodes) {
+            this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a document node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeDocument = function (node, requireWellFormed) {
-        var e_5, _a;
+    _serializeDocument(node, requireWellFormed) {
         /**
          * If the require well-formed flag is set (its value is true), and this node
          * has no documentElement (the documentElement attribute's value is null),
@@ -854,41 +788,31 @@ var BaseWriter = /** @class */ (function () {
         if (requireWellFormed && node.documentElement === null) {
             throw new Error("Missing document element (well-formed required).");
         }
-        try {
-            /**
-             * Otherwise, run the following steps:
-             * 1. Let serialized document be an empty string.
-             * 2. For each child child of node, in tree order, run the XML
-             * serialization algorithm on the child passing along the provided
-             * arguments, and append the result to serialized document.
-             *
-             * _Note:_ This will serialize any number of ProcessingInstruction and
-             * Comment nodes both before and after the Document's documentElement node,
-             * including at most one DocumentType node. (Text nodes are not allowed as
-             * children of the Document.)
-             *
-             * 3. Return the value of serialized document.
-            */
-            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var childNode = _c.value;
-                this._serializeNode(childNode, requireWellFormed);
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_5) throw e_5.error; }
+        /**
+         * Otherwise, run the following steps:
+         * 1. Let serialized document be an empty string.
+         * 2. For each child child of node, in tree order, run the XML
+         * serialization algorithm on the child passing along the provided
+         * arguments, and append the result to serialized document.
+         *
+         * _Note:_ This will serialize any number of ProcessingInstruction and
+         * Comment nodes both before and after the Document's documentElement node,
+         * including at most one DocumentType node. (Text nodes are not allowed as
+         * children of the Document.)
+         *
+         * 3. Return the value of serialized document.
+        */
+        for (const childNode of node._children) {
+            this._serializeNode(childNode, requireWellFormed);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a comment node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeComment = function (node, requireWellFormed) {
+    _serializeComment(node, requireWellFormed) {
         /**
          * If the require well-formed flag is set (its value is true), and node's
          * data contains characters that are not matched by the XML Char production
@@ -896,7 +820,7 @@ var BaseWriter = /** @class */ (function () {
          * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
          * the serialization of this node's data would not be well-formed.
          */
-        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
+        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
             node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
             throw new Error("Comment data contains invalid characters (well-formed required).");
         }
@@ -904,7 +828,7 @@ var BaseWriter = /** @class */ (function () {
          * Otherwise, return the concatenation of "<!--", node's data, and "-->".
          */
         this.comment(node.data);
-    };
+    }
     /**
      * Produces an XML serialization of a text node.
      *
@@ -912,14 +836,14 @@ var BaseWriter = /** @class */ (function () {
      * @param requireWellFormed - whether to check conformance
      * @param level - current depth of the XML tree
      */
-    BaseWriter.prototype._serializeText = function (node, requireWellFormed) {
+    _serializeText(node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is set (its value is true), and
          * node's data contains characters that are not matched by the XML Char
          * production, then throw an exception; the serialization of this node's
          * data would not be well-formed.
          */
-        if (requireWellFormed && !algorithm_1.xml_isLegalChar(node.data)) {
+        if (requireWellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
             throw new Error("Text data contains invalid characters (well-formed required).");
         }
         /**
@@ -929,11 +853,11 @@ var BaseWriter = /** @class */ (function () {
          * 5. Replace any occurrences of ">" in markup by "&gt;".
          * 6. Return the value of markup.
          */
-        var markup = node.data.replace(constants_1.nonEntityAmpersandRegex, '&amp;')
+        const markup = node.data.replace(constants_1.nonEntityAmpersandRegex, '&amp;')
             .replace(/</g, '&lt;')
             .replace(/>/g, '&gt;');
         this.text(markup);
-    };
+    }
     /**
      * Produces an XML serialization of a document fragment node.
      *
@@ -943,72 +867,50 @@ var BaseWriter = /** @class */ (function () {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeDocumentFragmentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        var e_6, _a;
-        try {
-            /**
-             * 1. Let markup the empty string.
-             * 2. For each child child of node, in tree order, run the XML serialization
-             * algorithm on the child given namespace, prefix map, a reference to prefix
-             * index, and flag require well-formed. Concatenate the result to markup.
-             * 3. Return the value of markup.
-             */
-            for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var childNode = _c.value;
-                this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_6) throw e_6.error; }
+    _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+        /**
+         * 1. Let markup the empty string.
+         * 2. For each child child of node, in tree order, run the XML serialization
+         * algorithm on the child given namespace, prefix map, a reference to prefix
+         * index, and flag require well-formed. Concatenate the result to markup.
+         * 3. Return the value of markup.
+         */
+        for (const childNode of node.childNodes) {
+            this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a document fragment node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeDocumentFragment = function (node, requireWellFormed) {
-        var e_7, _a;
-        try {
-            /**
-             * 1. Let markup the empty string.
-             * 2. For each child child of node, in tree order, run the XML serialization
-             * algorithm on the child given namespace, prefix map, a reference to prefix
-             * index, and flag require well-formed. Concatenate the result to markup.
-             * 3. Return the value of markup.
-             */
-            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var childNode = _c.value;
-                this._serializeNode(childNode, requireWellFormed);
-            }
-        }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_7) throw e_7.error; }
+    _serializeDocumentFragment(node, requireWellFormed) {
+        /**
+         * 1. Let markup the empty string.
+         * 2. For each child child of node, in tree order, run the XML serialization
+         * algorithm on the child given namespace, prefix map, a reference to prefix
+         * index, and flag require well-formed. Concatenate the result to markup.
+         * 3. Return the value of markup.
+         */
+        for (const childNode of node._children) {
+            this._serializeNode(childNode, requireWellFormed);
         }
-    };
+    }
     /**
      * Produces an XML serialization of a document type node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeDocumentType = function (node, requireWellFormed) {
+    _serializeDocumentType(node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is true and the node's publicId
          * attribute contains characters that are not matched by the XML PubidChar
          *  production, then throw an exception; the serialization of this node
          * would not be a well-formed document type declaration.
          */
-        if (requireWellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) {
+        if (requireWellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
             throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
         }
         /**
@@ -1019,7 +921,7 @@ var BaseWriter = /** @class */ (function () {
          * of this node would not be a well-formed document type declaration.
          */
         if (requireWellFormed &&
-            (!algorithm_1.xml_isLegalChar(node.systemId) ||
+            (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
                 (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
             throw new Error("DocType system identifier contains invalid characters (well-formed required).");
         }
@@ -1052,14 +954,14 @@ var BaseWriter = /** @class */ (function () {
          * 11. Return the value of markup.
          */
         this.docType(node.name, node.publicId, node.systemId);
-    };
+    }
     /**
      * Produces an XML serialization of a processing instruction node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeProcessingInstruction = function (node, requireWellFormed) {
+    _serializeProcessingInstruction(node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is set (its value is true), and node's
          * target contains a ":" (U+003A COLON) character or is an ASCII
@@ -1076,7 +978,7 @@ var BaseWriter = /** @class */ (function () {
          * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
          * this node's data would not be well-formed.
          */
-        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
+        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
             node.data.indexOf("?>") !== -1)) {
             throw new Error("Processing instruction data contains invalid characters (well-formed required).");
         }
@@ -1090,19 +992,19 @@ var BaseWriter = /** @class */ (function () {
          * 4. Return the value of markup.
          */
         this.instruction(node.target, node.data);
-    };
+    }
     /**
      * Produces an XML serialization of a CDATA node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeCData = function (node, requireWellFormed) {
+    _serializeCData(node, requireWellFormed) {
         if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
             throw new Error("CDATA contains invalid characters (well-formed required).");
         }
         this.cdata(node.data);
-    };
+    }
     /**
     * Produces an XML serialization of the attributes of an element node.
     *
@@ -1114,8 +1016,7 @@ var BaseWriter = /** @class */ (function () {
      * attributes
      * @param requireWellFormed - whether to check conformance
     */
-    BaseWriter.prototype._serializeAttributesNS = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
-        var e_8, _a;
+    _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
         /**
          * 1. Let result be the empty string.
          * 2. Let localname set be a new empty namespace localname set. This
@@ -1126,209 +1027,198 @@ var BaseWriter = /** @class */ (function () {
          * This can occur when two otherwise identical attributes on the same
          * element differ only by their prefix values.
          */
-        var result = [];
-        var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
-        try {
+        const result = [];
+        const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
+        /**
+         * 3. Loop: For each attribute attr in element's attributes, in the order
+         * they are specified in the element's attribute list:
+         */
+        for (const attr of node.attributes) {
+            // Optimize common case
+            if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
+                result.push([null, null, attr.localName,
+                    this._serializeAttributeValue(attr.value, requireWellFormed)]);
+                continue;
+            }
             /**
-             * 3. Loop: For each attribute attr in element's attributes, in the order
-             * they are specified in the element's attribute list:
+             * 3.1. If the require well-formed flag is set (its value is true), and the
+             * localname set contains a tuple whose values match those of a new tuple
+             * consisting of attr's namespaceURI attribute and localName attribute,
+             * then throw an exception; the serialization of this attr would fail to
+             * produce a well-formed element serialization.
              */
-            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var attr = _c.value;
-                // Optimize common case
-                if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
-                    result.push([null, null, attr.localName,
-                        this._serializeAttributeValue(attr.value, requireWellFormed)]);
-                    continue;
-                }
+            if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
+                throw new Error("Element contains duplicate attributes (well-formed required).");
+            }
+            /**
+             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+             * localName attribute, and add it to the localname set.
+             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+             * 3.4. Let candidate prefix be null.
+             */
+            if (requireWellFormed && localNameSet)
+                localNameSet.set(attr.namespaceURI, attr.localName);
+            let attributeNamespace = attr.namespaceURI;
+            let candidatePrefix = null;
+            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+            if (attributeNamespace !== null) {
                 /**
-                 * 3.1. If the require well-formed flag is set (its value is true), and the
-                 * localname set contains a tuple whose values match those of a new tuple
-                 * consisting of attr's namespaceURI attribute and localName attribute,
-                 * then throw an exception; the serialization of this attr would fail to
-                 * produce a well-formed element serialization.
+                 * 3.5.1. Let candidate prefix be the result of retrieving a preferred
+                 * prefix string from map given namespace attribute namespace with
+                 * preferred prefix being attr's prefix value.
                  */
-                if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
-                    throw new Error("Element contains duplicate attributes (well-formed required).");
-                }
+                candidatePrefix = map.get(attr.prefix, attributeNamespace);
                 /**
-                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-                 * localName attribute, and add it to the localname set.
-                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-                 * 3.4. Let candidate prefix be null.
+                 * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
+                 * then run these steps:
                  */
-                if (requireWellFormed && localNameSet)
-                    localNameSet.set(attr.namespaceURI, attr.localName);
-                var attributeNamespace = attr.namespaceURI;
-                var candidatePrefix = null;
-                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-                if (attributeNamespace !== null) {
+                if (attributeNamespace === infra_1.namespace.XMLNS) {
                     /**
-                     * 3.5.1. Let candidate prefix be the result of retrieving a preferred
-                     * prefix string from map given namespace attribute namespace with
-                     * preferred prefix being attr's prefix value.
+                     * 3.5.2.1. If any of the following are true, then stop running these
+                     * steps and goto Loop to visit the next attribute:
+                     * - the attr's value is the XML namespace;
+                     * _Note:_ The XML namespace cannot be redeclared and survive
+                     * round-tripping (unless it defines the prefix "xml"). To avoid this
+                     * problem, this algorithm always prefixes elements in the XML
+                     * namespace with "xml" and drops any related definitions as seen
+                     * in the above condition.
+                     * - the attr's prefix is null and the ignore namespace definition
+                     * attribute flag is true (the Element's default namespace attribute
+                     * should be skipped);
+                     * - the attr's prefix is not null and either
+                     *   * the attr's localName is not a key contained in the local
+                     *     prefixes map, or
+                     *   * the attr's localName is present in the local prefixes map but
+                     *     the value of the key does not match attr's value
+                     * and furthermore that the attr's localName (as the prefix to find)
+                     * is found in the namespace prefix map given the namespace consisting
+                     * of the attr's value (the current namespace prefix definition was
+                     * exactly defined previously--on an ancestor element not the current
+                     * element whose attributes are being processed).
                      */
-                    candidatePrefix = map.get(attr.prefix, attributeNamespace);
+                    if (attr.value === infra_1.namespace.XML ||
+                        (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
+                        (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
+                            localPrefixesMap[attr.localName] !== attr.value) &&
+                            map.has(attr.localName, attr.value)))
+                        continue;
                     /**
-                     * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
-                     * then run these steps:
+                     * 3.5.2.2. If the require well-formed flag is set (its value is true),
+                     * and the value of attr's value attribute matches the XMLNS
+                     * namespace, then throw an exception; the serialization of this
+                     * attribute would produce invalid XML because the XMLNS namespace
+                     * is reserved and cannot be applied as an element's namespace via
+                     * XML parsing.
+                     *
+                     * _Note:_ DOM APIs do allow creation of elements in the XMLNS
+                     * namespace but with strict qualifications.
                      */
-                    if (attributeNamespace === infra_1.namespace.XMLNS) {
-                        /**
-                         * 3.5.2.1. If any of the following are true, then stop running these
-                         * steps and goto Loop to visit the next attribute:
-                         * - the attr's value is the XML namespace;
-                         * _Note:_ The XML namespace cannot be redeclared and survive
-                         * round-tripping (unless it defines the prefix "xml"). To avoid this
-                         * problem, this algorithm always prefixes elements in the XML
-                         * namespace with "xml" and drops any related definitions as seen
-                         * in the above condition.
-                         * - the attr's prefix is null and the ignore namespace definition
-                         * attribute flag is true (the Element's default namespace attribute
-                         * should be skipped);
-                         * - the attr's prefix is not null and either
-                         *   * the attr's localName is not a key contained in the local
-                         *     prefixes map, or
-                         *   * the attr's localName is present in the local prefixes map but
-                         *     the value of the key does not match attr's value
-                         * and furthermore that the attr's localName (as the prefix to find)
-                         * is found in the namespace prefix map given the namespace consisting
-                         * of the attr's value (the current namespace prefix definition was
-                         * exactly defined previously--on an ancestor element not the current
-                         * element whose attributes are being processed).
-                         */
-                        if (attr.value === infra_1.namespace.XML ||
-                            (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
-                            (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
-                                localPrefixesMap[attr.localName] !== attr.value) &&
-                                map.has(attr.localName, attr.value)))
-                            continue;
-                        /**
-                         * 3.5.2.2. If the require well-formed flag is set (its value is true),
-                         * and the value of attr's value attribute matches the XMLNS
-                         * namespace, then throw an exception; the serialization of this
-                         * attribute would produce invalid XML because the XMLNS namespace
-                         * is reserved and cannot be applied as an element's namespace via
-                         * XML parsing.
-                         *
-                         * _Note:_ DOM APIs do allow creation of elements in the XMLNS
-                         * namespace but with strict qualifications.
-                         */
-                        if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
-                            throw new Error("XMLNS namespace is reserved (well-formed required).");
-                        }
-                        /**
-                         * 3.5.2.3. If the require well-formed flag is set (its value is true),
-                         * and the value of attr's value attribute is the empty string, then
-                         * throw an exception; namespace prefix declarations cannot be used
-                         * to undeclare a namespace (use a default namespace declaration
-                         * instead).
-                         */
-                        if (requireWellFormed && attr.value === '') {
-                            throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
-                        }
-                        /**
-                         * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
-                         * candidate prefix be the string "xmlns".
-                         */
-                        if (attr.prefix === 'xmlns')
-                            candidatePrefix = 'xmlns';
+                    if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
+                        throw new Error("XMLNS namespace is reserved (well-formed required).");
+                    }
+                    /**
+                     * 3.5.2.3. If the require well-formed flag is set (its value is true),
+                     * and the value of attr's value attribute is the empty string, then
+                     * throw an exception; namespace prefix declarations cannot be used
+                     * to undeclare a namespace (use a default namespace declaration
+                     * instead).
+                     */
+                    if (requireWellFormed && attr.value === '') {
+                        throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
+                    }
+                    /**
+                     * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
+                     * candidate prefix be the string "xmlns".
+                     */
+                    if (attr.prefix === 'xmlns')
+                        candidatePrefix = 'xmlns';
+                    /**
+                     * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
+                     * Run these steps:
+                     *
+                     * _Note:_ The (candidatePrefix === null) check is not in the spec.
+                     * We deviate from the spec here. Otherwise a prefix is generated for
+                     * all attributes with namespaces.
+                     */
+                }
+                else if (candidatePrefix === null) {
+                    if (attr.prefix !== null &&
+                        (!map.hasPrefix(attr.prefix) ||
+                            map.has(attr.prefix, attributeNamespace))) {
                         /**
-                         * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
-                         * Run these steps:
-                         *
-                         * _Note:_ The (candidatePrefix === null) check is not in the spec.
-                         * We deviate from the spec here. Otherwise a prefix is generated for
-                         * all attributes with namespaces.
+                         * Check if we can use the attribute's own prefix.
+                         * We deviate from the spec here.
+                         * TODO: This is not an efficient way of searching for prefixes.
+                         * Follow developments to the spec.
                          */
+                        candidatePrefix = attr.prefix;
                     }
-                    else if (candidatePrefix === null) {
-                        if (attr.prefix !== null &&
-                            (!map.hasPrefix(attr.prefix) ||
-                                map.has(attr.prefix, attributeNamespace))) {
-                            /**
-                             * Check if we can use the attribute's own prefix.
-                             * We deviate from the spec here.
-                             * TODO: This is not an efficient way of searching for prefixes.
-                             * Follow developments to the spec.
-                             */
-                            candidatePrefix = attr.prefix;
-                        }
-                        else {
-                            /**
-                             * 3.5.3.1. Let candidate prefix be the result of generating a prefix
-                             * providing map, attribute namespace, and prefix index as input.
-                             */
-                            candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
-                        }
+                    else {
                         /**
-                         * 3.5.3.2. Append the following to result, in the order listed:
-                         * 3.5.3.2.1. " " (U+0020 SPACE);
-                         * 3.5.3.2.2. The string "xmlns:";
-                         * 3.5.3.2.3. The value of candidate prefix;
-                         * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                         * 3.5.3.2.5. The result of serializing an attribute value given
-                         * attribute namespace and the require well-formed flag as input;
-                         * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
-                        */
-                        result.push([null, "xmlns", candidatePrefix,
-                            this._serializeAttributeValue(attributeNamespace, requireWellFormed)]);
+                         * 3.5.3.1. Let candidate prefix be the result of generating a prefix
+                         * providing map, attribute namespace, and prefix index as input.
+                         */
+                        candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
                     }
+                    /**
+                     * 3.5.3.2. Append the following to result, in the order listed:
+                     * 3.5.3.2.1. " " (U+0020 SPACE);
+                     * 3.5.3.2.2. The string "xmlns:";
+                     * 3.5.3.2.3. The value of candidate prefix;
+                     * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                     * 3.5.3.2.5. The result of serializing an attribute value given
+                     * attribute namespace and the require well-formed flag as input;
+                     * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
+                    */
+                    result.push([null, "xmlns", candidatePrefix,
+                        this._serializeAttributeValue(attributeNamespace, requireWellFormed)]);
                 }
-                /**
-                 * 3.6. Append a " " (U+0020 SPACE) to result.
-                 * 3.7. If candidate prefix is not null, then append to result the
-                 * concatenation of candidate prefix with ":" (U+003A COLON).
-                 */
-                var attrName = '';
-                if (candidatePrefix !== null) {
-                    attrName = candidatePrefix;
-                }
-                /**
-                 * 3.8. If the require well-formed flag is set (its value is true), and
-                 * this attr's localName attribute contains the character
-                 * ":" (U+003A COLON) or does not match the XML Name production or
-                 * equals "xmlns" and attribute namespace is null, then throw an
-                 * exception; the serialization of this attr would not be a
-                 * well-formed attribute.
-                 */
-                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                    !algorithm_1.xml_isName(attr.localName) ||
-                    (attr.localName === "xmlns" && attributeNamespace === null))) {
-                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
-                }
-                /**
-                 * 3.9. Append the following strings to result, in the order listed:
-                 * 3.9.1. The value of attr's localName;
-                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                 * 3.9.3. The result of serializing an attribute value given attr's value
-                 * attribute and the require well-formed flag as input;
-                 * 3.9.4. """ (U+0022 QUOTATION MARK).
-                 */
-                result.push([attributeNamespace, candidatePrefix, attr.localName,
-                    this._serializeAttributeValue(attr.value, requireWellFormed)]);
             }
-        }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            /**
+             * 3.6. Append a " " (U+0020 SPACE) to result.
+             * 3.7. If candidate prefix is not null, then append to result the
+             * concatenation of candidate prefix with ":" (U+003A COLON).
+             */
+            let attrName = '';
+            if (candidatePrefix !== null) {
+                attrName = candidatePrefix;
             }
-            finally { if (e_8) throw e_8.error; }
+            /**
+             * 3.8. If the require well-formed flag is set (its value is true), and
+             * this attr's localName attribute contains the character
+             * ":" (U+003A COLON) or does not match the XML Name production or
+             * equals "xmlns" and attribute namespace is null, then throw an
+             * exception; the serialization of this attr would not be a
+             * well-formed attribute.
+             */
+            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                !(0, algorithm_1.xml_isName)(attr.localName) ||
+                (attr.localName === "xmlns" && attributeNamespace === null))) {
+                throw new Error("Attribute local name contains invalid characters (well-formed required).");
+            }
+            /**
+             * 3.9. Append the following strings to result, in the order listed:
+             * 3.9.1. The value of attr's localName;
+             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+             * 3.9.3. The result of serializing an attribute value given attr's value
+             * attribute and the require well-formed flag as input;
+             * 3.9.4. """ (U+0022 QUOTATION MARK).
+             */
+            result.push([attributeNamespace, candidatePrefix, attr.localName,
+                this._serializeAttributeValue(attr.value, requireWellFormed)]);
         }
         /**
          * 4. Return the value of result.
          */
         return result;
-    };
+    }
     /**
     * Produces an XML serialization of the attributes of an element node.
     *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
     */
-    BaseWriter.prototype._serializeAttributes = function (node, requireWellFormed) {
-        var e_9, _a;
+    _serializeAttributes(node, requireWellFormed) {
         /**
          * 1. Let result be the empty string.
          * 2. Let localname set be a new empty namespace localname set. This
@@ -1339,82 +1229,72 @@ var BaseWriter = /** @class */ (function () {
          * This can occur when two otherwise identical attributes on the same
          * element differ only by their prefix values.
          */
-        var result = [];
-        var localNameSet = requireWellFormed ? {} : undefined;
-        try {
-            /**
-             * 3. Loop: For each attribute attr in element's attributes, in the order
-             * they are specified in the element's attribute list:
-             */
-            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var attr = _c.value;
-                // Optimize common case
-                if (!requireWellFormed) {
-                    result.push([null, null, attr.localName,
-                        this._serializeAttributeValue(attr.value, requireWellFormed)]);
-                    continue;
-                }
-                /**
-                 * 3.1. If the require well-formed flag is set (its value is true), and the
-                 * localname set contains a tuple whose values match those of a new tuple
-                 * consisting of attr's namespaceURI attribute and localName attribute,
-                 * then throw an exception; the serialization of this attr would fail to
-                 * produce a well-formed element serialization.
-                 */
-                if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
-                    throw new Error("Element contains duplicate attributes (well-formed required).");
-                }
-                /**
-                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-                 * localName attribute, and add it to the localname set.
-                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-                 * 3.4. Let candidate prefix be null.
-                 */
-                /* istanbul ignore else */
-                if (requireWellFormed && localNameSet)
-                    localNameSet[attr.localName] = true;
-                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-                /**
-                 * 3.6. Append a " " (U+0020 SPACE) to result.
-                 * 3.7. If candidate prefix is not null, then append to result the
-                 * concatenation of candidate prefix with ":" (U+003A COLON).
-                 */
-                /**
-                 * 3.8. If the require well-formed flag is set (its value is true), and
-                 * this attr's localName attribute contains the character
-                 * ":" (U+003A COLON) or does not match the XML Name production or
-                 * equals "xmlns" and attribute namespace is null, then throw an
-                 * exception; the serialization of this attr would not be a
-                 * well-formed attribute.
-                 */
-                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                    !algorithm_1.xml_isName(attr.localName))) {
-                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
-                }
-                /**
-                 * 3.9. Append the following strings to result, in the order listed:
-                 * 3.9.1. The value of attr's localName;
-                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                 * 3.9.3. The result of serializing an attribute value given attr's value
-                 * attribute and the require well-formed flag as input;
-                 * 3.9.4. """ (U+0022 QUOTATION MARK).
-                 */
+        const result = [];
+        const localNameSet = requireWellFormed ? {} : undefined;
+        /**
+         * 3. Loop: For each attribute attr in element's attributes, in the order
+         * they are specified in the element's attribute list:
+         */
+        for (const attr of node.attributes) {
+            // Optimize common case
+            if (!requireWellFormed) {
                 result.push([null, null, attr.localName,
                     this._serializeAttributeValue(attr.value, requireWellFormed)]);
+                continue;
             }
-        }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            /**
+             * 3.1. If the require well-formed flag is set (its value is true), and the
+             * localname set contains a tuple whose values match those of a new tuple
+             * consisting of attr's namespaceURI attribute and localName attribute,
+             * then throw an exception; the serialization of this attr would fail to
+             * produce a well-formed element serialization.
+             */
+            if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
+                throw new Error("Element contains duplicate attributes (well-formed required).");
+            }
+            /**
+             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+             * localName attribute, and add it to the localname set.
+             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+             * 3.4. Let candidate prefix be null.
+             */
+            /* istanbul ignore else */
+            if (requireWellFormed && localNameSet)
+                localNameSet[attr.localName] = true;
+            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+            /**
+             * 3.6. Append a " " (U+0020 SPACE) to result.
+             * 3.7. If candidate prefix is not null, then append to result the
+             * concatenation of candidate prefix with ":" (U+003A COLON).
+             */
+            /**
+             * 3.8. If the require well-formed flag is set (its value is true), and
+             * this attr's localName attribute contains the character
+             * ":" (U+003A COLON) or does not match the XML Name production or
+             * equals "xmlns" and attribute namespace is null, then throw an
+             * exception; the serialization of this attr would not be a
+             * well-formed attribute.
+             */
+            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                !(0, algorithm_1.xml_isName)(attr.localName))) {
+                throw new Error("Attribute local name contains invalid characters (well-formed required).");
             }
-            finally { if (e_9) throw e_9.error; }
+            /**
+             * 3.9. Append the following strings to result, in the order listed:
+             * 3.9.1. The value of attr's localName;
+             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+             * 3.9.3. The result of serializing an attribute value given attr's value
+             * attribute and the require well-formed flag as input;
+             * 3.9.4. """ (U+0022 QUOTATION MARK).
+             */
+            result.push([null, null, attr.localName,
+                this._serializeAttributeValue(attr.value, requireWellFormed)]);
         }
         /**
          * 4. Return the value of result.
          */
         return result;
-    };
+    }
     /**
     * Records namespace information for the given element and returns the
     * default namespace attribute value.
@@ -1423,109 +1303,98 @@ var BaseWriter = /** @class */ (function () {
     * @param map - namespace prefix map
     * @param localPrefixesMap - local prefixes map
     */
-    BaseWriter.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) {
-        var e_10, _a;
+    _recordNamespaceInformation(node, map, localPrefixesMap) {
         /**
          * 1. Let default namespace attr value be null.
          */
-        var defaultNamespaceAttrValue = null;
-        try {
+        let defaultNamespaceAttrValue = null;
+        /**
+         * 2. Main: For each attribute attr in element's attributes, in the order
+         * they are specified in the element's attribute list:
+         */
+        for (const attr of node.attributes) {
             /**
-             * 2. Main: For each attribute attr in element's attributes, in the order
-             * they are specified in the element's attribute list:
+             * _Note:_ The following conditional steps find namespace prefixes. Only
+             * attributes in the XMLNS namespace are considered (e.g., attributes made
+             * to look like namespace declarations via
+             * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
+             * included).
              */
-            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var attr = _c.value;
+            /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
+            let attributeNamespace = attr.namespaceURI;
+            /** 2.2. Let attribute prefix be the value of attr's prefix. */
+            let attributePrefix = attr.prefix;
+            /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
+            if (attributeNamespace === infra_1.namespace.XMLNS) {
                 /**
-                 * _Note:_ The following conditional steps find namespace prefixes. Only
-                 * attributes in the XMLNS namespace are considered (e.g., attributes made
-                 * to look like namespace declarations via
-                 * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
-                 * included).
+                 * 2.3.1. If attribute prefix is null, then attr is a default namespace
+                 * declaration. Set the default namespace attr value to attr's value and
+                 * stop running these steps, returning to Main to visit the next
+                 * attribute.
                  */
-                /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
-                var attributeNamespace = attr.namespaceURI;
-                /** 2.2. Let attribute prefix be the value of attr's prefix. */
-                var attributePrefix = attr.prefix;
-                /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
-                if (attributeNamespace === infra_1.namespace.XMLNS) {
+                if (attributePrefix === null) {
+                    defaultNamespaceAttrValue = attr.value;
+                    continue;
                     /**
-                     * 2.3.1. If attribute prefix is null, then attr is a default namespace
-                     * declaration. Set the default namespace attr value to attr's value and
-                     * stop running these steps, returning to Main to visit the next
+                     * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
+                     * namespace prefix definition. Run the following steps:
+                     */
+                }
+                else {
+                    /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
+                    let prefixDefinition = attr.localName;
+                    /** 2.3.2.2. Let namespace definition be the value of attr's value. */
+                    let namespaceDefinition = attr.value;
+                    /**
+                     * 2.3.2.3. If namespace definition is the XML namespace, then stop
+                     * running these steps, and return to Main to visit the next
                      * attribute.
+                     *
+                     * _Note:_ XML namespace definitions in prefixes are completely
+                     * ignored (in order to avoid unnecessary work when there might be
+                     * prefix conflicts). XML namespaced elements are always handled
+                     * uniformly by prefixing (and overriding if necessary) the element's
+                     * localname with the reserved "xml" prefix.
                      */
-                    if (attributePrefix === null) {
-                        defaultNamespaceAttrValue = attr.value;
+                    if (namespaceDefinition === infra_1.namespace.XML) {
                         continue;
-                        /**
-                         * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
-                         * namespace prefix definition. Run the following steps:
-                         */
                     }
-                    else {
-                        /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
-                        var prefixDefinition = attr.localName;
-                        /** 2.3.2.2. Let namespace definition be the value of attr's value. */
-                        var namespaceDefinition = attr.value;
-                        /**
-                         * 2.3.2.3. If namespace definition is the XML namespace, then stop
-                         * running these steps, and return to Main to visit the next
-                         * attribute.
-                         *
-                         * _Note:_ XML namespace definitions in prefixes are completely
-                         * ignored (in order to avoid unnecessary work when there might be
-                         * prefix conflicts). XML namespaced elements are always handled
-                         * uniformly by prefixing (and overriding if necessary) the element's
-                         * localname with the reserved "xml" prefix.
-                         */
-                        if (namespaceDefinition === infra_1.namespace.XML) {
-                            continue;
-                        }
-                        /**
-                         * 2.3.2.4. If namespace definition is the empty string (the
-                         * declarative form of having no namespace), then let namespace
-                         * definition be null instead.
-                         */
-                        if (namespaceDefinition === '') {
-                            namespaceDefinition = null;
-                        }
-                        /**
-                         * 2.3.2.5. If prefix definition is found in map given the namespace
-                         * namespace definition, then stop running these steps, and return to
-                         * Main to visit the next attribute.
-                         *
-                         * _Note:_ This step avoids adding duplicate prefix definitions for
-                         * the same namespace in the map. This has the side-effect of avoiding
-                         * later serialization of duplicate namespace prefix declarations in
-                         * any descendant nodes.
-                         */
-                        if (map.has(prefixDefinition, namespaceDefinition)) {
-                            continue;
-                        }
-                        /**
-                         * 2.3.2.6. Add the prefix prefix definition to map given namespace
-                         * namespace definition.
-                         */
-                        map.set(prefixDefinition, namespaceDefinition);
-                        /**
-                         * 2.3.2.7. Add the value of prefix definition as a new key to the
-                         * local prefixes map, with the namespace definition as the key's
-                         * value replacing the value of null with the empty string if
-                         * applicable.
-                         */
-                        localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
+                    /**
+                     * 2.3.2.4. If namespace definition is the empty string (the
+                     * declarative form of having no namespace), then let namespace
+                     * definition be null instead.
+                     */
+                    if (namespaceDefinition === '') {
+                        namespaceDefinition = null;
+                    }
+                    /**
+                     * 2.3.2.5. If prefix definition is found in map given the namespace
+                     * namespace definition, then stop running these steps, and return to
+                     * Main to visit the next attribute.
+                     *
+                     * _Note:_ This step avoids adding duplicate prefix definitions for
+                     * the same namespace in the map. This has the side-effect of avoiding
+                     * later serialization of duplicate namespace prefix declarations in
+                     * any descendant nodes.
+                     */
+                    if (map.has(prefixDefinition, namespaceDefinition)) {
+                        continue;
                     }
+                    /**
+                     * 2.3.2.6. Add the prefix prefix definition to map given namespace
+                     * namespace definition.
+                     */
+                    map.set(prefixDefinition, namespaceDefinition);
+                    /**
+                     * 2.3.2.7. Add the value of prefix definition as a new key to the
+                     * local prefixes map, with the namespace definition as the key's
+                     * value replacing the value of null with the empty string if
+                     * applicable.
+                     */
+                    localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
                 }
             }
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_10) throw e_10.error; }
-        }
         /**
          * 3. Return the value of default namespace attr value.
          *
@@ -1533,7 +1402,7 @@ var BaseWriter = /** @class */ (function () {
          * converted to null.
          */
         return defaultNamespaceAttrValue;
-    };
+    }
     /**
     * Generates a new prefix for the given namespace.
     *
@@ -1541,7 +1410,7 @@ var BaseWriter = /** @class */ (function () {
     * @param prefixMap - namespace prefix map
     * @param prefixIndex - generated namespace prefix index
     */
-    BaseWriter.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) {
+    _generatePrefix(newNamespace, prefixMap, prefixIndex) {
         /**
          * 1. Let generated prefix be the concatenation of the string "ns" and the
          * current numerical value of prefix index.
@@ -1549,18 +1418,18 @@ var BaseWriter = /** @class */ (function () {
          * 3. Add to map the generated prefix given the new namespace namespace.
          * 4. Return the value of generated prefix.
          */
-        var generatedPrefix = "ns" + prefixIndex.value.toString();
+        const generatedPrefix = "ns" + prefixIndex.value.toString();
         prefixIndex.value++;
         prefixMap.set(generatedPrefix, newNamespace);
         return generatedPrefix;
-    };
+    }
     /**
      * Produces an XML serialization of an attribute value.
      *
      * @param value - attribute value
      * @param requireWellFormed - whether to check conformance
      */
-    BaseWriter.prototype._serializeAttributeValue = function (value, requireWellFormed) {
+    _serializeAttributeValue(value, requireWellFormed) {
         /**
          * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
          *
@@ -1569,7 +1438,7 @@ var BaseWriter = /** @class */ (function () {
          * production, then throw an exception; the serialization of this attribute
          * value would fail to produce a well-formed element serialization.
          */
-        if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) {
+        if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
             throw new Error("Invalid characters in attribute value.");
         }
         /**
@@ -1593,11 +1462,7 @@ var BaseWriter = /** @class */ (function () {
             .replace(/</g, '&lt;')
             .replace(/>/g, '&gt;')
             .replace(/"/g, '&quot;');
-    };
-    BaseWriter._VoidElementNames = new Set(['area', 'base', 'basefont',
-        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
-        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
-    return BaseWriter;
-}());
+    }
+}
 exports.BaseWriter = BaseWriter;
 //# sourceMappingURL=BaseWriter.js.map