@mavogel/awscdk-rootmail 0.0.321 → 0.0.323

package/node_modules/@smithy/util-endpoints/dist-cjs/index.js

@@ -1,544 +1,463 @@
-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, {
-  EndpointCache: () => EndpointCache,
-  EndpointError: () => EndpointError,
-  customEndpointFunctions: () => customEndpointFunctions,
-  isIpAddress: () => isIpAddress,
-  isValidHostLabel: () => isValidHostLabel,
-  resolveEndpoint: () => resolveEndpoint
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/cache/EndpointCache.ts
-var EndpointCache = class {
-  /**
-   * @param [size] - desired average maximum capacity. A buffer of 10 additional keys will be allowed
-   *                 before keys are dropped.
-   * @param [params] - list of params to consider as part of the cache key.
-   *
-   * If the params list is not populated, no caching will happen.
-   * This may be out of order depending on how the object is created and arrives to this class.
-   */
-  constructor({ size, params }) {
-    this.data = /* @__PURE__ */ new Map();
-    this.parameters = [];
-    this.capacity = size ?? 50;
-    if (params) {
-      this.parameters = params;
-    }
-  }
-  static {
-    __name(this, "EndpointCache");
-  }
-  /**
-   * @param endpointParams - query for endpoint.
-   * @param resolver - provider of the value if not present.
-   * @returns endpoint corresponding to the query.
-   */
-  get(endpointParams, resolver) {
-    const key = this.hash(endpointParams);
-    if (key === false) {
-      return resolver();
-    }
-    if (!this.data.has(key)) {
-      if (this.data.size > this.capacity + 10) {
-        const keys = this.data.keys();
-        let i = 0;
-        while (true) {
-          const { value, done } = keys.next();
-          this.data.delete(value);
-          if (done || ++i > 10) {
-            break;
-          }
+'use strict';
+
+var types = require('@smithy/types');
+
+class EndpointCache {
+    capacity;
+    data = new Map();
+    parameters = [];
+    constructor({ size, params }) {
+        this.capacity = size ?? 50;
+        if (params) {
+            this.parameters = params;
+        }
+    }
+    get(endpointParams, resolver) {
+        const key = this.hash(endpointParams);
+        if (key === false) {
+            return resolver();
+        }
+        if (!this.data.has(key)) {
+            if (this.data.size > this.capacity + 10) {
+                const keys = this.data.keys();
+                let i = 0;
+                while (true) {
+                    const { value, done } = keys.next();
+                    this.data.delete(value);
+                    if (done || ++i > 10) {
+                        break;
+                    }
+                }
+            }
+            this.data.set(key, resolver());
+        }
+        return this.data.get(key);
+    }
+    size() {
+        return this.data.size;
+    }
+    hash(endpointParams) {
+        let buffer = "";
+        const { parameters } = this;
+        if (parameters.length === 0) {
+            return false;
+        }
+        for (const param of parameters) {
+            const val = String(endpointParams[param] ?? "");
+            if (val.includes("|;")) {
+                return false;
+            }
+            buffer += val + "|;";
+        }
+        return buffer;
+    }
+}
+
+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("]"));
+
+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 (!isValidHostLabel(label)) {
+            return false;
         }
-      }
-      this.data.set(key, resolver());
-    }
-    return this.data.get(key);
-  }
-  size() {
-    return this.data.size;
-  }
-  /**
-   * @returns cache key or false if not cachable.
-   */
-  hash(endpointParams) {
-    let buffer = "";
-    const { parameters } = this;
-    if (parameters.length === 0) {
-      return false;
-    }
-    for (const param of parameters) {
-      const val = String(endpointParams[param] ?? "");
-      if (val.includes("|;")) {
-        return false;
-      }
-      buffer += val + "|;";
-    }
-    return buffer;
-  }
+    }
+    return true;
 };
 
-// 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
+const customEndpointFunctions = {};
+
+const debugId = "endpoints";
+
 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);
+    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);
+}
+
+class EndpointError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EndpointError";
+    }
 }
-__name(toDebugString, "toDebugString");
-
-// src/types/EndpointError.ts
-var EndpointError = class extends Error {
-  static {
-    __name(this, "EndpointError");
-  }
-  constructor(message) {
-    super(message);
-    this.name = "EndpointError";
-  }
+
+const booleanEquals = (value1, value2) => value1 === value2;
+
+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 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;
 };
 
-// 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
+const getAttr = (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);
+
+const isSet = (value) => value != null;
+
+const not = (value) => !value;
+
+const DEFAULT_PORTS = {
+    [types.EndpointURLScheme.HTTP]: 80,
+    [types.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
+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.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,
+    };
 };
 
