lambda-live-debugger 1.8.5 → 1.8.6

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js

@@ -1,313 +0,0 @@
-import { deref } from "../deref";
-import { ListSchema } from "./ListSchema";
-import { MapSchema } from "./MapSchema";
-import { SCHEMA } from "./sentinels";
-import { SimpleSchema } from "./SimpleSchema";
-import { StructureSchema } from "./StructureSchema";
-export class NormalizedSchema {
-    constructor(ref, memberName) {
-        this.ref = ref;
-        this.memberName = memberName;
-        this.symbol = NormalizedSchema.symbol;
-        const traitStack = [];
-        let _ref = ref;
-        let schema = ref;
-        this._isMemberSchema = false;
-        while (Array.isArray(_ref)) {
-            traitStack.push(_ref[1]);
-            _ref = _ref[0];
-            schema = deref(_ref);
-            this._isMemberSchema = true;
-        }
-        if (traitStack.length > 0) {
-            this.memberTraits = {};
-            for (let i = traitStack.length - 1; i >= 0; --i) {
-                const traitSet = traitStack[i];
-                Object.assign(this.memberTraits, NormalizedSchema.translateTraits(traitSet));
-            }
-        }
-        else {
-            this.memberTraits = 0;
-        }
-        if (schema instanceof NormalizedSchema) {
-            this.name = schema.name;
-            this.traits = schema.traits;
-            this._isMemberSchema = schema._isMemberSchema;
-            this.schema = schema.schema;
-            this.memberTraits = Object.assign({}, schema.getMemberTraits(), this.getMemberTraits());
-            this.normalizedTraits = void 0;
-            this.ref = schema.ref;
-            this.memberName = memberName ?? schema.memberName;
-            return;
-        }
-        this.schema = deref(schema);
-        if (this.schema && typeof this.schema === "object") {
-            this.traits = this.schema?.traits ?? {};
-        }
-        else {
-            this.traits = 0;
-        }
-        this.name =
-            (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
-        if (this._isMemberSchema && !memberName) {
-            throw new Error(`@smithy/core/schema - NormalizedSchema member schema ${this.getName(true)} must initialize with memberName argument.`);
-        }
-    }
-    static [Symbol.hasInstance](lhs) {
-        const isPrototype = NormalizedSchema.prototype.isPrototypeOf(lhs);
-        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-            const ns = lhs;
-            return ns.symbol === NormalizedSchema.symbol;
-        }
-        return isPrototype;
-    }
-    static of(ref, memberName) {
-        if (ref instanceof NormalizedSchema) {
-            return ref;
-        }
-        return new NormalizedSchema(ref, memberName);
-    }
-    static translateTraits(indicator) {
-        if (typeof indicator === "object") {
-            return indicator;
-        }
-        indicator = indicator | 0;
-        const traits = {};
-        if ((indicator & 1) === 1) {
-            traits.httpLabel = 1;
-        }
-        if (((indicator >> 1) & 1) === 1) {
-            traits.idempotent = 1;
-        }
-        if (((indicator >> 2) & 1) === 1) {
-            traits.idempotencyToken = 1;
-        }
-        if (((indicator >> 3) & 1) === 1) {
-            traits.sensitive = 1;
-        }
-        if (((indicator >> 4) & 1) === 1) {
-            traits.httpPayload = 1;
-        }
-        if (((indicator >> 5) & 1) === 1) {
-            traits.httpResponseCode = 1;
-        }
-        if (((indicator >> 6) & 1) === 1) {
-            traits.httpQueryParams = 1;
-        }
-        return traits;
-    }
-    static memberFrom(memberSchema, memberName) {
-        if (memberSchema instanceof NormalizedSchema) {
-            memberSchema.memberName = memberName;
-            memberSchema._isMemberSchema = true;
-            return memberSchema;
-        }
-        return new NormalizedSchema(memberSchema, memberName);
-    }
-    getSchema() {
-        if (this.schema instanceof NormalizedSchema) {
-            return (this.schema = this.schema.getSchema());
-        }
-        if (this.schema instanceof SimpleSchema) {
-            return deref(this.schema.schemaRef);
-        }
-        return deref(this.schema);
-    }
-    getName(withNamespace = false) {
-        if (!withNamespace) {
-            if (this.name && this.name.includes("#")) {
-                return this.name.split("#")[1];
-            }
-        }
-        return this.name || undefined;
-    }
-    getMemberName() {
-        if (!this.isMemberSchema()) {
-            throw new Error(`@smithy/core/schema - cannot get member name on non-member schema: ${this.getName(true)}`);
-        }
-        return this.memberName;
-    }
-    isMemberSchema() {
-        return this._isMemberSchema;
-    }
-    isUnitSchema() {
-        return this.getSchema() === "unit";
-    }
-    isListSchema() {
-        const inner = this.getSchema();
-        if (typeof inner === "number") {
-            return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
-        }
-        return inner instanceof ListSchema;
-    }
-    isMapSchema() {
-        const inner = this.getSchema();
-        if (typeof inner === "number") {
-            return inner >= SCHEMA.MAP_MODIFIER && inner <= 255;
-        }
-        return inner instanceof MapSchema;
-    }
-    isDocumentSchema() {
-        return this.getSchema() === SCHEMA.DOCUMENT;
-    }
-    isStructSchema() {
-        const inner = this.getSchema();
-        return (inner !== null && typeof inner === "object" && "members" in inner) || inner instanceof StructureSchema;
-    }
-    isBlobSchema() {
-        return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
-    }
-    isTimestampSchema() {
-        const schema = this.getSchema();
-        return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
-    }
-    isStringSchema() {
-        return this.getSchema() === SCHEMA.STRING;
-    }
-    isBooleanSchema() {
-        return this.getSchema() === SCHEMA.BOOLEAN;
-    }
-    isNumericSchema() {
-        return this.getSchema() === SCHEMA.NUMERIC;
-    }
-    isBigIntegerSchema() {
-        return this.getSchema() === SCHEMA.BIG_INTEGER;
-    }
-    isBigDecimalSchema() {
-        return this.getSchema() === SCHEMA.BIG_DECIMAL;
-    }
-    isStreaming() {
-        const streaming = !!this.getMergedTraits().streaming;
-        if (streaming) {
-            return true;
-        }
-        return this.getSchema() === SCHEMA.STREAMING_BLOB;
-    }
-    isIdempotencyToken() {
-        if (typeof this.traits === "number") {
-            return (this.traits & 0b0100) === 0b0100;
-        }
-        else if (typeof this.traits === "object") {
-            return !!this.traits.idempotencyToken;
-        }
-        return false;
-    }
-    getMergedTraits() {
-        if (this.normalizedTraits) {
-            return this.normalizedTraits;
-        }
-        this.normalizedTraits = {
-            ...this.getOwnTraits(),
-            ...this.getMemberTraits(),
-        };
-        return this.normalizedTraits;
-    }
-    getMemberTraits() {
-        return NormalizedSchema.translateTraits(this.memberTraits);
-    }
-    getOwnTraits() {
-        return NormalizedSchema.translateTraits(this.traits);
-    }
-    getKeySchema() {
-        if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "key");
-        }
-        if (!this.isMapSchema()) {
-            throw new Error(`@smithy/core/schema - cannot get key schema for non-map schema: ${this.getName(true)}`);
-        }
-        const schema = this.getSchema();
-        if (typeof schema === "number") {
-            return NormalizedSchema.memberFrom([63 & schema, 0], "key");
-        }
-        return NormalizedSchema.memberFrom([schema.keySchema, 0], "key");
-    }
-    getValueSchema() {
-        const schema = this.getSchema();
-        if (typeof schema === "number") {
-            if (this.isMapSchema()) {
-                return NormalizedSchema.memberFrom([63 & schema, 0], "value");
-            }
-            else if (this.isListSchema()) {
-                return NormalizedSchema.memberFrom([63 & schema, 0], "member");
-            }
-        }
-        if (schema && typeof schema === "object") {
-            if (this.isStructSchema()) {
-                throw new Error(`cannot call getValueSchema() with StructureSchema ${this.getName(true)}`);
-            }
-            const collection = schema;
-            if ("valueSchema" in collection) {
-                if (this.isMapSchema()) {
-                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "value");
-                }
-                else if (this.isListSchema()) {
-                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "member");
-                }
-            }
-        }
-        if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "value");
-        }
-        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
-    }
-    getMemberSchema(member) {
-        if (this.isStructSchema()) {
-            const struct = this.getSchema();
-            if (!(member in struct.members)) {
-                throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`);
-            }
-            return NormalizedSchema.memberFrom(struct.members[member], member);
-        }
-        if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
-        }
-        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have members.`);
-    }
-    getMemberSchemas() {
-        const { schema } = this;
-        const struct = schema;
-        if (!struct || typeof struct !== "object") {
-            return {};
-        }
-        if ("members" in struct) {
-            const buffer = {};
-            for (const member of struct.memberNames) {
-                buffer[member] = this.getMemberSchema(member);
-            }
-            return buffer;
-        }
-        return {};
-    }
-    *structIterator() {
-        if (this.isUnitSchema()) {
-            return;
-        }
-        if (!this.isStructSchema()) {
-            throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
-        }
-        const struct = this.getSchema();
-        for (let i = 0; i < struct.memberNames.length; ++i) {
-            yield [struct.memberNames[i], NormalizedSchema.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
-        }
-    }
-    getSchemaName() {
-        const schema = this.getSchema();
-        if (typeof schema === "number") {
-            const _schema = 63 & schema;
-            const container = 192 & schema;
-            const type = Object.entries(SCHEMA).find(([, value]) => {
-                return value === _schema;
-            })?.[0] ?? "Unknown";
-            switch (container) {
-                case SCHEMA.MAP_MODIFIER:
-                    return `${type}Map`;
-                case SCHEMA.LIST_MODIFIER:
-                    return `${type}List`;
-                case 0:
-                    return type;
-            }
-        }
-        return "Unknown";
-    }
-}
-NormalizedSchema.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js

@@ -1,16 +0,0 @@
-import { TypeRegistry } from "../TypeRegistry";
-import { Schema } from "./Schema";
-export class OperationSchema extends Schema {
-    constructor(name, traits, input, output) {
-        super(name, traits);
-        this.name = name;
-        this.traits = traits;
-        this.input = input;
-        this.output = output;
-    }
-}
-export function op(namespace, name, traits = {}, input, output) {
-    const schema = new OperationSchema(namespace + "#" + name, traits, input, output);
-    TypeRegistry.for(namespace).register(name, schema);
-    return schema;
-}

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js

@@ -1,6 +0,0 @@
-export class Schema {
-    constructor(name, traits) {
-        this.name = name;
-        this.traits = traits;
-    }
-}

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js

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

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js

@@ -1,32 +0,0 @@
-import { TypeRegistry } from "../TypeRegistry";
-import { Schema } from "./Schema";
-export class StructureSchema extends Schema {
-    constructor(name, traits, memberNames, memberList) {
-        super(name, traits);
-        this.name = name;
-        this.traits = traits;
-        this.memberNames = memberNames;
-        this.memberList = memberList;
-        this.symbol = StructureSchema.symbol;
-        this.members = {};
-        for (let i = 0; i < memberNames.length; ++i) {
-            this.members[memberNames[i]] = Array.isArray(memberList[i])
-                ? memberList[i]
-                : [memberList[i], 0];
-        }
-    }
-    static [Symbol.hasInstance](lhs) {
-        const isPrototype = StructureSchema.prototype.isPrototypeOf(lhs);
-        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-            const struct = lhs;
-            return struct.symbol === StructureSchema.symbol;
-        }
-        return isPrototype;
-    }
-}
-StructureSchema.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
-export function struct(namespace, name, traits, memberNames, memberList) {
-    const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
-    TypeRegistry.for(namespace).register(name, schema);
-    return schema;
-}

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js

