@ndlib/ndlib-cdk2 1.0.20 → 1.0.21

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/index.js

@@ -1,8 +1,484 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/isIpAddress"), exports);
-tslib_1.__exportStar(require("./lib/isValidHostLabel"), exports);
-tslib_1.__exportStar(require("./utils/customEndpointFunctions"), exports);
-tslib_1.__exportStar(require("./resolveEndpoint"), exports);
-tslib_1.__exportStar(require("./types"), 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, {
+  EndpointError: () => EndpointError,
+  customEndpointFunctions: () => customEndpointFunctions,
+  isIpAddress: () => isIpAddress,
+  isValidHostLabel: () => isValidHostLabel,
+  resolveEndpoint: () => resolveEndpoint
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/isIpAddress.ts
+var IP_V4_REGEX = new RegExp(
+  `^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`
+);
+var isIpAddress = /* @__PURE__ */ __name((value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]"), "isIpAddress");
+
+// src/lib/isValidHostLabel.ts
+var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
+var isValidHostLabel = /* @__PURE__ */ __name((value, allowSubDomains = false) => {
+  if (!allowSubDomains) {
+    return VALID_HOST_LABEL_REGEX.test(value);
+  }
+  const labels = value.split(".");
+  for (const label of labels) {
+    if (!isValidHostLabel(label)) {
+      return false;
+    }
+  }
+  return true;
+}, "isValidHostLabel");
+
+// src/utils/customEndpointFunctions.ts
+var customEndpointFunctions = {};
+
+// src/debug/debugId.ts
+var debugId = "endpoints";
+
+// src/debug/toDebugString.ts
+function toDebugString(input) {
+  if (typeof input !== "object" || input == null) {
+    return input;
+  }
+  if ("ref" in input) {
+    return `$${toDebugString(input.ref)}`;
+  }
+  if ("fn" in input) {
+    return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`;
+  }
+  return JSON.stringify(input, null, 2);
+}
+__name(toDebugString, "toDebugString");
+
+// src/types/EndpointError.ts
+var _EndpointError = class _EndpointError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EndpointError";
+  }
+};
+__name(_EndpointError, "EndpointError");
+var EndpointError = _EndpointError;
+
+// src/lib/booleanEquals.ts
+var booleanEquals = /* @__PURE__ */ __name((value1, value2) => value1 === value2, "booleanEquals");
+
+// src/lib/getAttrPathList.ts
+var getAttrPathList = /* @__PURE__ */ __name((path) => {
+  const parts = path.split(".");
+  const pathList = [];
+  for (const part of parts) {
+    const squareBracketIndex = part.indexOf("[");
+    if (squareBracketIndex !== -1) {
+      if (part.indexOf("]") !== part.length - 1) {
+        throw new EndpointError(`Path: '${path}' does not end with ']'`);
+      }
+      const arrayIndex = part.slice(squareBracketIndex + 1, -1);
+      if (Number.isNaN(parseInt(arrayIndex))) {
+        throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
+      }
+      if (squareBracketIndex !== 0) {
+        pathList.push(part.slice(0, squareBracketIndex));
+      }
+      pathList.push(arrayIndex);
+    } else {
+      pathList.push(part);
+    }
+  }
+  return pathList;
+}, "getAttrPathList");
+
+// src/lib/getAttr.ts
+var getAttr = /* @__PURE__ */ __name((value, path) => getAttrPathList(path).reduce((acc, index) => {
+  if (typeof acc !== "object") {
+    throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
+  } else if (Array.isArray(acc)) {
+    return acc[parseInt(index)];
+  }
+  return acc[index];
+}, value), "getAttr");
+
+// src/lib/isSet.ts
+var isSet = /* @__PURE__ */ __name((value) => value != null, "isSet");
+
+// src/lib/not.ts
+var not = /* @__PURE__ */ __name((value) => !value, "not");
+
+// src/lib/parseURL.ts
+var import_types3 = require("@smithy/types");
+var DEFAULT_PORTS = {
+  [import_types3.EndpointURLScheme.HTTP]: 80,
+  [import_types3.EndpointURLScheme.HTTPS]: 443
+};
+var parseURL = /* @__PURE__ */ __name((value) => {
+  const whatwgURL = (() => {
+    try {
+      if (value instanceof URL) {
+        return value;
+      }
+      if (typeof value === "object" && "hostname" in value) {
+        const { hostname: hostname2, port, protocol: protocol2 = "", path = "", query = {} } = value;
+        const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path}`);
+        url.search = Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&");
+        return url;
+      }
+      return new URL(value);
+    } catch (error) {
+      return null;
+    }
+  })();
+  if (!whatwgURL) {
+    console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
+    return null;
+  }
+  const urlString = whatwgURL.href;
+  const { host, hostname, pathname, protocol, search } = whatwgURL;
+  if (search) {
+    return null;
+  }
+  const scheme = protocol.slice(0, -1);
+  if (!Object.values(import_types3.EndpointURLScheme).includes(scheme)) {
+    return null;
+  }
+  const isIp = isIpAddress(hostname);
+  const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`);
+  const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
+  return {
+    scheme,
+    authority,
+    path: pathname,
+    normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
+    isIp
+  };
+}, "parseURL");
+
+// src/lib/stringEquals.ts
+var stringEquals = /* @__PURE__ */ __name((value1, value2) => value1 === value2, "stringEquals");
+
+// src/lib/substring.ts
+var substring = /* @__PURE__ */ __name((input, start, stop, reverse) => {
+  if (start >= stop || input.length < stop) {
+    return null;
+  }
+  if (!reverse) {
+    return input.substring(start, stop);
+  }
+  return input.substring(input.length - stop, input.length - start);
+}, "substring");
+
+// src/lib/uriEncode.ts
+var uriEncode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`), "uriEncode");
+
+// src/utils/endpointFunctions.ts
+var endpointFunctions = {
+  booleanEquals,
+  getAttr,
+  isSet,
+  isValidHostLabel,
+  not,
+  parseURL,
+  stringEquals,
+  substring,
+  uriEncode
+};
+
+// src/utils/evaluateTemplate.ts
+var evaluateTemplate = /* @__PURE__ */ __name((template, options) => {
+  const evaluatedTemplateArr = [];
+  const templateContext = {
+    ...options.endpointParams,
+    ...options.referenceRecord
+  };
+  let currentIndex = 0;
+  while (currentIndex < template.length) {
+    const openingBraceIndex = template.indexOf("{", currentIndex);
+    if (openingBraceIndex === -1) {
+      evaluatedTemplateArr.push(template.slice(currentIndex));
+      break;
+    }
+    evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
+    const closingBraceIndex = template.indexOf("}", openingBraceIndex);
+    if (closingBraceIndex === -1) {
+      evaluatedTemplateArr.push(template.slice(openingBraceIndex));
+      break;
+    }
+    if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
+      evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
+      currentIndex = closingBraceIndex + 2;
+    }
+    const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
+    if (parameterName.includes("#")) {
+      const [refName, attrName] = parameterName.split("#");
+      evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName));
+    } else {
+      evaluatedTemplateArr.push(templateContext[parameterName]);
+    }
+    currentIndex = closingBraceIndex + 1;
+  }
+  return evaluatedTemplateArr.join("");
+}, "evaluateTemplate");
+
+// src/utils/getReferenceValue.ts
+var getReferenceValue = /* @__PURE__ */ __name(({ ref }, options) => {
+  const referenceRecord = {
+    ...options.endpointParams,
+    ...options.referenceRecord
+  };
+  return referenceRecord[ref];
+}, "getReferenceValue");
+
+// src/utils/evaluateExpression.ts
+var evaluateExpression = /* @__PURE__ */ __name((obj, keyName, options) => {
+  if (typeof obj === "string") {
+    return evaluateTemplate(obj, options);
+  } else if (obj["fn"]) {
+    return callFunction(obj, options);
+  } else if (obj["ref"]) {
+    return getReferenceValue(obj, options);
+  }
+  throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
+}, "evaluateExpression");
+
+// src/utils/callFunction.ts
+var callFunction = /* @__PURE__ */ __name(({ fn, argv }, options) => {
+  const evaluatedArgs = argv.map(
+    (arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options)
+  );
+  const fnSegments = fn.split(".");
+  if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
+    return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
+  }
+  return endpointFunctions[fn](...evaluatedArgs);
+}, "callFunction");
+
+// src/utils/evaluateCondition.ts
+var evaluateCondition = /* @__PURE__ */ __name(({ assign, ...fnArgs }, options) => {
+  var _a, _b;
+  if (assign && assign in options.referenceRecord) {
+    throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
+  }
+  const value = callFunction(fnArgs, options);
+  (_b = (_a = options.logger) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, debugId, `evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);
+  return {
+    result: value === "" ? true : !!value,
+    ...assign != null && { toAssign: { name: assign, value } }
+  };
+}, "evaluateCondition");
+
+// src/utils/evaluateConditions.ts
+var evaluateConditions = /* @__PURE__ */ __name((conditions = [], options) => {
+  var _a, _b;
+  const conditionsReferenceRecord = {};
+  for (const condition of conditions) {
+    const { result, toAssign } = evaluateCondition(condition, {
+      ...options,
+      referenceRecord: {
+        ...options.referenceRecord,
+        ...conditionsReferenceRecord
+      }
+    });
+    if (!result) {
+      return { result };
+    }
+    if (toAssign) {
+      conditionsReferenceRecord[toAssign.name] = toAssign.value;
+      (_b = (_a = options.logger) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, debugId, `assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
+    }
+  }
+  return { result: true, referenceRecord: conditionsReferenceRecord };
+}, "evaluateConditions");
+
+// src/utils/getEndpointHeaders.ts
+var getEndpointHeaders = /* @__PURE__ */ __name((headers, options) => Object.entries(headers).reduce(
+  (acc, [headerKey, headerVal]) => ({
+    ...acc,
+    [headerKey]: headerVal.map((headerValEntry) => {
+      const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
+      if (typeof processedExpr !== "string") {
+        throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
+      }
+      return processedExpr;
+    })
+  }),
+  {}
+), "getEndpointHeaders");
+
+// src/utils/getEndpointProperty.ts
+var getEndpointProperty = /* @__PURE__ */ __name((property, options) => {
+  if (Array.isArray(property)) {
+    return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
+  }
+  switch (typeof property) {
+    case "string":
+      return evaluateTemplate(property, options);
+    case "object":
+      if (property === null) {
+        throw new EndpointError(`Unexpected endpoint property: ${property}`);
+      }
+      return getEndpointProperties(property, options);
+    case "boolean":
+      return property;
+    default:
+      throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
+  }
+}, "getEndpointProperty");
+
+// src/utils/getEndpointProperties.ts
+var getEndpointProperties = /* @__PURE__ */ __name((properties, options) => Object.entries(properties).reduce(
+  (acc, [propertyKey, propertyVal]) => ({
+    ...acc,
+    [propertyKey]: getEndpointProperty(propertyVal, options)
+  }),
+  {}
+), "getEndpointProperties");
+
+// src/utils/getEndpointUrl.ts
+var getEndpointUrl = /* @__PURE__ */ __name((endpointUrl, options) => {
+  const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
+  if (typeof expression === "string") {
+    try {
+      return new URL(expression);
+    } catch (error) {
+      console.error(`Failed to construct URL with ${expression}`, error);
+      throw error;
+    }
+  }
+  throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
+}, "getEndpointUrl");
+
+// src/utils/evaluateEndpointRule.ts
+var evaluateEndpointRule = /* @__PURE__ */ __name((endpointRule, options) => {
+  var _a, _b;
+  const { conditions, endpoint } = endpointRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  const endpointRuleOptions = {
+    ...options,
+    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+  };
+  const { url, properties, headers } = endpoint;
+  (_b = (_a = options.logger) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, debugId, `Resolving endpoint from template: ${toDebugString(endpoint)}`);
+  return {
+    ...headers != void 0 && {
+      headers: getEndpointHeaders(headers, endpointRuleOptions)
+    },
+    ...properties != void 0 && {
+      properties: getEndpointProperties(properties, endpointRuleOptions)
+    },
+    url: getEndpointUrl(url, endpointRuleOptions)
+  };
+}, "evaluateEndpointRule");
+
+// src/utils/evaluateErrorRule.ts
+var evaluateErrorRule = /* @__PURE__ */ __name((errorRule, options) => {
+  const { conditions, error } = errorRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  throw new EndpointError(
+    evaluateExpression(error, "Error", {
+      ...options,
+      referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+    })
+  );
+}, "evaluateErrorRule");
+
+// src/utils/evaluateTreeRule.ts
+var evaluateTreeRule = /* @__PURE__ */ __name((treeRule, options) => {
+  const { conditions, rules } = treeRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  return evaluateRules(rules, {
+    ...options,
+    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+  });
+}, "evaluateTreeRule");
+
+// src/utils/evaluateRules.ts
+var evaluateRules = /* @__PURE__ */ __name((rules, options) => {
+  for (const rule of rules) {
+    if (rule.type === "endpoint") {
+      const endpointOrUndefined = evaluateEndpointRule(rule, options);
+      if (endpointOrUndefined) {
+        return endpointOrUndefined;
+      }
+    } else if (rule.type === "error") {
+      evaluateErrorRule(rule, options);
+    } else if (rule.type === "tree") {
+      const endpointOrUndefined = evaluateTreeRule(rule, options);
+      if (endpointOrUndefined) {
+        return endpointOrUndefined;
+      }
+    } else {
+      throw new EndpointError(`Unknown endpoint rule: ${rule}`);
+    }
+  }
+  throw new EndpointError(`Rules evaluation failed`);
+}, "evaluateRules");
+
+// src/resolveEndpoint.ts
+var resolveEndpoint = /* @__PURE__ */ __name((ruleSetObject, options) => {
+  var _a, _b, _c, _d, _e;
+  const { endpointParams, logger } = options;
+  const { parameters, rules } = ruleSetObject;
+  (_b = (_a = options.logger) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, `${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
+  const paramsWithDefault = Object.entries(parameters).filter(([, v]) => v.default != null).map(([k, v]) => [k, v.default]);
+  if (paramsWithDefault.length > 0) {
+    for (const [paramKey, paramDefaultValue] of paramsWithDefault) {
+      endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue;
+    }
+  }
+  const requiredParams = Object.entries(parameters).filter(([, v]) => v.required).map(([k]) => k);
+  for (const requiredParam of requiredParams) {
+    if (endpointParams[requiredParam] == null) {
+      throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
+    }
+  }
+  const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
+  if ((_c = options.endpointParams) == null ? void 0 : _c.Endpoint) {
+    try {
+      const givenEndpoint = new URL(options.endpointParams.Endpoint);
+      const { protocol, port } = givenEndpoint;
+      endpoint.url.protocol = protocol;
+      endpoint.url.port = port;
+    } catch (e) {
+    }
+  }
+  (_e = (_d = options.logger) == null ? void 0 : _d.debug) == null ? void 0 : _e.call(_d, `${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
+  return endpoint;
+}, "resolveEndpoint");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  isIpAddress,
+  isValidHostLabel,
+  customEndpointFunctions,
+  resolveEndpoint,
+  EndpointError
+});
+

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/booleanEquals.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanEquals = void 0;
-const booleanEquals = (value1, value2) => value1 === value2;
-exports.booleanEquals = booleanEquals;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/getAttr.js

