@cdklabs/cdk-construct-connect-datalake 0.0.14 → 0.0.16

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

@@ -1,4 +1,4 @@
-const { nv, toUtf8, fromUtf8, NumericValue, calculateBodyLength, _parseEpochTimestamp, fromBase64, generateIdempotencyToken } = require("@smithy/core/serde");
+const { nv, NumericValue, calculateBodyLength, _parseEpochTimestamp, fromBase64, generateIdempotencyToken } = require("@smithy/core/serde");
 const { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require("@smithy/core/protocols");
 const { NormalizedSchema, deref, TypeRegistry } = require("@smithy/core/schema");
 const { getSmithyContext } = require("@smithy/core/transport");
@@ -29,14 +29,15 @@ function tag(data) {
     return data;
 }
 
-const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
 const USE_BUFFER$1 = typeof Buffer !== "undefined";
+const textDecoder = new TextDecoder();
 let payload = alloc(0);
+let isBuffer = false;
 let dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
-const textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
 let _offset = 0;
 function setPayload(bytes) {
     payload = bytes;
+    isBuffer = USE_BUFFER$1 && payload instanceof Buffer;
     dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
 }
 function decode(at, to) {
@@ -45,10 +46,13 @@ function decode(at, to) {
     }
     const major = (payload[at] & 0b1110_0000) >> 5;
     const minor = payload[at] & 0b0001_1111;
+    if (minor === minorIndefinite && 2 <= major && major <= 5) {
+        return decodeIndefinite(at, to);
+    }
     switch (major) {
         case majorUint64:
         case majorNegativeInt64:
-        case majorTag:
+        case majorTag: {
             let unsignedInt;
             let offset;
             if (minor < 24) {
@@ -58,31 +62,43 @@ function decode(at, to) {
             else {
                 switch (minor) {
                     case extendedOneByte:
-                    case extendedFloat16:
-                    case extendedFloat32:
-                    case extendedFloat64:
-                        const countLength = minorValueToArgumentLength[minor];
-                        const countOffset = (countLength + 1);
-                        offset = countOffset;
-                        if (to - at < countOffset) {
-                            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
+                        if (to - at < 2) {
+                            overflow(1);
                         }
-                        const countIndex = at + 1;
-                        if (countLength === 1) {
-                            unsignedInt = payload[countIndex];
+                        unsignedInt = payload[at + 1];
+                        offset = 2;
+                        break;
+                    case extendedFloat16:
+                        if (to - at < 3) {
+                            overflow(2);
                         }
-                        else if (countLength === 2) {
-                            unsignedInt = dataView$1.getUint16(countIndex);
+                        unsignedInt = dataView$1.getUint16(at + 1);
+                        offset = 3;
+                        break;
+                    case extendedFloat32:
+                        if (to - at < 5) {
+                            overflow(4);
                         }
-                        else if (countLength === 4) {
-                            unsignedInt = dataView$1.getUint32(countIndex);
+                        unsignedInt = dataView$1.getUint32(at + 1);
+                        offset = 5;
+                        break;
+                    case extendedFloat64:
+                        if (to - at < 9) {
+                            overflow(8);
                         }
-                        else {
-                            unsignedInt = dataView$1.getBigUint64(countIndex);
+                        {
+                            const hi = dataView$1.getUint32(at + 1);
+                            if (hi < 0x00200000) {
+                                unsignedInt = hi * 4294967296 + dataView$1.getUint32(at + 5);
+                            }
+                            else {
+                                unsignedInt = dataView$1.getBigUint64(at + 1);
+                            }
                         }
+                        offset = 9;
                         break;
                     default:
-                        throw new Error(`unexpected minor value ${minor}.`);
+                        unexpectedMinor(minor);
                 }
             }
             if (major === majorUint64) {
@@ -101,234 +117,97 @@ function decode(at, to) {
                 return castBigInt(negativeInt);
             }
             else {
-                if (minor === 2 || minor === 3) {
-                    const length = decodeCount(at + offset, to);
-                    let b = BigInt(0);
-                    const start = at + offset + _offset;
-                    for (let i = start; i < start + length; ++i) {
-                        b = (b << BigInt(8)) | BigInt(payload[i]);
-                    }
-                    _offset = offset + _offset + length;
-                    return minor === 3 ? -b - BigInt(1) : b;
-                }
-                else if (minor === 4) {
-                    const decimalFraction = decode(at + offset, to);
-                    const [exponent, mantissa] = decimalFraction;
-                    const normalizer = mantissa < 0 ? -1 : 1;
-                    const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
-                    let numericString;
-                    const sign = mantissa < 0 ? "-" : "";
-                    numericString =
-                        exponent === 0
-                            ? mantissaStr
-                            : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-                    numericString = numericString.replace(/^0+/g, "");
-                    if (numericString === "") {
-                        numericString = "0";
-                    }
-                    if (numericString[0] === ".") {
-                        numericString = "0" + numericString;
-                    }
-                    numericString = sign + numericString;
-                    _offset = offset + _offset;
-                    return nv(numericString);
-                }
-                else {
-                    const value = decode(at + offset, to);
-                    const valueOffset = _offset;
-                    _offset = offset + valueOffset;
-                    return tag({ tag: castBigInt(unsignedInt), value });
-                }
+                return decodeTagValue(at, to, minor, unsignedInt, offset);
             }
+        }
         case majorUtf8String:
+            return decodeUtf8String(at, to);
         case majorMap:
+            return decodeMap(at, to);
         case majorList:
+            return decodeList(at, to);
         case majorUnstructuredByteString:
-            if (minor === minorIndefinite) {
-                switch (major) {
-                    case majorUtf8String:
-                        return decodeUtf8StringIndefinite(at, to);
-                    case majorMap:
-                        return decodeMapIndefinite(at, to);
-                    case majorList:
-                        return decodeListIndefinite(at, to);
-                    case majorUnstructuredByteString:
-                        return decodeUnstructuredByteStringIndefinite(at, to);
-                }
-            }
-            else {
-                switch (major) {
-                    case majorUtf8String:
-                        return decodeUtf8String(at, to);
-                    case majorMap:
-                        return decodeMap(at, to);
-                    case majorList:
-                        return decodeList(at, to);
-                    case majorUnstructuredByteString:
-                        return decodeUnstructuredByteString(at, to);
-                }
-            }
+            return decodeUnstructuredByteString(at, to);
         default:
             return decodeSpecial(at, to);
     }
 }
-function bytesToUtf8(bytes, at, to) {
-    if (USE_BUFFER$1 && bytes.constructor?.name === "Buffer") {
-        return bytes.toString("utf-8", at, to);
-    }
-    if (textDecoder) {
-        return textDecoder.decode(bytes.subarray(at, to));
-    }
-    return toUtf8(bytes.subarray(at, to));
-}
-function demote(bigInteger) {
-    const num = Number(bigInteger);
-    if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
-        console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
+function decodeIndefinite(at, to) {
+    const major = (payload[at] & 0b1110_0000) >> 5;
+    const minor = payload[at] & 0b0001_1111;
+    if (minor === minorIndefinite) {
+        switch (major) {
+            case majorUtf8String:
+                return decodeUtf8StringIndefinite(at, to);
+            case majorMap:
+                return decodeMapIndefinite(at, to);
+            case majorList:
+                return decodeListIndefinite(at, to);
+            case majorUnstructuredByteString:
+                return decodeUnstructuredByteStringIndefinite(at, to);
+        }
     }
-    return num;
 }
-const minorValueToArgumentLength = {
-    [extendedOneByte]: 1,
-    [extendedFloat16]: 2,
-    [extendedFloat32]: 4,
-    [extendedFloat64]: 8,
-};
 function bytesToFloat16(a, b) {
     const sign = a >> 7;
     const exponent = (a & 0b0111_1100) >> 2;
     const fraction = ((a & 0b0000_0011) << 8) | b;
     const scalar = sign === 0 ? 1 : -1;
-    let exponentComponent;
-    let summation;
     if (exponent === 0b00000) {
-        if (fraction === 0b00000_00000) {
+        if (fraction === 0) {
             return 0;
         }
-        else {
-            exponentComponent = Math.pow(2, 1 - 15);
-            summation = 0;
-        }
+        return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
     }
     else if (exponent === 0b11111) {
-        if (fraction === 0b00000_00000) {
+        if (fraction === 0) {
             return scalar * Infinity;
         }
-        else {
-            return NaN;
-        }
+        return NaN;
     }
-    else {
-        exponentComponent = Math.pow(2, exponent - 15);
-        summation = 1;
-    }
-    summation += fraction / 1024;
-    return scalar * (exponentComponent * summation);
+    return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
 }
-function decodeCount(at, to) {
-    const minor = payload[at] & 0b0001_1111;
-    if (minor < 24) {
-        _offset = 1;
-        return minor;
-    }
-    if (minor === extendedOneByte ||
-        minor === extendedFloat16 ||
-        minor === extendedFloat32 ||
-        minor === extendedFloat64) {
-        const countLength = minorValueToArgumentLength[minor];
-        _offset = (countLength + 1);
-        if (to - at < _offset) {
-            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
-        }
-        const countIndex = at + 1;
-        if (countLength === 1) {
-            return payload[countIndex];
-        }
-        else if (countLength === 2) {
-            return dataView$1.getUint16(countIndex);
-        }
-        else if (countLength === 4) {
-            return dataView$1.getUint32(countIndex);
-        }
-        return demote(dataView$1.getBigUint64(countIndex));
+function decodeMap(at, to) {
+    const mapDataLength = decodeCount(at, to);
+    if (mapDataLength < 15) {
+        return decodeMapSmall(at, to, mapDataLength);
     }
-    throw new Error(`unexpected minor value ${minor}.`);
+    return decodeMapLarge(at, to, mapDataLength);
 }
-function decodeUtf8String(at, to) {
-    const length = decodeCount(at, to);
+function decodeMapLarge(at, to, mapDataLength) {
     const offset = _offset;
     at += offset;
-    if (to - at < length) {
-        throw new Error(`string len ${length} greater than remaining buf len.`);
-    }
-    const value = bytesToUtf8(payload, at, at + length);
-    _offset = offset + length;
-    return value;
-}
-function decodeUtf8StringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            return bytesToUtf8(data, 0, data.length);
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        const minor = payload[at] & 0b0001_1111;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} in indefinite string.`);
-        }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
+    const base = at;
+    const map = Object.create(null);
+    for (let i = 0; i < mapDataLength; ++i) {
+        const key = decodeUtf8String(at, to);
+        at += _offset;
+        const valMajor = (payload[at] & 0b1110_0000) >> 5;
+        if (valMajor === majorUtf8String) {
+            map[key] = decodeUtf8String(at, to);
         }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
+        else {
+            map[key] = decode(at, to);
         }
+        at += _offset;
     }
-    throw new Error("expected break marker.");
+    _offset = offset + (at - base);
+    Object.setPrototypeOf(map, Object.prototype);
+    return map;
 }
-function decodeUnstructuredByteString(at, to) {
-    const length = decodeCount(at, to);
+function decodeMapSmall(at, to, mapDataLength) {
     const offset = _offset;
     at += offset;
-    if (to - at < length) {
-        throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`);
-    }
-    const value = payload.subarray(at, at + length);
-    _offset = offset + length;
-    return value;
-}
-function decodeUnstructuredByteStringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            return data;
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        const minor = payload[at] & 0b0001_1111;
-        if (major !== majorUnstructuredByteString) {
-            throw new Error(`unexpected major type ${major} in indefinite string.`);
-        }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
-        }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
-        }
+    const base = at;
+    const map = {};
+    for (let i = 0; i < mapDataLength; ++i) {
+        const key = decodeUtf8String(at, to);
+        at += _offset;
+        map[key] = decode(at, to);
+        at += _offset;
     }
-    throw new Error("expected break marker.");
+    _offset = offset + (at - base);
+    return map;
 }
 function decodeList(at, to) {
     const listDataLength = decodeCount(at, to);
@@ -337,75 +216,115 @@ function decodeList(at, to) {
     const base = at;
     const list = Array(listDataLength);
     for (let i = 0; i < listDataLength; ++i) {
-        const item = decode(at, to);
-        const itemOffset = _offset;
-        list[i] = item;
-        at += itemOffset;
+        list[i] = decode(at, to);
+        at += _offset;
     }
     _offset = offset + (at - base);
     return list;
 }
-function decodeListIndefinite(at, to) {
-    at += 1;
-    const list = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return list;
+function decodeUtf8String(at, to) {
+    const length = decodeCount(at, to);
+    const offset = _offset;
+    at += offset;
+    if (to - at < length) {
+        overflow(length);
+    }
+    _offset = offset + length;
+    if (length < 24) {
+        return decodeUtf8StringCached(at, length);
+    }
+    if (isBuffer) {
+        return payload.toString("utf-8", at, at + length);
+    }
+    return textDecoder.decode(payload.subarray(at, at + length));
+}
+const stringCache = new Array(2048);
+const stringCacheEpochs = new Uint16Array(2048);
+let cacheEpoch = 0;
+function advanceDecodingEpoch() {
+    cacheEpoch = (cacheEpoch + 1) & 0b1111_1111_1111_1111;
+}
+function decodeUtf8StringCached(at, length) {
+    let h = length;
+    for (let i = 0; i < length; ++i) {
+        h = (h * 31 + payload[at + i]) | 0;
+    }
+    const slot = (h >>> 0) & 2047;
+    const cached = stringCache[slot];
+    if (cached !== undefined) {
+        if (cached.length === length) {
+            let match = true;
+            for (let i = 0; i < length; ++i) {
+                if (cached.charCodeAt(i) !== payload[at + i]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                stringCacheEpochs[slot] = cacheEpoch;
+                return cached;
+            }
         }
-        const item = decode(at, to);
-        const n = _offset;
-        at += n;
-        list.push(item);
     }
-    throw new Error("expected break marker.");
+    const result = isBuffer
+        ? payload.toString("utf-8", at, at + length)
+        : textDecoder.decode(payload.subarray(at, at + length));
+    if (stringCacheEpochs[slot] !== cacheEpoch) {
+        stringCache[slot] = result;
+        stringCacheEpochs[slot] = cacheEpoch;
+    }
+    return result;
 }
-function decodeMap(at, to) {
-    const mapDataLength = decodeCount(at, to);
+function decodeUnstructuredByteString(at, to) {
+    const length = decodeCount(at, to);
     const offset = _offset;
     at += offset;
-    const base = at;
-    const map = {};
-    for (let i = 0; i < mapDataLength; ++i) {
-        if (at >= to) {
-            throw new Error("unexpected end of map payload.");
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
-        }
-        const key = decode(at, to);
-        at += _offset;
-        const value = decode(at, to);
-        at += _offset;
-        map[key] = value;
+    if (to - at < length) {
+        overflow(length);
     }
-    _offset = offset + (at - base);
-    return map;
+    const value = payload.subarray(at, at + length);
+    _offset = offset + length;
+    return value;
 }
-function decodeMapIndefinite(at, to) {
-    at += 1;
-    const base = at;
-    const map = {};
-    for (; at < to;) {
-        if (at >= to) {
-            throw new Error("unexpected end of map payload.");
+function decodeTagValue(at, to, minor, unsignedInt, offset) {
+    if (minor === 2 || minor === 3) {
+        const length = decodeCount(at + offset, to);
+        let b = BigInt(0);
+        const start = at + offset + _offset;
+        for (let i = start; i < start + length; ++i) {
+            b = (b << BigInt(8)) | BigInt(payload[i]);
         }
-        if (payload[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return map;
+        _offset = offset + _offset + length;
+        return minor === 3 ? -b - BigInt(1) : b;
+    }
+    else if (minor === 4) {
+        const decimalFraction = decode(at + offset, to);
+        const [exponent, mantissa] = decimalFraction;
+        const normalizer = mantissa < 0 ? -1 : 1;
+        const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
+        let numericString;
+        const sign = mantissa < 0 ? "-" : "";
+        numericString =
+            exponent === 0
+                ? mantissaStr
+                : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
+        numericString = numericString.replace(/^0+/g, "");
+        if (numericString === "") {
+            numericString = "0";
         }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} for map key.`);
+        if (numericString[0] === ".") {
+            numericString = "0" + numericString;
         }
-        const key = decode(at, to);
-        at += _offset;
-        const value = decode(at, to);
-        at += _offset;
-        map[key] = value;
+        numericString = sign + numericString;
+        _offset = offset + _offset;
+        return nv(numericString);
+    }
+    else {
+        const value = decode(at + offset, to);
+        const valueOffset = _offset;
+        _offset = offset + valueOffset;
+        return tag({ tag: castBigInt(unsignedInt), value });
     }
-    throw new Error("expected break marker.");
 }
 function decodeSpecial(at, to) {
     const minor = payload[at] & 0b0001_1111;
@@ -439,98 +358,216 @@ function decodeSpecial(at, to) {
             _offset = 9;
             return dataView$1.getFloat64(at + 1);
         default:
-            throw new Error(`unexpected minor value ${minor}.`);
+            unexpectedMinor(minor);
     }
 }
-function castBigInt(bigInt) {
-    if (typeof bigInt === "number") {
-        return bigInt;
+function decodeCount(at, to) {
+    const minor = payload[at] & 0b0001_1111;
+    if (minor < 24) {
+        _offset = 1;
+        return minor;
     }
-    const num = Number(bigInt);
-    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
-        return num;
+    switch (minor) {
+        case extendedOneByte:
+            if (to - at < 2) {
+                overflow(1);
+            }
+            _offset = 2;
+            return payload[at + 1];
+        case extendedFloat16:
+            if (to - at < 3) {
+                overflow(2);
+            }
+            _offset = 3;
+            return dataView$1.getUint16(at + 1);
+        case extendedFloat32:
+            if (to - at < 5) {
+                overflow(4);
+            }
+            _offset = 5;
+            return dataView$1.getUint32(at + 1);
+        case extendedFloat64:
+            if (to - at < 9) {
+                overflow(8);
+            }
+            _offset = 9;
+            return demote(dataView$1.getBigUint64(at + 1));
+        default:
+            unexpectedMinor(minor);
     }
-    return bigInt;
 }
-
-const USE_BUFFER = typeof Buffer !== "undefined";
-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);
+function decodeMapIndefinite(at, to) {
+    at += 1;
+    const base = at;
+    const map = {};
+    for (; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            _offset = at - base + 2;
+            return map;
         }
+        const key = decodeUtf8String(at, to);
+        at += _offset;
+        map[key] = decode(at, to);
+        at += _offset;
     }
+    throw new Error("expected break marker.");
 }
-function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
-    return out;
+function decodeListIndefinite(at, to) {
+    at += 1;
+    const list = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            _offset = at - base + 2;
+            return list;
+        }
+        list.push(decode(at, to));
+        at += _offset;
+    }
+    throw new Error("expected break marker.");
 }
-function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
+function decodeUtf8StringIndefinite(at, to) {
+    at += 1;
+    const vector = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            const data = alloc(vector.length);
+            data.set(vector, 0);
+            _offset = at - base + 2;
+            if (USE_BUFFER$1) {
+                return data.toString("utf-8", 0, data.length);
+            }
+            return textDecoder.decode(data);
         }
-        else {
-            data.set(old, 0);
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
+        if (major !== majorUtf8String) {
+            unexpectedMajorInIndefiniteString(major);
+        }
+        if (minor === minorIndefinite) {
+            throw new Error("nested indefinite string.");
+        }
+        const bytes = decodeUnstructuredByteString(at, to);
+        const length = _offset;
+        at += length;
+        for (let i = 0; i < bytes.length; ++i) {
+            vector.push(bytes[i]);
         }
     }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    throw new Error("expected break marker.");
 }
-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;
+function decodeUnstructuredByteStringIndefinite(at, to) {
+    at += 1;
+    const vector = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            const data = alloc(vector.length);
+            data.set(vector, 0);
+            _offset = at - base + 2;
+            return data;
+        }
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
+        if (major !== majorUnstructuredByteString) {
+            unexpectedMajorInIndefiniteString(major);
+        }
+        if (minor === minorIndefinite) {
+            throw new Error("nested indefinite string.");
+        }
+        const bytes = decodeUnstructuredByteString(at, to);
+        const length = _offset;
+        at += length;
+        for (let i = 0; i < bytes.length; ++i) {
+            vector.push(bytes[i]);
+        }
     }
-    else if (value < 1 << 16) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        dataView.setUint16(cursor, value);
-        cursor += 2;
+    throw new Error("expected break marker.");
+}
+function castBigInt(bigInt) {
+    if (typeof bigInt === "number") {
+        return bigInt;
     }
-    else if (value < 2 ** 32) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
+    const num = Number(bigInt);
+    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
+        return num;
     }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-        cursor += 8;
+    return bigInt;
+}
+function demote(bigInteger) {
+    const num = Number(bigInteger);
+    if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
+        console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
     }
+    return num;
+}
+function overflow(n) {
+    throw new Error(`length ${n} greater than remaining buf len.`);
+}
+function unexpectedMinor(minor) {
+    throw new Error(`unexpected minor value ${minor}.`);
 }
+function unexpectedMajorInIndefiniteString(major) {
+    throw new Error(`unexpected major type ${major} in indefinite string.`);
+}
+
+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 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;
@@ -545,7 +582,7 @@ 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;
@@ -554,7 +591,10 @@ 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;
@@ -568,28 +608,16 @@ 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);
@@ -600,14 +628,9 @@ 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;
             }
@@ -625,15 +648,16 @@ 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;
@@ -644,9 +668,9 @@ 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]) {
@@ -660,24 +684,147 @@ 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.`);
     }
 }
+function advanceEncodingEpoch() {
+    encodeCacheEpoch = (encodeCacheEpoch + 1) & 0b1111_1111_1111_1111;
+    encodeCacheSaturated = false;
+}
+function toUint8Array() {
+    const out = alloc(cursor);
+    out.set(data.subarray(0, cursor), 0);
+    cursor = 0;
+    return out;
+}
+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;
+    }
+}
 
 const cbor = {
     deserialize(payload) {
+        advanceDecodingEpoch();
         setPayload(payload);
         return decode(0, payload.length);
     },
     serialize(input) {
+        advanceEncodingEpoch();
         try {
             encode(input);
             return toUint8Array();