@cdk8s/awscdk-resolver 0.0.564 → 0.0.566

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

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-parser",
-  "version": "5.7.2",
+  "version": "5.7.3",
   "description": "Validate XML, Parse XML, Build XML without C/C++ based libraries",
   "main": "./lib/fxp.cjs",
   "type": "module",
@@ -23,7 +23,6 @@
     "test": "c8 --reporter=lcov --reporter=text jasmine spec/*spec.js",
     "test-types": "tsc --noEmit spec/typings/typings-test.ts",
     "unit": "jasmine",
-    "coverage": "nyc report --reporter html --reporter text -t .nyc_output --report-dir .nyc_output/summary",
     "perf": "node ./benchmark/perfTest3.js",
     "lint": "eslint src/**/*.js spec/**/*.js benchmark/**/*.js",
     "bundle": "webpack --config webpack.cjs.config.js",
@@ -72,7 +71,6 @@
     "babel-loader": "^8.2.2",
     "c8": "^10.1.3",
     "eslint": "^8.3.0",
-    "he": "^1.2.0",
     "jasmine": "^5.6.0",
     "prettier": "^3.5.1",
     "publish-please": "^5.5.2",
@@ -88,7 +86,7 @@
   ],
   "dependencies": {
     "@nodable/entities": "^2.1.0",
-    "fast-xml-builder": "^1.1.5",
+    "fast-xml-builder": "^1.1.7",
     "path-expression-matcher": "^1.5.0",
     "strnum": "^2.2.3"
   }

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/fxp.d.ts