@@ -1,15 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAttr = void 0;
-const types_1 = require("../types");
-const getAttrPathList_1 = require("./getAttrPathList");
-const getAttr = (value, path) => (0, getAttrPathList_1.getAttrPathList)(path).reduce((acc, index) => {
-    if (typeof acc !== "object") {
-        throw new types_1.EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
-    }
-    else if (Array.isArray(acc)) {
-        return acc[parseInt(index)];
-    }
-    return acc[index];
-}, value);
-exports.getAttr = getAttr;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/getAttrPathList.js

@@ -1,29 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAttrPathList = void 0;
-const types_1 = require("../types");
-const getAttrPathList = (path) => {
-    const parts = path.split(".");
-    const pathList = [];
-    for (const part of parts) {
-        const squareBracketIndex = part.indexOf("[");
-        if (squareBracketIndex !== -1) {
-            if (part.indexOf("]") !== part.length - 1) {
-                throw new types_1.EndpointError(`Path: '${path}' does not end with ']'`);
-            }
-            const arrayIndex = part.slice(squareBracketIndex + 1, -1);
-            if (Number.isNaN(parseInt(arrayIndex))) {
-                throw new types_1.EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
-            }
-            if (squareBracketIndex !== 0) {
-                pathList.push(part.slice(0, squareBracketIndex));
-            }
-            pathList.push(arrayIndex);
-        }
-        else {
-            pathList.push(part);
-        }
-    }
-    return pathList;
-};
-exports.getAttrPathList = getAttrPathList;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/index.js

