@cdklabs/cdk-ssm-documents 0.0.65 → 0.0.67

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -1,83 +1,64 @@
-import { NumericValue, fromUtf8 } from "@smithy/core/serde";
+import { NumericValue } from "@smithy/core/serde";
 import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
 const USE_BUFFER = typeof Buffer !== "undefined";
+const encodeStringCache = new Map();
+let encodeCacheEpoch = 0;
+let encodeCacheSaturated = false;
 const initialSize = 2048;
 let data = alloc(initialSize);
 let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
 let cursor = 0;
-function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor;
-    if (remaining < bytes) {
-        if (cursor < 16_000_000) {
-            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-        }
-        else {
-            resize(data.byteLength + bytes + 16_000_000);
-        }
-    }
-}
-export function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
-    return out;
-}
-export function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
-        }
-        else {
-            data.set(old, 0);
-        }
-    }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-}
-function encodeHeader(major, value) {
-    if (value < 24) {
-        data[cursor++] = (major << 5) | value;
-    }
-    else if (value < 1 << 8) {
-        data[cursor++] = (major << 5) | 24;
-        data[cursor++] = value;
-    }
-    else if (value < 1 << 16) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        dataView.setUint16(cursor, value);
-        cursor += 2;
-    }
-    else if (value < 2 ** 32) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-        cursor += 8;
-    }
-}
 export function encode(_input) {
     const encodeStack = [_input];
     while (encodeStack.length) {
         const input = encodeStack.pop();
-        ensureSpace(typeof input === "string" ? input.length * 4 : 64);
         if (typeof input === "string") {
+            const len = input.length;
             if (USE_BUFFER) {
-                encodeHeader(majorUtf8String, Buffer.byteLength(input));
-                cursor += data.write(input, cursor);
+                ensureSpace(len * 3 + 9);
+                if (len > 23) {
+                    encodeHeader(majorUtf8String, Buffer.byteLength(input));
+                    cursor += data.write(input, cursor);
+                }
+                else {
+                    encodeStringCached(input);
+                }
             }
             else {
-                const bytes = fromUtf8(input);
-                encodeHeader(majorUtf8String, bytes.byteLength);
-                data.set(bytes, cursor);
-                cursor += bytes.byteLength;
+                const maxBytes = len * 3;
+                ensureSpace(maxBytes + 9);
+                const headerPos = cursor;
+                const result = new TextEncoder().encodeInto(input, data.subarray(cursor + 9));
+                const byteLen = result.written;
+                let headerSize;
+                if (byteLen < 24) {
+                    headerSize = 1;
+                }
+                else if (byteLen < 256) {
+                    headerSize = 2;
+                }
+                else if (byteLen < 65536) {
+                    headerSize = 3;
+                }
+                else if (byteLen < 4294967296) {
+                    headerSize = 5;
+                }
+                else {
+                    headerSize = 9;
+                }
+                if (headerSize < 9) {
+                    data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
+                }
+                cursor = headerPos;
+                encodeInteger(majorUtf8String, byteLen);
+                cursor += byteLen;
             }
             continue;
         }
-        else if (typeof input === "number") {
+        if (data.byteLength - cursor < 9) {
+            ensureSpace(64);
+        }
+        if (typeof input === "number") {
             if (Number.isInteger(input)) {
                 const nonNegative = input >= 0;
                 const major = nonNegative ? majorUint64 : majorNegativeInt64;
@@ -92,7 +73,7 @@ export function encode(_input) {
                 else if (value < 65536) {
                     data[cursor++] = (major << 5) | extendedFloat16;
                     data[cursor++] = value >> 8;
-                    data[cursor++] = value;
+                    data[cursor++] = value & 0xff;
                 }
                 else if (value < 4294967296) {
                     data[cursor++] = (major << 5) | extendedFloat32;
@@ -101,7 +82,10 @@ export function encode(_input) {
                 }
                 else {
                     data[cursor++] = (major << 5) | extendedFloat64;
-                    dataView.setBigUint64(cursor, BigInt(value));
+                    const hi = (value / 4294967296) | 0;
+                    const lo = (value - hi * 4294967296) | 0;
+                    dataView.setUint32(cursor, hi);
+                    dataView.setUint32(cursor + 4, lo);
                     cursor += 8;
                 }
                 continue;
@@ -115,28 +99,16 @@ export function encode(_input) {
             const nonNegative = input >= 0;
             const major = nonNegative ? majorUint64 : majorNegativeInt64;
             const value = nonNegative ? input : -input - BigInt(1);
-            const n = Number(value);
-            if (n < 24) {
-                data[cursor++] = (major << 5) | n;
-            }
-            else if (n < 256) {
-                data[cursor++] = (major << 5) | 24;
-                data[cursor++] = n;
-            }
-            else if (n < 65536) {
-                data[cursor++] = (major << 5) | extendedFloat16;
-                data[cursor++] = n >> 8;
-                data[cursor++] = n & 0b1111_1111;
-            }
-            else if (n < 4294967296) {
-                data[cursor++] = (major << 5) | extendedFloat32;
-                dataView.setUint32(cursor, n);
-                cursor += 4;
-            }
-            else if (value < BigInt("18446744073709551616")) {
-                data[cursor++] = (major << 5) | extendedFloat64;
-                dataView.setBigUint64(cursor, value);
-                cursor += 8;
+            if (value < BigInt("18446744073709551616")) {
+                const n = Number(value);
+                if (n < 4294967296) {
+                    encodeInteger(major, n);
+                }
+                else {
+                    data[cursor++] = (major << 5) | extendedFloat64;
+                    dataView.setBigUint64(cursor, value);
+                    cursor += 8;
+                }
             }
             else {
                 const binaryBigInt = value.toString(2);
@@ -147,14 +119,9 @@ export function encode(_input) {
                     bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
                     b >>= BigInt(8);
                 }
-                ensureSpace(bigIntBytes.byteLength * 2);
+                ensureSpace(bigIntBytes.byteLength * 2 + 16);
                 data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
-                if (USE_BUFFER) {
-                    encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
-                }
-                else {
-                    encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
-                }
+                encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
                 data.set(bigIntBytes, cursor);
                 cursor += bigIntBytes.byteLength;
             }
@@ -172,15 +139,16 @@ export function encode(_input) {
             throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
         }
         else if (Array.isArray(input)) {
+            encodeInteger(majorList, input.length);
+            ensureSpace(input.length * 9 + 64);
             for (let i = input.length - 1; i >= 0; --i) {
                 encodeStack.push(input[i]);
             }
-            encodeHeader(majorList, input.length);
             continue;
         }
         else if (typeof input.byteLength === "number") {
-            ensureSpace(input.length * 2);
-            encodeHeader(majorUnstructuredByteString, input.length);
+            ensureSpace(input.length * 2 + 9);
+            encodeInteger(majorUnstructuredByteString, input.length);
             data.set(input, cursor);
             cursor += input.byteLength;
             continue;
@@ -191,9 +159,9 @@ export function encode(_input) {
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
                 data[cursor++] = 0b110_00100;
+                encodeInteger(majorList, 2);
                 encodeStack.push(mantissa);
                 encodeStack.push(exponent);
-                encodeHeader(majorList, 2);
                 continue;
             }
             if (input[tagSymbol]) {
@@ -207,14 +175,135 @@ export function encode(_input) {
                 }
             }
             const keys = Object.keys(input);
-            for (let i = keys.length - 1; i >= 0; --i) {
-                const key = keys[i];
-                encodeStack.push(input[key]);
-                encodeStack.push(key);
+            const len = keys.length;
+            encodeInteger(majorMap, len);
+            for (let i = len - 1; i >= 0; --i) {
+                encodeStack.push(input[keys[i]]);
+                encodeStack.push(keys[i]);
             }
-            encodeHeader(majorMap, keys.length);
             continue;
         }
         throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
     }
 }
+export function advanceEncodingEpoch() {
+    encodeCacheEpoch = (encodeCacheEpoch + 1) & 0b1111_1111_1111_1111;
+    encodeCacheSaturated = false;
+}
+export function toUint8Array() {
+    const out = alloc(cursor);
+    out.set(data.subarray(0, cursor), 0);
+    cursor = 0;
+    return out;
+}
+export function resize(size) {
+    const old = data;
+    data = alloc(size);
+    if (old) {
+        if (old.copy) {
+            old.copy(data, 0, 0, old.byteLength);
+        }
+        else {
+            data.set(old, 0);
+        }
+    }
+    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+function encodeStringCached(input) {
+    const cached = encodeStringCache.get(input);
+    if (cached !== undefined) {
+        data.set(cached.bytes, cursor);
+        cursor += cached.bytes.length;
+        cached.epoch = encodeCacheEpoch;
+        return;
+    }
+    const start = cursor;
+    const byteLen = Buffer.byteLength(input);
+    encodeInteger(majorUtf8String, byteLen);
+    cursor += data.write(input, cursor);
+    const bytes = Uint8Array.prototype.slice.call(data, start, cursor);
+    if (encodeStringCache.size >= 2048) {
+        if (encodeCacheSaturated) {
+            return;
+        }
+        let evicted = 0;
+        for (const [key, entry] of encodeStringCache) {
+            if (evicted >= 1024) {
+                break;
+            }
+            if (entry.epoch !== encodeCacheEpoch) {
+                encodeStringCache.delete(key);
+                evicted++;
+            }
+        }
+        if (evicted === 0) {
+            encodeCacheSaturated = true;
+            return;
+        }
+    }
+    if (encodeStringCache.size < 2048) {
+        encodeStringCache.set(input, { epoch: encodeCacheEpoch, bytes });
+    }
+}
+function ensureSpace(bytes) {
+    const remaining = data.byteLength - cursor;
+    if (remaining < bytes) {
+        if (cursor < 16_000_000) {
+            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
+        }
+        else {
+            resize(data.byteLength + bytes + 16_000_000);
+        }
+    }
+}
+function encodeHeader(major, value) {
+    if (value < 24) {
+        data[cursor++] = (major << 5) | value;
+    }
+    else if (value < 256) {
+        data[cursor++] = (major << 5) | 24;
+        data[cursor++] = value;
+    }
+    else if (value < 65536) {
+        data[cursor++] = (major << 5) | extendedFloat16;
+        dataView.setUint16(cursor, value);
+        cursor += 2;
+    }
+    else if (value < 4294967296) {
+        data[cursor++] = (major << 5) | extendedFloat32;
+        dataView.setUint32(cursor, value);
+        cursor += 4;
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
+        cursor += 8;
+    }
+}
+function encodeInteger(major, value) {
+    if (value < 24) {
+        data[cursor++] = (major << 5) | value;
+    }
+    else if (value < 256) {
+        data[cursor++] = (major << 5) | 24;
+        data[cursor++] = value;
+    }
+    else if (value < 65536) {
+        data[cursor++] = (major << 5) | extendedFloat16;
+        data[cursor++] = value >> 8;
+        data[cursor++] = value & 0xff;
+    }
+    else if (value < 4294967296) {
+        data[cursor++] = (major << 5) | extendedFloat32;
+        dataView.setUint32(cursor, value);
+        cursor += 4;
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        const hi = (value / 4294967296) | 0;
+        const lo = (value - hi * 4294967296) | 0;
+        dataView.setUint32(cursor, hi);
+        dataView.setUint32(cursor + 4, lo);
+        cursor += 8;
+    }
+}

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

@@ -1,11 +1,13 @@
-import { decode, setPayload } from "./cbor-decode";
-import { encode, resize, toUint8Array } from "./cbor-encode";
+import { advanceDecodingEpoch, decode, setPayload } from "./cbor-decode";
+import { advanceEncodingEpoch, encode, resize, toUint8Array } from "./cbor-encode";
 export const cbor = {
     deserialize(payload) {
+        advanceDecodingEpoch();
         setPayload(payload);
         return decode(0, payload.length);
     },
     serialize(input) {
+        advanceEncodingEpoch();
         try {
             encode(input);
             return toUint8Array();

package/node_modules/@smithy/core/dist-es/submodules/checksum/crc32/Crc32Js.js

@@ -0,0 +1,27 @@
+const CRC32_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; ++i) {
+    let c = i;
+    for (let j = 0; j < 8; ++j) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    CRC32_TABLE[i] = c >>> 0;
+}
+const ONES = 0xffff_ffff;
+export class Crc32Js {
+    digestLength = 4;
+    checksum = ONES;
+    update(data) {
+        for (let i = 0; i < data.length; ++i) {
+            this.checksum = (this.checksum >>> 8) ^ CRC32_TABLE[(this.checksum ^ data[i]) & 0xff];
+        }
+    }
+    async digest() {
+        const value = (this.checksum ^ ONES) >>> 0;
+        const out = new Uint8Array(4);
+        new DataView(out.buffer).setUint32(0, value, false);
+        return out;
+    }
+    reset() {
+        this.checksum = ONES;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/crc32/Crc32Node.js

@@ -0,0 +1,21 @@
+import * as zlib from "node:zlib";
+import { Crc32Js } from "./Crc32Js";
+const zlibCrc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : undefined;
+export const Crc32Node = zlibCrc32 ? buildNativeClass(zlibCrc32) : Crc32Js;
+function buildNativeClass(nativeCrc32) {
+    return class Crc32Node {
+        digestLength = 4;
+        value = 0;
+        update(data) {
+            this.value = nativeCrc32(data, this.value);
+        }
+        async digest() {
+            const out = new Uint8Array(4);
+            new DataView(out.buffer).setUint32(0, this.value >>> 0, false);
+            return out;
+        }
+        reset() {
+            this.value = 0;
+        }
+    };
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/index.browser.js

@@ -2,5 +2,11 @@ const no = Symbol.for("node-only");
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export const fileStreamHasher = no;
 export const readableStreamHasher = no;
-export { Md5 } from "./md5-js/md5";
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export const Md5Node = no;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export const Crc32Node = no;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export const Sha256Node = no;
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-es/submodules/checksum/index.js

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export { fileStreamHasher } from "./hash-stream-node/fileStreamHasher";
 export { readableStreamHasher } from "./hash-stream-node/readableStreamHasher";
-export { Md5 } from "./md5-js/md5";
+export { Md5Js } from "./md5/Md5Js";
+export { Md5Node, Md5Node as Md5 } from "./md5/Md5Node";
+export { Crc32Js } from "./crc32/Crc32Js";
+export { Crc32Node, Crc32Node as Crc32 } from "./crc32/Crc32Node";
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256Node, Sha256Node as Sha256 } from "./sha256/Sha256Node";
+export { Sha256WebCrypto } from "./sha256/Sha256WebCrypto";
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-es/submodules/checksum/index.native.js

@@ -2,5 +2,11 @@ const no = Symbol.for("node-only");
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export const fileStreamHasher = no;
 export const readableStreamHasher = no;
-export { Md5 } from "./md5-js/md5";
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export const Md5Node = no;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export const Crc32Node = no;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export const Sha256Node = no;
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader.native";

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5/Md5Js.js

@@ -0,0 +1,92 @@
+import { toUint8Array } from "@smithy/core/serde";
+export class Md5Js {
+    digestLength = 16;
+    state = Uint32Array.from(INIT);
+    writeBuffer = new DataView(new ArrayBuffer(64));
+    bufferLength = 0;
+    bytesHashed = 0;
+    update(sourceData) {
+        const data = toUint8Array(sourceData);
+        let pos = 0;
+        let len = data.byteLength;
+        this.bytesHashed += len;
+        while (len > 0) {
+            this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
+            --len;
+            if (this.bufferLength === 64) {
+                compress(this.state, this.writeBuffer);
+                this.bufferLength = 0;
+            }
+        }
+    }
+    async digest() {
+        const state = Uint32Array.from(this.state);
+        const buf = new DataView(this.writeBuffer.buffer.slice(0));
+        let bufLen = this.bufferLength;
+        const bits = this.bytesHashed * 8;
+        buf.setUint8(bufLen++, 0x80);
+        if (this.bufferLength % 64 >= 56) {
+            for (let i = bufLen; i < 64; ++i) {
+                buf.setUint8(i, 0);
+            }
+            compress(state, buf);
+            bufLen = 0;
+        }
+        for (let i = bufLen; i < 56; ++i) {
+            buf.setUint8(i, 0);
+        }
+        buf.setUint32(56, bits >>> 0, true);
+        buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
+        compress(state, buf);
+        const out = new Uint8Array(16);
+        const view = new DataView(out.buffer);
+        for (let i = 0; i < 4; ++i) {
+            view.setUint32(i * 4, state[i], true);
+        }
+        return out;
+    }
+    reset() {
+        this.state.set(INIT);
+        this.writeBuffer = new DataView(new ArrayBuffer(64));
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+    }
+}
+const INIT = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
+const M = 0xffffffff;
+const S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
+const T = Array.from({ length: 64 }, (_, i) => (Math.abs(Math.sin(i + 1)) * 2 ** 32) >>> 0);
+function compress(state, block) {
+    let a = state[0], b = state[1], c = state[2], d = state[3];
+    for (let i = 0; i < 64; ++i) {
+        let f, g;
+        if (i < 16) {
+            f = (b & c) | (~b & d);
+            g = i;
+        }
+        else if (i < 32) {
+            f = (d & b) | (c & ~d);
+            g = (5 * i + 1) % 16;
+        }
+        else if (i < 48) {
+            f = b ^ c ^ d;
+            g = (3 * i + 5) % 16;
+        }
+        else {
+            f = c ^ (b | ~d);
+            g = (7 * i) % 16;
+        }
+        const x = block.getUint32(g * 4, true);
+        const tmp = d;
+        d = c;
+        c = b;
+        const s = S[(i >> 4) * 4 + (i & 3)];
+        const sum = (((a + f) & M) + ((x + T[i]) & M)) & M;
+        b = (b + (((sum << s) | (sum >>> (32 - s))) >>> 0)) & M;
+        a = tmp;
+    }
+    state[0] = (state[0] + a) & M;
+    state[1] = (state[1] + b) & M;
+    state[2] = (state[2] + c) & M;
+    state[3] = (state[3] + d) & M;
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5/Md5Node.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { toUint8Array } from "@smithy/core/serde";
+import { Md5Js } from "./Md5Js";
+const hasNativeCrypto = (() => {
+    try {
+        createHash("md5");
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+export const Md5Node = hasNativeCrypto ? buildNativeClass() : Md5Js;
+function buildNativeClass() {
+    return class Md5Node {
+        digestLength = 16;
+        hash = createHash("md5");
+        update(data) {
+            this.hash.update(toUint8Array(data));
+        }
+        async digest() {
+            const buf = this.hash.copy().digest();
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        reset() {
+            this.hash = createHash("md5");
+        }
+    };
+}