@@ -1,16 +0,0 @@
-export const SCHEMA = {
-    BLOB: 21,
-    STREAMING_BLOB: 42,
-    BOOLEAN: 2,
-    STRING: 0,
-    NUMERIC: 1,
-    BIG_INTEGER: 17,
-    BIG_DECIMAL: 19,
-    DOCUMENT: 15,
-    TIMESTAMP_DEFAULT: 4,
-    TIMESTAMP_DATE_TIME: 5,
-    TIMESTAMP_HTTP_DATE: 6,
-    TIMESTAMP_EPOCH_SECONDS: 7,
-    LIST_MODIFIER: 64,
-    MAP_MODIFIER: 128,
-};

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/serde/copyDocumentWithTransform.js

@@ -1 +0,0 @@
-export const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source;

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js

@@ -1,190 +0,0 @@
-import { strictParseByte, strictParseDouble, strictParseFloat32, strictParseShort } from "./parse-utils";
-const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-export function dateToUtcString(date) {
-    const year = date.getUTCFullYear();
-    const month = date.getUTCMonth();
-    const dayOfWeek = date.getUTCDay();
-    const dayOfMonthInt = date.getUTCDate();
-    const hoursInt = date.getUTCHours();
-    const minutesInt = date.getUTCMinutes();
-    const secondsInt = date.getUTCSeconds();
-    const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
-    const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
-    const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
-    const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
-    return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`;
-}
-const RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
-export const parseRfc3339DateTime = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        throw new TypeError("RFC-3339 date-times must be expressed as strings");
-    }
-    const match = RFC3339.exec(value);
-    if (!match) {
-        throw new TypeError("Invalid RFC-3339 date-time value");
-    }
-    const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
-    const year = strictParseShort(stripLeadingZeroes(yearStr));
-    const month = parseDateValue(monthStr, "month", 1, 12);
-    const day = parseDateValue(dayStr, "day", 1, 31);
-    return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
-};
-const RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
-export const parseRfc3339DateTimeWithOffset = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        throw new TypeError("RFC-3339 date-times must be expressed as strings");
-    }
-    const match = RFC3339_WITH_OFFSET.exec(value);
-    if (!match) {
-        throw new TypeError("Invalid RFC-3339 date-time value");
-    }
-    const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
-    const year = strictParseShort(stripLeadingZeroes(yearStr));
-    const month = parseDateValue(monthStr, "month", 1, 12);
-    const day = parseDateValue(dayStr, "day", 1, 31);
-    const date = buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
-    if (offsetStr.toUpperCase() != "Z") {
-        date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr));
-    }
-    return date;
-};
-const IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
-const RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
-const ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
-export const parseRfc7231DateTime = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        throw new TypeError("RFC-7231 date-times must be expressed as strings");
-    }
-    let match = IMF_FIXDATE.exec(value);
-    if (match) {
-        const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
-        return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
-    }
-    match = RFC_850_DATE.exec(value);
-    if (match) {
-        const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
-        return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
-            hours,
-            minutes,
-            seconds,
-            fractionalMilliseconds,
-        }));
-    }
-    match = ASC_TIME.exec(value);
-    if (match) {
-        const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
-        return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
-    }
-    throw new TypeError("Invalid RFC-7231 date-time value");
-};
-export const parseEpochTimestamp = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    let valueAsDouble;
-    if (typeof value === "number") {
-        valueAsDouble = value;
-    }
-    else if (typeof value === "string") {
-        valueAsDouble = strictParseDouble(value);
-    }
-    else if (typeof value === "object" && value.tag === 1) {
-        valueAsDouble = value.value;
-    }
-    else {
-        throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
-    }
-    if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
-        throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
-    }
-    return new Date(Math.round(valueAsDouble * 1000));
-};
-const buildDate = (year, month, day, time) => {
-    const adjustedMonth = month - 1;
-    validateDayOfMonth(year, adjustedMonth, day);
-    return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds)));
-};
-const parseTwoDigitYear = (value) => {
-    const thisYear = new Date().getUTCFullYear();
-    const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value));
-    if (valueInThisCentury < thisYear) {
-        return valueInThisCentury + 100;
-    }
-    return valueInThisCentury;
-};
-const FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1000;
-const adjustRfc850Year = (input) => {
-    if (input.getTime() - new Date().getTime() > FIFTY_YEARS_IN_MILLIS) {
-        return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
-    }
-    return input;
-};
-const parseMonthByShortName = (value) => {
-    const monthIdx = MONTHS.indexOf(value);
-    if (monthIdx < 0) {
-        throw new TypeError(`Invalid month: ${value}`);
-    }
-    return monthIdx + 1;
-};
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const validateDayOfMonth = (year, month, day) => {
-    let maxDays = DAYS_IN_MONTH[month];
-    if (month === 1 && isLeapYear(year)) {
-        maxDays = 29;
-    }
-    if (day > maxDays) {
-        throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`);
-    }
-};
-const isLeapYear = (year) => {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-};
-const parseDateValue = (value, type, lower, upper) => {
-    const dateVal = strictParseByte(stripLeadingZeroes(value));
-    if (dateVal < lower || dateVal > upper) {
-        throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
-    }
-    return dateVal;
-};
-const parseMilliseconds = (value) => {
-    if (value === null || value === undefined) {
-        return 0;
-    }
-    return strictParseFloat32("0." + value) * 1000;
-};
-const parseOffsetToMilliseconds = (value) => {
-    const directionStr = value[0];
-    let direction = 1;
-    if (directionStr == "+") {
-        direction = 1;
-    }
-    else if (directionStr == "-") {
-        direction = -1;
-    }
-    else {
-        throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
-    }
-    const hour = Number(value.substring(1, 3));
-    const minute = Number(value.substring(4, 6));
-    return direction * (hour * 60 + minute) * 60 * 1000;
-};
-const stripLeadingZeroes = (value) => {
-    let idx = 0;
-    while (idx < value.length - 1 && value.charAt(idx) === "0") {
-        idx++;
-    }
-    if (idx === 0) {
-        return value;
-    }
-    return value.slice(idx);
-};

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/serde/generateIdempotencyToken.js

@@ -1,2 +0,0 @@
-import { v4 as generateIdempotencyToken } from "uuid";
-export { generateIdempotencyToken };

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/serde/index.js

@@ -1,9 +0,0 @@
-export * from "./copyDocumentWithTransform";
-export * from "./date-utils";
-export * from "./generateIdempotencyToken";
-export * from "./lazy-json";
-export * from "./parse-utils";
-export * from "./quote-header";
-export * from "./split-every";
-export * from "./split-header";
-export * from "./value/NumericValue";

package/node_modules/@aws-sdk/nested-clients/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js

@@ -1,24 +0,0 @@
-export const LazyJsonString = function LazyJsonString(val) {
-    const str = Object.assign(new String(val), {
-        deserializeJSON() {
-            return JSON.parse(String(val));
-        },
-        toString() {
-            return String(val);
-        },
-        toJSON() {
-            return String(val);
-        },
-    });
-    return str;
-};
-LazyJsonString.from = (object) => {
-    if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) {
-        return object;
-    }
-    else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
-        return LazyJsonString(String(object));
-    }
-    return LazyJsonString(JSON.stringify(object));
-};
-LazyJsonString.fromObject = LazyJsonString.from;