@@ -701,6 +701,7 @@ export class XMLParser {
    * Add Entity which is not by default supported by this library
    * @param entityIdentifier {string} Eg: 'ent' for &ent;
    * @param entityValue {string} Eg: '\r'
+   * @deprecated Use `entityDecoder` instead
    */
   addEntity(entityIdentifier: string, entityValue: string): void;
 

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js

@@ -776,7 +776,7 @@ function readStopNodeData(xmlData, tagName, i) {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
         i = closeIndex;
       } else {
-        const tagData = readTagExp(xmlData, i, '>')
+        const tagData = readTagExp(xmlData, i, false)
 
         if (tagData) {
           const openTagName = tagData && tagData.tagName;

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/xmlparser/node2json.js

@@ -71,6 +71,10 @@ function compress(arr, options, matcher, readonlyMatcher) {
       let val = compress(tagObj[property], options, matcher, readonlyMatcher);
       const isLeaf = isLeafTag(val, options);
 
+      if (Object.keys(val).length === 0 && options.alwaysCreateTextNode) {
+        val[options.textNodeName] = "";
+      }
+
       if (tagObj[":@"]) {
         assignAttributes(val, tagObj[":@"], readonlyMatcher, options);
       } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {

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

@@ -1,11 +1,11 @@
 {
   "name": "@aws-sdk/xml-builder",
-  "version": "3.972.22",
+  "version": "3.972.24",
   "description": "XML utilities for the AWS SDK",
   "dependencies": {
     "@nodable/entities": "2.1.0",
     "@smithy/types": "^4.14.1",
-    "fast-xml-parser": "5.7.2",
+    "fast-xml-parser": "5.7.3",
     "tslib": "^2.6.2"
   },
   "scripts": {
@@ -45,8 +45,8 @@
     "./dist-es/xml-parser": "./dist-es/xml-parser.browser"
   },
   "react-native": {
-    "./dist-es/xml-parser": "./dist-es/xml-parser",
-    "./dist-cjs/xml-parser": "./dist-cjs/xml-parser"
+    "./dist-es/xml-parser": "./dist-es/xml-parser.browser",
+    "./dist-cjs/xml-parser": "./dist-cjs/xml-parser.browser"
   },
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages-internal/xml-builder",
   "repository": {

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1080,7 +1080,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
         const ns = schema.NormalizedSchema.of(errorSchema);
         const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new ErrorCtor(message);
+        const exception = new ErrorCtor({});
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             output[name] = this.deserializer.readValue(member, dataObject[name]);

package/node_modules/@smithy/core/dist-cjs/submodules/serde/index.browser.js

@@ -3,6 +3,122 @@
 var protocols = require('@smithy/core/protocols');
 var endpoints = require('@smithy/core/endpoints');
 
+const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+    acc[c] = Number(i);
+    return acc;
+}, {});
+const alphabetByValue = chars.split("");
+const bitsPerLetter = 6;
+const bitsPerByte = 8;
+const maxLetterValue = 0b111111;
+
+const fromBase64 = (input) => {
+    let totalByteLength = (input.length / 4) * 3;
+    if (input.slice(-2) === "==") {
+        totalByteLength -= 2;
+    }
+    else if (input.slice(-1) === "=") {
+        totalByteLength--;
+    }
+    const out = new ArrayBuffer(totalByteLength);
+    const dataView = new DataView(out);
+    for (let i = 0; i < input.length; i += 4) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = i + 3; j <= limit; j++) {
+            if (input[j] !== "=") {
+                if (!(input[j] in alphabetByEncoding)) {
+                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+                }
+                bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);
+                bitLength += bitsPerLetter;
+            }
+            else {
+                bits >>= bitsPerLetter;
+            }
+        }
+        const chunkOffset = (i / 4) * 3;
+        bits >>= bitLength % bitsPerByte;
+        const byteLength = Math.floor(bitLength / bitsPerByte);
+        for (let k = 0; k < byteLength; k++) {
+            const offset = (byteLength - k - 1) * bitsPerByte;
+            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
+        }
+    }
+    return new Uint8Array(out);
+};
+
+const fromUtf8 = (input) => new TextEncoder().encode(input);
+
+function toBase64(_input) {
+    let input;
+    if (typeof _input === "string") {
+        input = fromUtf8(_input);
+    }
+    else {
+        input = _input;
+    }
+    const isArrayLike = typeof input === "object" && typeof input.length === "number";
+    const isUint8Array = typeof input === "object" &&
+        typeof input.byteOffset === "number" &&
+        typeof input.byteLength === "number";
+    if (!isArrayLike && !isUint8Array) {
+        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    let str = "";
+    for (let i = 0; i < input.length; i += 3) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+            bits |= input[j] << ((limit - j - 1) * bitsPerByte);
+            bitLength += bitsPerByte;
+        }
+        const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+        bits <<= bitClusterCount * bitsPerLetter - bitLength;
+        for (let k = 1; k <= bitClusterCount; k++) {
+            const offset = (bitClusterCount - k) * bitsPerLetter;
+            str += alphabetByValue[(bits & (maxLetterValue << offset)) >> offset];
+        }
+        str += "==".slice(0, 4 - bitClusterCount);
+    }
+    return str;
+}
+
+function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+    return class Uint8ArrayBlobAdapter extends Uint8Array {
+        static fromString(source, encoding = "utf-8") {
+            if (typeof source === "string") {
+                if (encoding === "base64") {
+                    return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
+                }
+                return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
+            }
+            throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+        }
+        static mutate(source) {
+            Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
+            return source;
+        }
+        transformToString(encoding = "utf-8") {
+            if (encoding === "base64") {
+                return toBase64(this);
+            }
+            return toUtf8(this);
+        }
+    };
+}
+
+const toUtf8 = (input) => {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return new TextDecoder("utf-8").decode(input);
+};
+
 const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bindV4(getRandomValues) {
     if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -721,107 +837,6 @@ function toHex(bytes) {
     return out;
 }
 
-const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
-const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
-    acc[c] = Number(i);
-    return acc;
-}, {});
-const alphabetByValue = chars.split("");
-const bitsPerLetter = 6;
-const bitsPerByte = 8;
-const maxLetterValue = 0b111111;
-
-const fromBase64$1 = (input) => {
-    let totalByteLength = (input.length / 4) * 3;
-    if (input.slice(-2) === "==") {
-        totalByteLength -= 2;
-    }
-    else if (input.slice(-1) === "=") {
-        totalByteLength--;
-    }
-    const out = new ArrayBuffer(totalByteLength);
-    const dataView = new DataView(out);
-    for (let i = 0; i < input.length; i += 4) {
-        let bits = 0;
-        let bitLength = 0;
-        for (let j = i, limit = i + 3; j <= limit; j++) {
-            if (input[j] !== "=") {
-                if (!(input[j] in alphabetByEncoding)) {
-                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
-                }
-                bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);
-                bitLength += bitsPerLetter;
-            }
-            else {
-                bits >>= bitsPerLetter;
-            }
-        }
-        const chunkOffset = (i / 4) * 3;
-        bits >>= bitLength % bitsPerByte;
-        const byteLength = Math.floor(bitLength / bitsPerByte);
-        for (let k = 0; k < byteLength; k++) {
-            const offset = (byteLength - k - 1) * bitsPerByte;
-            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
-        }
-    }
-    return new Uint8Array(out);
-};
-
-const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
-    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
-
-const fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
-    if (!isArrayBuffer(input)) {
-        throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
-    }
-    return Buffer.from(input, offset, length);
-};
-const fromString = (input, encoding) => {
-    if (typeof input !== "string") {
-        throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
-    }
-    return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
-};
-
-const fromUtf8$1 = (input) => {
-    const buf = fromString(input, "utf8");
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
-};
-
-function toBase64$1(_input) {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_input);
-    }
-    else {
-        input = _input;
-    }
-    const isArrayLike = typeof input === "object" && typeof input.length === "number";
-    const isUint8Array = typeof input === "object" &&
-        typeof input.byteOffset === "number" &&
-        typeof input.byteLength === "number";
-    if (!isArrayLike && !isUint8Array) {
-        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
-    }
-    let str = "";
-    for (let i = 0; i < input.length; i += 3) {
-        let bits = 0;
-        let bitLength = 0;
-        for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
-            bits |= input[j] << ((limit - j - 1) * bitsPerByte);
-            bitLength += bitsPerByte;
-        }
-        const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
-        bits <<= bitClusterCount * bitsPerLetter - bitLength;
-        for (let k = 1; k <= bitClusterCount; k++) {
-            const offset = (bitClusterCount - k) * bitsPerLetter;
-            str += alphabetByValue[(bits & (maxLetterValue << offset)) >> offset];
-        }
-        str += "==".slice(0, 4 - bitClusterCount);
-    }
-    return str;
-}
-
 const TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder() : null;
 const calculateBodyLength = (body) => {
     if (typeof body === "string") {
@@ -849,11 +864,9 @@ const calculateBodyLength = (body) => {
     throw new Error(`Body Length computation failed for ${body}`);
 };
 
-const fromUtf8 = (input) => new TextEncoder().encode(input);
-
 const toUint8Array = (data) => {
     if (typeof data === "string") {
-        return fromUtf8$1(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
@@ -861,15 +874,8 @@ const toUint8Array = (data) => {
     return new Uint8Array(data);
 };
 
-const toUtf8$1 = (input) => {
-    if (typeof input === "string") {
-        return input;
-    }
-    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
-        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
-    }
-    return new TextDecoder("utf-8").decode(input);
-};
+const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
+    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
 
 const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
     const { response } = await next(args);
@@ -965,64 +971,6 @@ function getSerdePlugin(config, serializer, deserializer) {
     };
 }
 
-const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-const fromBase64 = (input) => {
-    if ((input.length * 3) % 4 !== 0) {
-        throw new TypeError(`Incorrect padding on base64 string.`);
-    }
-    if (!BASE64_REGEX.exec(input)) {
-        throw new TypeError(`Invalid base64 string.`);
-    }
-    const buffer = fromString(input, "base64");
-    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-};
-
-const toBase64 = (_input) => {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_input);
-    }
-    else {
-        input = _input;
-    }
-    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
-        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
-    }
-    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
-};
-
-const toUtf8 = (input) => {
-    if (typeof input === "string") {
-        return input;
-    }
-    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
-        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
-    }
-    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
-};
-
-class Uint8ArrayBlobAdapter extends Uint8Array {
-    static fromString(source, encoding = "utf-8") {
-        if (typeof source === "string") {
-            if (encoding === "base64") {
-                return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
-            }
-            return Uint8ArrayBlobAdapter.mutate(fromUtf8$1(source));
-        }
-        throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
-    }
-    static mutate(source) {
-        Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
-        return source;
-    }
-    transformToString(encoding = "utf-8") {
-        if (encoding === "base64") {
-            return toBase64(this);
-        }
-        return toUtf8(this);
-    }
-}
-
 const ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function () { };
 class ChecksumStream extends ReadableStreamRef {
 }
@@ -1376,7 +1324,11 @@ async function splitStream(stream) {
 }
 
 const no = Symbol.for("node-only");
+const fromArrayBuffer = no;
+const fromString = no;
 const Hash = no;
+class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 const v4 = bindV4(_getRandomValues);
 const generateIdempotencyToken = v4;
@@ -1409,7 +1361,7 @@ exports.expectShort = expectShort;
 exports.expectString = expectString;
 exports.expectUnion = expectUnion;
 exports.fromArrayBuffer = fromArrayBuffer;
-exports.fromBase64 = fromBase64$1;
+exports.fromBase64 = fromBase64;
 exports.fromHex = fromHex;
 exports.fromString = fromString;
 exports.fromUtf8 = fromUtf8;
@@ -1446,8 +1398,8 @@ exports.strictParseInt = strictParseInt;
 exports.strictParseInt32 = strictParseInt32;
 exports.strictParseLong = strictParseLong;
 exports.strictParseShort = strictParseShort;
-exports.toBase64 = toBase64$1;
+exports.toBase64 = toBase64;
 exports.toHex = toHex;
 exports.toUint8Array = toUint8Array;
-exports.toUtf8 = toUtf8$1;
+exports.toUtf8 = toUtf8;
 exports.v4 = v4;