@loaders.gl/xml 3.4.0-alpha.1 → 3.4.0-alpha.3

package/dist/dist.min.js

@@ -1740,13 +1740,14 @@ Actual: ${this.attribValue}`);
         cdataPropName: false,
         numberParseOptions: {
           hex: true,
-          leadingZeros: true
+          leadingZeros: true,
+          eNotation: true
         },
-        tagValueProcessor: function(tagName, val) {
-          return val;
+        tagValueProcessor: function(tagName, val2) {
+          return val2;
         },
-        attributeValueProcessor: function(attrName, val) {
-          return val;
+        attributeValueProcessor: function(attrName, val2) {
+          return val2;
         },
         stopNodes: [],
         alwaysCreateTextNode: false,
@@ -1757,7 +1758,11 @@ Actual: ${this.attribValue}`);
         htmlEntities: false,
         ignoreDeclaration: false,
         ignorePiTags: false,
-        transformTagName: false
+        transformTagName: false,
+        transformAttributeName: false,
+        updateTag: function(tagName, jPath, attrs) {
+          return tagName;
+        }
       };
       var buildOptions = function(options) {
         return Object.assign({}, defaultOptions, options);
@@ -1777,10 +1782,14 @@ Actual: ${this.attribValue}`);
           this.child = [];
           this[":@"] = {};
         }
-        add(key, val) {
-          this.child.push({ [key]: val });
+        add(key, val2) {
+          if (key === "__proto__")
+            key = "#__proto__";
+          this.child.push({ [key]: val2 });
         }
         addChild(node) {
+          if (node.tagname === "__proto__")
+            node.tagname = "#__proto__";
           if (node[":@"] && Object.keys(node[":@"]).length > 0) {
             this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
           } else {
@@ -1800,38 +1809,39 @@ Actual: ${this.attribValue}`);
         if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
           i = i + 9;
           let angleBracketsCount = 1;
-          let hasBody = false, entity = false, comment = false;
+          let hasBody = false, comment = false;
           let exp = "";
           for (; i < xmlData.length; i++) {
-            if (xmlData[i] === "<") {
-              if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y") {
+            if (xmlData[i] === "<" && !comment) {
+              if (hasBody && isEntity(xmlData, i)) {
                 i += 7;
-                entity = true;
-              } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T") {
+                [entityName, val, i] = readEntityExp(xmlData, i + 1);
+                if (val.indexOf("&") === -1)
+                  entities[entityName] = {
+                    regx: RegExp(`&${entityName};`, "g"),
+                    val
+                  };
+              } else if (hasBody && isElement(xmlData, i))
                 i += 8;
-              } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T") {
+              else if (hasBody && isAttlist(xmlData, i))
                 i += 8;
-              } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N") {
+              else if (hasBody && isNotation(xmlData, i))
                 i += 9;
-              } else if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-") {
+              else if (isComment)
                 comment = true;
-              } else {
+              else
                 throw new Error("Invalid DOCTYPE");
-              }
               angleBracketsCount++;
               exp = "";
             } else if (xmlData[i] === ">") {
               if (comment) {
                 if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
                   comment = false;
-                } else {
-                  throw new Error(`Invalid XML comment in DOCTYPE`);
+                  angleBracketsCount--;
                 }
-              } else if (entity) {
-                parseEntityExp(exp, entities);
-                entity = false;
+              } else {
+                angleBracketsCount--;
               }
-              angleBracketsCount--;
               if (angleBracketsCount === 0) {
                 break;
               }
