@mavogel/awscdk-rootmail 0.0.321 → 0.0.323

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

@@ -4,6 +4,7 @@ import { fromBase64 } from "@smithy/util-base64";
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
 export class CborCodec {
+    serdeContext;
     createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -19,6 +20,8 @@ export class CborCodec {
     }
 }
 export class CborShapeSerializer {
+    serdeContext;
+    value;
     setSerdeContext(serdeContext) {
         this.serdeContext = serdeContext;
     }
@@ -96,6 +99,7 @@ export class CborShapeSerializer {
     }
 }
 export class CborShapeDeserializer {
+    serdeContext;
     setSerdeContext(serdeContext) {
         this.serdeContext = serdeContext;
     }

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

@@ -4,11 +4,11 @@ import { getSmithyContext } from "@smithy/util-middleware";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
 export class SmithyRpcV2CborProtocol extends RpcProtocol {
+    codec = new CborCodec();
+    serializer = this.codec.createSerializer();
+    deserializer = this.codec.createDeserializer();
     constructor({ defaultNamespace }) {
         super({ defaultNamespace });
-        this.codec = new CborCodec();
-        this.serializer = this.codec.createSerializer();
-        this.deserializer = this.codec.createDeserializer();
     }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
@@ -70,16 +70,18 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
             if (dataObject.Message) {
                 dataObject.message = dataObject.Message;
             }
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            const baseExceptionSchema = synthetic.getBaseException();
             if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
+                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
                 throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
             }
             throw Object.assign(new Error(errorName), errorMetadata, dataObject);
         }
         const ns = NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
+        const exception = new ErrorCtor(message);
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             output[name] = this.deserializer.readValue(member, dataObject[name]);

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

