@cdklabs/cdk-ssm-documents 0.0.66 → 0.0.67

package/node_modules/@nodable/entities/src/entityTries.js

@@ -1,49 +0,0 @@
-// entityTries.js
-// Builds integer-keyed tries so the decoder never allocates a string object
-// during lookup — every key is a plain charCode number.
-//
-// trie1: Map<code0, entity>
-// trie2: Map<code0, Map<code1, entity>>
-// trie3: Map<code0, Map<code1, Map<code2, entity>>>
-
-import { ALL_ENTITIES } from './entities.js';
-
-// Reverse map: character sequence → "&name;"
-const CHAR_TO_ENTITY = new Map();
-for (const [name, chars] of Object.entries(ALL_ENTITIES)) {
-  CHAR_TO_ENTITY.set(chars, `&${name};`);
-}
-
-export const trie1 = new Map();   // code0          → entity string
-export const trie2 = new Map();   // code0 → Map    → entity string
-export const trie3 = new Map();   // code0 → Map → Map → entity string
-
-for (const [chars, entity] of CHAR_TO_ENTITY) {
-  const len = chars.length;
-
-  if (len === 1) {
-    const c0 = chars.charCodeAt(0);
-    // Keep shortest match only if no longer match already claimed this code
-    // (longer matches are inserted in the same pass so we just overwrite —
-    //  trie1 is only consulted after trie2/trie3 both miss, so no conflict)
-    trie1.set(c0, entity);
-
-  } else if (len === 2) {
-    const c0 = chars.charCodeAt(0);
-    const c1 = chars.charCodeAt(1);
-    let inner = trie2.get(c0);
-    if (inner === undefined) { inner = new Map(); trie2.set(c0, inner); }
-    inner.set(c1, entity);
-
-  } else if (len === 3) {
-    const c0 = chars.charCodeAt(0);
-    const c1 = chars.charCodeAt(1);
-    const c2 = chars.charCodeAt(2);
-    let mid = trie3.get(c0);
-    if (mid === undefined) { mid = new Map(); trie3.set(c0, mid); }
-    let inner = mid.get(c1);
-    if (inner === undefined) { inner = new Map(); mid.set(c1, inner); }
-    inner.set(c2, entity);
-  }
-  // HTML5 has no named entity whose character sequence is longer than 3 chars
-}

package/node_modules/@nodable/entities/src/index.d.ts