@@ -1849,15 +1859,45 @@ Actual: ${this.attribValue}`);
         }
         return { entities, i };
       }
-      var entityRegex = RegExp(`^\\s([a-zA-z0-0]+)[ 	](['"])([^&]+)\\2`);
-      function parseEntityExp(exp, entities) {
-        const match = entityRegex.exec(exp);
-        if (match) {
-          entities[match[1]] = {
-            regx: RegExp(`&${match[1]};`, "g"),
-            val: match[3]
-          };
-        }
+      function readEntityExp(xmlData, i) {
+        let entityName2 = "";
+        for (; i < xmlData.length && (xmlData[i] !== "'" && xmlData[i] !== '"'); i++) {
+          entityName2 += xmlData[i];
+        }
+        entityName2 = entityName2.trim();
+        if (entityName2.indexOf(" ") !== -1)
+          throw new Error("External entites are not supported");
+        const startChar = xmlData[i++];
+        let val2 = "";
+        for (; i < xmlData.length && xmlData[i] !== startChar; i++) {
+          val2 += xmlData[i];
+        }
+        return [entityName2, val2, i];
+      }
+      function isComment(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-")
+          return true;
+        return false;
+      }
+      function isEntity(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y")
+          return true;
+        return false;
+      }
+      function isElement(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T")
+          return true;
+        return false;
+      }
+      function isAttlist(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T")
+          return true;
+        return false;
+      }
+      function isNotation(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N")
+          return true;
+        return false;
       }
       module.exports = readDocType;
     }
@@ -2000,6 +2040,7 @@ Actual: ${this.attribValue}`);
           this.replaceEntitiesValue = replaceEntitiesValue;
           this.readStopNodeData = readStopNodeData;
           this.saveTextToParentTag = saveTextToParentTag;
+          this.addChild = addChild;
         }
       };
       function addExternalEntities(externalEntities) {
@@ -2012,27 +2053,27 @@ Actual: ${this.attribValue}`);
           };
         }
       }
-      function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
-        if (val !== void 0) {
+      function parseTextData(val2, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+        if (val2 !== void 0) {
           if (this.options.trimValues && !dontTrim) {
-            val = val.trim();
+            val2 = val2.trim();
           }
-          if (val.length > 0) {
+          if (val2.length > 0) {
             if (!escapeEntities)
-              val = this.replaceEntitiesValue(val);
-            const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+              val2 = this.replaceEntitiesValue(val2);
+            const newval = this.options.tagValueProcessor(tagName, val2, jPath, hasAttributes, isLeafNode);
             if (newval === null || newval === void 0) {
-              return val;
-            } else if (typeof newval !== typeof val || newval !== val) {
+              return val2;
+            } else if (typeof newval !== typeof val2 || newval !== val2) {
               return newval;
             } else if (this.options.trimValues) {
-              return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+              return parseValue(val2, this.options.parseTagValue, this.options.numberParseOptions);
             } else {
-              const trimmedVal = val.trim();
-              if (trimmedVal === val) {
-                return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+              const trimmedVal = val2.trim();
+              if (trimmedVal === val2) {
+                return parseValue(val2, this.options.parseTagValue, this.options.numberParseOptions);
               } else {
-                return val;
+                return val2;
               }
             }
           }
@@ -2052,7 +2093,7 @@ Actual: ${this.attribValue}`);
         return tagname;
       }
       var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
-      function buildAttributesMap(attrStr, jPath) {
+      function buildAttributesMap(attrStr, jPath, tagName) {
         if (!this.options.ignoreAttributes && typeof attrStr === "string") {
           const matches = util.getAllMatches(attrStr, attrsRegx);
           const len = matches.length;
@@ -2060,8 +2101,13 @@ Actual: ${this.attribValue}`);
           for (let i = 0; i < len; i++) {
             const attrName = this.resolveNameSpace(matches[i][1]);
             let oldVal = matches[i][4];
-            const aName = this.options.attributeNamePrefix + attrName;
+            let aName = this.options.attributeNamePrefix + attrName;
             if (attrName.length) {
+              if (this.options.transformAttributeName) {
+                aName = this.options.transformAttributeName(aName);
+              }
+              if (aName === "__proto__")
+                aName = "#__proto__";
               if (oldVal !== void 0) {
                 if (this.options.trimValues) {
                   oldVal = oldVal.trim();
@@ -2115,7 +2161,18 @@ Actual: ${this.attribValue}`);
               if (currentNode) {
                 textData = this.saveTextToParentTag(textData, currentNode, jPath);
               }
-              jPath = jPath.substr(0, jPath.lastIndexOf("."));
+              const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+              if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+                throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
+              }
+              let propIndex = 0;
+              if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
+                propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
+                this.tagsNodeStack.pop();
+              } else {
+                propIndex = jPath.lastIndexOf(".");
+              }
+              jPath = jPath.substring(0, propIndex);
               currentNode = this.tagsNodeStack.pop();
               textData = "";
               i = closeIndex;
@@ -2129,9 +2186,9 @@ Actual: ${this.attribValue}`);
                 const childNode = new xmlNode(tagData.tagName);
                 childNode.add(this.options.textNodeName, "");
                 if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath);
+                  childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
                 }
-                currentNode.addChild(childNode);
+                this.addChild(currentNode, childNode, jPath);
               }
               i = tagData.closeIndex + 1;
             } else if (xmlData.substr(i + 1, 3) === "!--") {
@@ -2153,10 +2210,10 @@ Actual: ${this.attribValue}`);
               if (this.options.cdataPropName) {
                 currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
               } else {
-                let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
-                if (val == void 0)
-                  val = "";
-                currentNode.add(this.options.textNodeName, val);
+                let val2 = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
+                if (val2 == void 0)
+                  val2 = "";
+                currentNode.add(this.options.textNodeName, val2);
               }
               i = closeIndex + 2;
             } else {
@@ -2173,12 +2230,13 @@ Actual: ${this.attribValue}`);
                   textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
                 }
               }
-              if (tagName !== xmlObj.tagname) {
-                jPath += jPath ? "." + tagName : tagName;
-              }
               const lastTag = currentNode;
               if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
                 currentNode = this.tagsNodeStack.pop();
+                jPath = jPath.substring(0, jPath.lastIndexOf("."));
+              }
+              if (tagName !== xmlObj.tagname) {
+                jPath += jPath ? "." + tagName : tagName;
               }
               if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
                 let tagContent = "";
