@cdk8s/awscdk-resolver 0.0.50 → 0.0.52

package/node_modules/@smithy/eventstream-codec/dist-cjs/index.js

@@ -1,11 +1,468 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./EventStreamCodec"), exports);
-tslib_1.__exportStar(require("./HeaderMarshaller"), exports);
-tslib_1.__exportStar(require("./Int64"), exports);
-tslib_1.__exportStar(require("./Message"), exports);
-tslib_1.__exportStar(require("./MessageDecoderStream"), exports);
-tslib_1.__exportStar(require("./MessageEncoderStream"), exports);
-tslib_1.__exportStar(require("./SmithyMessageDecoderStream"), exports);
-tslib_1.__exportStar(require("./SmithyMessageEncoderStream"), exports);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  EventStreamCodec: () => EventStreamCodec,
+  HeaderMarshaller: () => HeaderMarshaller,
+  Int64: () => Int64,
+  MessageDecoderStream: () => MessageDecoderStream,
+  MessageEncoderStream: () => MessageEncoderStream,
+  SmithyMessageDecoderStream: () => SmithyMessageDecoderStream,
+  SmithyMessageEncoderStream: () => SmithyMessageEncoderStream
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/EventStreamCodec.ts
+var import_crc322 = require("@aws-crypto/crc32");
+
+// src/HeaderMarshaller.ts
+
+
+// src/Int64.ts
+var import_util_hex_encoding = require("@smithy/util-hex-encoding");
+var _Int64 = class _Int64 {
+  constructor(bytes) {
+    this.bytes = bytes;
+    if (bytes.byteLength !== 8) {
+      throw new Error("Int64 buffers must be exactly 8 bytes");
+    }
+  }
+  static fromNumber(number) {
+    if (number > 9223372036854776e3 || number < -9223372036854776e3) {
+      throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
+    }
+    const bytes = new Uint8Array(8);
+    for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
+      bytes[i] = remaining;
+    }
+    if (number < 0) {
+      negate(bytes);
+    }
+    return new _Int64(bytes);
+  }
+  /**
+   * Called implicitly by infix arithmetic operators.
+   */
+  valueOf() {
+    const bytes = this.bytes.slice(0);
+    const negative = bytes[0] & 128;
+    if (negative) {
+      negate(bytes);
+    }
+    return parseInt((0, import_util_hex_encoding.toHex)(bytes), 16) * (negative ? -1 : 1);
+  }
+  toString() {
+    return String(this.valueOf());
+  }
+};
+__name(_Int64, "Int64");
+var Int64 = _Int64;
+function negate(bytes) {
+  for (let i = 0; i < 8; i++) {
+    bytes[i] ^= 255;
+  }
+  for (let i = 7; i > -1; i--) {
+    bytes[i]++;
+    if (bytes[i] !== 0)
+      break;
+  }
+}
+__name(negate, "negate");
+
+// src/HeaderMarshaller.ts
+var _HeaderMarshaller = class _HeaderMarshaller {
+  constructor(toUtf8, fromUtf8) {
+    this.toUtf8 = toUtf8;
+    this.fromUtf8 = fromUtf8;
+  }
+  format(headers) {
+    const chunks = [];
+    for (const headerName of Object.keys(headers)) {
+      const bytes = this.fromUtf8(headerName);
+      chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
+    }
+    const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
+    let position = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, position);
+      position += chunk.byteLength;
+    }
+    return out;
+  }
+  formatHeaderValue(header) {
+    switch (header.type) {
+      case "boolean":
+        return Uint8Array.from([header.value ? 0 /* boolTrue */ : 1 /* boolFalse */]);
+      case "byte":
+        return Uint8Array.from([2 /* byte */, header.value]);
+      case "short":
+        const shortView = new DataView(new ArrayBuffer(3));
+        shortView.setUint8(0, 3 /* short */);
+        shortView.setInt16(1, header.value, false);
+        return new Uint8Array(shortView.buffer);
+      case "integer":
+        const intView = new DataView(new ArrayBuffer(5));
+        intView.setUint8(0, 4 /* integer */);
+        intView.setInt32(1, header.value, false);
+        return new Uint8Array(intView.buffer);
+      case "long":
+        const longBytes = new Uint8Array(9);
+        longBytes[0] = 5 /* long */;
+        longBytes.set(header.value.bytes, 1);
+        return longBytes;
+      case "binary":
+        const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
+        binView.setUint8(0, 6 /* byteArray */);
+        binView.setUint16(1, header.value.byteLength, false);
+        const binBytes = new Uint8Array(binView.buffer);
+        binBytes.set(header.value, 3);
+        return binBytes;
+      case "string":
+        const utf8Bytes = this.fromUtf8(header.value);
+        const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
+        strView.setUint8(0, 7 /* string */);
+        strView.setUint16(1, utf8Bytes.byteLength, false);
+        const strBytes = new Uint8Array(strView.buffer);
+        strBytes.set(utf8Bytes, 3);
+        return strBytes;
+      case "timestamp":
+        const tsBytes = new Uint8Array(9);
+        tsBytes[0] = 8 /* timestamp */;
+        tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
+        return tsBytes;
+      case "uuid":
+        if (!UUID_PATTERN.test(header.value)) {
+          throw new Error(`Invalid UUID received: ${header.value}`);
+        }
+        const uuidBytes = new Uint8Array(17);
+        uuidBytes[0] = 9 /* uuid */;
+        uuidBytes.set((0, import_util_hex_encoding.fromHex)(header.value.replace(/\-/g, "")), 1);
+        return uuidBytes;
+    }
+  }
+  parse(headers) {
+    const out = {};
+    let position = 0;
+    while (position < headers.byteLength) {
+      const nameLength = headers.getUint8(position++);
+      const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
+      position += nameLength;
+      switch (headers.getUint8(position++)) {
+        case 0 /* boolTrue */:
+          out[name] = {
+            type: BOOLEAN_TAG,
+            value: true
+          };
+          break;
+        case 1 /* boolFalse */:
+          out[name] = {
+            type: BOOLEAN_TAG,
+            value: false
+          };
+          break;
+        case 2 /* byte */:
+          out[name] = {
+            type: BYTE_TAG,
+            value: headers.getInt8(position++)
+          };
+          break;
+        case 3 /* short */:
+          out[name] = {
+            type: SHORT_TAG,
+            value: headers.getInt16(position, false)
+          };
+          position += 2;
+          break;
+        case 4 /* integer */:
+          out[name] = {
+            type: INT_TAG,
+            value: headers.getInt32(position, false)
+          };
+          position += 4;
+          break;
+        case 5 /* long */:
+          out[name] = {
+            type: LONG_TAG,
+            value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8))
+          };
+          position += 8;
+          break;
+        case 6 /* byteArray */:
+          const binaryLength = headers.getUint16(position, false);
+          position += 2;
+          out[name] = {
+            type: BINARY_TAG,
+            value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength)
+          };
+          position += binaryLength;
+          break;
+        case 7 /* string */:
+          const stringLength = headers.getUint16(position, false);
+          position += 2;
+          out[name] = {
+            type: STRING_TAG,
+            value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength))
+          };
+          position += stringLength;
+          break;
+        case 8 /* timestamp */:
+          out[name] = {
+            type: TIMESTAMP_TAG,
+            value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf())
+          };
+          position += 8;
+          break;
+        case 9 /* uuid */:
+          const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
+          position += 16;
+          out[name] = {
+            type: UUID_TAG,
+            value: `${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(0, 4))}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(4, 6))}-${(0, import_util_hex_encoding.toHex)(
+              uuidBytes.subarray(6, 8)
+            )}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(8, 10))}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(10))}`
+          };
+          break;
+        default:
+          throw new Error(`Unrecognized header type tag`);
+      }
+    }
+    return out;
+  }
+};
+__name(_HeaderMarshaller, "HeaderMarshaller");
+var HeaderMarshaller = _HeaderMarshaller;
+var BOOLEAN_TAG = "boolean";
+var BYTE_TAG = "byte";
+var SHORT_TAG = "short";
+var INT_TAG = "integer";
+var LONG_TAG = "long";
+var BINARY_TAG = "binary";
+var STRING_TAG = "string";
+var TIMESTAMP_TAG = "timestamp";
+var UUID_TAG = "uuid";
+var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+
+// src/splitMessage.ts
+var import_crc32 = require("@aws-crypto/crc32");
+var PRELUDE_MEMBER_LENGTH = 4;
+var PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
+var CHECKSUM_LENGTH = 4;
+var MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
+function splitMessage({ byteLength, byteOffset, buffer }) {
+  if (byteLength < MINIMUM_MESSAGE_LENGTH) {
+    throw new Error("Provided message too short to accommodate event stream message overhead");
+  }
+  const view = new DataView(buffer, byteOffset, byteLength);
+  const messageLength = view.getUint32(0, false);
+  if (byteLength !== messageLength) {
+    throw new Error("Reported message length does not match received message length");
+  }
+  const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
+  const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
+  const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
+  const checksummer = new import_crc32.Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+  if (expectedPreludeChecksum !== checksummer.digest()) {
+    throw new Error(
+      `The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`
+    );
+  }
+  checksummer.update(
+    new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH))
+  );
+  if (expectedMessageChecksum !== checksummer.digest()) {
+    throw new Error(
+      `The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`
+    );
+  }
+  return {
+    headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
+    body: new Uint8Array(
+      buffer,
+      byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength,
+      messageLength - headerLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH)
+    )
+  };
+}
+__name(splitMessage, "splitMessage");
+
+// src/EventStreamCodec.ts
+var _EventStreamCodec = class _EventStreamCodec {
+  constructor(toUtf8, fromUtf8) {
+    this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
+    this.messageBuffer = [];
+    this.isEndOfStream = false;
+  }
+  feed(message) {
+    this.messageBuffer.push(this.decode(message));
+  }
+  endOfStream() {
+    this.isEndOfStream = true;
+  }
+  getMessage() {
+    const message = this.messageBuffer.pop();
+    const isEndOfStream = this.isEndOfStream;
+    return {
+      getMessage() {
+        return message;
+      },
+      isEndOfStream() {
+        return isEndOfStream;
+      }
+    };
+  }
+  getAvailableMessages() {
+    const messages = this.messageBuffer;
+    this.messageBuffer = [];
+    const isEndOfStream = this.isEndOfStream;
+    return {
+      getMessages() {
+        return messages;
+      },
+      isEndOfStream() {
+        return isEndOfStream;
+      }
+    };
+  }
+  /**
+   * Convert a structured JavaScript object with tagged headers into a binary
+   * event stream message.
+   */
+  encode({ headers: rawHeaders, body }) {
+    const headers = this.headerMarshaller.format(rawHeaders);
+    const length = headers.byteLength + body.byteLength + 16;
+    const out = new Uint8Array(length);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    const checksum = new import_crc322.Crc32();
+    view.setUint32(0, length, false);
+    view.setUint32(4, headers.byteLength, false);
+    view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
+    out.set(headers, 12);
+    out.set(body, headers.byteLength + 12);
+    view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
+    return out;
+  }
+  /**
+   * Convert a binary event stream message into a JavaScript object with an
+   * opaque, binary body and tagged, parsed headers.
+   */
+  decode(message) {
+    const { headers, body } = splitMessage(message);
+    return { headers: this.headerMarshaller.parse(headers), body };
+  }
+  /**
+   * Convert a structured JavaScript object with tagged headers into a binary
+   * event stream message header.
+   */
+  formatHeaders(rawHeaders) {
+    return this.headerMarshaller.format(rawHeaders);
+  }
+};
+__name(_EventStreamCodec, "EventStreamCodec");
+var EventStreamCodec = _EventStreamCodec;
+
+// src/MessageDecoderStream.ts
+var _MessageDecoderStream = class _MessageDecoderStream {
+  constructor(options) {
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    return this.asyncIterator();
+  }
+  async *asyncIterator() {
+    for await (const bytes of this.options.inputStream) {
+      const decoded = this.options.decoder.decode(bytes);
+      yield decoded;
+    }
+  }
+};
+__name(_MessageDecoderStream, "MessageDecoderStream");
+var MessageDecoderStream = _MessageDecoderStream;
+
+// src/MessageEncoderStream.ts
+var _MessageEncoderStream = class _MessageEncoderStream {
+  constructor(options) {
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    return this.asyncIterator();
+  }
+  async *asyncIterator() {
+    for await (const msg of this.options.messageStream) {
+      const encoded = this.options.encoder.encode(msg);
+      yield encoded;
+    }
+    if (this.options.includeEndFrame) {
+      yield new Uint8Array(0);
+    }
+  }
+};
+__name(_MessageEncoderStream, "MessageEncoderStream");
+var MessageEncoderStream = _MessageEncoderStream;
+
+// src/SmithyMessageDecoderStream.ts
+var _SmithyMessageDecoderStream = class _SmithyMessageDecoderStream {
+  constructor(options) {
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    return this.asyncIterator();
+  }
+  async *asyncIterator() {
+    for await (const message of this.options.messageStream) {
+      const deserialized = await this.options.deserializer(message);
+      if (deserialized === void 0)
+        continue;
+      yield deserialized;
+    }
+  }
+};
+__name(_SmithyMessageDecoderStream, "SmithyMessageDecoderStream");
+var SmithyMessageDecoderStream = _SmithyMessageDecoderStream;
+
+// src/SmithyMessageEncoderStream.ts
+var _SmithyMessageEncoderStream = class _SmithyMessageEncoderStream {
+  constructor(options) {
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    return this.asyncIterator();
+  }
+  async *asyncIterator() {
+    for await (const chunk of this.options.inputStream) {
+      const payloadBuf = this.options.serializer(chunk);
+      yield payloadBuf;
+    }
+  }
+};
+__name(_SmithyMessageEncoderStream, "SmithyMessageEncoderStream");
+var SmithyMessageEncoderStream = _SmithyMessageEncoderStream;
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  EventStreamCodec,
+  HeaderMarshaller,
+  Int64,
+  MessageDecoderStream,
+  MessageEncoderStream,
+  SmithyMessageDecoderStream,
+  SmithyMessageEncoderStream
+});
+