@@ -1,341 +0,0 @@
-// ---------------------------------------------------------------------------
-// @nodable/entities — TypeScript declarations
-// ---------------------------------------------------------------------------
-
-/** A function-based entity replacement value (used for numeric refs). */
-export type EntityValFn = (match: string, captured: string, ...rest: unknown[]) => string;
-
-// ---------------------------------------------------------------------------
-// Entity registration hook
-// ---------------------------------------------------------------------------
-
-/**
- * Actions returned by `onExternalEntity` / `onInputEntity` hooks.
- * Use the `ENTITY_ACTION` constant object instead of raw strings to avoid typos.
- *
- * - `'allow'` — register and expand the entity normally
- * - `'block'` — silently skip the entity (not registered, treated as unknown)
- * - `'throw'` — abort registration with an error
- */
-export type EntityHookAction = 'allow' | 'block' | 'throw';
-
-/**
- * Immutable constant bag for entity registration hook return values.
- *
- * @example
- * import { ENTITY_ACTION } from '@nodable/entities';
- * const dec = new EntityDecoder({
- *   onInputEntity: (_name, _value) => ENTITY_ACTION.BLOCK,
- * });
- */
-export const ENTITY_ACTION: Readonly<{
-  /** Register and expand the entity normally. */
-  ALLOW: 'allow';
-  /** Silently skip this entity — it will not be registered. */
-  BLOCK: 'block';
-  /** Throw an error, aborting entity registration. */
-  THROW: 'throw';
-}>;
-
-/**
- * Callback signature for `onExternalEntity` and `onInputEntity` hooks.
- *
- * Called once per entity **at registration time** (not at decode time).
- * Return `ENTITY_ACTION.ALLOW` (or `'allow'`) to accept, `ENTITY_ACTION.BLOCK`
- * to silently skip, or `ENTITY_ACTION.THROW` to raise an error.
- *
- * @param name  — the entity name without `&` / `;`, e.g. `"brand"`
- * @param value — the resolved string value after any `{regex,val}` unwrapping
- */
-export type EntityRegistrationHook = (name: string, value: string) => EntityHookAction;
-
-// ---------------------------------------------------------------------------
-// Encoder options
-// ---------------------------------------------------------------------------
-
-export interface EntityEncoderOptions {
-  /**
-   * Whether to encode XML unsafe characters: `&`, `<`, `>`, `"`, `'`.
-   * @default true
-   */
-  encodeXmlSafe?: boolean;
-
-  /**
-   * Whether to encode non‑ASCII characters (e.g. `é` → `&eacute;`) using the
-   * built‑in named entity trie.
-   * @default true
-   */
-  encodeAllNamed?: boolean;
-
-  /**
-   * Maximum number of replacements performed **cumulatively** across all
-   * `encode()` calls. `0` means unlimited.
-   *
-   * Use `reset()` to reset the internal counter.
-   * @default 0
-   */
-  maxReplacements?: number;
-}
-
-// ---------------------------------------------------------------------------
-// EntityEncoder class
-// ---------------------------------------------------------------------------
-
-/**
- * High‑performance encoder that replaces characters with XML/HTML entities.
- *
- * - Escapes XML unsafe characters (`&`, `<`, `>`, `"`, `'`) when `encodeXmlSafe` is true.
- * - Replaces non‑ASCII characters (e.g. `é`, `©`) with named entities using
- *   a compact trie‑based lookup when `encodeAllNamed` is true.
- * - Supports a cumulative replacement limit (`maxReplacements`) that persists
- *   across multiple `encode()` calls until `reset()` is called.
- *
- * @example
- * const encoder = new EntityEncoder({ encodeXmlSafe: true, encodeAllNamed: true });
- * encoder.encode('<foo>');   // "&lt;foo&gt;"
- * encoder.encode('© 2025');  // "&copy; 2025"
- *
- * // With limit
- * const limited = new EntityEncoder({ maxReplacements: 2 });
- * limited.encode('<>&');     // "&lt;&gt;&"  (third replacement omitted)
- * limited.reset();           // reset counter
- */
-export class EntityEncoder {
-  constructor(options?: EntityEncoderOptions);
-
-  /**
-   * Encode a string by replacing XML‑unsafe characters and (optionally)
-   * non‑ASCII characters with named entities.
-   *
-   * If `maxReplacements` is set and the cumulative limit has been reached,
-   * the input string is returned unchanged.
-   *
-   * @returns Encoded string (may be identical to input if no replacements needed
-   *          or the limit has been exhausted).
-   */
-  encode(str: string): string;
-
-  /**
-   * Reset the internal replacement counter.
-   * Does **not** change `encodeXmlSafe`, `encodeAllNamed`, or `maxReplacements`.
-   */
-  reset(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Constructor options for EntityDecoder (existing)
-// ---------------------------------------------------------------------------
-
-/**
- * Controls which entity categories count toward the expansion limits.
- *
- * - `'external'` — only untrusted / injected entities (default)
- * - `'base'`     — only built‑in XML entities + user‑supplied `namedEntities`
- * - `'all'`      — all entities regardless of tier
- * - `string[]`   — explicit combination, e.g. `['external', 'base']`
- */
-export type ApplyLimitsTo = 'external' | 'base' | 'all' | Array<'external' | 'base'>;
-
-export interface EntityDecoderLimitOptions {
-  /**
-   * Maximum number of entity references expanded **per document**.
-   * `0` means unlimited.
-   * @default 0
-   */
-  maxTotalExpansions?: number;
-
-  /**
-   * Maximum number of characters **added** by entity expansion per document.
-   * `0` means unlimited.
-   * @default 0
-   */
-  maxExpandedLength?: number;
-
-  /**
-   * Which entity tiers count toward the expansion limits.
-   *
-   * - `'external'` (default) – only input/runtime + persistent external entities
-   * - `'base'`               – only built‑in XML + `namedEntities`
-   * - `'all'`                – every entity regardless of tier
-   * - `string[]`             – explicit combination, e.g. `['external', 'base']`
-   *
-   * @default 'external'
-   */
-  applyLimitsTo?: ApplyLimitsTo;
-}
-
-export interface EntityDecoderNCROptions {
-  /**
-   * XML version used for NCR classification.
-   * @default 1.0
-   */
-  xmlVersion?: 1.0 | 1.1;
-
-  /**
-   * Base action for all numeric references.
-   * @default 'allow'
-   */
-  onNCR?: 'allow' | 'leave' | 'remove' | 'throw';
-
-  /**
-   * Action for null NCR (U+0000).
-   * @default 'remove'
-   */
-  nullNCR?: 'remove' | 'throw';
-}
-
-export interface EntityDecoderOptions {
-  /**
-   * Extra named entities merged into the **base map** (trusted, counts as `'base'` tier).
-   * These are combined with the built‑in XML entities (`lt`, `gt`, `quot`, `apos`).
-   * Values containing `&` are silently skipped to prevent recursive expansion.
-   *
-   * @default null
-   */
-  namedEntities?: Record<string, string | { regex: RegExp; val: string | EntityValFn }> | null;
-
-
-  /**
-   * Hook called once on the fully decoded string (after all replacements).
-   *
-   * - Receives `(resolved, original)` and **must return a string**.
-   * - To reject expansion, return `original`.
-   * - To sanitize, return a cleaned version of `resolved`.
-   *
-   * @example
-   * postCheck: (resolved, original) =>
-   *   /<[a-z]/i.test(resolved) ? original : resolved
-   */
-  postCheck?: ((resolved: string, original: string) => string) | null;
-
-  /**
-   * Whether numeric character references (`&#NNN;`, `&#xHH;`) are allowed.
-   * @default true
-   */
-  numericAllowed?: boolean;
-
-  /**
-   * Array of entity names or numeric references to leave unexpanded.
-   * @default []
-   */
-  leave?: string[];
-
-  /**
-   * Array of entity names or numeric references to remove.
-   * @default []
-   */
-  remove?: string[];
-
-  /**
-   * Security limits for entity expansion.
-   */
-  limit?: EntityDecoderLimitOptions;
-
-  /**
-   * Numeric Character Reference (NCR) policy.
-   */
-  ncr?: EntityDecoderNCROptions;
-
-  /**
-   * Hook called once **at registration time** for each entity passed to
-   * `setExternalEntities()` or `addExternalEntity()`.
-   *
-   * - `'allow'` (or `ENTITY_ACTION.ALLOW`) — register the entity normally (default)
-   * - `'block'` (or `ENTITY_ACTION.BLOCK`) — silently skip; the entity is not stored
-   * - `'throw'` (or `ENTITY_ACTION.THROW`) — abort registration with an `Error`
-   *
-   * The hook receives the entity name (without `&`/`;`) and the resolved string
-   * value. It is **not** called during `decode()` — only when entities are added.
-   *
-   * @example
-   * const dec = new EntityDecoder({
-   *   onExternalEntity: (name, value) =>
-   *     DANGEROUS_NAMES.has(name) ? ENTITY_ACTION.BLOCK : ENTITY_ACTION.ALLOW,
-   * });
-   */
-  onExternalEntity?: EntityRegistrationHook | null;
-
-  /**
-   * Hook called once **at registration time** for each entity passed to
-   * `addInputEntities()`.
-   *
-   * Follows the same `'allow' | 'block' | 'throw'` contract as `onExternalEntity`.
-   *
-   * @example
-   * const dec = new EntityDecoder({
-   *   // Block all input / DOCTYPE entities unconditionally
-   *   onInputEntity: () => ENTITY_ACTION.BLOCK,
-   * });
-   */
-  onInputEntity?: EntityRegistrationHook | null;
-}
-
-// ---------------------------------------------------------------------------
-// EntityDecoder class (default export)
-// ---------------------------------------------------------------------------
-
-/**
- * Single‑pass, zero‑regex entity decoder for XML/HTML content.
- *
- * ## Entity lookup priority (highest → lowest)
- * 1. **input / runtime** – injected via `addInputEntities()` (DOCTYPE per document)
- * 2. **persistent external** – set via `setExternalEntities()` / `addExternalEntity()`
- * 3. **base map** – built‑in XML entities + user‑supplied `namedEntities`
- *
- * Numeric references (`&#NNN;`, `&#xHH;`) are resolved directly and count as the `'base'` tier.
- *
- * @example
- * const decoder = new EntityDecoder({
- *   namedEntities: COMMON_HTML,
- *   maxTotalExpansions: 100
- * });
- * decoder.setExternalEntities({ brand: 'Acme' });
- *
- * decoder.addInputEntities({ version: '1.0' });
- * decoder.decode('&brand; v&version; &lt;'); // 'Acme v1.0 <'
- *
- * decoder.reset(); // clears input entities + counters, keeps external entities
- */
-export default class EntityDecoder {
-  constructor(options?: EntityDecoderOptions);
-
-  setExternalEntities(
-    map: Record<string, string | { regex: RegExp; val: string | EntityValFn }>
-  ): void;
-
-  addExternalEntity(key: string, value: string): void;
-
-  addInputEntities(
-    map: Record<
-      string,
-      | string
-      | { regx: RegExp; val: string | EntityValFn }
-      | { regex: RegExp; val: string | EntityValFn }
-    >
-  ): void;
-
-  reset(): this;
-
-  decode(str: string): string;
-}
-
-// ---------------------------------------------------------------------------
-// Named entity group exports (for use with `namedEntities` option)
-// ---------------------------------------------------------------------------
-
-export const COMMON_HTML: Record<string, string>;
-export const ALL_ENTITIES: Record<string, string>;
-export const XML: Record<string, string>;
-export const BASIC_LATIN: Record<string, string>;
-export const LATIN_ACCENTS: Record<string, string>;
-export const LATIN_EXTENDED: Record<string, string>;
-export const GREEK: Record<string, string>;
-export const CYRILLIC: Record<string, string>;
-export const MATH: Record<string, string>;
-export const MATH_ADVANCED: Record<string, string>;
-export const ARROWS: Record<string, string>;
-export const SHAPES: Record<string, string>;
-export const PUNCTUATION: Record<string, string>;
-export const CURRENCY: Record<string, string>;
-export const FRACTIONS: Record<string, string>;
-export const MISC_SYMBOLS: Record<string, string>;

package/node_modules/@nodable/entities/src/index.js

@@ -1,29 +0,0 @@
-/**
- * @nodable/entities
- *
- * Standalone, zero-dependency XML/HTML entity replacement.
- *
-
- */
-
-export { default as EntityDecoder, ENTITY_ACTION } from './EntityDecoder.js';
-export {
-  COMMON_HTML,
-  XML,
-  ALL_ENTITIES,
-  ARROWS,
-  BASIC_LATIN,
-  CURRENCY,
-  MATH,
-  MATH_ADVANCED,
-  CYRILLIC,
-  FRACTIONS,
-  GREEK,
-  LATIN_ACCENTS,
-  LATIN_EXTENDED,
-  MISC_SYMBOLS,
-  PUNCTUATION,
-  SHAPES,
-} from './entities.js';
-
-export { default as EntityEncoder } from './EntityEncoder.js';

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5-js/constants.js

@@ -1,3 +0,0 @@
-export const BLOCK_SIZE = 64;
-export const DIGEST_LENGTH = 16;
-export const INIT = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5-js/md5.js

@@ -1,168 +0,0 @@
-import { fromUtf8 } from "@smithy/core/serde";
-import { BLOCK_SIZE, DIGEST_LENGTH, INIT } from "./constants";
-export class Md5 {
-    state;
-    buffer;
-    bufferLength;
-    bytesHashed;
-    finished;
-    constructor() {
-        this.reset();
-    }
-    update(sourceData) {
-        if (isEmptyData(sourceData)) {
-            return;
-        }
-        else if (this.finished) {
-            throw new Error("Attempted to update an already finished hash.");
-        }
-        const data = convertToBuffer(sourceData);
-        let position = 0;
-        let { byteLength } = data;
-        this.bytesHashed += byteLength;
-        while (byteLength > 0) {
-            this.buffer.setUint8(this.bufferLength++, data[position++]);
-            byteLength--;
-            if (this.bufferLength === BLOCK_SIZE) {
-                this.hashBuffer();
-                this.bufferLength = 0;
-            }
-        }
-    }
-    async digest() {
-        if (!this.finished) {
-            const { buffer, bufferLength: undecoratedLength, bytesHashed } = this;
-            const bitsHashed = bytesHashed * 8;
-            buffer.setUint8(this.bufferLength++, 0b10000000);
-            if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
-                for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
-                    buffer.setUint8(i, 0);
-                }
-                this.hashBuffer();
-                this.bufferLength = 0;
-            }
-            for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
-                buffer.setUint8(i, 0);
-            }
-            buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
-            buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
-            this.hashBuffer();
-            this.finished = true;
-        }
-        const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
-        for (let i = 0; i < 4; i++) {
-            out.setUint32(i * 4, this.state[i], true);
-        }
-        return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
-    }
-    hashBuffer() {
-        const { buffer, state } = this;
-        let a = state[0], b = state[1], c = state[2], d = state[3];
-        a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xd76aa478);
-        d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xe8c7b756);
-        c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070db);
-        b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xc1bdceee);
-        a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xf57c0faf);
-        d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787c62a);
-        c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xa8304613);
-        b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xfd469501);
-        a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098d8);
-        d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8b44f7af);
-        c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xffff5bb1);
-        b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895cd7be);
-        a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6b901122);
-        d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xfd987193);
-        c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xa679438e);
-        b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49b40821);
-        a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xf61e2562);
-        d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xc040b340);
-        c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265e5a51);
-        b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xe9b6c7aa);
-        a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xd62f105d);
-        d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
-        c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xd8a1e681);
-        b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xe7d3fbc8);
-        a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21e1cde6);
-        d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xc33707d6);
-        c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xf4d50d87);
-        b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455a14ed);
-        a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xa9e3e905);
-        d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xfcefa3f8);
-        c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676f02d9);
-        b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8d2a4c8a);
-        a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xfffa3942);
-        d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771f681);
-        c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6d9d6122);
-        b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xfde5380c);
-        a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xa4beea44);
-        d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4bdecfa9);
-        c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xf6bb4b60);
-        b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xbebfbc70);
-        a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289b7ec6);
-        d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xeaa127fa);
-        c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xd4ef3085);
-        b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881d05);
-        a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xd9d4d039);
-        d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xe6db99e5);
-        c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1fa27cf8);
-        b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xc4ac5665);
-        a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xf4292244);
-        d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432aff97);
-        c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xab9423a7);
-        b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xfc93a039);
-        a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655b59c3);
-        d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8f0ccc92);
-        c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xffeff47d);
-        b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845dd1);
-        a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6fa87e4f);
-        d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xfe2ce6e0);
-        c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xa3014314);
-        b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4e0811a1);
-        a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xf7537e82);
-        d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xbd3af235);
-        c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2ad7d2bb);
-        b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xeb86d391);
-        state[0] = (a + state[0]) & 0xffffffff;
-        state[1] = (b + state[1]) & 0xffffffff;
-        state[2] = (c + state[2]) & 0xffffffff;
-        state[3] = (d + state[3]) & 0xffffffff;
-    }
-    reset() {
-        this.state = Uint32Array.from(INIT);
-        this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
-        this.bufferLength = 0;
-        this.bytesHashed = 0;
-        this.finished = false;
-    }
-}
-function cmn(q, a, b, x, s, t) {
-    a = (((a + q) & 0xffffffff) + ((x + t) & 0xffffffff)) & 0xffffffff;
-    return (((a << s) | (a >>> (32 - s))) + b) & 0xffffffff;
-}
-function ff(a, b, c, d, x, s, t) {
-    return cmn((b & c) | (~b & d), a, b, x, s, t);
-}
-function gg(a, b, c, d, x, s, t) {
-    return cmn((b & d) | (c & ~d), a, b, x, s, t);
-}
-function hh(a, b, c, d, x, s, t) {
-    return cmn(b ^ c ^ d, a, b, x, s, t);
-}
-function ii(a, b, c, d, x, s, t) {
-    return cmn(c ^ (b | ~d), a, b, x, s, t);
-}
-function isEmptyData(data) {
-    if (typeof data === "string") {
-        return data.length === 0;
-    }
-    return data.byteLength === 0;
-}
-function convertToBuffer(data) {
-    if (typeof data === "string") {
-        return fromUtf8(data);
-    }
-    if (ArrayBuffer.isView(data)) {
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
-    }
-    return new Uint8Array(data);
-}

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5-js/constants.d.ts