@@ -2195,14 +2253,14 @@ Actual: ${this.attribValue}`);
                 }
                 const childNode = new xmlNode(tagName);
                 if (tagName !== tagExp && attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                 }
                 if (tagContent) {
                   tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
                 }
                 jPath = jPath.substr(0, jPath.lastIndexOf("."));
                 childNode.add(this.options.textNodeName, tagContent);
-                currentNode.addChild(childNode);
+                this.addChild(currentNode, childNode, jPath);
               } else {
                 if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                   if (tagName[tagName.length - 1] === "/") {
@@ -2216,17 +2274,17 @@ Actual: ${this.attribValue}`);
                   }
                   const childNode = new xmlNode(tagName);
                   if (tagName !== tagExp && attrExpPresent) {
-                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                   }
+                  this.addChild(currentNode, childNode, jPath);
                   jPath = jPath.substr(0, jPath.lastIndexOf("."));
-                  currentNode.addChild(childNode);
                 } else {
                   const childNode = new xmlNode(tagName);
                   this.tagsNodeStack.push(currentNode);
                   if (tagName !== tagExp && attrExpPresent) {
-                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                   }
-                  currentNode.addChild(childNode);
+                  this.addChild(currentNode, childNode, jPath);
                   currentNode = childNode;
                 }
                 textData = "";
@@ -2239,25 +2297,35 @@ Actual: ${this.attribValue}`);
         }
         return xmlObj.child;
       };
-      var replaceEntitiesValue = function(val) {
+      function addChild(currentNode, childNode, jPath) {
+        const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+        if (result === false) {
+        } else if (typeof result === "string") {
+          childNode.tagname = result;
+          currentNode.addChild(childNode);
+        } else {
+          currentNode.addChild(childNode);
+        }
+      }
+      var replaceEntitiesValue = function(val2) {
         if (this.options.processEntities) {
-          for (let entityName in this.docTypeEntities) {
-            const entity = this.docTypeEntities[entityName];
-            val = val.replace(entity.regx, entity.val);
+          for (let entityName2 in this.docTypeEntities) {
+            const entity = this.docTypeEntities[entityName2];
+            val2 = val2.replace(entity.regx, entity.val);
           }
-          for (let entityName in this.lastEntities) {
-            const entity = this.lastEntities[entityName];
-            val = val.replace(entity.regex, entity.val);
+          for (let entityName2 in this.lastEntities) {
+            const entity = this.lastEntities[entityName2];
+            val2 = val2.replace(entity.regex, entity.val);
           }
           if (this.options.htmlEntities) {
-            for (let entityName in this.htmlEntities) {
-              const entity = this.htmlEntities[entityName];
-              val = val.replace(entity.regex, entity.val);
+            for (let entityName2 in this.htmlEntities) {
+              const entity = this.htmlEntities[entityName2];
+              val2 = val2.replace(entity.regex, entity.val);
             }
           }
-          val = val.replace(this.ampEntity.regex, this.ampEntity.val);
+          val2 = val2.replace(this.ampEntity.regex, this.ampEntity.val);
         }
-        return val;
+        return val2;
       };
       function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
         if (textData) {
@@ -2384,18 +2452,18 @@ Actual: ${this.attribValue}`);
           }
         }
       }