@@ -1,12 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./booleanEquals"), exports);
-tslib_1.__exportStar(require("./getAttr"), exports);
-tslib_1.__exportStar(require("./isSet"), exports);
-tslib_1.__exportStar(require("./isValidHostLabel"), exports);
-tslib_1.__exportStar(require("./not"), exports);
-tslib_1.__exportStar(require("./parseURL"), exports);
-tslib_1.__exportStar(require("./stringEquals"), exports);
-tslib_1.__exportStar(require("./substring"), exports);
-tslib_1.__exportStar(require("./uriEncode"), exports);
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/isIpAddress.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIpAddress = void 0;
-const IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
-const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]"));
-exports.isIpAddress = isIpAddress;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/isSet.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSet = void 0;
-const isSet = (value) => value != null;
-exports.isSet = isSet;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/isValidHostLabel.js

@@ -1,17 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidHostLabel = void 0;
-const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
-const isValidHostLabel = (value, allowSubDomains = false) => {
-    if (!allowSubDomains) {
-        return VALID_HOST_LABEL_REGEX.test(value);
-    }
-    const labels = value.split(".");
-    for (const label of labels) {
-        if (!(0, exports.isValidHostLabel)(label)) {
-            return false;
-        }
-    }
-    return true;
-};
-exports.isValidHostLabel = isValidHostLabel;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/not.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.not = void 0;
-const not = (value) => !value;
-exports.not = not;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/parseURL.js