@@ -1,12 +0,0 @@
-/**
- * @internal
- */
-export declare const BLOCK_SIZE = 64;
-/**
- * @internal
- */
-export declare const DIGEST_LENGTH = 16;
-/**
- * @internal
- */
-export declare const INIT: number[];

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5-js/md5.d.ts

@@ -1,16 +0,0 @@
-import type { Checksum, SourceData } from "@smithy/types";
-/**
- * @internal
- */
-export declare class Md5 implements Checksum {
-    private state;
-    private buffer;
-    private bufferLength;
-    private bytesHashed;
-    private finished;
-    constructor();
-    update(sourceData: SourceData): void;
-    digest(): Promise<Uint8Array>;
-    private hashBuffer;
-    reset(): void;
-}

package/node_modules/@smithy/fetch-http-handler/dist-es/stream-collector.js

@@ -1,53 +0,0 @@
-import { fromBase64 } from "@smithy/core/serde";
-export const streamCollector = async (stream) => {
-    if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
-        if (Blob.prototype.arrayBuffer !== undefined) {
-            return new Uint8Array(await stream.arrayBuffer());
-        }
-        return collectBlob(stream);
-    }
-    return collectStream(stream);
-};
-async function collectBlob(blob) {
-    const base64 = await readToBase64(blob);
-    const arrayBuffer = fromBase64(base64);
-    return new Uint8Array(arrayBuffer);
-}
-async function collectStream(stream) {
-    const chunks = [];
-    const reader = stream.getReader();
-    let isDone = false;
-    let length = 0;
-    while (!isDone) {
-        const { done, value } = await reader.read();
-        if (value) {
-            chunks.push(value);
-            length += value.length;
-        }
-        isDone = done;
-    }
-    const collected = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of chunks) {
-        collected.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return collected;
-}
-function readToBase64(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-            if (reader.readyState !== 2) {
-                return reject(new Error("Reader aborted too early"));
-            }
-            const result = (reader.result ?? "");
-            const commaIndex = result.indexOf(",");
-            const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-            resolve(result.substring(dataOffset));
-        };
-        reader.onabort = () => reject(new Error("Read aborted"));
-        reader.onerror = () => reject(reader.error);
-        reader.readAsDataURL(blob);
-    });
-}

package/node_modules/@smithy/fetch-http-handler/dist-types/stream-collector.d.ts

@@ -1,2 +0,0 @@
-import type { StreamCollector } from "@smithy/types";
-export declare const streamCollector: StreamCollector;

package/node_modules/@smithy/node-http-handler/dist-es/stream-collector/collector.js

@@ -1,8 +0,0 @@
-import { Writable } from "node:stream";
-export class Collector extends Writable {
-    bufferedBytes = [];
-    _write(chunk, encoding, callback) {
-        this.bufferedBytes.push(chunk);
-        callback();
-    }
-}