-      function parseValue(val, shouldParse, options) {
-        if (shouldParse && typeof val === "string") {
-          const newval = val.trim();
+      function parseValue(val2, shouldParse, options) {
+        if (shouldParse && typeof val2 === "string") {
+          const newval = val2.trim();
           if (newval === "true")
             return true;
           else if (newval === "false")
             return false;
           else
-            return toNumber(val, options);
+            return toNumber(val2, options);
         } else {
-          if (util.isExist(val)) {
-            return val;
+          if (util.isExist(val2)) {
+            return val2;
           } else {
             return "";
           }
@@ -2431,28 +2499,28 @@ Actual: ${this.attribValue}`);
           } else if (property === void 0) {
             continue;
           } else if (tagObj[property]) {
-            let val = compress(tagObj[property], options, newJpath);
-            const isLeaf = isLeafTag(val, options);
+            let val2 = compress(tagObj[property], options, newJpath);
+            const isLeaf = isLeafTag(val2, options);
             if (tagObj[":@"]) {
-              assignAttributes(val, tagObj[":@"], newJpath, options);
-            } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
-              val = val[options.textNodeName];
-            } else if (Object.keys(val).length === 0) {
+              assignAttributes(val2, tagObj[":@"], newJpath, options);
+            } else if (Object.keys(val2).length === 1 && val2[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
+              val2 = val2[options.textNodeName];
+            } else if (Object.keys(val2).length === 0) {
               if (options.alwaysCreateTextNode)
-                val[options.textNodeName] = "";
+                val2[options.textNodeName] = "";
               else
-                val = "";
+                val2 = "";
             }
             if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
               if (!Array.isArray(compressedObj[property])) {
                 compressedObj[property] = [compressedObj[property]];
               }
-              compressedObj[property].push(val);
+              compressedObj[property].push(val2);
             } else {
               if (options.isArray(property, newJpath, isLeaf)) {
-                compressedObj[property] = [val];
+                compressedObj[property] = [val2];
               } else {
-                compressedObj[property] = val;
+                compressedObj[property] = val2;
               }
             }
           }
@@ -2487,9 +2555,14 @@ Actual: ${this.attribValue}`);
         }
       }
       function isLeafTag(obj, options) {
+        const { textNodeName } = options;
         const propCount = Object.keys(obj).length;
-        if (propCount === 0 || propCount === 1 && obj[options.textNodeName])
+        if (propCount === 0) {
+          return true;
+        }
+        if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
           return true;
+        }
         return false;
       }
       exports.prettify = prettify;
@@ -2552,14 +2625,15 @@ Actual: ${this.attribValue}`);
     "node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js"(exports, module) {
       var EOL = "\n";
       function toXml(jArray, options) {
-        return arrToStr(jArray, options, "", 0);
-      }
-      function arrToStr(arr, options, jPath, level) {
-        let xmlStr = "";
         let indentation = "";
         if (options.format && options.indentBy.length > 0) {
-          indentation = EOL + "" + options.indentBy.repeat(level);
+          indentation = EOL;
         }
+        return arrToStr(jArray, options, "", indentation);
+      }
+      function arrToStr(arr, options, jPath, indentation) {
+        let xmlStr = "";
+        let isPreviousElementTag = false;
         for (let i = 0; i < arr.length; i++) {
           const tagObj = arr[i];
           const tagName = propName(tagObj);
@@ -2574,13 +2648,22 @@ Actual: ${this.attribValue}`);
               tagText = options.tagValueProcessor(tagName, tagText);
               tagText = replaceEntitiesValue(tagText, options);
             }
