{"version":3,"file":"2.js?41a9c34f6ae1f67e0028","mappings":"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","sources":["webpack:///../../../../../../gen/node_modules/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js"],"sourcesContent":["import { fromUtf8, toUtf8 } from \"@smithy/util-utf8\";\nexport class EventStreamSerde {\n    marshaller;\n    serializer;\n    deserializer;\n    serdeContext;\n    defaultContentType;\n    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {\n        this.marshaller = marshaller;\n        this.serializer = serializer;\n        this.deserializer = deserializer;\n        this.serdeContext = serdeContext;\n        this.defaultContentType = defaultContentType;\n    }\n    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {\n        const marshaller = this.marshaller;\n        const eventStreamMember = requestSchema.getEventStreamMember();\n        const unionSchema = requestSchema.getMemberSchema(eventStreamMember);\n        const serializer = this.serializer;\n        const defaultContentType = this.defaultContentType;\n        const initialRequestMarker = Symbol(\"initialRequestMarker\");\n        const eventStreamIterable = {\n            async *[Symbol.asyncIterator]() {\n                if (initialRequest) {\n                    const headers = {\n                        \":event-type\": { type: \"string\", value: \"initial-request\" },\n                        \":message-type\": { type: \"string\", value: \"event\" },\n                        \":content-type\": { type: \"string\", value: defaultContentType },\n                    };\n                    serializer.write(requestSchema, initialRequest);\n                    const body = serializer.flush();\n                    yield {\n                        [initialRequestMarker]: true,\n                        headers,\n                        body,\n                    };\n                }\n                for await (const page of eventStream) {\n                    yield page;\n                }\n            },\n        };\n        return marshaller.serialize(eventStreamIterable, (event) => {\n            if (event[initialRequestMarker]) {\n                return {\n                    headers: event.headers,\n                    body: event.body,\n                };\n            }\n            let unionMember = \"\";\n            for (const key in event) {\n                if (key !== \"__type\") {\n                    unionMember = key;\n                    break;\n                }\n            }\n            const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);\n            const headers = {\n                \":event-type\": { type: \"string\", value: eventType },\n                \":message-type\": { type: \"string\", value: \"event\" },\n                \":content-type\": { type: \"string\", value: explicitPayloadContentType ?? defaultContentType },\n                ...additionalHeaders,\n            };\n            return {\n                headers,\n                body,\n            };\n        });\n    }\n    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {\n        const marshaller = this.marshaller;\n        const eventStreamMember = responseSchema.getEventStreamMember();\n        const unionSchema = responseSchema.getMemberSchema(eventStreamMember);\n        const memberSchemas = unionSchema.getMemberSchemas();\n        const initialResponseMarker = Symbol(\"initialResponseMarker\");\n        const asyncIterable = marshaller.deserialize(response.body, async (event) => {\n            let unionMember = \"\";\n            for (const key in event) {\n                if (key !== \"__type\") {\n                    unionMember = key;\n                    break;\n                }\n            }\n            const body = event[unionMember].body;\n            if (unionMember === \"initial-response\") {\n                const dataObject = await this.deserializer.read(responseSchema, body);\n                delete dataObject[eventStreamMember];\n                return {\n                    [initialResponseMarker]: true,\n                    ...dataObject,\n                };\n            }\n            else if (unionMember in memberSchemas) {\n                const eventStreamSchema = memberSchemas[unionMember];\n                if (eventStreamSchema.isStructSchema()) {\n                    const out = {};\n                    let hasBindings = false;\n                    for (const [name, member] of eventStreamSchema.structIterator()) {\n                        const { eventHeader, eventPayload } = member.getMergedTraits();\n                        hasBindings = hasBindings || Boolean(eventHeader || eventPayload);\n                        if (eventPayload) {\n                            if (member.isBlobSchema()) {\n                                out[name] = body;\n                            }\n                            else if (member.isStringSchema()) {\n                                out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);\n                            }\n                            else if (member.isStructSchema()) {\n                                out[name] = await this.deserializer.read(member, body);\n                            }\n                        }\n                        else if (eventHeader) {\n                            const value = event[unionMember].headers[name]?.value;\n                            if (value != null) {\n                                if (member.isNumericSchema()) {\n                                    if (value && typeof value === \"object\" && \"bytes\" in value) {\n                                        out[name] = BigInt(value.toString());\n                                    }\n                                    else {\n                                        out[name] = Number(value);\n                                    }\n                                }\n                                else {\n                                    out[name] = value;\n                                }\n                            }\n                        }\n                    }\n                    if (hasBindings) {\n                        return {\n                            [unionMember]: out,\n                        };\n                    }\n                    if (body.byteLength === 0) {\n                        return {\n                            [unionMember]: {},\n                        };\n                    }\n                }\n                return {\n                    [unionMember]: await this.deserializer.read(eventStreamSchema, body),\n                };\n            }\n            else {\n                return {\n                    $unknown: event,\n                };\n            }\n        });\n        const asyncIterator = asyncIterable[Symbol.asyncIterator]();\n        const firstEvent = await asyncIterator.next();\n        if (firstEvent.done) {\n            return asyncIterable;\n        }\n        if (firstEvent.value?.[initialResponseMarker]) {\n            if (!responseSchema) {\n                throw new Error(\"@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.\");\n            }\n            for (const key in firstEvent.value) {\n                initialResponseContainer[key] = firstEvent.value[key];\n            }\n        }\n        return {\n            async *[Symbol.asyncIterator]() {\n                if (!firstEvent?.value?.[initialResponseMarker]) {\n                    yield firstEvent.value;\n                }\n                while (true) {\n                    const { done, value } = await asyncIterator.next();\n                    if (done) {\n                        break;\n                    }\n                    yield value;\n                }\n            },\n        };\n    }\n    writeEventBody(unionMember, unionSchema, event) {\n        const serializer = this.serializer;\n        let eventType = unionMember;\n        let explicitPayloadMember = null;\n        let explicitPayloadContentType;\n        const isKnownSchema = (() => {\n            const struct = unionSchema.getSchema();\n            return struct[4].includes(unionMember);\n        })();\n        const additionalHeaders = {};\n        if (!isKnownSchema) {\n            const [type, value] = event[unionMember];\n            eventType = type;\n            serializer.write(15, value);\n        }\n        else {\n            const eventSchema = unionSchema.getMemberSchema(unionMember);\n            if (eventSchema.isStructSchema()) {\n                for (const [memberName, memberSchema] of eventSchema.structIterator()) {\n                    const { eventHeader, eventPayload } = memberSchema.getMergedTraits();\n                    if (eventPayload) {\n                        explicitPayloadMember = memberName;\n                    }\n                    else if (eventHeader) {\n                        const value = event[unionMember][memberName];\n                        let type = \"binary\";\n                        if (memberSchema.isNumericSchema()) {\n                            if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {\n                                type = \"integer\";\n                            }\n                            else {\n                                type = \"long\";\n                            }\n                        }\n                        else if (memberSchema.isTimestampSchema()) {\n                            type = \"timestamp\";\n                        }\n                        else if (memberSchema.isStringSchema()) {\n                            type = \"string\";\n                        }\n                        else if (memberSchema.isBooleanSchema()) {\n                            type = \"boolean\";\n                        }\n                        if (value != null) {\n                            additionalHeaders[memberName] = {\n                                type,\n                                value,\n                            };\n                            delete event[unionMember][memberName];\n                        }\n                    }\n                }\n                if (explicitPayloadMember !== null) {\n                    const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);\n                    if (payloadSchema.isBlobSchema()) {\n                        explicitPayloadContentType = \"application/octet-stream\";\n                    }\n                    else if (payloadSchema.isStringSchema()) {\n                        explicitPayloadContentType = \"text/plain\";\n                    }\n                    serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);\n                }\n                else {\n                    serializer.write(eventSchema, event[unionMember]);\n                }\n            }\n            else if (eventSchema.isUnitSchema()) {\n                serializer.write(eventSchema, {});\n            }\n            else {\n                throw new Error(\"@smithy/core/event-streams - non-struct member not supported in event stream union.\");\n            }\n        }\n        const messageSerialization = serializer.flush() ?? new Uint8Array();\n        const body = typeof messageSerialization === \"string\"\n            ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization)\n            : messageSerialization;\n        return {\n            body,\n            eventType,\n            explicitPayloadContentType,\n            additionalHeaders,\n        };\n    }\n}\n"],"names":["EventStreamSerde","marshaller","serializer","deserializer","serdeContext","defaultContentType","constructor","this","serializeEventStream","eventStream","requestSchema","initialRequest","eventStreamMember","getEventStreamMember","unionSchema","getMemberSchema","initialRequestMarker","Symbol","eventStreamIterable","asyncIterator","headers","type","value","write","body","flush","page","serialize","event","unionMember","key","additionalHeaders","eventType","explicitPayloadContentType","writeEventBody","deserializeEventStream","response","responseSchema","initialResponseContainer","memberSchemas","getMemberSchemas","initialResponseMarker","asyncIterable","deserialize","async","dataObject","read","eventStreamSchema","isStructSchema","out","hasBindings","name","member","structIterator","eventHeader","eventPayload","getMergedTraits","Boolean","isBlobSchema","isStringSchema","utf8Encoder","toUtf8","isNumericSchema","BigInt","toString","Number","byteLength","$unknown","firstEvent","next","done","Error","explicitPayloadMember","getSchema","includes","eventSchema","memberName","memberSchema","isTimestampSchema","isBooleanSchema","payloadSchema","isUnitSchema","messageSerialization","Uint8Array","utf8Decoder","fromUtf8"],"sourceRoot":""}