@cdklabs/cdk-ssm-documents 0.0.63 → 0.0.65

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

@@ -5,6 +5,30 @@
 
 import { XML as DEFAULT_XML_ENTITIES } from "./entities.js"
 
+// ---------------------------------------------------------------------------
+// Entity hook action constants
+// ---------------------------------------------------------------------------
+
+/**
+ * Action constants for `onExternalEntity` and `onInputEntity` hooks.
+ *
+ * Use these instead of raw strings to avoid typos:
+ *
+ * @example
+ * import EntityDecoder, { ENTITY_ACTION } from './EntityDecoder.js';
+ * const dec = new EntityDecoder({
+ *   onInputEntity: (name, value) => ENTITY_ACTION.BLOCK,
+ * });
+ */
+export const ENTITY_ACTION = Object.freeze({
+  /** Resolve and expand the entity normally. */
+  ALLOW: 'allow',
+  /** Silently skip this entity — it will not be registered. */
+  BLOCK: 'block',
+  /** Throw an error, aborting entity registration entirely. */
+  THROW: 'throw',
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -169,6 +193,14 @@ export default class EntityDecoder {
    *   the effective action is max(onNCR, rangeMinimum).
    * @param {'remove'|'throw'} [options.ncr.nullNCR='remove']
    *   Action for U+0000 (null). 'allow' and 'leave' are clamped to 'remove' since null is never safe.
+   * @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} [options.onExternalEntity=null]
+   *   Hook called when an external entity is registered via `setExternalEntities()` or
+   *   `addExternalEntity()`. Return `ENTITY_ACTION.ALLOW` to accept the entity,
+   *   `ENTITY_ACTION.BLOCK` to silently skip it, or `ENTITY_ACTION.THROW` to abort with an error.
+   * @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} [options.onInputEntity=null]
+   *   Hook called when an input entity is registered via `addInputEntities()`. Return
+   *   `ENTITY_ACTION.ALLOW` to accept, `ENTITY_ACTION.BLOCK` to silently skip, or
+   *   `ENTITY_ACTION.THROW` to abort with an error.
    */
   constructor(options = {}) {
     this._limit = options.limit || {};
@@ -204,6 +236,43 @@ export default class EntityDecoder {
     this._ncrXmlVersion = ncrCfg.xmlVersion;
     this._ncrOnLevel = ncrCfg.onLevel;
     this._ncrNullLevel = ncrCfg.nullLevel;
+
+    // --- Registration hooks ---
+    /** @type {((name: string, value: string) => 'allow'|'block'|'throw')|null} */
+    this._onExternalEntity = typeof options.onExternalEntity === 'function'
+      ? options.onExternalEntity
+      : null;
+    /** @type {((name: string, value: string) => 'allow'|'block'|'throw')|null} */
+    this._onInputEntity = typeof options.onInputEntity === 'function'
+      ? options.onInputEntity
+      : null;
+  }
+
+  // -------------------------------------------------------------------------
+  // Private: registration hook dispatch
+  // -------------------------------------------------------------------------
+
+  /**
+   * Invoke a registration hook for a single entity name/value pair.
+   * Returns true when the entity should be accepted, false when it should be
+   * silently skipped (BLOCK), and throws when the hook returns THROW.
+   *
+   * @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} hook
+   * @param {string} name
+   * @param {string} value
+   * @param {string} context  — used in error messages ('external' | 'input')
+   * @returns {boolean}  true = accept, false = skip
+   */
+  _applyRegistrationHook(hook, name, value, context) {
+    if (!hook) return true; // no hook → always accept
+    const action = hook(name, value);
+    if (action === ENTITY_ACTION.BLOCK) return false;
+    if (action === ENTITY_ACTION.THROW) {
+      throw new Error(
+        `[EntityDecoder] Registration of ${context} entity "&${name};" was rejected by hook`
+      );
+    }
+    return true; // ALLOW or any unknown return value → accept
   }
 
   // -------------------------------------------------------------------------
@@ -213,6 +282,9 @@ export default class EntityDecoder {
   /**
    * Replace the full set of persistent external entities.
    * All keys are validated — throws on invalid characters.
+   * If `onExternalEntity` is set, it is called once per entry; entries that
+   * return `ENTITY_ACTION.BLOCK` are silently omitted, `ENTITY_ACTION.THROW`
+   * aborts the whole call.
    * @param {Record<string, string | { regex?: RegExp, val: string }>} map
    */
   setExternalEntities(map) {
@@ -221,18 +293,34 @@ export default class EntityDecoder {
         validateEntityName(key);
       }
     }
-    this._externalMap = mergeEntityMaps(map);
+    if (!this._onExternalEntity) {
+      this._externalMap = mergeEntityMaps(map);
+      return;
+    }
+    // Hook present — resolve values first, then filter
+    const flat = mergeEntityMaps(map);
+    const filtered = Object.create(null);
+    for (const [name, value] of Object.entries(flat)) {
+      if (this._applyRegistrationHook(this._onExternalEntity, name, value, 'external')) {
+        filtered[name] = value;
+      }
+    }
+    this._externalMap = filtered;
   }
 
   /**
    * Add a single persistent external entity.
+   * If `onExternalEntity` is set it is called before the entity is stored;
+   * `ENTITY_ACTION.BLOCK` silently skips storage, `ENTITY_ACTION.THROW` raises.
    * @param {string} key
    * @param {string} value
    */
   addExternalEntity(key, value) {
     validateEntityName(key);
     if (typeof value === 'string' && value.indexOf('&') === -1) {
-      this._externalMap[key] = value;
+      if (this._applyRegistrationHook(this._onExternalEntity, key, value, 'external')) {
+        this._externalMap[key] = value;
+      }
     }
   }
 
@@ -243,12 +331,25 @@ export default class EntityDecoder {
   /**
    * Inject DOCTYPE entities for the current document.
    * Also resets per-document expansion counters.
+   * If `onInputEntity` is set it is called once per entry; entries returning
+   * `ENTITY_ACTION.BLOCK` are silently omitted, `ENTITY_ACTION.THROW` aborts.
    * @param {Record<string, string | { regx?: RegExp, regex?: RegExp, val: string }>} map
    */
   addInputEntities(map) {
     this._totalExpansions = 0;
     this._expandedLength = 0;
-    this._inputMap = mergeEntityMaps(map);
+    if (!this._onInputEntity) {
+      this._inputMap = mergeEntityMaps(map);
+      return;
+    }
+    const flat = mergeEntityMaps(map);
+    const filtered = Object.create(null);
+    for (const [name, value] of Object.entries(flat)) {
+      if (this._applyRegistrationHook(this._onInputEntity, name, value, 'input')) {
+        filtered[name] = value;
+      }
+    }
+    this._inputMap = filtered;
   }
 
   // -------------------------------------------------------------------------

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

@@ -5,6 +5,50 @@
 /** 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
 // ---------------------------------------------------------------------------
@@ -191,6 +235,39 @@ export interface EntityDecoderOptions {
    * 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;
 }
 
 // ---------------------------------------------------------------------------

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

@@ -6,7 +6,7 @@
 
  */
 
-export { default as EntityDecoder } from './EntityDecoder.js';
+export { default as EntityDecoder, ENTITY_ACTION } from './EntityDecoder.js';
 export {
   COMMON_HTML,
   XML,

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

@@ -1,9 +1,9 @@
-'use strict';
-
-var transport = require('@smithy/core/transport');
-var protocols = require('@smithy/core/protocols');
-var types = require('@smithy/types');
-var client = require('@smithy/core/client');
+const { getSmithyContext } = require("@smithy/core/transport");
+exports.getSmithyContext = getSmithyContext;
+const { HttpRequest } = require("@smithy/core/protocols");
+const { requestBuilder } = require("@smithy/core/protocols");
+exports.requestBuilder = requestBuilder;
+const { HttpApiKeyAuthLocation } = require("@smithy/types");
 
 const resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
     if (!authSchemePreference || authSchemePreference.length === 0) {
@@ -38,7 +38,7 @@ const httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async
     const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
     const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
     const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-    const smithyContext = client.getSmithyContext(context);
+    const smithyContext = getSmithyContext(context);
     const failureReasons = [];
     for (const option of resolvedOptions) {
         const scheme = authSchemes.get(option.schemeId);
@@ -106,10 +106,10 @@ const defaultErrorHandler = (signingProperties) => (error) => {
 };
 const defaultSuccessHandler = (httpResponse, signingProperties) => { };
 const httpSigningMiddleware = (config) => (next, context) => async (args) => {
-    if (!protocols.HttpRequest.isInstance(args.request)) {
+    if (!HttpRequest.isInstance(args.request)) {
         return next(args);
     }
-    const smithyContext = client.getSmithyContext(context);
+    const smithyContext = getSmithyContext(context);
     const scheme = smithyContext.selectedHttpAuthScheme;
     if (!scheme) {
         throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
@@ -228,11 +228,11 @@ class HttpApiKeyAuthSigner {
         if (!identity.apiKey) {
             throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
         }
-        const clonedRequest = protocols.HttpRequest.clone(httpRequest);
-        if (signingProperties.in === types.HttpApiKeyAuthLocation.QUERY) {
+        const clonedRequest = HttpRequest.clone(httpRequest);
+        if (signingProperties.in === HttpApiKeyAuthLocation.QUERY) {
             clonedRequest.query[signingProperties.name] = identity.apiKey;
         }
-        else if (signingProperties.in === types.HttpApiKeyAuthLocation.HEADER) {
+        else if (signingProperties.in === HttpApiKeyAuthLocation.HEADER) {
             clonedRequest.headers[signingProperties.name] = signingProperties.scheme
                 ? `${signingProperties.scheme} ${identity.apiKey}`
                 : identity.apiKey;
@@ -249,7 +249,7 @@ class HttpApiKeyAuthSigner {
 
 class HttpBearerAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
-        const clonedRequest = protocols.HttpRequest.clone(httpRequest);
+        const clonedRequest = HttpRequest.clone(httpRequest);
         if (!identity.token) {
             throw new Error("request could not be signed with `token` since the `token` is not defined");
         }
@@ -320,8 +320,6 @@ const memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
     };
 };
 
-exports.getSmithyContext = transport.getSmithyContext;
-exports.requestBuilder = protocols.requestBuilder;
 exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig;
 exports.EXPIRATION_MS = EXPIRATION_MS;
 exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner;

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

@@ -1,9 +1,7 @@
-'use strict';
-
-var serde = require('@smithy/core/serde');
-var protocols = require('@smithy/core/protocols');
-var client = require('@smithy/core/client');
-var schema = require('@smithy/core/schema');
+const { nv, toUtf8, fromUtf8, NumericValue, calculateBodyLength, _parseEpochTimestamp, fromBase64, generateIdempotencyToken } = require("@smithy/core/serde");
+const { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require("@smithy/core/protocols");
+const { NormalizedSchema, deref, TypeRegistry } = require("@smithy/core/schema");
+const { getSmithyContext } = require("@smithy/core/transport");
 
 const majorUint64 = 0;
 const majorNegativeInt64 = 1;
@@ -133,7 +131,7 @@ function decode(at, to) {
                     }
                     numericString = sign + numericString;
                     _offset = offset + _offset;
-                    return serde.nv(numericString);
+                    return nv(numericString);
                 }
                 else {
                     const value = decode(at + offset, to);
@@ -181,7 +179,7 @@ function bytesToUtf8(bytes, at, to) {
     if (textDecoder) {
         return textDecoder.decode(bytes.subarray(at, to));
     }
-    return serde.toUtf8(bytes.subarray(at, to));
+    return toUtf8(bytes.subarray(at, to));
 }
 function demote(bigInteger) {
     const num = Number(bigInteger);
@@ -525,7 +523,7 @@ function encode(_input) {
                 cursor += data.write(input, cursor);
             }
             else {
-                const bytes = serde.fromUtf8(input);
+                const bytes = fromUtf8(input);
                 encodeHeader(majorUtf8String, bytes.byteLength);
                 data.set(bytes, cursor);
                 cursor += bytes.byteLength;
@@ -641,7 +639,7 @@ function encode(_input) {
             continue;
         }
         else if (typeof input === "object") {
-            if (input instanceof serde.NumericValue) {
+            if (input instanceof NumericValue) {
                 const decimalIndex = input.string.indexOf(".");
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
@@ -695,7 +693,7 @@ const cbor = {
 };
 
 const parseCborBody = (streamBody, context) => {
-    return protocols.collectBody(streamBody, context).then(async (bytes) => {
+    return collectBody(streamBody, context).then(async (bytes) => {
         if (bytes.length) {
             try {
                 return cbor.deserialize(bytes);
@@ -781,14 +779,14 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
     if (body !== undefined) {
         contents.body = body;
         try {
-            contents.headers["content-length"] = String(serde.calculateBodyLength(body));
+            contents.headers["content-length"] = String(calculateBodyLength(body));
         }
         catch (e) { }
     }
-    return new protocols.HttpRequest(contents);
+    return new HttpRequest(contents);
 };
 
-class CborCodec extends protocols.SerdeContext {
+class CborCodec extends SerdeContext {
     createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -800,22 +798,22 @@ class CborCodec extends protocols.SerdeContext {
         return deserializer;
     }
 }
-class CborShapeSerializer extends protocols.SerdeContext {
+class CborShapeSerializer extends SerdeContext {
     value;
     write(schema, value) {
         this.value = this.serialize(schema, value);
     }
-    serialize(schema$1, source) {
-        const ns = schema.NormalizedSchema.of(schema$1);
+    serialize(schema, source) {
+        const ns = NormalizedSchema.of(schema);
         if (source == null) {
             if (ns.isIdempotencyToken()) {
-                return serde.generateIdempotencyToken();
+                return generateIdempotencyToken();
             }
             return source;
         }
         if (ns.isBlobSchema()) {
             if (typeof source === "string") {
-                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(source);
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
             }
             return source;
         }
@@ -890,26 +888,26 @@ class CborShapeSerializer extends protocols.SerdeContext {
         return buffer;
     }
 }
-class CborShapeDeserializer extends protocols.SerdeContext {
+class CborShapeDeserializer extends SerdeContext {
     read(schema, bytes) {
         const data = cbor.deserialize(bytes);
         return this.readValue(schema, data);
     }
     readValue(_schema, value) {
-        const ns = schema.NormalizedSchema.of(_schema);
+        const ns = NormalizedSchema.of(_schema);
         if (ns.isTimestampSchema()) {
             if (typeof value === "number") {
-                return serde._parseEpochTimestamp(value);
+                return _parseEpochTimestamp(value);
             }
             if (typeof value === "object") {
                 if (value.tag === 1 && "value" in value) {
-                    return serde._parseEpochTimestamp(value.value);
+                    return _parseEpochTimestamp(value.value);
                 }
             }
         }
         if (ns.isBlobSchema()) {
             if (typeof value === "string") {
-                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(value);
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
             }
             return value;
         }
@@ -989,7 +987,7 @@ class CborShapeDeserializer extends protocols.SerdeContext {
                     }
                 }
             }
-            else if (value instanceof serde.NumericValue) {
+            else if (value instanceof NumericValue) {
                 return value;
             }
             return newObject;
@@ -1000,7 +998,7 @@ class CborShapeDeserializer extends protocols.SerdeContext {
     }
 }
 
-class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
+class SmithyRpcV2CborProtocol extends RpcProtocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
@@ -1020,7 +1018,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             "smithy-protocol": "rpc-v2-cbor",
             accept: this.getDefaultContentType(),
         });
-        if (schema.deref(operationSchema.input) === "unit") {
+        if (deref(operationSchema.input) === "unit") {
             delete request.body;
             delete request.headers["content-type"];
         }
@@ -1034,7 +1032,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             }
             catch (e) { }
         }
-        const { service, operation } = client.getSmithyContext(context);
+        const { service, operation } = getSmithyContext(context);
         const path = `/service/${service}/operation/${operation}`;
         if (request.path.endsWith("/")) {
             request.path += path.slice(1);
@@ -1058,7 +1056,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             [namespace] = errorName.split("#");
         }
         const registry = this.compositeErrorRegistry;
-        const nsRegistry = schema.TypeRegistry.for(namespace);
+        const nsRegistry = TypeRegistry.for(namespace);
         registry.copyFrom(nsRegistry);
         let errorSchema;
         try {
@@ -1068,7 +1066,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             if (dataObject.Message) {
                 dataObject.message = dataObject.Message;
             }
-            const syntheticRegistry = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
             registry.copyFrom(syntheticRegistry);
             const baseExceptionSchema = registry.getBaseException();
             if (baseExceptionSchema) {
@@ -1077,7 +1075,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             }
             throw Object.assign(new Error(errorName), errorMetadata, dataObject);
         }
-        const ns = schema.NormalizedSchema.of(errorSchema);
+        const ns = NormalizedSchema.of(errorSchema);
         const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
         const exception = new ErrorCtor({});

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

@@ -1,6 +1,4 @@
-'use strict';
-
-var serde = require('@smithy/core/serde');
+const { fromUtf8 } = require("@smithy/core/serde");
 
 async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
     const size = blob.size;
@@ -183,7 +181,7 @@ function isEmptyData(data) {
 }
 function convertToBuffer(data) {
     if (typeof data === "string") {
-        return serde.fromUtf8(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);

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

@@ -1,8 +1,6 @@
-'use strict';
-
-var node_fs = require('node:fs');
-var node_stream = require('node:stream');
-var serde = require('@smithy/core/serde');
+const { createReadStream } = require("node:fs");
+const { Writable } = require("node:stream");
+const { toUint8Array, fromUtf8 } = require("@smithy/core/serde");
 
 async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
     const size = blob.size;
@@ -22,7 +20,7 @@ const blobHasher = async function blobHasher(hashCtor, blob) {
     return hash.digest();
 };
 
-class HashCalculator extends node_stream.Writable {
+class HashCalculator extends Writable {
     hash;
     constructor(hash, options) {
         super(options);
@@ -30,7 +28,7 @@ class HashCalculator extends node_stream.Writable {
     }
     _write(chunk, encoding, callback) {
         try {
-            this.hash.update(serde.toUint8Array(chunk));
+            this.hash.update(toUint8Array(chunk));
         }
         catch (err) {
             return callback(err);
@@ -44,7 +42,7 @@ const fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject)
         reject(new Error("Unable to calculate hash for non-file streams."));
         return;
     }
-    const fileStreamTee = node_fs.createReadStream(fileStream.path, {
+    const fileStreamTee = createReadStream(fileStream.path, {
         start: fileStream.start,
         end: fileStream.end,
     });
@@ -244,7 +242,7 @@ function isEmptyData(data) {
 }
 function convertToBuffer(data) {
     if (typeof data === "string") {
-        return serde.fromUtf8(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);

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

@@ -1,6 +1,4 @@
-'use strict';
-
-var serde = require('@smithy/core/serde');
+const { fromUtf8, fromBase64 } = require("@smithy/core/serde");
 
 async function blobReader$1(blob, onChunk, chunkSize = 1024 * 1024) {
     const size = blob.size;
@@ -183,7 +181,7 @@ function isEmptyData(data) {
 }
 function convertToBuffer(data) {
     if (typeof data === "string") {
-        return serde.fromUtf8(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
@@ -209,7 +207,7 @@ function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
             const result = event.target.result;
             const dataOffset = result.indexOf(",") + 1;
             const data = result.substring(dataOffset);
-            const decoded = serde.fromBase64(data);
+            const decoded = fromBase64(data);
             onChunk(decoded);
             totalBytesRead += decoded.byteLength;
             read();