-            xmlStr += indentation + tagText;
+            if (isPreviousElementTag) {
+              xmlStr += indentation;
+            }
+            xmlStr += tagText;
+            isPreviousElementTag = false;
             continue;
           } else if (tagName === options.cdataPropName) {
-            xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
+            if (isPreviousElementTag) {
+              xmlStr += indentation;
+            }
+            xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
+            isPreviousElementTag = false;
             continue;
           } else if (tagName === options.commentPropName) {
             xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
+            isPreviousElementTag = true;
             continue;
           } else if (tagName[0] === "?") {
             const attStr2 = attr_to_str(tagObj[":@"], options);
@@ -2588,11 +2671,16 @@ Actual: ${this.attribValue}`);
             let piTextNodeName = tagObj[tagName][0][options.textNodeName];
             piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
             xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr2}?>`;
+            isPreviousElementTag = true;
             continue;
           }
+          let newIdentation = indentation;
+          if (newIdentation !== "") {
+            newIdentation += options.indentBy;
+          }
           const attStr = attr_to_str(tagObj[":@"], options);
-          let tagStart = indentation + `<${tagName}${attStr}`;
-          let tagValue = arrToStr(tagObj[tagName], options, newJPath, level + 1);
+          const tagStart = indentation + `<${tagName}${attStr}`;
+          const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
           if (options.unpairedTags.indexOf(tagName) !== -1) {
             if (options.suppressUnpairedNode)
               xmlStr += tagStart + ">";
@@ -2600,9 +2688,18 @@ Actual: ${this.attribValue}`);
               xmlStr += tagStart + "/>";
           } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
             xmlStr += tagStart + "/>";
-          } else {
+          } else if (tagValue && tagValue.endsWith(">")) {
             xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
+          } else {
+            xmlStr += tagStart + ">";
+            if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) {
+              xmlStr += indentation + options.indentBy + tagValue + indentation;
+            } else {
+              xmlStr += tagValue;
+            }
+            xmlStr += `</${tagName}>`;
           }
+          isPreviousElementTag = true;
         }
         return xmlStr;
       }
@@ -2685,7 +2782,7 @@ Actual: ${this.attribValue}`);
         ],
         processEntities: true,
         stopNodes: [],
-        transformTagName: false
+        oneListGroup: false
       };
       function Builder(options) {
         this.options = Object.assign({}, defaultOptions, options);
@@ -2709,17 +2806,6 @@ Actual: ${this.attribValue}`);
           this.tagEndChar = ">";
           this.newLine = "";
         }
-        if (this.options.suppressEmptyNode) {
-          this.buildTextNode = buildEmptyTextNode;
-          this.buildObjNode = buildEmptyObjNode;
-        } else {
-          this.buildTextNode = buildTextValNode;
-          this.buildObjNode = buildObjectNode;
-        }
-        this.buildTextValNode = buildTextValNode;
-        this.buildObjectNode = buildObjectNode;
-        this.replaceEntitiesValue = replaceEntitiesValue;
-        this.buildAttrPairStr = buildAttrPairStr;
       }
       Builder.prototype.build = function(jObj) {
         if (this.options.preserveOrder) {
@@ -2735,16 +2821,16 @@ Actual: ${this.attribValue}`);
       };
       Builder.prototype.j2x = function(jObj, level) {
         let attrStr = "";
-        let val = "";
+        let val2 = "";
         for (let key in jObj) {
           if (typeof jObj[key] === "undefined") {
           } else if (jObj[key] === null) {
             if (key[0] === "?")
-              val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
+              val2 += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
             else
-              val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
+              val2 += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
           } else if (jObj[key] instanceof Date) {
-            val += this.buildTextNode(jObj[key], key, "", level);
+            val2 += this.buildTextValNode(jObj[key], key, "", level);
           } else if (typeof jObj[key] !== "object") {
             const attr = this.isAttribute(key);
             if (attr) {
@@ -2752,27 +2838,36 @@ Actual: ${this.attribValue}`);
             } else {
               if (key === this.options.textNodeName) {
                 let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
-                val += this.replaceEntitiesValue(newval);
+                val2 += this.replaceEntitiesValue(newval);
               } else {
-                val += this.buildTextNode(jObj[key], key, "", level);
+                val2 += this.buildTextValNode(jObj[key], key, "", level);
               }
             }
           } else if (Array.isArray(jObj[key])) {
             const arrLen = jObj[key].length;
+            let listTagVal = "";
             for (let j = 0; j < arrLen; j++) {
               const item = jObj[key][j];
               if (typeof item === "undefined") {
               } else if (item === null) {
                 if (key[0] === "?")
-                  val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
+                  val2 += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
                 else
-                  val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
+                  val2 += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
               } else if (typeof item === "object") {
-                val += this.processTextOrObjNode(item, key, level);
+                if (this.options.oneListGroup) {
+                  listTagVal += this.j2x(item, level + 1).val;
+                } else {
+                  listTagVal += this.processTextOrObjNode(item, key, level);
+                }
               } else {
-                val += this.buildTextNode(item, key, "", level);
+                listTagVal += this.buildTextValNode(item, key, "", level);
               }
             }
+            if (this.options.oneListGroup) {
+              listTagVal = this.buildObjectNode(listTagVal, key, "", level);
+            }
+            val2 += listTagVal;
           } else {
             if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
               const Ks = Object.keys(jObj[key]);
@@ -2781,73 +2876,81 @@ Actual: ${this.attribValue}`);
                 attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
               }
             } else {
-              val += this.processTextOrObjNode(jObj[key], key, level);
+              val2 += this.processTextOrObjNode(jObj[key], key, level);
             }
           }
         }