@@ -15,8 +15,8 @@ export function decode(at, to) {
     if (at >= to) {
         throw new Error("unexpected end of (decode) payload.");
     }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
+    const major = (payload[at] & 0b1110_0000) >> 5;
+    const minor = payload[at] & 0b0001_1111;
     switch (major) {
         case majorUint64:
         case majorNegativeInt64:
@@ -168,13 +168,13 @@ const minorValueToArgumentLength = {
 };
 export function bytesToFloat16(a, b) {
     const sign = a >> 7;
-    const exponent = (a & 124) >> 2;
-    const fraction = ((a & 3) << 8) | b;
+    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 === 0) {
+        if (fraction === 0b00000_00000) {
             return 0;
         }
         else {
@@ -183,7 +183,7 @@ export function bytesToFloat16(a, b) {
         }
     }
     else if (exponent === 0b11111) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return scalar * Infinity;
         }
         else {
@@ -198,7 +198,7 @@ export function bytesToFloat16(a, b) {
     return scalar * (exponentComponent * summation);
 }
 function decodeCount(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     if (minor < 24) {
         _offset = 1;
         return minor;
@@ -241,14 +241,14 @@ function decodeUtf8StringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        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] & 224) >> 5;
-        const minor = payload[at] & 31;
+        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.`);
         }
@@ -279,14 +279,14 @@ function decodeUnstructuredByteStringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             const data = alloc(vector.length);
             data.set(vector, 0);
             _offset = at - base + 2;
             return data;
         }
-        const major = (payload[at] & 224) >> 5;
-        const minor = payload[at] & 31;
+        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.`);
         }
@@ -321,7 +321,7 @@ function decodeListIndefinite(at, to) {
     at += 1;
     const list = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return list;
         }
@@ -342,7 +342,7 @@ function decodeMap(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
         }
@@ -363,11 +363,11 @@ function decodeMapIndefinite(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return map;
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key.`);
         }
@@ -380,7 +380,7 @@ function decodeMapIndefinite(at, to) {
     throw new Error("expected break marker.");
 }
 function decodeSpecial(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     switch (minor) {
         case specialTrue:
         case specialFalse:

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

@@ -9,11 +9,11 @@ let cursor = 0;
 function ensureSpace(bytes) {
     const remaining = data.byteLength - cursor;
     if (remaining < bytes) {
-        if (cursor < 16000000) {
+        if (cursor < 16_000_000) {
             resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
         }
         else {
-            resize(data.byteLength + bytes + 16000000);
+            resize(data.byteLength + bytes + 16_000_000);
         }
     }
 }
@@ -127,7 +127,7 @@ export function encode(_input) {
             else if (n < 65536) {
                 data[cursor++] = (major << 5) | extendedFloat16;
                 data[cursor++] = n >> 8;
-                data[cursor++] = n & 255;
+                data[cursor++] = n & 0b1111_1111;
             }
             else if (n < 4294967296) {
                 data[cursor++] = (major << 5) | extendedFloat32;
@@ -149,7 +149,7 @@ export function encode(_input) {
                     b >>= BigInt(8);
                 }
                 ensureSpace(bigIntBytes.byteLength * 2);
-                data[cursor++] = nonNegative ? 194 : 195;
+                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
                 if (USE_BUFFER) {
                     encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
                 }
@@ -191,7 +191,7 @@ export function encode(_input) {
                 const decimalIndex = input.string.indexOf(".");
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
-                data[cursor++] = 196;
+                data[cursor++] = 0b110_00100;
                 encodeStack.push(mantissa);
                 encodeStack.push(exponent);
                 encodeHeader(majorList, 2);

package/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -1,6 +1,11 @@
 import { SCHEMA } from "@smithy/core/schema";
 import { fromUtf8 } from "@smithy/util-utf8";
 export class EventStreamSerde {
+    marshaller;
+    serializer;
+    deserializer;
+    serdeContext;
+    defaultContentType;
     constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {
         this.marshaller = marshaller;
         this.serializer = serializer;

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

@@ -120,14 +120,13 @@ export class HttpBindingProtocol extends HttpProtocol {
         if (traits.httpQueryParams) {
             for (const [key, val] of Object.entries(data)) {
                 if (!(key in query)) {
-                    this.serializeQuery(NormalizedSchema.of([
-                        ns.getValueSchema(),
-                        {
-                            ...traits,
-                            httpQuery: key,
-                            httpQueryParams: undefined,
-                        },
-                    ]), val, query);
+                    const valueSchema = ns.getValueSchema();
+                    Object.assign(valueSchema.getMergedTraits(), {
+                        ...traits,
+                        httpQuery: key,
+                        httpQueryParams: undefined,
+                    });
+                    this.serializeQuery(valueSchema, val, query);
                 }
             }
             return;
@@ -219,6 +218,7 @@ export class HttpBindingProtocol extends HttpProtocol {
                 if (null != value) {
                     if (memberSchema.isListSchema()) {
                         const headerListValueSchema = memberSchema.getValueSchema();
+                        headerListValueSchema.getMergedTraits().httpHeader = key;
                         let sections;
                         if (headerListValueSchema.isTimestampSchema() &&
                             headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
@@ -229,7 +229,7 @@ export class HttpBindingProtocol extends HttpProtocol {
                         }
                         const list = [];
                         for (const section of sections) {
-                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
+                            list.push(await deserializer.read(headerListValueSchema, section.trim()));
                         }
                         dataObject[memberName] = list;
                     }
@@ -242,7 +242,9 @@ export class HttpBindingProtocol extends HttpProtocol {
                 dataObject[memberName] = {};
                 for (const [header, value] of Object.entries(response.headers)) {
                     if (header.startsWith(memberTraits.httpPrefixHeaders)) {
-                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read([memberSchema.getValueSchema(), { httpHeader: header }], value);
+                        const valueSchema = memberSchema.getValueSchema();
+                        valueSchema.getMergedTraits().httpHeader = header;
+                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
                     }
                 }
             }

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

@@ -1,6 +1,8 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
 export class HttpProtocol {
+    options;
+    serdeContext;
     constructor(options) {
         this.options = options;
     }

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

@@ -4,16 +4,18 @@ export function requestBuilder(input, context) {
     return new RequestBuilder(input, context);
 }
 export class RequestBuilder {
+    input;
+    context;
+    query = {};
+    method = "";
+    headers = {};
+    path = "";
+    body = null;
+    hostname = "";
+    resolvePathStack = [];
     constructor(input, context) {
         this.input = input;
         this.context = context;
-        this.query = {};
-        this.method = "";
-        this.headers = {};
-        this.path = "";
-        this.body = null;
-        this.hostname = "";
-        this.resolvePathStack = [];
     }
     async build() {
         const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js

@@ -4,6 +4,8 @@ import { fromBase64 } from "@smithy/util-base64";
 import { toUtf8 } from "@smithy/util-utf8";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class FromStringShapeDeserializer {
+    settings;
+    serdeContext;
     constructor(settings) {
         this.settings = settings;
     }

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js

@@ -2,6 +2,9 @@ import { NormalizedSchema } from "@smithy/core/schema";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 import { FromStringShapeDeserializer } from "./FromStringShapeDeserializer";
 export class HttpInterceptingShapeDeserializer {
+    codecDeserializer;
+    stringDeserializer;
+    serdeContext;
     constructor(codecDeserializer, codecSettings) {
         this.codecDeserializer = codecDeserializer;
         this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeSerializer.js

@@ -1,6 +1,9 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { ToStringShapeSerializer } from "./ToStringShapeSerializer";
 export class HttpInterceptingShapeSerializer {
+    codecSerializer;
+    stringSerializer;
+    buffer;
     constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
         this.codecSerializer = codecSerializer;
         this.stringSerializer = stringSerializer;

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js

@@ -3,10 +3,11 @@ import { dateToUtcString, LazyJsonString, quoteHeader } from "@smithy/core/serde
 import { toBase64 } from "@smithy/util-base64";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class ToStringShapeSerializer {
+    settings;
+    stringBuffer = "";
+    serdeContext = undefined;
     constructor(settings) {
         this.settings = settings;
-        this.stringBuffer = "";
-        this.serdeContext = undefined;
     }
     setSerdeContext(serdeContext) {
         this.serdeContext = serdeContext;

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

@@ -1,7 +1,12 @@
 export class TypeRegistry {
-    constructor(namespace, schemas = new Map()) {
+    namespace;
+    schemas;
+    exceptions;
+    static registries = new Map();
+    constructor(namespace, schemas = new Map(), exceptions = new Map()) {
         this.namespace = namespace;
         this.schemas = schemas;
+        this.exceptions = exceptions;
     }
     static for(namespace) {
         if (!TypeRegistry.registries.has(namespace)) {
@@ -11,8 +16,7 @@ export class TypeRegistry {
     }
     register(shapeId, schema) {
         const qualifiedName = this.normalizeShapeId(shapeId);
-        const registry = TypeRegistry.for(this.getNamespace(shapeId));
-        registry.schemas.set(qualifiedName, schema);
+        this.schemas.set(qualifiedName, schema);
     }
     getSchema(shapeId) {
         const id = this.normalizeShapeId(shapeId);
@@ -21,6 +25,12 @@ export class TypeRegistry {
         }
         return this.schemas.get(id);
     }
+    registerError(errorSchema, ctor) {
+        this.exceptions.set(errorSchema, ctor);
+    }
+    getErrorCtor(errorSchema) {
+        return this.exceptions.get(errorSchema);
+    }
     getBaseException() {
         for (const [id, schema] of this.schemas.entries()) {
             if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
@@ -32,9 +42,9 @@ export class TypeRegistry {
     find(predicate) {
         return [...this.schemas.values()].find(predicate);
     }
-    destroy() {
-        TypeRegistry.registries.delete(this.namespace);
+    clear() {
         this.schemas.clear();
+        this.exceptions.clear();
     }
     normalizeShapeId(shapeId) {
         if (shapeId.includes("#")) {
@@ -46,4 +56,3 @@ export class TypeRegistry {
         return this.normalizeShapeId(shapeId).split("#")[0];
     }
 }
-TypeRegistry.registries = new Map();

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js

@@ -1,27 +1,15 @@
-import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
 import { StructureSchema } from "./StructureSchema";
 export class ErrorSchema extends StructureSchema {
-    constructor(name, traits, memberNames, memberList, ctor) {
-        super(name, traits, memberNames, memberList);
-        this.name = name;
-        this.traits = traits;
-        this.memberNames = memberNames;
-        this.memberList = memberList;
-        this.ctor = ctor;
-        this.symbol = ErrorSchema.symbol;
-    }
-    static [Symbol.hasInstance](lhs) {
-        const isPrototype = ErrorSchema.prototype.isPrototypeOf(lhs);
-        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-            const err = lhs;
-            return err.symbol === ErrorSchema.symbol;
-        }
-        return isPrototype;
-    }
-}
-ErrorSchema.symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
-export function error(namespace, name, traits = {}, memberNames, memberList, ctor) {
-    const schema = new ErrorSchema(namespace + "#" + name, traits, memberNames, memberList, ctor);
-    TypeRegistry.for(namespace).register(name, schema);
-    return schema;
+    static symbol = Symbol.for("@smithy/err");
+    ctor;
+    symbol = ErrorSchema.symbol;
 }
+export const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+    ctor: null,
+});

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js

@@ -1,25 +1,14 @@
-import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 export class ListSchema extends Schema {
-    constructor(name, traits, valueSchema) {
-        super(name, traits);
-        this.name = name;
-        this.traits = traits;
-        this.valueSchema = valueSchema;
-        this.symbol = ListSchema.symbol;
-    }
-    static [Symbol.hasInstance](lhs) {
-        const isPrototype = ListSchema.prototype.isPrototypeOf(lhs);
-        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-            const list = lhs;
-            return list.symbol === ListSchema.symbol;
-        }
-        return isPrototype;
-    }
-}
-ListSchema.symbol = Symbol.for("@smithy/core/schema::ListSchema");
-export function list(namespace, name, traits = {}, valueSchema) {
-    const schema = new ListSchema(namespace + "#" + name, traits, typeof valueSchema === "function" ? valueSchema() : valueSchema);
-    TypeRegistry.for(namespace).register(name, schema);
-    return schema;
+    static symbol = Symbol.for("@smithy/lis");
+    name;
+    traits;
+    valueSchema;
+    symbol = ListSchema.symbol;
 }
+export const list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), {
+    name,
+    namespace,
+    traits,
+    valueSchema,
+});

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js

@@ -1,26 +1,16 @@
-import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 export class MapSchema extends Schema {
-    constructor(name, traits, keySchema, valueSchema) {
-        super(name, traits);
-        this.name = name;
-        this.traits = traits;
-        this.keySchema = keySchema;
-        this.valueSchema = valueSchema;
-        this.symbol = MapSchema.symbol;
-    }
-    static [Symbol.hasInstance](lhs) {
-        const isPrototype = MapSchema.prototype.isPrototypeOf(lhs);
-        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-            const map = lhs;
-            return map.symbol === MapSchema.symbol;
-        }
-        return isPrototype;
-    }
-}
-MapSchema.symbol = Symbol.for("@smithy/core/schema::MapSchema");
-export function map(namespace, name, traits = {}, keySchema, valueSchema) {
-    const schema = new MapSchema(namespace + "#" + name, traits, keySchema, typeof valueSchema === "function" ? valueSchema() : valueSchema);
-    TypeRegistry.for(namespace).register(name, schema);
-    return schema;
+    static symbol = Symbol.for("@smithy/map");
+    name;
+    traits;
+    keySchema;
+    valueSchema;
+    symbol = MapSchema.symbol;
 }
+export const map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema(), {
+    name,
+    namespace,
+    traits,
+    keySchema,
+    valueSchema,
+});