@cdk8s/awscdk-resolver 0.0.609 → 0.0.610

package/node_modules/@aws-sdk/xml-builder/dist-es/xml-parser.js

@@ -1,44 +1,234 @@
-import { XMLParser } from "fast-xml-parser";
-import { COMMON_HTML, CURRENCY, EntityDecoderImpl, XML } from "./xml-external/nodable_entities";
-const entityDecoder = new EntityDecoderImpl({
-    namedEntities: { ...XML, ...COMMON_HTML, ...CURRENCY },
-    numericAllowed: true,
-    limit: {
-        maxTotalExpansions: Infinity,
-    },
-    ncr: {
-        xmlVersion: 1.1,
-    },
-});
-const parser = new XMLParser({
-    attributeNamePrefix: "",
-    processEntities: {
-        enabled: true,
-        maxTotalExpansions: Infinity,
-    },
-    htmlEntities: true,
-    entityDecoder: {
-        setExternalEntities: (entities) => {
-            entityDecoder.setExternalEntities(entities);
-        },
-        addInputEntities: (entities) => {
-            entityDecoder.addInputEntities(entities);
-        },
-        reset: () => {
-            entityDecoder.reset();
-        },
-        decode: (text) => {
-            return entityDecoder.decode(text);
-        },
-        setXmlVersion: (version) => void {},
-    },
-    ignoreAttributes: false,
-    ignoreDeclaration: true,
-    parseTagValue: false,
-    trimValues: false,
-    tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
-    maxNestedTags: Infinity,
-});
-export function parseXML(xmlString) {
-    return parser.parse(xmlString, true);
+export function parseXML(xml) {
+    const state = new AwsXmlParser(xml);
+    return state.parse();
+}
+class AwsXmlParser {
+    x;
+    i = 0;
+    z;
+    constructor(x) {
+        this.x = x;
+        this.x = x.replace(/\r\n?/g, "\n");
+        this.z = this.x.length;
+    }
+    parse() {
+        const p = this;
+        const { z } = p;
+        while (p.i < z) {
+            p.trim();
+            if (p.i >= z) {
+                break;
+            }
+            if (p.isNext("<?")) {
+                p.readTo("?>");
+                p.trim();
+            }
+            else if (p.isNext("<!--")) {
+                p.readTo("-->");
+                p.trim();
+            }
+            else if (p.isNext("<!DOCTYPE", false)) {
+                p.skipDoctype();
+                p.trim();
+            }
+            else if (p.x[p.i] === "<") {
+                const root = p.parseTag();
+                return { [root.tag]: root.value };
+            }
+            else {
+                throw new Error("@aws-sdk XML parse error: unexpected content.");
+            }
+        }
+        throw new Error("@aws-sdk XML parse error: no root element.");
+    }
+    isNext(s, caseSensitive = true) {
+        const p = this;
+        if (caseSensitive) {
+            return p.x.startsWith(s, p.i);
+        }
+        return p.x.toLowerCase().startsWith(s.toLowerCase(), p.i);
+    }
+    readTo(stop) {
+        const p = this;
+        const _i = p.x.indexOf(stop, p.i);
+        if (_i === -1) {
+            throw new Error(`@aws-sdk XML parse error: expected "${stop}" not found.`);
+        }
+        const result = p.x.slice(p.i, _i);
+        p.i = _i + stop.length;
+        return result;
+    }
+    trim() {
+        const p = this;
+        while (p.i < p.z && " \t\r\n".includes(p.x[p.i])) {
+            ++p.i;
+        }
+    }
+    readAttrValue() {
+        const p = this;
+        const quote = p.x[p.i];
+        ++p.i;
+        let value = "";
+        while (p.i < p.z && p.x[p.i] !== quote) {
+            value += p.x[p.i++];
+        }
+        ++p.i;
+        return p.decodeEntities(value);
+    }
+    parseTag() {
+        const p = this;
+        ++p.i;
+        let tag = "";
+        while (p.i < p.z && !" \t\r\n>/".includes(p.x[p.i])) {
+            tag += p.x[p.i++];
+        }
+        let hasAttrs = false;
+        const attrs = Object.create(null);
+        while (p.i < p.z) {
+            p.trim();
+            if (">/".includes(p.x[p.i])) {
+                break;
+            }
+            let name = "";
+            while (p.i < p.z && !"= \t\r\n>/?".includes(p.x[p.i])) {
+                name += p.x[p.i++];
+            }
+            p.trim();
+            if (p.x[p.i] !== "=") {
+                break;
+            }
+            ++p.i;
+            p.trim();
+            attrs[name] = p.readAttrValue();
+            hasAttrs = true;
+        }
+        if (p.i >= p.z) {
+            throw new Error("@aws-sdk XML parse error: unexpected end of input.");
+        }
+        if (p.x[p.i] === "/") {
+            ++p.i;
+            if (p.i >= p.z || p.x[p.i] !== ">") {
+                throw new Error("@aws-sdk XML parse error: expected > at the end of self-closing tag.");
+            }
+            ++p.i;
+            Object.setPrototypeOf(attrs, Object.prototype);
+            return { tag, value: hasAttrs ? attrs : "" };
+        }
+        if (p.x[p.i] !== ">") {
+            throw new Error("@aws-sdk XML parse error: expected > at the end of opening tag.");
+        }
+        ++p.i;
+        const textParts = [];
+        const childTags = [];
+        let hasElementChild = false;
+        while (p.i < p.z) {
+            if (p.isNext("</")) {
+                break;
+            }
+            if (p.x[p.i] === "<") {
+                if (p.isNext("<!--")) {
+                    p.readTo("-->");
+                }
+                else if (p.isNext("<![CDATA[")) {
+                    p.i += 9;
+                    textParts.push(p.readTo("]]>"));
+                }
+                else if (p.isNext("<?")) {
+                    p.readTo("?>");
+                }
+                else {
+                    hasElementChild = true;
+                    childTags.push(p.parseTag());
+                }
+            }
+            else {
+                let text = "";
+                while (p.i < p.z && p.x[p.i] !== "<") {
+                    text += p.x[p.i++];
+                }
+                textParts.push(p.decodeEntities(text));
+            }
+        }
+        if (!p.isNext("</")) {
+            throw new Error(`@aws-sdk XML parse error: missing closing tag </${tag}>.`);
+        }
+        p.i += 2;
+        const closeTag = p.readTo(">").trim();
+        if (closeTag !== tag) {
+            throw new Error(`@aws-sdk XML parse error: mismatched tags <${tag}> and </${closeTag}>.`);
+        }
+        if (!hasAttrs && textParts.length === 0 && !hasElementChild) {
+            return { tag, value: "" };
+        }
+        if (!hasAttrs && !hasElementChild) {
+            const text = textParts.length === 1 ? textParts[0] : textParts.join("");
+            if (text.trim() === "" && text.includes("\n")) {
+                return { tag, value: "" };
+            }
+            return { tag, value: text };
+        }
+        const obj = Object.create(null);
+        for (const text of textParts) {
+            if (text.trim() === "" && text.includes("\n")) {
+                continue;
+            }
+            obj["#text"] = "#text" in obj ? obj["#text"] + text : text;
+        }
+        for (const child of childTags) {
+            if (child.tag in obj) {
+                if (Array.isArray(obj[child.tag])) {
+                    obj[child.tag].push(child.value);
+                }
+                else {
+                    obj[child.tag] = [obj[child.tag], child.value];
+                }
+            }
+            else {
+                obj[child.tag] = child.value;
+            }
+        }
+        for (const [k, v] of Object.entries(attrs)) {
+            obj[k] = v;
+        }
+        Object.setPrototypeOf(obj, Object.prototype);
+        return { tag, value: obj };
+    }
+    static ENTITIES = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        apos: "'",
+    };
+    skipDoctype() {
+        const p = this;
+        p.i += 9;
+        let depth = 0;
+        while (p.i < p.z) {
+            const c = p.x[p.i];
+            if (c === "[") {
+                ++depth;
+            }
+            else if (c === "]") {
+                --depth;
+            }
+            else if (c === ">" && depth === 0) {
+                ++p.i;
+                return;
+            }
+            ++p.i;
+        }
+        throw new Error("@aws-sdk XML parse error: unclosed DOCTYPE.");
+    }
+    decodeEntities(s) {
+        return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{0,30}));/g, (_, hex, dec, named) => {
+            if (hex) {
+                return String.fromCharCode(parseInt(hex, 16));
+            }
+            if (dec) {
+                return String.fromCharCode(parseInt(dec, 10));
+            }
+            return AwsXmlParser.ENTITIES[named] ?? "";
+        });
+    }
 }

package/node_modules/@aws-sdk/xml-builder/dist-types/ts3.4/xml-parser.d.ts

@@ -1 +1 @@
-export declare function parseXML(xmlString: string): any;
+export declare function parseXML(xml: string): any;

package/node_modules/@aws-sdk/xml-builder/dist-types/xml-parser.d.ts

@@ -1,4 +1,5 @@
 /**
+ * AWS SDK XML to object converter.
  * @internal
  */
-export declare function parseXML(xmlString: string): any;
+export declare function parseXML(xml: string): any;

package/node_modules/@aws-sdk/xml-builder/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@aws-sdk/xml-builder",
-  "version": "3.972.30",
+  "version": "3.972.31",
   "description": "XML utilities for the AWS SDK",
   "dependencies": {
     "@smithy/types": "^4.14.3",
-    "fast-xml-parser": "5.7.3",
     "tslib": "^2.6.2"
   },
   "scripts": {
@@ -15,8 +14,10 @@
     "build:types": "premove dist-types && tsc -p tsconfig.types.json",
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
     "clean": "premove dist-cjs dist-es dist-types",
+    "profile": "node --inspect-brk ./scripts/benchmark",
     "test": "yarn g:vitest run",
-    "test:watch": "yarn g:vitest watch"
+    "test:watch": "yarn g:vitest watch",
+    "test:fuzz": "jazzer tests/xml-parser.fuzz.js corpus --sync -i xml-parser -- -max_total_time=300"
   },
   "sideEffects": false,
   "author": {
@@ -54,7 +55,6 @@
     "directory": "packages-internal/xml-builder"
   },
   "devDependencies": {
-    "@nodable/entities": "2.1.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",