-        return { attrStr, val };
+        return { attrStr, val: val2 };
       };
-      function buildAttrPairStr(attrName, val) {
-        val = this.options.attributeValueProcessor(attrName, "" + val);
-        val = this.replaceEntitiesValue(val);
-        if (this.options.suppressBooleanAttributes && val === "true") {
+      Builder.prototype.buildAttrPairStr = function(attrName, val2) {
+        val2 = this.options.attributeValueProcessor(attrName, "" + val2);
+        val2 = this.replaceEntitiesValue(val2);
+        if (this.options.suppressBooleanAttributes && val2 === "true") {
           return " " + attrName;
         } else
-          return " " + attrName + '="' + val + '"';
-      }
+          return " " + attrName + '="' + val2 + '"';
+      };
       function processTextOrObjNode(object, key, level) {
         const result = this.j2x(object, level + 1);
         if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) {
-          return this.buildTextNode(object[this.options.textNodeName], key, result.attrStr, level);
+          return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
         } else {
-          return this.buildObjNode(result.val, key, result.attrStr, level);
+          return this.buildObjectNode(result.val, key, result.attrStr, level);
         }
       }
-      function buildObjectNode(val, key, attrStr, level) {
-        let tagEndExp = "</" + key + this.tagEndChar;
-        let piClosingChar = "";
-        if (key[0] === "?") {
-          piClosingChar = "?";
-          tagEndExp = "";
-        }
-        if (attrStr && val.indexOf("<") === -1) {
-          return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
-        } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
-          return this.indentate(level) + `<!--${val}-->` + this.newLine;
+      Builder.prototype.buildObjectNode = function(val2, key, attrStr, level) {
+        if (val2 === "") {
+          if (key[0] === "?")
+            return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+          else {
+            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
+          }
         } else {
-          return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
+          let tagEndExp = "</" + key + this.tagEndChar;
+          let piClosingChar = "";
+          if (key[0] === "?") {
+            piClosingChar = "?";
+            tagEndExp = "";
+          }
+          if (attrStr && val2.indexOf("<") === -1) {
+            return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val2 + tagEndExp;
+          } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
+            return this.indentate(level) + `<!--${val2}-->` + this.newLine;
+          } else {
+            return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val2 + this.indentate(level) + tagEndExp;
+          }
         }
-      }
-      function buildEmptyObjNode(val, key, attrStr, level) {
-        if (val !== "") {
-          return this.buildObjectNode(val, key, attrStr, level);
+      };
+      Builder.prototype.closeTag = function(key) {
+        let closeTag = "";
+        if (this.options.unpairedTags.indexOf(key) !== -1) {
+          if (!this.options.suppressUnpairedNode)
+            closeTag = "/";
+        } else if (this.options.suppressEmptyNode) {
+          closeTag = "/";
         } else {
-          if (key[0] === "?")
-            return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-          else
-            return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar;
+          closeTag = `></${key}`;
         }
-      }
-      function buildTextValNode(val, key, attrStr, level) {
+        return closeTag;
+      };
+      Builder.prototype.buildTextValNode = function(val2, key, attrStr, level) {
         if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
-          return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
+          return this.indentate(level) + `<![CDATA[${val2}]]>` + this.newLine;
         } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
-          return this.indentate(level) + `<!--${val}-->` + this.newLine;
+          return this.indentate(level) + `<!--${val2}-->` + this.newLine;
+        } else if (key[0] === "?") {
+          return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
         } else {
-          let textValue = this.options.tagValueProcessor(key, val);
+          let textValue = this.options.tagValueProcessor(key, val2);
           textValue = this.replaceEntitiesValue(textValue);
-          if (textValue === "" && this.options.unpairedTags.indexOf(key) !== -1) {
-            if (this.options.suppressUnpairedNode) {
-              return this.indentate(level) + "<" + key + this.tagEndChar;
-            } else {
-              return this.indentate(level) + "<" + key + "/" + this.tagEndChar;
-            }
+          if (textValue === "") {
+            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
           } else {
             return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
           }
         }
-      }
-      function replaceEntitiesValue(textValue) {
+      };
+      Builder.prototype.replaceEntitiesValue = function(textValue) {
         if (textValue && textValue.length > 0 && this.options.processEntities) {
           for (let i = 0; i < this.options.entities.length; i++) {
             const entity = this.options.entities[i];
@@ -2855,23 +2958,7 @@ Actual: ${this.attribValue}`);
           }
         }
         return textValue;
-      }
-      function buildEmptyTextNode(val, key, attrStr, level) {
-        if (val === "" && this.options.unpairedTags.indexOf(key) !== -1) {
-          if (this.options.suppressUnpairedNode) {
-            return this.indentate(level) + "<" + key + this.tagEndChar;
-          } else {
-            return this.indentate(level) + "<" + key + "/" + this.tagEndChar;
-          }
-        } else if (val !== "") {
-          return this.buildTextValNode(val, key, attrStr, level);
-        } else {
-          if (key[0] === "?")
-            return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-          else
-            return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar;
-        }
-      }
+      };
       function indentate(level) {
         return this.options.indentBy.repeat(level);
       }
@@ -2901,31 +2988,75 @@ Actual: ${this.attribValue}`);
     }
   });
 