-// 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) => {
-  if (assign && assign in options.referenceRecord) {
-    throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
-  }
-  const value = callFunction(fnArgs, options);
-  options.logger?.debug?.(`${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) => {
-  const conditionsReferenceRecord = {};
-  for (const condition of conditions) {
-    const { result, toAssign } = evaluateCondition(condition, {
-      ...options,
-      referenceRecord: {
+const stringEquals = (value1, value2) => value1 === value2;
+
+const substring = (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);
+};
+
+const uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+
+const endpointFunctions = {
+    booleanEquals,
+    getAttr,
+    isSet,
+    isValidHostLabel,
+    not,
+    parseURL,
+    stringEquals,
+    substring,
+    uriEncode,
+};
+
+const evaluateTemplate = (template, options) => {
+    const evaluatedTemplateArr = [];
+    const templateContext = {
+        ...options.endpointParams,
         ...options.referenceRecord,
-        ...conditionsReferenceRecord
-      }
-    });
-    if (!result) {
-      return { result };
+    };
+    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;
     }
-    if (toAssign) {
-      conditionsReferenceRecord[toAssign.name] = toAssign.value;
-      options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
+    return evaluatedTemplateArr.join("");
+};
+
+const getReferenceValue = ({ ref }, options) => {
+    const referenceRecord = {
+        ...options.endpointParams,
+        ...options.referenceRecord,
+    };
+    return referenceRecord[ref];
+};
+
+const evaluateExpression = (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.`);
+};
+
+const callFunction = ({ 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);
+};
+
+const evaluateCondition = ({ assign, ...fnArgs }, options) => {
+    if (assign && assign in options.referenceRecord) {
+        throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
+    }
+    const value = callFunction(fnArgs, options);
+    options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);
+    return {
+        result: value === "" ? true : !!value,
+        ...(assign != null && { toAssign: { name: assign, value } }),
+    };
+};
+
+const evaluateConditions = (conditions = [], options) => {
+    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;
+            options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
+        }
     }
-  }
-  return { result: true, referenceRecord: conditionsReferenceRecord };
-}, "evaluateConditions");
+    return { result: true, referenceRecord: conditionsReferenceRecord };
+};
 
-// src/utils/getEndpointHeaders.ts
-var getEndpointHeaders = /* @__PURE__ */ __name((headers, options) => Object.entries(headers).reduce(
-  (acc, [headerKey, headerVal]) => ({
+const getEndpointHeaders = (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]) => ({
+        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;
+    }),
+}), {});
+
+const getEndpointProperty = (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}`);
+    }
+};
+
+const getEndpointProperties = (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) => {
-  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;
-  options.logger?.debug?.(`${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) => {
-  const { endpointParams, logger } = options;
-  const { parameters, rules } = ruleSetObject;
-  options.logger?.debug?.(`${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: {} });
-  options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
-  return endpoint;
-}, "resolveEndpoint");
-// Annotate the CommonJS export names for ESM import in node:
-
-0 && (module.exports = {
-  EndpointCache,
-  isIpAddress,
-  isValidHostLabel,
-  customEndpointFunctions,
-  resolveEndpoint,
-  EndpointError
-});
+    [propertyKey]: getEndpointProperty(propertyVal, options),
+}), {});
+
+const getEndpointUrl = (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}`);
+};
+
+const evaluateEndpointRule = (endpointRule, options) => {
+    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;
+    options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
+    return {
+        ...(headers != undefined && {
+            headers: getEndpointHeaders(headers, endpointRuleOptions),
+        }),
+        ...(properties != undefined && {
+            properties: getEndpointProperties(properties, endpointRuleOptions),
+        }),
+        url: getEndpointUrl(url, endpointRuleOptions),
+    };
+};
+
+const evaluateErrorRule = (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 },
+    }));
+};
+
+const evaluateTreeRule = (treeRule, options) => {
+    const { conditions, rules } = treeRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
+    if (!result) {
+        return;
+    }
+    return evaluateRules(rules, {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    });
+};
+
+const evaluateRules = (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`);
+};
+
+const resolveEndpoint = (ruleSetObject, options) => {
+    const { endpointParams, logger } = options;
+    const { parameters, rules } = ruleSetObject;
+    options.logger?.debug?.(`${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: {} });
+    options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
+    return endpoint;
+};
 
+exports.EndpointCache = EndpointCache;
+exports.EndpointError = EndpointError;
+exports.customEndpointFunctions = customEndpointFunctions;
+exports.isIpAddress = isIpAddress;
+exports.isValidHostLabel = isValidHostLabel;
+exports.resolveEndpoint = resolveEndpoint;