replicas-engine 0.1.280 → 0.1.282

package/dist/src/chunk-WPAL27HA.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import {
-  ProviderError
-} from "./chunk-ST5JVROM.js";
-
-// ../node_modules/.bun/@smithy+property-provider@4.2.14/node_modules/@smithy/property-provider/dist-es/chain.js
-var chain = (...providers) => async () => {
-  if (providers.length === 0) {
-    throw new ProviderError("No providers in chain");
-  }
-  let lastProviderError;
-  for (const provider of providers) {
-    try {
-      const credentials = await provider();
-      return credentials;
-    } catch (err) {
-      lastProviderError = err;
-      if (err?.tryNextLink) {
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw lastProviderError;
-};
-
-export {
-  chain
-};

package/dist/src/chunk-ZDZBYCXV.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-
-// ../node_modules/.bun/@smithy+smithy-client@4.12.13/node_modules/@smithy/smithy-client/dist-es/create-aggregated-client.js
-var createAggregatedClient = (commands, Client, options) => {
-  for (const [command, CommandCtor] of Object.entries(commands)) {
-    const methodImpl = async function(args, optionsOrCb, cb) {
-      const command2 = new CommandCtor(args);
-      if (typeof optionsOrCb === "function") {
-        this.send(command2, optionsOrCb);
-      } else if (typeof cb === "function") {
-        if (typeof optionsOrCb !== "object")
-          throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
-        this.send(command2, optionsOrCb || {}, cb);
-      } else {
-        return this.send(command2, optionsOrCb);
-      }
-    };
-    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
-    Client.prototype[methodName] = methodImpl;
-  }
-  const { paginators = {}, waiters = {} } = options ?? {};
-  for (const [paginatorName, paginatorFn] of Object.entries(paginators)) {
-    if (Client.prototype[paginatorName] === void 0) {
-      Client.prototype[paginatorName] = function(commandInput = {}, paginationConfiguration, ...rest) {
-        return paginatorFn({
-          ...paginationConfiguration,
-          client: this
-        }, commandInput, ...rest);
-      };
-    }
-  }
-  for (const [waiterName, waiterFn] of Object.entries(waiters)) {
-    if (Client.prototype[waiterName] === void 0) {
-      Client.prototype[waiterName] = async function(commandInput = {}, waiterConfiguration, ...rest) {
-        let config = waiterConfiguration;
-        if (typeof waiterConfiguration === "number") {
-          config = {
-            maxWaitTime: waiterConfiguration
-          };
-        }
-        return waiterFn({
-          ...config,
-          client: this
-        }, commandInput, ...rest);
-      };
-    }
-  }
-};
-
-export {
-  createAggregatedClient
-};

package/dist/src/chunk-ZNARSMJG.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-
-// ../node_modules/.bun/@aws-sdk+core@3.974.8/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
-function setCredentialFeature(credentials, feature, value) {
-  if (!credentials.$source) {
-    credentials.$source = {};
-  }
-  credentials.$source[feature] = value;
-  return credentials;
-}
-
-export {
-  setCredentialFeature
-};

package/dist/src/event-streams-XS4D2DFO.js

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