-  // src/lib/parse-xml.ts
-  function parseXML(text, options) {
+  // src/lib/parsers/parse-xml.ts
+  function fastParseXML(text, options) {
     const parser = new import_fast_xml_parser.XMLParser({
       ignoreAttributes: false,
       attributeNamePrefix: "",
-      ...options?.xml
+      ...options
     });
     const parsedXML = parser.parse(text);
     return parsedXML;
   }
   var import_fast_xml_parser;
   var init_parse_xml = __esm({
-    "src/lib/parse-xml.ts"() {
+    "src/lib/parsers/parse-xml.ts"() {
       import_fast_xml_parser = __toModule(require_fxp());
     }
   });
 
+  // src/lib/xml-utils/uncapitalize.ts
+  function uncapitalize(str) {
+    return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+  }
+  function uncapitalizeKeys(object) {
+    if (Array.isArray(object)) {
+      return object.map((element) => uncapitalizeKeys(element));
+    }
+    if (object && typeof object === "object") {
+      const newObject = {};
+      for (const [key, value] of Object.entries(object)) {
+        newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+      }
+      return newObject;
+    }
+    return object;
+  }
+  var init_uncapitalize = __esm({
+    "src/lib/xml-utils/uncapitalize.ts"() {
+    }
+  });
+
   // src/xml-loader.ts
   function testXMLFile(text) {
     return text.startsWith("<?xml");
   }
+  function parseTextSync(text, options) {
+    const xmlOptions = { ...XMLLoader.options.xml, ...options?.xml };
+    switch (xmlOptions.parser) {
+      case "fast-xml-parser":
+        const fastXMLOptions = {
+          allowBooleanAttributes: true,
+          ignoreDeclaration: true,
+          removeNSPrefix: xmlOptions.removeNSPrefix,
+          textNodeName: xmlOptions.textNodeName,
+          isArray: (name, jpath, isLeafNode, isAttribute) => {
+            const array = Boolean(xmlOptions?.arrayPaths?.some((path) => jpath === path));
+            return array;
+          },
+          ...options?._fastXML
+        };
+        const xml = fastParseXML(text, fastXMLOptions);
+        return xmlOptions.uncapitalizeKeys ? uncapitalizeKeys(xml) : xml;
+      default:
+        throw new Error(options?.xml?.parser);
+    }
+  }
   var VERSION, XMLLoader;
   var init_xml_loader = __esm({
     "src/xml-loader.ts"() {
       init_parse_xml();
+      init_uncapitalize();
       VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       XMLLoader = {
         name: "XML",
@@ -2937,31 +3068,123 @@ Actual: ${this.attribValue}`);
         mimeTypes: ["application/xml", "text/xml"],
         testText: testXMLFile,
         options: {
-          xml: {}
+          xml: {
+            parser: "fast-xml-parser",
+            uncapitalizeKeys: false,
+            removeNSPrefix: false,
+            textNodeName: "value",
+            arrayPaths: []
+          }
         },
-        parse: async (arrayBuffer, options) => parseXML(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: (text, options) => parseXML(text, options)
+        parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseTextSync(text, options)
       };
     }
   });
 
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    const options = { ...baseOptions };
+    for (const [key, newValue] of Object.entries(newOptions)) {
+      if (newValue && typeof newValue === "object") {
+        options[key] = options[key] || {};
+        Object.assign(options[key], newOptions[key]);
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+  var init_merge_loader_options = __esm({
+    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/index.ts
+  var init_src = __esm({
+    "../loader-utils/src/index.ts"() {
+      init_merge_loader_options();
+    }
+  });
+
+  // src/html-loader.ts
+  function testHTMLFile(text) {
+    return text.startsWith("<html");
+  }
+  function parseTextSync2(text, options) {
+    options = mergeLoaderOptions(options, {
+      xml: {
+        parser: "fast-xml-parser"
+      },
+      _fastXML: {
+        htmlEntities: true
+      }
+    });
+    return XMLLoader.parseTextSync(text, options);
+  }
+  var HTMLLoader;
+  var init_html_loader = __esm({
+    "src/html-loader.ts"() {
+      init_src();
+      init_xml_loader();
+      HTMLLoader = {
+        ...XMLLoader,
+        name: "HTML",
+        id: "html",
+        extensions: ["html", "htm"],
+        mimeTypes: ["text/html"],
+        testText: testHTMLFile,
+        parse: async (arrayBuffer, options) => parseTextSync2(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseTextSync2(text, options)
+      };
+    }
+  });
+
+  // src/lib/xml-utils/xml-utils.ts
+  function convertXMLValueToArray(xmlValue) {
+    if (Array.isArray(xmlValue)) {
+      return xmlValue;
+    }
+    if (xmlValue && typeof xmlValue === "object" && xmlValue["0"]) {
+    }
+    if (xmlValue) {
+      return [xmlValue];
+    }
+    return [];
+  }
+  function convertXMLFieldToArrayInPlace(xml, key) {
+    xml[key] = convertXMLValueToArray(xml[key]);
+  }
+  var init_xml_utils = __esm({
+    "src/lib/xml-utils/xml-utils.ts"() {
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    HTMLLoader: () => HTMLLoader,
     SAXParser: () => SAXParser,
-    XMLLoader: () => XMLLoader
+    XMLLoader: () => XMLLoader,
+    _uncapitalize: () => uncapitalize,
+    _uncapitalizeKeys: () => uncapitalizeKeys,
+    convertXMLFieldToArrayInPlace: () => convertXMLFieldToArrayInPlace,
+    convertXMLValueToArray: () => convertXMLValueToArray
   });
-  var init_src = __esm({
+  var init_src2 = __esm({
     "src/index.ts"() {
       init_xml_loader();
+      init_html_loader();
       init_sax();
+      init_xml_utils();
+      init_uncapitalize();
     }
   });
 
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src(), src_exports);
+      var moduleExports = (init_src2(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }