@stacksjs/ts-cloud 0.1.14 → 0.2.0

package/dist/index.js

@@ -1057,6 +1057,14 @@ function normalizeProcessEntities(value) {
 var defaultOptions2, buildOptions = function(options) {
   const built = Object.assign({}, defaultOptions2, options);
   built.processEntities = normalizeProcessEntities(built.processEntities);
+  if (built.stopNodes && Array.isArray(built.stopNodes)) {
+    built.stopNodes = built.stopNodes.map((node) => {
+      if (typeof node === "string" && node.startsWith("*.")) {
+        return ".." + node.substring(2);
+      }
+      return node;
+    });
+  }
   return built;
 };
 var init_OptionsBuilder = __esm(() => {
@@ -1099,7 +1107,8 @@ var init_OptionsBuilder = __esm(() => {
     },
     captureMetaData: false,
     maxNestedTags: 100,
-    strictReservedNames: true
+    strictReservedNames: true,
+    jPath: true
   };
 });
 
@@ -1571,7 +1580,382 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 
+// ../../node_modules/path-expression-matcher/src/Expression.js
+class Expression {
+  constructor(pattern, options = {}) {
+    this.pattern = pattern;
+    this.separator = options.separator || ".";
+    this.segments = this._parse(pattern);
+    this._hasDeepWildcard = this.segments.some((seg) => seg.type === "deep-wildcard");
+    this._hasAttributeCondition = this.segments.some((seg) => seg.attrName !== undefined);
+    this._hasPositionSelector = this.segments.some((seg) => seg.position !== undefined);
+  }
+  _parse(pattern) {
+    const segments = [];
+    let i = 0;
+    let currentPart = "";
+    while (i < pattern.length) {
+      if (pattern[i] === this.separator) {
+        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {
+          if (currentPart.trim()) {
+            segments.push(this._parseSegment(currentPart.trim()));
+            currentPart = "";
+          }
+          segments.push({ type: "deep-wildcard" });
+          i += 2;
+        } else {
+          if (currentPart.trim()) {
+            segments.push(this._parseSegment(currentPart.trim()));
+          }
+          currentPart = "";
+          i++;
+        }
+      } else {
+        currentPart += pattern[i];
+        i++;
+      }
+    }
+    if (currentPart.trim()) {
+      segments.push(this._parseSegment(currentPart.trim()));
+    }
+    return segments;
+  }
+  _parseSegment(part) {
+    const segment = { type: "tag" };
+    let bracketContent = null;
+    let withoutBrackets = part;
+    const bracketMatch = part.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);
+    if (bracketMatch) {
+      withoutBrackets = bracketMatch[1] + bracketMatch[3];
+      if (bracketMatch[2]) {
+        const content = bracketMatch[2].slice(1, -1);
+        if (content) {
+          bracketContent = content;
+        }
+      }
+    }
+    let namespace = undefined;
+    let tagAndPosition = withoutBrackets;
+    if (withoutBrackets.includes("::")) {
+      const nsIndex = withoutBrackets.indexOf("::");
+      namespace = withoutBrackets.substring(0, nsIndex).trim();
+      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim();
+      if (!namespace) {
+        throw new Error(`Invalid namespace in pattern: ${part}`);
+      }
+    }
+    let tag = undefined;
+    let positionMatch = null;
+    if (tagAndPosition.includes(":")) {
+      const colonIndex = tagAndPosition.lastIndexOf(":");
+      const tagPart = tagAndPosition.substring(0, colonIndex).trim();
+      const posPart = tagAndPosition.substring(colonIndex + 1).trim();
+      const isPositionKeyword = ["first", "last", "odd", "even"].includes(posPart) || /^nth\(\d+\)$/.test(posPart);
+      if (isPositionKeyword) {
+        tag = tagPart;
+        positionMatch = posPart;
+      } else {
+        tag = tagAndPosition;
+      }
+    } else {
+      tag = tagAndPosition;
+    }
+    if (!tag) {
+      throw new Error(`Invalid segment pattern: ${part}`);
+    }
+    segment.tag = tag;
+    if (namespace) {
+      segment.namespace = namespace;
+    }
+    if (bracketContent) {
+      if (bracketContent.includes("=")) {
+        const eqIndex = bracketContent.indexOf("=");
+        segment.attrName = bracketContent.substring(0, eqIndex).trim();
+        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();
+      } else {
+        segment.attrName = bracketContent.trim();
+      }
+    }
+    if (positionMatch) {
+      const nthMatch = positionMatch.match(/^nth\((\d+)\)$/);
+      if (nthMatch) {
+        segment.position = "nth";
+        segment.positionValue = parseInt(nthMatch[1], 10);
+      } else {
+        segment.position = positionMatch;
+      }
+    }
+    return segment;
+  }
+  get length() {
+    return this.segments.length;
+  }
+  hasDeepWildcard() {
+    return this._hasDeepWildcard;
+  }
+  hasAttributeCondition() {
+    return this._hasAttributeCondition;
+  }
+  hasPositionSelector() {
+    return this._hasPositionSelector;
+  }
+  toString() {
+    return this.pattern;
+  }
+}
+
+// ../../node_modules/path-expression-matcher/src/Matcher.js
+class Matcher {
+  constructor(options = {}) {
+    this.separator = options.separator || ".";
+    this.path = [];
+    this.siblingStacks = [];
+  }
+  push(tagName, attrValues = null, namespace = null) {
+    if (this.path.length > 0) {
+      const prev = this.path[this.path.length - 1];
+      prev.values = undefined;
+    }
+    const currentLevel = this.path.length;
+    if (!this.siblingStacks[currentLevel]) {
+      this.siblingStacks[currentLevel] = new Map;
+    }
+    const siblings = this.siblingStacks[currentLevel];
+    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
+    const counter = siblings.get(siblingKey) || 0;
+    let position = 0;
+    for (const count of siblings.values()) {
+      position += count;
+    }
+    siblings.set(siblingKey, counter + 1);
+    const node = {
+      tag: tagName,
+      position,
+      counter
+    };
+    if (namespace !== null && namespace !== undefined) {
+      node.namespace = namespace;
+    }
+    if (attrValues !== null && attrValues !== undefined) {
+      node.values = attrValues;
+    }
+    this.path.push(node);
+  }
+  pop() {
+    if (this.path.length === 0) {
+      return;
+    }
+    const node = this.path.pop();
+    if (this.siblingStacks.length > this.path.length + 1) {
+      this.siblingStacks.length = this.path.length + 1;
+    }
+    return node;
+  }
+  updateCurrent(attrValues) {
+    if (this.path.length > 0) {
+      const current = this.path[this.path.length - 1];
+      if (attrValues !== null && attrValues !== undefined) {
+        current.values = attrValues;
+      }
+    }
+  }
+  getCurrentTag() {
+    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;
+  }
+  getCurrentNamespace() {
+    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;
+  }
+  getAttrValue(attrName) {
+    if (this.path.length === 0)
+      return;
+    const current = this.path[this.path.length - 1];
+    return current.values?.[attrName];
+  }
+  hasAttr(attrName) {
+    if (this.path.length === 0)
+      return false;
+    const current = this.path[this.path.length - 1];
+    return current.values !== undefined && attrName in current.values;
+  }
+  getPosition() {
+    if (this.path.length === 0)
+      return -1;
+    return this.path[this.path.length - 1].position ?? 0;
+  }
+  getCounter() {
+    if (this.path.length === 0)
+      return -1;
+    return this.path[this.path.length - 1].counter ?? 0;
+  }
+  getIndex() {
+    return this.getPosition();
+  }
+  getDepth() {
+    return this.path.length;
+  }
+  toString(separator, includeNamespace = true) {
+    const sep = separator || this.separator;
+    return this.path.map((n) => {
+      if (includeNamespace && n.namespace) {
+        return `${n.namespace}:${n.tag}`;
+      }
+      return n.tag;
+    }).join(sep);
+  }
+  toArray() {
+    return this.path.map((n) => n.tag);
+  }
+  reset() {
+    this.path = [];
+    this.siblingStacks = [];
+  }
+  matches(expression) {
+    const segments = expression.segments;
+    if (segments.length === 0) {
+      return false;
+    }
+    if (expression.hasDeepWildcard()) {
+      return this._matchWithDeepWildcard(segments);
+    }
+    return this._matchSimple(segments);
+  }
+  _matchSimple(segments) {
+    if (this.path.length !== segments.length) {
+      return false;
+    }
+    for (let i = 0;i < segments.length; i++) {
+      const segment = segments[i];
+      const node = this.path[i];
+      const isCurrentNode = i === this.path.length - 1;
+      if (!this._matchSegment(segment, node, isCurrentNode)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _matchWithDeepWildcard(segments) {
+    let pathIdx = this.path.length - 1;
+    let segIdx = segments.length - 1;
+    while (segIdx >= 0 && pathIdx >= 0) {
+      const segment = segments[segIdx];
+      if (segment.type === "deep-wildcard") {
+        segIdx--;
+        if (segIdx < 0) {
+          return true;
+        }
+        const nextSeg = segments[segIdx];
+        let found = false;
+        for (let i = pathIdx;i >= 0; i--) {
+          const isCurrentNode = i === this.path.length - 1;
+          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {
+            pathIdx = i - 1;
+            segIdx--;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return false;
+        }
+      } else {
+        const isCurrentNode = pathIdx === this.path.length - 1;
+        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {
+          return false;
+        }
+        pathIdx--;
+        segIdx--;
+      }
+    }
+    return segIdx < 0;
+  }
+  _matchSegment(segment, node, isCurrentNode) {
+    if (segment.tag !== "*" && segment.tag !== node.tag) {
+      return false;
+    }
+    if (segment.namespace !== undefined) {
+      if (segment.namespace !== "*" && segment.namespace !== node.namespace) {
+        return false;
+      }
+    }
+    if (segment.attrName !== undefined) {
+      if (!isCurrentNode) {
+        return false;
+      }
+      if (!node.values || !(segment.attrName in node.values)) {
+        return false;
+      }
+      if (segment.attrValue !== undefined) {
+        const actualValue = node.values[segment.attrName];
+        if (String(actualValue) !== String(segment.attrValue)) {
+          return false;
+        }
+      }
+    }
+    if (segment.position !== undefined) {
+      if (!isCurrentNode) {
+        return false;
+      }
+      const counter = node.counter ?? 0;
+      if (segment.position === "first" && counter !== 0) {
+        return false;
+      } else if (segment.position === "odd" && counter % 2 !== 1) {
+        return false;
+      } else if (segment.position === "even" && counter % 2 !== 0) {
+        return false;
+      } else if (segment.position === "nth") {
+        if (counter !== segment.positionValue) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  snapshot() {
+    return {
+      path: this.path.map((node) => ({ ...node })),
+      siblingStacks: this.siblingStacks.map((map) => new Map(map))
+    };
+  }
+  restore(snapshot) {
+    this.path = snapshot.path.map((node) => ({ ...node }));
+    this.siblingStacks = snapshot.siblingStacks.map((map) => new Map(map));
+  }
+}
+
+// ../../node_modules/path-expression-matcher/src/index.js
+var init_src = () => {};
+
 // ../../node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+function extractRawAttributes(prefixedAttrs, options) {
+  if (!prefixedAttrs)
+    return {};
+  const attrs = options.attributesGroupName ? prefixedAttrs[options.attributesGroupName] : prefixedAttrs;
+  if (!attrs)
+    return {};
+  const rawAttrs = {};
+  for (const key in attrs) {
+    if (key.startsWith(options.attributeNamePrefix)) {
+      const rawName = key.substring(options.attributeNamePrefix.length);
+      rawAttrs[rawName] = attrs[key];
+    } else {
+      rawAttrs[key] = attrs[key];
+    }
+  }
+  return rawAttrs;
+}
+function extractNamespace(rawTagName) {
+  if (!rawTagName || typeof rawTagName !== "string")
+    return;
+  const colonIndex = rawTagName.indexOf(":");
+  if (colonIndex !== -1 && colonIndex > 0) {
+    const ns = rawTagName.substring(0, colonIndex);
+    if (ns !== "xmlns") {
+      return ns;
+    }
+  }
+  return;
+}
+
 class OrderedObjParser {
   constructor(options) {
     this.options = options;
@@ -1610,17 +1994,16 @@ class OrderedObjParser {
     this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
     this.entityExpansionCount = 0;
     this.currentExpandedLength = 0;
+    this.matcher = new Matcher;
+    this.isCurrentNodeStopNode = false;
     if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-      this.stopNodesExact = new Set;
-      this.stopNodesWildcard = new Set;
+      this.stopNodeExpressions = [];
       for (let i = 0;i < this.options.stopNodes.length; i++) {
         const stopNodeExp = this.options.stopNodes[i];
-        if (typeof stopNodeExp !== "string")
-          continue;
-        if (stopNodeExp.startsWith("*.")) {
-          this.stopNodesWildcard.add(stopNodeExp.substring(2));
-        } else {
-          this.stopNodesExact.add(stopNodeExp);
+        if (typeof stopNodeExp === "string") {
+          this.stopNodeExpressions.push(new Expression(stopNodeExp));
+        } else if (stopNodeExp instanceof Expression) {
+          this.stopNodeExpressions.push(stopNodeExp);
         }
       }
     }
@@ -1645,7 +2028,8 @@ function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode,
     if (val.length > 0) {
       if (!escapeEntities)
         val = this.replaceEntitiesValue(val, tagName, jPath);
-      const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
       if (newval === null || newval === undefined) {
         return val;
       } else if (typeof newval !== typeof val || newval !== val) {
@@ -1681,9 +2065,26 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     const matches = getAllMatches(attrStr, attrsRegx);
     const len = matches.length;
     const attrs = {};
+    const rawAttrsForMatcher = {};
     for (let i = 0;i < len; i++) {
       const attrName = this.resolveNameSpace(matches[i][1]);
-      if (this.ignoreAttributesFn(attrName, jPath)) {
+      const oldVal = matches[i][4];
+      if (attrName.length && oldVal !== undefined) {
+        let parsedVal = oldVal;
+        if (this.options.trimValues) {
+          parsedVal = parsedVal.trim();
+        }
+        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, jPath);
+        rawAttrsForMatcher[attrName] = parsedVal;
+      }
+    }
+    if (Object.keys(rawAttrsForMatcher).length > 0 && typeof jPath === "object" && jPath.updateCurrent) {
+      jPath.updateCurrent(rawAttrsForMatcher);
+    }
+    for (let i = 0;i < len; i++) {
+      const attrName = this.resolveNameSpace(matches[i][1]);
+      const jPathStr = this.options.jPath ? jPath.toString() : jPath;
+      if (this.ignoreAttributesFn(attrName, jPathStr)) {
         continue;
       }
       let oldVal = matches[i][4];
@@ -1699,7 +2100,8 @@ function buildAttributesMap(attrStr, jPath, tagName) {
             oldVal = oldVal.trim();
           }
           oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
-          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
+          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);
           if (newVal === null || newVal === undefined) {
             attrs[aName] = oldVal;
           } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
@@ -1723,10 +2125,11 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     return attrs;
   }
 }
-function addChild(currentNode, childNode, jPath, startIndex) {
+function addChild(currentNode, childNode, matcher, startIndex) {
   if (!this.options.captureMetaData)
     startIndex = undefined;
-  const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+  const jPathOrMatcher = this.options.jPath ? matcher.toString() : matcher;
+  const result = this.options.updateTag(childNode.tagname, jPathOrMatcher, childNode[":@"]);
   if (result === false) {} else if (typeof result === "string") {
     childNode.tagname = result;
     currentNode.addChild(childNode, startIndex);
@@ -1734,22 +2137,78 @@ function addChild(currentNode, childNode, jPath, startIndex) {
     currentNode.addChild(childNode, startIndex);
   }
 }
-function saveTextToParentTag(textData, parentNode, jPath, isLeafNode) {
+function replaceEntitiesValue(val, tagName, jPath) {
+  const entityConfig = this.options.processEntities;
+  if (!entityConfig || !entityConfig.enabled) {
+    return val;
+  }
+  if (entityConfig.allowedTags) {
+    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+    const allowed = Array.isArray(entityConfig.allowedTags) ? entityConfig.allowedTags.includes(tagName) : entityConfig.allowedTags(tagName, jPathOrMatcher);
+    if (!allowed) {
+      return val;
+    }
+  }
+  if (entityConfig.tagFilter) {
+    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+    if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {
+      return val;
+    }
+  }
+  for (let entityName in this.docTypeEntities) {
+    const entity = this.docTypeEntities[entityName];
+    const matches = val.match(entity.regx);
+    if (matches) {
+      this.entityExpansionCount += matches.length;
+      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+        throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
+      }
+      const lengthBefore = val.length;
+      val = val.replace(entity.regx, entity.val);
+      if (entityConfig.maxExpandedLength) {
+        this.currentExpandedLength += val.length - lengthBefore;
+        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {
+          throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`);
+        }
+      }
+    }
+  }
+  if (val.indexOf("&") === -1)
+    return val;
+  for (let entityName in this.lastEntities) {
+    const entity = this.lastEntities[entityName];
+    val = val.replace(entity.regex, entity.val);
+  }
+  if (val.indexOf("&") === -1)
+    return val;
+  if (this.options.htmlEntities) {
+    for (let entityName in this.htmlEntities) {
+      const entity = this.htmlEntities[entityName];
+      val = val.replace(entity.regex, entity.val);
+    }
+  }
+  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
+  return val;
+}
+function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
   if (textData) {
     if (isLeafNode === undefined)
       isLeafNode = parentNode.child.length === 0;
-    textData = this.parseTextData(textData, parentNode.tagname, jPath, false, parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false, isLeafNode);
+    textData = this.parseTextData(textData, parentNode.tagname, matcher, false, parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false, isLeafNode);
     if (textData !== undefined && textData !== "")
       parentNode.add(this.options.textNodeName, textData);
     textData = "";
   }
   return textData;
 }
-function isItStopNode(stopNodesExact, stopNodesWildcard, jPath, currentTagName) {
-  if (stopNodesWildcard && stopNodesWildcard.has(currentTagName))
-    return true;
-  if (stopNodesExact && stopNodesExact.has(jPath))
-    return true;
+function isItStopNode(stopNodeExpressions, matcher) {
+  if (!stopNodeExpressions || stopNodeExpressions.length === 0)
+    return false;
+  for (let i = 0;i < stopNodeExpressions.length; i++) {
+    if (matcher.matches(stopNodeExpressions[i])) {
+      return true;
+    }
+  }
   return false;
 }
 function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
@@ -1890,7 +2349,7 @@ var attrsRegx, parseXml = function(xmlData) {
   const xmlObj = new XmlNode("!xml");
   let currentNode = xmlObj;
   let textData = "";
-  let jPath = "";
+  this.matcher.reset();
   this.entityExpansionCount = 0;
   this.currentExpandedLength = 0;
   const docTypeReader = new DocTypeReader(this.options.processEntities);
@@ -1910,20 +2369,18 @@ var attrsRegx, parseXml = function(xmlData) {
           tagName = this.options.transformTagName(tagName);
         }
         if (currentNode) {
-          textData = this.saveTextToParentTag(textData, currentNode, jPath);
+          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
         }
-        const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+        const lastTagName = this.matcher.getCurrentTag();
         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.matcher.pop();
           this.tagsNodeStack.pop();
-        } else {
-          propIndex = jPath.lastIndexOf(".");
         }
-        jPath = jPath.substring(0, propIndex);
+        this.matcher.pop();
+        this.isCurrentNodeStopNode = false;
         currentNode = this.tagsNodeStack.pop();
         textData = "";
         i = closeIndex;
@@ -1931,21 +2388,21 @@ var attrsRegx, parseXml = function(xmlData) {
         let tagData = readTagExp(xmlData, i, false, "?>");
         if (!tagData)
           throw new Error("Pi Tag is not closed.");
-        textData = this.saveTextToParentTag(textData, currentNode, jPath);
+        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
         if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {} else {
           const childNode = new XmlNode(tagData.tagName);
           childNode.add(this.options.textNodeName, "");
           if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
-            childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
+            childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
           }
-          this.addChild(currentNode, childNode, jPath, i);
+          this.addChild(currentNode, childNode, this.matcher, i);
         }
         i = tagData.closeIndex + 1;
       } else if (xmlData.substr(i + 1, 3) === "!--") {
         const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
         if (this.options.commentPropName) {
           const comment = xmlData.substring(i + 4, endIndex - 2);
-          textData = this.saveTextToParentTag(textData, currentNode, jPath);
+          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
           currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
         }
         i = endIndex;
@@ -1956,8 +2413,8 @@ var attrsRegx, parseXml = function(xmlData) {
       } else if (xmlData.substr(i + 1, 2) === "![") {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
         const tagExp = xmlData.substring(i + 9, closeIndex);
-        textData = this.saveTextToParentTag(textData, currentNode, jPath);
-        let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
+        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
+        let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);
         if (val == undefined)
           val = "";
         if (this.options.cdataPropName) {
@@ -1968,6 +2425,10 @@ var attrsRegx, parseXml = function(xmlData) {
         i = closeIndex + 2;
       } else {
         let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+        if (!result) {
+          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));
+          throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
+        }
         let tagName = result.tagName;
         const rawTagName = result.rawTagName;
         let tagExp = result.tagExp;
@@ -1985,28 +2446,45 @@ var attrsRegx, parseXml = function(xmlData) {
         }
         if (currentNode && textData) {
           if (currentNode.tagname !== "!xml") {
-            textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
+            textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);
           }
         }
         const lastTag = currentNode;
         if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
           currentNode = this.tagsNodeStack.pop();
-          jPath = jPath.substring(0, jPath.lastIndexOf("."));
+          this.matcher.pop();
+        }
+        let isSelfClosing = false;
+        if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
+          isSelfClosing = true;
+          if (tagName[tagName.length - 1] === "/") {
+            tagName = tagName.substr(0, tagName.length - 1);
+            tagExp = tagName;
+          } else {
+            tagExp = tagExp.substr(0, tagExp.length - 1);
+          }
+          attrExpPresent = tagName !== tagExp;
         }
+        let prefixedAttrs = null;
+        let rawAttrs = {};
+        let namespace = undefined;
+        namespace = extractNamespace(rawTagName);
         if (tagName !== xmlObj.tagname) {
-          jPath += jPath ? "." + tagName : tagName;
+          this.matcher.push(tagName, {}, namespace);
+        }
+        if (tagName !== tagExp && attrExpPresent) {
+          prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
+          if (prefixedAttrs) {
+            rawAttrs = extractRawAttributes(prefixedAttrs, this.options);
+          }
+        }
+        if (tagName !== xmlObj.tagname) {
+          this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);
         }
         const startIndex = i;
-        if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, jPath, tagName)) {
+        if (this.isCurrentNodeStopNode) {
           let tagContent = "";
-          if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-            if (tagName[tagName.length - 1] === "/") {
-              tagName = tagName.substr(0, tagName.length - 1);
-              jPath = jPath.substr(0, jPath.length - 1);
-              tagExp = tagName;
-            } else {
-              tagExp = tagExp.substr(0, tagExp.length - 1);
-            }
+          if (isSelfClosing) {
             i = result.closeIndex;
           } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
             i = result.closeIndex;
@@ -2018,24 +2496,15 @@ var attrsRegx, parseXml = function(xmlData) {
             tagContent = result2.tagContent;
           }
           const childNode = new XmlNode(tagName);
-          if (tagName !== tagExp && attrExpPresent) {
-            childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
-          }
-          if (tagContent) {
-            tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
+          if (prefixedAttrs) {
+            childNode[":@"] = prefixedAttrs;
           }
-          jPath = jPath.substr(0, jPath.lastIndexOf("."));
           childNode.add(this.options.textNodeName, tagContent);
-          this.addChild(currentNode, childNode, jPath, startIndex);
+          this.matcher.pop();
+          this.isCurrentNodeStopNode = false;
+          this.addChild(currentNode, childNode, this.matcher, startIndex);
         } else {
-          if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-            if (tagName[tagName.length - 1] === "/") {
-              tagName = tagName.substr(0, tagName.length - 1);
-              jPath = jPath.substr(0, jPath.length - 1);
-              tagExp = tagName;
-            } else {
-              tagExp = tagExp.substr(0, tagExp.length - 1);
-            }
+          if (isSelfClosing) {
             if (this.options.transformTagName) {
               const newTagName = this.options.transformTagName(tagName);
               if (tagExp === tagName) {
@@ -2044,18 +2513,20 @@ var attrsRegx, parseXml = function(xmlData) {
               tagName = newTagName;
             }
             const childNode = new XmlNode(tagName);
-            if (tagName !== tagExp && attrExpPresent) {
-              childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+            if (prefixedAttrs) {
+              childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, jPath, startIndex);
-            jPath = jPath.substr(0, jPath.lastIndexOf("."));
+            this.addChild(currentNode, childNode, this.matcher, startIndex);
+            this.matcher.pop();
+            this.isCurrentNodeStopNode = false;
           } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
             const childNode = new XmlNode(tagName);
-            if (tagName !== tagExp && attrExpPresent) {
-              childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+            if (prefixedAttrs) {
+              childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, jPath, startIndex);
-            jPath = jPath.substr(0, jPath.lastIndexOf("."));
+            this.addChild(currentNode, childNode, this.matcher, startIndex);
+            this.matcher.pop();
+            this.isCurrentNodeStopNode = false;
             i = result.closeIndex;
             continue;
           } else {
@@ -2064,10 +2535,10 @@ var attrsRegx, parseXml = function(xmlData) {
               throw new Error("Maximum nested tags exceeded");
             }
             this.tagsNodeStack.push(currentNode);
-            if (tagName !== tagExp && attrExpPresent) {
-              childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+            if (prefixedAttrs) {
+              childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, jPath, startIndex);
+            this.addChild(currentNode, childNode, this.matcher, startIndex);
             currentNode = childNode;
           }
           textData = "";
@@ -2079,82 +2550,46 @@ var attrsRegx, parseXml = function(xmlData) {
     }
   }
   return xmlObj.child;
-}, replaceEntitiesValue = function(val, tagName, jPath) {
-  if (val.indexOf("&") === -1) {
-    return val;
-  }
-  const entityConfig = this.options.processEntities;
-  if (!entityConfig.enabled) {
-    return val;
-  }
-  if (entityConfig.allowedTags) {
-    if (!entityConfig.allowedTags.includes(tagName)) {
-      return val;
-    }
-  }
-  if (entityConfig.tagFilter) {
-    if (!entityConfig.tagFilter(tagName, jPath)) {
-      return val;
-    }
-  }
-  for (let entityName in this.docTypeEntities) {
-    const entity = this.docTypeEntities[entityName];
-    const matches = val.match(entity.regx);
-    if (matches) {
-      this.entityExpansionCount += matches.length;
-      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
-        throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
-      }
-      const lengthBefore = val.length;
-      val = val.replace(entity.regx, entity.val);
-      if (entityConfig.maxExpandedLength) {
-        this.currentExpandedLength += val.length - lengthBefore;
-        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {
-          throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`);
-        }
-      }
-    }
-  }
-  if (val.indexOf("&") === -1)
-    return val;
-  for (let entityName in this.lastEntities) {
-    const entity = this.lastEntities[entityName];
-    val = val.replace(entity.regex, entity.val);
-  }
-  if (val.indexOf("&") === -1)
-    return val;
-  if (this.options.htmlEntities) {
-    for (let entityName in this.htmlEntities) {
-      const entity = this.htmlEntities[entityName];
-      val = val.replace(entity.regex, entity.val);
-    }
-  }
-  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
-  return val;
 };
 var init_OrderedObjParser = __esm(() => {
   init_util();
   init_xmlNode();
   init_DocTypeReader();
   init_strnum();
+  init_src();
   attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
 });
 
 // ../../node_modules/fast-xml-parser/src/xmlparser/node2json.js
-function prettify(node, options) {
-  return compress(node, options);
+function stripAttributePrefix(attrs, prefix) {
+  if (!attrs || typeof attrs !== "object")
+    return {};
+  if (!prefix)
+    return attrs;
+  const rawAttrs = {};
+  for (const key in attrs) {
+    if (key.startsWith(prefix)) {
+      const rawName = key.substring(prefix.length);
+      rawAttrs[rawName] = attrs[key];
+    } else {
+      rawAttrs[key] = attrs[key];
+    }
+  }
+  return rawAttrs;
 }
-function compress(arr, options, jPath) {
+function prettify(node, options, matcher) {
+  return compress(node, options, matcher);
+}
+function compress(arr, options, matcher) {
   let text;
   const compressedObj = {};
   for (let i = 0;i < arr.length; i++) {
     const tagObj = arr[i];
     const property = propName(tagObj);
-    let newJpath = "";
-    if (jPath === undefined)
-      newJpath = property;
-    else
-      newJpath = jPath + "." + property;
+    if (property !== undefined && property !== options.textNodeName) {
+      const rawAttrs = stripAttributePrefix(tagObj[":@"] || {}, options.attributeNamePrefix);
+      matcher.push(property, rawAttrs);
+    }
     if (property === options.textNodeName) {
       if (text === undefined)
         text = tagObj[property];
@@ -2163,10 +2598,10 @@ function compress(arr, options, jPath) {
     } else if (property === undefined) {
       continue;
     } else if (tagObj[property]) {
-      let val = compress(tagObj[property], options, newJpath);
+      let val = compress(tagObj[property], options, matcher);
       const isLeaf = isLeafTag(val, options);
       if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], newJpath, options);
+        assignAttributes(val, tagObj[":@"], matcher, options);
       } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
         val = val[options.textNodeName];
       } else if (Object.keys(val).length === 0) {
@@ -2184,12 +2619,16 @@ function compress(arr, options, jPath) {
         }
         compressedObj[property].push(val);
       } else {
-        if (options.isArray(property, newJpath, isLeaf)) {
+        const jPathOrMatcher = options.jPath ? matcher.toString() : matcher;
+        if (options.isArray(property, jPathOrMatcher, isLeaf)) {
           compressedObj[property] = [val];
         } else {
           compressedObj[property] = val;
         }
       }
+      if (property !== undefined && property !== options.textNodeName) {
+        matcher.pop();
+      }
     }
   }
   if (typeof text === "string") {
@@ -2207,13 +2646,15 @@ function propName(obj) {
       return key;
   }
 }
-function assignAttributes(obj, attrMap, jpath, options) {
+function assignAttributes(obj, attrMap, matcher, options) {
   if (attrMap) {
     const keys = Object.keys(attrMap);
     const len = keys.length;
     for (let i = 0;i < len; i++) {
       const atrrName = keys[i];
-      if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix) ? atrrName.substring(options.attributeNamePrefix.length) : atrrName;
+      const jPathOrMatcher = options.jPath ? matcher.toString() + "." + rawAttrName : matcher;
+      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {
         obj[atrrName] = [attrMap[atrrName]];
       } else {
         obj[atrrName] = attrMap[atrrName];
@@ -2235,6 +2676,7 @@ function isLeafTag(obj, options) {
 var METADATA_SYMBOL2;
 var init_node2json = __esm(() => {
   init_xmlNode();
+  init_src();
   METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
 });
 
@@ -2264,7 +2706,7 @@ class XMLParser {
     if (this.options.preserveOrder || orderedResult === undefined)
       return orderedResult;
     else
-      return prettify(orderedResult, this.options);
+      return prettify(orderedResult, this.options, orderedObjParser.matcher);
   }
   addEntity(key, value) {
     if (value.indexOf("&") !== -1) {
@@ -8539,7 +8981,8 @@ function generateExternalDnsStaticSiteTemplate(config4) {
     aliases,
     certificateArn,
     defaultRootObject = "index.html",
-    errorDocument = "404.html"
+    errorDocument = "404.html",
+    passthroughUrls = false
   } = config4;
   const resources = {};
   const outputs = {};
@@ -8579,16 +9022,17 @@ function generateExternalDnsStaticSiteTemplate(config4) {
       }
     }
   };
-  resources.UrlRewriteFunction = {
-    Type: "AWS::CloudFront::Function",
-    Properties: {
-      Name: { "Fn::Sub": "${AWS::StackName}-url-rewrite" },
-      AutoPublish: true,
-      FunctionConfig: {
-        Comment: "Append .html extension to URLs without extensions",
-        Runtime: "cloudfront-js-2.0"
-      },
-      FunctionCode: `function handler(event) {
+  if (!passthroughUrls) {
+    resources.UrlRewriteFunction = {
+      Type: "AWS::CloudFront::Function",
+      Properties: {
+        Name: { "Fn::Sub": "${AWS::StackName}-url-rewrite" },
+        AutoPublish: true,
+        FunctionConfig: {
+          Comment: "Append .html extension to URLs without extensions",
+          Runtime: "cloudfront-js-2.0"
+        },
+        FunctionCode: `function handler(event) {
   const request = event.request;
   var uri = request.uri;
 
@@ -8603,8 +9047,9 @@ function generateExternalDnsStaticSiteTemplate(config4) {
 
   return request;
 }`
-    }
-  };
+      }
+    };
+  }
   const distributionConfig = {
     Enabled: true,
     DefaultRootObject: defaultRootObject,
@@ -8628,12 +9073,14 @@ function generateExternalDnsStaticSiteTemplate(config4) {
       CachedMethods: ["GET", "HEAD"],
       Compress: true,
       CachePolicyId: "658327ea-f89d-4fab-a63d-7e88639e58f6",
-      FunctionAssociations: [
-        {
-          EventType: "viewer-request",
-          FunctionARN: { "Fn::GetAtt": ["UrlRewriteFunction", "FunctionARN"] }
-        }
-      ]
+      ...!passthroughUrls && {
+        FunctionAssociations: [
+          {
+            EventType: "viewer-request",
+            FunctionARN: { "Fn::GetAtt": ["UrlRewriteFunction", "FunctionARN"] }
+          }
+        ]
+      }
     },
     CustomErrorResponses: [
       {
@@ -8664,7 +9111,7 @@ function generateExternalDnsStaticSiteTemplate(config4) {
   }
   resources.CloudFrontDistribution = {
     Type: "AWS::CloudFront::Distribution",
-    DependsOn: ["S3Bucket", "CloudFrontOAC", "UrlRewriteFunction"],
+    DependsOn: passthroughUrls ? ["S3Bucket", "CloudFrontOAC"] : ["S3Bucket", "CloudFrontOAC", "UrlRewriteFunction"],
     Properties: {
       DistributionConfig: distributionConfig
     }
@@ -8910,7 +9357,8 @@ async function deployStaticSiteWithExternalDns(config4) {
     aliases,
     certificateArn,
     defaultRootObject: config4.defaultRootObject,
-    errorDocument: config4.errorDocument
+    errorDocument: config4.errorDocument,
+    passthroughUrls: config4.passthroughUrls
   });
   const tags = Object.entries(config4.tags || {}).map(([Key, Value]) => ({ Key, Value }));
   tags.push({ Key: "ManagedBy", Value: "ts-cloud" });
@@ -9940,7 +10388,7 @@ async function uploadStaticFiles(options) {
   }
   function getContentType(filePath) {
     const ext = filePath.split(".").pop()?.toLowerCase();
-    const types3 = {
+    const types4 = {
       html: "text/html; charset=utf-8",
       css: "text/css; charset=utf-8",
       js: "application/javascript; charset=utf-8",
@@ -9956,9 +10404,12 @@ async function uploadStaticFiles(options) {
       woff2: "font/woff2",
       ttf: "font/ttf",
       xml: "application/xml",
-      txt: "text/plain; charset=utf-8"
+      txt: "text/plain; charset=utf-8",
+      sh: "text/plain; charset=utf-8",
+      bash: "text/plain; charset=utf-8",
+      ps1: "text/plain; charset=utf-8"
     };
-    return types3[ext || ""] || "application/octet-stream";
+    return types4[ext || ""] || "application/octet-stream";
   }
   function computeMD5(content) {
     return createHash7("md5").update(content).digest("hex");
@@ -15168,7 +15619,7 @@ async function getConfig() {
 }
 var loadCloudConfig = getConfig;
 var config3 = defaultConfig3;
-// ../types/src/index.ts
+// ../core/src/types.ts
 var QueuePresets = {
   backgroundJobs: {
     visibilityTimeout: 120,