@cdklabs/cdk-ssm-documents 0.0.64 → 0.0.66

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

@@ -1,11 +1,9 @@
-'use strict';
+const { Readable } = require("node:stream");
+const { NoOpLogger, normalizeProvider } = require("@smithy/core/client");
+const { HttpResponse, HttpRequest } = require("@smithy/core/protocols");
+const { parseRfc7231DateTime, v4 } = require("@smithy/core/serde");
 
-var node_stream = require('node:stream');
-var client = require('@smithy/core/client');
-var protocols = require('@smithy/core/protocols');
-var serde = require('@smithy/core/serde');
-
-const isStreamingPayload = (request) => request?.body instanceof node_stream.Readable ||
+const isStreamingPayload = (request) => request?.body instanceof Readable ||
     (typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream);
 
 const CLOCK_SKEW_ERROR_CODES = [
@@ -92,7 +90,7 @@ const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
 const REQUEST_HEADER = "amz-sdk-request";
 
 function parseRetryAfterHeader(response, logger) {
-    if (!protocols.HttpResponse.isInstance(response)) {
+    if (!HttpResponse.isInstance(response)) {
         return;
     }
     for (const header of Object.keys(response.headers)) {
@@ -102,7 +100,7 @@ function parseRetryAfterHeader(response, logger) {
             let retryAfterSeconds = NaN;
             if (retryAfter.endsWith("GMT")) {
                 try {
-                    const date = serde.parseRfc7231DateTime(retryAfter);
+                    const date = parseRfc7231DateTime(retryAfter);
                     retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
                 }
                 catch (e) {
@@ -160,9 +158,9 @@ function bindRetryMiddleware(isStreamingPayload) {
             let attempts = 0;
             let totalRetryDelay = 0;
             const { request } = args;
-            const isRequest = protocols.HttpRequest.isInstance(request);
+            const isRequest = HttpRequest.isInstance(request);
             if (isRequest) {
-                request.headers[INVOCATION_ID_HEADER] = serde.v4();
+                request.headers[INVOCATION_ID_HEADER] = v4();
             }
             while (true) {
                 try {
@@ -179,7 +177,7 @@ function bindRetryMiddleware(isStreamingPayload) {
                     const retryErrorInfo = getRetryErrorInfo(e, options.logger);
                     lastError = asSdkError(e);
                     if (isRequest && isStreamingPayload(request)) {
-                        (context.logger instanceof client.NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
+                        (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
                         throw lastError;
                     }
                     try {
@@ -252,7 +250,7 @@ function bindGetRetryPlugin(isStreamingPayload) {
 }
 
 class DefaultRateLimiter {
-    static setTimeoutFn = setTimeout;
+    static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
     beta;
     minCapacity;
     minFillRate;
@@ -422,13 +420,13 @@ class DefaultRetryToken {
     }
 }
 
-exports.RETRY_MODES = void 0;
+var RETRY_MODES;
 (function (RETRY_MODES) {
     RETRY_MODES["STANDARD"] = "standard";
     RETRY_MODES["ADAPTIVE"] = "adaptive";
-})(exports.RETRY_MODES || (exports.RETRY_MODES = {}));
+})(RETRY_MODES || (RETRY_MODES = {}));
 const DEFAULT_MAX_ATTEMPTS = 3;
-const DEFAULT_RETRY_MODE = exports.RETRY_MODES.STANDARD;
+const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
 
 const refusal = {
     incompatible: 1,
@@ -436,7 +434,7 @@ const refusal = {
     capacity: 3,
 };
 let StandardRetryStrategy$1 = class StandardRetryStrategy {
-    mode = exports.RETRY_MODES.STANDARD;
+    mode = RETRY_MODES.STANDARD;
     retryBackoffStrategy;
     capacity = INITIAL_RETRY_TOKENS;
     maxAttemptsProvider;
@@ -524,7 +522,7 @@ let StandardRetryStrategy$1 = class StandardRetryStrategy {
 };
 
 let AdaptiveRetryStrategy$1 = class AdaptiveRetryStrategy {
-    mode = exports.RETRY_MODES.ADAPTIVE;
+    mode = RETRY_MODES.ADAPTIVE;
     rateLimiter;
     standardRetryStrategy;
     constructor(maxAttemptsProvider, options) {
@@ -615,7 +613,7 @@ class StandardRetryStrategy {
     retryDecider;
     delayDecider;
     retryQuota;
-    mode = exports.RETRY_MODES.STANDARD;
+    mode = RETRY_MODES.STANDARD;
     constructor(maxAttemptsProvider, options) {
         this.maxAttemptsProvider = maxAttemptsProvider;
         this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
@@ -641,12 +639,12 @@ class StandardRetryStrategy {
         let totalDelay = 0;
         const maxAttempts = await this.getMaxAttempts();
         const { request } = args;
-        if (protocols.HttpRequest.isInstance(request)) {
-            request.headers[INVOCATION_ID_HEADER] = serde.v4();
+        if (HttpRequest.isInstance(request)) {
+            request.headers[INVOCATION_ID_HEADER] = v4();
         }
         while (true) {
             try {
-                if (protocols.HttpRequest.isInstance(request)) {
+                if (HttpRequest.isInstance(request)) {
                     request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
                 }
                 if (options?.beforeRequest) {
@@ -684,7 +682,7 @@ class StandardRetryStrategy {
     }
 }
 const getDelayFromRetryAfterHeader = (response) => {
-    if (!protocols.HttpResponse.isInstance(response))
+    if (!HttpResponse.isInstance(response))
         return;
     const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
     if (!retryAfterHeaderName)
@@ -692,9 +690,9 @@ const getDelayFromRetryAfterHeader = (response) => {
     const retryAfter = response.headers[retryAfterHeaderName];
     const retryAfterSeconds = Number(retryAfter);
     if (!Number.isNaN(retryAfterSeconds))
-        return retryAfterSeconds * 1000;
+        return Math.min(retryAfterSeconds * 1000, 20_000);
     const retryAfterDate = new Date(retryAfter);
-    return retryAfterDate.getTime() - Date.now();
+    return Math.min(retryAfterDate.getTime() - Date.now(), 20_000);
 };
 
 class AdaptiveRetryStrategy extends StandardRetryStrategy {
@@ -703,7 +701,7 @@ class AdaptiveRetryStrategy extends StandardRetryStrategy {
         const { rateLimiter, ...superOptions } = options ?? {};
         super(maxAttemptsProvider, superOptions);
         this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
-        this.mode = exports.RETRY_MODES.ADAPTIVE;
+        this.mode = RETRY_MODES.ADAPTIVE;
     }
     async retry(next, args) {
         return super.retry(next, args, {
@@ -745,13 +743,13 @@ const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
 const resolveRetryConfig = (input, defaults) => {
     const { retryStrategy, retryMode } = input;
     const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
-    const maxAttemptsProvider = client.normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
+    const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
     const getDefault = async () => {
         const maxAttempts = await maxAttemptsProvider();
-        const adaptive = (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE;
+        const adaptive = (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE;
         if (adaptive) {
             return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
                 maxAttempts,
@@ -778,7 +776,7 @@ const NODE_RETRY_MODE_CONFIG_OPTIONS = {
 
 const omitRetryHeadersMiddleware = () => (next) => async (args) => {
     const { request } = args;
-    if (protocols.HttpRequest.isInstance(request)) {
+    if (HttpRequest.isInstance(request)) {
         delete request.headers[INVOCATION_ID_HEADER];
         delete request.headers[REQUEST_HEADER];
     }
@@ -820,6 +818,7 @@ exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
 exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
 exports.REQUEST_HEADER = REQUEST_HEADER;
 exports.RETRY_COST = RETRY_COST;
+exports.RETRY_MODES = RETRY_MODES;
 exports.Retry = Retry;
 exports.StandardRetryStrategy = StandardRetryStrategy$1;
 exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;

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

@@ -1,6 +1,4 @@
-'use strict';
-
-var transport = require('@smithy/core/transport');
+const { getSmithyContext, HttpResponse, toEndpointV1 } = require("@smithy/core/transport");
 
 const deref = (schemaRef) => {
     if (typeof schemaRef === "function") {
@@ -19,7 +17,7 @@ const operation = (namespace, name, traits, input, output) => ({
 
 const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);
-    const { operationSchema } = transport.getSmithyContext(context);
+    const { operationSchema } = getSmithyContext(context);
     const [, ns, n, t, i, o] = operationSchema ?? [];
     try {
         const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
@@ -57,7 +55,7 @@ const schemaDeserializationMiddleware = (config) => (next, context) => async (ar
                 }
             }
             try {
-                if (transport.HttpResponse.isInstance(response)) {
+                if (HttpResponse.isInstance(response)) {
                     const { headers = {}, statusCode } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -81,10 +79,10 @@ const findHeader = (pattern, headers) => {
 };
 
 const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-    const { operationSchema } = transport.getSmithyContext(context);
+    const { operationSchema } = getSmithyContext(context);
     const [, ns, n, t, i, o] = operationSchema ?? [];
     const endpoint = context.endpointV2
-        ? async () => transport.toEndpointV1(context.endpointV2)
+        ? async () => toEndpointV1(context.endpointV2)
         : config.endpoint;
     const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
         ...config,

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

@@ -1,7 +1,5 @@
-'use strict';
-
-var transport = require('@smithy/core/transport');
-var endpoints = require('@smithy/core/endpoints');
+const { HttpResponse } = require("@smithy/core/transport");
+const { toEndpointV1 } = require("@smithy/core/endpoints");
 
 const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
 const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
@@ -912,7 +910,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                 }
             }
             try {
-                if (transport.HttpResponse.isInstance(response)) {
+                if (HttpResponse.isInstance(response)) {
                     const { headers = {} } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -938,7 +936,7 @@ const findHeader = (pattern, headers) => {
 const serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
     const endpointConfig = options;
     const endpoint = context.endpointV2
-        ? async () => endpoints.toEndpointV1(context.endpointV2)
+        ? async () => toEndpointV1(context.endpointV2)
         : endpointConfig.endpoint;
     if (!endpoint) {
         throw new Error("No valid endpoint provider available.");

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

@@ -1,10 +1,8 @@
-'use strict';
-
-var node_crypto = require('node:crypto');
-var node_fs = require('node:fs');
-var transport = require('@smithy/core/transport');
-var endpoints = require('@smithy/core/endpoints');
-var node_stream = require('node:stream');
+const { createHmac, createHash, getRandomValues } = require("node:crypto");
+const { ReadStream, lstatSync, fstatSync } = require("node:fs");
+const { HttpResponse } = require("@smithy/core/transport");
+const { toEndpointV1 } = require("@smithy/core/endpoints");
+const { Duplex, Readable, Writable, PassThrough } = require("node:stream");
 
 const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
     Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
@@ -821,12 +819,12 @@ const calculateBodyLength = (body) => {
     else if (typeof body.start === "number" && typeof body.end === "number") {
         return body.end + 1 - body.start;
     }
-    else if (body instanceof node_fs.ReadStream) {
+    else if (body instanceof ReadStream) {
         if (body.path != null) {
-            return node_fs.lstatSync(body.path).size;
+            return lstatSync(body.path).size;
         }
         else if (typeof body.fd === "number") {
-            return node_fs.fstatSync(body.fd).size;
+            return fstatSync(body.fd).size;
         }
     }
     throw new Error(`Body Length computation failed for ${body}`);
@@ -877,7 +875,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                 }
             }
             try {
-                if (transport.HttpResponse.isInstance(response)) {
+                if (HttpResponse.isInstance(response)) {
                     const { headers = {} } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -903,7 +901,7 @@ const findHeader = (pattern, headers) => {
 const serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
     const endpointConfig = options;
     const endpoint = context.endpointV2
-        ? async () => endpoints.toEndpointV1(context.endpointV2)
+        ? async () => toEndpointV1(context.endpointV2)
         : endpointConfig.endpoint;
     if (!endpoint) {
         throw new Error("No valid endpoint provider available.");
@@ -953,8 +951,8 @@ class Hash {
     }
     reset() {
         this.hash = this.secret
-            ? node_crypto.createHmac(this.algorithmIdentifier, castSourceData(this.secret))
-            : node_crypto.createHash(this.algorithmIdentifier);
+            ? createHmac(this.algorithmIdentifier, castSourceData(this.secret))
+            : createHash(this.algorithmIdentifier);
     }
 }
 function castSourceData(toCast, encoding) {
@@ -970,7 +968,7 @@ function castSourceData(toCast, encoding) {
     return fromArrayBuffer(toCast);
 }
 
-let ChecksumStream$1 = class ChecksumStream extends node_stream.Duplex {
+let ChecksumStream$1 = class ChecksumStream extends Duplex {
     expectedChecksum;
     checksumSourceLocation;
     checksum;
@@ -1256,7 +1254,7 @@ function createBufferedReadable(upstream, size, logger) {
     if (isReadableStream(upstream)) {
         return createBufferedReadableStream(upstream, size, logger);
     }
-    const downstream = new node_stream.Readable({ read() { } });
+    const downstream = new Readable({ read() { } });
     let streamBufferingLoggedWarning = false;
     let bytesSeen = 0;
     const buffers = [
@@ -1346,7 +1344,7 @@ function getAwsChunkedEncodingStream(stream, options) {
         checksumLocationName !== undefined &&
         streamHasher !== undefined;
     const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined;
-    const awsChunkedEncodingStream = new node_stream.Readable({
+    const awsChunkedEncodingStream = new Readable({
         read: () => { },
     });
     readable.on("data", (data) => {
@@ -1421,7 +1419,7 @@ const headStream = (stream, bytes) => {
         });
     });
 };
-let Collector$1 = class Collector extends node_stream.Writable {
+let Collector$1 = class Collector extends Writable {
     buffers = [];
     limit = Infinity;
     bytesBuffered = 0;
@@ -1597,7 +1595,7 @@ const sdkStreamMixin$1 = (stream) => {
 };
 const isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
 
-class Collector extends node_stream.Writable {
+class Collector extends Writable {
     bufferedBytes = [];
     _write(chunk, encoding, callback) {
         this.bufferedBytes.push(chunk);
@@ -1647,7 +1645,7 @@ const streamCollector = (stream) => {
 
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 const sdkStreamMixin = (stream) => {
-    if (!(stream instanceof node_stream.Readable)) {
+    if (!(stream instanceof Readable)) {
         try {
             return sdkStreamMixin$1(stream);
         }
@@ -1683,11 +1681,11 @@ const sdkStreamMixin = (stream) => {
             if (stream.readableFlowing !== null) {
                 throw new Error("The stream has been consumed by other callbacks.");
             }
-            if (typeof node_stream.Readable.toWeb !== "function") {
+            if (typeof Readable.toWeb !== "function") {
                 throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
             }
             transformed = true;
-            return node_stream.Readable.toWeb(stream);
+            return Readable.toWeb(stream);
         },
     });
 };
@@ -1704,8 +1702,8 @@ async function splitStream(stream) {
     if (isReadableStream(stream) || isBlob(stream)) {
         return splitStream$1(stream);
     }
-    const stream1 = new node_stream.PassThrough();
-    const stream2 = new node_stream.PassThrough();
+    const stream1 = new PassThrough();
+    const stream2 = new PassThrough();
     stream.pipe(stream1);
     stream.pipe(stream2);
     return [stream1, stream2];
@@ -1713,7 +1711,7 @@ async function splitStream(stream) {
 
 class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64$1) {
 }
-const _getRandomValues = node_crypto.getRandomValues;
+const _getRandomValues = getRandomValues;
 const v4 = bindV4(_getRandomValues);
 const generateIdempotencyToken = v4;
 

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

@@ -1,7 +1,5 @@
-'use strict';
-
-var transport = require('@smithy/core/transport');
-var endpoints = require('@smithy/core/endpoints');
+const { HttpResponse } = require("@smithy/core/transport");
+const { toEndpointV1 } = require("@smithy/core/endpoints");
 
 const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
 const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
@@ -912,7 +910,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                 }
             }
             try {
-                if (transport.HttpResponse.isInstance(response)) {
+                if (HttpResponse.isInstance(response)) {
                     const { headers = {} } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -938,7 +936,7 @@ const findHeader = (pattern, headers) => {
 const serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
     const endpointConfig = options;
     const endpoint = context.endpointV2
-        ? async () => endpoints.toEndpointV1(context.endpointV2)
+        ? async () => toEndpointV1(context.endpointV2)
         : endpointConfig.endpoint;
     if (!endpoint) {
         throw new Error("No valid endpoint provider available.");

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

@@ -1,8 +1,6 @@
-'use strict';
+const { SMITHY_CONTEXT_KEY } = require("@smithy/types");
 
-var types = require('@smithy/types');
-
-const getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {});
+const getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
 
 class HttpRequest {
     method;

package/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js

@@ -1,4 +1,4 @@
-import { getSmithyContext } from "@smithy/core/client";
+import { getSmithyContext } from "@smithy/core/transport";
 import { resolveAuthOptions } from "./resolveAuthOptions";
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {
     const map = new Map();

package/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-signing/httpSigningMiddleware.js

@@ -1,5 +1,5 @@
-import { getSmithyContext } from "@smithy/core/client";
 import { HttpRequest } from "@smithy/core/protocols";
+import { getSmithyContext } from "@smithy/core/transport";
 const defaultErrorHandler = (signingProperties) => (error) => {
     throw error;
 };

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

@@ -1,6 +1,6 @@
-import { getSmithyContext } from "@smithy/core/client";
 import { RpcProtocol } from "@smithy/core/protocols";
 import { NormalizedSchema, TypeRegistry, deref } from "@smithy/core/schema";
+import { getSmithyContext } from "@smithy/core/transport";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
 export class SmithyRpcV2CborProtocol extends RpcProtocol {