package/node_modules/@smithy/eventstream-codec/dist-cjs/splitMessage.js

@@ -1,34 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitMessage = void 0;
-const crc32_1 = require("@aws-crypto/crc32");
-const PRELUDE_MEMBER_LENGTH = 4;
-const PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
-const CHECKSUM_LENGTH = 4;
-const MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
-function splitMessage({ byteLength, byteOffset, buffer }) {
-    if (byteLength < MINIMUM_MESSAGE_LENGTH) {
-        throw new Error("Provided message too short to accommodate event stream message overhead");
-    }
-    const view = new DataView(buffer, byteOffset, byteLength);
-    const messageLength = view.getUint32(0, false);
-    if (byteLength !== messageLength) {
-        throw new Error("Reported message length does not match received message length");
-    }
-    const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
-    const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
-    const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
-    const checksummer = new crc32_1.Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
-    if (expectedPreludeChecksum !== checksummer.digest()) {
-        throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`);
-    }
-    checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
-    if (expectedMessageChecksum !== checksummer.digest()) {
-        throw new Error(`The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`);
-    }
-    return {
-        headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
-        body: new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength, messageLength - headerLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH)),
-    };
-}
-exports.splitMessage = splitMessage;
+module.exports = require("./index.js");

package/node_modules/@smithy/eventstream-codec/dist-cjs/vectorTypes.fixture.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = require("./index.js");

package/node_modules/@smithy/eventstream-codec/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@smithy/eventstream-codec",
-  "version": "2.0.16",
+  "version": "2.1.1",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
-    "build:cjs": "yarn g:tsc -p tsconfig.cjs.json",
+    "build:cjs": "node ../../scripts/inline eventstream-codec",
     "build:es": "yarn g:tsc -p tsconfig.es.json",
     "build:types": "yarn g:tsc -p tsconfig.types.json",
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
@@ -23,12 +23,12 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@aws-crypto/crc32": "3.0.0",
-    "@smithy/types": "^2.8.0",
-    "@smithy/util-hex-encoding": "^2.0.0",
+    "@smithy/types": "^2.9.1",
+    "@smithy/util-hex-encoding": "^2.1.1",
     "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@smithy/util-utf8": "^2.0.2",
+    "@smithy/util-utf8": "^2.1.1",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^14.14.31",
     "concurrently": "7.0.0",

package/node_modules/@smithy/fetch-http-handler/dist-cjs/fetch-http-handler.js

@@ -1,117 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FetchHttpHandler = exports.keepAliveSupport = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const querystring_builder_1 = require("@smithy/querystring-builder");
-const request_timeout_1 = require("./request-timeout");
-exports.keepAliveSupport = {
-    supported: Boolean(typeof Request !== "undefined" && "keepalive" in new Request("https://[::1]")),
-};
-class FetchHttpHandler {
-    static create(instanceOrOptions) {
-        if (typeof (instanceOrOptions === null || instanceOrOptions === void 0 ? void 0 : instanceOrOptions.handle) === "function") {
-            return instanceOrOptions;
-        }
-        return new FetchHttpHandler(instanceOrOptions);
-    }
-    constructor(options) {
-        if (typeof options === "function") {
-            this.configProvider = options().then((opts) => opts || {});
-        }
-        else {
-            this.config = options !== null && options !== void 0 ? options : {};
-            this.configProvider = Promise.resolve(this.config);
-        }
-    }
-    destroy() {
-    }
-    async handle(request, { abortSignal } = {}) {
-        var _a, _b;
-        if (!this.config) {
-            this.config = await this.configProvider;
-        }
-        const requestTimeoutInMs = this.config.requestTimeout;
-        const keepAlive = this.config.keepAlive === true;
-        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-            const abortError = new Error("Request aborted");
-            abortError.name = "AbortError";
-            return Promise.reject(abortError);
-        }
-        let path = request.path;
-        const queryString = (0, querystring_builder_1.buildQueryString)(request.query || {});
-        if (queryString) {
-            path += `?${queryString}`;
-        }
-        if (request.fragment) {
-            path += `#${request.fragment}`;
-        }
-        let auth = "";
-        if (request.username != null || request.password != null) {
-            const username = (_a = request.username) !== null && _a !== void 0 ? _a : "";
-            const password = (_b = request.password) !== null && _b !== void 0 ? _b : "";
-            auth = `${username}:${password}@`;
-        }
-        const { port, method } = request;
-        const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path}`;
-        const body = method === "GET" || method === "HEAD" ? undefined : request.body;
-        const requestOptions = { body, headers: new Headers(request.headers), method: method };
-        if (typeof AbortController !== "undefined") {
-            requestOptions["signal"] = abortSignal;
-        }
-        if (exports.keepAliveSupport.supported) {
-            requestOptions["keepalive"] = keepAlive;
-        }
-        const fetchRequest = new Request(url, requestOptions);
-        const raceOfPromises = [
-            fetch(fetchRequest).then((response) => {
-                const fetchHeaders = response.headers;
-                const transformedHeaders = {};
-                for (const pair of fetchHeaders.entries()) {
-                    transformedHeaders[pair[0]] = pair[1];
-                }
-                const hasReadableStream = response.body != undefined;
-                if (!hasReadableStream) {
-                    return response.blob().then((body) => ({
-                        response: new protocol_http_1.HttpResponse({
-                            headers: transformedHeaders,
-                            reason: response.statusText,
-                            statusCode: response.status,
-                            body,
-                        }),
-                    }));
-                }
-                return {
-                    response: new protocol_http_1.HttpResponse({
-                        headers: transformedHeaders,
-                        reason: response.statusText,
-                        statusCode: response.status,
-                        body: response.body,
-                    }),
-                };
-            }),
-            (0, request_timeout_1.requestTimeout)(requestTimeoutInMs),
-        ];
-        if (abortSignal) {
-            raceOfPromises.push(new Promise((resolve, reject) => {
-                abortSignal.onabort = () => {
-                    const abortError = new Error("Request aborted");
-                    abortError.name = "AbortError";
-                    reject(abortError);
-                };
-            }));
-        }
-        return Promise.race(raceOfPromises);
-    }
-    updateHttpClientConfig(key, value) {
-        this.config = undefined;
-        this.configProvider = this.configProvider.then((config) => {
-            config[key] = value;
-            return config;
-        });
-    }
-    httpHandlerConfigs() {
-        var _a;
-        return (_a = this.config) !== null && _a !== void 0 ? _a : {};
-    }
-}
-exports.FetchHttpHandler = FetchHttpHandler;
+module.exports = require("./index.js");