@@ -1,55 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseURL = void 0;
-const types_1 = require("@smithy/types");
-const isIpAddress_1 = require("./isIpAddress");
-const DEFAULT_PORTS = {
-    [types_1.EndpointURLScheme.HTTP]: 80,
-    [types_1.EndpointURLScheme.HTTPS]: 443,
-};
-const parseURL = (value) => {
-    const whatwgURL = (() => {
-        try {
-            if (value instanceof URL) {
-                return value;
-            }
-            if (typeof value === "object" && "hostname" in value) {
-                const { hostname, port, protocol = "", path = "", query = {} } = value;
-                const url = new URL(`${protocol}//${hostname}${port ? `:${port}` : ""}${path}`);
-                url.search = Object.entries(query)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join("&");
-                return url;
-            }
-            return new URL(value);
-        }
-        catch (error) {
-            return null;
-        }
-    })();
-    if (!whatwgURL) {
-        console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
-        return null;
-    }
-    const urlString = whatwgURL.href;
-    const { host, hostname, pathname, protocol, search } = whatwgURL;
-    if (search) {
-        return null;
-    }
-    const scheme = protocol.slice(0, -1);
-    if (!Object.values(types_1.EndpointURLScheme).includes(scheme)) {
-        return null;
-    }
-    const isIp = (0, isIpAddress_1.isIpAddress)(hostname);
-    const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) ||
-        (typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`));
-    const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
-    return {
-        scheme,
-        authority,
-        path: pathname,
-        normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
-        isIp,
-    };
-};
-exports.parseURL = parseURL;
+module.exports = require("../index.js");

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/util-endpoints/dist-cjs/lib/stringEquals.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringEquals = void 0;
-const stringEquals = (value1, value2) => value1 === value2;
-exports.stringEquals = stringEquals;
+module.exports = require("../index.js");