@costrict/csc 4.0.4 → 4.0.5

package/dist/chunk-n35vwqby.js

@@ -0,0 +1,777 @@
+// @bun
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-kxqjncxw.js";
+import {
+  require_dist_cjs
+} from "./chunk-cddv8twj.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js
+var REGION_ENV_NAME = "AWS_REGION", REGION_INI_NAME = "region", NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS;
+var init_config = __esm(() => {
+  NODE_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[REGION_ENV_NAME],
+    configFileSelector: (profile) => profile[REGION_INI_NAME],
+    default: () => {
+      throw new Error("Region is missing");
+    }
+  };
+  NODE_REGION_CONFIG_FILE_OPTIONS = {
+    preferredFile: "credentials"
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
+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;
+  }
+}
+var init_EndpointCache = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js
+var IP_V4_REGEX, isIpAddress = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
+var init_isIpAddress = __esm(() => {
+  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}$`);
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js
+var VALID_HOST_LABEL_REGEX, 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;
+    }
+  }
+  return true;
+};
+var init_isValidHostLabel = __esm(() => {
+  VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js
+var customEndpointFunctions;
+var init_customEndpointFunctions = __esm(() => {
+  customEndpointFunctions = {};
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js
+var debugId = "endpoints";
+var init_debugId = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js
+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);
+}
+var init_toDebugString = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/debug/index.js
+var init_debug = __esm(() => {
+  init_debugId();
+  init_toDebugString();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js
+var EndpointError;
+var init_EndpointError = __esm(() => {
+  EndpointError = class EndpointError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "EndpointError";
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/EndpointFunctions.js
+var init_EndpointFunctions = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/EndpointRuleObject.js
+var init_EndpointRuleObject = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/ErrorRuleObject.js
+var init_ErrorRuleObject = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/RuleSetObject.js
+var init_RuleSetObject = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/TreeRuleObject.js
+var init_TreeRuleObject = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/shared.js
+var init_shared = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/types/index.js
+var init_types = __esm(() => {
+  init_EndpointError();
+  init_EndpointFunctions();
+  init_EndpointRuleObject();
+  init_ErrorRuleObject();
+  init_RuleSetObject();
+  init_TreeRuleObject();
+  init_shared();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js
+var booleanEquals = (value1, value2) => value1 === value2;
+var init_booleanEquals = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js
+var 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;
+};
+var init_getAttrPathList = __esm(() => {
+  init_types();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js
+var 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);
+var init_getAttr = __esm(() => {
+  init_types();
+  init_getAttrPathList();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js
+var isSet = (value) => value != null;
+var init_isSet = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/not.js
+var not = (value) => !value;
+var init_not = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js
+var import_types3, DEFAULT_PORTS, parseURL = (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
+  };
+};
+var init_parseURL = __esm(() => {
+  init_isIpAddress();
+  import_types3 = __toESM(require_dist_cjs(), 1);
+  DEFAULT_PORTS = {
+    [import_types3.EndpointURLScheme.HTTP]: 80,
+    [import_types3.EndpointURLScheme.HTTPS]: 443
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js
+var stringEquals = (value1, value2) => value1 === value2;
+var init_stringEquals = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/substring.js
+var substring = (input, start, stop, reverse) => {
+  if (start >= stop || input.length < stop || /[^\u0000-\u007f]/.test(input)) {
+    return null;
+  }
+  if (!reverse) {
+    return input.substring(start, stop);
+  }
+  return input.substring(input.length - stop, input.length - start);
+};
+var init_substring = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js
+var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+var init_uriEncode = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/lib/index.js
+var init_lib = __esm(() => {
+  init_booleanEquals();
+  init_getAttr();
+  init_isSet();
+  init_isValidHostLabel();
+  init_not();
+  init_parseURL();
+  init_stringEquals();
+  init_substring();
+  init_uriEncode();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js
+var endpointFunctions;
+var init_endpointFunctions = __esm(() => {
+  init_lib();
+  endpointFunctions = {
+    booleanEquals,
+    getAttr,
+    isSet,
+    isValidHostLabel,
+    not,
+    parseURL,
+    stringEquals,
+    substring,
+    uriEncode
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js
+var evaluateTemplate = (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("");
+};
+var init_evaluateTemplate = __esm(() => {
+  init_lib();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js
+var getReferenceValue = ({ ref }, options) => {
+  const referenceRecord = {
+    ...options.endpointParams,
+    ...options.referenceRecord
+  };
+  return referenceRecord[ref];
+};
+var init_getReferenceValue = () => {};
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js
+var evaluateExpression = (obj, keyName, options) => {
+  if (typeof obj === "string") {
+    return evaluateTemplate(obj, options);
+  } else if (obj["fn"]) {
+    return group.callFunction(obj, options);
+  } else if (obj["ref"]) {
+    return getReferenceValue(obj, options);
+  }
+  throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
+}, callFunction = ({ fn, argv }, options) => {
+  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group.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);
+}, group;
+var init_evaluateExpression = __esm(() => {
+  init_types();
+  init_customEndpointFunctions();
+  init_endpointFunctions();
+  init_evaluateTemplate();
+  init_getReferenceValue();
+  group = {
+    evaluateExpression,
+    callFunction
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js
+var init_callFunction = __esm(() => {
+  init_evaluateExpression();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
+var 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 } }
+  };
+};
+var init_evaluateCondition = __esm(() => {
+  init_debug();
+  init_types();
+  init_callFunction();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js
+var 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 };
+};
+var init_evaluateConditions = __esm(() => {
+  init_debug();
+  init_evaluateCondition();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js
+var 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;
+  })
+}), {});
+var init_getEndpointHeaders = __esm(() => {
+  init_types();
+  init_evaluateExpression();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
+var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+  ...acc,
+  [propertyKey]: group2.getEndpointProperty(propertyVal, options)
+}), {}), 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 group2.getEndpointProperties(property, options);
+    case "boolean":
+      return property;
+    default:
+      throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
+  }
+}, group2;
+var init_getEndpointProperties = __esm(() => {
+  init_types();
+  init_evaluateTemplate();
+  group2 = {
+    getEndpointProperty,
+    getEndpointProperties
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
+var 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}`);
+};
+var init_getEndpointUrl = __esm(() => {
+  init_types();
+  init_evaluateExpression();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js
+var 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 != null && {
+      headers: getEndpointHeaders(headers, endpointRuleOptions)
+    },
+    ...properties != null && {
+      properties: getEndpointProperties(properties, endpointRuleOptions)
+    },
+    url: getEndpointUrl(url, endpointRuleOptions)
+  };
+};
+var init_evaluateEndpointRule = __esm(() => {
+  init_debug();
+  init_evaluateConditions();
+  init_getEndpointHeaders();
+  init_getEndpointProperties();
+  init_getEndpointUrl();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js
+var 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 }
+  }));
+};
+var init_evaluateErrorRule = __esm(() => {
+  init_types();
+  init_evaluateConditions();
+  init_evaluateExpression();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
+var 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 = group3.evaluateTreeRule(rule, options);
+      if (endpointOrUndefined) {
+        return endpointOrUndefined;
+      }
+    } else {
+      throw new EndpointError(`Unknown endpoint rule: ${rule}`);
+    }
+  }
+  throw new EndpointError(`Rules evaluation failed`);
+}, evaluateTreeRule = (treeRule, options) => {
+  const { conditions, rules } = treeRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  return group3.evaluateRules(rules, {
+    ...options,
+    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+  });
+}, group3;
+var init_evaluateRules = __esm(() => {
+  init_types();
+  init_evaluateConditions();
+  init_evaluateEndpointRule();
+  init_evaluateErrorRule();
+  group3 = {
+    evaluateRules,
+    evaluateTreeRule
+  };
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/utils/index.js
+var init_utils = __esm(() => {
+  init_customEndpointFunctions();
+  init_evaluateRules();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
+var 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;
+};
+var init_resolveEndpoint = __esm(() => {
+  init_debug();
+  init_types();
+  init_utils();
+});
+
+// node_modules/.bun/@smithy+util-endpoints@3.3.4/node_modules/@smithy/util-endpoints/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_EndpointCache();
+  init_isIpAddress();
+  init_isValidHostLabel();
+  init_customEndpointFunctions();
+  init_resolveEndpoint();
+  init_types();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/checkRegion.js
+var validRegions, checkRegion = (region, check = isValidHostLabel) => {
+  if (!validRegions.has(region) && !check(region)) {
+    if (region === "*") {
+      console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
+    } else {
+      throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+    }
+  } else {
+    validRegions.add(region);
+  }
+};
+var init_checkRegion = __esm(() => {
+  init_dist_es();
+  validRegions = new Set;
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
+var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
+var init_isFipsRegion = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js
+var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
+var init_getRealRegion = __esm(() => {
+  init_isFipsRegion();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js
+var resolveRegionConfig = (input) => {
+  const { region, useFipsEndpoint } = input;
+  if (!region) {
+    throw new Error("Region is missing");
+  }
+  return Object.assign(input, {
+    region: async () => {
+      const providedRegion = typeof region === "function" ? await region() : region;
+      const realRegion = getRealRegion(providedRegion);
+      checkRegion(realRegion);
+      return realRegion;
+    },
+    useFipsEndpoint: async () => {
+      const providedRegion = typeof region === "string" ? region : await region();
+      if (isFipsRegion(providedRegion)) {
+        return true;
+      }
+      return typeof useFipsEndpoint !== "function" ? Promise.resolve(!!useFipsEndpoint) : useFipsEndpoint();
+    }
+  });
+};
+var init_resolveRegionConfig = __esm(() => {
+  init_checkRegion();
+  init_getRealRegion();
+  init_isFipsRegion();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js
+var import_util_config_provider, ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT", CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint", NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS;
+var init_NodeUseDualstackEndpointConfigOptions = __esm(() => {
+  import_util_config_provider = __toESM(require_dist_cjs2(), 1);
+  NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => import_util_config_provider.booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, import_util_config_provider.SelectorType.ENV),
+    configFileSelector: (profile) => import_util_config_provider.booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, import_util_config_provider.SelectorType.CONFIG),
+    default: false
+  };
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js
+var import_util_config_provider2, ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT", CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint", NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS;
+var init_NodeUseFipsEndpointConfigOptions = __esm(() => {
+  import_util_config_provider2 = __toESM(require_dist_cjs2(), 1);
+  NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => import_util_config_provider2.booleanSelector(env, ENV_USE_FIPS_ENDPOINT, import_util_config_provider2.SelectorType.ENV),
+    configFileSelector: (profile) => import_util_config_provider2.booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, import_util_config_provider2.SelectorType.CONFIG),
+    default: false
+  };
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveCustomEndpointsConfig.js
+var init_resolveCustomEndpointsConfig = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveEndpointsConfig.js
+var init_resolveEndpointsConfig = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/index.js
+var init_endpointsConfig = __esm(() => {
+  init_NodeUseDualstackEndpointConfigOptions();
+  init_NodeUseFipsEndpointConfigOptions();
+  init_resolveCustomEndpointsConfig();
+  init_resolveEndpointsConfig();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionConfig/index.js
+var init_regionConfig = __esm(() => {
+  init_config();
+  init_resolveRegionConfig();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionInfo/PartitionHash.js
+var init_PartitionHash = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionInfo/RegionHash.js
+var init_RegionHash = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionInfo/getRegionInfo.js
+var init_getRegionInfo = () => {};
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/regionInfo/index.js
+var init_regionInfo = __esm(() => {
+  init_PartitionHash();
+  init_RegionHash();
+  init_getRegionInfo();
+});
+
+// node_modules/.bun/@smithy+config-resolver@4.4.14/node_modules/@smithy/config-resolver/dist-es/index.js
+var init_dist_es2 = __esm(() => {
+  init_endpointsConfig();
+  init_regionConfig();
+  init_regionInfo();
+});
+
+export { NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, EndpointCache, customEndpointFunctions, resolveEndpoint, init_dist_es, resolveRegionConfig, init_dist_es2 as init_dist_es1 };