@hasna/domains
Version:
Domain portfolio, registrar, marketplace, and DNS management for AI agents — CLI + MCP + HTTP API + SDK, shared account API and PostgreSQL
35,331 lines • 1.24 MB
JavaScript
// @bun
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
function __accessProp(key) {
return this[key];
}
var __toESMCache_node;
var __toESMCache_esm;
var __toESM = (mod, isNodeMode, target) => {
var canCache = mod != null && typeof mod === "object";
if (canCache) {
var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
var cached = cache.get(mod);
if (cached)
return cached;
}
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
if (mod && typeof mod === "object" || typeof mod === "function") {
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: __accessProp.bind(mod, key),
enumerable: true
});
}
if (canCache)
cache.set(mod, to);
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __returnValue = (v) => v;
function __exportSetter(name, newValue) {
this[name] = __returnValue.bind(null, newValue);
}
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: __exportSetter.bind(all, name)
});
};
var __esm = (fn, res, err) => () => {
if (fn)
try {
res = fn(fn = 0);
} catch (e) {
err = [e];
}
if (err)
throw err[0];
return res;
};
var __require = import.meta.require;
// ../../node_modules/.bun/@smithy+types@4.18.0/node_modules/@smithy/types/dist-cjs/index.js
var require_dist_cjs = __commonJS(function(exports) {
var HttpAuthLocation;
(function(HttpAuthLocation) {
HttpAuthLocation["HEADER"] = "header";
HttpAuthLocation["QUERY"] = "query";
})(HttpAuthLocation || (HttpAuthLocation = {}));
var HttpApiKeyAuthLocation;
(function(HttpApiKeyAuthLocation) {
HttpApiKeyAuthLocation["HEADER"] = "header";
HttpApiKeyAuthLocation["QUERY"] = "query";
})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
var EndpointURLScheme;
(function(EndpointURLScheme) {
EndpointURLScheme["HTTP"] = "http";
EndpointURLScheme["HTTPS"] = "https";
})(EndpointURLScheme || (EndpointURLScheme = {}));
var AlgorithmId;
(function(AlgorithmId) {
AlgorithmId["MD5"] = "md5";
AlgorithmId["CRC32"] = "crc32";
AlgorithmId["CRC32C"] = "crc32c";
AlgorithmId["SHA1"] = "sha1";
AlgorithmId["SHA256"] = "sha256";
})(AlgorithmId || (AlgorithmId = {}));
var getChecksumConfiguration = (runtimeConfig) => {
const checksumAlgorithms = [];
if (runtimeConfig.sha256 !== undefined) {
checksumAlgorithms.push({
algorithmId: () => AlgorithmId.SHA256,
checksumConstructor: () => runtimeConfig.sha256
});
}
if (runtimeConfig.md5 != null) {
checksumAlgorithms.push({
algorithmId: () => AlgorithmId.MD5,
checksumConstructor: () => runtimeConfig.md5
});
}
return {
addChecksumAlgorithm(algo) {
checksumAlgorithms.push(algo);
},
checksumAlgorithms() {
return checksumAlgorithms;
}
};
};
var resolveChecksumRuntimeConfig = (clientConfig) => {
const runtimeConfig = {};
clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
});
return runtimeConfig;
};
var getDefaultClientConfiguration = (runtimeConfig) => {
return getChecksumConfiguration(runtimeConfig);
};
var resolveDefaultRuntimeConfig = (config) => {
return resolveChecksumRuntimeConfig(config);
};
var FieldPosition;
(function(FieldPosition) {
FieldPosition[FieldPosition["HEADER"] = 0] = "HEADER";
FieldPosition[FieldPosition["TRAILER"] = 1] = "TRAILER";
})(FieldPosition || (FieldPosition = {}));
var SMITHY_CONTEXT_KEY = "__smithy_context";
var IniSectionType;
(function(IniSectionType) {
IniSectionType["PROFILE"] = "profile";
IniSectionType["SSO_SESSION"] = "sso-session";
IniSectionType["SERVICES"] = "services";
})(IniSectionType || (IniSectionType = {}));
var RequestHandlerProtocol;
(function(RequestHandlerProtocol) {
RequestHandlerProtocol["HTTP_0_9"] = "http/0.9";
RequestHandlerProtocol["HTTP_1_0"] = "http/1.0";
RequestHandlerProtocol["TDS_8_0"] = "tds/8.0";
})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
exports.AlgorithmId = AlgorithmId;
exports.EndpointURLScheme = EndpointURLScheme;
exports.FieldPosition = FieldPosition;
exports.HttpApiKeyAuthLocation = HttpApiKeyAuthLocation;
exports.HttpAuthLocation = HttpAuthLocation;
exports.IniSectionType = IniSectionType;
exports.RequestHandlerProtocol = RequestHandlerProtocol;
exports.SMITHY_CONTEXT_KEY = SMITHY_CONTEXT_KEY;
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/transport/index.js
var require_transport = __commonJS(function(exports) {
var { SMITHY_CONTEXT_KEY } = require_dist_cjs();
var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
function hasOwn(o, k) {
return Object.prototype.hasOwnProperty.call(o, k);
}
class HttpRequest {
method;
protocol;
hostname;
port;
path;
query;
headers;
username;
password;
fragment;
body;
constructor(options) {
this.method = options.method || "GET";
this.hostname = options.hostname || "localhost";
this.port = options.port;
this.query = options.query || {};
this.headers = options.headers || {};
this.body = options.body;
this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
this.username = options.username;
this.password = options.password;
this.fragment = options.fragment;
}
static clone(request) {
const cloned = new HttpRequest({
...request,
headers: { ...request.headers }
});
if (cloned.query) {
cloned.query = cloneQuery(cloned.query);
}
return cloned;
}
static isInstance(request) {
if (!request) {
return false;
}
const req = request;
return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
}
clone() {
return HttpRequest.clone(this);
}
}
function cloneQuery(query) {
return Object.keys(query).reduce((carry, paramName) => {
const param = query[paramName];
return {
...carry,
[paramName]: Array.isArray(param) ? [...param] : param
};
}, {});
}
class HttpResponse {
statusCode;
reason;
headers;
body;
constructor(options) {
this.statusCode = options.statusCode;
this.reason = options.reason;
this.headers = options.headers || {};
this.body = options.body;
}
static isInstance(response) {
if (!response)
return false;
const resp = response;
return typeof resp.statusCode === "number" && typeof resp.headers === "object";
}
}
var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
var 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;
};
function isValidHostname(hostname) {
const hostPattern = /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/;
return hostPattern.test(hostname);
}
var normalizeProvider = (input) => {
if (typeof input === "function")
return input;
const promisified = Promise.resolve(input);
return () => promisified;
};
function parseQueryString(querystring) {
const query = {};
querystring = querystring.replace(/^\?/, "");
if (querystring) {
for (const pair of querystring.split("&")) {
let [key, value = null] = pair.split("=");
key = decodeURIComponent(key);
if (value) {
value = decodeURIComponent(value);
}
if (!(key in query)) {
query[key] = value;
} else if (Array.isArray(query[key])) {
query[key].push(value);
} else {
query[key] = [query[key], value];
}
}
}
return query;
}
var parseUrl = (url) => {
if (typeof url === "string") {
return parseUrl(new URL(url));
}
const { hostname, pathname, port, protocol, search } = url;
let query;
if (search) {
query = parseQueryString(search);
}
return {
hostname,
port: port ? parseInt(port) : undefined,
protocol,
path: pathname,
query
};
};
var toEndpointV1 = (endpoint) => {
if (typeof endpoint === "object") {
if ("url" in endpoint) {
const v1Endpoint = parseUrl(endpoint.url);
if (endpoint.headers) {
v1Endpoint.headers = {};
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
}
}
return v1Endpoint;
}
return endpoint;
}
return parseUrl(endpoint);
};
exports.HttpRequest = HttpRequest;
exports.HttpResponse = HttpResponse;
exports.getSmithyContext = getSmithyContext;
exports.hasOwn = hasOwn;
exports.isValidHostLabel = isValidHostLabel;
exports.isValidHostname = isValidHostname;
exports.normalizeProvider = normalizeProvider;
exports.parseQueryString = parseQueryString;
exports.parseUrl = parseUrl;
exports.toEndpointV1 = toEndpointV1;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js
var require_schema = __commonJS(function(exports) {
var { getSmithyContext, HttpResponse, toEndpointV1 } = require_transport();
var deref = (schemaRef) => {
if (typeof schemaRef === "function") {
return schemaRef();
}
return schemaRef;
};
var operation = (namespace, name, traits, input, output) => ({
name,
namespace,
traits,
input,
output
});
var schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
const { response } = await next(args);
const { operationSchema } = getSmithyContext(context);
const [, ns, n, t, i, o] = operationSchema ?? [];
try {
const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
...config,
...context
}, response);
return {
response,
output: parsed
};
} catch (error) {
Object.defineProperty(error, "$response", {
value: response,
enumerable: false,
writable: false,
configurable: false
});
if (!("$metadata" in error)) {
const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
try {
error.message += `
` + hint;
} catch (ignored) {
if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
console.warn(hint);
} else {
context.logger?.warn?.(hint);
}
}
if (typeof error.$responseBodyText !== "undefined") {
if (error.$response) {
error.$response.body = error.$responseBodyText;
}
}
try {
if (HttpResponse.isInstance(response)) {
const { headers = {}, statusCode } = response;
const headerEntries = Object.entries(headers);
error.$metadata = {
httpStatusCode: statusCode,
requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
};
}
} catch (ignored) {}
}
throw error;
}
};
var findHeader = (pattern, headers) => {
return (headers.find(([k]) => {
return k.match(pattern);
}) || [undefined, undefined])[1];
};
var schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
const { operationSchema } = getSmithyContext(context);
const [, ns, n, t, i, o] = operationSchema ?? [];
const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : config.endpoint;
const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
...config,
...context,
endpoint
});
return next({
...args,
request
});
};
var deserializerMiddlewareOption = {
name: "deserializerMiddleware",
step: "deserialize",
tags: ["DESERIALIZER"],
override: true
};
var serializerMiddlewareOption = {
name: "serializerMiddleware",
step: "serialize",
tags: ["SERIALIZER"],
override: true
};
function getSchemaSerdePlugin(config) {
return {
applyToStack: (commandStack) => {
commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
config.protocol.setSerdeContext(config);
}
};
}
class Schema {
name;
namespace;
traits;
static assign(instance, values) {
const schema = Object.assign(instance, values);
return schema;
}
static [Symbol.hasInstance](lhs) {
const isPrototype = this.prototype.isPrototypeOf(lhs);
if (!isPrototype && typeof lhs === "object" && lhs !== null) {
const list = lhs;
return list.symbol === this.symbol;
}
return isPrototype;
}
getName() {
return this.namespace + "#" + this.name;
}
}
class ListSchema extends Schema {
static symbol = Symbol.for("@smithy/lis");
valueSchema;
symbol = ListSchema.symbol;
}
var list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema, {
name,
namespace,
traits,
valueSchema
});
class MapSchema extends Schema {
static symbol = Symbol.for("@smithy/map");
keySchema;
valueSchema;
symbol = MapSchema.symbol;
}
var map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema, {
name,
namespace,
traits,
keySchema,
valueSchema
});
class OperationSchema extends Schema {
static symbol = Symbol.for("@smithy/ope");
input;
output;
symbol = OperationSchema.symbol;
}
var op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema, {
name,
namespace,
traits,
input,
output
});
class StructureSchema extends Schema {
static symbol = Symbol.for("@smithy/str");
memberNames;
memberList;
symbol = StructureSchema.symbol;
}
var struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema, {
name,
namespace,
traits,
memberNames,
memberList
});
class ErrorSchema extends StructureSchema {
static symbol = Symbol.for("@smithy/err");
ctor;
symbol = ErrorSchema.symbol;
}
var error = (namespace, name, traits, memberNames, memberList, _ctor) => Schema.assign(new ErrorSchema, {
name,
namespace,
traits,
memberNames,
memberList,
ctor: null
});
var traitsCache = [];
function translateTraits(indicator) {
if (typeof indicator === "object") {
return indicator;
}
indicator = indicator | 0;
if (traitsCache[indicator]) {
return traitsCache[indicator];
}
const traits = {};
let i = 0;
for (const trait of [
"httpLabel",
"idempotent",
"idempotencyToken",
"sensitive",
"httpPayload",
"httpResponseCode",
"httpQueryParams"
]) {
if ((indicator >> i++ & 1) === 1) {
traits[trait] = 1;
}
}
return traitsCache[indicator] = traits;
}
var anno = {
it: Symbol.for("@smithy/nor-struct-it"),
ns: Symbol.for("@smithy/ns")
};
var simpleSchemaCacheN = [];
var simpleSchemaCacheS = {};
class NormalizedSchema {
ref;
memberName;
static symbol = Symbol.for("@smithy/nor");
symbol = NormalizedSchema.symbol;
name;
schema;
_isMemberSchema;
traits;
memberTraits;
normalizedTraits;
constructor(ref, memberName) {
this.ref = ref;
this.memberName = memberName;
const traitStack = [];
let _ref = ref;
let schema = ref;
this._isMemberSchema = false;
while (isMemberSchema(_ref)) {
traitStack.push(_ref[1]);
_ref = _ref[0];
schema = deref(_ref);
this._isMemberSchema = true;
}
if (traitStack.length > 0) {
this.memberTraits = {};
for (let i = traitStack.length - 1;i >= 0; --i) {
const traitSet = traitStack[i];
Object.assign(this.memberTraits, translateTraits(traitSet));
}
} else {
this.memberTraits = 0;
}
if (schema instanceof NormalizedSchema) {
const computedMemberTraits = this.memberTraits;
Object.assign(this, schema);
this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
this.normalizedTraits = undefined;
this.memberName = memberName ?? schema.memberName;
return;
}
this.schema = deref(schema);
if (isStaticSchema(this.schema)) {
this.name = `${this.schema[1]}#${this.schema[2]}`;
this.traits = this.schema[3];
} else {
this.name = this.memberName ?? String(schema);
this.traits = 0;
}
if (this._isMemberSchema && !memberName) {
throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
}
}
static [Symbol.hasInstance](lhs) {
const isPrototype = this.prototype.isPrototypeOf(lhs);
if (!isPrototype && typeof lhs === "object" && lhs !== null) {
const ns = lhs;
return ns.symbol === this.symbol;
}
return isPrototype;
}
static of(ref) {
const keyAble = typeof ref === "function" || typeof ref === "object" && ref !== null;
if (typeof ref === "number") {
if (simpleSchemaCacheN[ref]) {
return simpleSchemaCacheN[ref];
}
} else if (typeof ref === "string") {
if (simpleSchemaCacheS[ref]) {
return simpleSchemaCacheS[ref];
}
} else if (keyAble) {
if (ref[anno.ns]) {
return ref[anno.ns];
}
}
const sc = deref(ref);
if (sc instanceof NormalizedSchema) {
return sc;
}
if (isMemberSchema(sc)) {
const [ns, traits] = sc;
if (ns instanceof NormalizedSchema) {
Object.assign(ns.getMergedTraits(), translateTraits(traits));
return ns;
}
throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
}
const ns = new NormalizedSchema(sc);
if (keyAble) {
return ref[anno.ns] = ns;
}
if (typeof sc === "string") {
return simpleSchemaCacheS[sc] = ns;
}
if (typeof sc === "number") {
return simpleSchemaCacheN[sc] = ns;
}
return ns;
}
getSchema() {
const sc = this.schema;
if (Array.isArray(sc) && sc[0] === 0) {
return sc[4];
}
return sc;
}
getName(withNamespace = false) {
const { name } = this;
const short = !withNamespace && name && name.includes("#");
return short ? name.split("#")[1] : name || undefined;
}
getMemberName() {
return this.memberName;
}
isMemberSchema() {
return this._isMemberSchema;
}
isListSchema() {
const sc = this.getSchema();
return typeof sc === "number" ? sc >= 64 && sc < 128 : sc[0] === 1;
}
isMapSchema() {
const sc = this.getSchema();
return typeof sc === "number" ? sc >= 128 && sc <= 255 : sc[0] === 2;
}
isStructSchema() {
const sc = this.getSchema();
if (typeof sc !== "object") {
return false;
}
const id = sc[0];
return id === 3 || id === -3 || id === 4;
}
isUnionSchema() {
const sc = this.getSchema();
if (typeof sc !== "object") {
return false;
}
return sc[0] === 4;
}
isBlobSchema() {
const sc = this.getSchema();
return sc === 21 || sc === 42;
}
isTimestampSchema() {
const sc = this.getSchema();
return typeof sc === "number" && sc >= 4 && sc <= 7;
}
isUnitSchema() {
return this.getSchema() === "unit";
}
isDocumentSchema() {
return this.getSchema() === 15;
}
isStringSchema() {
return this.getSchema() === 0;
}
isBooleanSchema() {
return this.getSchema() === 2;
}
isNumericSchema() {
return this.getSchema() === 1;
}
isBigIntegerSchema() {
return this.getSchema() === 17;
}
isBigDecimalSchema() {
return this.getSchema() === 19;
}
isStreaming() {
const { streaming } = this.getMergedTraits();
return !!streaming || this.getSchema() === 42;
}
isIdempotencyToken() {
return !!this.getMergedTraits().idempotencyToken;
}
getMergedTraits() {
return this.normalizedTraits ?? (this.normalizedTraits = {
...this.getOwnTraits(),
...this.getMemberTraits()
});
}
getMemberTraits() {
return translateTraits(this.memberTraits);
}
getOwnTraits() {
return translateTraits(this.traits);
}
getKeySchema() {
const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
if (!isDoc && !isMap) {
throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
}
const schema = this.getSchema();
const memberSchema = isDoc ? 15 : schema[4] ?? 0;
return member([memberSchema, 0], "key");
}
getValueSchema() {
const sc = this.getSchema();
const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
const memberSchema = typeof sc === "number" ? 63 & sc : sc && typeof sc === "object" && (isMap || isList) ? sc[3 + sc[0]] : isDoc ? 15 : undefined;
if (memberSchema != null) {
return member([memberSchema, 0], isMap ? "value" : "member");
}
throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
}
getMemberSchema(memberName) {
const struct = this.getSchema();
if (this.isStructSchema() && struct[4].includes(memberName)) {
const i = struct[4].indexOf(memberName);
const memberSchema = struct[5][i];
return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
}
if (this.isDocumentSchema()) {
return member([15, 0], memberName);
}
throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${memberName}.`);
}
getMemberSchemas() {
const buffer = {};
try {
for (const [k, v] of this.structIterator()) {
buffer[k] = v;
}
} catch (ignored) {}
return buffer;
}
getEventStreamMember() {
if (this.isStructSchema()) {
for (const [memberName, memberSchema] of this.structIterator()) {
if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
return memberName;
}
}
}
return "";
}
*structIterator() {
if (this.isUnitSchema()) {
return;
}
if (!this.isStructSchema()) {
throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
}
const struct = this.getSchema();
const z = struct[4].length;
let it = struct[anno.it];
if (it && z === it.length) {
yield* it;
return;
}
it = Array(z);
for (let i = 0;i < z; ++i) {
const k = struct[4][i];
const v = member([struct[5][i], 0], k);
yield it[i] = [k, v];
}
struct[anno.it] = it;
}
}
function member(memberSchema, memberName) {
if (memberSchema instanceof NormalizedSchema) {
return Object.assign(memberSchema, {
memberName,
_isMemberSchema: true
});
}
const internalCtorAccess = NormalizedSchema;
return new internalCtorAccess(memberSchema, memberName);
}
var isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
var isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
class SimpleSchema extends Schema {
static symbol = Symbol.for("@smithy/sim");
schemaRef;
symbol = SimpleSchema.symbol;
}
var sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema, {
name,
namespace,
traits,
schemaRef
});
var simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema, {
name,
namespace,
traits,
schemaRef
});
var SCHEMA = {
BLOB: 21,
STREAMING_BLOB: 42,
BOOLEAN: 2,
STRING: 0,
NUMERIC: 1,
BIG_INTEGER: 17,
BIG_DECIMAL: 19,
DOCUMENT: 15,
TIMESTAMP_DEFAULT: 4,
TIMESTAMP_DATE_TIME: 5,
TIMESTAMP_HTTP_DATE: 6,
TIMESTAMP_EPOCH_SECONDS: 7,
LIST_MODIFIER: 64,
MAP_MODIFIER: 128
};
class TypeRegistry {
namespace;
schemas;
exceptions;
static registries = new Map;
constructor(namespace, schemas = new Map, exceptions = new Map) {
this.namespace = namespace;
this.schemas = schemas;
this.exceptions = exceptions;
}
static for(namespace) {
if (!TypeRegistry.registries.has(namespace)) {
TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
}
return TypeRegistry.registries.get(namespace);
}
copyFrom(other) {
const { schemas, exceptions } = this;
for (const [k, v] of other.schemas) {
if (!schemas.has(k)) {
schemas.set(k, v);
}
}
for (const [k, v] of other.exceptions) {
if (!exceptions.has(k)) {
exceptions.set(k, v);
}
}
}
register(shapeId, schema) {
const qualifiedName = this.normalizeShapeId(shapeId);
for (const r of [this, TypeRegistry.for(qualifiedName.split("#")[0])]) {
r.schemas.set(qualifiedName, schema);
}
}
getSchema(shapeId) {
const id = this.normalizeShapeId(shapeId);
if (!this.schemas.has(id)) {
if (!shapeId.includes("#")) {
const suffix = "#" + shapeId;
const candidates = [];
for (const [shapeId, schema] of this.schemas.entries()) {
if (shapeId.endsWith(suffix)) {
candidates.push(schema);
}
}
if (candidates.length === 1) {
return candidates[0];
}
}
throw new Error(`@smithy/core/schema - schema not found for ${id}`);
}
return this.schemas.get(id);
}
registerError(es, ctor) {
const $error2 = es;
const ns = $error2[1];
for (const r of [this, TypeRegistry.for(ns)]) {
r.schemas.set(ns + "#" + $error2[2], $error2);
r.exceptions.set($error2, ctor);
}
}
getErrorCtor(es) {
const $error2 = es;
if (this.exceptions.has($error2)) {
return this.exceptions.get($error2);
}
const registry = TypeRegistry.for($error2[1]);
return registry.exceptions.get($error2);
}
getBaseException() {
for (const exceptionKey of this.exceptions.keys()) {
if (Array.isArray(exceptionKey)) {
const [, ns, name] = exceptionKey;
const id = ns + "#" + name;
if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
return exceptionKey;
}
}
}
return;
}
find(predicate) {
for (const schema of this.schemas.values()) {
if (predicate(schema)) {
return schema;
}
}
return;
}
clear() {
this.schemas.clear();
this.exceptions.clear();
}
normalizeShapeId(shapeId) {
if (shapeId.includes("#")) {
return shapeId;
}
return this.namespace + "#" + shapeId;
}
}
exports.ErrorSchema = ErrorSchema;
exports.ListSchema = ListSchema;
exports.MapSchema = MapSchema;
exports.NormalizedSchema = NormalizedSchema;
exports.OperationSchema = OperationSchema;
exports.SCHEMA = SCHEMA;
exports.Schema = Schema;
exports.SimpleSchema = SimpleSchema;
exports.StructureSchema = StructureSchema;
exports.TypeRegistry = TypeRegistry;
exports.deref = deref;
exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
exports.error = error;
exports.getSchemaSerdePlugin = getSchemaSerdePlugin;
exports.isStaticSchema = isStaticSchema;
exports.list = list;
exports.map = map;
exports.op = op;
exports.operation = operation;
exports.serializerMiddlewareOption = serializerMiddlewareOption;
exports.sim = sim;
exports.simAdapter = simAdapter;
exports.simpleSchemaCacheN = simpleSchemaCacheN;
exports.simpleSchemaCacheS = simpleSchemaCacheS;
exports.struct = struct;
exports.traitsCache = traitsCache;
exports.translateTraits = translateTraits;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/client/index.js
var require_client = __commonJS(function(exports) {
var { hasOwn } = require_transport();
var { getSmithyContext, normalizeProvider } = require_transport();
exports.getSmithyContext = getSmithyContext;
exports.normalizeProvider = normalizeProvider;
var { SMITHY_CONTEXT_KEY, AlgorithmId } = require_dist_cjs();
exports.AlgorithmId = AlgorithmId;
var { NormalizedSchema } = require_schema();
var getAllAliases = (name, aliases) => {
const _aliases = [];
if (name) {
_aliases.push(name);
}
if (aliases) {
for (const alias of aliases) {
_aliases.push(alias);
}
}
return _aliases;
};
var getMiddlewareNameWithAliases = (name, aliases) => {
return `${name || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`;
};
var constructStack = () => {
let absoluteEntries = [];
let relativeEntries = [];
let identifyOnResolve = false;
const entriesNameSet = new Set;
const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
const removeByName = (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
const aliases = getAllAliases(entry.name, entry.aliases);
if (aliases.includes(toRemove)) {
isRemoved = true;
for (const alias of aliases) {
entriesNameSet.delete(alias);
}
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
};
const removeByReference = (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
if (entry.middleware === toRemove) {
isRemoved = true;
for (const alias of getAllAliases(entry.name, entry.aliases)) {
entriesNameSet.delete(alias);
}
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
};
const cloneTo = (toStack) => {
absoluteEntries.forEach((entry) => {
toStack.add(entry.middleware, { ...entry });
});
relativeEntries.forEach((entry) => {
toStack.addRelativeTo(entry.middleware, { ...entry });
});
toStack.identifyOnResolve?.(stack.identifyOnResolve());
return toStack;
};
const expandRelativeMiddlewareList = (from) => {
const expandedMiddlewareList = [];
from.before.forEach((entry) => {
if (entry.before.length === 0 && entry.after.length === 0) {
expandedMiddlewareList.push(entry);
} else {
expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
}
});
expandedMiddlewareList.push(from);
from.after.reverse().forEach((entry) => {
if (entry.before.length === 0 && entry.after.length === 0) {
expandedMiddlewareList.push(entry);
} else {
expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
}
});
return expandedMiddlewareList;
};
const getMiddlewareList = (debug = false) => {
const normalizedAbsoluteEntries = [];
const normalizedRelativeEntries = [];
const normalizedEntriesNameMap = {};
absoluteEntries.forEach((entry) => {
const normalizedEntry = {
...entry,
before: [],
after: []
};
for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
normalizedEntriesNameMap[alias] = normalizedEntry;
}
normalizedAbsoluteEntries.push(normalizedEntry);
});
relativeEntries.forEach((entry) => {
const normalizedEntry = {
...entry,
before: [],
after: []
};
for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
normalizedEntriesNameMap[alias] = normalizedEntry;
}
normalizedRelativeEntries.push(normalizedEntry);
});
normalizedRelativeEntries.forEach((entry) => {
if (entry.toMiddleware) {
const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
if (toMiddleware === undefined) {
if (debug) {
return;
}
throw new Error(`${entry.toMiddleware} is not found when adding ` + `${getMiddlewareNameWithAliases(entry.name, entry.aliases)} ` + `middleware ${entry.relation} ${entry.toMiddleware}`);
}
if (entry.relation === "after") {
toMiddleware.after.push(entry);
}
if (entry.relation === "before") {
toMiddleware.before.push(entry);
}
}
});
const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expandedMiddlewareList) => {
wholeList.push(...expandedMiddlewareList);
return wholeList;
}, []);
return mainChain;
};
const stack = {
add: (middleware, options = {}) => {
const { name, override, aliases: _aliases } = options;
const entry = {
step: "initialize",
priority: "normal",
middleware,
...options
};
const aliases = getAllAliases(name, _aliases);
if (aliases.length > 0) {
if (aliases.some((alias) => entriesNameSet.has(alias))) {
if (!override)
throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
for (const alias of aliases) {
const toOverrideIndex = absoluteEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias));
if (toOverrideIndex === -1) {
continue;
}
const toOverride = absoluteEntries[toOverrideIndex];
if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) {
throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ` + `${toOverride.priority} priority in ${toOverride.step} step cannot ` + `be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware with ` + `${entry.priority} priority in ${entry.step} step.`);
}
absoluteEntries.splice(toOverrideIndex, 1);
}
}
for (const alias of aliases) {
entriesNameSet.add(alias);
}
}
absoluteEntries.push(entry);
},
addRelativeTo: (middleware, options) => {
const { name, override, aliases: _aliases } = options;
const entry = {
middleware,
...options
};
const aliases = getAllAliases(name, _aliases);
if (aliases.length > 0) {
if (aliases.some((alias) => entriesNameSet.has(alias))) {
if (!override)
throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
for (const alias of aliases) {
const toOverrideIndex = relativeEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias));
if (toOverrideIndex === -1) {
continue;
}
const toOverride = relativeEntries[toOverrideIndex];
if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ` + `${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden ` + `by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware ${entry.relation} ` + `"${entry.toMiddleware}" middleware.`);
}
relativeEntries.splice(toOverrideIndex, 1);
}
}
for (const alias of aliases) {
entriesNameSet.add(alias);
}
}
relativeEntries.push(entry);
},
clone: () => cloneTo(constructStack()),
use: (plugin) => {
plugin.applyToStack(stack);
},
remove: (toRemove) => {
if (typeof toRemove === "string")
return removeByName(toRemove);
else
return removeByReference(toRemove);
},
removeByTag: (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
const { tags, name, aliases: _aliases } = entry;
if (tags && tags.includes(toRemove)) {
const aliases = getAllAliases(name, _aliases);
for (const alias of aliases) {
entriesNameSet.delete(alias);
}
isRemoved = true;
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
},
concat: (from) => {
const cloned = cloneTo(constructStack());
cloned.use(from);
cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false));
return cloned;
},
applyToStack: cloneTo,
identify: () => {
return getMiddlewareList(true).map((mw) => {
const step = mw.step ?? mw.relation + " " + mw.toMiddleware;
return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step;
});
},
identifyOnResolve(toggle) {
if (typeof toggle === "boolean")
identifyOnResolve = toggle;
return identifyOnResolve;
},
resolve: (handler, context) => {
for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
handler = middleware(handler, context);
}
if (identifyOnResolve) {
console.log(stack.identify());
}
return handler;
}
};
return stack;
};
var stepWeights = {
initialize: 5,
serialize: 4,
build: 3,
finalizeRequest: 2,
deserialize: 1
};
var priorityWeights = {
high: 3,
normal: 2,
low: 1
};
var invalidFunction = (message) => () => {
throw new Error(message);
};
var invalidProvider = (message) => () => Promise.reject(message);
var getCircularReplacer = () => {
const seen = new WeakSet;
return (key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return "[Circular]";
}
seen.add(value);
}
return value;
};
};
var sleep = (seconds) => {
return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
};
var waiterServiceDefaults = {
minDelay: 2,
maxDelay: 120
};
var WaiterState;
(function(WaiterState) {
WaiterState["ABORTED"] = "ABORTED";
WaiterState["FAILURE"] = "FAILURE";
WaiterState["SUCCESS"] = "SUCCESS";
WaiterState["RETRY"] = "RETRY";
WaiterState["TIMEOUT"] = "TIMEOUT";
})(WaiterState || (WaiterState = {}));
var checkExceptions = (result) => {
if (result.state === WaiterState.ABORTED) {
const abortError = new Error(`${JSON.stringify({
...result,
reason: "Request was aborted"
}, getCircularReplacer())}`);
abortError.name = "AbortError";
throw abortError;
} else if (result.state === WaiterState.TIMEOUT) {
const timeoutError = new Error(`${JSON.stringify({
...result,
reason: "Waiter has timed out"
}, getCircularReplacer())}`);
timeoutError.name = "TimeoutError";
throw timeoutError;
} else if (result.state !== WaiterState.SUCCESS) {
throw new Error(`${JSON.stringify(result, getCircularReplacer())}`);
}
return result;
};
var runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
const observedResponses = {};
const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
let currentAttempt = 0;
const waitUntil = Date.now() + maxWaitTime * 1000;
const warn403Time = Date.now() + 60000;
let didWarn403 = false;
while (true) {
if (currentAttempt > 0) {
const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
if (abortController?.signal?.aborted || abortSignal?.aborted) {
const message = "AbortController signal aborted.";
observedResponses[message] |= 0;
observedResponses[message] += 1;
return { state: WaiterState.ABORTED, observedResponses };
}
if (Date.now() + delayMs > waitUntil) {
return { state: WaiterState.TIMEOUT, observedResponses };
}
await sleep(delayMs / 1000);
}
const { state, reason } = await acceptorChecks(client, input);
if (reason) {
const message = createMessageFromResponse(reason);
observedResponses[message] |= 0;
observedResponses[message] += 1;
}
if (state !== WaiterState.RETRY) {
return { state, reason, final: reason, observedResponses };
}
currentAttempt += 1;
if (!didWarn403 && Date.now() >= warn403Time) {
checkWarn403(observedResponses, client);
didWarn403 = true;
}
}
};
var checkWarn403 = (observedResponses = {}, client) => {
const orderedErrors = Object.keys(observedResponses);
let count403 = 0;
for (const response of orderedErrors) {
const n = observedResponses[response] | 0;
if (response.startsWith("403:")) {
count403 += n;
}
}
const clientLogger = client?.config?.logger;
const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger") ? clientLogger : console;
if (count403 >= 3 || orderedErrors[orderedErrors.length - 1]?.startsWith("403:")) {
warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
}
};
var createMessageFromResponse = (reason) => {
const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
if (reason?.$responseBodyText) {
return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
}
if (status) {
if (reason?.$response || reason?.message) {
return `${status ?? "Unknown"}: ${reason?.message}`;
}
return `${status}: OK`;
}
return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
};
var exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
if (attempt > attemptCountCeiling) {
return maxDelayMs;
}
const delay = minDelayMs * 2 ** (attempt - 1);
const capped = Math.min(delay, maxDelayMs);
const waitFor = randomInRange(minDelayMs, capped);
if (Date.now() + waitFor > waitUntil) {
const timeRemaining = waitUntil - Date.now();
return Math.max(0, timeRemaining - 500);
}
return waitFor;
};
var randomInRange = (min, max) => min + Math.random() * (max - min);
var validateWaiterOptions = (options) => {
if (options.maxWaitTime <= 0) {
throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`);
} else if (options.minDelay <= 0) {
throw new Error(`WaiterConfiguration.minDelay must be greater than 0`);
} else if (options.maxDelay <= 0) {
throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`);
} else if (options.maxWaitTime <= options.minDelay) {
throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
} else if (options.maxDelay < options.minDelay) {
throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
}
};
var abortTimeout = (abortSignal) => {
let onAbort;
const promise = new Promise((resolve) => {
onAbort = () => resolve({ state: WaiterState.ABORTED });
if (typeof abortSignal.addEventListener === "function") {
abortSignal.addEventListener("abort", onAbort);
} else {
abortSignal.onabort = onAbort;
}
});
return {
clearListener() {
if (typeof abortSignal.removeEventListener === "function") {
abortSignal.removeEventListener("abort", onAbort);
}
},
aborted: promise
};
};
var createWaiter = async (options, input, acceptorChecks) => {
const params = {
...waiterServiceDefaults,
...options
};
validateWaiterOptions(params);
const exitConditions = [runPolling(params, input, acceptorChecks)];
const finalize = [];
if (options.abortSignal) {
const { aborted, clearListener } = abortTimeout(options.abortSignal);
finalize.push(clearListener);
exitConditions.push(aborted);
}
if (options.abortController?.signal) {
const { aborted, clearListener } = abortTimeout(options.abortController.signal);
finalize.push(clearListener);
exitConditions.push(aborted);
}
return Promise.race(exitConditions).then((result) => {
for (const fn of finalize) {
fn();
}
return result;
});
};
class Client {
config;
middlewareStack = constructStack();
initConfig;
handlers;
constructor(config) {
this.config = config;
const { protocol, protocolSettings } = config;
if (protocolSettings) {
if (typeof protocol === "function") {
config.protocol = new protocol(protocolSettings);
}
}
}
send(command, optionsOrCb, cb) {
const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
let handler;
if (useHandlerCache) {
if (!this.handlers) {
this.handlers = new WeakMap;
}
const handlers = this.handlers;
if (handlers.has(command.constructor)) {
handler = handlers.get(command.constructor);
} else {
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
handlers.set(command.constructor, handler);
}
} else {
delete this.handlers;
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
}
if (callback) {
handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {});
} else {
return handler(command).then((result) => result.output);
}
}
destroy() {
this.config?.requestHandler?.destroy?.();
delete this.handlers;
}
}
var SENSITIVE_STRING$1 = "***SensitiveInformation***";
function schemaLogFilter(schema, data) {
if (data == null) {
return data;
}
const ns = NormalizedSchema.of(schema);
if (ns.getMergedTraits().sensitive) {
return SENSITIVE_STRING$1;
}
if (ns.isListSchema()) {
const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
if (isSensitive) {
return SENSITIVE_STRING$1;
}
} else if (ns.isMapSchema()) {
const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
if (isSensitive) {
return SENSITIVE_STRING$1;
}
} else if (ns.isStructSchema() && typeof data === "object") {
const object = data;
const newObject = {};
for (const [member, memberNs] of ns.structIterator()) {
if (object[member] != null) {
newObject[member] = schemaLogFilter(memberNs, object[member]);
}
}
return newObject;
}
return data;
}
class Command {
middlewareStack = constructStack();
schema;
static classBuilder() {
return new ClassBuilder;
}
resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor }) {
for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
this.middlewareStack.use(mw);
}
const stack = clientStack.concat(this.middlewareStack);
const { logger } = configuration;
const handlerExecutionContext = {
logger,
clientName,
commandName,
inputFilterSensitiveLog,
outputFilterSensitiveLog,
[SMITHY_CONTEXT_KEY]: {
commandInstance: this,
...smithyContext
},
...additionalContext
};
const { requestHandler } = configuration;
let requestOptions = options ?? {};
if (smithyContext.eventStream) {
requestOptions = {
isEventStream: true,
...requestOptions
};
}
return stack.resolve((request) => requestHandler.handle(request.request, requestOptions), handlerExecutionContext);
}
}
class ClassBuilder {
_init = () => {};
_ep = {};
_middlewareFn = () => [];
_commandName = "";
_clientName = "";
_additionalContext = {};
_smithyContext = {};
_inputFilterSensitiveLog = undefined;
_outputFilterSensitiveLog = undefined;
_serializer = null;
_deserializer = null;
_operationSchema;
init(cb) {
this._init = cb;
}
ep(endpointParameterInstructions) {
this._ep = endpointParameterInstructions;
return this;
}
m(middlewareSupplier) {
this._middlewareFn = middlewareSupplier;
return this;
}
s(service, operation, smithyContext = {}) {
this._smithyContext = {
service,
operation,
...smithyContext
};
return this;
}
c(additionalContext = {}) {
this._additionalContext = additionalContext;
return this;
}
n(clientName, commandName) {
this._clientName = clientName;
this._commandName = commandName;
return this;
}
f(inputFilter = (_) => _, outputFilter = (_) => _) {
this._inputFilterSensitiveLog = inputFilter;
this._outputFilterSensitiveLog = outputFilter;
return this;
}
ser(serializer) {
this._serializer = serializer;
return this;
}
de(deserializer) {
this._deserializer = deserializer;
return this;
}
sc(operation) {
this._operationSchema = operation;
this._smithyContext.operationSchema = operation;
return this;
}
build() {
const closure = this;
let CommandRef;
return CommandRef = class extends Command {
input;
static getEndpointParameterInstructions() {
return closure._ep;
}
constructor(...[input]) {
super();
this.input = input ?? {};
closure._init(this);
this.schema = closure._operationSchema;
}
resolveMiddleware(stack, configuration, options) {
const op = closure._operationSchema;
const input = op?.[4] ?? op?.input;
const output = op?.[5] ?? op?.output;
return this.resolveMiddlewareWithContext(stack, configuration, options, {
CommandCtor: CommandRef,
middlewareFn: closure._middlewareFn,
clientName: closure._clientName,
commandName: closure._commandName,
inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
smithyContext: closure._smithyContext,
additionalContext: closure._additionalContext
});
}
serialize = closure._serializer;
deserialize = closure._deserializer;
};
}
}
var SENSITIVE_STRING = "***SensitiveInformation***";
var createAggregatedClient = (commands, Client, options) => {
for (const [command, CommandCtor] of Object.entries(commands)) {
const methodImpl = async function(args, optionsOrCb, cb) {
const command = new CommandCtor(args);
if (typeof optionsOrCb === "function") {
this.send(command, optionsOrCb);
} else if (typeof cb === "function") {
if (typeof optionsOrCb !== "object")
throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
this.send(command, optionsOrCb || {}, cb);
} else {
return this.send(command, optionsOrCb);
}
};
const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
Client.prototype[methodName] = methodImpl;
}
const { paginators = {}, waiters = {} } = options ?? {};
for (const [paginatorName, paginatorFn] of Object.entries(paginators)) {
if (Client.prototype[paginatorName] === undefined) {
Client.prototype[paginatorName] = function(commandInput = {}, paginationConfiguration, ...rest) {
return paginatorFn({
...paginationConfiguration,
client: this
}, commandInput, ...rest);
};
}
}
for (const [waiterName, waiterFn] of Object.entries(waiters)) {
if (Client.prototype[waiterName] === undefined) {
Client.prototype[waiterName] = async function(commandInput = {}, waiterConfiguration, ...rest) {
let config = waiterConfiguration;
if (typeof waiterConfiguration === "number") {
config = {
maxWaitTime: waiterConfiguration
};
}
return waiterFn({
...config,
client: this
}, commandInput, ...rest);
};
}
}
};
class ServiceException extends Error {
$fault;
$response;
$retryable;
$metadata;
constructor(options) {
super(options.message);
Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
this.name = options.name;
this.$fault = options.$fault;
this.$metadata = options.$metadata;
}
static isInstance(value) {
if (!value)
return false;
const candidate = value;
return ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
}
static [Symbol.hasInstance](instance) {
if (!instance)
return false;
const candidate = instance;
if (this === ServiceException) {
return ServiceException.isInstance(instance);
}
if (ServiceException.isInstance(instance)) {
if (candidate.name && this.name) {
return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
}
return this.prototype.isPrototypeOf(instance);
}
return false;
}
}
var decorateServiceException = (exception, additions = {}) => {
Object.entries(additions).filter(([, v]) => v !== undefined).forEach(([k, v]) => {
if (exception[k] == undefined || exception[k] === "") {
exception[k] = v;
}
});
const message = exception.message || exception.Message || "UnknownError";
exception.message = message;
delete exception.Message;
return exception;
};
var throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
const $metadata = deserializeMetadata(output);
const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
const response = new exceptionCtor({
name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
$fault: "client",
$metadata
});
throw decorateServiceException(response, parsedBody);
};
var withBaseException = (ExceptionCtor) => {
return ({ output, parsedBody, errorCode }) => {
throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
};
};
var deserializeMetadata = (output) => ({
httpStatusCode: output.statusCode,
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
extendedRequestId: output.headers["x-amz-id-2"],
cfId: output.headers["x-amz-cf-id"]
});
var loadConfigsForDefaultMode = (mode) => {
switch (mode) {
case "standard":
return {
retryMode: "standard",
connectionTimeout: 3100
};
case "in-region":
return {
retryMode: "standard",
connectionTimeout: 1100
};
case "cross-region":
return {
retryMode: "standard",
connectionTimeout: 3100
};
case "mobile":
return {
retryMode: "standard",
connectionTimeout: 30000
};
default:
return {};
}
};
var warningEmitted = false;
var emitWarningIfUnsupportedVersion = (version) => {
if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
warningEmitted = true;
}
};
var knownAlgorithms = Object.values(AlgorithmId);
var getChecksumConfiguration = (runtimeConfig) => {
const checksumAlgorithms = [];
for (const id in AlgorithmId) {
if (!hasOwn(AlgorithmId, id))
continue;
const algorithmId = AlgorithmId[id];
if (runtimeConfig[algorithmId] === undefined) {
continue;
}
checksumAlgorithms.push({
algorithmId: () => algorithmId,
checksumConstructor: () => runtimeConfig[algorithmId]
});
}
for (const [id, ChecksumCtor] of Object.entries(runtimeConfig.checksumAlgorithms ?? {})) {
checksumAlgorithms.push({
algorithmId: () => id,
checksumConstructor: () => ChecksumCtor
});
}
return {
addChecksumAlgorithm(algo) {
runtimeConfig.checksumAlgorithms = runtimeConfig.checksumAlgorithms ?? {};
const id = algo.algorithmId();
const ctor = algo.checksumConstructor();
if (knownAlgorithms.includes(id)) {
runtimeConfig.checksumAlgorithms[id.toUpperCase()] = ctor;
} else {
runtimeConfig.checksumAlgorithms[id] = ctor;
}
checksumAlgorithms.push(algo);
},
checksumAlgorithms() {
return checksumAlgorithms;
}
};
};
var resolveChecksumRuntimeConfig = (clientConfig) => {
const runtimeConfig = {};
clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
const id = checksumAlgorithm.algorithmId();
if (knownAlgorithms.includes(id)) {
runtimeConfig[id] = checksumAlgorithm.checksumConstructor();
}
});
return runtimeConfig;
};
var getRetryConfiguration = (runtimeConfig) => {
return {
setRetryStrategy(retryStrategy) {
runtimeConfig.retryStrategy = retryStrategy;
},
retryStrategy() {
return runtimeConfig.retryStrategy;
}
};
};
var resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
const runtimeConfig = {};
runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
return runtimeConfig;
};
var getDefaultExtensionConfiguration = (runtimeConfig) => {
return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
};
var getDefaultClientConfiguration = getDefaultExtensionConfiguration;
var resolveDefaultRuntimeConfig = (config) => {
return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
};
var getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray];
var getValueFromTextNode = (obj) => {
const textNodeName = "#text";
for (const key in obj) {
if (!hasOwn(obj, key))
continue;
if (obj[key][textNodeName] !== undefined) {
obj[key] = obj[key][textNodeName];
} else if (typeof obj[key] === "object" && obj[key] !== null) {
obj[key] = getValueFromTextNode(obj[key]);
}
}
return obj;
};
var isSerializableHeaderValue = (value) => {
return value != null;
};
class NoOpLogger {
trace() {}
debug() {}
info() {}
warn() {}
error() {}
}
function map(arg0, arg1, arg2) {
let target;
let filter;
let instructions;
if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
target = {};
instructions = arg0;
} else {
target = arg0;
if (typeof arg1 === "function") {
filter = arg1;
instructions = arg2;
return mapWithFilter(target, filter, instructions);
} else {
instructions = arg1;
}
}
for (const key in instructions) {
if (!hasOwn(instructions, key))
continue;
if (!Array.isArray(instructions[key])) {
target[key] = instructions[key];
continue;
}
applyInstruction(target, null, instructions, key);
}
return target;
}
var convertMap = (target) => {
const output = {};
for (const [k, v] of Object.entries(target || {})) {
output[k] = [, v];
}
return output;
};
var take = (source, instructions) => {
const out = {};
for (const key in instructions) {
if (!hasOwn(instructions, key))
continue;
applyInstruction(out, source, instructions, key);
}
return out;
};
var mapWithFilter = (target, filter, instructions) => {
return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
if (Array.isArray(value)) {
_instructions[key] = value;
} else {
if (typeof value === "function") {
_instructions[key] = [filter, value()];
} else {
_instructions[key] = [filter, value];
}
}
return _instructions;
}, {}));
};
var applyInstruction = (target, source, instructions, targetKey) => {
if (source !== null) {
let instruction = instructions[targetKey];
if (typeof instruction === "function") {
instruction = [, instruction];
}
const [filter = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
if (typeof filter === "function" && filter(source[sourceKey]) || typeof filter !== "function" && !!filter) {
target[targetKey] = valueFn(source[sourceKey]);
}
return;
}
let [filter, value] = instructions[targetKey];
if (typeof value === "function") {
let _value;
const defaultFilterPassed = filter === undefined && (_value = value()) != null;
const customFilterPassed = typeof filter === "function" && !!filter(undefined) || typeof filter !== "function" && !!filter;
if (defaultFilterPassed) {
target[targetKey] = _value;
} else if (customFilterPassed) {
target[targetKey] = value();
}
} else {
const defaultFilterPassed = filter === undefined && value != null;
const customFilterPassed = typeof filter === "function" && !!filter(value) || typeof filter !== "function" && !!filter;
if (defaultFilterPassed || customFilterPassed) {
target[targetKey] = value;
}
}
};
var nonNullish = (_) => _ != null;
var pass = (_) => _;
var serializeFloat = (value) => {
if (value !== value) {
return "NaN";
}
switch (value) {
case Infinity:
return "Infinity";
case -Infinity:
return "-Infinity";
default:
return value;
}
};
var serializeDateTime = (date) => date.toISOString().replace(".000Z", "Z");
var _json = (obj) => {
if (obj == null) {
return {};
}
if (Array.isArray(obj)) {
return obj.filter((_) => _ != null).map(_json);
}
if (typeof obj === "object") {
const target = {};
for (const key in obj) {
if (!hasOwn(obj, key))
continue;
if (obj[key] == null) {
continue;
}
target[key] = _json(obj[key]);
}
return target;
}
return obj;
};
function makeBuilder(common, service, name, ep) {
return function makeCommand(added, plugins, op, $, smithyContext = {}) {
const epMerged = Object.assign({}, common, added);
return Command.classBuilder().ep(epMerged).m(function(CommandCtor, clientStack, config, options) {
const list = plugins.call(this, CommandCtor, clientStack, config, options);
list.unshift(ep(config, CommandCtor.getEndpointParameterInstructions()));
return list;
}).s(service, op, smithyContext).n(name, op.charAt(0).toUpperCase() + op.slice(1) + "Command").sc($).build();
};
}
exports.Client = Client;
exports.Command = Command;
exports.NoOpLogger = NoOpLogger;
exports.SENSITIVE_STRING = SENSITIVE_STRING;
exports.ServiceException = ServiceException;
exports.WaiterState = WaiterState;
exports._json = _json;
exports.checkExceptions = checkExceptions;
exports.constructStack = constructStack;
exports.convertMap = convertMap;
exports.createAggregatedClient = createAggregatedClient;
exports.createWaiter = createWaiter;
exports.decorateServiceException = decorateServiceException;
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
exports.getArrayIfSingleItem = getArrayIfSingleItem;
exports.getChecksumConfiguration = getChecksumConfiguration;
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
exports.getDefaultExtensionConfiguration = getDefaultExtensionConfiguration;
exports.getRetryConfiguration = getRetryConfiguration;
exports.getValueFromTextNode = getValueFromTextNode;
exports.invalidFunction = invalidFunction;
exports.invalidProvider = invalidProvider;
exports.isSerializableHeaderValue = isSerializableHeaderValue;
exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode;
exports.makeBuilder = makeBuilder;
exports.map = map;
exports.resolveChecksumRuntimeConfig = resolveChecksumRuntimeConfig;
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
exports.resolveRetryRuntimeConfig = resolveRetryRuntimeConfig;
exports.schemaLogFilter = schemaLogFilter;
exports.serializeDateTime = serializeDateTime;
exports.serializeFloat = serializeFloat;
exports.take = take;
exports.throwDefaultError = throwDefaultError;
exports.waiterServiceDefaults = waiterServiceDefaults;
exports.withBaseException = withBaseException;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/config/index.js
var require_config = __commonJS(function(exports) {
var { homedir } = __require("os");
var { sep, join } = __require("path");
var { createHash } = __require("crypto");
var { readFile: readFile$1 } = __require("fs/promises");
var { IniSectionType } = require_dist_cjs();
var { normalizeProvider } = require_client();
var { isValidHostLabel } = require_transport();
class ProviderError extends Error {
name = "ProviderError";
tryNextLink;
constructor(message, options = true) {
let logger;
let tryNextLink = true;
if (typeof options === "boolean") {
logger = undefined;
tryNextLink = options;
} else if (options != null && typeof options === "object") {
logger = options.logger;
tryNextLink = options.tryNextLink ?? true;
}
super(message);
this.tryNextLink = tryNextLink;
Object.setPrototypeOf(this, ProviderError.prototype);
logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
}
static from(error, options = true) {
return Object.assign(new this(error.message, options), error);
}
}
class CredentialsProviderError extends ProviderError {
name = "CredentialsProviderError";
constructor(message, options = true) {
super(message, options);
Object.setPrototypeOf(this, CredentialsProviderError.prototype);
}
}
class TokenProviderError extends ProviderError {
name = "TokenProviderError";
constructor(message, options = true) {
super(message, options);
Object.setPrototypeOf(this, TokenProviderError.prototype);
}
}
var chain = (...providers) => async () => {
if (providers.length === 0) {
throw new ProviderError("No providers in chain");
}
let lastProviderError;
for (const provider of providers) {
try {
const credentials = await provider();
return credentials;
} catch (err) {
lastProviderError = err;
if (err?.tryNextLink) {
continue;
}
throw err;
}
}
throw lastProviderError;
};
var fromValue = (staticValue) => () => Promise.resolve(staticValue);
var memoize = (provider, isExpired, requiresRefresh) => {
let resolved;
let pending;
let hasResult;
let isConstant = false;
const coalesceProvider = async () => {
if (!pending) {
pending = provider();
}
try {
resolved = await pending;
hasResult = true;
isConstant = false;
} finally {
pending = undefined;
}
return resolved;
};
if (isExpired === undefined) {
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider();
}
return resolved;
};
}
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider();
}
if (isConstant) {
return resolved;
}
if (requiresRefresh && !requiresRefresh(resolved)) {
isConstant = true;
return resolved;
}
if (isExpired(resolved)) {
await coalesceProvider();
return resolved;
}
return resolved;
};
};
var booleanSelector = (obj, key, type) => {
if (!(key in obj))
return;
if (obj[key] === "true")
return true;
if (obj[key] === "false")
return false;
throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
};
var numberSelector = (obj, key, type) => {
if (!(key in obj))
return;
const numberValue = parseInt(obj[key], 10);
if (Number.isNaN(numberValue)) {
throw new TypeError(`Cannot load ${type} '${key}'. Expected number, got '${obj[key]}'.`);
}
return numberValue;
};
var SelectorType;
(function(SelectorType) {
SelectorType["ENV"] = "env";
SelectorType["CONFIG"] = "shared config entry";
})(SelectorType || (SelectorType = {}));
var homeDirCache = {};
var getHomeDirCacheKey = () => {
if (process && process.geteuid) {
return `${process.geteuid()}`;
}
return "DEFAULT";
};
var getHomeDir = () => {
const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${sep}` } = process.env;
if (HOME)
return HOME;
if (USERPROFILE)
return USERPROFILE;
if (HOMEPATH)
return `${HOMEDRIVE}${HOMEPATH}`;
const homeDirCacheKey = getHomeDirCacheKey();
if (!homeDirCache[homeDirCacheKey])
homeDirCache[homeDirCacheKey] = homedir();
return homeDirCache[homeDirCacheKey];
};
var ENV_PROFILE = "AWS_PROFILE";
var DEFAULT_PROFILE = "default";
var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
var getSSOTokenFilepath = (id) => {
const hasher = createHash("sha1");
const cacheName = hasher.update(id).digest("hex");
return join(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
};
var tokenIntercept = {};
var getSSOTokenFromFile = async (id) => {
if (tokenIntercept[id]) {
return tokenIntercept[id];
}
const ssoTokenFilepath = getSSOTokenFilepath(id);
const ssoTokenText = await readFile$1(ssoTokenFilepath, "utf8");
return JSON.parse(ssoTokenText);
};
var CONFIG_PREFIX_SEPARATOR = ".";
var getConfigData = (data) => Object.entries(data).filter(([key]) => {
const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
if (indexOfSeparator === -1) {
return false;
}
return Object.values(IniSectionType).includes(key.substring(0, indexOfSeparator));
}).reduce((acc, [key, value]) => {
const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
const updatedKey = key.substring(0, indexOfSeparator) === IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
acc[updatedKey] = value;
return acc;
}, {
...data.default && { default: data.default }
});
var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || join(getHomeDir(), ".aws", "config");
var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || join(getHomeDir(), ".aws", "credentials");
var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@+.%:/]+)\2$/;
var profileNameBlockList = ["__proto__", "profile __proto__"];
var parseIni = (iniData) => {
const map = {};
let currentSection;
let currentSubSection;
for (const iniLine of iniData.split(/\r?\n/)) {
const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
if (isSection) {
currentSection = undefined;
currentSubSection = undefined;
const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
const matches = prefixKeyRegex.exec(sectionName);
if (matches) {
const [, prefix, , name] = matches;
if (Object.values(IniSectionType).includes(prefix)) {
currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
}
} else {
currentSection = sectionName;
}
if (profileNameBlockList.includes(sectionName)) {
throw new Error(`Found invalid profile name "${sectionName}"`);
}
} else if (currentSection) {
const indexOfEqualsSign = trimmedLine.indexOf("=");
if (![0, -1].includes(indexOfEqualsSign)) {
const [name, value] = [
trimmedLine.substring(0, indexOfEqualsSign).trim(),
trimmedLine.substring(indexOfEqualsSign + 1).trim()
];
if (value === "") {
currentSubSection = name;
} else {
if (currentSubSection && iniLine.trimStart() === iniLine) {
currentSubSection = undefined;
}
map[currentSection] = map[currentSection] || {};
const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name;
map[currentSection][key] = value;
}
}
}
}
return map;
};
var filePromises = {};
var fileIntercept = {};
var readFile = (path, options) => {
if (fileIntercept[path] !== undefined) {
return fileIntercept[path];
}
if (!filePromises[path] || options?.ignoreCache) {
filePromises[path] = readFile$1(path, "utf8");
}
return filePromises[path];
};
var swallowError$1 = () => ({});
var loadSharedConfigFiles = async (init = {}) => {
const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init;
const homeDir = getHomeDir();
const relativeHomeDirPrefix = "~/";
let resolvedFilepath = filepath;
if (filepath.startsWith(relativeHomeDirPrefix)) {
resolvedFilepath = join(homeDir, filepath.slice(2));
}
let resolvedConfigFilepath = configFilepath;
if (configFilepath.startsWith(relativeHomeDirPrefix)) {
resolvedConfigFilepath = join(homeDir, configFilepath.slice(2));
}
const parsedFiles = await Promise.all([
readFile(resolvedConfigFilepath, {
ignoreCache: init.ignoreCache
}).then(parseIni).then(getConfigData).catch(swallowError$1),
readFile(resolvedFilepath, {
ignoreCache: init.ignoreCache
}).then(parseIni).catch(swallowError$1)
]);
return {
configFile: parsedFiles[0],
credentialsFile: parsedFiles[1]
};
};
var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
var swallowError = () => ({});
var loadSsoSessionData = async (init = {}) => readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
var mergeConfigFiles = (...files) => {
const merged = {};
for (const file of files) {
for (const [key, values] of Object.entries(file)) {
if (merged[key] !== undefined) {
Object.assign(merged[key], values);
} else {
merged[key] = values;
}
}
}
return merged;
};
var parseKnownFiles = async (init) => {
const parsedFiles = await loadSharedConfigFiles(init);
return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile);
};
var externalDataInterceptor = {
getFileRecord() {
return fileIntercept;
},
interceptFile(path, contents) {
fileIntercept[path] = Promise.resolve(contents);
},
getTokenRecord() {
return tokenIntercept;
},
interceptToken(id, contents) {
tokenIntercept[id] = contents;
}
};
function getSelectorName(functionString) {
try {
const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
constants.delete("CONFIG");
constants.delete("CONFIG_PREFIX_SEPARATOR");
constants.delete("ENV");
return [...constants].join(", ");
} catch (ignored) {
return functionString;
}
}
var fromEnv = (envVarSelector, options) => async () => {
try {
const config = envVarSelector(process.env, options);
if (config === undefined) {
throw new Error;
}
return config;
} catch (e) {
throw new CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
}
};
var fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
const profile = getProfileName(init);
const { configFile, credentialsFile } = await loadSharedConfigFiles(init);
const profileFromCredentials = credentialsFile[profile] || {};
const profileFromConfig = configFile[profile] || {};
const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
try {
const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
const configValue = configSelector(mergedProfile, cfgFile);
if (configValue === undefined) {
throw new Error;
}
return configValue;
} catch (e) {
throw new CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
}
};
var isFunction = (func) => typeof func === "function";
var fromStatic = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromValue(defaultValue);
var loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
const { signingName, logger } = configuration;
const envOptions = { signingName, logger };
return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue)));
};
var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
var DEFAULT_USE_DUALSTACK_ENDPOINT = false;
var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
default: false
};
var nodeDualstackConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
default: undefined
};
var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
var DEFAULT_USE_FIPS_ENDPOINT = false;
var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
default: false
};
var nodeFipsConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
default: undefined
};
var resolveCustomEndpointsConfig = (input) => {
const { tls, endpoint, urlParser, useDualstackEndpoint } = input;
return Object.assign(input, {
tls: tls ?? true,
endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint),
isCustomEndpoint: true,
useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false)
});
};
var getEndpointFromRegion = async (input) => {
const { tls = true } = input;
const region = await input.region();
const dnsHostRegex = new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/);
if (!dnsHostRegex.test(region)) {
throw new Error("Invalid region in client config");
}
const useDualstackEndpoint = await input.useDualstackEndpoint();
const useFipsEndpoint = await input.useFipsEndpoint();
const { hostname } = await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint }) ?? {};
if (!hostname) {
throw new Error("Cannot resolve hostname from client config");
}
return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
};
var resolveEndpointsConfig = (input) => {
const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint ?? false);
const { endpoint, useFipsEndpoint, urlParser, tls } = input;
return Object.assign(input, {
tls: tls ?? true,
endpoint: endpoint ? normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint) : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }),
isCustomEndpoint: !!endpoint,
useDualstackEndpoint
});
};
var AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
var AWS_REGION_ENV = "AWS_REGION";
var AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
var DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
var IMDS_REGION_PATH = "/latest/meta-data/placement/region";
var IMDS_TOKEN_PATH = "/latest/api/token";
var X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token";
var X_AWS_EC2_METADATA_TOKEN_TTL = "x-aws-ec2-metadata-token-ttl-seconds";
var TIMEOUT_MS = 1000;
var NEG_CACHE_TTL_MS = 60000;
var negativeCacheUntil = 0;
var getInstanceMetadataRegion = async () => {
if (process.env[ENV_IMDS_DISABLED]) {
return;
}
if (Date.now() < negativeCacheUntil) {
return;
}
try {
const endpoint = resolveImdsEndpoint();
const token = (await imdsRequest({
...endpoint,
path: IMDS_TOKEN_PATH,
method: "PUT",
headers: {
[X_AWS_EC2_METADATA_TOKEN_TTL]: "21600"
}
})).toString();
const region = (await imdsRequest({
...endpoint,
path: IMDS_REGION_PATH,
method: "GET",
headers: {
[X_AWS_EC2_METADATA_TOKEN]: token
}
})).toString().trim();
return region || cacheNegativeAndReturnUndefined();
} catch {
return cacheNegativeAndReturnUndefined();
}
};
var cacheNegativeAndReturnUndefined = () => {
negativeCacheUntil = Date.now() + NEG_CACHE_TTL_MS;
return;
};
var resolveImdsEndpoint = () => {
const envEndpoint = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT;
if (envEndpoint) {
const url = new URL(envEndpoint);
return {
hostname: url.hostname.replace(/^\[(.+)]$/, "$1"),
port: url.port ? Number(url.port) : undefined
};
}
if (process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE === "IPv6") {
return { hostname: "fd00:ec2::254" };
}
return { hostname: "169.254.169.254" };
};
var imdsRequest = async (options) => {
const { request } = __require("http");
return new Promise((resolve, reject) => {
const req = request({
hostname: options.hostname,
port: options.port,
path: options.path,
method: options.method,
headers: options.headers,
timeout: TIMEOUT_MS,
signal: AbortSignal.timeout(TIMEOUT_MS)
});
req.on("error", (err) => {
reject(err);
req.destroy();
});
req.on("timeout", () => {
reject(new Error("TimeoutError from instance metadata service"));
req.destroy();
});
req.on("response", (res) => {
const { statusCode = 400 } = res;
if (statusCode < 200 || statusCode >= 300) {
reject(Object.assign(new Error("Error response received from instance metadata service"), { statusCode }));
req.destroy();
return;
}
const chunks = [];
res.on("data", (chunk) => chunks.push(chunk));
res.on("end", () => {
resolve(Buffer.concat(chunks));
req.destroy();
});
});
req.end();
});
};
var REGION_ENV_NAME = "AWS_REGION";
var REGION_INI_NAME = "region";
var NODE_REGION_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[REGION_ENV_NAME],
configFileSelector: (profile) => profile[REGION_INI_NAME],
default: async () => {
const region = await getInstanceMetadataRegion();
if (region) {
return region;
}
throw new Error("Region is missing");
}
};
var NODE_REGION_CONFIG_FILE_OPTIONS = {
preferredFile: "credentials"
};
var validRegions = new Set;
var 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 isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
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 getHostnameFromVariants = (variants = [], { useFipsEndpoint, useDualstackEndpoint }) => variants.find(({ tags }) => useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack"))?.hostname;
var getResolvedHostname = (resolvedRegion, { regionHostname, partitionHostname }) => regionHostname ? regionHostname : partitionHostname ? partitionHostname.replace("{region}", resolvedRegion) : undefined;
var getResolvedPartition = (region, { partitionHash }) => Object.keys(partitionHash || {}).find((key) => partitionHash[key].regions.includes(region)) ?? "aws";
var getResolvedSigningRegion = (hostname, { signingRegion, regionRegex, useFipsEndpoint }) => {
if (signingRegion) {
return signingRegion;
} else if (useFipsEndpoint) {
const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
const regionRegexmatchArray = hostname.match(regionRegexJs);
if (regionRegexmatchArray) {
return regionRegexmatchArray[0].slice(1, -1);
}
}
};
var getRegionInfo = (region, { useFipsEndpoint = false, useDualstackEndpoint = false, signingService, regionHash, partitionHash }) => {
const partition = getResolvedPartition(region, { partitionHash });
const resolvedRegion = region in regionHash ? region : partitionHash[partition]?.endpoint ?? region;
const hostnameOptions = { useFipsEndpoint, useDualstackEndpoint };
const regionHostname = getHostnameFromVariants(regionHash[resolvedRegion]?.variants, hostnameOptions);
const partitionHostname = getHostnameFromVariants(partitionHash[partition]?.variants, hostnameOptions);
const hostname = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname });
if (hostname === undefined) {
throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`);
}
const signingRegion = getResolvedSigningRegion(hostname, {
signingRegion: regionHash[resolvedRegion]?.signingRegion,
regionRegex: partitionHash[partition].regionRegex,
useFipsEndpoint
});
return {
partition,
signingService,
hostname,
...signingRegion && { signingRegion },
...regionHash[resolvedRegion]?.signingService && {
signingService: regionHash[resolvedRegion].signingService
}
};
};
var AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
var AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => {
return env[AWS_DEFAULTS_MODE_ENV];
},
configFileSelector: (profile) => {
return profile[AWS_DEFAULTS_MODE_CONFIG];
},
default: "legacy"
};
var resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS) } = {}) => memoize(async () => {
const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
switch (mode?.toLowerCase()) {
case "auto":
return resolveNodeDefaultsModeAuto(region);
case "in-region":
case "cross-region":
case "mobile":
case "standard":
case "legacy":
return Promise.resolve(mode?.toLocaleLowerCase());
case undefined:
return Promise.resolve("legacy");
default:
throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
}
});
var resolveNodeDefaultsModeAuto = async (clientRegion) => {
if (clientRegion) {
const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion;
const inferredRegion = await inferPhysicalRegion();
if (!inferredRegion) {
return "standard";
}
if (resolvedRegion === inferredRegion) {
return "in-region";
} else {
return "cross-region";
}
}
return "standard";
};
var inferPhysicalRegion = async () => {
if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
}
return getInstanceMetadataRegion();
};
exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
exports.CONFIG_USE_DUALSTACK_ENDPOINT = CONFIG_USE_DUALSTACK_ENDPOINT;
exports.CONFIG_USE_FIPS_ENDPOINT = CONFIG_USE_FIPS_ENDPOINT;
exports.CredentialsProviderError = CredentialsProviderError;
exports.DEFAULT_PROFILE = DEFAULT_PROFILE;
exports.DEFAULT_USE_DUALSTACK_ENDPOINT = DEFAULT_USE_DUALSTACK_ENDPOINT;
exports.DEFAULT_USE_FIPS_ENDPOINT = DEFAULT_USE_FIPS_ENDPOINT;
exports.ENV_PROFILE = ENV_PROFILE;
exports.ENV_USE_DUALSTACK_ENDPOINT = ENV_USE_DUALSTACK_ENDPOINT;
exports.ENV_USE_FIPS_ENDPOINT = ENV_USE_FIPS_ENDPOINT;
exports.NODE_REGION_CONFIG_FILE_OPTIONS = NODE_REGION_CONFIG_FILE_OPTIONS;
exports.NODE_REGION_CONFIG_OPTIONS = NODE_REGION_CONFIG_OPTIONS;
exports.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS;
exports.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS;
exports.ProviderError = ProviderError;
exports.REGION_ENV_NAME = REGION_ENV_NAME;
exports.REGION_INI_NAME = REGION_INI_NAME;
exports.SelectorType = SelectorType;
exports.TokenProviderError = TokenProviderError;
exports.booleanSelector = booleanSelector;
exports.chain = chain;
exports.externalDataInterceptor = externalDataInterceptor;
exports.fromStatic = fromStatic;
exports.fromValue = fromValue;
exports.getHomeDir = getHomeDir;
exports.getProfileName = getProfileName;
exports.getRegionInfo = getRegionInfo;
exports.getSSOTokenFilepath = getSSOTokenFilepath;
exports.getSSOTokenFromFile = getSSOTokenFromFile;
exports.loadConfig = loadConfig;
exports.loadSharedConfigFiles = loadSharedConfigFiles;
exports.loadSsoSessionData = loadSsoSessionData;
exports.memoize = memoize;
exports.nodeDualstackConfigSelectors = nodeDualstackConfigSelectors;
exports.nodeFipsConfigSelectors = nodeFipsConfigSelectors;
exports.numberSelector = numberSelector;
exports.parseKnownFiles = parseKnownFiles;
exports.readFile = readFile;
exports.resolveCustomEndpointsConfig = resolveCustomEndpointsConfig;
exports.resolveDefaultsModeConfig = resolveDefaultsModeConfig;
exports.resolveEndpointsConfig = resolveEndpointsConfig;
exports.resolveRegionConfig = resolveRegionConfig;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/endpoints/index.js
var require_endpoints = __commonJS(function(exports) {
var { CONFIG_PREFIX_SEPARATOR, booleanSelector, SelectorType, loadConfig } = require_config();
var { toEndpointV1, getSmithyContext, normalizeProvider, isValidHostLabel, hasOwn } = require_transport();
exports.isValidHostLabel = isValidHostLabel;
exports.middlewareEndpointToEndpointV1 = toEndpointV1;
exports.toEndpointV1 = toEndpointV1;
var { EndpointURLScheme } = require_dist_cjs();
var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
var CONFIG_ENDPOINT_URL = "endpoint_url";
var getEndpointUrlConfig = (serviceId) => ({
environmentVariableSelector: (env) => {
const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
if (serviceEndpointUrl)
return serviceEndpointUrl;
const endpointUrl = env[ENV_ENDPOINT_URL];
if (endpointUrl)
return endpointUrl;
return;
},
configFileSelector: (profile, config) => {
if (profile.services) {
const servicesSectionKey = ["services", profile.services].join(CONFIG_PREFIX_SEPARATOR);
if (!config || !config[servicesSectionKey]) {
throw new Error(`The services section "${profile.services}" specified in the profile is not present in the shared configuration file.`);
}
const servicesSection = config[servicesSectionKey];
const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
const endpointUrl = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
if (endpointUrl)
return endpointUrl;
}
const endpointUrl = profile[CONFIG_ENDPOINT_URL];
if (endpointUrl)
return endpointUrl;
return;
},
default: undefined
});
var ENV_IGNORE_CONFIGURED_ENDPOINT_URLS = "AWS_IGNORE_CONFIGURED_ENDPOINT_URLS";
var CONFIG_IGNORE_CONFIGURED_ENDPOINT_URLS = "ignore_configured_endpoint_urls";
var ignoreConfiguredEndpointUrlsConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_IGNORE_CONFIGURED_ENDPOINT_URLS, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_IGNORE_CONFIGURED_ENDPOINT_URLS, SelectorType.CONFIG),
default: false
};
var getEndpointFromConfig = async (serviceId) => {
const ignore = await loadConfig(ignoreConfiguredEndpointUrlsConfigSelectors)();
if (ignore) {
return;
}
return loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
};
var resolveParamsForS3 = async (endpointParams) => {
const bucket = endpointParams?.Bucket || "";
if (typeof endpointParams.Bucket === "string") {
endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
}
if (isArnBucketName(bucket)) {
if (endpointParams.ForcePathStyle === true) {
throw new Error("Path-style addressing cannot be used with ARN buckets");
}
} else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
endpointParams.ForcePathStyle = true;
}
if (endpointParams.DisableMultiRegionAccessPoints) {
endpointParams.disableMultiRegionAccessPoints = true;
endpointParams.DisableMRAP = true;
}
return endpointParams;
};
var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
var DOTS_PATTERN = /\.\./;
var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
var isArnBucketName = (bucketName) => {
const [arn, partition, service, , , bucket] = bucketName.split(":");
const isArn = arn === "arn" && bucketName.split(":").length >= 6;
const isValidArn = Boolean(isArn && partition && service && bucket);
if (isArn && !isValidArn) {
throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
}
return isValidArn;
};
var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config, isClientContextParam = false) => {
const configProvider = async () => {
let configValue;
if (isClientContextParam) {
const clientContextParams = config.clientContextParams;
const nestedValue = clientContextParams?.[configKey];
configValue = nestedValue ?? config[configKey] ?? config[canonicalEndpointParamKey];
} else {
configValue = config[configKey] ?? config[canonicalEndpointParamKey];
}
if (typeof configValue === "function") {
return configValue();
}
return configValue;
};
if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
return async () => {
const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
return configValue;
};
}
if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
return async () => {
const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
const configValue = credentials?.accountId ?? credentials?.AccountId;
return configValue;
};
}
if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
return async () => {
if (config.isCustomEndpoint === false) {
return;
}
const endpoint = await configProvider();
if (endpoint && typeof endpoint === "object") {
if ("url" in endpoint) {
return endpoint.url.href;
}
if ("hostname" in endpoint) {
const { protocol, hostname, port, path } = endpoint;
return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
}
}
return endpoint;
};
}
return configProvider;
};
function bindGetEndpointFromInstructions(getEndpointFromConfig) {
return async (commandInput, instructionsSupplier, clientConfig, context) => {
if (!clientConfig.isCustomEndpoint && !clientConfig.ignoreConfiguredEndpointUrls) {
let endpointFromConfig;
if (clientConfig.serviceConfiguredEndpoint) {
endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
} else {
endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
}
if (endpointFromConfig) {
clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
clientConfig.isCustomEndpoint = true;
context?.logger?.debug?.(`@smithy/core/endpoints - resolved endpoint from config: ${endpointFromConfig}`);
}
}
const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
if (typeof clientConfig.endpointProvider !== "function") {
throw new Error("config.endpointProvider is not set.");
}
const endpoint = clientConfig.endpointProvider(endpointParams, context);
if (clientConfig.isCustomEndpoint && clientConfig.endpoint) {
const customEndpoint = await clientConfig.endpoint();
if (customEndpoint?.headers) {
endpoint.headers ??= {};
for (const [name, value] of Object.entries(customEndpoint.headers)) {
endpoint.headers[name] = Array.isArray(value) ? value : [value];
}
}
}
return endpoint;
};
}
var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
const endpointParams = {};
const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
for (const [name, instruction] of Object.entries(instructions)) {
switch (instruction.type) {
case "staticContextParams":
endpointParams[name] = instruction.value;
break;
case "contextParams":
endpointParams[name] = commandInput[instruction.name];
break;
case "clientContextParams":
case "builtInParams":
endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig, instruction.type !== "builtInParams")();
break;
case "operationContextParams":
endpointParams[name] = instruction.get(commandInput);
break;
default:
throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
}
}
if (Object.keys(instructions).length === 0) {
Object.assign(endpointParams, clientConfig);
}
if (String(clientConfig.serviceId).toLowerCase() === "s3") {
await resolveParamsForS3(endpointParams);
}
return endpointParams;
};
function setFeature(context, feature, value) {
if (!context.__smithy_context) {
context.__smithy_context = { features: {} };
} else if (!context.__smithy_context.features) {
context.__smithy_context.features = {};
}
context.__smithy_context.features[feature] = value;
}
function bindEndpointMiddleware(getEndpointFromConfig) {
const getEndpointFromInstructions = bindGetEndpointFromInstructions(getEndpointFromConfig);
return ({ config, instructions }) => {
return (next, context) => async (args) => {
if (config.isCustomEndpoint) {
setFeature(context, "ENDPOINT_OVERRIDE", "N");
}
const endpoint = await getEndpointFromInstructions(args.input, {
getEndpointParameterInstructions() {
return instructions;
}
}, { ...config }, context);
context.endpointV2 = endpoint;
context.authSchemes = endpoint.properties?.authSchemes;
const authScheme = context.authSchemes?.[0];
if (authScheme) {
context["signing_region"] = authScheme.signingRegion;
context["signing_service"] = authScheme.signingName;
const smithyContext = getSmithyContext(context);
const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
if (httpAuthOption) {
httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
signing_region: authScheme.signingRegion,
signingRegion: authScheme.signingRegion,
signing_service: authScheme.signingName,
signingName: authScheme.signingName,
signingRegionSet: authScheme.signingRegionSet
}, authScheme.properties);
}
}
return next({
...args
});
};
};
}
var serializerMiddlewareOption = {
name: "serializerMiddleware"
};
var endpointMiddlewareOptions = {
step: "serialize",
tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
name: "endpointV2Middleware",
override: true,
relation: "before",
toMiddleware: serializerMiddlewareOption.name
};
function bindGetEndpointPlugin(getEndpointFromConfig) {
const endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
return (config, instructions) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(endpointMiddleware({
config,
instructions
}), endpointMiddlewareOptions);
}
});
}
function bindResolveEndpointConfig(getEndpointFromConfig) {
return (input) => {
const tls = input.tls ?? true;
const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider(endpoint)()) : undefined;
const isCustomEndpoint = !!endpoint;
const resolvedConfig = Object.assign(input, {
endpoint: customEndpointProvider,
tls,
isCustomEndpoint,
useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false),
useFipsEndpoint: normalizeProvider(useFipsEndpoint ?? false),
ignoreConfiguredEndpointUrls: !!input.ignoreConfiguredEndpointUrls
});
let configuredEndpointPromise = undefined;
resolvedConfig.serviceConfiguredEndpoint = async () => {
if (input.serviceId && !configuredEndpointPromise) {
configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
}
return configuredEndpointPromise;
};
return resolvedConfig;
};
}
class BinaryDecisionDiagram {
nodes;
root;
conditions;
results;
constructor(bdd, root, conditions, results) {
this.nodes = bdd;
this.root = root;
this.conditions = conditions;
this.results = results;
}
static from(bdd, root, conditions, results) {
return new BinaryDecisionDiagram(bdd, root, conditions, results);
}
}
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;
}
}
class EndpointError extends Error {
constructor(message) {
super(message);
this.name = "EndpointError";
}
}
var 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);
}
var customEndpointFunctions = {};
var booleanEquals = (value1, value2) => value1 === value2;
function coalesce(...args) {
for (const arg of args) {
if (arg != null) {
return arg;
}
}
return;
}
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 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)) {
const i = parseInt(index);
return acc[i < 0 ? acc.length + i : i];
}
return acc[index];
}, value);
var isSet = (value) => value != null;
function ite(condition, trueValue, falseValue) {
return condition ? trueValue : falseValue;
}
var not = (value) => !value;
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 = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
var DEFAULT_PORTS = {
[EndpointURLScheme.HTTP]: 80,
[EndpointURLScheme.HTTPS]: 443
};
var 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 (ignored) {
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(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
};
};
function split(value, delimiter, limit) {
if (limit === 1) {
return [value];
}
if (value === "") {
return [""];
}
const parts = value.split(delimiter);
if (limit === 0) {
return parts;
}
return parts.slice(0, limit - 1).concat(parts.slice(1).join(delimiter));
}
var stringEquals = (value1, value2) => value1 === value2;
var substring = (input, start, stop, reverse) => {
if (input == null || 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 uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
var endpointFunctions = {
booleanEquals,
coalesce,
getAttr,
isSet,
isValidHostLabel,
ite,
not,
parseURL,
split,
stringEquals,
substring,
uriEncode
};
var evaluateTemplate = (template, options) => {
const evaluatedTemplateArr = [];
const { referenceRecord, endpointParams } = options;
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(referenceRecord[refName] ?? endpointParams[refName], attrName));
} else {
evaluatedTemplateArr.push(referenceRecord[parameterName] ?? endpointParams[parameterName]);
}
currentIndex = closingBraceIndex + 1;
}
return evaluatedTemplateArr.join("");
};
var getReferenceValue = ({ ref }, options) => {
return options.referenceRecord[ref] ?? options.endpointParams[ref];
};
var evaluateExpression = (obj, keyName, options) => {
if (typeof obj === "string") {
return evaluateTemplate(obj, options);
} else if (obj["fn"]) {
return group$2.callFunction(obj, options);
} else if (obj["ref"]) {
return getReferenceValue(obj, options);
}
throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
};
var callFunction = ({ fn, argv }, options) => {
const evaluatedArgs = Array(argv.length);
for (let i = 0;i < evaluatedArgs.length; ++i) {
const arg = argv[i];
if (typeof arg === "boolean" || typeof arg === "number") {
evaluatedArgs[i] = arg;
} else {
evaluatedArgs[i] = group$2.evaluateExpression(arg, "arg", options);
}
}
const namespaceSeparatorIndex = fn.indexOf(".");
if (namespaceSeparatorIndex !== -1) {
const namespaceFunctions = customEndpointFunctions[fn.slice(0, namespaceSeparatorIndex)];
const customFunction = namespaceFunctions?.[fn.slice(namespaceSeparatorIndex + 1)];
if (typeof customFunction === "function") {
return customFunction(...evaluatedArgs);
}
}
const callable = endpointFunctions[fn];
if (typeof callable === "function") {
return callable(...evaluatedArgs);
}
throw new Error(`function ${fn} not loaded in endpointFunctions.`);
};
var group$2 = {
evaluateExpression,
callFunction
};
var evaluateCondition = (condition, options) => {
const { assign } = condition;
if (assign && assign in options.referenceRecord) {
throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
}
const value = callFunction(condition, options);
options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(condition)} = ${toDebugString(value)}`);
const result = value === "" ? true : !!value;
if (assign != null) {
return { result, toAssign: { name: assign, value } };
}
return { result };
};
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;
});
return acc;
}, {});
var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
acc[propertyKey] = group$1.getEndpointProperty(propertyVal, options);
return acc;
}, {});
var 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 group$1.getEndpointProperties(property, options);
case "boolean":
return property;
default:
throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
}
};
var group$1 = {
getEndpointProperty,
getEndpointProperties
};
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 RESULT = 1e8;
var decideEndpoint = (bdd, options) => {
const { nodes, root, results, conditions } = bdd;
let ref = root;
const referenceRecord = {};
const closure = {
referenceRecord,
endpointParams: options.endpointParams,
logger: options.logger
};
while (ref !== 1 && ref !== -1 && ref < RESULT) {
const node_i = 3 * (Math.abs(ref) - 1);
const [condition_i, highRef, lowRef] = [nodes[node_i], nodes[node_i + 1], nodes[node_i + 2]];
const [fn, argv, assign] = conditions[condition_i];
const evaluation = evaluateCondition({ fn, assign, argv }, closure);
if (evaluation.toAssign) {
const { name, value } = evaluation.toAssign;
referenceRecord[name] = value;
}
ref = ref >= 0 === evaluation.result ? highRef : lowRef;
}
if (ref >= RESULT) {
const result = results[ref - RESULT];
if (result[0] === -1) {
const [, errorExpression] = result;
throw new EndpointError(evaluateExpression(errorExpression, "Error", closure));
}
const [url, properties, headers] = result;
return {
url: getEndpointUrl(url, closure),
properties: getEndpointProperties(properties, closure),
headers: getEndpointHeaders(headers ?? {}, closure)
};
}
throw new EndpointError(`No matching endpoint.`);
};
var evaluateConditions = (conditions = [], options) => {
const conditionsReferenceRecord = {};
const conditionOptions = {
...options,
referenceRecord: { ...options.referenceRecord }
};
let didAssign = false;
for (const condition of conditions) {
const { result, toAssign } = evaluateCondition(condition, conditionOptions);
if (!result) {
return { result };
}
if (toAssign) {
didAssign = true;
conditionsReferenceRecord[toAssign.name] = toAssign.value;
conditionOptions.referenceRecord[toAssign.name] = toAssign.value;
options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
}
}
if (didAssign) {
return { result: true, referenceRecord: conditionsReferenceRecord };
}
return { result: true };
};
var evaluateEndpointRule = (endpointRule, options) => {
const { conditions, endpoint } = endpointRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const endpointRuleOptions = referenceRecord ? {
...options,
referenceRecord: { ...options.referenceRecord, ...referenceRecord }
} : options;
const { url, properties, headers } = endpoint;
options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
const endpointToReturn = { url: getEndpointUrl(url, endpointRuleOptions) };
if (headers != null) {
endpointToReturn.headers = getEndpointHeaders(headers, endpointRuleOptions);
}
if (properties != null) {
endpointToReturn.properties = getEndpointProperties(properties, endpointRuleOptions);
}
return endpointToReturn;
};
var evaluateErrorRule = (errorRule, options) => {
const { conditions, error } = errorRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const errorRuleOptions = referenceRecord ? {
...options,
referenceRecord: { ...options.referenceRecord, ...referenceRecord }
} : options;
throw new EndpointError(evaluateExpression(error, "Error", errorRuleOptions));
};
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 = group.evaluateTreeRule(rule, options);
if (endpointOrUndefined) {
return endpointOrUndefined;
}
} else {
throw new EndpointError(`Unknown endpoint rule: ${rule}`);
}
}
throw new EndpointError(`Rules evaluation failed`);
};
var evaluateTreeRule = (treeRule, options) => {
const { conditions, rules } = treeRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const treeRuleOptions = referenceRecord ? { ...options, referenceRecord: { ...options.referenceRecord, ...referenceRecord } } : options;
return group.evaluateRules(rules, treeRuleOptions);
};
var group = {
evaluateRules,
evaluateTreeRule
};
var resolveEndpoint = (ruleSetObject, options) => {
const { endpointParams, logger } = options;
const { parameters, rules } = ruleSetObject;
options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
for (const paramKey in parameters) {
if (!hasOwn(parameters, paramKey))
continue;
const parameter = parameters[paramKey];
const endpointParam = endpointParams[paramKey];
if (endpointParam == null && parameter.default != null) {
endpointParams[paramKey] = parameter.default;
continue;
}
if (parameter.required && endpointParam == null) {
throw new EndpointError(`Missing required parameter: '${paramKey}'`);
}
}
const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
return endpoint;
};
var resolveEndpointRequiredConfig = (input) => {
const { endpoint } = input;
if (endpoint === undefined) {
input.endpoint = async () => {
throw new Error("@smithy/middleware-endpoint: (default endpointRuleSet) endpoint is not set - you must configure an endpoint.");
};
}
return input;
};
var getEndpointFromInstructions = bindGetEndpointFromInstructions(getEndpointFromConfig);
var resolveEndpointConfig = bindResolveEndpointConfig(getEndpointFromConfig);
var endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
var getEndpointPlugin = bindGetEndpointPlugin(getEndpointFromConfig);
exports.BinaryDecisionDiagram = BinaryDecisionDiagram;
exports.EndpointCache = EndpointCache;
exports.EndpointError = EndpointError;
exports.customEndpointFunctions = customEndpointFunctions;
exports.decideEndpoint = decideEndpoint;
exports.endpointMiddleware = endpointMiddleware;
exports.endpointMiddlewareOptions = endpointMiddlewareOptions;
exports.getEndpointFromInstructions = getEndpointFromInstructions;
exports.getEndpointPlugin = getEndpointPlugin;
exports.isIpAddress = isIpAddress;
exports.resolveEndpoint = resolveEndpoint;
exports.resolveEndpointConfig = resolveEndpointConfig;
exports.resolveEndpointRequiredConfig = resolveEndpointRequiredConfig;
exports.resolveParams = resolveParams;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/serde/index.js
var require_serde = __commonJS(function(exports) {
var { createHmac, createHash, getRandomValues } = __require("crypto");
var { hasOwn, HttpResponse } = require_transport();
exports.hasOwn = hasOwn;
var { ReadStream, lstatSync, fstatSync } = __require("fs");
var { toEndpointV1 } = require_endpoints();
var { Readable, Writable, PassThrough } = __require("stream");
var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
if (!isArrayBuffer(input)) {
throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
}
return Buffer.from(input, offset, length);
};
var fromString = (input, encoding) => {
if (typeof input !== "string") {
throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
}
return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
};
var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
var fromBase64 = (input) => {
if (input.length * 3 % 4 !== 0) {
throw new TypeError(`Incorrect padding on base64 string.`);
}
if (!BASE64_REGEX.exec(input)) {
throw new TypeError(`Invalid base64 string.`);
}
const buffer = fromString(input, "base64");
return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
var fromUtf8$1 = (input) => {
const buf = fromString(input, "utf8");
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
};
var toBase64$1 = (_input) => {
let input;
if (typeof _input === "string") {
input = fromUtf8$1(_input);
} else {
input = _input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
}
return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
};
function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
return class Uint8ArrayBlobAdapter extends Uint8Array {
static fromString(source, encoding = "utf-8") {
if (typeof source === "string") {
if (encoding === "base64") {
return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
}
return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
}
throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
}
static mutate(source) {
Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
return source;
}
transformToString(encoding = "utf-8") {
if (encoding === "base64") {
return toBase64(this);
}
return toUtf8(this);
}
};
}
var toUtf8$1 = (input) => {
if (typeof input === "string") {
return input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
}
return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
};
var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
function bindV4(getRandomValues) {
if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
return () => crypto.randomUUID();
}
return () => {
const rnds = new Uint8Array(16);
getRandomValues(rnds);
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
};
}
var copyDocumentWithTransform = (source, _schemaRef, _transform = (_) => _) => source;
var parseBoolean = (value) => {
switch (value) {
case "true":
return true;
case "false":
return false;
default:
throw new Error(`Unable to parse boolean value "${value}"`);
}
};
var expectBoolean = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "number") {
if (value === 0 || value === 1) {
logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
}
if (value === 0) {
return false;
}
if (value === 1) {
return true;
}
}
if (typeof value === "string") {
const lower = value.toLowerCase();
if (lower === "false" || lower === "true") {
logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
}
if (lower === "false") {
return false;
}
if (lower === "true") {
return true;
}
}
if (typeof value === "boolean") {
return value;
}
throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
};
var expectNumber = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "string") {
const parsed = parseFloat(value);
if (!Number.isNaN(parsed)) {
if (String(parsed) !== String(value)) {
logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
}
return parsed;
}
}
if (typeof value === "number") {
return value;
}
throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
};
var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
var expectFloat32 = (value) => {
const expected = expectNumber(value);
if (expected !== undefined && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
if (Math.abs(expected) > MAX_FLOAT) {
throw new TypeError(`Expected 32-bit float, got ${value}`);
}
}
return expected;
};
var expectLong = (value) => {
if (value === null || value === undefined) {
return;
}
if (Number.isInteger(value) && !Number.isNaN(value)) {
return value;
}
throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
};
var expectInt = expectLong;
var expectInt32 = (value) => expectSizedInt(value, 32);
var expectShort = (value) => expectSizedInt(value, 16);
var expectByte = (value) => expectSizedInt(value, 8);
var expectSizedInt = (value, size) => {
const expected = expectLong(value);
if (expected !== undefined && castInt(expected, size) !== expected) {
throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
}
return expected;
};
var castInt = (value, size) => {
switch (size) {
case 32:
return Int32Array.of(value)[0];
case 16:
return Int16Array.of(value)[0];
case 8:
return Int8Array.of(value)[0];
}
};
var expectNonNull = (value, location) => {
if (value === null || value === undefined) {
if (location) {
throw new TypeError(`Expected a non-null value for ${location}`);
}
throw new TypeError("Expected a non-null value");
}
return value;
};
var expectObject = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "object" && !Array.isArray(value)) {
return value;
}
const receivedType = Array.isArray(value) ? "array" : typeof value;
throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
};
var expectString = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "string") {
return value;
}
if (["boolean", "number", "bigint"].includes(typeof value)) {
logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
return String(value);
}
throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
};
var expectUnion = (value) => {
if (value === null || value === undefined) {
return;
}
const asObject = expectObject(value);
const setKeys = [];
for (const k in asObject) {
if (!hasOwn(asObject, k))
continue;
if (asObject[k] != null) {
setKeys.push(k);
}
}
if (setKeys.length === 0) {
throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
}
if (setKeys.length > 1) {
throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
}
return asObject;
};
var strictParseDouble = (value) => {
if (typeof value == "string") {
return expectNumber(parseNumber(value));
}
return expectNumber(value);
};
var strictParseFloat = strictParseDouble;
var strictParseFloat32 = (value) => {
if (typeof value == "string") {
return expectFloat32(parseNumber(value));
}
return expectFloat32(value);
};
var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
var parseNumber = (value) => {
const matches = value.match(NUMBER_REGEX);
if (matches === null || matches[0].length !== value.length) {
throw new TypeError(`Expected real number, got implicit NaN`);
}
return parseFloat(value);
};
var limitedParseDouble = (value) => {
if (typeof value == "string") {
return parseFloatString(value);
}
return expectNumber(value);
};
var handleFloat = limitedParseDouble;
var limitedParseFloat = limitedParseDouble;
var limitedParseFloat32 = (value) => {
if (typeof value == "string") {
return parseFloatString(value);
}
return expectFloat32(value);
};
var parseFloatString = (value) => {
switch (value) {
case "NaN":
return NaN;
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
default:
throw new Error(`Unable to parse float value: ${value}`);
}
};
var strictParseLong = (value) => {
if (typeof value === "string") {
return expectLong(parseNumber(value));
}
return expectLong(value);
};
var strictParseInt = strictParseLong;
var strictParseInt32 = (value) => {
if (typeof value === "string") {
return expectInt32(parseNumber(value));
}
return expectInt32(value);
};
var strictParseShort = (value) => {
if (typeof value === "string") {
return expectShort(parseNumber(value));
}
return expectShort(value);
};
var strictParseByte = (value) => {
if (typeof value === "string") {
return expectByte(parseNumber(value));
}
return expectByte(value);
};
var stackTraceWarning = (message) => {
return String(new TypeError(message).stack || message).split(`
`).slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join(`
`);
};
var logger = {
warn: console.warn
};
var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
function dateToUtcString(date) {
const year = date.getUTCFullYear();
const month = date.getUTCMonth();
const dayOfWeek = date.getUTCDay();
const dayOfMonthInt = date.getUTCDate();
const hoursInt = date.getUTCHours();
const minutesInt = date.getUTCMinutes();
const secondsInt = date.getUTCSeconds();
const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`;
}
var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
var parseRfc3339DateTime = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-3339 date-times must be expressed as strings");
}
const match = RFC3339.exec(value);
if (!match) {
throw new TypeError("Invalid RFC-3339 date-time value");
}
const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
const year = strictParseShort(stripLeadingZeroes(yearStr));
const month = parseDateValue(monthStr, "month", 1, 12);
const day = parseDateValue(dayStr, "day", 1, 31);
return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
};
var RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}:\d{2})|[zZ])$/);
var parseRfc3339DateTimeWithOffset = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-3339 date-times must be expressed as strings");
}
const match = RFC3339_WITH_OFFSET$1.exec(value);
if (!match) {
throw new TypeError("Invalid RFC-3339 date-time value");
}
const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
const year = strictParseShort(stripLeadingZeroes(yearStr));
const month = parseDateValue(monthStr, "month", 1, 12);
const day = parseDateValue(dayStr, "day", 1, 31);
const date = buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
if (offsetStr.toUpperCase() != "Z") {
date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr));
}
return date;
};
var IMF_FIXDATE$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
var RFC_850_DATE$1 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
var ASC_TIME$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
var parseRfc7231DateTime = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-7231 date-times must be expressed as strings");
}
let match = IMF_FIXDATE$1.exec(value);
if (match) {
const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
}
match = RFC_850_DATE$1.exec(value);
if (match) {
const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
hours,
minutes,
seconds,
fractionalMilliseconds
}));
}
match = ASC_TIME$1.exec(value);
if (match) {
const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
}
throw new TypeError("Invalid RFC-7231 date-time value");
};
var parseEpochTimestamp = (value) => {
if (value === null || value === undefined) {
return;
}
let valueAsDouble;
if (typeof value === "number") {
valueAsDouble = value;
} else if (typeof value === "string") {
valueAsDouble = strictParseDouble(value);
} else if (typeof value === "object" && value.tag === 1) {
valueAsDouble = value.value;
} else {
throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
}
if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
}
return new Date(Math.round(valueAsDouble * 1000));
};
var buildDate = (year, month, day, time) => {
const adjustedMonth = month - 1;
validateDayOfMonth(year, adjustedMonth, day);
return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds)));
};
var parseTwoDigitYear = (value) => {
const thisYear = new Date().getUTCFullYear();
const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value));
if (valueInThisCentury < thisYear) {
return valueInThisCentury + 100;
}
return valueInThisCentury;
};
var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1000;
var adjustRfc850Year = (input) => {
if (input.getTime() - new Date().getTime() > FIFTY_YEARS_IN_MILLIS) {
return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
}
return input;
};
var parseMonthByShortName = (value) => {
const monthIdx = MONTHS.indexOf(value);
if (monthIdx < 0) {
throw new TypeError(`Invalid month: ${value}`);
}
return monthIdx + 1;
};
var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var validateDayOfMonth = (year, month, day) => {
let maxDays = DAYS_IN_MONTH[month];
if (month === 1 && isLeapYear(year)) {
maxDays = 29;
}
if (day > maxDays) {
throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`);
}
};
var isLeapYear = (year) => {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
};
var parseDateValue = (value, type, lower, upper) => {
const dateVal = strictParseByte(stripLeadingZeroes(value));
if (dateVal < lower || dateVal > upper) {
throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
}
return dateVal;
};
var parseMilliseconds = (value) => {
if (value === null || value === undefined) {
return 0;
}
return strictParseFloat32("0." + value) * 1000;
};
var parseOffsetToMilliseconds = (value) => {
const directionStr = value[0];
let direction = 1;
if (directionStr == "+") {
direction = 1;
} else if (directionStr == "-") {
direction = -1;
} else {
throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
}
const hour = Number(value.substring(1, 3));
const minute = Number(value.substring(4, 6));
return direction * (hour * 60 + minute) * 60 * 1000;
};
var stripLeadingZeroes = (value) => {
let idx = 0;
while (idx < value.length - 1 && value.charAt(idx) === "0") {
idx++;
}
if (idx === 0) {
return value;
}
return value.slice(idx);
};
var LazyJsonString = function LazyJsonString(val) {
const str = Object.assign(new String(val), {
deserializeJSON() {
return JSON.parse(String(val));
},
toString() {
return String(val);
},
toJSON() {
return String(val);
}
});
return str;
};
LazyJsonString.from = (object) => {
if (object && typeof object === "object" && (object instanceof LazyJsonString || ("deserializeJSON" in object))) {
return object;
} else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
return LazyJsonString(String(object));
}
return LazyJsonString(JSON.stringify(object));
};
LazyJsonString.fromObject = LazyJsonString.from;
function quoteHeader(part) {
if (part.includes(",") || part.includes('"')) {
part = `"${part.replace(/"/g, "\\\"")}"`;
}
return part;
}
var ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
var mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
var time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
var date = `(\\d?\\d)`;
var year = `(\\d{4})`;
var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
var IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
var RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
var ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
var _parseEpochTimestamp = (value) => {
if (value == null) {
return;
}
let num = NaN;
if (typeof value === "number") {
num = value;
} else if (typeof value === "string") {
if (!/^-?\d*\.?\d+$/.test(value)) {
throw new TypeError(`parseEpochTimestamp - numeric string invalid.`);
}
num = Number.parseFloat(value);
} else if (typeof value === "object" && value.tag === 1) {
num = value.value;
}
if (isNaN(num) || Math.abs(num) === Infinity) {
throw new TypeError("Epoch timestamps must be valid finite numbers.");
}
return new Date(Math.round(num * 1000));
};
var _parseRfc3339DateTimeWithOffset = (value) => {
if (value == null) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC3339 timestamps must be strings");
}
const matches = RFC3339_WITH_OFFSET.exec(value);
if (!matches) {
throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
}
const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
range(monthStr, 1, 12);
range(dayStr, 1, 31);
range(hours, 0, 23);
range(minutes, 0, 59);
range(seconds, 0, 60);
const date = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1000) : 0));
date.setUTCFullYear(Number(yearStr));
if (offsetStr.toUpperCase() != "Z") {
const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [undefined, "+", 0, 0];
const scalar = sign === "-" ? 1 : -1;
date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1000 + Number(offsetM) * 60 * 1000));
}
return date;
};
var _parseRfc7231DateTime = (value) => {
if (value == null) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC7231 timestamps must be strings.");
}
let day;
let month;
let year;
let hour;
let minute;
let second;
let fraction;
let matches;
if (matches = IMF_FIXDATE.exec(value)) {
[, day, month, year, hour, minute, second, fraction] = matches;
} else if (matches = RFC_850_DATE.exec(value)) {
[, day, month, year, hour, minute, second, fraction] = matches;
year = (Number(year) + 1900).toString();
} else if (matches = ASC_TIME.exec(value)) {
[, month, day, hour, minute, second, fraction, year] = matches;
}
if (year && second) {
const timestamp = Date.UTC(Number(year), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1000) : 0);
range(day, 1, 31);
range(hour, 0, 23);
range(minute, 0, 59);
range(second, 0, 60);
const date = new Date(timestamp);
date.setUTCFullYear(Number(year));
return date;
}
throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
};
function range(v, min, max) {
const _v = Number(v);
if (_v < min || _v > max) {
throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
}
}
function splitEvery(value, delimiter, numDelimiters) {
if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
}
const segments = value.split(delimiter);
if (numDelimiters === 1) {
return segments;
}
const compoundSegments = [];
let currentSegment = "";
for (let i = 0;i < segments.length; i++) {
if (currentSegment === "") {
currentSegment = segments[i];
} else {
currentSegment += delimiter + segments[i];
}
if ((i + 1) % numDelimiters === 0) {
compoundSegments.push(currentSegment);
currentSegment = "";
}
}
if (currentSegment !== "") {
compoundSegments.push(currentSegment);
}
return compoundSegments;
}
var splitHeader = (value) => {
const z = value.length;
const values = [];
let withinQuotes = false;
let prevChar = undefined;
let anchor = 0;
for (let i = 0;i < z; ++i) {
const char = value[i];
switch (char) {
case `"`:
if (prevChar !== "\\") {
withinQuotes = !withinQuotes;
}
break;
case ",":
if (!withinQuotes) {
values.push(value.slice(anchor, i));
anchor = i + 1;
}
break;
}
prevChar = char;
}
values.push(value.slice(anchor));
return values.map((v) => {
v = v.trim();
const z = v.length;
if (z < 2) {
return v;
}
if (v[0] === `"` && v[z - 1] === `"`) {
v = v.slice(1, z - 1);
}
return v.replace(/\\"/g, '"');
});
};
var format = /^-?((0|[1-9]\d*)(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/;
class NumericValue {
string;
type;
constructor(string, type) {
this.string = string;
this.type = type;
if (!format.test(string)) {
throw new Error(`@smithy/core/serde - NumericValue string must conform to the Smithy bigDecimal format. Received: "${string}"`);
}
}
toString() {
return this.string;
}
static [Symbol.hasInstance](object) {
if (!object || typeof object !== "object") {
return false;
}
const _nv = object;
return NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format.test(_nv.string);
}
}
function nv(input) {
return new NumericValue(String(input), "bigDecimal");
}
var SHORT_TO_HEX = {};
var HEX_TO_SHORT = {};
for (let i = 0;i < 256; i++) {
let encodedByte = i.toString(16).toLowerCase();
if (encodedByte.length === 1) {
encodedByte = `0${encodedByte}`;
}
SHORT_TO_HEX[i] = encodedByte;
HEX_TO_SHORT[encodedByte] = i;
}
function fromHex(encoded) {
if (encoded.length % 2 !== 0) {
throw new Error("Hex encoded strings must have an even number length");
}
const out = new Uint8Array(encoded.length / 2);
for (let i = 0;i < encoded.length; i += 2) {
const encodedByte = encoded.slice(i, i + 2).toLowerCase();
if (encodedByte in HEX_TO_SHORT) {
out[i / 2] = HEX_TO_SHORT[encodedByte];
} else {
throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
}
}
return out;
}
function toHex(bytes) {
let out = "";
for (let i = 0;i < bytes.byteLength; i++) {
out += SHORT_TO_HEX[bytes[i]];
}
return out;
}
var calculateBodyLength = (body) => {
if (!body) {
return 0;
}
if (typeof body === "string") {
return Buffer.byteLength(body);
} else if (typeof body.byteLength === "number") {
return body.byteLength;
} else if (typeof body.size === "number") {
return body.size;
} else if (typeof body.start === "number" && typeof body.end === "number") {
return body.end + 1 - body.start;
} else if (body instanceof ReadStream) {
if (body.path != null) {
return lstatSync(body.path).size;
} else if (typeof body.fd === "number") {
return fstatSync(body.fd).size;
}
}
throw new Error(`Body Length computation failed for ${body}`);
};
var toUint8Array = (data) => {
if (data instanceof Uint8Array) {
return data;
}
if (typeof data === "string") {
return fromUtf8$1(data);
}
if (ArrayBuffer.isView(data)) {
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
}
return new Uint8Array(data);
};
function concatBytes(arrays, length) {
if (length === undefined) {
length = 0;
for (const bytes of arrays) {
length += bytes.byteLength;
}
}
const result = new Uint8Array(length);
let offset = 0;
for (const buf of arrays) {
result.set(buf, offset);
offset += buf.byteLength;
}
return result;
}
var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
const { response } = await next(args);
try {
const parsed = await deserializer(response, options);
return {
response,
output: parsed
};
} catch (error) {
Object.defineProperty(error, "$response", {
value: response,
enumerable: false,
writable: false,
configurable: false
});
if (!("$metadata" in error)) {
const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
try {
error.message += `
` + hint;
} catch (ignored) {
if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
console.warn(hint);
} else {
context.logger?.warn?.(hint);
}
}
if (typeof error.$responseBodyText !== "undefined") {
if (error.$response) {
error.$response.body = error.$responseBodyText;
}
}
try {
if (HttpResponse.isInstance(response)) {
const { headers = {} } = response;
const headerEntries = Object.entries(headers);
error.$metadata = {
httpStatusCode: response.statusCode,
requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
};
}
} catch (ignored) {}
}
throw error;
}
};
var findHeader = (pattern, headers) => {
return (headers.find(([k]) => {
return k.match(pattern);
}) || [undefined, undefined])[1];
};
var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
const endpointConfig = options;
const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : endpointConfig.endpoint;
if (!endpoint) {
throw new Error("No valid endpoint provider available.");
}
const request = await serializer(args.input, { ...options, endpoint });
return next({
...args,
request
});
};
var deserializerMiddlewareOption = {
name: "deserializerMiddleware",
step: "deserialize",
tags: ["DESERIALIZER"],
override: true
};
var serializerMiddlewareOption = {
name: "serializerMiddleware",
step: "serialize",
tags: ["SERIALIZER"],
override: true
};
function getSerdePlugin(config, serializer, deserializer) {
return {
applyToStack: (commandStack) => {
commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
}
};
}
class Hash {
algorithmIdentifier;
secret;
hash;
constructor(algorithmIdentifier, secret) {
this.algorithmIdentifier = algorithmIdentifier;
this.secret = secret;
this.reset();
}
update(toHash, encoding) {
this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
}
digest() {
return Promise.resolve(this.hash.digest());
}
reset() {
this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
}
}
function castSourceData(toCast, encoding) {
if (Buffer.isBuffer(toCast)) {
return toCast;
}
if (typeof toCast === "string") {
return fromString(toCast, encoding);
}
if (ArrayBuffer.isView(toCast)) {
return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
}
return fromArrayBuffer(toCast);
}
var ChecksumStream$1 = class ChecksumStream extends Readable {
expectedChecksum;
checksumSourceLocation;
checksum;
source;
base64Encoder;
constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) {
super();
if (typeof source.pipe !== "function") {
throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
}
this.source = source;
this.base64Encoder = base64Encoder ?? toBase64$1;
this.expectedChecksum = expectedChecksum;
this.checksum = checksum;
this.checksumSourceLocation = checksumSourceLocation;
this.source.on("data", this.onSourceData);
this.source.on("end", this.onSourceEnd);
this.source.on("error", this.onSourceError);
this.source.on("close", this.onSourceClose);
this.source.pause();
}
onSourceData = (chunk) => {
if (this.destroyed) {
return;
}
try {
this.checksum.update(chunk);
} catch (e) {
this.destroy(e);
return;
}
if (!this.push(chunk)) {
this.source.pause();
}
};
onSourceEnd = async () => {
if (this.destroyed) {
return;
}
try {
const digest = await this.checksum.digest();
const received = this.base64Encoder(digest);
if (this.expectedChecksum !== received) {
this.destroy(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` + ` in response header "${this.checksumSourceLocation}".`));
return;
}
} catch (e) {
this.destroy(e);
return;
}
this.push(null);
};
onSourceError = (error) => {
this.destroy(error);
};
onSourceClose = () => {
if (!this.destroyed && !this.source.readableEnded) {
this.destroy(new Error("Connection lost or stream closed before all data was received."));
}
};
_read(_size) {
this.source.resume();
}
_destroy(error, callback) {
this.source?.removeListener("data", this.onSourceData);
this.source?.removeListener("end", this.onSourceEnd);
this.source?.removeListener("error", this.onSourceError);
this.source?.removeListener("close", this.onSourceClose);
this.source?.destroy();
callback(error);
}
};
var isReadableStream = (stream) => typeof ReadableStream === "function" && (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
var isBlob = (blob) => {
return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);
};
var fromUtf8 = (input) => new TextEncoder().encode(input);
var chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
Object.entries(chars).reduce((acc, [i, c]) => {
acc[c] = Number(i);
return acc;
}, {});
var alphabetByValue = chars.split("");
var bitsPerLetter = 6;
var bitsPerByte = 8;
var maxLetterValue = 63;
function toBase64(_input) {
let input;
if (typeof _input === "string") {
input = fromUtf8(_input);
} else {
input = _input;
}
const isArrayLike = typeof input === "object" && typeof input.length === "number";
const isUint8Array = typeof input === "object" && typeof input.byteOffset === "number" && typeof input.byteLength === "number";
if (!isArrayLike && !isUint8Array) {
throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
}
let str = "";
for (let i = 0;i < input.length; i += 3) {
let bits = 0;
let bitLength = 0;
for (let j = i, limit = Math.min(i + 3, input.length);j < limit; j++) {
bits |= input[j] << (limit - j - 1) * bitsPerByte;
bitLength += bitsPerByte;
}
const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
bits <<= bitClusterCount * bitsPerLetter - bitLength;
for (let k = 1;k <= bitClusterCount; k++) {
const offset = (bitClusterCount - k) * bitsPerLetter;
str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
}
str += "==".slice(0, 4 - bitClusterCount);
}
return str;
}
var ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {};
class ChecksumStream extends ReadableStreamRef {
}
var createChecksumStream$1 = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) => {
if (!isReadableStream(source)) {
throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
}
const encoder = base64Encoder ?? toBase64;
if (typeof TransformStream !== "function") {
throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
}
const transform = new TransformStream({
start() {},
async transform(chunk, controller) {
checksum.update(chunk);
controller.enqueue(chunk);
},
async flush(controller) {
const digest = await checksum.digest();
const received = encoder(digest);
if (expectedChecksum !== received) {
const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` + ` in response header "${checksumSourceLocation}".`);
controller.error(error);
} else {
controller.terminate();
}
}
});
source.pipeThrough(transform);
const readable = transform.readable;
Object.setPrototypeOf(readable, ChecksumStream.prototype);
return readable;
};
function createChecksumStream(init) {
if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
return createChecksumStream$1(init);
}
return new ChecksumStream$1(init);
}
class ByteArrayCollector {
allocByteArray;
byteLength = 0;
byteArrays = [];
constructor(allocByteArray) {
this.allocByteArray = allocByteArray;
}
push(byteArray) {
this.byteArrays.push(byteArray);
this.byteLength += byteArray.byteLength;
}
flush() {
if (this.byteArrays.length === 1) {
const bytes = this.byteArrays[0];
this.reset();
return bytes;
}
const aggregation = this.allocByteArray(this.byteLength);
let cursor = 0;
for (let i = 0;i < this.byteArrays.length; ++i) {
const bytes = this.byteArrays[i];
aggregation.set(bytes, cursor);
cursor += bytes.byteLength;
}
this.reset();
return aggregation;
}
reset() {
this.byteArrays = [];
this.byteLength = 0;
}
}
function createBufferedReadableStream(upstream, size, logger) {
const reader = upstream.getReader();
let streamBufferingLoggedWarning = false;
let bytesSeen = 0;
const buffers = ["", new ByteArrayCollector((size) => new Uint8Array(size))];
let mode = -1;
const pull = async (controller) => {
const { value, done } = await reader.read();
const chunk = value;
if (done) {
if (mode !== -1) {
const remainder = flush(buffers, mode);
if (sizeOf(remainder) > 0) {
controller.enqueue(remainder);
}
}
controller.close();
} else {
const chunkMode = modeOf(chunk, false);
if (mode !== chunkMode) {
if (mode >= 0) {
controller.enqueue(flush(buffers, mode));
}
mode = chunkMode;
}
if (mode === -1) {
controller.enqueue(chunk);
return;
}
const chunkSize = sizeOf(chunk);
bytesSeen += chunkSize;
const bufferSize = sizeOf(buffers[mode]);
if (chunkSize >= size && bufferSize === 0) {
controller.enqueue(chunk);
} else {
const newSize = merge(buffers, mode, chunk);
if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
streamBufferingLoggedWarning = true;
logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
}
if (newSize >= size) {
controller.enqueue(flush(buffers, mode));
} else {
await pull(controller);
}
}
}
};
return new ReadableStream({
pull
});
}
function merge(buffers, mode, chunk) {
switch (mode) {
case 0:
buffers[0] += chunk;
return sizeOf(buffers[0]);
case 1:
case 2:
buffers[mode].push(chunk);
return sizeOf(buffers[mode]);
}
}
function flush(buffers, mode) {
switch (mode) {
case 0:
const s = buffers[0];
buffers[0] = "";
return s;
case 1:
case 2:
return buffers[mode].flush();
}
throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
}
function sizeOf(chunk) {
return chunk?.byteLength ?? chunk?.length ?? 0;
}
function modeOf(chunk, allowBuffer = true) {
if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) {
return 2;
}
if (chunk instanceof Uint8Array) {
return 1;
}
if (typeof chunk === "string") {
return 0;
}
return -1;
}
function createBufferedReadable(upstream, size, logger) {
if (isReadableStream(upstream)) {
return createBufferedReadableStream(upstream, size, logger);
}
const downstream = new Readable({ read() {} });
let streamBufferingLoggedWarning = false;
let bytesSeen = 0;
const buffers = [
"",
new ByteArrayCollector((size) => new Uint8Array(size)),
new ByteArrayCollector((size) => Buffer.from(new Uint8Array(size)))
];
let mode = -1;
upstream.on("data", (chunk) => {
const chunkMode = modeOf(chunk, true);
if (mode !== chunkMode) {
if (mode >= 0) {
downstream.push(flush(buffers, mode));
}
mode = chunkMode;
}
if (mode === -1) {
downstream.push(chunk);
return;
}
const chunkSize = sizeOf(chunk);
bytesSeen += chunkSize;
const bufferSize = sizeOf(buffers[mode]);
if (chunkSize >= size && bufferSize === 0) {
downstream.push(chunk);
} else {
const newSize = merge(buffers, mode, chunk);
if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
streamBufferingLoggedWarning = true;
logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
}
if (newSize >= size) {
downstream.push(flush(buffers, mode));
}
}
});
upstream.on("end", () => {
if (mode !== -1) {
const remainder = flush(buffers, mode);
if (sizeOf(remainder) > 0) {
downstream.push(remainder);
}
}
downstream.push(null);
});
return downstream;
}
var getAwsChunkedEncodingStream$1 = (readableStream, options) => {
const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
const checksumRequired = base64Encoder !== undefined && bodyLengthChecker !== undefined && checksumAlgorithmFn !== undefined && checksumLocationName !== undefined && streamHasher !== undefined;
const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined;
const reader = readableStream.getReader();
return new ReadableStream({
async pull(controller) {
const { value, done } = await reader.read();
if (done) {
controller.enqueue(`0\r
`);
if (checksumRequired) {
const checksum = base64Encoder(await digest);
controller.enqueue(`${checksumLocationName}:${checksum}\r
`);
controller.enqueue(`\r
`);
}
controller.close();
} else {
controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r
${value}\r
`);
}
}
});
};
function getAwsChunkedEncodingStream(stream, options) {
const readable = stream;
const readableStream = stream;
if (isReadableStream(readableStream)) {
return getAwsChunkedEncodingStream$1(readableStream, options);
}
const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
const checksumRequired = base64Encoder !== undefined && checksumAlgorithmFn !== undefined && checksumLocationName !== undefined && streamHasher !== undefined;
const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined;
const awsChunkedEncodingStream = new Readable({
read: () => {}
});
readable.on("data", (data) => {
const length = bodyLengthChecker(data) || 0;
if (length === 0) {
return;
}
awsChunkedEncodingStream.push(`${length.toString(16)}\r
`);
awsChunkedEncodingStream.push(data);
awsChunkedEncodingStream.push(`\r
`);
});
readable.on("end", async () => {
awsChunkedEncodingStream.push(`0\r
`);
if (checksumRequired) {
const checksum = base64Encoder(await digest);
awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r
`);
awsChunkedEncodingStream.push(`\r
`);
}
awsChunkedEncodingStream.push(null);
});
return awsChunkedEncodingStream;
}
async function headStream$1(stream, bytes) {
let byteLengthCounter = 0;
const chunks = [];
const reader = stream.getReader();
let isDone = false;
while (!isDone) {
const { done, value } = await reader.read();
if (value) {
chunks.push(value);
byteLengthCounter += value?.byteLength ?? 0;
}
if (byteLengthCounter >= bytes) {
break;
}
isDone = done;
}
reader.releaseLock();
const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));
let offset = 0;
for (const chunk of chunks) {
if (chunk.byteLength > collected.byteLength - offset) {
collected.set(chunk.subarray(0, collected.byteLength - offset), offset);
break;
} else {
collected.set(chunk, offset);
}
offset += chunk.length;
}
return collected;
}
var headStream = (stream, bytes) => {
if (isReadableStream(stream)) {
return headStream$1(stream, bytes);
}
return new Promise((resolve, reject) => {
const collector = new Collector$1;
collector.limit = bytes;
stream.pipe(collector);
stream.on("error", (err) => {
collector.end();
reject(err);
});
collector.on("error", reject);
collector.on("finish", function() {
const bytes = concatBytes(this.buffers);
resolve(bytes);
});
});
};
var Collector$1 = class Collector extends Writable {
buffers = [];
limit = Infinity;
bytesBuffered = 0;
_write(chunk, encoding, callback) {
this.buffers.push(chunk);
this.bytesBuffered += chunk.byteLength ?? 0;
if (this.bytesBuffered >= this.limit) {
const excess = this.bytesBuffered - this.limit;
const tailBuffer = this.buffers[this.buffers.length - 1];
this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
this.emit("finish");
}
callback();
}
};
var toUtf8 = (input) => {
if (typeof input === "string") {
return input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
}
return new TextDecoder("utf-8").decode(input);
};
var streamCollector$1 = async (stream) => {
if (isBlob(stream)) {
return collectBlob(stream);
}
return collectReadableStream(stream);
};
async function collectBlob(blob) {
return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
}
async function collectReadableStream(stream) {
const chunks = [];
const reader = stream.getReader();
let length = 0;
while (true) {
const { done, value } = await reader.read();
if (value) {
chunks.push(value);
length += value.length;
}
if (done) {
break;
}
}
return concatBytes(chunks, length);
}
var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1 = "The stream has already been transformed.";
var sdkStreamMixin$1 = (stream) => {
if (!isBlobInstance(stream) && !isReadableStream(stream)) {
const name = stream?.__proto__?.constructor?.name || stream;
throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
}
let transformed = false;
const transformToByteArray = async () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1);
}
transformed = true;
return await streamCollector$1(stream);
};
const blobToWebStream = (blob) => {
if (typeof blob.stream !== "function") {
throw new Error(`Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.
` + "If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
}
return blob.stream();
};
return Object.assign(stream, {
transformToByteArray,
transformToString: async (encoding) => {
const buf = await transformToByteArray();
if (encoding === "base64") {
return toBase64(buf);
} else if (encoding === "hex") {
return toHex(buf);
} else if (encoding === undefined || encoding === "utf8" || encoding === "utf-8") {
return toUtf8(buf);
} else if (typeof TextDecoder === "function") {
return new TextDecoder(encoding).decode(buf);
} else {
throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
}
},
transformToWebStream: () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1);
}
transformed = true;
if (isBlobInstance(stream)) {
return blobToWebStream(stream);
} else if (isReadableStream(stream)) {
return stream;
} else {
throw new Error(`Cannot transform payload to web stream, got ${stream}`);
}
}
});
};
var isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
var streamCollector = (stream) => {
if (isBlob(stream)) {
return collectBlob(stream);
}
if (isReadableStream(stream)) {
return collectReadableStream(stream);
}
return new Promise((resolve, reject) => {
const collector = new Collector;
const nodeStream = stream;
nodeStream.pipe(collector);
nodeStream.on("error", (err) => {
collector.end();
reject(err);
});
collector.on("error", reject);
collector.on("finish", function() {
const bytes = concatBytes(this.bufferedBytes);
resolve(bytes);
});
});
};
class Collector extends Writable {
bufferedBytes = [];
_write(chunk, encoding, callback) {
this.bufferedBytes.push(chunk);
callback();
}
}
var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
var sdkStreamMixin = (stream) => {
if (!(stream instanceof Readable)) {
try {
return sdkStreamMixin$1(stream);
} catch (ignored) {
const name = stream?.__proto__?.constructor?.name || stream;
throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
}
}
let transformed = false;
const transformToByteArray = async () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
}
transformed = true;
return await streamCollector(stream);
};
return Object.assign(stream, {
transformToByteArray,
transformToString: async (encoding) => {
const buf = await transformToByteArray();
if (encoding === undefined || Buffer.isEncoding(encoding)) {
return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
} else {
const decoder = new TextDecoder(encoding);
return decoder.decode(buf);
}
},
transformToWebStream: () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
}
if (stream.readableFlowing !== null) {
throw new Error("The stream has been consumed by other callbacks.");
}
if (typeof Readable.toWeb !== "function") {
throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
}
transformed = true;
return Readable.toWeb(stream);
}
});
};
async function splitStream$1(stream) {
if (typeof stream.stream === "function") {
stream = stream.stream();
}
const readableStream = stream;
return readableStream.tee();
}
async function splitStream(stream) {
if (isReadableStream(stream) || isBlob(stream)) {
return splitStream$1(stream);
}
const stream1 = new PassThrough;
const stream2 = new PassThrough;
stream.pipe(stream1);
stream.pipe(stream2);
return [stream1, stream2];
}
class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64) {
}
var _getRandomValues = getRandomValues;
var v4 = bindV4(_getRandomValues);
var generateIdempotencyToken = v4;
exports.ChecksumStream = ChecksumStream$1;
exports.Hash = Hash;
exports.LazyJsonString = LazyJsonString;
exports.NumericValue = NumericValue;
exports.Uint8ArrayBlobAdapter = Uint8ArrayBlobAdapter;
exports._parseEpochTimestamp = _parseEpochTimestamp;
exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset;
exports._parseRfc7231DateTime = _parseRfc7231DateTime;
exports.calculateBodyLength = calculateBodyLength;
exports.concatBytes = concatBytes;
exports.copyDocumentWithTransform = copyDocumentWithTransform;
exports.createBufferedReadable = createBufferedReadable;
exports.createChecksumStream = createChecksumStream;
exports.dateToUtcString = dateToUtcString;
exports.deserializerMiddleware = deserializerMiddleware;
exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
exports.expectBoolean = expectBoolean;
exports.expectByte = expectByte;
exports.expectFloat32 = expectFloat32;
exports.expectInt = expectInt;
exports.expectInt32 = expectInt32;
exports.expectLong = expectLong;
exports.expectNonNull = expectNonNull;
exports.expectNumber = expectNumber;
exports.expectObject = expectObject;
exports.expectShort = expectShort;
exports.expectString = expectString;
exports.expectUnion = expectUnion;
exports.fromArrayBuffer = fromArrayBuffer;
exports.fromBase64 = fromBase64;
exports.fromHex = fromHex;
exports.fromString = fromString;
exports.fromUtf8 = fromUtf8$1;
exports.generateIdempotencyToken = generateIdempotencyToken;
exports.getAwsChunkedEncodingStream = getAwsChunkedEncodingStream;
exports.getSerdePlugin = getSerdePlugin;
exports.handleFloat = handleFloat;
exports.headStream = headStream;
exports.isArrayBuffer = isArrayBuffer;
exports.isBlob = isBlob;
exports.isReadableStream = isReadableStream;
exports.limitedParseDouble = limitedParseDouble;
exports.limitedParseFloat = limitedParseFloat;
exports.limitedParseFloat32 = limitedParseFloat32;
exports.logger = logger;
exports.nv = nv;
exports.parseBoolean = parseBoolean;
exports.parseEpochTimestamp = parseEpochTimestamp;
exports.parseRfc3339DateTime = parseRfc3339DateTime;
exports.parseRfc3339DateTimeWithOffset = parseRfc3339DateTimeWithOffset;
exports.parseRfc7231DateTime = parseRfc7231DateTime;
exports.quoteHeader = quoteHeader;
exports.sdkStreamMixin = sdkStreamMixin;
exports.serializerMiddleware = serializerMiddleware;
exports.serializerMiddlewareOption = serializerMiddlewareOption;
exports.splitEvery = splitEvery;
exports.splitHeader = splitHeader;
exports.splitStream = splitStream;
exports.streamCollector = streamCollector;
exports.strictParseByte = strictParseByte;
exports.strictParseDouble = strictParseDouble;
exports.strictParseFloat = strictParseFloat;
exports.strictParseFloat32 = strictParseFloat32;
exports.strictParseInt = strictParseInt;
exports.strictParseInt32 = strictParseInt32;
exports.strictParseLong = strictParseLong;
exports.strictParseShort = strictParseShort;
exports.toBase64 = toBase64$1;
exports.toHex = toHex;
exports.toUint8Array = toUint8Array;
exports.toUtf8 = toUtf8$1;
exports.v4 = v4;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/checksum/index.js
var require_checksum = __commonJS(function(exports) {
var { createReadStream } = __require("fs");
var { Writable } = __require("stream");
var { toUint8Array, concatBytes } = require_serde();
var { createHash, createHmac } = __require("crypto");
var zlib = __require("zlib");
async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
const size = blob.size;
let totalBytesRead = 0;
while (totalBytesRead < size) {
const slice = blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize));
onChunk(new Uint8Array(await slice.arrayBuffer()));
totalBytesRead += slice.size;
}
}
var blobHasher = async function blobHasher(hashCtor, blob) {
const hash = new hashCtor;
await blobReader(blob, (chunk) => {
hash.update(chunk);
});
return hash.digest();
};
class HashCalculator extends Writable {
hash;
constructor(hash, options) {
super(options);
this.hash = hash;
}
_write(chunk, encoding, callback) {
try {
this.hash.update(toUint8Array(chunk));
} catch (err) {
return callback(err);
}
callback();
}
}
var fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject) => {
if (!isReadStream(fileStream)) {
reject(new Error("Unable to calculate hash for non-file streams."));
return;
}
const fileStreamTee = createReadStream(fileStream.path, {
start: fileStream.start,
end: fileStream.end
});
const hash = new hashCtor;
const hashCalculator = new HashCalculator(hash);
fileStreamTee.pipe(hashCalculator);
fileStreamTee.on("error", (err) => {
hashCalculator.end();
reject(err);
});
hashCalculator.on("error", reject);
hashCalculator.on("finish", function() {
hash.digest().then(resolve).catch(reject);
});
});
var isReadStream = (stream) => typeof stream.path === "string";
var readableStreamHasher = (hashCtor, readableStream) => {
if (readableStream.readableFlowing !== null) {
throw new Error("Unable to calculate hash for flowing readable stream");
}
const hash = new hashCtor;
const hashCalculator = new HashCalculator(hash);
readableStream.pipe(hashCalculator);
return new Promise((resolve, reject) => {
readableStream.on("error", (err) => {
hashCalculator.end();
reject(err);
});
hashCalculator.on("error", reject);
hashCalculator.on("finish", () => {
hash.digest().then(resolve).catch(reject);
});
});
};
class Md5Js {
digestLength = 16;
state = Uint32Array.from(INIT$1);
writeBuffer = new DataView(new ArrayBuffer(64));
bufferLength = 0;
bytesHashed = 0;
update(sourceData) {
const data = toUint8Array(sourceData);
let pos = 0;
let len = data.byteLength;
this.bytesHashed += len;
while (len > 0) {
this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
--len;
if (this.bufferLength === 64) {
compress(this.state, this.writeBuffer);
this.bufferLength = 0;
}
}
}
async digest() {
const state = Uint32Array.from(this.state);
const buf = new DataView(this.writeBuffer.buffer.slice(0));
let bufLen = this.bufferLength;
const bits = this.bytesHashed * 8;
buf.setUint8(bufLen++, 128);
if (this.bufferLength % 64 >= 56) {
for (let i = bufLen;i < 64; ++i) {
buf.setUint8(i, 0);
}
compress(state, buf);
bufLen = 0;
}
for (let i = bufLen;i < 56; ++i) {
buf.setUint8(i, 0);
}
buf.setUint32(56, bits >>> 0, true);
buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
compress(state, buf);
const out = new Uint8Array(16);
const view = new DataView(out.buffer);
for (let i = 0;i < 4; ++i) {
view.setUint32(i * 4, state[i], true);
}
return out;
}
reset() {
this.state.set(INIT$1);
this.writeBuffer = new DataView(new ArrayBuffer(64));
this.bufferLength = 0;
this.bytesHashed = 0;
}
}
var INIT$1 = [1732584193, 4023233417, 2562383102, 271733878];
var M = 4294967295;
var S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
var T = Array.from({ length: 64 }, (_, i) => Math.abs(Math.sin(i + 1)) * 2 ** 32 >>> 0);
function compress(state, block) {
let a = state[0], b = state[1], c = state[2], d = state[3];
for (let i = 0;i < 64; ++i) {
let f, g;
if (i < 16) {
f = b & c | ~b & d;
g = i;
} else if (i < 32) {
f = d & b | c & ~d;
g = (5 * i + 1) % 16;
} else if (i < 48) {
f = b ^ c ^ d;
g = (3 * i + 5) % 16;
} else {
f = c ^ (b | ~d);
g = 7 * i % 16;
}
const x = block.getUint32(g * 4, true);
const tmp = d;
d = c;
c = b;
const s = S[(i >> 4) * 4 + (i & 3)];
const sum = (a + f & M) + (x + T[i] & M) & M;
b = b + ((sum << s | sum >>> 32 - s) >>> 0) & M;
a = tmp;
}
state[0] = state[0] + a & M;
state[1] = state[1] + b & M;
state[2] = state[2] + c & M;
state[3] = state[3] + d & M;
}
var hasNativeCrypto$1 = (() => {
try {
createHash("md5");
return true;
} catch {
return false;
}
})();
var Md5Node = hasNativeCrypto$1 ? buildNativeClass$2() : Md5Js;
function buildNativeClass$2() {
return class Md5Node {
digestLength = 16;
hash = createHash("md5");
update(data) {
this.hash.update(toUint8Array(data));
}
async digest() {
const buf = this.hash.copy().digest();
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
}
reset() {
this.hash = createHash("md5");
}
};
}
var CRC32_TABLE = new Uint32Array(256);
for (let i = 0;i < 256; ++i) {
let c = i;
for (let j = 0;j < 8; ++j) {
c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
}
CRC32_TABLE[i] = c >>> 0;
}
var ONES = 4294967295;
class Crc32Js {
digestLength = 4;
checksum = ONES;
update(data) {
for (let i = 0;i < data.length; ++i) {
this.checksum = this.checksum >>> 8 ^ CRC32_TABLE[(this.checksum ^ data[i]) & 255];
}
}
digestSync() {
return (this.checksum ^ ONES) >>> 0;
}
async digest() {
const value = this.digestSync();
const out = new Uint8Array(4);
new DataView(out.buffer).setUint32(0, value, false);
return out;
}
reset() {
this.checksum = ONES;
}
}
var zlibCrc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : undefined;
var Crc32Node = zlibCrc32 ? buildNativeClass$1(zlibCrc32) : Crc32Js;
function buildNativeClass$1(nativeCrc32) {
return class Crc32Node {
digestLength = 4;
value = 0;
update(data) {
this.value = nativeCrc32(data, this.value);
}
digestSync() {
return this.value >>> 0;
}
async digest() {
const out = new Uint8Array(4);
new DataView(out.buffer).setUint32(0, this.digestSync(), false);
return out;
}
reset() {
this.value = 0;
}
};
}
var BLOCK = 64;
var DIGEST_LENGTH = 32;
var MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
class Sha256Js {
digestLength = DIGEST_LENGTH;
state = Int32Array.from(INIT);
w;
buffer = new Uint8Array(64);
bufferLength = 0;
bytesHashed = 0;
finished = false;
inner;
outer;
constructor(secret) {
if (secret) {
const key = Sha256Js.normalizeKey(secret);
this.inner = new Sha256Js;
this.outer = new Sha256Js;
const { inner, outer } = this;
const pad = new Uint8Array(BLOCK * 2);
for (let i = 0;i < BLOCK; ++i) {
pad[i] = 54 ^ key[i];
pad[i + BLOCK] = 92 ^ key[i];
}
inner.update(pad.subarray(0, BLOCK));
outer.update(pad.subarray(BLOCK));
}
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished HMAC.");
}
if (this.inner) {
this.inner.update(data);
return;
}
const chunk = toUint8Array(data);
let position = 0;
let { byteLength } = chunk;
this.bytesHashed += byteLength;
if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
throw new Error("Cannot hash more than 2^53 - 1 bits");
}
while (byteLength > 0) {
this.buffer[this.bufferLength++] = chunk[position++];
byteLength--;
if (this.bufferLength === BLOCK) {
this.hashBuffer();
this.bufferLength = 0;
}
}
}
async digest() {
const { inner, outer } = this;
if (inner && outer) {
if (this.finished) {
throw new Error("Attempted to digest an already finished HMAC.");
}
this.finished = true;
const innerDigest = inner.digestSync();
outer.update(innerDigest);
return outer.digestSync();
}
return this.digestSync();
}
reset() {
this.state = Int32Array.from(INIT);
this.buffer = new Uint8Array(64);
this.bufferLength = 0;
this.bytesHashed = 0;
}
digestSync() {
const state = this.state.slice();
const buffer = this.buffer.slice();
let bufferLength = this.bufferLength;
const bitsHashed = this.bytesHashed * 8;
const bufferView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
bufferView.setUint8(bufferLength++, 128);
if ((bufferLength - 1) % BLOCK >= BLOCK - 8) {
for (let i = bufferLength;i < BLOCK; ++i) {
bufferView.setUint8(i, 0);
}
this.hashBufferWith(state, buffer);
bufferLength = 0;
}
for (let i = bufferLength;i < BLOCK - 8; ++i) {
bufferView.setUint8(i, 0);
}
bufferView.setUint32(BLOCK - 8, Math.floor(bitsHashed / 4294967296), false);
bufferView.setUint32(BLOCK - 4, bitsHashed, false);
this.hashBufferWith(state, buffer);
const out = new Uint8Array(DIGEST_LENGTH);
for (let i = 0;i < 8; ++i) {
out[i * 4] = state[i] >>> 24 & 255;
out[i * 4 + 1] = state[i] >>> 16 & 255;
out[i * 4 + 2] = state[i] >>> 8 & 255;
out[i * 4 + 3] = state[i] >>> 0 & 255;
}
return out;
}
static normalizeKey(secret) {
const key = toUint8Array(secret);
if (key.byteLength > BLOCK) {
const h = new Sha256Js;
h.update(key);
const out = h.digestSync();
const padded = new Uint8Array(BLOCK);
padded.set(out);
return padded;
}
if (key.byteLength < BLOCK) {
const padded = new Uint8Array(BLOCK);
padded.set(key);
return padded;
}
return key;
}
hashBuffer() {
this.hashBufferWith(this.state, this.buffer);
}
hashBufferWith(state, buffer) {
const w = this.w ??= new Int32Array(64);
let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4], s5 = state[5], s6 = state[6], s7 = state[7];
for (let i = 0;i < BLOCK; ++i) {
if (i < 16) {
w[i] = (buffer[i * 4] & 255) << 24 | (buffer[i * 4 + 1] & 255) << 16 | (buffer[i * 4 + 2] & 255) << 8 | buffer[i * 4 + 3] & 255;
} else {
let u = w[i - 2];
const t1 = (u >>> 17 | u << 15) ^ (u >>> 19 | u << 13) ^ u >>> 10;
u = w[i - 15];
const t2 = (u >>> 7 | u << 25) ^ (u >>> 18 | u << 14) ^ u >>> 3;
w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
}
const t1 = (((s4 >>> 6 | s4 << 26) ^ (s4 >>> 11 | s4 << 21) ^ (s4 >>> 25 | s4 << 7)) + (s4 & s5 ^ ~s4 & s6) | 0) + (s7 + (K[i] + w[i] | 0) | 0) | 0;
const t2 = ((s0 >>> 2 | s0 << 30) ^ (s0 >>> 13 | s0 << 19) ^ (s0 >>> 22 | s0 << 10)) + (s0 & s1 ^ s0 & s2 ^ s1 & s2) | 0;
s7 = s6;
s6 = s5;
s5 = s4;
s4 = s3 + t1 | 0;
s3 = s2;
s2 = s1;
s1 = s0;
s0 = t1 + t2 | 0;
}
state[0] += s0;
state[1] += s1;
state[2] += s2;
state[3] += s3;
state[4] += s4;
state[5] += s5;
state[6] += s6;
state[7] += s7;
}
}
var INIT = new Int32Array([
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
]);
var K = new Int32Array([
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
]);
var hasNativeCrypto = (() => {
try {
createHash("sha256");
return true;
} catch {
return false;
}
})();
var Sha256Node = hasNativeCrypto ? buildNativeClass() : Sha256Js;
function buildNativeClass() {
return class Sha256Node {
digestLength = 32;
secret;
hash;
isHmac;
finished = false;
constructor(secret) {
this.secret = secret;
this.isHmac = !!secret;
this.hash = this.createHash();
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished hash.");
}
this.hash.update(data);
}
async digest() {
let buf;
if (this.isHmac) {
this.finished = true;
buf = this.hash.digest();
} else {
buf = this.hash.copy().digest();
}
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
}
reset() {
this.hash = this.createHash();
this.finished = false;
}
createHash() {
return this.secret ? createHmac("sha256", toBuffer(this.secret)) : createHash("sha256");
}
};
}
function toBuffer(data) {
if (typeof data === "string") {
return data;
}
if (ArrayBuffer.isView(data)) {
return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
}
return Buffer.from(data);
}
var { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
var subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function" ? globalThis.crypto.subtle : undefined;
var MAX_PENDING_BYTES = 8 * 1024 * 1024;
class Sha256WebCrypto {
digestLength = 32;
secret;
pending = [];
pendingBytes = 0;
fallback;
finished = false;
constructor(secret) {
if (secret) {
this.secret = toUint8Array(secret);
}
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished HMAC.");
}
if (this.fallback) {
this.fallback.update(data);
return;
}
this.pending.push(data.slice());
this.pendingBytes += data.byteLength;
if (this.pendingBytes >= MAX_PENDING_BYTES) {
this.switchToFallback();
}
}
async digest() {
if (this.fallback) {
return this.fallback.digest();
}
if (this.secret && this.finished) {
throw new Error("Attempted to digest an already finished HMAC.");
}
const data = concatBytes(this.pending);
if (subtle) {
if (this.secret) {
this.finished = true;
const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
const sig = await subtle.sign("HMAC", key, data);
return new Uint8Array(sig);
}
const hash = await subtle.digest("SHA-256", data);
return new Uint8Array(hash);
}
const sha256 = new Sha256Js(this.secret);
sha256.update(data);
return sha256.digest();
}
reset() {
this.pending = [];
this.pendingBytes = 0;
this.fallback = undefined;
this.finished = false;
}
switchToFallback() {
const sha256Js = new Sha256Js(this.secret);
for (const chunk of this.pending) {
sha256Js.update(chunk);
}
this.fallback = sha256Js;
this.pending = [];
this.pendingBytes = 0;
}
}
exports.Crc32 = Crc32Node;
exports.Crc32Js = Crc32Js;
exports.Crc32Node = Crc32Node;
exports.Md5 = Md5Node;
exports.Md5Js = Md5Js;
exports.Md5Node = Md5Node;
exports.Sha256 = Sha256Node;
exports.Sha256Js = Sha256Js;
exports.Sha256Node = Sha256Node;
exports.Sha256WebCrypto = Sha256WebCrypto;
exports.blobHasher = blobHasher;
exports.blobReader = blobReader;
exports.fileStreamHasher = fileStreamHasher;
exports.readableStreamHasher = readableStreamHasher;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/event-streams/index.js
var require_event_streams = __commonJS(function(exports) {
var { Crc32 } = require_checksum();
var { hasOwn } = require_transport();
var { toHex, fromHex, toUtf8, fromUtf8 } = require_serde();
var { Readable } = __require("stream");
var { TypeRegistry } = require_schema();
class Int64 {
bytes;
constructor(bytes) {
this.bytes = bytes;
if (bytes.byteLength !== 8) {
throw new Error("Int64 buffers must be exactly 8 bytes");
}
}
static fromNumber(number) {
if (number > 9223372036854776000 || number < -9223372036854776000) {
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);
}
valueOf() {
const bytes = this.bytes.slice(0);
const negative = bytes[0] & 128;
if (negative) {
negate(bytes);
}
return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
}
toString() {
return String(this.valueOf());
}
}
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;
}
}
class HeaderMarshaller {
toUtf8;
fromUtf8;
constructor(toUtf8, fromUtf8) {
this.toUtf8 = toUtf8;
this.fromUtf8 = fromUtf8;
}
format(headers) {
const chunks = [];
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
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 : 1]);
case "byte":
return Uint8Array.from([2, header.value]);
case "short":
const shortView = new DataView(new ArrayBuffer(3));
shortView.setUint8(0, 3);
shortView.setInt16(1, header.value, false);
return new Uint8Array(shortView.buffer);
case "integer":
const intView = new DataView(new ArrayBuffer(5));
intView.setUint8(0, 4);
intView.setInt32(1, header.value, false);
return new Uint8Array(intView.buffer);
case "long":
const longBytes = new Uint8Array(9);
longBytes[0] = 5;
longBytes.set(header.value.bytes, 1);
return longBytes;
case "binary":
const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
binView.setUint8(0, 6);
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);
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;
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;
uuidBytes.set(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:
out[name] = {
type: BOOLEAN_TAG,
value: true
};
break;
case 1:
out[name] = {
type: BOOLEAN_TAG,
value: false
};
break;
case 2:
out[name] = {
type: BYTE_TAG,
value: headers.getInt8(position++)
};
break;
case 3:
out[name] = {
type: SHORT_TAG,
value: headers.getInt16(position, false)
};
position += 2;
break;
case 4:
out[name] = {
type: INT_TAG,
value: headers.getInt32(position, false)
};
position += 4;
break;
case 5:
out[name] = {
type: LONG_TAG,
value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8))
};
position += 8;
break;
case 6:
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:
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:
out[name] = {
type: TIMESTAMP_TAG,
value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf())
};
position += 8;
break;
case 9:
const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
position += 16;
out[name] = {
type: UUID_TAG,
value: `${toHex(uuidBytes.subarray(0, 4))}-${toHex(uuidBytes.subarray(4, 6))}-${toHex(uuidBytes.subarray(6, 8))}-${toHex(uuidBytes.subarray(8, 10))}-${toHex(uuidBytes.subarray(10))}`
};
break;
default:
throw new Error(`Unrecognized header type tag`);
}
}
return out;
}
}
var HEADER_VALUE_TYPE;
(function(HEADER_VALUE_TYPE) {
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
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}$/;
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 Crc32;
checksummer.update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
if (expectedPreludeChecksum !== checksummer.digestSync()) {
throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digestSync()})`);
}
checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
if (expectedMessageChecksum !== checksummer.digestSync()) {
throw new Error(`The message checksum (${checksummer.digestSync()}) 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))
};
}
class EventStreamCodec {
headerMarshaller;
messageBuffer;
isEndOfStream;
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;
}
};
}
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 Crc32;
view.setUint32(0, length, false);
view.setUint32(4, headers.byteLength, false);
checksum.update(out.subarray(0, 8));
view.setUint32(8, checksum.digestSync(), false);
out.set(headers, 12);
out.set(body, headers.byteLength + 12);
checksum.update(out.subarray(8, length - 4));
view.setUint32(length - 4, checksum.digestSync(), false);
return out;
}
decode(message) {
const { headers, body } = splitMessage(message);
return { headers: this.headerMarshaller.parse(headers), body };
}
formatHeaders(rawHeaders) {
return this.headerMarshaller.format(rawHeaders);
}
}
class MessageDecoderStream {
options;
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;
}
}
}
class MessageEncoderStream {
options;
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);
}
}
}
class SmithyMessageDecoderStream {
options;
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 === undefined)
continue;
yield deserialized;
}
}
}
class SmithyMessageEncoderStream {
options;
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;
}
}
}
function getChunkedStream(source) {
let currentMessageTotalLength = 0;
let currentMessagePendingLength = 0;
let currentMessage = null;
let messageLengthBuffer = null;
const allocateMessage = (size) => {
if (typeof size !== "number") {
throw new Error("Attempted to allocate an event message where size was not a number: " + size);
}
currentMessageTotalLength = size;
currentMessagePendingLength = 4;
currentMessage = new Uint8Array(size);
const currentMessageView = new DataView(currentMessage.buffer);
currentMessageView.setUint32(0, size, false);
};
const iterator = async function* () {
const sourceIterator = source[Symbol.asyncIterator]();
while (true) {
const { value, done } = await sourceIterator.next();
if (done) {
if (!currentMessageTotalLength) {
return;
} else if (currentMessageTotalLength === currentMessagePendingLength) {
yield currentMessage;
} else {
throw new Error("Truncated event message received.");
}
return;
}
const chunkLength = value.length;
let currentOffset = 0;
while (currentOffset < chunkLength) {
if (!currentMessage) {
const bytesRemaining = chunkLength - currentOffset;
if (!messageLengthBuffer) {
messageLengthBuffer = new Uint8Array(4);
}
const numBytesForTotal = Math.min(4 - currentMessagePendingLength, bytesRemaining);
messageLengthBuffer.set(value.slice(currentOffset, currentOffset + numBytesForTotal), currentMessagePendingLength);
currentMessagePendingLength += numBytesForTotal;
currentOffset += numBytesForTotal;
if (currentMessagePendingLength < 4) {
break;
}
allocateMessage(new DataView(messageLengthBuffer.buffer).getUint32(0, false));
messageLengthBuffer = null;
}
const numBytesToWrite = Math.min(currentMessageTotalLength - currentMessagePendingLength, chunkLength - currentOffset);
currentMessage.set(value.slice(currentOffset, currentOffset + numBytesToWrite), currentMessagePendingLength);
currentMessagePendingLength += numBytesToWrite;
currentOffset += numBytesToWrite;
if (currentMessageTotalLength && currentMessageTotalLength === currentMessagePendingLength) {
yield currentMessage;
currentMessage = null;
currentMessageTotalLength = 0;
currentMessagePendingLength = 0;
}
}
}
};
return {
[Symbol.asyncIterator]: iterator
};
}
function getUnmarshalledStream(source, options) {
const messageUnmarshaller = getMessageUnmarshaller(options.deserializer, options.toUtf8);
return {
[Symbol.asyncIterator]: async function* () {
for await (const chunk of source) {
const message = options.eventStreamCodec.decode(chunk);
const type = await messageUnmarshaller(message);
if (type === undefined)
continue;
yield type;
}
}
};
}
function getMessageUnmarshaller(deserializer, toUtf8) {
return async function(message) {
const { value: messageType } = message.headers[":message-type"];
if (messageType === "error") {
const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
unmodeledError.name = message.headers[":error-code"].value;
throw unmodeledError;
} else if (messageType === "exception") {
const code = message.headers[":exception-type"].value;
const exception = { [code]: message };
const deserializedException = await deserializer(exception);
if (deserializedException.$unknown) {
const error = new Error(toUtf8(message.body));
error.name = code;
throw error;
}
throw deserializedException[code];
} else if (messageType === "event") {
const event = {
[message.headers[":event-type"].value]: message
};
const deserialized = await deserializer(event);
if (deserialized.$unknown)
return;
return deserialized;
} else {
throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
}
};
}
var EventStreamMarshaller$1 = class EventStreamMarshaller {
eventStreamCodec;
utfEncoder;
constructor({ utf8Encoder, utf8Decoder }) {
this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
this.utfEncoder = utf8Encoder;
}
deserialize(body, deserializer) {
const inputStream = getChunkedStream(body);
return new SmithyMessageDecoderStream({
messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
});
}
serialize(inputStream, serializer) {
return new MessageEncoderStream({
messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
encoder: this.eventStreamCodec,
includeEndFrame: true
});
}
};
var eventStreamSerdeProvider$1 = (options) => new EventStreamMarshaller$1(options);
class EventStreamMarshaller {
universalMarshaller;
constructor({ utf8Encoder, utf8Decoder }) {
this.universalMarshaller = new EventStreamMarshaller$1({
utf8Decoder,
utf8Encoder
});
}
deserialize(body, deserializer) {
const bodyIterable = typeof body[Symbol.asyncIterator] === "function" ? body : readableToIterable(body);
return this.universalMarshaller.deserialize(bodyIterable, deserializer);
}
serialize(input, serializer) {
return Readable.from(this.universalMarshaller.serialize(input, serializer));
}
}
var eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
async function* readableToIterable(readStream) {
let streamEnded = false;
let generationEnded = false;
const records = new Array;
readStream.on("error", (err) => {
if (!streamEnded) {
streamEnded = true;
}
if (err) {
throw err;
}
});
readStream.on("data", (data) => {
records.push(data);
});
readStream.on("end", () => {
streamEnded = true;
});
while (!generationEnded) {
const value = await new Promise((resolve) => setTimeout(() => resolve(records.shift()), 0));
if (value) {
yield value;
}
generationEnded = streamEnded && records.length === 0;
}
}
var readableStreamToIterable = (readableStream) => ({
[Symbol.asyncIterator]: async function* () {
const reader = readableStream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done)
return;
yield value;
}
} finally {
reader.releaseLock();
}
}
});
var iterableToReadableStream = (asyncIterable) => {
const iterator = asyncIterable[Symbol.asyncIterator]();
return new ReadableStream({
async pull(controller) {
const { done, value } = await iterator.next();
if (done) {
return controller.close();
}
controller.enqueue(value);
}
});
};
var resolveEventStreamSerdeConfig = (input) => Object.assign(input, {
eventStreamMarshaller: input.eventStreamSerdeProvider(input)
});
class EventStreamSerde {
marshaller;
serializer;
deserializer;
serdeContext;
defaultContentType;
compositeErrorRegistry;
constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry }) {
this.marshaller = marshaller;
this.serializer = serializer;
this.deserializer = deserializer;
this.serdeContext = serdeContext;
this.defaultContentType = defaultContentType;
this.compositeErrorRegistry = compositeErrorRegistry;
}
async serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType }) {
const marshaller = this.marshaller;
const eventStreamMember = requestSchema.getEventStreamMember();
const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
const serializer = this.serializer;
const defaultContentType = this.defaultContentType;
const initialRequestMarker = Symbol("initialRequestMarker");
const eventStreamIterable = {
async* [Symbol.asyncIterator]() {
if (initialRequest) {
const headers = {
":event-type": { type: "string", value: initialMessageType ?? "initial-request" },
":message-type": { type: "string", value: "event" },
":content-type": { type: "string", value: defaultContentType }
};
serializer.write(requestSchema, initialRequest);
const body = serializer.flush();
yield {
[initialRequestMarker]: true,
headers,
body
};
}
for await (const page of eventStream) {
yield page;
}
}
};
return marshaller.serialize(eventStreamIterable, (event) => {
if (event[initialRequestMarker]) {
return {
headers: event.headers,
body: event.body
};
}
let unionMember = "";
for (const key in event) {
if (!hasOwn(event, key))
continue;
if (key !== "__type") {
unionMember = key;
break;
}
}
const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
const headers = {
":event-type": { type: "string", value: eventType },
":message-type": { type: "string", value: "event" },
":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
...additionalHeaders
};
return {
headers,
body
};
});
}
async deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType }) {
const marshaller = this.marshaller;
const eventStreamMember = responseSchema.getEventStreamMember();
const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
const memberSchemas = unionSchema.getMemberSchemas();
const initialResponseMarker = Symbol("initialResponseMarker");
const asyncIterable = marshaller.deserialize(response.body, async (event) => {
let unionMember = "";
for (const key in event) {
if (!hasOwn(event, key))
continue;
if (key !== "__type") {
unionMember = key;
break;
}
}
const body = event[unionMember].body;
if (unionMember === (initialMessageType ?? "initial-response")) {
const dataObject = await this.deserializer.read(responseSchema, body);
delete dataObject[eventStreamMember];
return {
[initialResponseMarker]: true,
...dataObject
};
} else if (unionMember in memberSchemas) {
const eventStreamSchema = memberSchemas[unionMember];
if (eventStreamSchema.isStructSchema()) {
const out = {};
let hasBindings = false;
for (const [name, member] of eventStreamSchema.structIterator()) {
const { eventHeader, eventPayload } = member.getMergedTraits();
hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
if (eventPayload) {
if (member.isBlobSchema()) {
out[name] = body;
} else if (member.isStringSchema()) {
out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
} else if (member.isStructSchema()) {
out[name] = await this.deserializer.read(member, body);
}
} else if (eventHeader) {
const value = event[unionMember].headers[name]?.value;
if (value != null) {
if (member.isNumericSchema()) {
if (value && typeof value === "object" && "bytes" in value) {
out[name] = BigInt(value.toString());
} else {
out[name] = Number(value);
}
} else {
out[name] = value;
}
}
}
}
return {
[unionMember]: await this.readEventMember(eventStreamSchema, body, hasBindings, out)
};
}
return {
[unionMember]: await this.deserializer.read(eventStreamSchema, body)
};
} else {
return {
$unknown: event
};
}
});
const asyncIterator = asyncIterable[Symbol.asyncIterator]();
const firstEvent = await asyncIterator.next();
if (firstEvent.done) {
return asyncIterable;
}
if (firstEvent.value?.[initialResponseMarker]) {
if (!responseSchema) {
throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
}
for (const key in firstEvent.value) {
if (!hasOwn(firstEvent.value, key))
continue;
initialResponseContainer[key] = firstEvent.value[key];
}
}
return {
async* [Symbol.asyncIterator]() {
if (!firstEvent?.value?.[initialResponseMarker]) {
yield firstEvent.value;
}
while (true) {
const { done, value } = await asyncIterator.next();
if (done) {
break;
}
yield value;
}
}
};
}
async readEventMember(eventStreamSchema, body, hasBindings, out) {
let ErrCtor;
const staticStructuralSchema = eventStreamSchema.getSchema();
if (Array.isArray(staticStructuralSchema) && staticStructuralSchema[0] === -3) {
const namespace = staticStructuralSchema[1];
const nsRegistry = TypeRegistry.for(namespace);
this.compositeErrorRegistry?.copyFrom(nsRegistry);
ErrCtor = (this.compositeErrorRegistry ?? nsRegistry)?.getErrorCtor(staticStructuralSchema);
}
const dataObject = hasBindings ? out : body.byteLength === 0 ? {} : await this.deserializer.read(eventStreamSchema, body);
if (ErrCtor) {
const message = dataObject.message ?? dataObject.Message ?? "Unknown";
const metadata = {};
const $fault = eventStreamSchema.getMergedTraits().error;
if ($fault) {
metadata.$fault = $fault;
}
return Object.assign(new ErrCtor({}), metadata, {
message
}, dataObject);
}
return dataObject;
}
writeEventBody(unionMember, unionSchema, event) {
const serializer = this.serializer;
let eventType = unionMember;
let explicitPayloadMember = null;
let explicitPayloadContentType;
const isKnownSchema = (() => {
const struct = unionSchema.getSchema();
return struct[4].includes(unionMember);
})();
const additionalHeaders = {};
if (!isKnownSchema) {
const [type, value] = event[unionMember];
eventType = type;
serializer.write(15, value);
} else {
const eventSchema = unionSchema.getMemberSchema(unionMember);
if (eventSchema.isStructSchema()) {
for (const [memberName, memberSchema] of eventSchema.structIterator()) {
const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
if (eventPayload) {
explicitPayloadMember = memberName;
} else if (eventHeader) {
const value = event[unionMember][memberName];
let type = "binary";
if (memberSchema.isNumericSchema()) {
if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
type = "integer";
} else {
type = "long";
}
} else if (memberSchema.isTimestampSchema()) {
type = "timestamp";
} else if (memberSchema.isStringSchema()) {
type = "string";
} else if (memberSchema.isBooleanSchema()) {
type = "boolean";
}
if (value != null) {
additionalHeaders[memberName] = {
type,
value
};
delete event[unionMember][memberName];
}
}
}
if (explicitPayloadMember !== null) {
const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
if (payloadSchema.isBlobSchema()) {
explicitPayloadContentType = "application/octet-stream";
} else if (payloadSchema.isStringSchema()) {
explicitPayloadContentType = "text/plain";
}
serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
} else {
serializer.write(eventSchema, event[unionMember]);
}
} else if (eventSchema.isUnitSchema()) {
serializer.write(eventSchema, {});
} else {
throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
}
}
const messageSerialization = serializer.flush() ?? new Uint8Array;
const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization) : messageSerialization;
return {
body,
eventType,
explicitPayloadContentType,
additionalHeaders
};
}
}
exports.EventStreamCodec = EventStreamCodec;
exports.EventStreamMarshaller = EventStreamMarshaller;
exports.EventStreamSerde = EventStreamSerde;
exports.HeaderMarshaller = HeaderMarshaller;
exports.Int64 = Int64;
exports.MessageDecoderStream = MessageDecoderStream;
exports.MessageEncoderStream = MessageEncoderStream;
exports.SmithyMessageDecoderStream = SmithyMessageDecoderStream;
exports.SmithyMessageEncoderStream = SmithyMessageEncoderStream;
exports.UniversalEventStreamMarshaller = EventStreamMarshaller$1;
exports.eventStreamSerdeProvider = eventStreamSerdeProvider;
exports.getChunkedStream = getChunkedStream;
exports.getMessageUnmarshaller = getMessageUnmarshaller;
exports.getUnmarshalledStream = getUnmarshalledStream;
exports.iterableToReadableStream = iterableToReadableStream;
exports.readableStreamToIterable = readableStreamToIterable;
exports.resolveEventStreamSerdeConfig = resolveEventStreamSerdeConfig;
exports.universalEventStreamSerdeProvider = eventStreamSerdeProvider$1;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js
var require_protocols = __commonJS(function(exports) {
var { Uint8ArrayBlobAdapter, sdkStreamMixin, splitEvery, splitHeader, fromBase64, _parseEpochTimestamp, _parseRfc7231DateTime, _parseRfc3339DateTimeWithOffset, LazyJsonString, NumericValue, toUtf8, fromUtf8, generateIdempotencyToken, toBase64, dateToUtcString, quoteHeader } = require_serde();
var { HttpRequest, HttpResponse, hasOwn, isValidHostname } = require_transport();
var { parseQueryString, parseUrl } = require_transport();
exports.HttpRequest = HttpRequest;
exports.HttpResponse = HttpResponse;
exports.isValidHostname = isValidHostname;
exports.parseQueryString = parseQueryString;
exports.parseUrl = parseUrl;
var { TypeRegistry, NormalizedSchema, translateTraits } = require_schema();
var { FieldPosition } = require_dist_cjs();
var collectBody = async (streamBody = new Uint8Array, context) => {
if (streamBody instanceof Uint8Array) {
return Uint8ArrayBlobAdapter.mutate(streamBody);
}
if (!streamBody) {
return Uint8ArrayBlobAdapter.mutate(new Uint8Array);
}
const fromContext = context.streamCollector(streamBody);
return Uint8ArrayBlobAdapter.mutate(await fromContext);
};
function extendedEncodeURIComponent(str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
});
}
class SerdeContext {
serdeContext;
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
}
}
class HttpProtocol extends SerdeContext {
options;
compositeErrorRegistry;
constructor(options) {
super();
this.options = options;
this.compositeErrorRegistry = TypeRegistry.for(options.defaultNamespace);
for (const etr of options.errorTypeRegistries ?? []) {
this.compositeErrorRegistry.copyFrom(etr);
}
}
getRequestType() {
return HttpRequest;
}
getResponseType() {
return HttpResponse;
}
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
this.serializer.setSerdeContext(serdeContext);
this.deserializer.setSerdeContext(serdeContext);
if (this.getPayloadCodec()) {
this.getPayloadCodec().setSerdeContext(serdeContext);
}
}
updateServiceEndpoint(request, endpoint) {
if ("url" in endpoint) {
request.protocol = endpoint.url.protocol;
request.hostname = endpoint.url.hostname;
request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined;
request.path = endpoint.url.pathname;
request.fragment = endpoint.url.hash || undefined;
request.username = endpoint.url.username || undefined;
request.password = endpoint.url.password || undefined;
if (!request.query) {
request.query = {};
}
for (const [k, v] of endpoint.url.searchParams.entries()) {
request.query[k] = v;
}
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
request.headers[name] = endpoint.headers[name].join(", ");
}
}
return request;
} else {
request.protocol = endpoint.protocol;
request.hostname = endpoint.hostname;
request.port = endpoint.port ? Number(endpoint.port) : undefined;
request.path = endpoint.path;
request.query = {
...endpoint.query
};
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
request.headers[name] = endpoint.headers[name];
}
}
return request;
}
}
setHostPrefix(request, operationSchema, input) {
if (this.serdeContext?.disableHostPrefix) {
return;
}
const inputNs = NormalizedSchema.of(operationSchema.input);
const opTraits = translateTraits(operationSchema.traits ?? {});
if (opTraits.endpoint) {
let hostPrefix = opTraits.endpoint?.[0];
if (typeof hostPrefix === "string") {
for (const [name, member] of inputNs.structIterator()) {
if (!member.getMergedTraits().hostLabel) {
continue;
}
const replacement = input[name];
if (typeof replacement !== "string") {
throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
}
hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
}
request.hostname = hostPrefix + request.hostname;
if (!isValidHostname(request.hostname)) {
throw new Error(`[${request.hostname}] is not a valid hostname.`);
}
}
}
}
deserializeMetadata(output) {
return {
httpStatusCode: output.statusCode,
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
extendedRequestId: output.headers["x-amz-id-2"],
cfId: output.headers["x-amz-cf-id"]
};
}
async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
const eventStreamSerde = await this.loadEventStreamCapability();
return eventStreamSerde.serializeEventStream({
eventStream,
requestSchema,
initialRequest
});
}
async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
const eventStreamSerde = await this.loadEventStreamCapability();
return eventStreamSerde.deserializeEventStream({
response,
responseSchema,
initialResponseContainer
});
}
async loadEventStreamCapability() {
const { EventStreamSerde, eventStreamSerdeProvider } = require_event_streams();
const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
return new EventStreamSerde({
marshaller,
serializer: this.serializer,
deserializer: this.deserializer,
serdeContext: this.serdeContext,
defaultContentType: this.getDefaultContentType(),
compositeErrorRegistry: this.compositeErrorRegistry
});
}
resolveEventStreamMarshaller(importedProvider) {
const context = this.serdeContext;
if (context.eventStreamMarshaller) {
return context.eventStreamMarshaller;
}
return importedProvider(this.serdeContext);
}
getDefaultContentType() {
throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
}
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
return [];
}
getEventStreamMarshaller() {
const context = this.serdeContext;
if (!context.eventStreamMarshaller) {
throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
}
return context.eventStreamMarshaller;
}
}
class HttpBindingProtocol extends HttpProtocol {
async serializeRequest(operationSchema, _input, context) {
const input = _input && typeof _input === "object" ? _input : {};
const serializer = this.serializer;
const query = {};
const headers = {};
const endpoint = await context.endpoint();
const ns = NormalizedSchema.of(operationSchema?.input);
const payloadMemberNames = [];
const payloadMemberSchemas = [];
let hasNonHttpBindingMember = false;
let payload;
const request = new HttpRequest({
protocol: "",
hostname: "",
port: undefined,
path: "",
fragment: undefined,
query,
headers,
body: undefined
});
if (endpoint) {
this.updateServiceEndpoint(request, endpoint);
this.setHostPrefix(request, operationSchema, input);
const opTraits = translateTraits(operationSchema.traits);
if (opTraits.http) {
request.method = opTraits.http[0];
const [path, search] = opTraits.http[1].split("?");
if (request.path == "/") {
request.path = path;
} else {
request.path += path;
}
const traitSearchParams = new URLSearchParams(search ?? "");
for (const [key, value] of traitSearchParams) {
query[key] = value;
}
}
}
for (const [memberName, memberNs] of ns.structIterator()) {
const memberTraits = memberNs.getMergedTraits() ?? {};
const inputMemberValue = input[memberName];
if (inputMemberValue == null && !memberNs.isIdempotencyToken()) {
if (memberTraits.httpLabel) {
if (request.path.includes(`{${memberName}+}`) || request.path.includes(`{${memberName}}`)) {
throw new Error(`No value provided for input HTTP label: ${memberName}.`);
}
}
continue;
}
if (memberTraits.httpPayload) {
const isStreaming = memberNs.isStreaming();
if (isStreaming) {
const isEventStream = memberNs.isStructSchema();
if (isEventStream) {
if (input[memberName]) {
payload = await this.serializeEventStream({
eventStream: input[memberName],
requestSchema: ns
});
}
} else {
payload = inputMemberValue;
}
} else {
serializer.write(memberNs, inputMemberValue);
payload = serializer.flush();
}
} else if (memberTraits.httpLabel) {
serializer.write(memberNs, inputMemberValue);
const replacement = serializer.flush();
if (request.path.includes(`{${memberName}+}`)) {
request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
} else if (request.path.includes(`{${memberName}}`)) {
request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
}
} else if (memberTraits.httpHeader) {
serializer.write(memberNs, inputMemberValue);
headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
} else if (typeof memberTraits.httpPrefixHeaders === "string") {
for (const key in inputMemberValue) {
if (!hasOwn(inputMemberValue, key))
continue;
const val = inputMemberValue[key];
const amalgam = memberTraits.httpPrefixHeaders + key;
serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
headers[amalgam.toLowerCase()] = serializer.flush();
}
} else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
this.serializeQuery(memberNs, inputMemberValue, query);
} else {
hasNonHttpBindingMember = true;
payloadMemberNames.push(memberName);
payloadMemberSchemas.push(memberNs);
}
}
if (hasNonHttpBindingMember && input) {
const [namespace, name] = (ns.getName(true) ?? "#Unknown").split("#");
const requiredMembers = ns.getSchema()[6];
const payloadSchema = [
3,
namespace,
name,
ns.getMergedTraits(),
payloadMemberNames,
payloadMemberSchemas,
undefined
];
if (requiredMembers) {
payloadSchema[6] = requiredMembers;
} else {
payloadSchema.pop();
}
serializer.write(payloadSchema, input);
payload = serializer.flush();
}
request.headers = headers;
request.query = query;
request.body = payload;
return request;
}
serializeQuery(ns, data, query) {
const serializer = this.serializer;
const traits = ns.getMergedTraits();
if (traits.httpQueryParams) {
for (const key in data) {
if (!hasOwn(data, key))
continue;
if (!(key in query)) {
const val = data[key];
const valueSchema = ns.getValueSchema();
Object.assign(valueSchema.getMergedTraits(), {
...traits,
httpQuery: key,
httpQueryParams: undefined
});
this.serializeQuery(valueSchema, val, query);
}
}
return;
}
if (ns.isListSchema()) {
const sparse = !!ns.getMergedTraits().sparse;
const buffer = [];
for (const item of data) {
serializer.write([ns.getValueSchema(), traits], item);
const serializable = serializer.flush();
if (sparse || serializable !== undefined) {
buffer.push(serializable);
}
}
query[traits.httpQuery] = buffer;
} else {
serializer.write([ns, traits], data);
query[traits.httpQuery] = serializer.flush();
}
}
async deserializeResponse(operationSchema, context, response) {
const deserializer = this.deserializer;
const ns = NormalizedSchema.of(operationSchema.output);
const dataObject = {};
if (response.statusCode >= 300) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(15, bytes));
}
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
}
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject);
if (nonHttpBindingMembers.length) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
const dataFromBody = await deserializer.read(ns, bytes);
for (const member of nonHttpBindingMembers) {
if (dataFromBody[member] != null) {
dataObject[member] = dataFromBody[member];
}
}
}
} else if (nonHttpBindingMembers.discardResponseBody) {
await collectBody(response.body, context);
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
let dataObject;
if (arg4 instanceof Set) {
dataObject = arg5;
} else {
dataObject = arg4;
}
let discardResponseBody = true;
const deserializer = this.deserializer;
const ns = NormalizedSchema.of(schema);
const nonHttpBindingMembers = [];
for (const [memberName, memberSchema] of ns.structIterator()) {
const memberTraits = memberSchema.getMemberTraits();
if (memberTraits.httpPayload) {
discardResponseBody = false;
const isStreaming = memberSchema.isStreaming();
if (isStreaming) {
const isEventStream = memberSchema.isStructSchema();
if (isEventStream) {
dataObject[memberName] = await this.deserializeEventStream({
response,
responseSchema: ns
});
} else {
dataObject[memberName] = sdkStreamMixin(response.body);
}
} else if (response.body) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
dataObject[memberName] = await deserializer.read(memberSchema, bytes);
}
}
} else if (memberTraits.httpHeader) {
const key = String(memberTraits.httpHeader).toLowerCase();
const value = response.headers[key];
if (value != null) {
if (memberSchema.isListSchema()) {
const headerListValueSchema = memberSchema.getValueSchema();
headerListValueSchema.getMergedTraits().httpHeader = key;
let sections;
if (headerListValueSchema.isTimestampSchema() && headerListValueSchema.getSchema() === 4) {
sections = splitEvery(value, ",", 2);
} else {
sections = splitHeader(value);
}
const list = [];
for (const section of sections) {
list.push(await deserializer.read(headerListValueSchema, section.trim()));
}
dataObject[memberName] = list;
} else {
dataObject[memberName] = await deserializer.read(memberSchema, value);
}
}
} else if (memberTraits.httpPrefixHeaders !== undefined) {
dataObject[memberName] = {};
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
if (header.startsWith(memberTraits.httpPrefixHeaders)) {
const value = response.headers[header];
const valueSchema = memberSchema.getValueSchema();
valueSchema.getMergedTraits().httpHeader = header;
dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
}
}
} else if (memberTraits.httpResponseCode) {
dataObject[memberName] = response.statusCode;
} else {
nonHttpBindingMembers.push(memberName);
}
}
nonHttpBindingMembers.discardResponseBody = discardResponseBody;
return nonHttpBindingMembers;
}
}
class RpcProtocol extends HttpProtocol {
async serializeRequest(operationSchema, _input, context) {
const serializer = this.serializer;
const query = {};
const headers = {};
const endpoint = await context.endpoint();
const ns = NormalizedSchema.of(operationSchema?.input);
const schema = ns.getSchema();
let payload;
const input = _input && typeof _input === "object" ? _input : {};
const request = new HttpRequest({
protocol: "",
hostname: "",
port: undefined,
path: "/",
fragment: undefined,
query,
headers,
body: undefined
});
if (endpoint) {
this.updateServiceEndpoint(request, endpoint);
this.setHostPrefix(request, operationSchema, input);
}
if (input) {
const eventStreamMember = ns.getEventStreamMember();
if (eventStreamMember) {
if (input[eventStreamMember]) {
const initialRequest = {};
for (const [memberName] of ns.structIterator()) {
if (memberName !== eventStreamMember && input[memberName] != null) {
initialRequest[memberName] = input[memberName];
}
}
payload = await this.serializeEventStream({
eventStream: input[eventStreamMember],
requestSchema: ns,
initialRequest
});
}
} else {
serializer.write(schema, input);
payload = serializer.flush();
}
}
request.headers = Object.assign(request.headers, headers);
request.query = query;
request.body = payload;
request.method = "POST";
return request;
}
async deserializeResponse(operationSchema, context, response) {
const deserializer = this.deserializer;
const ns = NormalizedSchema.of(operationSchema.output);
const dataObject = {};
if (response.statusCode >= 300) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(15, bytes));
}
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
}
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const eventStreamMember = ns.getEventStreamMember();
if (eventStreamMember) {
dataObject[eventStreamMember] = await this.deserializeEventStream({
response,
responseSchema: ns,
initialResponseContainer: dataObject
});
} else {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(ns, bytes));
}
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
}
var resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
if (input != null && input[memberName] !== undefined) {
const labelValue = labelValueProvider();
if (labelValue == null || labelValue.length <= 0) {
throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
}
resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => extendedEncodeURIComponent(segment)).join("/") : extendedEncodeURIComponent(labelValue));
} else {
throw new Error("No value provided for input HTTP label: " + memberName + ".");
}
return resolvedPath;
};
function requestBuilder(input, context) {
return new RequestBuilder(input, context);
}
class RequestBuilder {
input;
context;
query = {};
method = "";
headers = {};
path = "";
body = null;
hostname = "";
resolvePathStack = [];
constructor(input, context) {
this.input = input;
this.context = context;
}
async build() {
const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
this.path = basePath;
for (const resolvePath of this.resolvePathStack) {
resolvePath(this.path);
}
return new HttpRequest({
protocol,
hostname: this.hostname || hostname,
port,
method: this.method,
path: this.path,
query: this.query,
body: this.body,
headers: this.headers
});
}
hn(hostname) {
this.hostname = hostname;
return this;
}
bp(uriLabel) {
this.resolvePathStack.push((basePath) => {
this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
});
return this;
}
p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
this.resolvePathStack.push((path) => {
this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
});
return this;
}
h(headers) {
this.headers = headers;
return this;
}
q(query) {
this.query = query;
return this;
}
b(body) {
this.body = body;
return this;
}
m(method) {
this.method = method;
return this;
}
}
function determineTimestampFormat(ns, settings) {
if (settings.timestampFormat.useTrait) {
if (ns.isTimestampSchema() && (ns.getSchema() === 5 || ns.getSchema() === 6 || ns.getSchema() === 7)) {
return ns.getSchema();
}
}
const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
const bindingFormat = settings.httpBindings ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader) ? 6 : Boolean(httpQuery) || Boolean(httpLabel) ? 5 : undefined : undefined;
return bindingFormat ?? settings.timestampFormat.default;
}
class FromStringShapeDeserializer extends SerdeContext {
settings;
constructor(settings) {
super();
this.settings = settings;
}
read(_schema, data) {
const ns = NormalizedSchema.of(_schema);
if (ns.isListSchema()) {
return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
}
if (ns.isBlobSchema()) {
return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
}
if (ns.isTimestampSchema()) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return _parseRfc3339DateTimeWithOffset(data);
case 6:
return _parseRfc7231DateTime(data);
case 7:
return _parseEpochTimestamp(data);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", data);
return new Date(data);
}
}
if (ns.isStringSchema()) {
const mediaType = ns.getMergedTraits().mediaType;
let intermediateValue = data;
if (mediaType) {
if (ns.getMergedTraits().httpHeader) {
intermediateValue = this.base64ToUtf8(intermediateValue);
}
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
intermediateValue = LazyJsonString.from(intermediateValue);
}
return intermediateValue;
}
}
if (ns.isNumericSchema()) {
return Number(data);
}
if (ns.isBigIntegerSchema()) {
return BigInt(data);
}
if (ns.isBigDecimalSchema()) {
return new NumericValue(data, "bigDecimal");
}
if (ns.isBooleanSchema()) {
return String(data).toLowerCase() === "true";
}
return data;
}
base64ToUtf8(base64String) {
return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
}
}
class HttpInterceptingShapeDeserializer extends SerdeContext {
codecDeserializer;
stringDeserializer;
constructor(codecDeserializer, codecSettings) {
super();
this.codecDeserializer = codecDeserializer;
this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
}
setSerdeContext(serdeContext) {
this.stringDeserializer.setSerdeContext(serdeContext);
this.codecDeserializer.setSerdeContext(serdeContext);
this.serdeContext = serdeContext;
}
read(schema, data) {
const ns = NormalizedSchema.of(schema);
const traits = ns.getMergedTraits();
const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
if (traits.httpHeader || traits.httpResponseCode) {
return this.stringDeserializer.read(ns, toString(data));
}
if (traits.httpPayload) {
if (ns.isBlobSchema()) {
const toBytes = this.serdeContext?.utf8Decoder ?? fromUtf8;
if (typeof data === "string") {
return toBytes(data);
}
return data;
} else if (ns.isStringSchema()) {
if ("byteLength" in data) {
return toString(data);
}
return data;
}
}
return this.codecDeserializer.read(ns, data);
}
}
class ToStringShapeSerializer extends SerdeContext {
settings;
stringBuffer = "";
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
switch (typeof value) {
case "object":
if (value === null) {
this.stringBuffer = "null";
return;
}
if (ns.isTimestampSchema()) {
if (!(value instanceof Date)) {
throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`);
}
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
this.stringBuffer = value.toISOString().replace(".000Z", "Z");
break;
case 6:
this.stringBuffer = dateToUtcString(value);
break;
case 7:
this.stringBuffer = String(value.getTime() / 1000);
break;
default:
console.warn("Missing timestamp format, using epoch seconds", value);
this.stringBuffer = String(value.getTime() / 1000);
}
return;
}
if (ns.isBlobSchema() && "byteLength" in value) {
this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(value);
return;
}
if (ns.isListSchema() && Array.isArray(value)) {
let buffer = "";
for (const item of value) {
this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
const headerItem = this.flush();
const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : quoteHeader(headerItem);
if (buffer !== "") {
buffer += ", ";
}
buffer += serialized;
}
this.stringBuffer = buffer;
return;
}
this.stringBuffer = JSON.stringify(value, null, 2);
break;
case "string":
const mediaType = ns.getMergedTraits().mediaType;
let intermediateValue = value;
if (mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
intermediateValue = LazyJsonString.from(intermediateValue);
}
if (ns.getMergedTraits().httpHeader) {
this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
return;
}
}
this.stringBuffer = value;
break;
default:
if (ns.isIdempotencyToken()) {
this.stringBuffer = generateIdempotencyToken();
} else {
this.stringBuffer = String(value);
}
}
}
flush() {
const buffer = this.stringBuffer;
this.stringBuffer = "";
return buffer;
}
}
class HttpInterceptingShapeSerializer {
codecSerializer;
stringSerializer;
buffer;
constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
this.codecSerializer = codecSerializer;
this.stringSerializer = stringSerializer;
}
setSerdeContext(serdeContext) {
this.codecSerializer.setSerdeContext(serdeContext);
this.stringSerializer.setSerdeContext(serdeContext);
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
const traits = ns.getMergedTraits();
if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
this.stringSerializer.write(ns, value);
this.buffer = this.stringSerializer.flush();
return;
}
return this.codecSerializer.write(ns, value);
}
flush() {
if (this.buffer !== undefined) {
const buffer = this.buffer;
this.buffer = undefined;
return buffer;
}
return this.codecSerializer.flush();
}
}
class Field {
name;
kind;
values;
constructor({ name, kind = FieldPosition.HEADER, values = [] }) {
this.name = name;
this.kind = kind;
this.values = values;
}
add(value) {
this.values.push(value);
}
set(values) {
this.values = values;
}
remove(value) {
this.values = this.values.filter((v) => v !== value);
}
toString() {
return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
}
get() {
return this.values;
}
}
class Fields {
entries = {};
encoding;
constructor({ fields = [], encoding = "utf-8" }) {
fields.forEach(this.setField.bind(this));
this.encoding = encoding;
}
setField(field) {
this.entries[field.name.toLowerCase()] = field;
}
getField(name) {
return this.entries[name.toLowerCase()];
}
removeField(name) {
delete this.entries[name.toLowerCase()];
}
getByType(kind) {
return Object.values(this.entries).filter((field) => field.kind === kind);
}
}
var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
if (runtimeConfig.logger && runtimeConfig.logger.constructor?.name !== "NoOpLogger") {
runtimeConfig.requestHandler?.updateHttpClientConfig?.(Symbol.for("logger"), runtimeConfig.logger);
}
return {
setHttpHandler(handler) {
runtimeConfig.requestHandler = handler;
},
httpHandler() {
return runtimeConfig.requestHandler;
},
updateHttpClientConfig(key, value) {
runtimeConfig.requestHandler?.updateHttpClientConfig(key, value);
},
httpHandlerConfigs() {
return runtimeConfig.requestHandler.httpHandlerConfigs();
}
};
};
var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
return {
requestHandler: httpHandlerExtensionConfiguration.httpHandler()
};
};
var CONTENT_LENGTH_HEADER = "content-length";
function contentLengthMiddleware(bodyLengthChecker) {
return (next) => async (args) => {
const request = args.request;
if (HttpRequest.isInstance(request)) {
const { body, headers } = request;
if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf(CONTENT_LENGTH_HEADER) === -1) {
try {
const length = bodyLengthChecker(body);
if (length != null) {
request.headers = {
...request.headers,
[CONTENT_LENGTH_HEADER]: String(length)
};
}
} catch (ignored) {}
}
}
return next({
...args,
request
});
};
}
var contentLengthMiddlewareOptions = {
step: "build",
tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
name: "contentLengthMiddleware",
override: true
};
var getContentLengthPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
}
});
var escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
var hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
var escapeUriPath = (uri) => uri.split("/").map(escapeUri).join("/");
function buildQueryString(query) {
const parts = [];
for (let key of Object.keys(query).sort()) {
const value = query[key];
key = escapeUri(key);
if (Array.isArray(value)) {
for (let i = 0, iLen = value.length;i < iLen; i++) {
parts.push(`${key}=${escapeUri(value[i])}`);
}
} else {
let qsEntry = key;
if (value || typeof value === "string") {
qsEntry += `=${escapeUri(value)}`;
}
parts.push(qsEntry);
}
}
return parts.join("&");
}
exports.Field = Field;
exports.Fields = Fields;
exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
exports.HttpBindingProtocol = HttpBindingProtocol;
exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
exports.HttpProtocol = HttpProtocol;
exports.RequestBuilder = RequestBuilder;
exports.RpcProtocol = RpcProtocol;
exports.SerdeContext = SerdeContext;
exports.ToStringShapeSerializer = ToStringShapeSerializer;
exports.buildQueryString = buildQueryString;
exports.collectBody = collectBody;
exports.contentLengthMiddleware = contentLengthMiddleware;
exports.contentLengthMiddlewareOptions = contentLengthMiddlewareOptions;
exports.determineTimestampFormat = determineTimestampFormat;
exports.escapeUri = escapeUri;
exports.escapeUriPath = escapeUriPath;
exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
exports.getContentLengthPlugin = getContentLengthPlugin;
exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
exports.requestBuilder = requestBuilder;
exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
exports.resolvedPath = resolvedPath;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/retry/index.js
var require_retry = __commonJS(function(exports) {
var { Readable } = __require("stream");
var { NoOpLogger, normalizeProvider } = require_client();
var { HttpResponse, HttpRequest } = require_protocols();
var { parseRfc7231DateTime, v4 } = require_serde();
var { hasOwn } = require_transport();
var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
var CLOCK_SKEW_ERROR_CODES = [
"AccessDeniedException",
"AuthFailure",
"InvalidSignatureException",
"RequestExpired",
"RequestInTheFuture",
"RequestTimeTooSkewed",
"SignatureDoesNotMatch"
];
var THROTTLING_ERROR_CODES = [
"BandwidthLimitExceeded",
"EC2ThrottledException",
"LimitExceededException",
"PriorRequestNotComplete",
"ProvisionedThroughputExceededException",
"RequestLimitExceeded",
"RequestThrottled",
"RequestThrottledException",
"SlowDown",
"ThrottledException",
"Throttling",
"ThrottlingException",
"TooManyRequestsException",
"TransactionInProgressException"
];
var TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
var TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
var isRetryableByTrait = (error) => error?.$retryable !== undefined;
var isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name);
var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
var isBrowserNetworkError = (error) => {
const errorMessages = new Set([
"Failed to fetch",
"NetworkError when attempting to fetch resource",
"The Internet connection appears to be offline",
"Load failed",
"Network request failed"
]);
const isValid = error && error instanceof TypeError;
if (!isValid) {
return false;
}
return errorMessages.has(error.message);
};
var isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error.name) || error.$retryable?.throttling == true;
var isTransientError = (error, depth = 0) => isRetryableByTrait(error) || isClockSkewCorrectedError(error) || error.name === "InvalidSignatureException" && error.message?.includes("Signature expired") || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || isNodeJsHttp2TransientError(error) || error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1);
var isServerError = (error) => {
if (error.$metadata?.httpStatusCode !== undefined) {
const statusCode = error.$metadata.httpStatusCode;
if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) {
return true;
}
return false;
}
return false;
};
function isNodeJsHttp2TransientError(error) {
return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
}
var DEFAULT_RETRY_DELAY_BASE = 100;
var MAXIMUM_RETRY_DELAY = 20 * 1000;
var THROTTLING_RETRY_DELAY_BASE = 500;
var INITIAL_RETRY_TOKENS = 500;
var RETRY_COST = 5;
var TIMEOUT_RETRY_COST = 10;
var NO_RETRY_INCREMENT = 1;
var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
var REQUEST_HEADER = "amz-sdk-request";
function parseRetryAfterHeader(response, logger) {
if (!HttpResponse.isInstance(response)) {
return;
}
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
const h = header.toLowerCase();
if (h === "retry-after") {
const retryAfter = response.headers[header];
let retryAfterSeconds = NaN;
if (retryAfter.endsWith("GMT")) {
try {
const date = parseRfc7231DateTime(retryAfter);
retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
} catch (e) {
logger?.trace?.("Failed to parse retry-after header");
logger?.trace?.(e);
}
} else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
} else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
retryAfterSeconds = Number(retryAfter);
} else if (Date.parse(retryAfter) >= Date.now()) {
retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1000;
}
if (isNaN(retryAfterSeconds)) {
return;
}
return new Date(Date.now() + retryAfterSeconds * 1000);
} else if (h === "x-amz-retry-after") {
const v = response.headers[header];
const backoffMilliseconds = Number(v);
if (isNaN(backoffMilliseconds)) {
logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
return;
}
return new Date(Date.now() + backoffMilliseconds);
}
}
}
function getRetryAfterHint(response, logger) {
return parseRetryAfterHeader(response, logger);
}
var asSdkError = (error) => {
if (error instanceof Error)
return error;
if (error instanceof Object)
return Object.assign(new Error, error);
if (typeof error === "string")
return new Error(error);
return new Error(`AWS SDK error wrapper for ${error}`);
};
function bindRetryMiddleware(isStreamingPayload) {
return (options) => (next, context) => async (args) => {
let retryStrategy = await options.retryStrategy();
const maxAttempts = await options.maxAttempts();
if (isRetryStrategyV2(retryStrategy)) {
retryStrategy = retryStrategy;
let retryToken = await retryStrategy.acquireInitialRetryToken((context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
let lastError = new Error;
let attempts = 0;
let totalRetryDelay = 0;
const { request } = args;
const isRequest = HttpRequest.isInstance(request);
if (isRequest) {
request.headers[INVOCATION_ID_HEADER] = v4();
}
while (true) {
try {
if (isRequest) {
request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
}
const { response, output } = await next(args);
retryStrategy.recordSuccess(retryToken);
output.$metadata.attempts = attempts + 1;
output.$metadata.totalRetryDelay = totalRetryDelay;
return { response, output };
} catch (e) {
const retryErrorInfo = getRetryErrorInfo(e, options.logger);
lastError = asSdkError(e);
if (isRequest && isStreamingPayload(request)) {
(context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
throw lastError;
}
try {
retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
} catch (ignoredRefreshError) {
if (!lastError.$metadata) {
lastError.$metadata = {};
}
lastError.$metadata.attempts = attempts + 1;
lastError.$metadata.totalRetryDelay = totalRetryDelay;
throw lastError;
}
attempts = retryToken.getRetryCount();
const delay = retryToken.getRetryDelay();
totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
if (delay > 0) {
await cooldown(delay);
}
}
}
} else {
retryStrategy = retryStrategy;
if (retryStrategy?.mode) {
context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
}
return retryStrategy.retry(next, args);
}
};
}
var cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
var getRetryErrorInfo = (error, logger) => {
const errorInfo = {
error,
errorType: getRetryErrorType(error)
};
const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
if (retryAfterHint) {
errorInfo.retryAfterHint = retryAfterHint;
}
return errorInfo;
};
var getRetryErrorType = (error) => {
if (isThrottlingError(error))
return "THROTTLING";
if (isTransientError(error))
return "TRANSIENT";
if (isServerError(error))
return "SERVER_ERROR";
return "CLIENT_ERROR";
};
var retryMiddlewareOptions = {
name: "retryMiddleware",
tags: ["RETRY"],
step: "finalizeRequest",
priority: "high",
override: true
};
function bindGetRetryPlugin(isStreamingPayload) {
const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
return (options) => ({
applyToStack: (clientStack) => {
clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
}
});
}
class DefaultRateLimiter {
static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
beta;
minCapacity;
minFillRate;
scaleConstant;
smooth;
enabled = false;
availableTokens = 0;
lastMaxRate = 0;
measuredTxRate = 0;
requestCount = 0;
fillRate;
lastThrottleTime;
lastTimestamp = 0;
lastTxRateBucket;
maxCapacity;
timeWindow = 0;
constructor(options) {
this.beta = options?.beta ?? 0.7;
this.minCapacity = options?.minCapacity ?? 1;
this.minFillRate = options?.minFillRate ?? 0.5;
this.scaleConstant = options?.scaleConstant ?? 0.4;
this.smooth = options?.smooth ?? 0.8;
this.lastThrottleTime = this.getCurrentTimeInSeconds();
this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
this.fillRate = this.minFillRate;
this.maxCapacity = this.minCapacity;
}
async getSendToken() {
return this.acquireTokenBucket(1);
}
updateClientSendingRate(response) {
let calculatedRate;
this.updateMeasuredRate();
const retryErrorInfo = response;
const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
if (isThrottling) {
const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
this.lastMaxRate = rateToUse;
this.calculateTimeWindow();
this.lastThrottleTime = this.getCurrentTimeInSeconds();
calculatedRate = this.cubicThrottle(rateToUse);
this.enableTokenBucket();
} else {
this.calculateTimeWindow();
calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
}
const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
this.updateTokenBucketRate(newRate);
}
getCurrentTimeInSeconds() {
return Date.now() / 1000;
}
async acquireTokenBucket(amount) {
if (!this.enabled) {
return;
}
this.refillTokenBucket();
while (amount > this.availableTokens) {
const delay = (amount - this.availableTokens) / this.fillRate * 1000;
await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));
this.refillTokenBucket();
}
this.availableTokens = this.availableTokens - amount;
}
refillTokenBucket() {
const timestamp = this.getCurrentTimeInSeconds();
if (!this.lastTimestamp) {
this.lastTimestamp = timestamp;
return;
}
const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
this.lastTimestamp = timestamp;
}
calculateTimeWindow() {
this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
}
cubicThrottle(rateToUse) {
return this.getPrecise(rateToUse * this.beta);
}
cubicSuccess(timestamp) {
return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
}
enableTokenBucket() {
this.enabled = true;
}
updateTokenBucketRate(newRate) {
this.refillTokenBucket();
this.fillRate = Math.max(newRate, this.minFillRate);
this.maxCapacity = Math.max(newRate, this.minCapacity);
this.availableTokens = Math.min(this.availableTokens, this.maxCapacity);
}
updateMeasuredRate() {
const t = this.getCurrentTimeInSeconds();
const timeBucket = Math.floor(t * 2) / 2;
this.requestCount++;
if (timeBucket > this.lastTxRateBucket) {
const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
this.requestCount = 0;
this.lastTxRateBucket = timeBucket;
}
}
getPrecise(num) {
return parseFloat(num.toFixed(8));
}
}
class Retry {
static v2026 = typeof process !== "undefined" && process.env?.SMITHY_NEW_RETRIES_2026 === "true";
static delay() {
return Retry.v2026 ? 50 : 100;
}
static throttlingDelay() {
return Retry.v2026 ? 1000 : 500;
}
static cost() {
return Retry.v2026 ? 14 : 5;
}
static throttlingCost() {
return Retry.v2026 ? 5 : 10;
}
static modifiedCostType() {
return Retry.v2026 ? "THROTTLING" : "TRANSIENT";
}
}
class DefaultRetryBackoffStrategy {
x = Retry.delay();
computeNextBackoffDelay(i) {
const b = Math.random();
const r = 2;
const t_i = b * Math.min(this.x * r ** i, MAXIMUM_RETRY_DELAY);
return Math.floor(t_i);
}
setDelayBase(delay) {
this.x = delay;
}
}
class DefaultRetryToken {
delay;
count;
cost;
longPoll;
$retryLog = {
acquisitionDelay: 0
};
constructor(delay, count, cost, longPoll) {
this.delay = delay;
this.count = count;
this.cost = cost;
this.longPoll = longPoll;
}
getRetryCount() {
return this.count;
}
getRetryDelay() {
return Math.min(MAXIMUM_RETRY_DELAY, this.delay);
}
getRetryCost() {
return this.cost;
}
isLongPoll() {
return this.longPoll;
}
}
var RETRY_MODES;
(function(RETRY_MODES) {
RETRY_MODES["STANDARD"] = "standard";
RETRY_MODES["ADAPTIVE"] = "adaptive";
})(RETRY_MODES || (RETRY_MODES = {}));
var DEFAULT_MAX_ATTEMPTS = 3;
var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
var refusal = {
incompatible: 1,
attempts: 2,
capacity: 3
};
var StandardRetryStrategy$1 = class StandardRetryStrategy {
mode = RETRY_MODES.STANDARD;
retryBackoffStrategy;
capacity = INITIAL_RETRY_TOKENS;
maxAttemptsProvider;
baseDelay;
constructor(arg1) {
if (typeof arg1 === "number") {
this.maxAttemptsProvider = async () => arg1;
} else if (typeof arg1 === "function") {
this.maxAttemptsProvider = arg1;
} else if (arg1 && typeof arg1 === "object") {
this.maxAttemptsProvider = async () => arg1.maxAttempts;
this.baseDelay = arg1.baseDelay;
this.retryBackoffStrategy = arg1.backoff;
}
this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
this.baseDelay ??= Retry.delay();
this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy;
}
async acquireInitialRetryToken(retryTokenScope) {
return new DefaultRetryToken(Retry.delay(), 0, undefined, Retry.v2026 && retryTokenScope.includes(":longpoll"));
}
async refreshRetryTokenForRetry(token, errorInfo) {
const maxAttempts = await this.getMaxAttempts();
const retryCode = this.retryCode(token, errorInfo, maxAttempts);
const shouldRetry = retryCode === 0;
const isLongPoll = token.isLongPoll?.();
if (shouldRetry || isLongPoll) {
const errorType = errorInfo.errorType;
this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
let retryDelay = delayFromErrorType;
if (errorInfo.retryAfterHint instanceof Date) {
retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5000));
}
if (!shouldRetry) {
const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
if (longPollBackoff > 0) {
await new Promise((r) => setTimeout(r, longPollBackoff));
}
} else {
const capacityCost = this.getCapacityCost(errorType);
this.capacity -= capacityCost;
const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
await new Promise((r) => setTimeout(r, retryDelay));
nextToken.$retryLog.acquisitionDelay = retryDelay;
return nextToken;
}
}
throw new Error("No retry token available");
}
recordSuccess(token) {
this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
}
getCapacity() {
return this.capacity;
}
async maxAttempts() {
return this.maxAttemptsProvider();
}
async getMaxAttempts() {
try {
return await this.maxAttemptsProvider();
} catch (ignored) {
console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
return DEFAULT_MAX_ATTEMPTS;
}
}
retryCode(tokenToRenew, errorInfo, maxAttempts) {
const attempts = tokenToRenew.getRetryCount() + 1;
const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
return retryableStatus || attemptStatus || capacityStatus;
}
getCapacityCost(errorType) {
return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
}
isRetryableError(errorType) {
return errorType === "THROTTLING" || errorType === "TRANSIENT";
}
};
var AdaptiveRetryStrategy$1 = class AdaptiveRetryStrategy {
mode = RETRY_MODES.ADAPTIVE;
rateLimiter;
standardRetryStrategy;
constructor(maxAttemptsProvider, options) {
const { rateLimiter } = options ?? {};
this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
this.standardRetryStrategy = options ? new StandardRetryStrategy$1({
maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
...options
}) : new StandardRetryStrategy$1(maxAttemptsProvider);
}
async acquireInitialRetryToken(retryTokenScope) {
const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
await this.rateLimiter.getSendToken();
return token;
}
async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
this.rateLimiter.updateClientSendingRate(errorInfo);
const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
await this.rateLimiter.getSendToken();
return token;
}
recordSuccess(token) {
this.rateLimiter.updateClientSendingRate({});
this.standardRetryStrategy.recordSuccess(token);
}
async maxAttemptsProvider() {
return this.standardRetryStrategy.maxAttempts();
}
};
class ConfiguredRetryStrategy extends StandardRetryStrategy$1 {
computeNextBackoffDelay;
constructor(maxAttempts, computeNextBackoffDelay = Retry.delay()) {
super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
if (typeof computeNextBackoffDelay === "number") {
this.computeNextBackoffDelay = () => computeNextBackoffDelay;
} else {
this.computeNextBackoffDelay = computeNextBackoffDelay;
}
this.retryBackoffStrategy.computeNextBackoffDelay = (completedAttempt) => {
const nextAttempt = completedAttempt + 1;
return this.computeNextBackoffDelay(nextAttempt);
};
}
}
var getDefaultRetryQuota = (initialRetryTokens, options) => {
const MAX_CAPACITY = initialRetryTokens;
const noRetryIncrement = NO_RETRY_INCREMENT;
const retryCost = RETRY_COST;
const timeoutRetryCost = TIMEOUT_RETRY_COST;
let availableCapacity = initialRetryTokens;
const getCapacityAmount = (error) => error.name === "TimeoutError" ? timeoutRetryCost : retryCost;
const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
const retrieveRetryTokens = (error) => {
if (!hasRetryTokens(error)) {
throw new Error("No retry token available");
}
const capacityAmount = getCapacityAmount(error);
availableCapacity -= capacityAmount;
return capacityAmount;
};
const releaseRetryTokens = (capacityReleaseAmount) => {
availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
};
return Object.freeze({
hasRetryTokens,
retrieveRetryTokens,
releaseRetryTokens
});
};
var defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
var defaultRetryDecider = (error) => {
if (!error) {
return false;
}
return isRetryableByTrait(error) || isClockSkewError(error) || isThrottlingError(error) || isTransientError(error);
};
class StandardRetryStrategy {
maxAttemptsProvider;
retryDecider;
delayDecider;
retryQuota;
mode = RETRY_MODES.STANDARD;
constructor(maxAttemptsProvider, options) {
this.maxAttemptsProvider = maxAttemptsProvider;
this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
}
shouldRetry(error, attempts, maxAttempts) {
return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
}
async getMaxAttempts() {
let maxAttempts;
try {
maxAttempts = await this.maxAttemptsProvider();
} catch (ignored) {
maxAttempts = DEFAULT_MAX_ATTEMPTS;
}
return maxAttempts;
}
async retry(next, args, options) {
let retryTokenAmount;
let attempts = 0;
let totalDelay = 0;
const maxAttempts = await this.getMaxAttempts();
const { request } = args;
if (HttpRequest.isInstance(request)) {
request.headers[INVOCATION_ID_HEADER] = v4();
}
while (true) {
try {
if (HttpRequest.isInstance(request)) {
request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
}
if (options?.beforeRequest) {
await options.beforeRequest();
}
const { response, output } = await next(args);
if (options?.afterRequest) {
options.afterRequest(response);
}
this.retryQuota.releaseRetryTokens(retryTokenAmount);
output.$metadata.attempts = attempts + 1;
output.$metadata.totalRetryDelay = totalDelay;
return { response, output };
} catch (e) {
const err = asSdkError(e);
attempts++;
if (this.shouldRetry(err, attempts, maxAttempts)) {
retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
const delayFromDecider = this.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
const delay = Math.max(delayFromResponse || 0, delayFromDecider);
totalDelay += delay;
await new Promise((resolve) => setTimeout(resolve, delay));
continue;
}
if (!err.$metadata) {
err.$metadata = {};
}
err.$metadata.attempts = attempts;
err.$metadata.totalRetryDelay = totalDelay;
throw err;
}
}
}
}
var getDelayFromRetryAfterHeader = (response) => {
if (!HttpResponse.isInstance(response))
return;
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
if (!retryAfterHeaderName)
return;
const retryAfter = response.headers[retryAfterHeaderName];
const retryAfterSeconds = Number(retryAfter);
if (!Number.isNaN(retryAfterSeconds))
return Math.min(retryAfterSeconds * 1000, 20000);
const retryAfterDate = new Date(retryAfter);
return Math.min(retryAfterDate.getTime() - Date.now(), 20000);
};
class AdaptiveRetryStrategy extends StandardRetryStrategy {
rateLimiter;
constructor(maxAttemptsProvider, options) {
const { rateLimiter, ...superOptions } = options ?? {};
super(maxAttemptsProvider, superOptions);
this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
this.mode = RETRY_MODES.ADAPTIVE;
}
async retry(next, args) {
return super.retry(next, args, {
beforeRequest: async () => {
return this.rateLimiter.getSendToken();
},
afterRequest: (response) => {
this.rateLimiter.updateClientSendingRate(response);
}
});
}
}
var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
var CONFIG_MAX_ATTEMPTS = "max_attempts";
var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => {
const value = env[ENV_MAX_ATTEMPTS];
if (!value)
return;
const maxAttempt = parseInt(value);
if (Number.isNaN(maxAttempt)) {
throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
}
return maxAttempt;
},
configFileSelector: (profile) => {
const value = profile[CONFIG_MAX_ATTEMPTS];
if (!value)
return;
const maxAttempt = parseInt(value);
if (Number.isNaN(maxAttempt)) {
throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
}
return maxAttempt;
},
default: DEFAULT_MAX_ATTEMPTS
};
var resolveRetryConfig = (input, defaults) => {
const { retryStrategy, retryMode } = input;
const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
let controller = retryStrategy ? Promise.resolve(retryStrategy) : undefined;
const getDefault = async () => {
const maxAttempts = await maxAttemptsProvider();
const adaptive = await normalizeProvider(retryMode)() === RETRY_MODES.ADAPTIVE;
if (adaptive) {
return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
maxAttempts,
baseDelay: defaultBaseDelay
});
}
return new StandardRetryStrategy$1({
maxAttempts,
baseDelay: defaultBaseDelay
});
};
return Object.assign(input, {
maxAttempts: maxAttemptsProvider,
retryStrategy: () => controller ??= getDefault()
});
};
var ENV_RETRY_MODE = "AWS_RETRY_MODE";
var CONFIG_RETRY_MODE = "retry_mode";
var NODE_RETRY_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
default: DEFAULT_RETRY_MODE
};
var omitRetryHeadersMiddleware = () => (next) => async (args) => {
const { request } = args;
if (HttpRequest.isInstance(request)) {
delete request.headers[INVOCATION_ID_HEADER];
delete request.headers[REQUEST_HEADER];
}
return next(args);
};
var omitRetryHeadersMiddlewareOptions = {
name: "omitRetryHeadersMiddleware",
tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
relation: "before",
toMiddleware: "awsAuthMiddleware",
override: true
};
var getOmitRetryHeadersPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
}
});
var retryMiddleware = bindRetryMiddleware(isStreamingPayload);
var getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);
exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy$1;
exports.CONFIG_MAX_ATTEMPTS = CONFIG_MAX_ATTEMPTS;
exports.CONFIG_RETRY_MODE = CONFIG_RETRY_MODE;
exports.ConfiguredRetryStrategy = ConfiguredRetryStrategy;
exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS;
exports.DEFAULT_RETRY_DELAY_BASE = DEFAULT_RETRY_DELAY_BASE;
exports.DEFAULT_RETRY_MODE = DEFAULT_RETRY_MODE;
exports.DefaultRateLimiter = DefaultRateLimiter;
exports.DeprecatedAdaptiveRetryStrategy = AdaptiveRetryStrategy;
exports.DeprecatedStandardRetryStrategy = StandardRetryStrategy;
exports.ENV_MAX_ATTEMPTS = ENV_MAX_ATTEMPTS;
exports.ENV_RETRY_MODE = ENV_RETRY_MODE;
exports.INITIAL_RETRY_TOKENS = INITIAL_RETRY_TOKENS;
exports.INVOCATION_ID_HEADER = INVOCATION_ID_HEADER;
exports.MAXIMUM_RETRY_DELAY = MAXIMUM_RETRY_DELAY;
exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = NODE_MAX_ATTEMPT_CONFIG_OPTIONS;
exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
exports.REQUEST_HEADER = REQUEST_HEADER;
exports.RETRY_COST = RETRY_COST;
exports.RETRY_MODES = RETRY_MODES;
exports.Retry = Retry;
exports.StandardRetryStrategy = StandardRetryStrategy$1;
exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;
exports.TIMEOUT_RETRY_COST = TIMEOUT_RETRY_COST;
exports.defaultDelayDecider = defaultDelayDecider;
exports.defaultRetryDecider = defaultRetryDecider;
exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin;
exports.getRetryAfterHint = getRetryAfterHint;
exports.getRetryPlugin = getRetryPlugin;
exports.isBrowserNetworkError = isBrowserNetworkError;
exports.isClockSkewCorrectedError = isClockSkewCorrectedError;
exports.isClockSkewError = isClockSkewError;
exports.isNodeJsHttp2TransientError = isNodeJsHttp2TransientError;
exports.isRetryableByTrait = isRetryableByTrait;
exports.isServerError = isServerError;
exports.isThrottlingError = isThrottlingError;
exports.isTransientError = isTransientError;
exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware;
exports.omitRetryHeadersMiddlewareOptions = omitRetryHeadersMiddlewareOptions;
exports.resolveRetryConfig = resolveRetryConfig;
exports.retryMiddleware = retryMiddleware;
exports.retryMiddlewareOptions = retryMiddlewareOptions;
});
// ../../node_modules/.bun/@aws+lambda-invoke-store@0.3.0/node_modules/@aws/lambda-invoke-store/dist-cjs/invoke-store.js
var require_invoke_store = __commonJS(function(exports) {
var PROTECTED_KEYS = {
REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID"),
TRACEPARENT: Symbol.for("_AWS_LAMBDA_TRACEPARENT"),
TRACESTATE: Symbol.for("_AWS_LAMBDA_TRACESTATE"),
BAGGAGE: Symbol.for("_AWS_LAMBDA_BAGGAGE")
};
var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
if (!NO_GLOBAL_AWS_LAMBDA) {
globalThis.awslambda = globalThis.awslambda || {};
}
class InvokeStoreBase {
static PROTECTED_KEYS = PROTECTED_KEYS;
isProtectedKey(key) {
return Object.values(PROTECTED_KEYS).includes(key);
}
getRequestId() {
return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
}
getXRayTraceId() {
return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
}
getTenantId() {
return this.get(PROTECTED_KEYS.TENANT_ID);
}
getTraceparent() {
return this.get(PROTECTED_KEYS.TRACEPARENT);
}
getTracestate() {
return this.get(PROTECTED_KEYS.TRACESTATE);
}
getBaggage() {
return this.get(PROTECTED_KEYS.BAGGAGE);
}
}
class InvokeStoreSingle extends InvokeStoreBase {
currentContext;
getContext() {
return this.currentContext;
}
hasContext() {
return this.currentContext !== undefined;
}
get(key) {
return this.currentContext?.[key];
}
set(key, value) {
if (this.isProtectedKey(key)) {
throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
}
this.currentContext = this.currentContext || {};
this.currentContext[key] = value;
}
run(context, fn) {
this.currentContext = context;
return fn();
}
}
class InvokeStoreMulti extends InvokeStoreBase {
als;
static async create() {
const instance = new InvokeStoreMulti;
const asyncHooks = await import("async_hooks");
instance.als = new asyncHooks.AsyncLocalStorage;
return instance;
}
getContext() {
return this.als.getStore();
}
hasContext() {
return this.als.getStore() !== undefined;
}
get(key) {
return this.als.getStore()?.[key];
}
set(key, value) {
if (this.isProtectedKey(key)) {
throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
}
const store = this.als.getStore();
if (!store) {
throw new Error("No context available");
}
store[key] = value;
}
run(context, fn) {
return this.als.run(context, fn);
}
}
exports.InvokeStore = undefined;
(function(InvokeStore) {
let instance = null;
async function getInstanceAsync(forceInvokeStoreMulti) {
if (!instance) {
instance = (async () => {
const isMulti = forceInvokeStoreMulti === true || "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle;
if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
return globalThis.awslambda.InvokeStore;
} else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
globalThis.awslambda.InvokeStore = newInstance;
return newInstance;
} else {
return newInstance;
}
})();
}
return instance;
}
InvokeStore.getInstanceAsync = getInstanceAsync;
InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
reset: () => {
instance = null;
if (globalThis.awslambda?.InvokeStore) {
delete globalThis.awslambda.InvokeStore;
}
globalThis.awslambda = { InvokeStore: undefined };
}
} : undefined;
})(exports.InvokeStore || (exports.InvokeStore = {}));
exports.InvokeStoreBase = InvokeStoreBase;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/index.js
var require_dist_cjs2 = __commonJS(function(exports) {
var { getSmithyContext, hasOwn } = require_transport();
exports.getSmithyContext = getSmithyContext;
var { HttpRequest } = require_protocols();
var { requestBuilder } = require_protocols();
exports.requestBuilder = requestBuilder;
var { HttpApiKeyAuthLocation } = require_dist_cjs();
var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
if (!authSchemePreference || authSchemePreference.length === 0) {
return candidateAuthOptions;
}
const preferredAuthOptions = [];
for (const preferredSchemeName of authSchemePreference) {
for (const candidateAuthOption of candidateAuthOptions) {
const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
if (candidateAuthSchemeName === preferredSchemeName) {
preferredAuthOptions.push(candidateAuthOption);
}
}
}
for (const candidateAuthOption of candidateAuthOptions) {
if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
preferredAuthOptions.push(candidateAuthOption);
}
}
return preferredAuthOptions;
};
function convertHttpAuthSchemesToMap(httpAuthSchemes) {
const map = new Map;
for (const scheme of httpAuthSchemes) {
map.set(scheme.schemeId, scheme);
}
return map;
}
var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
const smithyContext = getSmithyContext(context);
const failureReasons = [];
for (const option of resolvedOptions) {
const scheme = authSchemes.get(option.schemeId);
if (!scheme) {
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
continue;
}
const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
if (!identityProvider) {
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
continue;
}
const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
smithyContext.selectedHttpAuthScheme = {
httpAuthOption: option,
identity: await identityProvider(option.identityProperties),
signer: scheme.signer
};
break;
}
if (!smithyContext.selectedHttpAuthScheme) {
throw new Error(failureReasons.join(`
`));
}
return next(args);
};
var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
step: "serialize",
tags: ["HTTP_AUTH_SCHEME"],
name: "httpAuthSchemeMiddleware",
override: true,
relation: "before",
toMiddleware: "endpointV2Middleware"
};
var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
httpAuthSchemeParametersProvider,
identityProviderConfigProvider
}), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
}
});
var httpAuthSchemeMiddlewareOptions = {
step: "serialize",
tags: ["HTTP_AUTH_SCHEME"],
name: "httpAuthSchemeMiddleware",
override: true,
relation: "before",
toMiddleware: "serializerMiddleware"
};
var getHttpAuthSchemePlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
httpAuthSchemeParametersProvider,
identityProviderConfigProvider
}), httpAuthSchemeMiddlewareOptions);
}
});
var defaultErrorHandler = (signingProperties) => (error) => {
throw error;
};
var defaultSuccessHandler = (httpResponse, signingProperties) => {};
var httpSigningMiddleware = (config) => (next, context) => async (args) => {
if (!HttpRequest.isInstance(args.request)) {
return next(args);
}
const smithyContext = getSmithyContext(context);
const scheme = smithyContext.selectedHttpAuthScheme;
if (!scheme) {
throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
}
const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
const output = await next({
...args,
request: await signer.sign(args.request, identity, signingProperties)
}).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
(signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
return output;
};
var httpSigningMiddlewareOptions = {
step: "finalizeRequest",
tags: ["HTTP_SIGNING"],
name: "httpSigningMiddleware",
aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
override: true,
relation: "after",
toMiddleware: "retryMiddleware"
};
var getHttpSigningPlugin = (config) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpSigningMiddleware(), httpSigningMiddlewareOptions);
}
});
var normalizeProvider = (input) => {
if (typeof input === "function")
return input;
const promisified = Promise.resolve(input);
return () => promisified;
};
var makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => {
let command = new CommandCtor(input);
command = withCommand(command) ?? command;
return await client.send(command, ...args);
};
function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
return async function* paginateOperation(config, input, ...additionalArguments) {
const _input = input;
let token = config.startingToken ?? _input[inputTokenName];
let hasNext = true;
let page;
while (hasNext) {
_input[inputTokenName] = token;
if (pageSizeTokenName) {
_input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
}
if (config.client instanceof ClientCtor) {
page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
} else {
throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
}
yield page;
const prevToken = token;
token = get(page, outputTokenName);
hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
}
return;
};
}
var get = (fromObject, path) => {
let cursor = fromObject;
const pathComponents = path.split(".");
for (const step of pathComponents) {
if (!cursor || typeof cursor !== "object") {
return;
}
cursor = cursor[step];
}
return cursor;
};
function setFeature(context, feature, value) {
if (!context.__smithy_context) {
context.__smithy_context = {
features: {}
};
} else if (!context.__smithy_context.features) {
context.__smithy_context.features = {};
}
context.__smithy_context.features[feature] = value;
}
class DefaultIdentityProviderConfig {
authSchemes = new Map;
constructor(config) {
for (const key in config) {
if (!hasOwn(config, key))
continue;
const value = config[key];
if (value !== undefined) {
this.authSchemes.set(key, value);
}
}
}
getIdentityProvider(schemeId) {
return this.authSchemes.get(schemeId);
}
}
class HttpApiKeyAuthSigner {
async sign(httpRequest, identity, signingProperties) {
if (!signingProperties) {
throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
}
if (!signingProperties.name) {
throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing");
}
if (!signingProperties.in) {
throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing");
}
if (!identity.apiKey) {
throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
}
const clonedRequest = HttpRequest.clone(httpRequest);
if (signingProperties.in === HttpApiKeyAuthLocation.QUERY) {
clonedRequest.query[signingProperties.name] = identity.apiKey;
} else if (signingProperties.in === HttpApiKeyAuthLocation.HEADER) {
clonedRequest.headers[signingProperties.name] = signingProperties.scheme ? `${signingProperties.scheme} ${identity.apiKey}` : identity.apiKey;
} else {
throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " + "but found: `" + signingProperties.in + "`");
}
return clonedRequest;
}
}
class HttpBearerAuthSigner {
async sign(httpRequest, identity, signingProperties) {
const clonedRequest = HttpRequest.clone(httpRequest);
if (!identity.token) {
throw new Error("request could not be signed with `token` since the `token` is not defined");
}
clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`;
return clonedRequest;
}
}
class NoAuthSigner {
async sign(httpRequest, identity, signingProperties) {
return httpRequest;
}
}
var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired(identity) {
return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
};
var EXPIRATION_MS = 300000;
var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
var doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined;
var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
if (provider === undefined) {
return;
}
const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
let resolved;
let pending;
let hasResult;
let isConstant = false;
const coalesceProvider = async (options) => {
if (!pending) {
pending = normalizedProvider(options);
}
try {
resolved = await pending;
hasResult = true;
isConstant = false;
} finally {
pending = undefined;
}
return resolved;
};
if (isExpired === undefined) {
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider(options);
}
return resolved;
};
}
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider(options);
}
if (isConstant) {
return resolved;
}
if (!requiresRefresh(resolved)) {
isConstant = true;
return resolved;
}
if (isExpired(resolved)) {
await coalesceProvider(options);
return resolved;
}
return resolved;
};
};
exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig;
exports.EXPIRATION_MS = EXPIRATION_MS;
exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner;
exports.HttpBearerAuthSigner = HttpBearerAuthSigner;
exports.NoAuthSigner = NoAuthSigner;
exports.createIsIdentityExpiredFunction = createIsIdentityExpiredFunction;
exports.createPaginator = createPaginator;
exports.doesIdentityRequireRefresh = doesIdentityRequireRefresh;
exports.getHttpAuthSchemeEndpointRuleSetPlugin = getHttpAuthSchemeEndpointRuleSetPlugin;
exports.getHttpAuthSchemePlugin = getHttpAuthSchemePlugin;
exports.getHttpSigningPlugin = getHttpSigningPlugin;
exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = httpAuthSchemeEndpointRuleSetMiddlewareOptions;
exports.httpAuthSchemeMiddleware = httpAuthSchemeMiddleware;
exports.httpAuthSchemeMiddlewareOptions = httpAuthSchemeMiddlewareOptions;
exports.httpSigningMiddleware = httpSigningMiddleware;
exports.httpSigningMiddlewareOptions = httpSigningMiddlewareOptions;
exports.isIdentityExpired = isIdentityExpired;
exports.memoizeIdentityProvider = memoizeIdentityProvider;
exports.normalizeProvider = normalizeProvider;
exports.setFeature = setFeature;
});
// ../../node_modules/.bun/bowser@2.14.1/node_modules/bowser/es5.js
var require_es5 = __commonJS(function(exports, module) {
(function(e, t) {
typeof exports == "object" && typeof module == "object" ? module.exports = t() : typeof define == "function" && define.amd ? define([], t) : typeof exports == "object" ? exports.bowser = t() : e.bowser = t();
})(exports, function() {
return function(e) {
var t = {};
function r(i) {
if (t[i])
return t[i].exports;
var n = t[i] = { i, l: false, exports: {} };
return e[i].call(n.exports, n, n.exports, r), n.l = true, n.exports;
}
return r.m = e, r.c = t, r.d = function(e, t, i) {
r.o(e, t) || Object.defineProperty(e, t, { enumerable: true, get: i });
}, r.r = function(e) {
typeof Symbol != "undefined" && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e, "__esModule", { value: true });
}, r.t = function(e, t) {
if (1 & t && (e = r(e)), 8 & t)
return e;
if (4 & t && typeof e == "object" && e && e.__esModule)
return e;
var i = Object.create(null);
if (r.r(i), Object.defineProperty(i, "default", { enumerable: true, value: e }), 2 & t && typeof e != "string")
for (var n in e)
r.d(i, n, function(t) {
return e[t];
}.bind(null, n));
return i;
}, r.n = function(e) {
var t = e && e.__esModule ? function() {
return e.default;
} : function() {
return e;
};
return r.d(t, "a", t), t;
}, r.o = function(e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}, r.p = "", r(r.s = 90);
}({ 17: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i = r(18), n = function() {
function e() {}
return e.getFirstMatch = function(e, t) {
var r = t.match(e);
return r && r.length > 0 && r[1] || "";
}, e.getSecondMatch = function(e, t) {
var r = t.match(e);
return r && r.length > 1 && r[2] || "";
}, e.matchAndReturnConst = function(e, t, r) {
if (e.test(t))
return r;
}, e.getWindowsVersionName = function(e) {
switch (e) {
case "NT":
return "NT";
case "XP":
return "XP";
case "NT 5.0":
return "2000";
case "NT 5.1":
return "XP";
case "NT 5.2":
return "2003";
case "NT 6.0":
return "Vista";
case "NT 6.1":
return "7";
case "NT 6.2":
return "8";
case "NT 6.3":
return "8.1";
case "NT 10.0":
return "10";
default:
return;
}
}, e.getMacOSVersionName = function(e) {
var t = e.split(".").splice(0, 2).map(function(e) {
return parseInt(e, 10) || 0;
});
t.push(0);
var r = t[0], i = t[1];
if (r === 10)
switch (i) {
case 5:
return "Leopard";
case 6:
return "Snow Leopard";
case 7:
return "Lion";
case 8:
return "Mountain Lion";
case 9:
return "Mavericks";
case 10:
return "Yosemite";
case 11:
return "El Capitan";
case 12:
return "Sierra";
case 13:
return "High Sierra";
case 14:
return "Mojave";
case 15:
return "Catalina";
default:
return;
}
switch (r) {
case 11:
return "Big Sur";
case 12:
return "Monterey";
case 13:
return "Ventura";
case 14:
return "Sonoma";
case 15:
return "Sequoia";
default:
return;
}
}, e.getAndroidVersionName = function(e) {
var t = e.split(".").splice(0, 2).map(function(e) {
return parseInt(e, 10) || 0;
});
if (t.push(0), !(t[0] === 1 && t[1] < 5))
return t[0] === 1 && t[1] < 6 ? "Cupcake" : t[0] === 1 && t[1] >= 6 ? "Donut" : t[0] === 2 && t[1] < 2 ? "Eclair" : t[0] === 2 && t[1] === 2 ? "Froyo" : t[0] === 2 && t[1] > 2 ? "Gingerbread" : t[0] === 3 ? "Honeycomb" : t[0] === 4 && t[1] < 1 ? "Ice Cream Sandwich" : t[0] === 4 && t[1] < 4 ? "Jelly Bean" : t[0] === 4 && t[1] >= 4 ? "KitKat" : t[0] === 5 ? "Lollipop" : t[0] === 6 ? "Marshmallow" : t[0] === 7 ? "Nougat" : t[0] === 8 ? "Oreo" : t[0] === 9 ? "Pie" : undefined;
}, e.getVersionPrecision = function(e) {
return e.split(".").length;
}, e.compareVersions = function(t, r, i) {
i === undefined && (i = false);
var n = e.getVersionPrecision(t), a = e.getVersionPrecision(r), o = Math.max(n, a), s = 0, u = e.map([t, r], function(t) {
var r = o - e.getVersionPrecision(t), i = t + new Array(r + 1).join(".0");
return e.map(i.split("."), function(e) {
return new Array(20 - e.length).join("0") + e;
}).reverse();
});
for (i && (s = o - Math.min(n, a)), o -= 1;o >= s; ) {
if (u[0][o] > u[1][o])
return 1;
if (u[0][o] === u[1][o]) {
if (o === s)
return 0;
o -= 1;
} else if (u[0][o] < u[1][o])
return -1;
}
}, e.map = function(e, t) {
var r, i = [];
if (Array.prototype.map)
return Array.prototype.map.call(e, t);
for (r = 0;r < e.length; r += 1)
i.push(t(e[r]));
return i;
}, e.find = function(e, t) {
var r, i;
if (Array.prototype.find)
return Array.prototype.find.call(e, t);
for (r = 0, i = e.length;r < i; r += 1) {
var n = e[r];
if (t(n, r))
return n;
}
}, e.assign = function(e) {
for (var t, r, i = e, n = arguments.length, a = new Array(n > 1 ? n - 1 : 0), o = 1;o < n; o++)
a[o - 1] = arguments[o];
if (Object.assign)
return Object.assign.apply(Object, [e].concat(a));
var s = function() {
var e = a[t];
typeof e == "object" && e !== null && Object.keys(e).forEach(function(t) {
i[t] = e[t];
});
};
for (t = 0, r = a.length;t < r; t += 1)
s();
return e;
}, e.getBrowserAlias = function(e) {
return i.BROWSER_ALIASES_MAP[e];
}, e.getBrowserTypeByAlias = function(e) {
return i.BROWSER_MAP[e] || "";
}, e;
}();
t.default = n, e.exports = t.default;
}, 18: function(e, t, r) {
t.__esModule = true, t.ENGINE_MAP = t.OS_MAP = t.PLATFORMS_MAP = t.BROWSER_MAP = t.BROWSER_ALIASES_MAP = undefined;
t.BROWSER_ALIASES_MAP = { AmazonBot: "amazonbot", "Amazon Silk": "amazon_silk", "Android Browser": "android", BaiduSpider: "baiduspider", Bada: "bada", BingCrawler: "bingcrawler", Brave: "brave", BlackBerry: "blackberry", "ChatGPT-User": "chatgpt_user", Chrome: "chrome", ClaudeBot: "claudebot", Chromium: "chromium", Diffbot: "diffbot", DuckDuckBot: "duckduckbot", DuckDuckGo: "duckduckgo", Electron: "electron", Epiphany: "epiphany", FacebookExternalHit: "facebookexternalhit", Firefox: "firefox", Focus: "focus", Generic: "generic", "Google Search": "google_search", Googlebot: "googlebot", GPTBot: "gptbot", "Internet Explorer": "ie", InternetArchiveCrawler: "internetarchivecrawler", "K-Meleon": "k_meleon", LibreWolf: "librewolf", Linespider: "linespider", Maxthon: "maxthon", "Meta-ExternalAds": "meta_externalads", "Meta-ExternalAgent": "meta_externalagent", "Meta-ExternalFetcher": "meta_externalfetcher", "Meta-WebIndexer": "meta_webindexer", "Microsoft Edge": "edge", "MZ Browser": "mz", "NAVER Whale Browser": "naver", "OAI-SearchBot": "oai_searchbot", Omgilibot: "omgilibot", Opera: "opera", "Opera Coast": "opera_coast", "Pale Moon": "pale_moon", PerplexityBot: "perplexitybot", "Perplexity-User": "perplexity_user", PhantomJS: "phantomjs", PingdomBot: "pingdombot", Puffin: "puffin", QQ: "qq", QQLite: "qqlite", QupZilla: "qupzilla", Roku: "roku", Safari: "safari", Sailfish: "sailfish", "Samsung Internet for Android": "samsung_internet", SlackBot: "slackbot", SeaMonkey: "seamonkey", Sleipnir: "sleipnir", "Sogou Browser": "sogou", Swing: "swing", Tizen: "tizen", "UC Browser": "uc", Vivaldi: "vivaldi", "WebOS Browser": "webos", WeChat: "wechat", YahooSlurp: "yahooslurp", "Yandex Browser": "yandex", YandexBot: "yandexbot", YouBot: "youbot" };
t.BROWSER_MAP = { amazonbot: "AmazonBot", amazon_silk: "Amazon Silk", android: "Android Browser", baiduspider: "BaiduSpider", bada: "Bada", bingcrawler: "BingCrawler", blackberry: "BlackBerry", brave: "Brave", chatgpt_user: "ChatGPT-User", chrome: "Chrome", claudebot: "ClaudeBot", chromium: "Chromium", diffbot: "Diffbot", duckduckbot: "DuckDuckBot", duckduckgo: "DuckDuckGo", edge: "Microsoft Edge", electron: "Electron", epiphany: "Epiphany", facebookexternalhit: "FacebookExternalHit", firefox: "Firefox", focus: "Focus", generic: "Generic", google_search: "Google Search", googlebot: "Googlebot", gptbot: "GPTBot", ie: "Internet Explorer", internetarchivecrawler: "InternetArchiveCrawler", k_meleon: "K-Meleon", librewolf: "LibreWolf", linespider: "Linespider", maxthon: "Maxthon", meta_externalads: "Meta-ExternalAds", meta_externalagent: "Meta-ExternalAgent", meta_externalfetcher: "Meta-ExternalFetcher", meta_webindexer: "Meta-WebIndexer", mz: "MZ Browser", naver: "NAVER Whale Browser", oai_searchbot: "OAI-SearchBot", omgilibot: "Omgilibot", opera: "Opera", opera_coast: "Opera Coast", pale_moon: "Pale Moon", perplexitybot: "PerplexityBot", perplexity_user: "Perplexity-User", phantomjs: "PhantomJS", pingdombot: "PingdomBot", puffin: "Puffin", qq: "QQ Browser", qqlite: "QQ Browser Lite", qupzilla: "QupZilla", roku: "Roku", safari: "Safari", sailfish: "Sailfish", samsung_internet: "Samsung Internet for Android", seamonkey: "SeaMonkey", slackbot: "SlackBot", sleipnir: "Sleipnir", sogou: "Sogou Browser", swing: "Swing", tizen: "Tizen", uc: "UC Browser", vivaldi: "Vivaldi", webos: "WebOS Browser", wechat: "WeChat", yahooslurp: "YahooSlurp", yandex: "Yandex Browser", yandexbot: "YandexBot", youbot: "YouBot" };
t.PLATFORMS_MAP = { bot: "bot", desktop: "desktop", mobile: "mobile", tablet: "tablet", tv: "tv" };
t.OS_MAP = { Android: "Android", Bada: "Bada", BlackBerry: "BlackBerry", ChromeOS: "Chrome OS", HarmonyOS: "HarmonyOS", iOS: "iOS", Linux: "Linux", MacOS: "macOS", PlayStation4: "PlayStation 4", Roku: "Roku", Tizen: "Tizen", WebOS: "WebOS", Windows: "Windows", WindowsPhone: "Windows Phone" };
t.ENGINE_MAP = { Blink: "Blink", EdgeHTML: "EdgeHTML", Gecko: "Gecko", Presto: "Presto", Trident: "Trident", WebKit: "WebKit" };
}, 90: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(91)) && i.__esModule ? i : { default: i }, a = r(18);
function o(e, t) {
for (var r = 0;r < t.length; r++) {
var i = t[r];
i.enumerable = i.enumerable || false, i.configurable = true, "value" in i && (i.writable = true), Object.defineProperty(e, i.key, i);
}
}
var s = function() {
function e() {}
var t, r, i;
return e.getParser = function(e, t, r) {
if (t === undefined && (t = false), r === undefined && (r = null), typeof e != "string")
throw new Error("UserAgent should be a string");
return new n.default(e, t, r);
}, e.parse = function(e, t) {
return t === undefined && (t = null), new n.default(e, t).getResult();
}, t = e, i = [{ key: "BROWSER_MAP", get: function() {
return a.BROWSER_MAP;
} }, { key: "ENGINE_MAP", get: function() {
return a.ENGINE_MAP;
} }, { key: "OS_MAP", get: function() {
return a.OS_MAP;
} }, { key: "PLATFORMS_MAP", get: function() {
return a.PLATFORMS_MAP;
} }], (r = null) && o(t.prototype, r), i && o(t, i), e;
}();
t.default = s, e.exports = t.default;
}, 91: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i = u(r(92)), n = u(r(93)), a = u(r(94)), o = u(r(95)), s = u(r(17));
function u(e) {
return e && e.__esModule ? e : { default: e };
}
var d = function() {
function e(e, t, r) {
if (t === undefined && (t = false), r === undefined && (r = null), e == null || e === "")
throw new Error("UserAgent parameter can't be empty");
this._ua = e;
var i = false;
typeof t == "boolean" ? (i = t, this._hints = r) : this._hints = t != null && typeof t == "object" ? t : null, this.parsedResult = {}, i !== true && this.parse();
}
var t = e.prototype;
return t.getHints = function() {
return this._hints;
}, t.hasBrand = function(e) {
if (!this._hints || !Array.isArray(this._hints.brands))
return false;
var t = e.toLowerCase();
return this._hints.brands.some(function(e) {
return e.brand && e.brand.toLowerCase() === t;
});
}, t.getBrandVersion = function(e) {
if (this._hints && Array.isArray(this._hints.brands)) {
var t = e.toLowerCase(), r = this._hints.brands.find(function(e) {
return e.brand && e.brand.toLowerCase() === t;
});
return r ? r.version : undefined;
}
}, t.getUA = function() {
return this._ua;
}, t.test = function(e) {
return e.test(this._ua);
}, t.parseBrowser = function() {
var e = this;
this.parsedResult.browser = {};
var t = s.default.find(i.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.browser = t.describe(this.getUA(), this)), this.parsedResult.browser;
}, t.getBrowser = function() {
return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
}, t.getBrowserName = function(e) {
return e ? String(this.getBrowser().name).toLowerCase() || "" : this.getBrowser().name || "";
}, t.getBrowserVersion = function() {
return this.getBrowser().version;
}, t.getOS = function() {
return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
}, t.parseOS = function() {
var e = this;
this.parsedResult.os = {};
var t = s.default.find(n.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.os = t.describe(this.getUA())), this.parsedResult.os;
}, t.getOSName = function(e) {
var t = this.getOS().name;
return e ? String(t).toLowerCase() || "" : t || "";
}, t.getOSVersion = function() {
return this.getOS().version;
}, t.getPlatform = function() {
return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
}, t.getPlatformType = function(e) {
e === undefined && (e = false);
var t = this.getPlatform().type;
return e ? String(t).toLowerCase() || "" : t || "";
}, t.parsePlatform = function() {
var e = this;
this.parsedResult.platform = {};
var t = s.default.find(a.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.platform = t.describe(this.getUA())), this.parsedResult.platform;
}, t.getEngine = function() {
return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
}, t.getEngineName = function(e) {
return e ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
}, t.parseEngine = function() {
var e = this;
this.parsedResult.engine = {};
var t = s.default.find(o.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.engine = t.describe(this.getUA())), this.parsedResult.engine;
}, t.parse = function() {
return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
}, t.getResult = function() {
return s.default.assign({}, this.parsedResult);
}, t.satisfies = function(e) {
var t = this, r = {}, i = 0, n = {}, a = 0;
if (Object.keys(e).forEach(function(t) {
var o = e[t];
typeof o == "string" ? (n[t] = o, a += 1) : typeof o == "object" && (r[t] = o, i += 1);
}), i > 0) {
var o = Object.keys(r), u = s.default.find(o, function(e) {
return t.isOS(e);
});
if (u) {
var d = this.satisfies(r[u]);
if (d !== undefined)
return d;
}
var c = s.default.find(o, function(e) {
return t.isPlatform(e);
});
if (c) {
var f = this.satisfies(r[c]);
if (f !== undefined)
return f;
}
}
if (a > 0) {
var l = Object.keys(n), b = s.default.find(l, function(e) {
return t.isBrowser(e, true);
});
if (b !== undefined)
return this.compareVersion(n[b]);
}
}, t.isBrowser = function(e, t) {
t === undefined && (t = false);
var r = this.getBrowserName().toLowerCase(), i = e.toLowerCase(), n = s.default.getBrowserTypeByAlias(i);
return t && n && (i = n.toLowerCase()), i === r;
}, t.compareVersion = function(e) {
var t = [0], r = e, i = false, n = this.getBrowserVersion();
if (typeof n == "string")
return e[0] === ">" || e[0] === "<" ? (r = e.substr(1), e[1] === "=" ? (i = true, r = e.substr(2)) : t = [], e[0] === ">" ? t.push(1) : t.push(-1)) : e[0] === "=" ? r = e.substr(1) : e[0] === "~" && (i = true, r = e.substr(1)), t.indexOf(s.default.compareVersions(n, r, i)) > -1;
}, t.isOS = function(e) {
return this.getOSName(true) === String(e).toLowerCase();
}, t.isPlatform = function(e) {
return this.getPlatformType(true) === String(e).toLowerCase();
}, t.isEngine = function(e) {
return this.getEngineName(true) === String(e).toLowerCase();
}, t.is = function(e, t) {
return t === undefined && (t = false), this.isBrowser(e, t) || this.isOS(e) || this.isPlatform(e);
}, t.some = function(e) {
var t = this;
return e === undefined && (e = []), e.some(function(e) {
return t.is(e);
});
}, e;
}();
t.default = d, e.exports = t.default;
}, 92: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i };
var a = /version\/(\d+(\.?_?\d+)+)/i, o = [{ test: [/gptbot/i], describe: function(e) {
var t = { name: "GPTBot" }, r = n.default.getFirstMatch(/gptbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/chatgpt-user/i], describe: function(e) {
var t = { name: "ChatGPT-User" }, r = n.default.getFirstMatch(/chatgpt-user\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/oai-searchbot/i], describe: function(e) {
var t = { name: "OAI-SearchBot" }, r = n.default.getFirstMatch(/oai-searchbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i], describe: function(e) {
var t = { name: "ClaudeBot" }, r = n.default.getFirstMatch(/(?:claudebot|claude-web|claude-user|claude-searchbot)\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/omgilibot/i, /webzio-extended/i], describe: function(e) {
var t = { name: "Omgilibot" }, r = n.default.getFirstMatch(/(?:omgilibot|webzio-extended)\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/diffbot/i], describe: function(e) {
var t = { name: "Diffbot" }, r = n.default.getFirstMatch(/diffbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/perplexitybot/i], describe: function(e) {
var t = { name: "PerplexityBot" }, r = n.default.getFirstMatch(/perplexitybot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/perplexity-user/i], describe: function(e) {
var t = { name: "Perplexity-User" }, r = n.default.getFirstMatch(/perplexity-user\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/youbot/i], describe: function(e) {
var t = { name: "YouBot" }, r = n.default.getFirstMatch(/youbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-webindexer/i], describe: function(e) {
var t = { name: "Meta-WebIndexer" }, r = n.default.getFirstMatch(/meta-webindexer\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalads/i], describe: function(e) {
var t = { name: "Meta-ExternalAds" }, r = n.default.getFirstMatch(/meta-externalads\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalagent/i], describe: function(e) {
var t = { name: "Meta-ExternalAgent" }, r = n.default.getFirstMatch(/meta-externalagent\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalfetcher/i], describe: function(e) {
var t = { name: "Meta-ExternalFetcher" }, r = n.default.getFirstMatch(/meta-externalfetcher\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/googlebot/i], describe: function(e) {
var t = { name: "Googlebot" }, r = n.default.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/linespider/i], describe: function(e) {
var t = { name: "Linespider" }, r = n.default.getFirstMatch(/(?:linespider)(?:-[-\w]+)?[\s/](\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/amazonbot/i], describe: function(e) {
var t = { name: "AmazonBot" }, r = n.default.getFirstMatch(/amazonbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/bingbot/i], describe: function(e) {
var t = { name: "BingCrawler" }, r = n.default.getFirstMatch(/bingbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/baiduspider/i], describe: function(e) {
var t = { name: "BaiduSpider" }, r = n.default.getFirstMatch(/baiduspider\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/duckduckbot/i], describe: function(e) {
var t = { name: "DuckDuckBot" }, r = n.default.getFirstMatch(/duckduckbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/ia_archiver/i], describe: function(e) {
var t = { name: "InternetArchiveCrawler" }, r = n.default.getFirstMatch(/ia_archiver\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/facebookexternalhit/i, /facebookcatalog/i], describe: function() {
return { name: "FacebookExternalHit" };
} }, { test: [/slackbot/i, /slack-imgProxy/i], describe: function(e) {
var t = { name: "SlackBot" }, r = n.default.getFirstMatch(/(?:slackbot|slack-imgproxy)(?:-[-\w]+)?[\s/](\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/yahoo!?[\s/]*slurp/i], describe: function() {
return { name: "YahooSlurp" };
} }, { test: [/yandexbot/i, /yandexmobilebot/i], describe: function() {
return { name: "YandexBot" };
} }, { test: [/pingdom/i], describe: function() {
return { name: "PingdomBot" };
} }, { test: [/opera/i], describe: function(e) {
var t = { name: "Opera" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/opr\/|opios/i], describe: function(e) {
var t = { name: "Opera" }, r = n.default.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/SamsungBrowser/i], describe: function(e) {
var t = { name: "Samsung Internet for Android" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/Whale/i], describe: function(e) {
var t = { name: "NAVER Whale Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/PaleMoon/i], describe: function(e) {
var t = { name: "Pale Moon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:PaleMoon)[\s/](\d+(?:\.\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/MZBrowser/i], describe: function(e) {
var t = { name: "MZ Browser" }, r = n.default.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/focus/i], describe: function(e) {
var t = { name: "Focus" }, r = n.default.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/swing/i], describe: function(e) {
var t = { name: "Swing" }, r = n.default.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/coast/i], describe: function(e) {
var t = { name: "Opera Coast" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/opt\/\d+(?:.?_?\d+)+/i], describe: function(e) {
var t = { name: "Opera Touch" }, r = n.default.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/yabrowser/i], describe: function(e) {
var t = { name: "Yandex Browser" }, r = n.default.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/ucbrowser/i], describe: function(e) {
var t = { name: "UC Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/Maxthon|mxios/i], describe: function(e) {
var t = { name: "Maxthon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/epiphany/i], describe: function(e) {
var t = { name: "Epiphany" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/puffin/i], describe: function(e) {
var t = { name: "Puffin" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sleipnir/i], describe: function(e) {
var t = { name: "Sleipnir" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/k-meleon/i], describe: function(e) {
var t = { name: "K-Meleon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/micromessenger/i], describe: function(e) {
var t = { name: "WeChat" }, r = n.default.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/qqbrowser/i], describe: function(e) {
var t = { name: /qqbrowserlite/i.test(e) ? "QQ Browser Lite" : "QQ Browser" }, r = n.default.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/msie|trident/i], describe: function(e) {
var t = { name: "Internet Explorer" }, r = n.default.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/\sedg\//i], describe: function(e) {
var t = { name: "Microsoft Edge" }, r = n.default.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/edg([ea]|ios)/i], describe: function(e) {
var t = { name: "Microsoft Edge" }, r = n.default.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/vivaldi/i], describe: function(e) {
var t = { name: "Vivaldi" }, r = n.default.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/seamonkey/i], describe: function(e) {
var t = { name: "SeaMonkey" }, r = n.default.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sailfish/i], describe: function(e) {
var t = { name: "Sailfish" }, r = n.default.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, e);
return r && (t.version = r), t;
} }, { test: [/silk/i], describe: function(e) {
var t = { name: "Amazon Silk" }, r = n.default.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/phantom/i], describe: function(e) {
var t = { name: "PhantomJS" }, r = n.default.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/slimerjs/i], describe: function(e) {
var t = { name: "SlimerJS" }, r = n.default.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/blackberry|\bbb\d+/i, /rim\stablet/i], describe: function(e) {
var t = { name: "BlackBerry" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/(web|hpw)[o0]s/i], describe: function(e) {
var t = { name: "WebOS Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/bada/i], describe: function(e) {
var t = { name: "Bada" }, r = n.default.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/tizen/i], describe: function(e) {
var t = { name: "Tizen" }, r = n.default.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/qupzilla/i], describe: function(e) {
var t = { name: "QupZilla" }, r = n.default.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/librewolf/i], describe: function(e) {
var t = { name: "LibreWolf" }, r = n.default.getFirstMatch(/(?:librewolf)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/firefox|iceweasel|fxios/i], describe: function(e) {
var t = { name: "Firefox" }, r = n.default.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/electron/i], describe: function(e) {
var t = { name: "Electron" }, r = n.default.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sogoumobilebrowser/i, /metasr/i, /se 2\.[x]/i], describe: function(e) {
var t = { name: "Sogou Browser" }, r = n.default.getFirstMatch(/(?:sogoumobilebrowser)[\s/](\d+(\.?_?\d+)+)/i, e), i = n.default.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, e), a = n.default.getFirstMatch(/se ([\d.]+)x/i, e), o = r || i || a;
return o && (t.version = o), t;
} }, { test: [/MiuiBrowser/i], describe: function(e) {
var t = { name: "Miui" }, r = n.default.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
return !!e.hasBrand("DuckDuckGo") || e.test(/\sDdg\/[\d.]+$/i);
}, describe: function(e, t) {
var r = { name: "DuckDuckGo" };
if (t) {
var i = t.getBrandVersion("DuckDuckGo");
if (i)
return r.version = i, r;
}
var a = n.default.getFirstMatch(/\sDdg\/([\d.]+)$/i, e);
return a && (r.version = a), r;
} }, { test: function(e) {
return e.hasBrand("Brave");
}, describe: function(e, t) {
var r = { name: "Brave" };
if (t) {
var i = t.getBrandVersion("Brave");
if (i)
return r.version = i, r;
}
return r;
} }, { test: [/chromium/i], describe: function(e) {
var t = { name: "Chromium" }, r = n.default.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/chrome|crios|crmo/i], describe: function(e) {
var t = { name: "Chrome" }, r = n.default.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/GSA/i], describe: function(e) {
var t = { name: "Google Search" }, r = n.default.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
var t = !e.test(/like android/i), r = e.test(/android/i);
return t && r;
}, describe: function(e) {
var t = { name: "Android Browser" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/playstation 4/i], describe: function(e) {
var t = { name: "PlayStation 4" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/safari|applewebkit/i], describe: function(e) {
var t = { name: "Safari" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/.*/i], describe: function(e) {
var t = e.search("\\(") !== -1 ? /^(.*)\/(.*)[ \t]\((.*)/ : /^(.*)\/(.*) /;
return { name: n.default.getFirstMatch(t, e), version: n.default.getSecondMatch(t, e) };
} }];
t.default = o, e.exports = t.default;
}, 93: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: [/Roku\/DVP/], describe: function(e) {
var t = n.default.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, e);
return { name: a.OS_MAP.Roku, version: t };
} }, { test: [/windows phone/i], describe: function(e) {
var t = n.default.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.WindowsPhone, version: t };
} }, { test: [/windows /i], describe: function(e) {
var t = n.default.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, e), r = n.default.getWindowsVersionName(t);
return { name: a.OS_MAP.Windows, version: t, versionName: r };
} }, { test: [/Macintosh(.*?) FxiOS(.*?)\//], describe: function(e) {
var t = { name: a.OS_MAP.iOS }, r = n.default.getSecondMatch(/(Version\/)(\d[\d.]+)/, e);
return r && (t.version = r), t;
} }, { test: [/macintosh/i], describe: function(e) {
var t = n.default.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, e).replace(/[_\s]/g, "."), r = n.default.getMacOSVersionName(t), i = { name: a.OS_MAP.MacOS, version: t };
return r && (i.versionName = r), i;
} }, { test: [/(ipod|iphone|ipad)/i], describe: function(e) {
var t = n.default.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, e).replace(/[_\s]/g, ".");
return { name: a.OS_MAP.iOS, version: t };
} }, { test: [/OpenHarmony/i], describe: function(e) {
var t = n.default.getFirstMatch(/OpenHarmony\s+(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.HarmonyOS, version: t };
} }, { test: function(e) {
var t = !e.test(/like android/i), r = e.test(/android/i);
return t && r;
}, describe: function(e) {
var t = n.default.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, e), r = n.default.getAndroidVersionName(t), i = { name: a.OS_MAP.Android, version: t };
return r && (i.versionName = r), i;
} }, { test: [/(web|hpw)[o0]s/i], describe: function(e) {
var t = n.default.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, e), r = { name: a.OS_MAP.WebOS };
return t && t.length && (r.version = t), r;
} }, { test: [/blackberry|\bbb\d+/i, /rim\stablet/i], describe: function(e) {
var t = n.default.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, e) || n.default.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, e) || n.default.getFirstMatch(/\bbb(\d+)/i, e);
return { name: a.OS_MAP.BlackBerry, version: t };
} }, { test: [/bada/i], describe: function(e) {
var t = n.default.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.Bada, version: t };
} }, { test: [/tizen/i], describe: function(e) {
var t = n.default.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.Tizen, version: t };
} }, { test: [/linux/i], describe: function() {
return { name: a.OS_MAP.Linux };
} }, { test: [/CrOS/], describe: function() {
return { name: a.OS_MAP.ChromeOS };
} }, { test: [/PlayStation 4/], describe: function(e) {
var t = n.default.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.PlayStation4, version: t };
} }];
t.default = o, e.exports = t.default;
}, 94: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: [/googlebot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Google" };
} }, { test: [/linespider/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Line" };
} }, { test: [/amazonbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Amazon" };
} }, { test: [/gptbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/chatgpt-user/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/oai-searchbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/baiduspider/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Baidu" };
} }, { test: [/bingbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Bing" };
} }, { test: [/duckduckbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "DuckDuckGo" };
} }, { test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Anthropic" };
} }, { test: [/omgilibot/i, /webzio-extended/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Webz.io" };
} }, { test: [/diffbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Diffbot" };
} }, { test: [/perplexitybot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Perplexity AI" };
} }, { test: [/perplexity-user/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Perplexity AI" };
} }, { test: [/youbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "You.com" };
} }, { test: [/ia_archiver/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Internet Archive" };
} }, { test: [/meta-webindexer/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalads/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalagent/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalfetcher/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/facebookexternalhit/i, /facebookcatalog/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/slackbot/i, /slack-imgProxy/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Slack" };
} }, { test: [/yahoo/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Yahoo" };
} }, { test: [/yandexbot/i, /yandexmobilebot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Yandex" };
} }, { test: [/pingdom/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Pingdom" };
} }, { test: [/huawei/i], describe: function(e) {
var t = n.default.getFirstMatch(/(can-l01)/i, e) && "Nova", r = { type: a.PLATFORMS_MAP.mobile, vendor: "Huawei" };
return t && (r.model = t), r;
} }, { test: [/nexus\s*(?:7|8|9|10).*/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Nexus" };
} }, { test: [/ipad/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Apple", model: "iPad" };
} }, { test: [/Macintosh(.*?) FxiOS(.*?)\//], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Apple", model: "iPad" };
} }, { test: [/kftt build/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Amazon", model: "Kindle Fire HD 7" };
} }, { test: [/silk/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Amazon" };
} }, { test: [/tablet(?! pc)/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet };
} }, { test: function(e) {
var t = e.test(/ipod|iphone/i), r = e.test(/like (ipod|iphone)/i);
return t && !r;
}, describe: function(e) {
var t = n.default.getFirstMatch(/(ipod|iphone)/i, e);
return { type: a.PLATFORMS_MAP.mobile, vendor: "Apple", model: t };
} }, { test: [/nexus\s*[0-6].*/i, /galaxy nexus/i], describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "Nexus" };
} }, { test: [/Nokia/i], describe: function(e) {
var t = n.default.getFirstMatch(/Nokia\s+([0-9]+(\.[0-9]+)?)/i, e), r = { type: a.PLATFORMS_MAP.mobile, vendor: "Nokia" };
return t && (r.model = t), r;
} }, { test: [/[^-]mobi/i], describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: function(e) {
return e.getBrowserName(true) === "blackberry";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "BlackBerry" };
} }, { test: function(e) {
return e.getBrowserName(true) === "bada";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: function(e) {
return e.getBrowserName() === "windows phone";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "Microsoft" };
} }, { test: function(e) {
var t = Number(String(e.getOSVersion()).split(".")[0]);
return e.getOSName(true) === "android" && t >= 3;
}, describe: function() {
return { type: a.PLATFORMS_MAP.tablet };
} }, { test: function(e) {
return e.getOSName(true) === "android";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: [/smart-?tv|smarttv/i], describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: [/netcast/i], describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: function(e) {
return e.getOSName(true) === "macos";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop, vendor: "Apple" };
} }, { test: function(e) {
return e.getOSName(true) === "windows";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop };
} }, { test: function(e) {
return e.getOSName(true) === "linux";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop };
} }, { test: function(e) {
return e.getOSName(true) === "playstation 4";
}, describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: function(e) {
return e.getOSName(true) === "roku";
}, describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }];
t.default = o, e.exports = t.default;
}, 95: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: function(e) {
return e.getBrowserName(true) === "microsoft edge";
}, describe: function(e) {
if (/\sedg\//i.test(e))
return { name: a.ENGINE_MAP.Blink };
var t = n.default.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, e);
return { name: a.ENGINE_MAP.EdgeHTML, version: t };
} }, { test: [/trident/i], describe: function(e) {
var t = { name: a.ENGINE_MAP.Trident }, r = n.default.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
return e.test(/presto/i);
}, describe: function(e) {
var t = { name: a.ENGINE_MAP.Presto }, r = n.default.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
var t = e.test(/gecko/i), r = e.test(/like gecko/i);
return t && !r;
}, describe: function(e) {
var t = { name: a.ENGINE_MAP.Gecko }, r = n.default.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/(apple)?webkit\/537\.36/i], describe: function() {
return { name: a.ENGINE_MAP.Blink };
} }, { test: [/(apple)?webkit/i], describe: function(e) {
var t = { name: a.ENGINE_MAP.WebKit }, r = n.default.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }];
t.default = o, e.exports = t.default;
} });
});
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
var require_client2 = __commonJS(function(exports) {
var { Retry, RETRY_MODES } = require_retry();
var { HttpRequest, parseUrl } = require_protocols();
var { InvokeStore } = require_invoke_store();
var { normalizeProvider } = require_dist_cjs2();
var { platform, release } = __require("os");
var { versions, env } = __require("process");
var { isValidHostLabel, isIpAddress, customEndpointFunctions } = require_endpoints();
var { EndpointError, resolveEndpoint } = require_endpoints();
exports.EndpointError = EndpointError;
exports.isIpAddress = isIpAddress;
exports.resolveEndpoint = resolveEndpoint;
var { loadConfig, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS } = require_config();
var { REGION_ENV_NAME, REGION_INI_NAME, resolveRegionConfig } = require_config();
exports.NODE_REGION_CONFIG_FILE_OPTIONS = NODE_REGION_CONFIG_FILE_OPTIONS;
exports.NODE_REGION_CONFIG_OPTIONS = NODE_REGION_CONFIG_OPTIONS;
exports.REGION_ENV_NAME = REGION_ENV_NAME;
exports.REGION_INI_NAME = REGION_INI_NAME;
exports.resolveRegionConfig = resolveRegionConfig;
var state = {
warningEmitted: false
};
var emitWarningIfUnsupportedVersion = (version) => {
if (version && !state.warningEmitted) {
if (process.env.AWS_SDK_JS_NODE_VERSION_SUPPORT_WARNING_DISABLED === "true") {
state.warningEmitted = true;
return;
}
const userMajorVersion = parseInt(version.substring(1, version.indexOf(".")));
const vv = 22;
if (userMajorVersion < vv) {
state.warningEmitted = true;
process.emitWarning(`NodeVersionSupportWarning: The AWS SDK for JavaScript (v3)
versions published after the first week of January 2027
will require node >=${vv}. You are running node ${version}.
To continue receiving updates to AWS services, bug fixes,
and security updates please upgrade to node >=${vv}.
More information can be found at: https://a.co/c895JFp`);
}
}
};
var longPollMiddleware = () => (next, context) => async (args) => {
context.__retryLongPoll = true;
return next(args);
};
var longPollMiddlewareOptions = {
name: "longPollMiddleware",
tags: ["RETRY"],
step: "initialize",
override: true
};
var getLongPollPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(longPollMiddleware(), longPollMiddlewareOptions);
}
});
function setCredentialFeature(credentials, feature, value) {
if (!credentials.$source) {
credentials.$source = {};
}
credentials.$source[feature] = value;
return credentials;
}
Retry.v2026 ||= typeof process === "object" && process.env?.AWS_NEW_RETRIES_2026 === "true";
function setFeature(context, feature, value) {
if (!context.__aws_sdk_context) {
context.__aws_sdk_context = {
features: {}
};
} else if (!context.__aws_sdk_context.features) {
context.__aws_sdk_context.features = {};
}
context.__aws_sdk_context.features[feature] = value;
}
function setTokenFeature(token, feature, value) {
if (!token.$source) {
token.$source = {};
}
token.$source[feature] = value;
return token;
}
function resolveHostHeaderConfig(input) {
return input;
}
var hostHeaderMiddleware = (options) => (next) => async (args) => {
if (!HttpRequest.isInstance(args.request))
return next(args);
const { request } = args;
const { handlerProtocol = "" } = options.requestHandler.metadata || {};
if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
delete request.headers["host"];
request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
} else if (!request.headers["host"]) {
let host = request.hostname;
if (request.port != null)
host += `:${request.port}`;
request.headers["host"] = host;
}
return next(args);
};
var hostHeaderMiddlewareOptions = {
name: "hostHeaderMiddleware",
step: "build",
priority: "low",
tags: ["HOST"],
override: true
};
var getHostHeaderPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
}
});
var loggerMiddleware = () => (next, context) => async (args) => {
try {
const response = await next(args);
const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
const { $metadata, ...outputWithoutMetadata } = response.output;
logger?.info?.({
clientName,
commandName,
input: inputFilterSensitiveLog(args.input),
output: outputFilterSensitiveLog(outputWithoutMetadata),
metadata: $metadata
});
return response;
} catch (error) {
const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
logger?.error?.({
clientName,
commandName,
input: inputFilterSensitiveLog(args.input),
error,
metadata: error.$metadata
});
throw error;
}
};
var loggerMiddlewareOptions = {
name: "loggerMiddleware",
tags: ["LOGGER"],
step: "initialize",
override: true
};
var getLoggerPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
}
});
var recursionDetectionMiddlewareOptions = {
step: "build",
tags: ["RECURSION_DETECTION", "TRACE_CONTEXT_PROPAGATION"],
name: "recursionDetectionMiddleware",
override: true,
priority: "low"
};
var AWS_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
var _X_AMZN_TRACE_ID = "_X_AMZN_TRACE_ID";
var X_AMZN_TRACE_ID = "X-Amzn-Trace-Id";
var TRACEPARENT = "traceparent";
var TRACESTATE = "tracestate";
var BAGGAGE = "baggage";
var recursionDetectionMiddleware = () => (next) => async (args) => {
const { request } = args;
if (!HttpRequest.isInstance(request)) {
return next(args);
}
let invokeStore;
{
const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === X_AMZN_TRACE_ID.toLowerCase()) ?? X_AMZN_TRACE_ID;
if (!request.headers.hasOwnProperty(traceIdHeader)) {
const functionName = process.env[AWS_LAMBDA_FUNCTION_NAME];
const traceIdFromEnv = process.env[_X_AMZN_TRACE_ID];
invokeStore ??= await InvokeStore.getInstanceAsync();
const traceIdFromInvokeStore = invokeStore?.getXRayTraceId();
const traceId = traceIdFromInvokeStore ?? traceIdFromEnv;
const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
request.headers[X_AMZN_TRACE_ID] = traceId;
}
}
}
{
sanitizeTraceHeaders(request.headers);
const existingTraceparent = request.headers[TRACEPARENT];
if (!existingTraceparent) {
const traceparent = (invokeStore ??= await InvokeStore.getInstanceAsync())?.getTraceparent?.();
if (traceparent) {
request.headers[TRACEPARENT] = traceparent;
const tracestate = invokeStore?.getTracestate?.();
if (tracestate) {
request.headers[TRACESTATE] = tracestate;
}
const baggage = invokeStore?.getBaggage?.();
if (baggage) {
request.headers[BAGGAGE] = baggage;
}
}
}
}
return next(args);
};
function sanitizeTraceHeaders(headers) {
for (const header of Object.keys(headers)) {
const lower = header.toLowerCase();
if (header !== lower && (lower === TRACEPARENT || lower === TRACESTATE || lower === BAGGAGE)) {
headers[lower] = headers[header];
delete headers[header];
}
}
}
var getRecursionDetectionPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
}
});
var DEFAULT_UA_APP_ID = undefined;
function isValidUserAgentAppId(appId) {
if (appId === undefined) {
return true;
}
return typeof appId === "string" && appId.length <= 50;
}
function resolveUserAgentConfig(input) {
const normalizedAppIdProvider = normalizeProvider(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
const { customUserAgent } = input;
return Object.assign(input, {
customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
userAgentAppId: async () => {
const appId = await normalizedAppIdProvider();
if (!isValidUserAgentAppId(appId)) {
const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
if (typeof appId !== "string") {
logger?.warn("userAgentAppId must be a string or undefined.");
} else if (appId.length > 50) {
logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
}
}
return appId;
}
});
}
var partitionsInfo = {
partitions: [
{
id: "aws",
outputs: {
dnsSuffix: "amazonaws.com",
dualStackDnsSuffix: "api.aws",
implicitGlobalRegion: "us-east-1",
name: "aws",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
regions: {
"af-south-1": {
description: "Africa (Cape Town)"
},
"ap-east-1": {
description: "Asia Pacific (Hong Kong)"
},
"ap-east-2": {
description: "Asia Pacific (Taipei)"
},
"ap-northeast-1": {
description: "Asia Pacific (Tokyo)"
},
"ap-northeast-2": {
description: "Asia Pacific (Seoul)"
},
"ap-northeast-3": {
description: "Asia Pacific (Osaka)"
},
"ap-south-1": {
description: "Asia Pacific (Mumbai)"
},
"ap-south-2": {
description: "Asia Pacific (Hyderabad)"
},
"ap-southeast-1": {
description: "Asia Pacific (Singapore)"
},
"ap-southeast-2": {
description: "Asia Pacific (Sydney)"
},
"ap-southeast-3": {
description: "Asia Pacific (Jakarta)"
},
"ap-southeast-4": {
description: "Asia Pacific (Melbourne)"
},
"ap-southeast-5": {
description: "Asia Pacific (Malaysia)"
},
"ap-southeast-6": {
description: "Asia Pacific (New Zealand)"
},
"ap-southeast-7": {
description: "Asia Pacific (Thailand)"
},
"aws-global": {
description: "aws global region"
},
"ca-central-1": {
description: "Canada (Central)"
},
"ca-west-1": {
description: "Canada West (Calgary)"
},
"eu-central-1": {
description: "Europe (Frankfurt)"
},
"eu-central-2": {
description: "Europe (Zurich)"
},
"eu-north-1": {
description: "Europe (Stockholm)"
},
"eu-south-1": {
description: "Europe (Milan)"
},
"eu-south-2": {
description: "Europe (Spain)"
},
"eu-west-1": {
description: "Europe (Ireland)"
},
"eu-west-2": {
description: "Europe (London)"
},
"eu-west-3": {
description: "Europe (Paris)"
},
"il-central-1": {
description: "Israel (Tel Aviv)"
},
"me-central-1": {
description: "Middle East (UAE)"
},
"me-south-1": {
description: "Middle East (Bahrain)"
},
"mx-central-1": {
description: "Mexico (Central)"
},
"sa-east-1": {
description: "South America (Sao Paulo)"
},
"us-east-1": {
description: "US East (N. Virginia)"
},
"us-east-2": {
description: "US East (Ohio)"
},
"us-west-1": {
description: "US West (N. California)"
},
"us-west-2": {
description: "US West (Oregon)"
}
}
},
{
id: "aws-cn",
outputs: {
dnsSuffix: "amazonaws.com.cn",
dualStackDnsSuffix: "api.amazonwebservices.com.cn",
implicitGlobalRegion: "cn-northwest-1",
name: "aws-cn",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^cn\\-\\w+\\-\\d+$",
regions: {
"aws-cn-global": {
description: "aws-cn global region"
},
"cn-north-1": {
description: "China (Beijing)"
},
"cn-northwest-1": {
description: "China (Ningxia)"
}
}
},
{
id: "aws-eusc",
outputs: {
dnsSuffix: "amazonaws.eu",
dualStackDnsSuffix: "api.amazonwebservices.eu",
implicitGlobalRegion: "eusc-de-east-1",
name: "aws-eusc",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
regions: {
"eusc-de-east-1": {
description: "AWS European Sovereign Cloud (Germany)"
}
}
},
{
id: "aws-iso",
outputs: {
dnsSuffix: "c2s.ic.gov",
dualStackDnsSuffix: "api.aws.ic.gov",
implicitGlobalRegion: "us-iso-east-1",
name: "aws-iso",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
regions: {
"aws-iso-global": {
description: "aws-iso global region"
},
"us-iso-east-1": {
description: "US ISO East"
},
"us-iso-west-1": {
description: "US ISO WEST"
}
}
},
{
id: "aws-iso-b",
outputs: {
dnsSuffix: "sc2s.sgov.gov",
dualStackDnsSuffix: "api.aws.scloud",
implicitGlobalRegion: "us-isob-east-1",
name: "aws-iso-b",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
regions: {
"aws-iso-b-global": {
description: "aws-iso-b global region"
},
"us-isob-east-1": {
description: "US ISOB East (Ohio)"
},
"us-isob-west-1": {
description: "US ISOB West"
}
}
},
{
id: "aws-iso-e",
outputs: {
dnsSuffix: "cloud.adc-e.uk",
dualStackDnsSuffix: "api.cloud-aws.adc-e.uk",
implicitGlobalRegion: "eu-isoe-west-1",
name: "aws-iso-e",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
regions: {
"aws-iso-e-global": {
description: "aws-iso-e global region"
},
"eu-isoe-west-1": {
description: "EU ISOE West"
}
}
},
{
id: "aws-iso-f",
outputs: {
dnsSuffix: "csp.hci.ic.gov",
dualStackDnsSuffix: "api.aws.hci.ic.gov",
implicitGlobalRegion: "us-isof-south-1",
name: "aws-iso-f",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
regions: {
"aws-iso-f-global": {
description: "aws-iso-f global region"
},
"us-isof-east-1": {
description: "US ISOF EAST"
},
"us-isof-south-1": {
description: "US ISOF SOUTH"
}
}
},
{
id: "aws-us-gov",
outputs: {
dnsSuffix: "amazonaws.com",
dualStackDnsSuffix: "api.aws",
implicitGlobalRegion: "us-gov-west-1",
name: "aws-us-gov",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
regions: {
"aws-us-gov-global": {
description: "aws-us-gov global region"
},
"us-gov-east-1": {
description: "AWS GovCloud (US-East)"
},
"us-gov-west-1": {
description: "AWS GovCloud (US-West)"
}
}
}
],
version: "1.1"
};
var selectedPartitionsInfo = partitionsInfo;
var selectedUserAgentPrefix = "";
var partition = (value) => {
const { partitions } = selectedPartitionsInfo;
for (const partition of partitions) {
const { regions, outputs } = partition;
for (const [region, regionData] of Object.entries(regions)) {
if (region === value) {
return {
...outputs,
...regionData
};
}
}
}
for (const partition of partitions) {
const { regionRegex, outputs } = partition;
if (new RegExp(regionRegex).test(value)) {
return {
...outputs
};
}
}
const DEFAULT_PARTITION = partitions.find((partition) => partition.id === "aws");
if (!DEFAULT_PARTITION) {
throw new Error("Provided region was not found in the partition array or regex," + " and default partition with id 'aws' doesn't exist.");
}
return {
...DEFAULT_PARTITION.outputs
};
};
var setPartitionInfo = (partitionsInfo, userAgentPrefix = "") => {
selectedPartitionsInfo = partitionsInfo;
selectedUserAgentPrefix = userAgentPrefix;
};
var useDefaultPartitionInfo = () => {
setPartitionInfo(partitionsInfo, "");
};
var getUserAgentPrefix = () => selectedUserAgentPrefix;
var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
async function checkFeatures(context, config, args) {
const request = args.request;
if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
}
if (typeof config.retryStrategy === "function") {
const retryStrategy = await config.retryStrategy();
if (typeof retryStrategy.mode === "string") {
switch (retryStrategy.mode) {
case RETRY_MODES.ADAPTIVE:
setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
break;
case RETRY_MODES.STANDARD:
setFeature(context, "RETRY_MODE_STANDARD", "E");
break;
}
}
}
if (typeof config.accountIdEndpointMode === "function") {
const endpointV2 = context.endpointV2;
if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
}
switch (await config.accountIdEndpointMode?.()) {
case "disabled":
setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
break;
case "preferred":
setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
break;
case "required":
setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
break;
}
}
const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
if (identity?.$source) {
const credentials = identity;
if (credentials.accountId) {
setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
}
for (const [key, value] of Object.entries(credentials.$source ?? {})) {
setFeature(context, key, value);
}
}
}
var USER_AGENT = "user-agent";
var X_AMZ_USER_AGENT = "x-amz-user-agent";
var SPACE = " ";
var UA_NAME_SEPARATOR = "/";
var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
var UA_ESCAPE_CHAR = "-";
var BYTE_LIMIT = 1024;
function encodeFeatures(features) {
let buffer = "";
for (const key in features) {
const val = features[key];
if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
if (buffer.length) {
buffer += "," + val;
} else {
buffer += val;
}
continue;
}
break;
}
return buffer;
}
var userAgentMiddleware = (options) => (next, context) => async (args) => {
const { request } = args;
if (!HttpRequest.isInstance(request)) {
return next(args);
}
const { headers } = request;
const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
await checkFeatures(context, options, args);
const awsContext = context;
defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
const appId = await options.userAgentAppId();
if (appId) {
defaultUserAgent.push(escapeUserAgent([`app`, `${appId}`]));
}
const prefix = getUserAgentPrefix();
const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent, ...userAgent, ...customUserAgent]).join(SPACE);
const normalUAValue = [
...defaultUserAgent.filter((section) => section.startsWith("aws-sdk-")),
...customUserAgent
].join(SPACE);
if (options.runtime !== "browser") {
if (normalUAValue) {
headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
}
headers[USER_AGENT] = sdkUserAgentValue;
} else {
headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
}
return next({
...args,
request
});
};
var escapeUserAgent = (userAgentPair) => {
const name = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
const prefix = name.substring(0, prefixSeparatorIndex);
let uaName = name.substring(prefixSeparatorIndex + 1);
if (prefix === "api") {
uaName = uaName.toLowerCase();
}
return [prefix, uaName, version].filter((item) => item && item.length > 0).reduce((acc, item, index) => {
switch (index) {
case 0:
return item;
case 1:
return `${acc}/${item}`;
default:
return `${acc}#${item}`;
}
}, "");
};
var getUserAgentMiddlewareOptions = {
name: "getUserAgentMiddleware",
step: "build",
priority: "low",
tags: ["SET_USER_AGENT", "USER_AGENT"],
override: true
};
var getUserAgentPlugin = (config) => ({
applyToStack: (clientStack) => {
clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
}
});
var getRuntimeUserAgentPair = () => {
const runtimesToCheck = ["deno", "bun", "llrt"];
for (const runtime of runtimesToCheck) {
if (versions[runtime]) {
return [`md/${runtime}`, versions[runtime]];
}
}
return ["md/nodejs", versions.node];
};
var crtAvailability = {
isCrtAvailable: false
};
var isCrtAvailable = () => {
if (crtAvailability.isCrtAvailable) {
return ["md/crt-avail"];
}
return null;
};
var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
const runtimeUserAgentPair = getRuntimeUserAgentPair();
return async (config) => {
const sections = [
["aws-sdk-js", clientVersion],
["ua", "2.1"],
[`os/${platform()}`, release()],
["lang/js"],
runtimeUserAgentPair
];
const crtAvailable = isCrtAvailable();
if (crtAvailable) {
sections.push(crtAvailable);
}
if (serviceId) {
sections.push([`api/${serviceId}`, clientVersion]);
}
if (env.AWS_EXECUTION_ENV) {
sections.push([`exec-env/${env.AWS_EXECUTION_ENV}`]);
}
const appId = await config?.userAgentAppId?.();
const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
return resolvedUserAgent;
};
};
var defaultUserAgent = createDefaultUserAgentProvider;
var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
var NODE_APP_ID_CONFIG_OPTIONS = {
environmentVariableSelector: (env2) => env2[UA_APP_ID_ENV_NAME],
configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
default: DEFAULT_UA_APP_ID
};
var createUserAgentStringParsingProvider = ({ serviceId, clientVersion }) => async (config) => {
const module2 = require_es5();
const parse2 = module2.parse ?? module2.default.parse ?? (() => "");
const parsedUA = typeof window !== "undefined" && window?.navigator?.userAgent ? parse2(window.navigator.userAgent) : undefined;
const sections = [
["aws-sdk-js", clientVersion],
["ua", "2.1"],
[`os/${parsedUA?.os?.name || "other"}`, parsedUA?.os?.version],
["lang/js"],
["md/browser", `${parsedUA?.browser?.name ?? "unknown"}_${parsedUA?.browser?.version ?? "unknown"}`]
];
if (serviceId) {
sections.push([`api/${serviceId}`, clientVersion]);
}
const appId = await config?.userAgentAppId?.();
if (appId) {
sections.push([`app/${appId}`]);
}
return sections;
};
var fallback = {
os(ua) {
if (/iPhone|iPad|iPod/.test(ua))
return "iOS";
if (/Macintosh|Mac OS X/.test(ua))
return "macOS";
if (/Windows NT/.test(ua))
return "Windows";
if (/Android/.test(ua))
return "Android";
if (/Linux/.test(ua))
return "Linux";
return;
},
browser(ua) {
if (/EdgiOS|EdgA|Edg\//.test(ua))
return "Microsoft Edge";
if (/Firefox\//.test(ua))
return "Firefox";
if (/Chrome\//.test(ua))
return "Chrome";
if (/Safari\//.test(ua))
return "Safari";
return;
}
};
var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
if (allowSubDomains) {
for (const label of value.split(".")) {
if (!isVirtualHostableS3Bucket(label)) {
return false;
}
}
return true;
}
if (!isValidHostLabel(value)) {
return false;
}
if (value.length < 3 || value.length > 63) {
return false;
}
if (value !== value.toLowerCase()) {
return false;
}
if (isIpAddress(value)) {
return false;
}
return true;
};
var ARN_DELIMITER = ":";
var RESOURCE_DELIMITER = "/";
var parseArn = (value) => {
const segments = value.split(ARN_DELIMITER);
if (segments.length < 6)
return null;
const [arn, partition, service, region, accountId, ...resourcePath] = segments;
if (arn !== "arn" || partition === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
return null;
const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
return {
partition,
service,
region,
accountId,
resourceId
};
};
var awsEndpointFunctions = {
isVirtualHostableS3Bucket,
parseArn,
partition
};
customEndpointFunctions.aws = awsEndpointFunctions;
var resolveDefaultAwsRegionalEndpointsConfig = (input) => {
if (typeof input.endpointProvider !== "function") {
throw new Error("@aws-sdk/util-endpoint - endpointProvider and endpoint missing in config for this client.");
}
const { endpoint } = input;
if (endpoint === undefined) {
input.endpoint = async () => {
return toEndpointV1(input.endpointProvider({
Region: typeof input.region === "function" ? await input.region() : input.region,
UseDualStack: typeof input.useDualstackEndpoint === "function" ? await input.useDualstackEndpoint() : input.useDualstackEndpoint,
UseFIPS: typeof input.useFipsEndpoint === "function" ? await input.useFipsEndpoint() : input.useFipsEndpoint,
Endpoint: undefined
}, { logger: input.logger }));
};
}
return input;
};
var toEndpointV1 = (endpoint) => parseUrl(endpoint.url);
function stsRegionDefaultResolver(loaderConfig = {}) {
return loadConfig({
...NODE_REGION_CONFIG_OPTIONS,
async default() {
if (!warning.silence) {
console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly.");
}
return "us-east-1";
}
}, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig });
}
var warning = {
silence: false
};
var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
return {
setRegion(region) {
runtimeConfig.region = region;
},
region() {
return runtimeConfig.region;
}
};
};
var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
return {
region: awsRegionExtensionConfiguration.region()
};
};
exports.DEFAULT_UA_APP_ID = DEFAULT_UA_APP_ID;
exports.NODE_APP_ID_CONFIG_OPTIONS = NODE_APP_ID_CONFIG_OPTIONS;
exports.UA_APP_ID_ENV_NAME = UA_APP_ID_ENV_NAME;
exports.UA_APP_ID_INI_NAME = UA_APP_ID_INI_NAME;
exports.awsEndpointFunctions = awsEndpointFunctions;
exports.createDefaultUserAgentProvider = createDefaultUserAgentProvider;
exports.createUserAgentStringParsingProvider = createUserAgentStringParsingProvider;
exports.crtAvailability = crtAvailability;
exports.defaultUserAgent = defaultUserAgent;
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
exports.fallback = fallback;
exports.getAwsRegionExtensionConfiguration = getAwsRegionExtensionConfiguration;
exports.getHostHeaderPlugin = getHostHeaderPlugin;
exports.getLoggerPlugin = getLoggerPlugin;
exports.getLongPollPlugin = getLongPollPlugin;
exports.getRecursionDetectionPlugin = getRecursionDetectionPlugin;
exports.getUserAgentMiddlewareOptions = getUserAgentMiddlewareOptions;
exports.getUserAgentPlugin = getUserAgentPlugin;
exports.getUserAgentPrefix = getUserAgentPrefix;
exports.hostHeaderMiddleware = hostHeaderMiddleware;
exports.hostHeaderMiddlewareOptions = hostHeaderMiddlewareOptions;
exports.isVirtualHostableS3Bucket = isVirtualHostableS3Bucket;
exports.loggerMiddleware = loggerMiddleware;
exports.loggerMiddlewareOptions = loggerMiddlewareOptions;
exports.parseArn = parseArn;
exports.partition = partition;
exports.recursionDetectionMiddleware = recursionDetectionMiddleware;
exports.recursionDetectionMiddlewareOptions = recursionDetectionMiddlewareOptions;
exports.resolveAwsRegionExtensionConfiguration = resolveAwsRegionExtensionConfiguration;
exports.resolveDefaultAwsRegionalEndpointsConfig = resolveDefaultAwsRegionalEndpointsConfig;
exports.resolveHostHeaderConfig = resolveHostHeaderConfig;
exports.resolveUserAgentConfig = resolveUserAgentConfig;
exports.setCredentialFeature = setCredentialFeature;
exports.setFeature = setFeature;
exports.setPartitionInfo = setPartitionInfo;
exports.setTokenFeature = setTokenFeature;
exports.state = state;
exports.stsRegionDefaultResolver = stsRegionDefaultResolver;
exports.stsRegionWarning = warning;
exports.toEndpointV1 = toEndpointV1;
exports.useDefaultPartitionInfo = useDefaultPartitionInfo;
exports.userAgentMiddleware = userAgentMiddleware;
});
// ../../node_modules/.bun/@smithy+signature-v4@5.7.3/node_modules/@smithy/signature-v4/dist-cjs/index.js
var require_dist_cjs3 = __commonJS(function(exports) {
var { hasOwn, fromUtf8, fromHex, toHex, toUint8Array, isArrayBuffer } = require_serde();
var { normalizeProvider } = require_client();
var { escapeUri, HttpRequest } = require_protocols();
class HeaderFormatter {
format(headers) {
const chunks = [];
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
const bytes = 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 : 1]);
case "byte":
return Uint8Array.from([2, header.value]);
case "short":
const shortView = new DataView(new ArrayBuffer(3));
shortView.setUint8(0, 3);
shortView.setInt16(1, header.value, false);
return new Uint8Array(shortView.buffer);
case "integer":
const intView = new DataView(new ArrayBuffer(5));
intView.setUint8(0, 4);
intView.setInt32(1, header.value, false);
return new Uint8Array(intView.buffer);
case "long":
const longBytes = new Uint8Array(9);
longBytes[0] = 5;
longBytes.set(header.value.bytes, 1);
return longBytes;
case "binary":
const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
binView.setUint8(0, 6);
binView.setUint16(1, header.value.byteLength, false);
const binBytes = new Uint8Array(binView.buffer);
binBytes.set(header.value, 3);
return binBytes;
case "string":
const utf8Bytes = fromUtf8(header.value);
const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
strView.setUint8(0, 7);
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;
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;
uuidBytes.set(fromHex(header.value.replace(/-/g, "")), 1);
return uuidBytes;
}
}
}
var HEADER_VALUE_TYPE;
(function(HEADER_VALUE_TYPE) {
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
class Int64 {
bytes;
constructor(bytes) {
this.bytes = bytes;
if (bytes.byteLength !== 8) {
throw new Error("Int64 buffers must be exactly 8 bytes");
}
}
static fromNumber(number) {
if (number > 9223372036854776000 || number < -9223372036854776000) {
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);
}
valueOf() {
const bytes = this.bytes.slice(0);
const negative = bytes[0] & 128;
if (negative) {
negate(bytes);
}
return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
}
toString() {
return String(this.valueOf());
}
}
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;
}
}
var ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
var SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
var EXPIRES_QUERY_PARAM = "X-Amz-Expires";
var SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
var TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
var REGION_SET_PARAM = "X-Amz-Region-Set";
var AUTH_HEADER = "authorization";
var AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
var DATE_HEADER = "date";
var GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
var SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
var SHA256_HEADER = "x-amz-content-sha256";
var TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
var HOST_HEADER = "host";
var ALWAYS_UNSIGNABLE_HEADERS = {
authorization: true,
"cache-control": true,
connection: true,
expect: true,
from: true,
"keep-alive": true,
"max-forwards": true,
pragma: true,
referer: true,
te: true,
trailer: true,
"transfer-encoding": true,
upgrade: true,
"user-agent": true,
"x-amzn-trace-id": true
};
var PROXY_HEADER_PATTERN = /^proxy-/;
var SEC_HEADER_PATTERN = /^sec-/;
var UNSIGNABLE_PATTERNS = [/^proxy-/i, /^sec-/i];
var ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
var ALGORITHM_IDENTIFIER_V4A = "AWS4-ECDSA-P256-SHA256";
var EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
var UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
var MAX_CACHE_SIZE = 50;
var KEY_TYPE_IDENTIFIER = "aws4_request";
var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
var getCanonicalQuery = ({ query = {} }) => {
const keys = [];
const serialized = {};
for (const key in query) {
if (!hasOwn(query, key))
continue;
if (key.toLowerCase() === SIGNATURE_HEADER) {
continue;
}
const encodedKey = escapeUri(key);
keys.push(encodedKey);
const value = query[key];
if (typeof value === "string") {
serialized[encodedKey] = `${encodedKey}=${escapeUri(value)}`;
} else if (Array.isArray(value)) {
serialized[encodedKey] = value.slice(0).reduce((encoded, value) => encoded.concat([`${encodedKey}=${escapeUri(value)}`]), []).sort().join("&");
}
}
return keys.sort().map((key) => serialized[key]).filter((serialized) => serialized).join("&");
};
var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
var toDate = (time) => {
if (typeof time === "number") {
return new Date(time * 1000);
}
if (typeof time === "string") {
if (Number(time)) {
return new Date(Number(time) * 1000);
}
return new Date(time);
}
return time;
};
class SignatureV4Base {
service;
regionProvider;
credentialProvider;
sha256;
uriEscapePath;
applyChecksum;
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
this.service = service;
this.sha256 = sha256;
this.uriEscapePath = uriEscapePath;
this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
this.regionProvider = normalizeProvider(region);
this.credentialProvider = normalizeProvider(credentials);
}
createCanonicalRequest(request, canonicalHeaders, payloadHash) {
const sortedHeaders = Object.keys(canonicalHeaders).sort();
return `${request.method}
${this.getCanonicalPath(request)}
${getCanonicalQuery(request)}
${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join(`
`)}
${sortedHeaders.join(";")}
${payloadHash}`;
}
async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) {
const hash = new this.sha256;
hash.update(toUint8Array(canonicalRequest));
const hashedRequest = await hash.digest();
return `${algorithmIdentifier}
${longDate}
${credentialScope}
${toHex(hashedRequest)}`;
}
getCanonicalPath({ path }) {
if (this.uriEscapePath) {
const normalizedPathSegments = [];
for (const pathSegment of path.split("/")) {
if (pathSegment?.length === 0)
continue;
if (pathSegment === ".")
continue;
if (pathSegment === "..") {
normalizedPathSegments.pop();
} else {
normalizedPathSegments.push(pathSegment);
}
}
const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
const doubleEncoded = escapeUri(normalizedPath);
return doubleEncoded.replace(/%2F/g, "/");
}
return path;
}
validateResolvedCredentials(credentials) {
if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
throw new Error("Resolved credential object is not valid");
}
}
formatDate(now) {
const longDate = iso8601(now).replace(/[-:]/g, "");
return {
longDate,
shortDate: longDate.slice(0, 8)
};
}
getCanonicalHeaderList(headers) {
return Object.keys(headers).sort().join(";");
}
}
var signingKeyCache = {};
var cacheQueue = [];
var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
var getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => {
const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId);
const cacheKey = `${shortDate}:${region}:${service}:${toHex(credsHash)}:${credentials.sessionToken}`;
if (cacheKey in signingKeyCache) {
return signingKeyCache[cacheKey];
}
cacheQueue.push(cacheKey);
while (cacheQueue.length > MAX_CACHE_SIZE) {
delete signingKeyCache[cacheQueue.shift()];
}
let key = `AWS4${credentials.secretAccessKey}`;
for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
key = await hmac(sha256Constructor, key, signable);
}
return signingKeyCache[cacheKey] = key;
};
var clearCredentialCache = () => {
cacheQueue.length = 0;
Object.keys(signingKeyCache).forEach((cacheKey) => {
delete signingKeyCache[cacheKey];
});
};
var hmac = (ctor, secret, data) => {
const hash = new ctor(secret);
hash.update(toUint8Array(data));
return hash.digest();
};
var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
const canonical = {};
for (const headerName of Object.keys(headers).sort()) {
if (headers[headerName] == undefined) {
continue;
}
const canonicalHeaderName = headerName.toLowerCase();
if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || unsignableHeaders?.has(canonicalHeaderName) || PROXY_HEADER_PATTERN.test(canonicalHeaderName) || SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
if (!signableHeaders || signableHeaders && !signableHeaders.has(canonicalHeaderName)) {
continue;
}
}
canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
}
return canonical;
};
var getPayloadHash = async ({ headers, body }, hashConstructor) => {
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
if (headerName.toLowerCase() === SHA256_HEADER) {
return headers[headerName];
}
}
if (body == undefined) {
return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
} else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer(body)) {
const hashCtor = new hashConstructor;
hashCtor.update(toUint8Array(body));
return toHex(await hashCtor.digest());
}
return UNSIGNED_PAYLOAD;
};
var hasHeader = (soughtHeader, headers) => {
soughtHeader = soughtHeader.toLowerCase();
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
if (soughtHeader === headerName.toLowerCase()) {
return true;
}
}
return false;
};
var moveHeadersToQuery = (request, options = {}) => {
const { headers, query = {} } = HttpRequest.clone(request);
for (const name in headers) {
if (!hasOwn(headers, name))
continue;
const lname = name.toLowerCase();
if (lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname) || options.hoistableHeaders?.has(lname)) {
query[name] = headers[name];
delete headers[name];
}
}
return {
...request,
headers,
query
};
};
var prepareRequest = (request) => {
request = HttpRequest.clone(request);
for (const headerName in request.headers) {
if (!hasOwn(request.headers, headerName))
continue;
if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
delete request.headers[headerName];
}
}
return request;
};
class SignatureV4 extends SignatureV4Base {
headerFormatter = new HeaderFormatter;
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
super({
applyChecksum,
credentials,
region,
service,
sha256,
uriEscapePath
});
}
async presign(originalRequest, options = {}) {
const { signingDate = new Date, expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
const credentials = await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const { longDate, shortDate } = this.formatDate(signingDate);
if (expiresIn > MAX_PRESIGNED_TTL) {
return Promise.reject("Signature version 4 presigned URLs" + " must have an expiration date less than one week in" + " the future");
}
const scope = createScope(shortDate, region, signingService ?? this.service);
const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
if (credentials.sessionToken) {
request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken;
}
request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`;
request.query[AMZ_DATE_QUERY_PARAM] = longDate;
request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
request.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders);
request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
return request;
}
async sign(toSign, options) {
if (typeof toSign === "string") {
return this.signString(toSign, options);
} else if (toSign.headers && toSign.payload) {
return this.signEvent(toSign, options);
} else if (toSign.message) {
return this.signMessage(toSign, options);
} else {
return this.signRequest(toSign, options);
}
}
async signEvent({ headers, payload }, { signingDate = new Date, priorSignature, signingRegion, signingService, eventStreamCredentials }) {
const region = signingRegion ?? await this.regionProvider();
const { shortDate, longDate } = this.formatDate(signingDate);
const scope = createScope(shortDate, region, signingService ?? this.service);
const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
const hash = new this.sha256;
hash.update(headers);
const hashedHeaders = toHex(await hash.digest());
const stringToSign = [
EVENT_ALGORITHM_IDENTIFIER,
longDate,
scope,
priorSignature,
hashedHeaders,
hashedPayload
].join(`
`);
return this.signString(stringToSign, {
signingDate,
signingRegion: region,
signingService,
eventStreamCredentials
});
}
async signMessage(signableMessage, { signingDate = new Date, signingRegion, signingService, eventStreamCredentials }) {
const promise = this.signEvent({
headers: this.headerFormatter.format(signableMessage.message.headers),
payload: signableMessage.message.body
}, {
signingDate,
signingRegion,
signingService,
priorSignature: signableMessage.priorSignature,
eventStreamCredentials
});
return promise.then((signature) => {
return { message: signableMessage.message, signature };
});
}
async signString(stringToSign, { signingDate = new Date, signingRegion, signingService, eventStreamCredentials } = {}) {
const credentials = eventStreamCredentials ?? await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const { shortDate } = this.formatDate(signingDate);
const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService));
hash.update(toUint8Array(stringToSign));
return toHex(await hash.digest());
}
async signRequest(requestToSign, { signingDate = new Date, signableHeaders, unsignableHeaders, signingRegion, signingService } = {}) {
const credentials = await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const request = prepareRequest(requestToSign);
const { longDate, shortDate } = this.formatDate(signingDate);
const scope = createScope(shortDate, region, signingService ?? this.service);
request.headers[AMZ_DATE_HEADER] = longDate;
if (credentials.sessionToken) {
request.headers[TOKEN_HEADER] = credentials.sessionToken;
}
const payloadHash = await getPayloadHash(request, this.sha256);
if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) {
request.headers[SHA256_HEADER] = payloadHash;
}
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash));
request.headers[AUTH_HEADER] = `${ALGORITHM_IDENTIFIER} ` + `Credential=${credentials.accessKeyId}/${scope}, ` + `SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, ` + `Signature=${signature}`;
return request;
}
async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER);
const hash = new this.sha256(await keyPromise);
hash.update(toUint8Array(stringToSign));
return toHex(await hash.digest());
}
getSigningKey(credentials, region, shortDate, service) {
return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
}
}
var signatureV4aContainer = {
SignatureV4a: null
};
exports.ALGORITHM_IDENTIFIER = ALGORITHM_IDENTIFIER;
exports.ALGORITHM_IDENTIFIER_V4A = ALGORITHM_IDENTIFIER_V4A;
exports.ALGORITHM_QUERY_PARAM = ALGORITHM_QUERY_PARAM;
exports.ALWAYS_UNSIGNABLE_HEADERS = ALWAYS_UNSIGNABLE_HEADERS;
exports.AMZ_DATE_HEADER = AMZ_DATE_HEADER;
exports.AMZ_DATE_QUERY_PARAM = AMZ_DATE_QUERY_PARAM;
exports.AUTH_HEADER = AUTH_HEADER;
exports.CREDENTIAL_QUERY_PARAM = CREDENTIAL_QUERY_PARAM;
exports.DATE_HEADER = DATE_HEADER;
exports.EVENT_ALGORITHM_IDENTIFIER = EVENT_ALGORITHM_IDENTIFIER;
exports.EXPIRES_QUERY_PARAM = EXPIRES_QUERY_PARAM;
exports.GENERATED_HEADERS = GENERATED_HEADERS;
exports.HOST_HEADER = HOST_HEADER;
exports.KEY_TYPE_IDENTIFIER = KEY_TYPE_IDENTIFIER;
exports.MAX_CACHE_SIZE = MAX_CACHE_SIZE;
exports.MAX_PRESIGNED_TTL = MAX_PRESIGNED_TTL;
exports.PROXY_HEADER_PATTERN = PROXY_HEADER_PATTERN;
exports.REGION_SET_PARAM = REGION_SET_PARAM;
exports.SEC_HEADER_PATTERN = SEC_HEADER_PATTERN;
exports.SHA256_HEADER = SHA256_HEADER;
exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
exports.SIGNATURE_QUERY_PARAM = SIGNATURE_QUERY_PARAM;
exports.SIGNED_HEADERS_QUERY_PARAM = SIGNED_HEADERS_QUERY_PARAM;
exports.SignatureV4 = SignatureV4;
exports.SignatureV4Base = SignatureV4Base;
exports.TOKEN_HEADER = TOKEN_HEADER;
exports.TOKEN_QUERY_PARAM = TOKEN_QUERY_PARAM;
exports.UNSIGNABLE_PATTERNS = UNSIGNABLE_PATTERNS;
exports.UNSIGNED_PAYLOAD = UNSIGNED_PAYLOAD;
exports.clearCredentialCache = clearCredentialCache;
exports.createScope = createScope;
exports.getCanonicalHeaders = getCanonicalHeaders;
exports.getCanonicalQuery = getCanonicalQuery;
exports.getPayloadHash = getPayloadHash;
exports.getSigningKey = getSigningKey;
exports.hasHeader = hasHeader;
exports.moveHeadersToQuery = moveHeadersToQuery;
exports.prepareRequest = prepareRequest;
exports.signatureV4aContainer = signatureV4aContainer;
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/httpAuthSchemes/index.js
var require_httpAuthSchemes = __commonJS(function(exports) {
var { ProviderError, booleanSelector, SelectorType, loadConfig } = require_config();
var { setCredentialFeature } = require_client2();
var { normalizeProvider, memoizeIdentityProvider, isIdentityExpired, doesIdentityRequireRefresh } = require_dist_cjs2();
var { SignatureV4 } = require_dist_cjs3();
var { HttpResponse, HttpRequest } = require_protocols();
var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
var getAgeHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.age ?? response.headers?.Age : undefined;
var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset, timeRequestSent, ageHeader) => {
if (ageHeader !== undefined) {
return currentSystemClockOffset;
}
const serverTime = Date.parse(clockTime);
const timeResponseReceived = Date.now();
if (timeRequestSent !== undefined && timeResponseReceived - timeRequestSent > 900000) {
return currentSystemClockOffset;
}
const candidateSkew = timeRequestSent !== undefined ? serverTime - (timeRequestSent + timeResponseReceived) / 2 : serverTime - timeResponseReceived;
return candidateSkew;
};
var throwSigningPropertyError = (name, property) => {
if (!property) {
throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
}
return property;
};
var validateSigningProperties = async (signingProperties) => {
const context = throwSigningPropertyError("context", signingProperties.context);
const config = throwSigningPropertyError("config", signingProperties.config);
const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
const signerFunction = throwSigningPropertyError("signer", config.signer);
const signer = await signerFunction(authScheme);
const signingRegion = signingProperties?.signingRegion;
const signingRegionSet = signingProperties?.signingRegionSet;
const signingName = signingProperties?.signingName;
return {
config,
signer,
signingRegion,
signingRegionSet,
signingName
};
};
class AwsSdkSigV4Signer {
async sign(httpRequest, identity, signingProperties) {
if (!HttpRequest.isInstance(httpRequest)) {
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
}
const validatedProps = await validateSigningProperties(signingProperties);
const { config, signer } = validatedProps;
let { signingRegion, signingName } = validatedProps;
const handlerExecutionContext = signingProperties.context;
if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
const [first, second] = handlerExecutionContext.authSchemes;
if (first?.name === "sigv4a" && second?.name === "sigv4") {
signingRegion = second?.signingRegion ?? signingRegion;
signingName = second?.signingName ?? signingName;
}
}
const noSkewCorrection = await config.disableClockSkewCorrection?.() === true;
signingProperties._disableClockSkewCorrection = noSkewCorrection;
if (!noSkewCorrection) {
signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
signingProperties._requestSentAt = Date.now();
}
const signedRequest = await signer.sign(httpRequest, {
signingDate: noSkewCorrection ? new Date : getSkewCorrectedDate(config.systemClockOffset),
signingRegion,
signingService: signingName
});
return signedRequest;
}
errorHandler(signingProperties) {
return (error) => {
const errorException = error;
if (!signingProperties._disableClockSkewCorrection) {
const serverTime = errorException.ServerTime ?? getDateHeader(errorException.$response);
if (serverTime) {
const config = throwSigningPropertyError("config", signingProperties.config);
const preRequestOffset = signingProperties._preRequestSystemClockOffset;
const timeRequestSent = signingProperties._requestSentAt;
const ageHeader = getAgeHeader(errorException.$response);
const newOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset, timeRequestSent, ageHeader);
config.systemClockOffset = newOffset;
const skewExceedsThreshold = Math.abs(newOffset) >= 240000;
const isLocalCorrection = newOffset !== preRequestOffset;
const isConcurrentCorrection = preRequestOffset !== undefined && preRequestOffset !== newOffset;
if (skewExceedsThreshold && (isLocalCorrection || isConcurrentCorrection) && errorException.$metadata) {
errorException.$metadata.clockSkewCorrected = true;
}
}
}
throw error;
};
}
successHandler(httpResponse, signingProperties) {
if (signingProperties._disableClockSkewCorrection) {
return;
}
const dateHeader = getDateHeader(httpResponse);
if (dateHeader) {
const config = throwSigningPropertyError("config", signingProperties.config);
const timeRequestSent = signingProperties._requestSentAt;
const ageHeader = getAgeHeader(httpResponse);
config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset, timeRequestSent, ageHeader);
}
}
}
var AWSSDKSigV4Signer = AwsSdkSigV4Signer;
class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer {
async sign(httpRequest, identity, signingProperties) {
if (!HttpRequest.isInstance(httpRequest)) {
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
}
const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.();
const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(",");
const noSkewCorrection = await config.disableClockSkewCorrection?.() === true;
signingProperties._disableClockSkewCorrection = noSkewCorrection;
if (!noSkewCorrection) {
signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
signingProperties._requestSentAt = Date.now();
}
const signedRequest = await signer.sign(httpRequest, {
signingDate: noSkewCorrection ? new Date : getSkewCorrectedDate(config.systemClockOffset),
signingRegion: multiRegionOverride,
signingService: signingName
});
return signedRequest;
}
}
var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
environmentVariableSelector: (env, options) => {
if (options?.signingName) {
const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
if (bearerTokenKey in env)
return ["httpBearerAuth"];
}
if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env))
return;
return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
},
configFileSelector: (profile) => {
if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
return;
return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
},
default: []
};
var resolveAwsSdkSigV4AConfig = (config) => {
config.sigv4aSigningRegionSet = normalizeProvider(config.sigv4aSigningRegionSet);
return config;
};
var NODE_SIGV4A_CONFIG_OPTIONS = {
environmentVariableSelector(env) {
if (env.AWS_SIGV4A_SIGNING_REGION_SET) {
return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
}
throw new ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
tryNextLink: true
});
},
configFileSelector(profile) {
if (profile.sigv4a_signing_region_set) {
return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
}
throw new ProviderError("sigv4a_signing_region_set not set in profile.", {
tryNextLink: true
});
},
default: undefined
};
var bindResolveAwsSdkSigV4Config = (defaultDisableClockSkewCorrection) => (config) => {
let inputCredentials = config.credentials;
let isUserSupplied = !!config.credentials;
let resolvedCredentials = undefined;
Object.defineProperty(config, "credentials", {
set(credentials) {
if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) {
isUserSupplied = true;
}
inputCredentials = credentials;
const memoizedProvider = normalizeCredentialProvider(config, {
credentials: inputCredentials,
credentialDefaultProvider: config.credentialDefaultProvider
});
const boundProvider = bindCallerConfig(config, memoizedProvider);
if (isUserSupplied && !boundProvider.attributed) {
const isCredentialObject = typeof inputCredentials === "object" && inputCredentials !== null;
resolvedCredentials = async (options) => {
const creds = await boundProvider(options);
const attributedCreds = creds;
if (isCredentialObject && (!attributedCreds.$source || Object.keys(attributedCreds.$source).length === 0)) {
return setCredentialFeature(attributedCreds, "CREDENTIALS_CODE", "e");
}
return attributedCreds;
};
resolvedCredentials.memoized = boundProvider.memoized;
resolvedCredentials.configBound = boundProvider.configBound;
resolvedCredentials.attributed = true;
} else {
resolvedCredentials = boundProvider;
}
},
get() {
return resolvedCredentials;
},
enumerable: true,
configurable: true
});
config.credentials = inputCredentials;
const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256 } = config;
let signer;
if (config.signer) {
signer = normalizeProvider(config.signer);
} else if (config.regionInfoProvider) {
signer = () => normalizeProvider(config.region)().then(async (region) => [
await config.regionInfoProvider(region, {
useFipsEndpoint: await config.useFipsEndpoint(),
useDualstackEndpoint: await config.useDualstackEndpoint()
}) || {},
region
]).then(([regionInfo, region]) => {
const { signingRegion, signingService } = regionInfo;
config.signingRegion = config.signingRegion || signingRegion || region;
config.signingName = config.signingName || signingService || config.serviceId;
const params = {
...config,
credentials: config.credentials,
region: config.signingRegion,
service: config.signingName,
sha256,
uriEscapePath: signingEscapePath
};
const SignerCtor = config.signerConstructor || SignatureV4;
return new SignerCtor(params);
});
} else {
signer = async (authScheme) => {
authScheme = Object.assign({}, {
name: "sigv4",
signingName: config.signingName || config.defaultSigningName,
signingRegion: await normalizeProvider(config.region)(),
properties: {}
}, authScheme);
const signingRegion = authScheme.signingRegion;
const signingService = authScheme.signingName;
config.signingRegion = config.signingRegion || signingRegion;
config.signingName = config.signingName || signingService || config.serviceId;
const params = {
...config,
credentials: config.credentials,
region: config.signingRegion,
service: config.signingName,
sha256,
uriEscapePath: signingEscapePath
};
const SignerCtor = config.signerConstructor || SignatureV4;
return new SignerCtor(params);
};
}
const resolvedConfig = Object.assign(config, {
systemClockOffset,
signingEscapePath,
signer,
disableClockSkewCorrection: normalizeProvider(config.disableClockSkewCorrection ?? defaultDisableClockSkewCorrection)
});
return resolvedConfig;
};
function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider }) {
let credentialsProvider;
if (credentials) {
if (!credentials?.memoized) {
credentialsProvider = memoizeIdentityProvider(credentials, isIdentityExpired, doesIdentityRequireRefresh);
} else {
credentialsProvider = credentials;
}
} else {
if (credentialDefaultProvider) {
credentialsProvider = normalizeProvider(credentialDefaultProvider(Object.assign({}, config, {
parentClientConfig: config
})));
} else {
credentialsProvider = async () => {
throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
};
}
}
credentialsProvider.memoized = true;
return credentialsProvider;
}
function bindCallerConfig(config, credentialsProvider) {
if (credentialsProvider.configBound) {
return credentialsProvider;
}
const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
fn.memoized = credentialsProvider.memoized;
fn.configBound = true;
return fn;
}
var ENV_DISABLE_CLOCK_SKEW_CORRECTION = "AWS_DISABLE_CLOCK_SKEW_CORRECTION";
var CONFIG_DISABLE_CLOCK_SKEW_CORRECTION = "disable_clock_skew_correction";
var NODE_DISABLE_CLOCK_SKEW_CORRECTION_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_DISABLE_CLOCK_SKEW_CORRECTION, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_DISABLE_CLOCK_SKEW_CORRECTION, SelectorType.CONFIG),
default: false
};
var DEFAULT_DISABLE_CLOCK_SKEW_CORRECTION = loadConfig(NODE_DISABLE_CLOCK_SKEW_CORRECTION_CONFIG_OPTIONS);
var resolveAwsSdkSigV4Config = bindResolveAwsSdkSigV4Config(DEFAULT_DISABLE_CLOCK_SKEW_CORRECTION);
var resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;
exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer;
exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner;
exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer;
exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS;
exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS;
exports.getBearerTokenEnvKey = getBearerTokenEnvKey;
exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config;
exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig;
exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config;
exports.validateSigningProperties = validateSigningProperties;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.70/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
var import_client4, import_config, ENV_KEY = "AWS_ACCESS_KEY_ID", ENV_SECRET = "AWS_SECRET_ACCESS_KEY", ENV_SESSION = "AWS_SESSION_TOKEN", ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION", ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE", ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID", fromEnv = (init) => async () => {
init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
const accessKeyId = process.env[ENV_KEY];
const secretAccessKey = process.env[ENV_SECRET];
const sessionToken = process.env[ENV_SESSION];
const expiry = process.env[ENV_EXPIRATION];
const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
const accountId = process.env[ENV_ACCOUNT_ID];
if (accessKeyId && secretAccessKey) {
const credentials = {
accessKeyId,
secretAccessKey,
...sessionToken && { sessionToken },
...expiry && { expiration: new Date(expiry) },
...credentialScope && { credentialScope },
...accountId && { accountId }
};
import_client4.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
return credentials;
}
throw new import_config.CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
};
var init_fromEnv = __esm(() => {
import_client4 = __toESM(require_client2());
import_config = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.70/node_modules/@aws-sdk/credential-provider-env/dist-es/index.js
var init_dist_es = __esm(() => {
init_fromEnv();
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/ImdsCredentials.js
var isImdsCredentials = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.AccessKeyId === "string" && typeof arg.SecretAccessKey === "string" && typeof arg.Token === "string" && typeof arg.Expiration === "string", fromImdsCredentials = (creds) => ({
accessKeyId: creds.AccessKeyId,
secretAccessKey: creds.SecretAccessKey,
sessionToken: creds.Token,
expiration: new Date(creds.Expiration),
...creds.AccountId && { accountId: creds.AccountId }
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/RemoteProviderInit.js
var DEFAULT_TIMEOUT = 1000, DEFAULT_MAX_RETRIES = 0, providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT }) => ({ maxRetries, timeout });
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/node-http.js
import node_http from "http";
var init_node_http = () => {};
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js
function httpRequest(options) {
return new Promise((resolve, reject) => {
const req = node_http.request({
method: "GET",
...options,
hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
});
req.on("error", (err) => {
reject(Object.assign(new import_config2.ProviderError("Unable to connect to instance metadata service"), err));
req.destroy();
});
req.on("timeout", () => {
reject(new import_config2.ProviderError("TimeoutError from instance metadata service"));
req.destroy();
});
req.on("response", (res) => {
const { statusCode = 400 } = res;
if (statusCode < 200 || 300 <= statusCode) {
reject(Object.assign(new import_config2.ProviderError("Error response received from instance metadata service"), { statusCode }));
req.destroy();
}
const chunks = [];
res.on("data", (chunk) => {
chunks.push(chunk);
});
res.on("end", () => {
resolve(Buffer.concat(chunks));
req.destroy();
});
});
req.end();
});
}
var import_config2;
var init_httpRequest = __esm(() => {
init_node_http();
import_config2 = __toESM(require_config());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/retry.js
var retry = (toRetry, maxRetries) => {
let promise = toRetry();
for (let i = 0;i < maxRetries; i++) {
promise = promise.catch(toRetry);
}
return promise;
};
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js
var import_config3, ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromContainerMetadata = (init = {}) => {
const { timeout, maxRetries } = providerConfigFromInit(init);
return () => retry(async () => {
const requestOptions = await getCmdsUri({ logger: init.logger });
const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions));
if (!isImdsCredentials(credsResponse)) {
throw new import_config3.CredentialsProviderError("Invalid response received from instance metadata service.", {
logger: init.logger
});
}
return fromImdsCredentials(credsResponse);
}, maxRetries);
}, requestFromEcsImds = async (timeout, options) => {
if (process.env[ENV_CMDS_AUTH_TOKEN]) {
options.headers = {
...options.headers,
Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
};
}
const buffer = await httpRequest({
...options,
timeout
});
return buffer.toString();
}, CMDS_IP = "169.254.170.2", GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri = async ({ logger }) => {
if (process.env[ENV_CMDS_RELATIVE_URI]) {
return {
hostname: CMDS_IP,
path: process.env[ENV_CMDS_RELATIVE_URI]
};
}
if (process.env[ENV_CMDS_FULL_URI]) {
let parsed;
try {
parsed = new URL(process.env[ENV_CMDS_FULL_URI]);
} catch {
throw new import_config3.CredentialsProviderError(`${process.env[ENV_CMDS_FULL_URI]} is not a valid container metadata service URL`, { tryNextLink: false, logger });
}
if (!parsed.hostname || !GREENGRASS_HOSTS.has(parsed.hostname)) {
throw new import_config3.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
tryNextLink: false,
logger
});
}
if (!parsed.protocol || !GREENGRASS_PROTOCOLS.has(parsed.protocol)) {
throw new import_config3.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
tryNextLink: false,
logger
});
}
return {
protocol: parsed.protocol,
hostname: parsed.hostname,
path: parsed.pathname + parsed.search,
port: parsed.port ? parseInt(parsed.port, 10) : undefined
};
}
throw new import_config3.CredentialsProviderError("The container metadata credential provider cannot be used unless" + ` the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment` + " variable is set", {
tryNextLink: false,
logger
});
};
var init_fromContainerMetadata = __esm(() => {
init_httpRequest();
import_config3 = __toESM(require_config());
GREENGRASS_HOSTS = new Set(["localhost", "127.0.0.1"]);
GREENGRASS_PROTOCOLS = new Set(["http:", "https:"]);
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/error/InstanceMetadataV1FallbackError.js
var import_config4, InstanceMetadataV1FallbackError;
var init_InstanceMetadataV1FallbackError = __esm(() => {
import_config4 = __toESM(require_config());
InstanceMetadataV1FallbackError = class InstanceMetadataV1FallbackError extends import_config4.CredentialsProviderError {
tryNextLink;
name = "InstanceMetadataV1FallbackError";
constructor(message, tryNextLink = true) {
super(message, tryNextLink);
this.tryNextLink = tryNextLink;
Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype);
}
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/Endpoint.js
var Endpoint;
var init_Endpoint = __esm(() => {
(function(Endpoint) {
Endpoint["IPv4"] = "http://169.254.169.254";
Endpoint["IPv6"] = "http://[fd00:ec2::254]";
})(Endpoint || (Endpoint = {}));
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointConfigOptions.js
var ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT", CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint", ENDPOINT_CONFIG_OPTIONS;
var init_EndpointConfigOptions = __esm(() => {
ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME],
configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
default: undefined
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointMode.js
var EndpointMode;
var init_EndpointMode = __esm(() => {
(function(EndpointMode) {
EndpointMode["IPv4"] = "IPv4";
EndpointMode["IPv6"] = "IPv6";
})(EndpointMode || (EndpointMode = {}));
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointModeConfigOptions.js
var ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE", CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode", ENDPOINT_MODE_CONFIG_OPTIONS;
var init_EndpointModeConfigOptions = __esm(() => {
init_EndpointMode();
ENDPOINT_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME],
configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
default: EndpointMode.IPv4
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/getInstanceMetadataEndpoint.js
var import_config5, import_protocols, getInstanceMetadataEndpoint = async () => import_protocols.parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig()), getFromEndpointConfig = async () => import_config5.loadConfig(ENDPOINT_CONFIG_OPTIONS)(), getFromEndpointModeConfig = async () => {
const endpointMode = await import_config5.loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)();
switch (endpointMode) {
case EndpointMode.IPv4:
return Endpoint.IPv4;
case EndpointMode.IPv6:
return Endpoint.IPv6;
default:
throw new Error(`Unsupported endpoint mode: ${endpointMode}.` + ` Select from ${Object.values(EndpointMode)}`);
}
};
var init_getInstanceMetadataEndpoint = __esm(() => {
init_Endpoint();
init_EndpointConfigOptions();
init_EndpointMode();
init_EndpointModeConfigOptions();
import_config5 = __toESM(require_config());
import_protocols = __toESM(require_protocols());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/getExtendedInstanceMetadataCredentials.js
var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html", getExtendedInstanceMetadataCredentials = (credentials, logger) => {
const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
const newExpiration = new Date(Date.now() + refreshInterval * 1000);
logger.warn("Attempting credential expiration extension due to a credential service availability issue. A refresh of these " + `credentials will be attempted after ${new Date(newExpiration)}.
For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
return {
...credentials,
...originalExpiration ? { originalExpiration } : {},
expiration: newExpiration
};
};
var init_getExtendedInstanceMetadataCredentials = __esm(() => {
STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/staticStabilityProvider.js
var staticStabilityProvider = (provider, options = {}) => {
const logger = options?.logger || console;
let pastCredentials;
return async () => {
let credentials;
try {
credentials = await provider();
if (credentials.expiration && credentials.expiration.getTime() < Date.now()) {
credentials = getExtendedInstanceMetadataCredentials(credentials, logger);
}
} catch (e) {
if (pastCredentials) {
logger.warn("Credential renew failed: ", e);
credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger);
} else {
throw e;
}
}
pastCredentials = credentials;
return credentials;
};
};
var init_staticStabilityProvider = __esm(() => {
init_getExtendedInstanceMetadataCredentials();
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/fromInstanceMetadata.js
var import_config6, IMDS_PATH = "/latest/meta-data/iam/security-credentials/", IMDS_TOKEN_PATH = "/latest/api/token", AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED", PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled", X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token", fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }), getInstanceMetadataProvider = (init = {}) => {
let disableFetchToken = false;
const { logger, profile } = init;
const { timeout, maxRetries } = providerConfigFromInit(init);
const getCredentials = async (maxRetries, options) => {
const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
if (isImdsV1Fallback) {
let fallbackBlockedFromProfile = false;
let fallbackBlockedFromProcessEnv = false;
const configValue = await import_config6.loadConfig({
environmentVariableSelector: (env) => {
const envValue = env[AWS_EC2_METADATA_V1_DISABLED];
fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
if (envValue === undefined) {
throw new import_config6.CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });
}
return fallbackBlockedFromProcessEnv;
},
configFileSelector: (profile) => {
const profileValue = profile[PROFILE_AWS_EC2_METADATA_V1_DISABLED];
fallbackBlockedFromProfile = !!profileValue && profileValue !== "false";
return fallbackBlockedFromProfile;
},
default: false
}, {
profile
})();
if (init.ec2MetadataV1Disabled || configValue) {
const causes = [];
if (init.ec2MetadataV1Disabled)
causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
if (fallbackBlockedFromProfile)
causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);
if (fallbackBlockedFromProcessEnv)
causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);
throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`);
}
}
const imdsProfile = (await retry(async () => {
let profile;
try {
profile = await getProfile(options);
} catch (err) {
if (err.statusCode === 401) {
disableFetchToken = false;
}
throw err;
}
return profile;
}, maxRetries)).trim();
return retry(async () => {
let creds;
try {
creds = await getCredentialsFromProfile(imdsProfile, options, init);
} catch (err) {
if (err.statusCode === 401) {
disableFetchToken = false;
}
throw err;
}
return creds;
}, maxRetries);
};
return async () => {
const endpoint = await getInstanceMetadataEndpoint();
if (disableFetchToken) {
logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
return getCredentials(maxRetries, { ...endpoint, timeout });
} else {
let token;
try {
token = (await getMetadataToken({ ...endpoint, timeout })).toString();
} catch (error) {
if (error?.statusCode === 400) {
throw Object.assign(error, {
message: "EC2 Metadata token request returned error"
});
} else if (error.message === "TimeoutError" || [403, 404, 405].includes(error.statusCode)) {
disableFetchToken = true;
}
logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
return getCredentials(maxRetries, { ...endpoint, timeout });
}
return getCredentials(maxRetries, {
...endpoint,
headers: {
[X_AWS_EC2_METADATA_TOKEN]: token
},
timeout
});
}
};
}, getMetadataToken = async (options) => httpRequest({
...options,
path: IMDS_TOKEN_PATH,
method: "PUT",
headers: {
"x-aws-ec2-metadata-token-ttl-seconds": "21600"
}
}), getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString(), getCredentialsFromProfile = async (profile, options, init) => {
const credentialsResponse = JSON.parse((await httpRequest({
...options,
path: IMDS_PATH + profile
})).toString());
if (!isImdsCredentials(credentialsResponse)) {
throw new import_config6.CredentialsProviderError("Invalid response received from instance metadata service.", {
logger: init.logger
});
}
return fromImdsCredentials(credentialsResponse);
};
var init_fromInstanceMetadata = __esm(() => {
init_InstanceMetadataV1FallbackError();
init_httpRequest();
init_getInstanceMetadataEndpoint();
init_staticStabilityProvider();
import_config6 = __toESM(require_config());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/index.js
var init_dist_es2 = __esm(() => {
init_fromContainerMetadata();
init_fromInstanceMetadata();
});
// ../../node_modules/.bun/@smithy+node-http-handler@4.12.1/node_modules/@smithy/node-http-handler/dist-cjs/index.js
var require_dist_cjs4 = __commonJS(function(exports) {
var { hasOwn } = require_serde();
var { streamCollector } = require_serde();
exports.streamCollector = streamCollector;
var { buildQueryString, HttpResponse } = require_protocols();
var node_https = __require("https");
var { Readable } = __require("stream");
var http2 = __require("http2");
function buildAbortError(abortSignal) {
const reason = abortSignal && typeof abortSignal === "object" && "reason" in abortSignal ? abortSignal.reason : undefined;
if (reason) {
if (reason instanceof Error) {
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
abortError.cause = reason;
return abortError;
}
const abortError = new Error(String(reason));
abortError.name = "AbortError";
return abortError;
}
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
return abortError;
}
var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
var getTransformedHeaders = (headers) => {
const transformedHeaders = {};
for (const name in headers) {
if (!hasOwn(headers, name))
continue;
const headerValues = headers[name];
transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
}
return transformedHeaders;
};
var timing = {
setTimeout: (cb, ms) => setTimeout(cb, ms),
clearTimeout: (timeoutId) => clearTimeout(timeoutId)
};
var DEFER_EVENT_LISTENER_TIME$2 = 1000;
var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
if (!timeoutInMs) {
return -1;
}
const registerTimeout = (offset) => {
const timeoutId = timing.setTimeout(() => {
request.destroy();
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
name: "TimeoutError"
}));
}, timeoutInMs - offset);
const doWithSocket = (socket) => {
if (socket?.connecting) {
socket.on("connect", () => {
timing.clearTimeout(timeoutId);
});
} else {
timing.clearTimeout(timeoutId);
}
};
if (request.socket) {
doWithSocket(request.socket);
} else {
request.on("socket", doWithSocket);
}
};
if (timeoutInMs < 2000) {
registerTimeout(0);
return 0;
}
return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
};
var setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
if (timeoutInMs) {
return timing.setTimeout(() => {
let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
if (throwOnRequestTimeout) {
const error = Object.assign(new Error(msg), {
name: "TimeoutError",
code: "ETIMEDOUT"
});
req.destroy(error);
reject(error);
} else {
msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
logger?.warn?.(msg);
}
}, timeoutInMs);
}
return -1;
};
var DEFER_EVENT_LISTENER_TIME$1 = 3000;
var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => {
if (keepAlive !== true) {
return -1;
}
const registerListener = () => {
if (request.socket) {
request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
} else {
request.on("socket", (socket) => {
socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
});
}
};
if (deferTimeMs === 0) {
registerListener();
return 0;
}
return timing.setTimeout(registerListener, deferTimeMs);
};
var DEFER_EVENT_LISTENER_TIME = 3000;
var setSocketTimeout = (request, reject, timeoutInMs = 0) => {
const registerTimeout = (offset) => {
const timeout = timeoutInMs - offset;
const onTimeout = () => {
request.destroy();
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
};
if (request.socket) {
request.socket.setTimeout(timeout, onTimeout);
request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
} else {
request.setTimeout(timeout, onTimeout);
}
};
if (0 < timeoutInMs && timeoutInMs < 6000) {
registerTimeout(0);
return 0;
}
return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
};
var MIN_WAIT_TIME = 6000;
async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
const headers = request.headers;
const expect = headers ? headers.Expect || headers.expect : undefined;
let timeoutId = -1;
let sendBody = true;
if (!externalAgent && expect === "100-continue") {
sendBody = await Promise.race([
new Promise((resolve) => {
timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
}),
new Promise((resolve) => {
httpRequest.on("continue", () => {
timing.clearTimeout(timeoutId);
resolve(true);
});
httpRequest.on("response", () => {
timing.clearTimeout(timeoutId);
resolve(false);
});
httpRequest.on("error", () => {
timing.clearTimeout(timeoutId);
resolve(false);
});
})
]);
}
if (sendBody) {
writeBody(httpRequest, request.body);
}
}
function writeBody(httpRequest, body) {
if (body instanceof Readable) {
body.pipe(httpRequest);
return;
}
if (body) {
const isBuffer = Buffer.isBuffer(body);
const isString = typeof body === "string";
if (isBuffer || isString) {
if (isBuffer && body.byteLength === 0) {
httpRequest.end();
} else {
httpRequest.end(body);
}
return;
}
const uint8 = body;
if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
return;
}
httpRequest.end(Buffer.from(body));
return;
}
httpRequest.end();
}
var DEFAULT_REQUEST_TIMEOUT = 0;
var hAgent = undefined;
var hRequest = undefined;
class NodeHttpHandler {
config;
configProvider;
socketWarningTimestamp = 0;
externalAgent = false;
metadata = { handlerProtocol: "http/1.1" };
static create(instanceOrOptions) {
if (typeof instanceOrOptions?.handle === "function") {
return instanceOrOptions;
}
return new NodeHttpHandler(instanceOrOptions);
}
static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
const { sockets, requests, maxSockets } = agent;
if (typeof maxSockets !== "number" || maxSockets === Infinity) {
return socketWarningTimestamp;
}
const interval = 15000;
if (Date.now() - interval < socketWarningTimestamp) {
return socketWarningTimestamp;
}
if (sockets && requests) {
for (const origin in sockets) {
if (!hasOwn(sockets, origin))
continue;
const socketsInUse = sockets[origin]?.length ?? 0;
const requestsEnqueued = requests[origin]?.length ?? 0;
if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
return Date.now();
}
}
}
return socketWarningTimestamp;
}
constructor(options) {
this.configProvider = new Promise((resolve, reject) => {
if (typeof options === "function") {
options().then((_options) => {
resolve(this.resolveDefaultConfig(_options));
}).catch(reject);
} else {
resolve(this.resolveDefaultConfig(options));
}
});
}
destroy() {
this.config?.httpAgent?.destroy();
this.config?.httpsAgent?.destroy();
}
async handle(request2, { abortSignal, requestTimeout } = {}) {
if (!this.config) {
this.config = await this.configProvider;
}
const config = this.config;
const logger = config.logger;
const isSSL = request2.protocol === "https:";
if (!isSSL && !this.config.httpAgent) {
this.config.httpAgent = await this.config.httpAgentProvider();
}
return new Promise((_resolve, _reject) => {
let writeRequestBodyPromise = undefined;
let socketWarningTimeoutId = -1;
let connectionTimeoutId = -1;
let requestTimeoutId = -1;
let socketTimeoutId = -1;
let keepAliveTimeoutId = -1;
const clearTimeouts = () => {
timing.clearTimeout(socketWarningTimeoutId);
timing.clearTimeout(connectionTimeoutId);
timing.clearTimeout(requestTimeoutId);
timing.clearTimeout(socketTimeoutId);
timing.clearTimeout(keepAliveTimeoutId);
};
const resolve = async (arg) => {
await writeRequestBodyPromise;
clearTimeouts();
_resolve(arg);
};
const reject = async (arg) => {
await writeRequestBodyPromise;
clearTimeouts();
_reject(arg);
};
if (abortSignal?.aborted) {
const abortError = buildAbortError(abortSignal);
reject(abortError);
return;
}
const headers = request2.headers;
const expectContinue = headers ? (headers.Expect ?? headers.expect) === "100-continue" : false;
let agent = isSSL ? config.httpsAgent : config.httpAgent;
if (expectContinue && !this.externalAgent) {
agent = new (isSSL ? node_https.Agent : hAgent)({
keepAlive: false,
maxSockets: Infinity
});
}
socketWarningTimeoutId = timing.setTimeout(() => {
this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, logger);
}, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000));
const queryString = request2.query ? buildQueryString(request2.query) : "";
let auth = undefined;
if (request2.username != null || request2.password != null) {
const username = request2.username ?? "";
const password = request2.password ?? "";
auth = `${username}:${password}`;
}
let path = request2.path;
if (queryString) {
path += `?${queryString}`;
}
if (request2.fragment) {
path += `#${request2.fragment}`;
}
let hostname = request2.hostname ?? "";
if (hostname[0] === "[" && hostname.endsWith("]")) {
hostname = request2.hostname.slice(1, -1);
} else {
hostname = request2.hostname;
}
const nodeHttpsOptions = {
headers: request2.headers,
host: hostname,
method: request2.method,
path,
port: request2.port,
agent,
auth
};
const requestFunc = isSSL ? node_https.request : hRequest;
const req = requestFunc(nodeHttpsOptions, (res) => {
const httpResponse = new HttpResponse({
statusCode: res.statusCode || -1,
reason: res.statusMessage,
headers: getTransformedHeaders(res.headers),
body: res
});
resolve({ response: httpResponse });
});
req.on("error", (err) => {
if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
reject(Object.assign(err, { name: "TimeoutError" }));
} else {
reject(err);
}
});
if (abortSignal) {
const onAbort = () => {
req.destroy();
const abortError = buildAbortError(abortSignal);
reject(abortError);
};
if (typeof abortSignal.addEventListener === "function") {
const signal = abortSignal;
signal.addEventListener("abort", onAbort, { once: true });
req.once("close", () => signal.removeEventListener("abort", onAbort));
} else {
abortSignal.onabort = onAbort;
}
}
const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
connectionTimeoutId = setConnectionTimeout(req, reject, config.connectionTimeout);
requestTimeoutId = setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, logger ?? console);
socketTimeoutId = setSocketTimeout(req, reject, config.socketTimeout);
const httpAgent = nodeHttpsOptions.agent;
if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
keepAliveTimeoutId = setSocketKeepAlive(req, {
keepAlive: httpAgent.keepAlive,
keepAliveMsecs: httpAgent.keepAliveMsecs
});
}
writeRequestBodyPromise = writeRequestBody(req, request2, effectiveRequestTimeout, this.externalAgent).catch((e) => {
clearTimeouts();
return _reject(e);
});
});
}
updateHttpClientConfig(key, value) {
this.config = undefined;
this.configProvider = this.configProvider.then((config) => {
if (key === Symbol.for("logger")) {
return {
...config,
logger: config.logger ?? value
};
}
return {
...config,
[key]: value
};
});
}
httpHandlerConfigs() {
return this.config ?? {};
}
resolveDefaultConfig(options) {
const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger } = options || {};
const keepAlive = true;
const maxSockets = 50;
return {
connectionTimeout,
requestTimeout,
socketTimeout,
socketAcquisitionWarningTimeout,
throwOnRequestTimeout,
httpAgentProvider: async () => {
const node_http = __require("http");
const { Agent, request } = node_http.default ?? node_http;
hRequest = request;
hAgent = Agent;
if (httpAgent instanceof hAgent || typeof httpAgent?.destroy === "function") {
this.externalAgent = true;
return httpAgent;
}
return new hAgent({ keepAlive, maxSockets, ...httpAgent });
},
httpsAgent: (() => {
if (httpsAgent instanceof node_https.Agent || typeof httpsAgent?.destroy === "function") {
this.externalAgent = true;
return httpsAgent;
}
return new node_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
})(),
logger
};
}
}
var ids = new Uint16Array(1);
class ClientHttp2SessionRef {
id = ids[0]++;
total = 0;
max = 0;
session;
refs = 0;
constructor(session) {
session.unref();
this.session = session;
}
retain() {
if (this.session.destroyed) {
throw new Error("@smithy/node-http-handler - cannot acquire reference to destroyed session.");
}
this.refs += 1;
this.total += 1;
this.max = Math.max(this.refs, this.max);
this.session.ref();
}
free() {
if (this.session.destroyed) {
return;
}
this.refs -= 1;
if (this.refs === 0) {
this.session.unref();
}
if (this.refs < 0) {
throw new Error("@smithy/node-http-handler - ClientHttp2Session refcount at zero, cannot decrement.");
}
}
deref() {
return this.session;
}
close() {
if (!this.session.closed) {
this.session.close();
}
}
destroy() {
this.refs = 0;
if (!this.session.destroyed) {
this.session.setTimeout(0);
this.session.destroy();
}
}
useCount() {
return this.refs;
}
}
class NodeHttp2ConnectionPool {
sessions = [];
maxConcurrency = 0;
constructor(sessions) {
this.sessions = (sessions ?? []).map((session) => new ClientHttp2SessionRef(session));
}
poll() {
let cleanup = false;
for (const session of this.sessions) {
if (session.deref().destroyed) {
cleanup = true;
continue;
}
if (!this.maxConcurrency || session.useCount() < this.maxConcurrency) {
return session;
}
}
if (cleanup) {
for (const session of this.sessions) {
if (session.deref().destroyed) {
this.remove(session);
}
}
}
}
offerLast(ref) {
this.sessions.push(ref);
}
remove(ref) {
const ix = this.sessions.indexOf(ref);
if (ix > -1) {
this.sessions.splice(ix, 1);
}
}
[Symbol.iterator]() {
return this.sessions[Symbol.iterator]();
}
setMaxConcurrency(maxConcurrency) {
this.maxConcurrency = maxConcurrency;
}
destroy(ref) {
this.remove(ref);
ref.destroy();
}
}
class NodeHttp2ConnectionManager {
config;
connectOptions;
connectionPools = new Map;
constructor(config) {
this.config = config;
if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
throw new RangeError("maxConcurrency must be greater than zero.");
}
}
lease(requestContext, connectionConfiguration) {
const url = this.getUrlString(requestContext);
const pool = this.getPool(url);
if (!this.config.disableConcurrency && !connectionConfiguration.isEventStream) {
const available = pool.poll();
if (available) {
available.retain();
return available;
}
}
const ref = new ClientHttp2SessionRef(this.connect(url));
const session = ref.deref();
if (this.config.maxConcurrency) {
session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
if (err) {
throw new Error("Fail to set maxConcurrentStreams to " + this.config.maxConcurrency + "when creating new session for " + requestContext.destination.toString());
}
});
}
const graceful = () => {
this.removeFromPoolAndClose(url, ref);
};
const ensureDestroyed = () => {
this.removeFromPoolAndCheckedDestroy(url, ref);
};
session.on("goaway", graceful);
session.on("error", ensureDestroyed);
session.on("frameError", ensureDestroyed);
session.on("close", ensureDestroyed);
if (connectionConfiguration.requestTimeout) {
session.setTimeout(connectionConfiguration.requestTimeout, ensureDestroyed);
}
pool.offerLast(ref);
ref.retain();
return ref;
}
release(_requestContext, ref) {
ref.free();
}
createIsolatedSession(requestContext, connectionConfiguration) {
const url = this.getUrlString(requestContext);
const ref = new ClientHttp2SessionRef(this.connect(url));
const session = ref.deref();
session.settings({ maxConcurrentStreams: 1 });
const ensureDestroyed = () => {
ref.destroy();
};
session.on("error", ensureDestroyed);
session.on("frameError", ensureDestroyed);
session.on("close", ensureDestroyed);
const timeout = connectionConfiguration.requestTimeout ?? 300000;
session.setTimeout(timeout, ensureDestroyed);
ref.retain();
return ref;
}
destroy() {
for (const [url, connectionPool] of this.connectionPools) {
for (const session of [...connectionPool]) {
session.destroy();
}
this.connectionPools.delete(url);
}
}
setMaxConcurrentStreams(maxConcurrentStreams) {
if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
throw new RangeError("maxConcurrentStreams must be greater than zero.");
}
this.config.maxConcurrency = maxConcurrentStreams;
for (const pool of this.connectionPools.values()) {
pool.setMaxConcurrency(maxConcurrentStreams);
}
}
setDisableConcurrentStreams(disableConcurrentStreams) {
this.config.disableConcurrency = disableConcurrentStreams;
}
setNodeHttp2ConnectOptions(nodeHttp2ConnectOptions) {
this.connectOptions = nodeHttp2ConnectOptions;
}
debug() {
const pools = {};
for (const [url, pool] of this.connectionPools) {
const sessions = [];
for (const ref of pool) {
sessions.push({
id: ref.id,
active: ref.useCount(),
maxConcurrent: ref.max,
totalRequests: ref.total
});
}
pools[url] = { sessions };
}
return pools;
}
removeFromPoolAndClose(authority, ref) {
this.connectionPools.get(authority)?.remove(ref);
ref.close();
}
removeFromPoolAndCheckedDestroy(authority, ref) {
this.connectionPools.get(authority)?.remove(ref);
ref.destroy();
}
getPool(url) {
if (!this.connectionPools.has(url)) {
const pool = new NodeHttp2ConnectionPool;
if (this.config.maxConcurrency) {
pool.setMaxConcurrency(this.config.maxConcurrency);
}
this.connectionPools.set(url, pool);
}
return this.connectionPools.get(url);
}
getUrlString(request) {
return request.destination.toString();
}
connect(url) {
return this.connectOptions === undefined ? http2.connect(url) : http2.connect(url, this.connectOptions);
}
}
var { constants } = http2;
class NodeHttp2Handler {
config;
configProvider;
metadata = { handlerProtocol: "h2" };
connectionManager = new NodeHttp2ConnectionManager({});
static create(instanceOrOptions) {
if (typeof instanceOrOptions?.handle === "function") {
return instanceOrOptions;
}
return new NodeHttp2Handler(instanceOrOptions);
}
constructor(options) {
this.configProvider = new Promise((resolve, reject) => {
if (typeof options === "function") {
options().then((opts) => {
resolve(opts || {});
}).catch(reject);
} else {
resolve(options || {});
}
});
}
destroy() {
this.connectionManager.destroy();
}
async handle(request, { abortSignal, requestTimeout, isEventStream } = {}) {
if (!this.config) {
this.config = await this.configProvider;
const { disableConcurrentStreams, maxConcurrentStreams, nodeHttp2ConnectOptions } = this.config;
this.connectionManager.setDisableConcurrentStreams(disableConcurrentStreams ?? false);
if (maxConcurrentStreams) {
this.connectionManager.setMaxConcurrentStreams(maxConcurrentStreams);
}
if (nodeHttp2ConnectOptions) {
this.connectionManager.setNodeHttp2ConnectOptions(nodeHttp2ConnectOptions);
}
}
const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config;
const useIsolatedSession = disableConcurrentStreams || isEventStream;
const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout;
return new Promise((_resolve, _reject) => {
let fulfilled = false;
let writeRequestBodyPromise = undefined;
const resolve = async (arg) => {
await writeRequestBodyPromise;
_resolve(arg);
};
const reject = async (arg) => {
await writeRequestBodyPromise;
_reject(arg);
};
if (abortSignal?.aborted) {
fulfilled = true;
const abortError = buildAbortError(abortSignal);
reject(abortError);
return;
}
const { hostname, method, port, protocol, query } = request;
let auth = "";
if (request.username != null || request.password != null) {
const username = request.username ?? "";
const password = request.password ?? "";
auth = `${username}:${password}@`;
}
const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
const requestContext = { destination: new URL(authority) };
const connectConfig = {
requestTimeout: this.config?.sessionTimeout,
isEventStream
};
const ref = useIsolatedSession ? this.connectionManager.createIsolatedSession(requestContext, connectConfig) : this.connectionManager.lease(requestContext, connectConfig);
const session = ref.deref();
const rejectWithDestroy = (err) => {
if (useIsolatedSession) {
ref.destroy();
}
fulfilled = true;
reject(err);
};
const queryString = query ? buildQueryString(query) : "";
let path = request.path;
if (queryString) {
path += `?${queryString}`;
}
if (request.fragment) {
path += `#${request.fragment}`;
}
const clientHttp2Stream = session.request({
...request.headers,
[constants.HTTP2_HEADER_PATH]: path,
[constants.HTTP2_HEADER_METHOD]: method
});
if (effectiveRequestTimeout) {
clientHttp2Stream.setTimeout(effectiveRequestTimeout, () => {
clientHttp2Stream.close();
const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`);
timeoutError.name = "TimeoutError";
rejectWithDestroy(timeoutError);
});
}
if (abortSignal) {
const onAbort = () => {
clientHttp2Stream.close();
const abortError = buildAbortError(abortSignal);
rejectWithDestroy(abortError);
};
if (typeof abortSignal.addEventListener === "function") {
const signal = abortSignal;
signal.addEventListener("abort", onAbort, { once: true });
clientHttp2Stream.once("close", () => signal.removeEventListener("abort", onAbort));
} else {
abortSignal.onabort = onAbort;
}
}
clientHttp2Stream.on("frameError", (type, code, id) => {
rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
});
clientHttp2Stream.on("error", rejectWithDestroy);
clientHttp2Stream.on("aborted", () => {
rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${clientHttp2Stream.rstCode}.`));
});
clientHttp2Stream.on("response", (headers) => {
const httpResponse = new HttpResponse({
statusCode: headers[":status"] ?? -1,
headers: getTransformedHeaders(headers),
body: clientHttp2Stream
});
fulfilled = true;
resolve({ response: httpResponse });
if (useIsolatedSession) {
session.close();
clientHttp2Stream.on("end", () => {
ref.destroy();
});
}
});
clientHttp2Stream.on("close", () => {
if (useIsolatedSession) {
ref.destroy();
} else {
this.connectionManager.release(requestContext, ref);
}
if (!fulfilled) {
const error = new Error("Unexpected error: http2 request did not get a response");
if (session.destroyed) {
error.name = "TimeoutError";
}
rejectWithDestroy(error);
}
});
writeRequestBodyPromise = writeRequestBody(clientHttp2Stream, request, effectiveRequestTimeout);
});
}
updateHttpClientConfig(key, value) {
this.config = undefined;
this.configProvider = this.configProvider.then((config) => {
return {
...config,
[key]: value
};
});
}
httpHandlerConfigs() {
return this.config ?? {};
}
}
exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT;
exports.NodeHttp2Handler = NodeHttp2Handler;
exports.NodeHttpHandler = NodeHttpHandler;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
var import_config7, ECS_CONTAINER_HOST = "169.254.170.2", EKS_CONTAINER_HOST_IPv4 = "169.254.170.23", EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]", checkUrl = (url, logger) => {
if (url.protocol === "https:") {
return;
}
if (url.hostname === ECS_CONTAINER_HOST || url.hostname === EKS_CONTAINER_HOST_IPv4 || url.hostname === EKS_CONTAINER_HOST_IPv6) {
return;
}
if (url.hostname.includes("[")) {
if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
return;
}
} else {
if (url.hostname === "localhost") {
return;
}
const ipComponents = url.hostname.split(".");
const inRange = (component) => {
const num = parseInt(component, 10);
return 0 <= num && num <= 255;
};
if (ipComponents[0] === "127" && inRange(ipComponents[1]) && inRange(ipComponents[2]) && inRange(ipComponents[3]) && ipComponents.length === 4) {
return;
}
}
throw new import_config7.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
- loopback CIDR 127.0.0.0/8 or [::1/128]
- ECS container host 169.254.170.2
- EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger });
};
var init_checkUrl = __esm(() => {
import_config7 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
function createGetRequest(url) {
return new import_protocols2.HttpRequest({
protocol: url.protocol,
hostname: url.hostname,
port: Number(url.port),
path: url.pathname,
query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => {
acc[k] = v;
return acc;
}, {}),
fragment: url.hash
});
}
async function getCredentials2(response, logger) {
const stream = import_serde2.sdkStreamMixin(response.body);
const str = await stream.transformToString();
if (response.statusCode === 200) {
const parsed = JSON.parse(str);
if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
throw new import_config8.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " + "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger });
}
return {
accessKeyId: parsed.AccessKeyId,
secretAccessKey: parsed.SecretAccessKey,
sessionToken: parsed.Token,
expiration: import_serde.parseRfc3339DateTime(parsed.Expiration)
};
}
if (response.statusCode >= 400 && response.statusCode < 500) {
let parsedBody = {};
try {
parsedBody = JSON.parse(str);
} catch (e) {}
throw Object.assign(new import_config8.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }), {
Code: parsedBody.Code,
Message: parsedBody.Message
});
}
throw new import_config8.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger });
}
var import_config8, import_protocols2, import_serde, import_serde2;
var init_requestHelpers = __esm(() => {
import_config8 = __toESM(require_config());
import_protocols2 = __toESM(require_protocols());
import_serde = __toESM(require_serde());
import_serde2 = __toESM(require_serde());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
var retryWrapper = (toRetry, maxRetries, delayMs) => {
return async () => {
for (let i = 0;i < maxRetries; ++i) {
try {
return await toRetry();
} catch (e) {
await new Promise((resolve) => setTimeout(resolve, delayMs));
}
}
return await toRetry();
};
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
import fs from "fs/promises";
var import_client5, import_config9, import_node_http_handler, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2", AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE", AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromHttp = (options = {}) => {
options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
let host;
const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger?.warn ? console.warn : options.logger.warn.bind(options.logger);
if (relative && full) {
warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
warn("awsContainerCredentialsRelativeUri will take precedence.");
}
if (token && tokenFile) {
warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
warn("awsContainerAuthorizationTokenFile will take precedence.");
}
if (relative) {
host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
} else if (full) {
host = full;
} else {
throw new import_config9.CredentialsProviderError(`No HTTP credential provider host provided.
Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger });
}
const url = new URL(host);
checkUrl(url, options.logger);
const requestHandler = import_node_http_handler.NodeHttpHandler.create({ connectionTimeout: options.timeout ?? 1000 });
const requestTimeout = options.timeout ?? 1000;
const provider = retryWrapper(async () => {
const request = createGetRequest(url);
if (tokenFile) {
request.headers.Authorization = validateToken((await fs.readFile(tokenFile)).toString());
} else if (token) {
request.headers.Authorization = validateToken(token);
}
try {
const result = await requestHandler.handle(request, { requestTimeout });
return getCredentials2(result.response).then((creds) => import_client5.setCredentialFeature(creds, "CREDENTIALS_HTTP", "z"));
} catch (e) {
throw new import_config9.CredentialsProviderError(String(e), { logger: options.logger });
}
}, options.maxRetries ?? 3, options.timeout ?? 1000);
return async () => {
try {
return await provider();
} finally {
requestHandler.destroy?.();
}
};
}, validateToken = (token) => {
if (token.includes(`\r
`)) {
throw new import_config9.CredentialsProviderError("Authorization token contains invalid \\r\\n sequence.");
}
return token;
};
var init_fromHttp = __esm(() => {
init_checkUrl();
init_requestHelpers();
import_client5 = __toESM(require_client2());
import_config9 = __toESM(require_config());
import_node_http_handler = __toESM(require_dist_cjs4());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/index.js
var init_dist_es3 = __esm(() => {
init_fromHttp();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/isSsoProfile.js
var isSsoProfile = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/constants.js
var EXPIRE_WINDOW_MS, REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
var init_constants = __esm(() => {
EXPIRE_WINDOW_MS = 5 * 60 * 1000;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js
var require_cbor = __commonJS(function(exports) {
var { nv, NumericValue, calculateBodyLength, generateIdempotencyToken, fromBase64, _parseEpochTimestamp } = require_serde();
var { hasOwn, getSmithyContext } = require_transport();
var { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require_protocols();
var { NormalizedSchema, deref, TypeRegistry } = require_schema();
var majorUint64 = 0;
var majorNegativeInt64 = 1;
var majorUnstructuredByteString = 2;
var majorUtf8String = 3;
var majorList = 4;
var majorMap = 5;
var majorTag = 6;
var majorSpecial = 7;
var specialFalse = 20;
var specialTrue = 21;
var specialNull = 22;
var specialUndefined = 23;
var extendedOneByte = 24;
var extendedFloat16 = 25;
var extendedFloat32 = 26;
var extendedFloat64 = 27;
var minorIndefinite = 31;
function alloc(size) {
return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
}
var tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
function tag(data) {
data[tagSymbol] = true;
return data;
}
var USE_BUFFER$3 = typeof Buffer !== "undefined";
var textDecoder$1 = new TextDecoder;
var payload$1 = alloc(0);
var isBuffer$1 = false;
var dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
var _offset = 0;
function setPayload(bytes) {
payload$1 = bytes;
isBuffer$1 = USE_BUFFER$3 && payload$1 instanceof Buffer;
dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
}
function decode(at, to) {
if (at >= to) {
throw new Error("unexpected end of (decode) payload.");
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (minor === minorIndefinite && 2 <= major && major <= 5) {
return decodeIndefinite(at, to);
}
switch (major) {
case majorUint64:
case majorNegativeInt64:
case majorTag: {
let unsignedInt;
let offset;
if (minor < 24) {
unsignedInt = minor;
offset = 1;
} else {
switch (minor) {
case extendedOneByte:
if (to - at < 2) {
overflow$1(1);
}
unsignedInt = payload$1[at + 1];
offset = 2;
break;
case extendedFloat16:
if (to - at < 3) {
overflow$1(2);
}
unsignedInt = dataView$2.getUint16(at + 1);
offset = 3;
break;
case extendedFloat32:
if (to - at < 5) {
overflow$1(4);
}
unsignedInt = dataView$2.getUint32(at + 1);
offset = 5;
break;
case extendedFloat64:
if (to - at < 9) {
overflow$1(8);
}
{
const hi = dataView$2.getUint32(at + 1);
if (hi < 2097152) {
unsignedInt = hi * 4294967296 + dataView$2.getUint32(at + 5);
} else {
unsignedInt = dataView$2.getBigUint64(at + 1);
}
}
offset = 9;
break;
default:
unexpectedMinor(minor);
}
}
if (major === majorUint64) {
_offset = offset;
return castBigInt$1(unsignedInt);
} else if (major === majorNegativeInt64) {
let negativeInt;
if (typeof unsignedInt === "bigint") {
negativeInt = BigInt(-1) - unsignedInt;
} else {
negativeInt = -1 - unsignedInt;
}
_offset = offset;
return castBigInt$1(negativeInt);
} else {
return decodeTagValue(at, to, minor, unsignedInt, offset);
}
}
case majorUtf8String:
return decodeUtf8String(at, to);
case majorMap:
return decodeMap(at, to);
case majorList:
return decodeList(at, to);
case majorUnstructuredByteString:
return decodeUnstructuredByteString(at, to);
default:
return decodeSpecial(at, to);
}
}
function decodeIndefinite(at, to) {
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (minor === minorIndefinite) {
switch (major) {
case majorUtf8String:
return decodeUtf8StringIndefinite(at, to);
case majorMap:
return decodeMapIndefinite(at, to);
case majorList:
return decodeListIndefinite(at, to);
case majorUnstructuredByteString:
return decodeUnstructuredByteStringIndefinite(at, to);
}
}
}
function bytesToFloat16$1(a, b) {
const sign = a >> 7;
const exponent = (a & 124) >> 2;
const fraction = (a & 3) << 8 | b;
const scalar = sign === 0 ? 1 : -1;
if (exponent === 0) {
if (fraction === 0) {
return 0;
}
return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
} else if (exponent === 31) {
if (fraction === 0) {
return scalar * Infinity;
}
return NaN;
}
return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
}
function decodeMap(at, to) {
const mapDataLength = decodeCount$1(at, to);
if (mapDataLength < 25) {
return decodeMapSmall(at, to, mapDataLength);
}
return decodeMapLarge(at, to, mapDataLength);
}
function decodeMapLarge(at, to, mapDataLength) {
const offset = _offset;
at += offset;
const base = at;
const map = Object.create(null);
for (let i = 0;i < mapDataLength; ++i) {
const key = decodeUtf8String(at, to);
at += _offset;
const valMajor = (payload$1[at] & 224) >> 5;
if (valMajor === majorUtf8String) {
map[key] = decodeUtf8String(at, to);
} else {
map[key] = decode(at, to);
}
at += _offset;
}
_offset = offset + (at - base);
Object.setPrototypeOf(map, Object.prototype);
return map;
}
function decodeMapSmall(at, to, mapDataLength) {
const offset = _offset;
at += offset;
const base = at;
const map = {};
for (let i = 0;i < mapDataLength; ++i) {
const key = decodeUtf8String(at, to);
at += _offset;
map[key] = decode(at, to);
at += _offset;
}
_offset = offset + (at - base);
return map;
}
function decodeList(at, to) {
const listDataLength = decodeCount$1(at, to);
const offset = _offset;
at += offset;
const base = at;
const list = Array(listDataLength);
for (let i = 0;i < listDataLength; ++i) {
list[i] = decode(at, to);
at += _offset;
}
_offset = offset + (at - base);
return list;
}
function decodeUtf8String(at, to) {
const length = decodeCount$1(at, to);
const offset = _offset;
at += offset;
if (to - at < length) {
overflow$1(length);
}
_offset = offset + length;
if (length < 24) {
return decodeUtf8StringCached(at, length);
}
if (isBuffer$1) {
return payload$1.toString("utf-8", at, at + length);
}
return textDecoder$1.decode(payload$1.subarray(at, at + length));
}
var stringCache$1 = new Array(2048);
var stringCacheEpochs$1 = new Uint16Array(2048);
var cacheEpoch$1 = 0;
function advanceDecodingEpoch() {
cacheEpoch$1 = cacheEpoch$1 + 1 & 65535;
}
function decodeUtf8StringCached(at, length) {
let h = length;
for (let i = 0;i < length; ++i) {
h = h * 31 + payload$1[at + i] | 0;
}
const slot = h >>> 0 & 2047;
const cached = stringCache$1[slot];
if (cached !== undefined) {
if (cached.length === length) {
let match = true;
for (let i = 0;i < length; ++i) {
if (cached.charCodeAt(i) !== payload$1[at + i]) {
match = false;
break;
}
}
if (match) {
stringCacheEpochs$1[slot] = cacheEpoch$1;
return cached;
}
}
}
const result = isBuffer$1 ? payload$1.toString("utf-8", at, at + length) : textDecoder$1.decode(payload$1.subarray(at, at + length));
if (stringCacheEpochs$1[slot] !== cacheEpoch$1) {
stringCache$1[slot] = result;
stringCacheEpochs$1[slot] = cacheEpoch$1;
}
return result;
}
function decodeUnstructuredByteString(at, to) {
const length = decodeCount$1(at, to);
const offset = _offset;
at += offset;
if (to - at < length) {
overflow$1(length);
}
const value = payload$1.subarray(at, at + length);
_offset = offset + length;
return value;
}
function decodeTagValue(at, to, minor, unsignedInt, offset) {
if (minor === 2 || minor === 3) {
const length = decodeCount$1(at + offset, to);
let b = BigInt(0);
const start = at + offset + _offset;
for (let i = start;i < start + length; ++i) {
b = b << BigInt(8) | BigInt(payload$1[i]);
}
_offset = offset + _offset + length;
return minor === 3 ? -b - BigInt(1) : b;
} else if (minor === 4) {
const decimalFraction = decode(at + offset, to);
const [rawExponent, mantissa] = decimalFraction;
const normalizer = mantissa < 0 ? -1 : 1;
const absMantissa = BigInt(normalizer) * BigInt(mantissa);
const mantissaDigits = String(absMantissa);
const sign = mantissa < 0 ? "-" : "";
let numericString;
const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
if (isSmallExponent) {
const exponent = rawExponent;
const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
numericString = exponent === 0 ? mantissaStr : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
numericString = numericString.replace(/^0+/g, "");
if (numericString === "") {
numericString = "0";
}
if (numericString[0] === ".") {
numericString = "0" + numericString;
}
numericString = sign + numericString;
} else {
const bigExponent = BigInt(rawExponent);
if (mantissaDigits.length === 1) {
numericString = sign + mantissaDigits + "e" + String(bigExponent);
} else {
const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
}
}
_offset = offset + _offset;
return nv(numericString);
} else {
const value = decode(at + offset, to);
const valueOffset = _offset;
_offset = offset + valueOffset;
return tag({ tag: castBigInt$1(unsignedInt), value });
}
}
function decodeSpecial(at, to) {
const minor = payload$1[at] & 31;
switch (minor) {
case specialTrue:
case specialFalse:
_offset = 1;
return minor === specialTrue;
case specialNull:
_offset = 1;
return null;
case specialUndefined:
_offset = 1;
return null;
case extendedFloat16:
if (to - at < 3) {
throw new Error("incomplete float16 at end of buf.");
}
_offset = 3;
return bytesToFloat16$1(payload$1[at + 1], payload$1[at + 2]);
case extendedFloat32:
if (to - at < 5) {
throw new Error("incomplete float32 at end of buf.");
}
_offset = 5;
return dataView$2.getFloat32(at + 1);
case extendedFloat64:
if (to - at < 9) {
throw new Error("incomplete float64 at end of buf.");
}
_offset = 9;
return dataView$2.getFloat64(at + 1);
default:
unexpectedMinor(minor);
}
}
function decodeCount$1(at, to) {
const minor = payload$1[at] & 31;
if (minor < 24) {
_offset = 1;
return minor;
}
switch (minor) {
case extendedOneByte:
if (to - at < 2) {
overflow$1(1);
}
_offset = 2;
return payload$1[at + 1];
case extendedFloat16:
if (to - at < 3) {
overflow$1(2);
}
_offset = 3;
return dataView$2.getUint16(at + 1);
case extendedFloat32:
if (to - at < 5) {
overflow$1(4);
}
_offset = 5;
return dataView$2.getUint32(at + 1);
case extendedFloat64:
if (to - at < 9) {
overflow$1(8);
}
_offset = 9;
return demote(dataView$2.getBigUint64(at + 1));
default:
unexpectedMinor(minor);
}
}
function decodeMapIndefinite(at, to) {
at += 1;
const base = at;
const map = {};
for (;at < to; ) {
if (payload$1[at] === 255) {
_offset = at - base + 2;
return map;
}
const key = decodeUtf8String(at, to);
at += _offset;
map[key] = decode(at, to);
at += _offset;
}
throw new Error("expected break marker.");
}
function decodeListIndefinite(at, to) {
at += 1;
const list = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
_offset = at - base + 2;
return list;
}
list.push(decode(at, to));
at += _offset;
}
throw new Error("expected break marker.");
}
function decodeUtf8StringIndefinite(at, to) {
at += 1;
const vector = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
const data = alloc(vector.length);
data.set(vector, 0);
_offset = at - base + 2;
if (USE_BUFFER$3) {
return data.toString("utf-8", 0, data.length);
}
return textDecoder$1.decode(data);
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (major !== majorUtf8String) {
unexpectedMajorInIndefiniteString(major);
}
if (minor === minorIndefinite) {
throw new Error("nested indefinite string.");
}
const bytes = decodeUnstructuredByteString(at, to);
const length = _offset;
at += length;
for (let i = 0;i < bytes.length; ++i) {
vector.push(bytes[i]);
}
}
throw new Error("expected break marker.");
}
function decodeUnstructuredByteStringIndefinite(at, to) {
at += 1;
const vector = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
const data = alloc(vector.length);
data.set(vector, 0);
_offset = at - base + 2;
return data;
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (major !== majorUnstructuredByteString) {
unexpectedMajorInIndefiniteString(major);
}
if (minor === minorIndefinite) {
throw new Error("nested indefinite string.");
}
const bytes = decodeUnstructuredByteString(at, to);
const length = _offset;
at += length;
for (let i = 0;i < bytes.length; ++i) {
vector.push(bytes[i]);
}
}
throw new Error("expected break marker.");
}
function castBigInt$1(bigInt) {
if (typeof bigInt === "number") {
return bigInt;
}
const num = Number(bigInt);
if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
return num;
}
return bigInt;
}
function demote(bigInteger) {
const num = Number(bigInteger);
if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
}
return num;
}
function overflow$1(n) {
throw new Error(`length ${n} greater than remaining buf len.`);
}
function unexpectedMinor(minor) {
throw new Error(`unexpected minor value ${minor}.`);
}
function unexpectedMajorInIndefiniteString(major) {
throw new Error(`unexpected major type ${major} in indefinite string.`);
}
var USE_BUFFER$2 = typeof Buffer !== "undefined";
var encodeStringCache = new Map;
var encodeCacheEpoch$1 = 0;
var encodeCacheSaturated$1 = false;
var initialSize = 2048;
var data = alloc(initialSize);
var dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
var cursor$1 = 0;
function encode(_input) {
const encodeStack = [_input];
while (encodeStack.length) {
const input = encodeStack.pop();
if (typeof input === "string") {
const len = input.length;
if (USE_BUFFER$2) {
ensureSpace(len * 3 + 9);
if (len > 23) {
encodeHeader$1(majorUtf8String, Buffer.byteLength(input));
cursor$1 += data.write(input, cursor$1);
} else {
encodeStringCached(input);
}
} else {
const maxBytes = len * 3;
ensureSpace(maxBytes + 9);
const headerPos = cursor$1;
const result = new TextEncoder().encodeInto(input, data.subarray(cursor$1 + 9));
const byteLen = result.written;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else if (byteLen < 65536) {
headerSize = 3;
} else if (byteLen < 4294967296) {
headerSize = 5;
} else {
headerSize = 9;
}
if (headerSize < 9) {
data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
}
cursor$1 = headerPos;
encodeInteger(majorUtf8String, byteLen);
cursor$1 += byteLen;
}
continue;
}
if (data.byteLength - cursor$1 < 9) {
ensureSpace(64);
}
if (typeof input === "number") {
if (Number.isInteger(input) && input >= -9007199254740992 && input <= 9007199254740991) {
const nonNegative = input >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const value = nonNegative ? input : -input - 1;
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
data[cursor$1++] = value >> 8;
data[cursor$1++] = value & 255;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
dataView$1.setUint32(cursor$1, hi);
dataView$1.setUint32(cursor$1 + 4, lo);
cursor$1 += 8;
}
continue;
}
data[cursor$1++] = majorSpecial << 5 | extendedFloat64;
dataView$1.setFloat64(cursor$1, input);
cursor$1 += 8;
continue;
} else if (typeof input === "bigint") {
const nonNegative = input >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const value = nonNegative ? input : -input - BigInt(1);
if (value < BigInt("18446744073709551616")) {
const n = Number(value);
if (n < 4294967296) {
encodeInteger(major, n);
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
dataView$1.setBigUint64(cursor$1, value);
cursor$1 += 8;
}
} else {
const binaryBigInt = value.toString(2);
const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
let b = value;
let i = 0;
while (bigIntBytes.byteLength - ++i >= 0) {
bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
b >>= BigInt(8);
}
ensureSpace(bigIntBytes.byteLength * 2 + 16);
data[cursor$1++] = nonNegative ? 194 : 195;
encodeHeader$1(majorUnstructuredByteString, bigIntBytes.byteLength);
data.set(bigIntBytes, cursor$1);
cursor$1 += bigIntBytes.byteLength;
}
continue;
} else if (input === null) {
data[cursor$1++] = majorSpecial << 5 | specialNull;
continue;
} else if (typeof input === "boolean") {
data[cursor$1++] = majorSpecial << 5 | (input ? specialTrue : specialFalse);
continue;
} else if (typeof input === "undefined") {
throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
} else if (Array.isArray(input)) {
encodeInteger(majorList, input.length);
ensureSpace(input.length * 9 + 64);
for (let i = input.length - 1;i >= 0; --i) {
encodeStack.push(input[i]);
}
continue;
} else if (typeof input.byteLength === "number") {
ensureSpace(input.length * 2 + 9);
encodeInteger(majorUnstructuredByteString, input.length);
data.set(input, cursor$1);
cursor$1 += input.byteLength;
continue;
} else if (typeof input === "object") {
if (input instanceof NumericValue) {
let str = input.string;
let expOffset = BigInt(0);
const eIndex = str.search(/[eE]/);
if (eIndex !== -1) {
expOffset = BigInt(str.slice(eIndex + 1));
str = str.slice(0, eIndex);
}
const decimalIndex = str.indexOf(".");
const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
const exponent = expOffset - BigInt(fractionDigits);
const mantissa = BigInt(str.replace(".", ""));
data[cursor$1++] = 196;
encodeInteger(majorList, 2);
encodeStack.push(mantissa);
encodeStack.push(exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn ? Number(exponent) : exponent);
continue;
}
if (input[tagSymbol]) {
if ("tag" in input && "value" in input) {
encodeStack.push(input.value);
encodeHeader$1(majorTag, input.tag);
continue;
} else {
throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
}
}
const keys = Object.keys(input);
const len = keys.length;
encodeInteger(majorMap, len);
for (let i = len - 1;i >= 0; --i) {
encodeStack.push(input[keys[i]]);
encodeStack.push(keys[i]);
}
continue;
}
throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
}
}
function advanceEncodingEpoch() {
encodeCacheEpoch$1 = encodeCacheEpoch$1 + 1 & 65535;
encodeCacheSaturated$1 = false;
}
function toUint8Array() {
const out = alloc(cursor$1);
out.set(data.subarray(0, cursor$1), 0);
cursor$1 = 0;
return out;
}
function resize(size) {
const old = data;
data = alloc(size);
if (old) {
if (old.copy) {
old.copy(data, 0, 0, old.byteLength);
} else {
data.set(old, 0);
}
}
dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
}
function encodeStringCached(input) {
const cached = encodeStringCache.get(input);
if (cached !== undefined) {
data.set(cached.bytes, cursor$1);
cursor$1 += cached.bytes.length;
cached.epoch = encodeCacheEpoch$1;
return;
}
const start = cursor$1;
const byteLen = Buffer.byteLength(input);
encodeInteger(majorUtf8String, byteLen);
cursor$1 += data.write(input, cursor$1);
const bytes = Uint8Array.prototype.slice.call(data, start, cursor$1);
if (encodeStringCache.size >= 2048) {
if (encodeCacheSaturated$1) {
return;
}
let evicted = 0;
for (const [key, entry] of encodeStringCache) {
if (evicted >= 1024) {
break;
}
if (entry.epoch !== encodeCacheEpoch$1) {
encodeStringCache.delete(key);
evicted++;
}
}
if (evicted === 0) {
encodeCacheSaturated$1 = true;
return;
}
}
if (encodeStringCache.size < 2048) {
encodeStringCache.set(input, { epoch: encodeCacheEpoch$1, bytes });
}
}
function ensureSpace(bytes) {
const remaining = data.byteLength - cursor$1;
if (remaining < bytes) {
if (cursor$1 < 16000000) {
resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
} else {
resize(data.byteLength + bytes + 16000000);
}
}
}
function encodeHeader$1(major, value) {
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
dataView$1.setUint16(cursor$1, value);
cursor$1 += 2;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
dataView$1.setBigUint64(cursor$1, typeof value === "bigint" ? value : BigInt(value));
cursor$1 += 8;
}
}
function encodeInteger(major, value) {
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
data[cursor$1++] = value >> 8;
data[cursor$1++] = value & 255;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
dataView$1.setUint32(cursor$1, hi);
dataView$1.setUint32(cursor$1 + 4, lo);
cursor$1 += 8;
}
}
var cbor = {
deserialize(payload) {
advanceDecodingEpoch();
setPayload(payload);
return decode(0, payload.length);
},
serialize(input) {
advanceEncodingEpoch();
try {
encode(input);
return toUint8Array();
} catch (e) {
toUint8Array();
throw e;
}
},
resizeEncodingBuffer(size) {
resize(size);
}
};
var parseCborBody = (streamBody, context) => {
return collectBody(streamBody, context).then(async (bytes) => {
if (bytes.length) {
try {
return cbor.deserialize(bytes);
} catch (e) {
Object.defineProperty(e, "$responseBodyText", {
value: context.utf8Encoder(bytes)
});
throw e;
}
}
return {};
});
};
var dateToTag = (date) => {
return tag({
tag: 1,
value: date.getTime() / 1000
});
};
var parseCborErrorBody = async (errorBody, context) => {
const value = await parseCborBody(errorBody, context);
value.message = value.message ?? value.Message;
return value;
};
var loadSmithyRpcV2CborErrorCode = (output, data) => {
const sanitizeErrorCode = (rawValue) => {
let cleanValue = rawValue;
if (typeof cleanValue === "number") {
cleanValue = cleanValue.toString();
}
if (cleanValue.indexOf(",") >= 0) {
cleanValue = cleanValue.split(",")[0];
}
if (cleanValue.indexOf(":") >= 0) {
cleanValue = cleanValue.split(":")[0];
}
if (cleanValue.indexOf("#") >= 0) {
cleanValue = cleanValue.split("#")[1];
}
return cleanValue;
};
if (data["__type"] !== undefined) {
return sanitizeErrorCode(data["__type"]);
}
let codeKey;
for (const key in data) {
if (!hasOwn(data, key))
continue;
if (key.toLowerCase() === "code") {
codeKey = key;
break;
}
}
if (codeKey && data[codeKey] !== undefined) {
return sanitizeErrorCode(data[codeKey]);
}
};
var checkCborResponse = (response) => {
if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
}
};
var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
const endpoint = await context.endpoint();
const { hostname, protocol = "https", port, path: basePath } = endpoint;
const contents = {
protocol,
hostname,
port,
method: "POST",
path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
headers: {
...headers
}
};
if (resolvedHostname !== undefined) {
contents.hostname = resolvedHostname;
}
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
contents.headers[name] = endpoint.headers[name];
}
}
if (body !== undefined) {
contents.body = body;
try {
contents.headers["content-length"] = String(calculateBodyLength(body));
} catch (ignored) {}
}
return new HttpRequest(contents);
};
class CborShapeSerializer2 extends SerdeContext {
write(schema, value) {
cursor = 0;
const ns = NormalizedSchema.of(schema);
writeValue(ns, value, undefined, this.serdeContext);
}
flush() {
const result = buf.subarray(0, cursor);
cursor = 0;
buf = allocUnsafe(INITIAL_BUFFER_SIZE);
view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
return result;
}
}
var CBOR_STRUCT_CACHE = Symbol.for("@smithy/cbor-struct-cache");
function loadCborStructIterator(ns) {
const schema = ns.getSchema();
const existing = schema[CBOR_STRUCT_CACHE];
if (existing) {
return existing;
}
const memberNames = [];
const memberSchemas = [];
for (const [name, memberSchema] of ns.structIterator()) {
memberNames.push(name);
memberSchemas.push(memberSchema);
}
const encodedKeys = new Array(memberNames.length);
for (let i = 0;i < memberNames.length; ++i) {
encodedKeys[i] = encodeCborStringKey(memberNames[i]);
}
const cache = { memberNames, memberSchemas, encodedKeys };
schema[CBOR_STRUCT_CACHE] = cache;
return cache;
}
function encodeCborStringKey(s) {
let utf8Bytes;
if (USE_BUFFER$1) {
utf8Bytes = Buffer.from(s, "utf-8");
} else {
utf8Bytes = new TextEncoder().encode(s);
}
const byteLen = utf8Bytes.length;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else {
headerSize = 3;
}
const result = new Uint8Array(headerSize + byteLen);
if (headerSize === 1) {
result[0] = majorUtf8String << 5 | byteLen;
} else if (headerSize === 2) {
result[0] = majorUtf8String << 5 | 24;
result[1] = byteLen;
} else {
result[0] = majorUtf8String << 5 | extendedFloat16;
result[1] = byteLen >> 8;
result[2] = byteLen & 255;
}
result.set(utf8Bytes, headerSize);
return result;
}
var USE_BUFFER$1 = typeof Buffer !== "undefined";
var textEncoder = new TextEncoder;
var INITIAL_BUFFER_SIZE = 2048;
var buf = USE_BUFFER$1 ? Buffer.allocUnsafe(INITIAL_BUFFER_SIZE) : new Uint8Array(INITIAL_BUFFER_SIZE);
var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
var cursor = 0;
var STRING_CACHE_MAX = 2048;
var stringEncodeCache = new Map;
var encodeCacheEpoch = 0;
var encodeCacheSaturated = false;
function allocUnsafe(size) {
return USE_BUFFER$1 ? Buffer.allocUnsafe(size) : new Uint8Array(size);
}
function writeValue(ns, value, container, serdeContext) {
if (value == null) {
if (value === undefined && ns.isIdempotencyToken()) {
writeString(generateIdempotencyToken());
return;
}
ensure(1);
buf[cursor++] = majorSpecial << 5 | specialNull;
return;
}
if (ns.isUnitSchema()) {
ensure(1);
encodeHeader(majorMap, 0);
return;
}
const isObject = typeof value === "object";
if (isObject) {
if (ns.isBlobSchema()) {
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
}
if (ns.isTimestampSchema()) {
if (value instanceof Date) {
writeTimestamp(value);
return;
}
}
if (ns.isStructSchema()) {
writeStruct(ns, value, serdeContext);
return;
}
if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
writeList(ns, value, ns.isDocumentSchema(), serdeContext);
return;
}
if (ns.isMapSchema()) {
writeMap(ns, value, false, serdeContext);
return;
}
if (value instanceof Date) {
writeTimestamp(value);
return;
}
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
if (value instanceof NumericValue) {
writeNumericValue(value);
return;
}
if (value[tagSymbol]) {
const tagged = value;
writeTag(tagged.tag, tagged.value);
return;
}
if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
writeList(ns, value, true, serdeContext);
} else {
writeMap(ns, value, true, serdeContext);
}
return;
}
if (ns.isBigDecimalSchema()) {
writeUntypedValue(value);
return;
}
writeMap(ns, value, true, serdeContext);
return;
}
if (typeof value === "string") {
if (ns.isBlobSchema()) {
const bytes = (serdeContext?.base64Decoder ?? fromBase64)(value);
writeBytes(bytes);
return;
}
writeString(value);
return;
}
if (typeof value === "number") {
ensure(9);
if (Number.isInteger(value) && value >= -9007199254740992 && value <= 9007199254740991) {
writeInteger(value);
} else {
writeFloat64(value);
}
return;
}
if (typeof value === "boolean") {
ensure(1);
buf[cursor++] = majorSpecial << 5 | (value ? specialTrue : specialFalse);
return;
}
if (typeof value === "bigint") {
writeBigInt(value);
return;
}
writeString(String(value));
}
function writeStruct(ns, value, serdeContext) {
if (ns.isUnionSchema()) {
let wrote = false;
for (const [memberName, memberSchema] of ns.structIterator()) {
const item = value[memberName];
if (item != null) {
ensure(9);
encodeHeader(majorMap, 1);
writeString(memberName);
writeValue(memberSchema, item, ns, serdeContext);
wrote = true;
break;
}
}
if (!wrote) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
ensure(9);
encodeHeader(majorMap, 1);
writeString($unknown[0]);
writeUntypedValue($unknown[1]);
} else {
ensure(9);
encodeHeader(majorMap, 0);
}
}
return;
}
const cache = loadCborStructIterator(ns);
const { memberNames, memberSchemas, encodedKeys } = cache;
const z = memberNames.length;
let headerSize;
if (z < 24) {
headerSize = 1;
} else if (z < 256) {
headerSize = 2;
} else {
headerSize = 3;
}
ensure(headerSize);
const headerPos = cursor;
cursor += headerSize;
let count = 0;
for (let i = 0;i < z; ++i) {
const item = value[memberNames[i]];
if (item == null && !memberSchemas[i].isIdempotencyToken()) {
continue;
}
const key = encodedKeys[i];
ensure(key.length);
buf.set(key, cursor);
cursor += key.length;
writeValue(memberSchemas[i], item, ns, serdeContext);
++count;
}
if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!memberNames.includes(k)) {
writeString(k);
writeUntypedValue(value[k]);
++count;
}
}
}
if (headerSize === 1) {
buf[headerPos] = majorMap << 5 | count;
} else if (headerSize === 2) {
buf[headerPos] = majorMap << 5 | 24;
buf[headerPos + 1] = count;
} else {
buf[headerPos] = majorMap << 5 | extendedFloat16;
buf[headerPos + 1] = count >> 8;
buf[headerPos + 2] = count & 255;
}
}
function writeList(ns, value, isDocument, serdeContext) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (isDocument || sparse) {
const items = [];
for (let i = 0;i < value.length; ++i) {
const item = value[i];
if (isDocument) {
if (item !== undefined) {
items.push(item);
}
} else {
if (item != null || sparse) {
items.push(item);
}
}
}
ensure(9);
encodeHeader(majorList, items.length);
for (let i = 0;i < items.length; ++i) {
writeValue(valueSchema, items[i], undefined, serdeContext);
}
} else {
let count = 0;
for (let i = 0;i < value.length; ++i) {
if (value[i] != null) {
++count;
}
}
ensure(9);
encodeHeader(majorList, count);
for (let i = 0;i < value.length; ++i) {
if (value[i] != null) {
writeValue(valueSchema, value[i], undefined, serdeContext);
}
}
}
}
function writeMap(ns, value, isDocument, serdeContext) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
const keys = [];
for (const k in value) {
if (!hasOwn(value, k))
continue;
const v = value[k];
if (isDocument ? v !== undefined : v != null || sparse) {
keys.push(k);
}
}
ensure(9);
encodeHeader(majorMap, keys.length);
for (let i = 0;i < keys.length; ++i) {
const k = keys[i];
writeString(k);
writeValue(valueSchema, value[k], undefined, serdeContext);
}
}
function writeUntypedValue(value) {
if (value == null) {
ensure(1);
buf[cursor++] = majorSpecial << 5 | specialNull;
return;
}
if (typeof value === "string") {
writeString(value);
return;
}
if (typeof value === "number") {
ensure(9);
if (Number.isInteger(value) && value >= -9007199254740992 && value <= 9007199254740991) {
writeInteger(value);
} else {
writeFloat64(value);
}
return;
}
if (typeof value === "boolean") {
ensure(1);
buf[cursor++] = majorSpecial << 5 | (value ? specialTrue : specialFalse);
return;
}
if (typeof value === "bigint") {
writeBigInt(value);
return;
}
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
if (value instanceof Date) {
writeTimestamp(value);
return;
}
if (value instanceof NumericValue) {
writeNumericValue(value);
return;
}
if (value[tagSymbol]) {
const tagged = value;
writeTag(tagged.tag, tagged.value);
return;
}
if (Array.isArray(value)) {
ensure(9);
encodeHeader(majorList, value.length);
for (let i = 0;i < value.length; ++i) {
writeUntypedValue(value[i]);
}
return;
}
if (typeof value === "object") {
const keys = Object.keys(value);
ensure(9);
encodeHeader(majorMap, keys.length);
for (let i = 0;i < keys.length; ++i) {
writeString(keys[i]);
writeUntypedValue(value[keys[i]]);
}
return;
}
writeString(String(value));
}
function ensure(n) {
if (cursor + n > buf.length) {
let newSize = buf.length * 2;
while (newSize < cursor + n) {
newSize *= 2;
}
const next = allocUnsafe(newSize);
next.set(buf.subarray(0, cursor));
buf = next;
view = new DataView(next.buffer, next.byteOffset, next.byteLength);
}
}
function encodeHeader(major, value) {
if (value < 24) {
buf[cursor++] = major << 5 | value;
} else if (value < 256) {
buf[cursor++] = major << 5 | 24;
buf[cursor++] = value;
} else if (value < 65536) {
buf[cursor++] = major << 5 | extendedFloat16;
buf[cursor++] = value >> 8;
buf[cursor++] = value & 255;
} else if (value < 4294967296) {
buf[cursor++] = major << 5 | extendedFloat32;
view.setUint32(cursor, value);
cursor += 4;
} else {
buf[cursor++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
view.setUint32(cursor, hi);
view.setUint32(cursor + 4, lo);
cursor += 8;
}
}
function encodeBigHeader(major, value) {
const n = Number(value);
if (n < 4294967296) {
encodeHeader(major, n);
return;
}
buf[cursor++] = major << 5 | extendedFloat64;
view.setBigUint64(cursor, value);
cursor += 8;
}
function writeString(s) {
const len = s.length;
if (len <= 23) {
const cached = stringEncodeCache.get(s);
if (cached) {
ensure(cached.bytes.length);
buf.set(cached.bytes, cursor);
cursor += cached.bytes.length;
cached.epoch = encodeCacheEpoch;
return;
}
const start = cursor;
writeStringUncached(s, len);
const end = cursor;
const bytes = Uint8Array.prototype.slice.call(buf, start, end);
if (stringEncodeCache.size >= STRING_CACHE_MAX) {
if (encodeCacheSaturated) {
return;
}
let evicted = 0;
for (const [key, entry] of stringEncodeCache) {
if (evicted >= 1024) {
break;
}
if (entry.epoch !== encodeCacheEpoch) {
stringEncodeCache.delete(key);
++evicted;
}
}
if (evicted === 0) {
encodeCacheSaturated = true;
return;
}
}
if (stringEncodeCache.size < STRING_CACHE_MAX) {
stringEncodeCache.set(s, { epoch: encodeCacheEpoch, bytes });
}
return;
}
writeStringUncached(s, len);
}
function writeStringUncached(s, len) {
if (USE_BUFFER$1) {
const maxBytes = len * 3;
ensure(maxBytes + 9);
const byteLen = Buffer.byteLength(s);
encodeHeader(majorUtf8String, byteLen);
cursor += buf.write(s, cursor);
} else {
const maxBytes = len * 3;
ensure(maxBytes + 9);
const headerPos = cursor;
const result = textEncoder.encodeInto(s, buf.subarray(headerPos + 9));
const byteLen = result.written;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else if (byteLen < 65536) {
headerSize = 3;
} else if (byteLen < 4294967296) {
headerSize = 5;
} else {
headerSize = 9;
}
if (headerSize < 9) {
buf.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
}
cursor = headerPos;
encodeHeader(majorUtf8String, byteLen);
cursor += byteLen;
}
}
function writeFloat64(value) {
ensure(9);
buf[cursor++] = majorSpecial << 5 | extendedFloat64;
view.setFloat64(cursor, value);
cursor += 8;
}
function writeInteger(value) {
ensure(9);
const nonNegative = value >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const abs = nonNegative ? value : -value - 1;
encodeHeader(major, abs);
}
function writeBigInt(value) {
const nonNegative = value >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const abs = nonNegative ? value : -value - BigInt(1);
if (abs < BigInt("18446744073709551616")) {
ensure(9);
encodeBigHeader(major, abs);
} else {
const binaryStr = abs.toString(2);
const byteLen = Math.ceil(binaryStr.length / 8);
const bigIntBytes = new Uint8Array(byteLen);
let b = abs;
for (let i = byteLen - 1;i >= 0; --i) {
bigIntBytes[i] = Number(b & BigInt(255));
b >>= BigInt(8);
}
ensure(byteLen + 16);
buf[cursor++] = nonNegative ? 194 : 195;
encodeHeader(majorUnstructuredByteString, byteLen);
buf.set(bigIntBytes, cursor);
cursor += byteLen;
}
}
function writeBytes(data) {
ensure(data.length + 9);
encodeHeader(majorUnstructuredByteString, data.length);
buf.set(data, cursor);
cursor += data.length;
}
function writeTag(tagValue, innerValue) {
ensure(9);
if (typeof tagValue === "bigint") {
encodeBigHeader(majorTag, tagValue);
} else {
encodeHeader(majorTag, tagValue);
}
writeUntypedValue(innerValue);
}
function writeNumericValue(nv) {
let str = nv.string;
let expOffset = BigInt(0);
const eIndex = str.search(/[eE]/);
if (eIndex !== -1) {
expOffset = BigInt(str.slice(eIndex + 1));
str = str.slice(0, eIndex);
}
const decimalIndex = str.indexOf(".");
const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
const exponent = expOffset - BigInt(fractionDigits);
const mantissa = BigInt(str.replace(".", ""));
ensure(9);
buf[cursor++] = 196;
encodeHeader(majorList, 2);
ensure(9);
if (exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn) {
writeInteger(Number(exponent));
} else {
writeBigInt(exponent);
}
writeBigInt(mantissa);
}
function writeTimestamp(date) {
ensure(18);
encodeHeader(majorTag, 1);
const epochSecs = date.getTime() / 1000;
if (Number.isInteger(epochSecs)) {
writeInteger(epochSecs);
} else {
writeFloat64(epochSecs);
}
}
class CborShapeDeserializer2 extends SerdeContext {
read(schema, bytes) {
payload = bytes;
isBuffer = USE_BUFFER && bytes instanceof Buffer;
dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
pos = 0;
end = bytes.length;
cacheEpoch = cacheEpoch + 1 & 65535;
return readValue(NormalizedSchema.of(schema));
}
readValue(_schema, value) {
return transformObject(NormalizedSchema.of(_schema), value);
}
}
var USE_BUFFER = typeof Buffer !== "undefined";
var textDecoder = new TextDecoder;
var payload = new Uint8Array(0);
var isBuffer = false;
var dataView = new DataView(new ArrayBuffer(0));
var pos = 0;
var end = 0;
var STRING_CACHE_SIZE = 2048;
var stringCache = new Array(STRING_CACHE_SIZE);
var stringCacheEpochs = new Uint16Array(STRING_CACHE_SIZE);
var cacheEpoch = 0;
function readValue(ns) {
if (pos >= end) {
throw new Error("unexpected end of CBOR payload.");
}
const major = (payload[pos] & 224) >> 5;
const minor = payload[pos] & 31;
if (minor === minorIndefinite && major >= 2 && major <= 5) {
return readIndefinite(ns, major);
}
switch (major) {
case majorUint64:
return readUnsignedInt();
case majorNegativeInt64:
return readNegativeInt();
case majorUnstructuredByteString:
return readByteString();
case majorUtf8String:
return readUtf8String();
case majorList:
return readList(ns);
case majorMap:
return readMap(ns);
case majorTag:
return readTag();
case majorSpecial:
return readSpecial();
default:
throw new Error(`unexpected CBOR major type ${major}.`);
}
}
function readList(ns) {
const count = decodeCount();
const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
const list = Array(count);
for (let i = 0;i < count; ++i) {
list[i] = readValue(memberSchema);
}
return list;
}
function readMap(ns) {
const count = decodeCount();
if (ns.isStructSchema()) {
const startPos = pos;
return readStruct(ns, count, startPos);
}
const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
const map = {};
for (let i = 0;i < count; ++i) {
const key = readUtf8String();
map[key] = readValue(valueSchema);
}
return map;
}
function readStruct(ns, count, startPos) {
const isUnion = ns.isUnionSchema();
const cache = loadCborStructIterator(ns);
const { memberSchemas, encodedKeys, memberNames } = cache;
const z = encodedKeys.length;
const result = {};
let unknownKey;
let unknownValue;
let unknownCount = 0;
let hasType = false;
let hint = 0;
for (let i = 0;i < count; ++i) {
const matchIdx = matchStructKey(encodedKeys, z, hint);
if (matchIdx >= 0) {
hint = matchIdx + 1;
if (hint >= z) {
hint = 0;
}
const val = readValue(memberSchemas[matchIdx]);
if (val != null) {
result[memberNames[matchIdx]] = val;
}
} else {
const key = readUtf8String();
const val = readValue(NormalizedSchema.of(15));
if (key === "__type" && typeof val === "string") {
hasType = true;
} else {
unknownKey = key;
unknownValue = val;
++unknownCount;
}
}
}
if (isUnion) {
let resultEmpty = true;
for (const _ in result) {
if (!hasOwn(result, _))
continue;
resultEmpty = false;
break;
}
if (resultEmpty && unknownCount === 1) {
result.$unknown = [unknownKey, unknownValue];
}
} else if (hasType) {
pos = startPos;
const docSchema = NormalizedSchema.of(15);
for (let i = 0;i < count; ++i) {
const key = readUtf8String();
const val = readValue(docSchema);
if (!(key in result)) {
result[key] = val;
}
}
}
return result;
}
function readTag(ns) {
const tagNum = decodeArgument();
const tagNumber = typeof tagNum === "bigint" ? Number(tagNum) : tagNum;
if (tagNumber === 1) {
const docSchema = NormalizedSchema.of(15);
const epochValue = readValue(docSchema);
return _parseEpochTimestamp(epochValue);
}
if (tagNumber === 2 || tagNumber === 3) {
const byteStr = readByteString();
let b = BigInt(0);
for (let i = 0;i < byteStr.length; ++i) {
b = b << BigInt(8) | BigInt(byteStr[i]);
}
return tagNumber === 3 ? -b - BigInt(1) : b;
}
if (tagNumber === 4) {
const docSchema = NormalizedSchema.of(15);
const pair = readValue(docSchema);
const [rawExponent, mantissa] = pair;
const normalizer = mantissa < 0 ? -1 : 1;
const absMantissa = BigInt(normalizer) * BigInt(mantissa);
const mantissaDigits = String(absMantissa);
const sign = mantissa < 0 ? "-" : "";
let numericString;
const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
if (isSmallExponent) {
const exponent = rawExponent;
const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
numericString = exponent === 0 ? mantissaStr : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
numericString = numericString.replace(/^0+/g, "");
if (numericString === "") {
numericString = "0";
}
if (numericString[0] === ".") {
numericString = "0" + numericString;
}
numericString = sign + numericString;
} else {
const bigExponent = BigInt(rawExponent);
if (mantissaDigits.length === 1) {
numericString = sign + mantissaDigits + "e" + String(bigExponent);
} else {
const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
}
}
return nv(numericString);
}
const docSchema = NormalizedSchema.of(15);
const innerValue = readValue(docSchema);
return { tag: castBigInt(tagNum), value: innerValue };
}
function readIndefinite(ns, major) {
switch (major) {
case majorUtf8String:
return readUtf8StringIndefinite();
case majorUnstructuredByteString:
return readByteStringIndefinite();
case majorList:
return readListIndefinite(ns);
case majorMap:
return readMapIndefinite(ns);
default:
throw new Error(`unexpected indefinite length for major ${major}.`);
}
}
function readUtf8StringIndefinite() {
pos += 1;
const chunks = [];
let totalLen = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
const combined = new Uint8Array(totalLen);
let offset = 0;
for (let i = 0;i < chunks.length; ++i) {
combined.set(chunks[i], offset);
offset += chunks[i].length;
}
if (USE_BUFFER) {
return Buffer.from(combined.buffer, combined.byteOffset, combined.byteLength).toString("utf-8");
}
return textDecoder.decode(combined);
}
const bytes = readByteString();
chunks.push(bytes);
totalLen += bytes.length;
}
throw new Error("expected break marker.");
}
function readByteStringIndefinite() {
pos += 1;
const chunks = [];
let totalLen = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
const combined = new Uint8Array(totalLen);
let offset = 0;
for (let i = 0;i < chunks.length; ++i) {
combined.set(chunks[i], offset);
offset += chunks[i].length;
}
return combined;
}
const bytes = readByteString();
chunks.push(bytes);
totalLen += bytes.length;
}
throw new Error("expected break marker.");
}
function readListIndefinite(ns) {
pos += 1;
const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
const list = [];
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
return list;
}
list.push(readValue(memberSchema));
}
throw new Error("expected break marker.");
}
function readMapIndefinite(ns) {
pos += 1;
if (ns.isStructSchema()) {
const cache = loadCborStructIterator(ns);
const { memberSchemas, encodedKeys, memberNames } = cache;
const z = encodedKeys.length;
const isUnion = ns.isUnionSchema();
const result = {};
let unknownKey;
let unknownValue;
let unknownCount = 0;
let hint = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
if (isUnion) {
let resultEmpty = true;
for (const _ in result) {
if (!hasOwn(result, _))
continue;
resultEmpty = false;
break;
}
if (resultEmpty && unknownCount === 1) {
result.$unknown = [unknownKey, unknownValue];
}
}
return result;
}
const matchIdx = matchStructKey(encodedKeys, z, hint);
if (matchIdx >= 0) {
hint = matchIdx + 1;
if (hint >= z) {
hint = 0;
}
const val = readValue(memberSchemas[matchIdx]);
if (val != null) {
result[memberNames[matchIdx]] = val;
}
} else {
const key = readUtf8String();
const val = readValue(NormalizedSchema.of(15));
if (key !== "__type") {
unknownKey = key;
unknownValue = val;
++unknownCount;
}
}
}
throw new Error("expected break marker.");
}
const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
const map = {};
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
return map;
}
const key = readUtf8String();
map[key] = readValue(valueSchema);
}
throw new Error("expected break marker.");
}
function matchStructKey(encodedKeys, z, hint) {
const hintKey = encodedKeys[hint];
if (pos + hintKey.length <= end && bytesMatch(pos, hintKey)) {
pos += hintKey.length;
return hint;
}
for (let i = 0;i < z; ++i) {
if (i === hint) {
continue;
}
const ek = encodedKeys[i];
if (pos + ek.length <= end && bytesMatch(pos, ek)) {
pos += ek.length;
return i;
}
}
return -1;
}
function bytesMatch(at, expected) {
const len = expected.length;
if (payload[at] !== expected[0]) {
return false;
}
for (let i = 1;i < len; ++i) {
if (payload[at + i] !== expected[i]) {
return false;
}
}
return true;
}
function decodeArgument() {
const minor = payload[pos] & 31;
if (minor < 24) {
pos += 1;
return minor;
}
switch (minor) {
case extendedOneByte:
if (end - pos < 2) {
overflow(1);
}
pos += 2;
return payload[pos - 1];
case extendedFloat16:
if (end - pos < 3) {
overflow(2);
}
pos += 3;
return dataView.getUint16(pos - 2);
case extendedFloat32:
if (end - pos < 5) {
overflow(4);
}
pos += 5;
return dataView.getUint32(pos - 4);
case extendedFloat64: {
if (end - pos < 9) {
overflow(8);
}
pos += 9;
const hi = dataView.getUint32(pos - 8);
if (hi < 2097152) {
return hi * 4294967296 + dataView.getUint32(pos - 4);
}
return dataView.getBigUint64(pos - 8);
}
default:
throw new Error(`unexpected minor value ${minor}.`);
}
}
function decodeCount() {
const val = decodeArgument();
return typeof val === "bigint" ? Number(val) : val;
}
function readUnsignedInt() {
const val = decodeArgument();
return castBigInt(val);
}
function readNegativeInt() {
const val = decodeArgument();
if (typeof val === "bigint") {
return BigInt(-1) - val;
}
return -1 - val;
}
function readByteString() {
const length = decodeCount();
if (end - pos < length) {
overflow(length);
}
const start = pos;
pos += length;
return payload.subarray(start, start + length);
}
function readUtf8String() {
const length = decodeCount();
if (end - pos < length) {
overflow(length);
}
const start = pos;
pos += length;
if (length < 24) {
return decodeUtf8Cached(start, length);
}
if (isBuffer) {
return payload.toString("utf-8", start, start + length);
}
return textDecoder.decode(payload.subarray(start, start + length));
}
function decodeUtf8Cached(at, length) {
let h = length;
for (let i = 0;i < length; ++i) {
h = h * 31 + payload[at + i] | 0;
}
const slot = h >>> 0 & STRING_CACHE_SIZE - 1;
const cached = stringCache[slot];
if (cached !== undefined && cached.length === length) {
let match = true;
for (let i = 0;i < length; ++i) {
if (cached.charCodeAt(i) !== payload[at + i]) {
match = false;
break;
}
}
if (match) {
stringCacheEpochs[slot] = cacheEpoch;
return cached;
}
}
const result = isBuffer ? payload.toString("utf-8", at, at + length) : textDecoder.decode(payload.subarray(at, at + length));
if (stringCacheEpochs[slot] !== cacheEpoch) {
stringCache[slot] = result;
stringCacheEpochs[slot] = cacheEpoch;
}
return result;
}
function readSpecial() {
const p = pos;
const minor = payload[p] & 31;
switch (minor) {
case specialTrue:
pos = p + 1;
return true;
case specialFalse:
pos = p + 1;
return false;
case specialNull:
pos = p + 1;
return null;
case specialUndefined:
pos = p + 1;
return null;
case extendedFloat16: {
if (end - p < 3) {
overflow(2);
}
pos = p + 3;
return bytesToFloat16(payload[p + 1], payload[p + 2]);
}
case extendedFloat32: {
if (end - p < 5) {
overflow(4);
}
pos = p + 5;
return dataView.getFloat32(p + 1);
}
case extendedFloat64: {
if (end - p < 9) {
overflow(8);
}
pos = p + 9;
return dataView.getFloat64(p + 1);
}
default:
throw new Error(`unexpected minor value ${minor} for major 7.`);
}
}
function bytesToFloat16(a, b) {
const sign = a >> 7;
const exponent = (a & 124) >> 2;
const fraction = (a & 3) << 8 | b;
const scalar = sign === 0 ? 1 : -1;
if (exponent === 0) {
if (fraction === 0) {
return 0;
}
return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
} else if (exponent === 31) {
if (fraction === 0) {
return scalar * Infinity;
}
return NaN;
}
return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
}
function castBigInt(value) {
if (typeof value === "number") {
return value;
}
const num = Number(value);
if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
return num;
}
return value;
}
function overflow(n) {
throw new Error(`CBOR: length ${n} greater than remaining buffer length.`);
}
function transformObject(ns, value) {
if (ns.isTimestampSchema()) {
if (typeof value === "number") {
return _parseEpochTimestamp(value);
}
if (typeof value === "object" && value !== null) {
if (value.tag === 1 && "value" in value) {
return _parseEpochTimestamp(value.value);
}
}
}
if (ns.isBlobSchema()) {
return value;
}
if (typeof value === "undefined" || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || typeof value === "symbol") {
return value;
}
if (typeof value !== "object" || value === null) {
return value;
}
if ("byteLength" in value) {
return value;
}
if (value instanceof Date) {
return value;
}
if (value instanceof NumericValue) {
return value;
}
if (ns.isDocumentSchema()) {
return value;
}
if (ns.isListSchema()) {
const memberSchema = ns.getValueSchema();
const out = [];
for (const item of value) {
out.push(transformObject(memberSchema, item));
}
return out;
}
const newObject = {};
if (ns.isMapSchema()) {
const targetSchema = ns.getValueSchema();
for (const key in value) {
if (!hasOwn(value, key))
continue;
newObject[key] = transformObject(targetSchema, value[key]);
}
} else if (ns.isStructSchema()) {
const isUnion = ns.isUnionSchema();
let keys;
if (isUnion) {
keys = new Set;
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (k !== "__type") {
keys.add(k);
}
}
}
for (const [key, memberSchema] of ns.structIterator()) {
if (isUnion) {
keys.delete(key);
}
if (value[key] != null) {
newObject[key] = transformObject(memberSchema, value[key]);
}
}
if (isUnion && keys?.size === 1) {
let newObjectEmpty = true;
for (const _ in newObject) {
if (!hasOwn(newObject, _))
continue;
newObjectEmpty = false;
break;
}
if (newObjectEmpty) {
const k = keys.values().next().value;
newObject.$unknown = [k, value[k]];
}
} else if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!(k in newObject)) {
newObject[k] = value[k];
}
}
}
}
return newObject;
}
class CborCodec extends SerdeContext {
createSerializer() {
const serializer = new CborShapeSerializer2;
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new CborShapeDeserializer2;
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class SmithyRpcV2CborProtocol extends RpcProtocol {
codec = new CborCodec;
serializer = this.codec.createSerializer();
deserializer = this.codec.createDeserializer();
constructor({ defaultNamespace, errorTypeRegistries }) {
super({ defaultNamespace, errorTypeRegistries });
}
getShapeId() {
return "smithy.protocols#rpcv2Cbor";
}
getPayloadCodec() {
return this.codec;
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
Object.assign(request.headers, {
"content-type": this.getDefaultContentType(),
"smithy-protocol": "rpc-v2-cbor",
accept: this.getDefaultContentType()
});
if (deref(operationSchema.input) === "unit") {
delete request.body;
delete request.headers["content-type"];
} else {
if (!request.body) {
this.serializer.write(15, {});
request.body = this.serializer.flush();
}
if (request.body instanceof Uint8Array) {
request.headers["content-length"] = String(request.body.byteLength);
}
}
const { service, operation } = getSmithyContext(context);
const path = `/service/${service}/operation/${operation}`;
if (request.path.endsWith("/")) {
request.path += path.slice(1);
} else {
request.path += path;
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
return super.deserializeResponse(operationSchema, context, response);
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
const errorMetadata = {
$metadata: metadata,
$fault: response.statusCode <= 500 ? "client" : "server"
};
let namespace = this.options.defaultNamespace;
if (errorName.includes("#")) {
[namespace] = errorName.split("#");
}
const registry = this.compositeErrorRegistry;
const nsRegistry = TypeRegistry.for(namespace);
registry.copyFrom(nsRegistry);
let errorSchema;
try {
errorSchema = registry.getSchema(errorName);
} catch (ignored) {
if (dataObject.Message) {
dataObject.message = dataObject.Message;
}
const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
registry.copyFrom(syntheticRegistry);
const baseExceptionSchema = registry.getBaseException();
if (baseExceptionSchema) {
const ErrorCtor = registry.getErrorCtor(baseExceptionSchema);
throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
}
throw Object.assign(new Error(errorName), errorMetadata, dataObject);
}
const ns = NormalizedSchema.of(errorSchema);
const ErrorCtor = registry.getErrorCtor(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "Unknown";
const exception = new ErrorCtor({});
const output = {};
for (const [name, member] of ns.structIterator()) {
output[name] = this.deserializer.readValue(member, dataObject[name]);
}
throw Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output);
}
getDefaultContentType() {
return "application/cbor";
}
}
class CborShapeSerializer extends SerdeContext {
value;
write(schema, value) {
this.value = this.serialize(schema, value);
}
serialize(schema, source) {
const ns = NormalizedSchema.of(schema);
if (source == null) {
if (ns.isIdempotencyToken()) {
return generateIdempotencyToken();
}
return source;
}
if (ns.isBlobSchema()) {
if (typeof source === "string") {
return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
}
return source;
}
if (ns.isTimestampSchema()) {
if (typeof source === "number" || typeof source === "bigint") {
return dateToTag(new Date(Number(source) / 1000 | 0));
}
return dateToTag(source);
}
if (typeof source === "function" || typeof source === "object") {
const sourceObject = source;
if (ns.isListSchema() && Array.isArray(sourceObject)) {
const sparse = !!ns.getMergedTraits().sparse;
const newArray = [];
let i = 0;
for (const item of sourceObject) {
const value = this.serialize(ns.getValueSchema(), item);
if (value != null || sparse) {
newArray[i++] = value;
}
}
return newArray;
}
if (sourceObject instanceof Date) {
return dateToTag(sourceObject);
}
const newObject = {};
if (ns.isMapSchema()) {
const sparse = !!ns.getMergedTraits().sparse;
for (const key in sourceObject) {
if (!hasOwn(sourceObject, key))
continue;
const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
if (value != null || sparse) {
newObject[key] = value;
}
}
} else if (ns.isStructSchema()) {
for (const [key, memberSchema] of ns.structIterator()) {
const value = this.serialize(memberSchema, sourceObject[key]);
if (value != null) {
newObject[key] = value;
}
}
const isUnion = ns.isUnionSchema();
if (isUnion && Array.isArray(sourceObject.$unknown)) {
const [k, v] = sourceObject.$unknown;
newObject[k] = v;
} else if (typeof sourceObject.__type === "string") {
for (const k in sourceObject) {
if (!hasOwn(sourceObject, k))
continue;
if (!(k in newObject)) {
newObject[k] = this.serialize(15, sourceObject[k]);
}
}
}
} else if (ns.isDocumentSchema()) {
if (Array.isArray(sourceObject)) {
const newArray = [];
let i = 0;
for (const item of sourceObject) {
newArray[i++] = this.serialize(ns.getValueSchema(), item);
}
return newArray;
}
for (const key in sourceObject) {
if (!hasOwn(sourceObject, key))
continue;
newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
}
} else if (ns.isBigDecimalSchema()) {
return sourceObject;
}
return newObject;
}
return source;
}
flush() {
const buffer = cbor.serialize(this.value);
this.value = undefined;
return buffer;
}
}
class CborShapeDeserializer extends SerdeContext {
read(schema, bytes) {
const data = cbor.deserialize(bytes);
return this.readValue(schema, data);
}
readValue(_schema, value) {
const ns = NormalizedSchema.of(_schema);
if (ns.isTimestampSchema()) {
if (typeof value === "number") {
return _parseEpochTimestamp(value);
}
if (typeof value === "object") {
if (value.tag === 1 && "value" in value) {
return _parseEpochTimestamp(value.value);
}
}
}
if (ns.isBlobSchema()) {
if (typeof value === "string") {
return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
}
return value;
}
if (typeof value === "undefined" || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || typeof value === "symbol") {
return value;
} else if (typeof value === "object") {
if (value === null) {
return null;
}
if ("byteLength" in value) {
return value;
}
if (value instanceof Date) {
return value;
}
if (ns.isDocumentSchema()) {
return value;
}
if (ns.isListSchema()) {
const newArray = [];
const memberSchema = ns.getValueSchema();
for (const item of value) {
const itemValue = this.readValue(memberSchema, item);
newArray.push(itemValue);
}
return newArray;
}
const newObject = {};
if (ns.isMapSchema()) {
const targetSchema = ns.getValueSchema();
for (const key in value) {
if (!hasOwn(value, key))
continue;
const itemValue = this.readValue(targetSchema, value[key]);
newObject[key] = itemValue;
}
} else if (ns.isStructSchema()) {
const isUnion = ns.isUnionSchema();
let keys;
if (isUnion) {
keys = new Set;
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (k !== "__type") {
keys.add(k);
}
}
}
for (const [key, memberSchema] of ns.structIterator()) {
if (isUnion) {
keys.delete(key);
}
if (value[key] != null) {
newObject[key] = this.readValue(memberSchema, value[key]);
}
}
if (isUnion && keys?.size === 1) {
let newObjectEmpty = true;
for (const _ in newObject) {
if (!hasOwn(newObject, _))
continue;
newObjectEmpty = false;
break;
}
if (newObjectEmpty) {
const k = keys.values().next().value;
newObject.$unknown = [k, value[k]];
}
} else if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!(k in newObject)) {
newObject[k] = value[k];
}
}
}
} else if (value instanceof NumericValue) {
return value;
}
return newObject;
} else {
return value;
}
}
}
exports.CborCodec = CborCodec;
exports.CborShapeDeserializer = CborShapeDeserializer;
exports.CborShapeDeserializer2 = CborShapeDeserializer2;
exports.CborShapeSerializer = CborShapeSerializer;
exports.CborShapeSerializer2 = CborShapeSerializer2;
exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol;
exports.buildHttpRpcRequest = buildHttpRpcRequest;
exports.cbor = cbor;
exports.checkCborResponse = checkCborResponse;
exports.dateToTag = dateToTag;
exports.loadSmithyRpcV2CborErrorCode = loadSmithyRpcV2CborErrorCode;
exports.parseCborBody = parseCborBody;
exports.parseCborErrorBody = parseCborErrorBody;
exports.tag = tag;
exports.tagSymbol = tagSymbol;
});
// ../../node_modules/.bun/@aws-sdk+xml-builder@3.972.40/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js
var require_dist_cjs5 = __commonJS(function(exports) {
var ATTR_ESCAPE_RE = /[&<>"]/g;
var ATTR_ESCAPE_MAP = {
"&": "&",
"<": "<",
">": ">",
'"': """
};
function escapeAttribute(value) {
return value.replace(ATTR_ESCAPE_RE, (ch) => ATTR_ESCAPE_MAP[ch]);
}
var ELEMENT_ESCAPE_RE = /[&"'<>\r\n\u0085\u2028]/g;
var ELEMENT_ESCAPE_MAP = {
"&": "&",
'"': """,
"'": "'",
"<": "<",
">": ">",
"\r": "
",
"\n": "
",
"\x85": "…",
"\u2028": "
"
};
function escapeElement(value) {
return value.replace(ELEMENT_ESCAPE_RE, (ch) => ELEMENT_ESCAPE_MAP[ch]);
}
class XmlText {
value;
constructor(value) {
this.value = value;
}
toString() {
return escapeElement("" + this.value);
}
}
class XmlNode {
name;
children;
attributes = {};
static of(name, childText, withName) {
const node = new XmlNode(name);
if (childText !== undefined) {
node.addChildNode(new XmlText(childText));
}
if (withName !== undefined) {
node.withName(withName);
}
return node;
}
constructor(name, children = []) {
this.name = name;
this.children = children;
}
withName(name) {
this.name = name;
return this;
}
addAttribute(name, value) {
this.attributes[name] = value;
return this;
}
addChildNode(child) {
this.children.push(child);
return this;
}
removeAttribute(name) {
delete this.attributes[name];
return this;
}
n(name) {
this.name = name;
return this;
}
c(child) {
this.children.push(child);
return this;
}
a(name, value) {
if (value != null) {
this.attributes[name] = value;
}
return this;
}
cc(input, field, withName = field) {
if (input[field] != null) {
const node = XmlNode.of(field, input[field]).withName(withName);
this.c(node);
}
}
l(input, listName, memberName, valueProvider) {
if (input[listName] != null) {
const nodes = valueProvider();
nodes.map((node) => {
node.withName(memberName);
this.c(node);
});
}
}
lc(input, listName, memberName, valueProvider) {
if (input[listName] != null) {
const nodes = valueProvider();
const containerNode = new XmlNode(memberName);
nodes.map((node) => {
containerNode.c(node);
});
this.c(containerNode);
}
}
toString() {
const hasChildren = Boolean(this.children.length);
let xmlText = `<${this.name}`;
const attributes = this.attributes;
for (const attributeName of Object.keys(attributes)) {
const attribute = attributes[attributeName];
if (attribute != null) {
xmlText += ` ${attributeName}="${escapeAttribute("" + attribute)}"`;
}
}
return xmlText += !hasChildren ? "/>" : `>${this.children.map((c) => c.toString()).join("")}</${this.name}>`;
}
}
function writeKey(obj) {
Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
}
function parseXML(xml) {
const state = new AwsXmlParser(xml);
return state.parse();
}
class AwsXmlParser {
x;
i = 0;
z;
constructor(x) {
this.x = x;
this.x = x.replace(/\r\n?/g, `
`);
this.z = this.x.length;
}
parse() {
const p = this;
const { z } = p;
while (p.i < z) {
p.trim();
if (p.i >= z) {
break;
}
if (p.isNext("<?")) {
p.readTo("?>");
p.trim();
} else if (p.isNext("<!--")) {
p.readTo("-->");
p.trim();
} else if (p.isNext("<!DOCTYPE", false)) {
p.skipDoctype();
p.trim();
} else if (p.x[p.i] === "<") {
const root = p.parseTag();
return { [root.tag]: root.value };
} else {
throw new Error("@aws-sdk XML parse error: unexpected content.");
}
}
throw new Error("@aws-sdk XML parse error: no root element.");
}
isNext(s, caseSensitive = true) {
const p = this;
if (caseSensitive) {
return p.x.startsWith(s, p.i);
}
return p.x.toLowerCase().startsWith(s.toLowerCase(), p.i);
}
readTo(stop) {
const p = this;
const _i = p.x.indexOf(stop, p.i);
if (_i === -1) {
throw new Error(`@aws-sdk XML parse error: expected "${stop}" not found.`);
}
const result = p.x.slice(p.i, _i);
p.i = _i + stop.length;
return result;
}
trim() {
const p = this;
while (p.i < p.z && ` \r
`.includes(p.x[p.i])) {
++p.i;
}
}
readAttrValue() {
const p = this;
const quote = p.x[p.i];
++p.i;
let value = "";
while (p.i < p.z && p.x[p.i] !== quote) {
value += p.x[p.i++];
}
++p.i;
return p.decodeEntities(value);
}
parseTag() {
const p = this;
++p.i;
let tag = "";
while (p.i < p.z && !` \r
>/`.includes(p.x[p.i])) {
tag += p.x[p.i++];
}
let hasAttrs = false;
const attrs = {};
while (p.i < p.z) {
p.trim();
if (">/".includes(p.x[p.i])) {
break;
}
let name = "";
while (p.i < p.z && !`= \r
>/?`.includes(p.x[p.i])) {
name += p.x[p.i++];
}
p.trim();
if (p.x[p.i] !== "=") {
break;
}
++p.i;
p.trim();
if (name === "__proto__") {
writeKey(attrs);
}
attrs[name] = p.readAttrValue();
hasAttrs = true;
}
if (p.i >= p.z) {
throw new Error("@aws-sdk XML parse error: unexpected end of input.");
}
if (p.x[p.i] === "/") {
++p.i;
if (p.i >= p.z || p.x[p.i] !== ">") {
throw new Error("@aws-sdk XML parse error: expected > at the end of self-closing tag.");
}
++p.i;
return { tag, value: hasAttrs ? attrs : "" };
}
if (p.x[p.i] !== ">") {
throw new Error("@aws-sdk XML parse error: expected > at the end of opening tag.");
}
++p.i;
const textParts = [];
const childTags = [];
let hasElementChild = false;
while (p.i < p.z) {
if (p.isNext("</")) {
break;
}
if (p.x[p.i] === "<") {
if (p.isNext("<!--")) {
p.readTo("-->");
} else if (p.isNext("<![CDATA[")) {
p.i += 9;
textParts.push(p.readTo("]]>"));
} else if (p.isNext("<?")) {
p.readTo("?>");
} else {
hasElementChild = true;
childTags.push(p.parseTag());
}
} else {
let text = "";
while (p.i < p.z && p.x[p.i] !== "<") {
text += p.x[p.i++];
}
textParts.push(p.decodeEntities(text));
}
}
if (!p.isNext("</")) {
throw new Error(`@aws-sdk XML parse error: missing closing tag </${tag}>.`);
}
p.i += 2;
const closeTag = p.readTo(">").trim();
if (closeTag !== tag) {
throw new Error(`@aws-sdk XML parse error: mismatched tags <${tag}> and </${closeTag}>.`);
}
if (!hasAttrs && textParts.length === 0 && !hasElementChild) {
return { tag, value: "" };
}
if (!hasAttrs && !hasElementChild) {
const text = textParts.length === 1 ? textParts[0] : textParts.join("");
if (text.trim() === "" && text.includes(`
`)) {
return { tag, value: "" };
}
return { tag, value: text };
}
const obj = {};
for (const text of textParts) {
if (text.trim() === "" && text.includes(`
`)) {
continue;
}
obj["#text"] = "#text" in obj ? obj["#text"] + text : text;
}
for (const child of childTags) {
if (child.tag === "__proto__") {
writeKey(obj);
}
if (child.tag in obj) {
if (Array.isArray(obj[child.tag])) {
obj[child.tag].push(child.value);
} else {
obj[child.tag] = [obj[child.tag], child.value];
}
} else {
obj[child.tag] = child.value;
}
}
for (const [k, v] of Object.entries(attrs)) {
if (k === "__proto__") {
writeKey(obj);
}
obj[k] = v;
}
return { tag, value: obj };
}
static ENTITIES = {
amp: "&",
lt: "<",
gt: ">",
quot: '"',
apos: "'"
};
skipDoctype() {
const p = this;
p.i += 9;
let depth = 0;
while (p.i < p.z) {
const c = p.x[p.i];
if (c === "[") {
++depth;
} else if (c === "]") {
--depth;
} else if (c === ">" && depth === 0) {
++p.i;
return;
}
++p.i;
}
throw new Error("@aws-sdk XML parse error: unclosed DOCTYPE.");
}
decodeEntities(s) {
return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{0,30}));/g, (_, hex, dec, named) => {
if (hex) {
return String.fromCharCode(parseInt(hex, 16));
}
if (dec) {
return String.fromCharCode(parseInt(dec, 10));
}
return AwsXmlParser.ENTITIES[named] ?? "";
});
}
}
exports.XmlNode = XmlNode;
exports.XmlText = XmlText;
exports.parseXML = parseXML;
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/protocols/index.js
var require_protocols2 = __commonJS(function(exports) {
var { SmithyRpcV2CborProtocol, loadSmithyRpcV2CborErrorCode } = require_cbor();
var { TypeRegistry, NormalizedSchema, deref } = require_schema();
var { decorateServiceException, getValueFromTextNode } = require_client();
var { collectBody, determineTimestampFormat, RpcProtocol, HttpBindingProtocol, HttpInterceptingShapeSerializer, HttpInterceptingShapeDeserializer, FromStringShapeDeserializer, extendedEncodeURIComponent } = require_protocols();
var { NumericValue, toUtf8, fromBase64, LazyJsonString, parseEpochTimestamp, parseRfc7231DateTime, parseRfc3339DateTimeWithOffset, generateIdempotencyToken, toBase64, dateToUtcString, expectUnion } = require_serde();
var { parseXML, XmlNode, XmlText } = require_dist_cjs5();
class ProtocolLib {
queryCompat;
errorRegistry;
constructor(queryCompat = false) {
this.queryCompat = queryCompat;
}
resolveRestContentType(defaultContentType, inputSchema) {
const members = inputSchema.getMemberSchemas();
const httpPayloadMember = Object.values(members).find((m) => {
return !!m.getMergedTraits().httpPayload;
});
if (httpPayloadMember) {
const mediaType = httpPayloadMember.getMergedTraits().mediaType;
if (mediaType) {
return mediaType;
} else if (httpPayloadMember.isStringSchema()) {
return "text/plain";
} else if (httpPayloadMember.isBlobSchema()) {
return "application/octet-stream";
} else {
return defaultContentType;
}
} else if (!inputSchema.isUnitSchema()) {
const hasBody = Object.values(members).find((m) => {
const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
const noPrefixHeaders = httpPrefixHeaders === undefined;
return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders;
});
if (hasBody) {
return defaultContentType;
}
}
}
async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) {
let errorName = errorIdentifier;
if (errorIdentifier.includes("#")) {
[, errorName] = errorIdentifier.split("#");
}
const errorMetadata = {
$metadata: metadata,
$fault: response.statusCode < 500 ? "client" : "server"
};
if (!this.errorRegistry) {
throw new Error("@aws-sdk/core/protocols - error handler not initialized.");
}
try {
const errorSchema = getErrorSchema?.(this.errorRegistry, errorName) ?? this.errorRegistry.getSchema(errorIdentifier);
return { errorSchema, errorMetadata };
} catch (e) {
dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const synthetic = this.errorRegistry;
const baseExceptionSchema = synthetic.getBaseException();
if (baseExceptionSchema) {
const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error;
throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject);
}
const d = dataObject;
const message = d?.message ?? d?.Message ?? d?.Error?.Message ?? d?.Error?.message;
throw this.decorateServiceException(Object.assign(new Error(message), {
name: errorName
}, errorMetadata), dataObject);
}
}
compose(composite, errorIdentifier, defaultNamespace) {
let namespace = defaultNamespace;
if (errorIdentifier.includes("#")) {
[namespace] = errorIdentifier.split("#");
}
const staticRegistry = TypeRegistry.for(namespace);
const defaultSyntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + defaultNamespace);
composite.copyFrom(staticRegistry);
composite.copyFrom(defaultSyntheticRegistry);
this.errorRegistry = composite;
}
decorateServiceException(exception, additions = {}) {
if (this.queryCompat) {
const msg = exception.Message ?? additions.Message;
const error = decorateServiceException(exception, additions);
if (msg) {
error.message = msg;
}
const errorObj = error.Error ?? {};
errorObj.Type = error.Error?.Type;
errorObj.Code = error.Error?.Code;
errorObj.Message = error.Error?.message ?? error.Error?.Message ?? msg;
error.Error = errorObj;
const reqId = error.$metadata.requestId;
if (reqId) {
error.RequestId = reqId;
}
return error;
}
return decorateServiceException(exception, additions);
}
setQueryCompatError(output, response) {
const queryErrorHeader = response.headers?.["x-amzn-query-error"];
if (output !== undefined && queryErrorHeader != null) {
const [Code, Type] = queryErrorHeader.split(";");
const keys = Object.keys(output);
const Error2 = {
Code,
Type
};
output.Code = Code;
output.Type = Type;
for (let i = 0;i < keys.length; i++) {
const k = keys[i];
Error2[k === "message" ? "Message" : k] = output[k];
}
delete Error2.__type;
output.Error = Error2;
}
}
queryCompatOutput(queryCompatErrorData, errorData) {
if (queryCompatErrorData.Error) {
errorData.Error = queryCompatErrorData.Error;
}
if (queryCompatErrorData.Type) {
errorData.Type = queryCompatErrorData.Type;
}
if (queryCompatErrorData.Code) {
errorData.Code = queryCompatErrorData.Code;
}
}
findQueryCompatibleError(registry, errorName) {
try {
return registry.getSchema(errorName);
} catch (e) {
return registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
}
}
}
class AwsSmithyRpcV2CborProtocol extends SmithyRpcV2CborProtocol {
awsQueryCompatible;
mixin;
constructor({ defaultNamespace, errorTypeRegistries, awsQueryCompatible }) {
super({ defaultNamespace, errorTypeRegistries });
this.awsQueryCompatible = !!awsQueryCompatible;
this.mixin = new ProtocolLib(this.awsQueryCompatible);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (this.awsQueryCompatible) {
request.headers["x-amzn-query-mode"] = "true";
}
return request;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
if (this.awsQueryCompatible) {
this.mixin.setQueryCompatError(dataObject, response);
}
const errorName = (() => {
const compatHeader = response.headers["x-amzn-query-error"];
if (compatHeader && this.awsQueryCompatible) {
return compatHeader.split(";")[0];
}
return loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
})();
this.mixin.compose(this.compositeErrorRegistry, errorName, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata, this.awsQueryCompatible ? this.mixin.findQueryCompatibleError : undefined);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {};
for (const [name, member] of ns.structIterator()) {
if (dataObject[name] != null) {
output[name] = this.deserializer.readValue(member, dataObject[name]);
}
}
if (this.awsQueryCompatible) {
this.mixin.queryCompatOutput(dataObject, output);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
}
class SerdeContextConfig {
serdeContext;
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
}
}
class UnionSerde {
from;
to;
keys;
constructor(from, to) {
this.from = from;
this.to = to;
const keys = Object.keys(this.from);
const set = new Set(keys);
set.delete("__type");
this.keys = set;
}
mark(key) {
this.keys.delete(key);
}
hasUnknown() {
return this.keys.size === 1 && Object.keys(this.to).length === 0;
}
writeUnknown() {
if (this.hasUnknown()) {
const k = this.keys.values().next().value;
const v = this.from[k];
this.to.$unknown = [k, v];
}
}
}
var canParseBuffer;
function detectBufferParsing() {
if (canParseBuffer === undefined) {
try {
if (typeof Buffer !== "function") {
canParseBuffer = false;
} else {
const result = JSON.parse(Buffer.from([123, 125]));
canParseBuffer = result !== null && typeof result === "object";
}
} catch {
canParseBuffer = false;
}
}
return canParseBuffer;
}
function jsonReviver(key, value, context) {
if (context?.source) {
const numericString = context.source;
if (typeof value === "number") {
const inSafeRange = value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER;
if (inSafeRange) {
if (isRepresentable(numericString, value)) {
return value;
}
return new NumericValue(numericString, "bigDecimal");
} else {
if (isFractionalBigNumeric(numericString)) {
return new NumericValue(numericString, "bigDecimal");
}
if (/[eE]/.test(numericString)) {
return expandExponentToBigInt(numericString);
}
return BigInt(numericString);
}
}
}
return value;
}
function isFractionalBigNumeric(s) {
const dotIndex = s.indexOf(".");
if (dotIndex === -1) {
return false;
}
const eIndex = s.search(/[eE]/);
if (eIndex === -1) {
return true;
}
const fracDigits = eIndex - dotIndex - 1;
const exp = parseInt(s.slice(eIndex + 1), 10);
return exp < fracDigits;
}
function isRepresentable(numericString, value) {
if (numericString === String(value)) {
return true;
}
if (Object.is(value, -0)) {
return true;
}
if (/[eE]/.test(numericString)) {
return expandToDecimal(numericString) === expandToDecimal(String(value));
}
const normalized = numericString.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
const canonical = String(value);
if (normalized === canonical) {
return true;
}
if (/[eE]/.test(canonical)) {
return normalized === expandToDecimal(canonical);
}
return false;
}
function expandToDecimal(s) {
const negative = s.startsWith("-");
const abs = negative ? s.slice(1) : s;
const eIndex = abs.search(/[eE]/);
let result;
if (eIndex === -1) {
result = abs;
} else {
const exp = parseInt(abs.slice(eIndex + 1), 10);
const mantissa = abs.slice(0, eIndex);
const dotIndex = mantissa.indexOf(".");
let digits;
let intLen;
if (dotIndex === -1) {
digits = mantissa;
intLen = mantissa.length;
} else {
digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
intLen = dotIndex;
}
digits = digits.replace(/0+$/, "") || "0";
const newDotPos = intLen + exp;
if (digits === "0") {
result = "0";
} else if (newDotPos <= 0) {
result = "0." + "0".repeat(-newDotPos) + digits;
} else if (newDotPos >= digits.length) {
result = digits + "0".repeat(newDotPos - digits.length);
} else {
result = digits.slice(0, newDotPos) + "." + digits.slice(newDotPos);
}
}
if (result.includes(".")) {
result = result.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
}
return (negative ? "-" : "") + result;
}
function expandExponentToBigInt(s) {
const eIndex = s.search(/[eE]/);
const exp = parseInt(s.slice(eIndex + 1), 10);
const negative = s.startsWith("-");
const mantissa = s.slice(negative ? 1 : 0, eIndex);
const dotIndex = mantissa.indexOf(".");
let digits;
let shift;
if (dotIndex === -1) {
digits = mantissa;
shift = exp;
} else {
digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
const fracDigits = mantissa.length - dotIndex - 1;
shift = exp - fracDigits;
}
digits = digits.replace(/0+$/, "") || "0";
const result = BigInt(digits) * 10n ** BigInt(shift + (mantissa.replace(".", "").length - digits.length));
return negative ? -result : result;
}
var REVIVER_SYMBOL = Symbol.for("@aws-sdk/reviver");
function needsReviver(schema) {
const ns = NormalizedSchema.of(schema);
const raw = ns.getSchema();
if (Array.isArray(raw) && ns.isStructSchema()) {
if (REVIVER_SYMBOL in raw) {
return raw[REVIVER_SYMBOL];
}
const result = _check(ns, new Set);
raw[REVIVER_SYMBOL] = result;
return result;
}
return _check(ns, new Set);
}
function _check(ns, seen) {
const raw = ns.getSchema();
if (seen.has(raw)) {
return false;
}
seen.add(raw);
if (ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
return true;
}
if (ns.isStructSchema()) {
for (const [, memberSchema] of ns.structIterator()) {
if (_check(memberSchema, seen)) {
return true;
}
}
} else if (ns.isListSchema() || ns.isMapSchema()) {
if (_check(ns.getValueSchema(), seen)) {
return true;
}
} else if (ns.isDocumentSchema()) {
return true;
}
return false;
}
var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));
async function parseJsonBody(streamBody, context, schema) {
let parsingInput;
if (detectBufferParsing() && typeof streamBody?.[Symbol.asyncIterator] === "function") {
const buffer = await collectBody(streamBody, context);
if (typeof Buffer === "function") {
if (Buffer.isBuffer(buffer)) {
parsingInput = buffer;
} else {
parsingInput = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
}
}
if (!parsingInput) {
parsingInput = await collectBodyString(streamBody, context);
}
if (parsingInput.length === 0) {
return {};
}
const reviver = schema && needsReviver(schema) ? jsonReviver : undefined;
try {
return JSON.parse(parsingInput, reviver);
} catch (e) {
if (e?.name === "SyntaxError") {
Object.defineProperty(e, "$responseBodyText", {
value: typeof parsingInput === "string" ? parsingInput : parsingInput.toString("utf8")
});
}
throw e;
}
}
var parseJsonErrorBody = async (errorBody, context) => {
const value = await parseJsonBody(errorBody, context);
value.message = value.message ?? value.Message;
return value;
};
var findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
var sanitizeErrorCode = (rawValue) => {
let cleanValue = rawValue;
if (typeof cleanValue === "number") {
cleanValue = cleanValue.toString();
}
if (cleanValue.indexOf(",") >= 0) {
cleanValue = cleanValue.split(",")[0];
}
if (cleanValue.indexOf(":") >= 0) {
cleanValue = cleanValue.split(":")[0];
}
if (cleanValue.indexOf("#") >= 0) {
cleanValue = cleanValue.split("#")[1];
}
return cleanValue;
};
var loadRestJsonErrorCode = (output, data) => {
return loadErrorCode(output, data, ["header", "code", "type"]);
};
var loadJsonRpcErrorCode = (output, data, queryCompat = false) => {
return loadErrorCode(output, data, queryCompat ? ["code", "header", "type"] : ["type", "code", "header"]);
};
var loadErrorCode = ({ headers }, data, order) => {
while (order.length > 0) {
const location = order.shift();
switch (location) {
case "header":
const headerKey = findKey(headers ?? {}, "x-amzn-errortype");
if (headerKey !== undefined) {
return sanitizeErrorCode(headers[headerKey]);
}
break;
case "code":
const codeKey = findKey(data ?? {}, "code");
if (codeKey && data[codeKey] !== undefined) {
return sanitizeErrorCode(data[codeKey]);
}
break;
case "type":
if (data?.__type !== undefined) {
return sanitizeErrorCode(data.__type);
}
break;
}
}
};
function writeKey(obj) {
Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
}
class JsonShapeDeserializer2 extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
async read(schema, data) {
const reviver = needsReviver(schema) ? jsonReviver : undefined;
let parsed;
if (typeof data === "string") {
if (data.length === 0) {
return {};
}
parsed = JSON.parse(data, reviver);
} else if (data instanceof Uint8Array && detectBufferParsing()) {
if (data.byteLength === 0) {
return {};
}
const buf = Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
parsed = JSON.parse(buf, reviver);
} else {
parsed = await parseJsonBody(data, this.serdeContext, schema);
}
return this._read(schema, parsed);
}
readObject(schema, data) {
return this._read(schema, data);
}
_read(schema, value) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
return this._readStruct(ns, value);
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
if (this.needsTransform(listMember)) {
for (let i = 0;i < value.length; ++i) {
value[i] = this._read(listMember, value[i]);
}
}
return value;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const map = value;
if (this.needsTransform(mapMember)) {
for (const k in map) {
if (k === "__proto__") {
writeKey(map);
}
map[k] = this._read(mapMember, map[k]);
}
}
return map;
}
}
if (ns.isBlobSchema() && typeof value === "string") {
return fromBase64(value);
}
const mediaType = ns.getMergedTraits().mediaType;
if (ns.isStringSchema() && typeof value === "string" && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
return value;
}
if (ns.isTimestampSchema() && value != null) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return parseRfc3339DateTimeWithOffset(value);
case 6:
return parseRfc7231DateTime(value);
case 7:
return parseEpochTimestamp(value);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", value);
return new Date(value);
}
}
if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
return BigInt(value);
}
if (ns.isBigDecimalSchema() && value != null) {
if (value instanceof NumericValue) {
return value;
}
const untyped = value;
if (untyped.type === "bigDecimal" && "string" in untyped) {
return new NumericValue(untyped.string, untyped.type);
}
return new NumericValue(String(value), "bigDecimal");
}
if (ns.isNumericSchema() && typeof value === "string") {
switch (value) {
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
case "NaN":
return NaN;
}
return value;
}
if (ns.isDocumentSchema()) {
if (isObject) {
if (Array.isArray(value)) {
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (!(v instanceof NumericValue)) {
value[i] = this._read(ns, v);
}
}
} else {
const doc = value;
for (const k in doc) {
if (k === "__proto__") {
writeKey(doc);
}
const v = doc[k];
if (!(v instanceof NumericValue)) {
doc[k] = this._read(ns, v);
}
}
}
}
}
return value;
}
_readStruct(ns, record) {
const union = ns.isUnionSchema();
const out = {};
let nameMap;
const hasType = typeof record.__type === "string";
const { jsonName } = this.settings;
if (jsonName && hasType) {
nameMap = {};
}
let unionSerde;
if (union) {
unionSerde = new UnionSerde(record, out);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
let fromKey = memberName;
if (jsonName) {
fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
if (hasType) {
nameMap[fromKey] = memberName;
}
}
if (union) {
unionSerde.mark(fromKey);
}
if (record[fromKey] != null) {
out[memberName] = this._read(memberSchema, record[fromKey]);
}
}
if (union) {
unionSerde.writeUnknown();
} else if (hasType) {
for (const k in record) {
const v = record[k];
const t = jsonName ? nameMap[k] ?? k : k;
if (!(t in out)) {
out[t] = v;
}
}
}
return out;
}
needsTransform(ns) {
if (ns.isBlobSchema() || ns.isTimestampSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
return true;
}
if (ns.isDocumentSchema() || ns.isStructSchema() || ns.isListSchema() || ns.isMapSchema()) {
return true;
}
if (ns.isStringSchema() && ns.getMergedTraits().mediaType) {
return true;
}
return false;
}
}
class JsonBytesStringAdapter extends Uint8Array {
string = null;
static allocUnsafe(bytes) {
if (typeof Buffer === "function") {
const buffer = Buffer.allocUnsafe(bytes);
return new JsonBytesStringAdapter(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
return new JsonBytesStringAdapter(bytes);
}
toString() {
return this.s();
}
valueOf() {
return this.s();
}
includes(searchString, position) {
if (typeof searchString === "string") {
return this.s().includes(searchString, position);
}
return Uint8Array.prototype.includes.call(this, searchString, position);
}
indexOf(searchString, position) {
if (typeof searchString === "string") {
return this.s().indexOf(searchString, position);
}
return Uint8Array.prototype.indexOf.call(this, searchString, position);
}
lastIndexOf(searchString, position) {
if (typeof searchString === "string") {
return this.s().lastIndexOf(searchString, position);
}
const fn = Uint8Array.prototype.lastIndexOf;
if (position !== undefined) {
return fn.call(this, searchString, position);
}
return fn.call(this, searchString);
}
startsWith(searchString, position) {
return this.s().startsWith(searchString, position);
}
endsWith(searchString, endPosition) {
return this.s().endsWith(searchString, endPosition);
}
match(regexp) {
return this.s().match(regexp);
}
replace(searchValue, replaceValue) {
return this.s().replace(searchValue, replaceValue);
}
search(regexp) {
return this.s().search(regexp);
}
split(separator, limit) {
return this.s().split(separator, limit);
}
substring(start, end) {
return this.s().substring(start, end);
}
trim() {
return this.s().trim();
}
trimStart() {
return this.s().trimStart();
}
trimEnd() {
return this.s().trimEnd();
}
charAt(pos) {
return this.s().charAt(pos);
}
charCodeAt(index) {
return this.s().charCodeAt(index);
}
padStart(maxLength, fillString) {
return this.s().padStart(maxLength, fillString);
}
padEnd(maxLength, fillString) {
return this.s().padEnd(maxLength, fillString);
}
repeat(count) {
return this.s().repeat(count);
}
toUpperCase() {
return this.s().toUpperCase();
}
toLowerCase() {
return this.s().toLowerCase();
}
s() {
if (this.string == null) {
const n = Date.now();
if (n > warned + 60000) {
console.warn("@aws-sdk/core/protocols - WARN - JsonCodec2: you have called a string method on a Uint8Array request body. " + "It has been automatically converted to string. In a future version this will throw an error.");
warned = n;
}
this.string = toUtf8(this);
}
return this.string;
}
}
var warned = 0;
var encoder = new TextEncoder;
var OPEN_BRACE = 123;
var CLOSE_BRACE = 125;
var OPEN_BRACKET = 91;
var CLOSE_BRACKET = 93;
var QUOTE = 34;
var COLON = 58;
var COMMA = 44;
var BACKSLASH = 92;
var TRUE = new Uint8Array([116, 114, 117, 101]);
var FALSE = new Uint8Array([102, 97, 108, 115, 101]);
var NULL = new Uint8Array([110, 117, 108, 108]);
var ESCAPE_TABLE = new Array(128).fill(null);
ESCAPE_TABLE[8] = "b";
ESCAPE_TABLE[9] = "t";
ESCAPE_TABLE[10] = "n";
ESCAPE_TABLE[12] = "f";
ESCAPE_TABLE[13] = "r";
ESCAPE_TABLE[34] = '"';
ESCAPE_TABLE[92] = "\\";
for (let i = 0;i < 32; i++) {
if (ESCAPE_TABLE[i] === null) {
ESCAPE_TABLE[i] = "u00" + i.toString(16).padStart(2, "0");
}
}
var INITIAL_BUFFER_SIZE = 2048;
function alloc(size) {
return JsonBytesStringAdapter.allocUnsafe(size);
}
class JsonShapeSerializer2 extends SerdeContextConfig {
settings;
json;
i = 0;
rootSchema;
rawValue;
passthrough = false;
constructor(settings) {
super();
this.settings = settings;
this.json = alloc(INITIAL_BUFFER_SIZE);
}
write(schema, value) {
this.i = 0;
this.rawValue = value;
this.rootSchema = NormalizedSchema.of(schema);
this.passthrough = this.rootSchema.isBlobSchema() || this.rootSchema.isStringSchema();
if (!this.passthrough) {
this.writeValue(this.rootSchema, value, undefined);
}
}
writeDiscriminatedDocument(schema, value) {
this.i = 0;
this.rootSchema = NormalizedSchema.of(schema);
const ns = this.rootSchema;
if (ns.isStructSchema() && value != null && typeof value === "object") {
this.writeValue(ns, value, undefined);
const prefix = `"__type":"${ns.getName(true) ?? "Unknown"}",`;
const z = prefix.length;
this.ensure(z);
this.json.copyWithin(1 + z, 1, this.i);
encoder.encodeInto(prefix, this.json.subarray(1));
this.i += z;
} else {
this.writeValue(ns, value, undefined);
}
}
flush() {
this.rootSchema = undefined;
const finalPosition = this.i;
this.i = 0;
const raw = this.rawValue;
this.rawValue = undefined;
if (finalPosition === 0) {
return raw;
}
const result = this.json.subarray(0, finalPosition);
this.json = alloc(INITIAL_BUFFER_SIZE);
return result;
}
ensure(byteCount) {
const { i, json } = this;
if (i + byteCount > json.length) {
let newSize = json.length * 2;
while (newSize < i + byteCount) {
newSize *= 2;
}
const next = alloc(newSize);
next.set(this.json);
this.json = next;
}
}
writeAscii(s) {
const z = s.length;
this.ensure(z);
let { i, json } = this;
for (let j = 0;j < z; ++j) {
json[i] = s.charCodeAt(j);
i += 1;
}
this.i = i;
}
writeAsciiQuoted(s) {
const z = s.length;
this.ensure(z + 4);
let { json, i } = this;
json[i++] = QUOTE;
for (let j = 0;j < z; ++j) {
json[i++] = s.charCodeAt(j);
}
json[i++] = QUOTE;
this.i = i;
}
writeJsonString(s) {
this.ensure(s.length * 3 + 2);
this.json[this.i++] = QUOTE;
const z = s.length;
for (let j = 0;j < z; ++j) {
const c = s.charCodeAt(j);
if (c > 34 && c < 92) {
this.json[this.i++] = c;
} else if (c < 128) {
const esc = ESCAPE_TABLE[c];
if (esc !== null) {
this.ensure(esc.length + 1);
this.json[this.i++] = BACKSLASH;
for (let k = 0;k < esc.length; k++) {
this.json[this.i++] = esc.charCodeAt(k);
}
} else {
this.json[this.i++] = c;
}
} else if (c >= 55296 && c <= 56319) {
const next = j + 1 < z ? s.charCodeAt(j + 1) : 0;
if (next >= 56320 && next <= 57343) {
this.ensure(4);
const { written } = encoder.encodeInto(s.substring(j, j + 2), this.json.subarray(this.i));
this.i += written;
++j;
} else {
this.ensure(6);
this.writeUnicodeEscape(c);
}
} else if (c >= 56320 && c <= 57343) {
this.ensure(6);
this.writeUnicodeEscape(c);
} else {
let { i, json } = this;
if (c < 2048) {
json[i++] = 192 | c >> 6;
json[i++] = 128 | c & 63;
} else {
json[i++] = 224 | c >> 12;
json[i++] = 128 | c >> 6 & 63;
json[i++] = 128 | c & 63;
}
this.i = i;
}
}
this.json[this.i++] = QUOTE;
}
writeUnicodeEscape(code) {
let { json, i } = this;
json[i++] = BACKSLASH;
json[i++] = 117;
const hex = code.toString(16).padStart(4, "0");
for (let j = 0;j < 4; ++j) {
json[i++] = hex.charCodeAt(j);
}
this.i = i;
}
static B64 = (() => {
const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const table = new Uint8Array(64);
for (let i = 0;i < 64; ++i) {
table[i] = chars.charCodeAt(i);
}
return table;
})();
writeBase64(data) {
const b64Len = Math.ceil(data.length / 3) * 4;
this.ensure(b64Len + 2);
const json = this.json;
const B64 = JsonShapeSerializer2.B64;
let i = this.i;
json[i++] = QUOTE;
const len = data.length;
const remainder = len % 3;
const mainLen = len - remainder;
for (let j = 0;j < mainLen; j += 3) {
const a = data[j];
const b = data[j + 1];
const c = data[j + 2];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4 | b >> 4];
json[i++] = B64[(b & 15) << 2 | c >> 6];
json[i++] = B64[c & 63];
}
if (remainder === 2) {
const a = data[mainLen];
const b = data[mainLen + 1];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4 | b >> 4];
json[i++] = B64[(b & 15) << 2];
json[i++] = 61;
} else if (remainder === 1) {
const a = data[mainLen];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4];
json[i++] = 61;
json[i++] = 61;
}
json[i++] = QUOTE;
this.i = i;
}
writeValue(schema, value, container) {
if (value == null) {
if (container?.isStructSchema()) {
if (value === undefined) {
const ns = NormalizedSchema.of(schema);
if (ns.isIdempotencyToken()) {
this.writeAsciiQuoted(generateIdempotencyToken());
return;
}
}
return;
}
this.ensure(4);
this.json.set(NULL, this.i);
this.i += 4;
return;
}
const ns = NormalizedSchema.of(schema);
const isObject = typeof value === "object";
if (ns.isStringSchema()) {
const mediaType = ns.getMergedTraits().mediaType;
if (mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
this.writeJsonString(LazyJsonString.from(value).toString());
return;
}
}
}
if (isObject) {
if (ns.isStructSchema()) {
this.writeStruct(ns, value);
return;
}
if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
this.writeList(ns, value, ns.isDocumentSchema());
return;
}
if (ns.isMapSchema()) {
this.writeMap(ns, value, false);
return;
}
if (value instanceof Uint8Array && (ns.isBlobSchema() || ns.isDocumentSchema())) {
this.writeBase64(value);
return;
}
if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
this.writeTimestamp(ns, value);
return;
}
if (value instanceof NumericValue) {
this.writeAscii(value.string);
return;
}
if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
this.writeList(ns, value, true);
} else {
this.writeMap(ns, value, true);
}
return;
}
const json = JSON.stringify(value);
this.writeAscii(json);
return;
}
if (typeof value === "string") {
if (ns.isBlobSchema()) {
const b64 = (this.serdeContext?.base64Encoder ?? toBase64)(value);
this.writeAsciiQuoted(b64);
return;
}
this.writeJsonString(value);
return;
}
if (typeof value === "number") {
if (Math.abs(value) === Infinity || Number.isNaN(value)) {
this.writeAsciiQuoted(String(value));
return;
}
const numStr = String(value);
this.writeAscii(numStr);
return;
}
if (typeof value === "boolean") {
this.ensure(5);
let { i, json } = this;
if (value) {
json.set(TRUE, i);
i += 4;
} else {
json.set(FALSE, i);
i += 5;
}
this.i = i;
return;
}
if (typeof value === "bigint") {
this.writeAscii(value.toString());
return;
}
this.writeAscii(String(value));
}
writeStruct(ns, value) {
this.ensure(2);
this.json[this.i++] = OPEN_BRACE;
let wroteAny = false;
const hasType = typeof value.__type === "string";
let writtenKeys;
if (hasType) {
writtenKeys = new Set;
}
for (const [memberName, memberSchema] of ns.structIterator()) {
const item = value[memberName];
if (item == null && !memberSchema.isIdempotencyToken()) {
continue;
}
if (wroteAny) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
wroteAny = true;
const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
if (writtenKeys) {
writtenKeys.add(memberName);
writtenKeys.add(targetKey);
}
this.writeAsciiQuoted(targetKey);
this.json[this.i++] = COLON;
this.writeValue(memberSchema, item, ns);
}
if (!wroteAny && ns.isUnionSchema()) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
this.writeAsciiQuoted(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(15, v, ns);
}
} else if (hasType) {
for (const k in value) {
if (writtenKeys.has(k)) {
continue;
}
writtenKeys.add(k);
const v = value[k];
if (wroteAny) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
wroteAny = true;
this.writeAsciiQuoted(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(15, v, undefined);
}
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACE;
}
writeList(ns, value, isDocument) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (!isDocument) {
if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
let hasSpecials = false;
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (Number.isNaN(v) || v === Infinity || v === -Infinity || v == null && !sparse) {
hasSpecials = true;
break;
}
}
let json;
if (!hasSpecials) {
json = JSON.stringify(value);
} else {
const out = [];
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (v == null && !sparse)
continue;
if (Number.isNaN(v) || v === Infinity || v === -Infinity) {
out.push(String(v));
} else {
out.push(v);
}
}
json = JSON.stringify(out);
}
this.ensure(json.length * 3);
this.i += encoder.encodeInto(json, this.json.subarray(this.i)).written;
return;
}
}
this.ensure(2);
this.json[this.i++] = OPEN_BRACKET;
let wroteFirstItem = false;
for (let i = 0;i < value.length; ++i) {
const item = value[i];
if (isDocument ? item === undefined : item == null && !sparse) {
continue;
}
if (wroteFirstItem) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
this.writeValue(valueSchema, item, undefined);
wroteFirstItem = true;
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACKET;
}
writeMap(ns, value, isDocument) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (!isDocument) {
if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
let modifications;
for (const k in value) {
const v = value[k];
if (Number.isNaN(v) || v === Infinity || v === -Infinity) {
(modifications ??= {})[k] = v;
value[k] = String(v);
} else if (v === null && !sparse) {
(modifications ??= {})[k] = null;
value[k] = undefined;
}
}
const json = JSON.stringify(value);
if (modifications) {
Object.assign(value, modifications);
}
this.ensure(json.length * 3);
this.i += encoder.encodeInto(json, this.json.subarray(this.i)).written;
return;
}
}
this.ensure(2);
this.json[this.i++] = OPEN_BRACE;
let first = true;
for (const k in value) {
const v = value[k];
if (isDocument ? v === undefined : v == null && !sparse) {
continue;
}
if (!first) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
first = false;
this.writeJsonString(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(valueSchema, v, undefined);
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACE;
}
writeTimestamp(ns, value) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5: {
const iso = value.toISOString().replace(".000Z", "Z");
this.writeAsciiQuoted(iso);
return;
}
case 6: {
this.writeAsciiQuoted(dateToUtcString(value));
return;
}
case 7: {
const epochSecs = String(value.getTime() / 1000);
this.writeAscii(epochSecs);
return;
}
default: {
const epochSecs = String(value.getTime() / 1000);
this.writeAscii(epochSecs);
return;
}
}
}
}
class JsonCodec2 extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new JsonShapeSerializer2(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new JsonShapeDeserializer2(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class AwsJsonRpcProtocol extends RpcProtocol {
serializer;
deserializer;
serviceTarget;
codec;
mixin;
awsQueryCompatible;
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries
});
this.serviceTarget = serviceTarget;
this.codec = jsonCodec ?? new JsonCodec2({
timestampFormat: {
useTrait: true,
default: 7
},
jsonName: false
});
this.serializer = this.codec.createSerializer();
this.deserializer = this.codec.createDeserializer();
this.awsQueryCompatible = !!awsQueryCompatible;
this.mixin = new ProtocolLib(this.awsQueryCompatible);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (!request.path.endsWith("/")) {
request.path += "/";
}
request.headers["content-type"] = `application/x-amz-json-${this.getJsonRpcVersion()}`;
request.headers["x-amz-target"] = `${this.serviceTarget}.${operationSchema.name}`;
if (this.awsQueryCompatible) {
request.headers["x-amzn-query-mode"] = "true";
}
if (deref(operationSchema.input) === "unit" || !request.body) {
request.body = "{}";
}
return request;
}
getPayloadCodec() {
return this.codec;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const { awsQueryCompatible } = this;
if (awsQueryCompatible) {
this.mixin.setQueryCompatError(dataObject, response);
}
const errorIdentifier = loadJsonRpcErrorCode(response, dataObject, awsQueryCompatible) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata, awsQueryCompatible ? this.mixin.findQueryCompatibleError : undefined);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
if (dataObject[name] != null) {
output[name] = errorDeserializer.readObject(member, dataObject[name]);
}
}
if (awsQueryCompatible) {
this.mixin.queryCompatOutput(dataObject, output);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
}
class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries,
serviceTarget,
awsQueryCompatible,
jsonCodec
});
}
getShapeId() {
return "aws.protocols#awsJson1_0";
}
getJsonRpcVersion() {
return "1.0";
}
getDefaultContentType() {
return "application/x-amz-json-1.0";
}
}
class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries,
serviceTarget,
awsQueryCompatible,
jsonCodec
});
}
getShapeId() {
return "aws.protocols#awsJson1_1";
}
getJsonRpcVersion() {
return "1.1";
}
getDefaultContentType() {
return "application/x-amz-json-1.1";
}
}
class AwsRestJsonProtocol extends HttpBindingProtocol {
serializer;
deserializer;
codec;
mixin = new ProtocolLib;
constructor({ defaultNamespace, errorTypeRegistries, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries
});
const settings = {
timestampFormat: {
useTrait: true,
default: 7
},
httpBindings: true,
jsonName: true
};
this.codec = jsonCodec ?? new JsonCodec2(settings);
this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
}
getShapeId() {
return "aws.protocols#restJson1";
}
getPayloadCodec() {
return this.codec;
}
setSerdeContext(serdeContext) {
this.codec.setSerdeContext(serdeContext);
super.setSerdeContext(serdeContext);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
const inputSchema = NormalizedSchema.of(operationSchema.input);
if (!request.headers["content-type"]) {
const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
if (contentType) {
request.headers["content-type"] = contentType;
}
}
if (request.body == null && request.headers["content-type"] === this.getDefaultContentType()) {
request.body = "{}";
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
const output = await super.deserializeResponse(operationSchema, context, response);
const outputSchema = NormalizedSchema.of(operationSchema.output);
for (const [name, member] of outputSchema.structIterator()) {
if (member.getMemberTraits().httpPayload && !(name in output)) {
output[name] = null;
}
}
return output;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().jsonName ?? name;
output[name] = errorDeserializer.readObject(member, dataObject[target]);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
getDefaultContentType() {
return "application/json";
}
}
class JsonShapeDeserializer extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
async read(schema, data) {
const reviver = needsReviver(schema) ? jsonReviver : undefined;
return this._read(schema, typeof data === "string" ? JSON.parse(data, reviver) : await parseJsonBody(data, this.serdeContext, schema));
}
readObject(schema, data) {
return this._read(schema, data);
}
_read(schema, value) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
const record = value;
const union = ns.isUnionSchema();
const out = {};
let nameMap = undefined;
const { jsonName } = this.settings;
if (jsonName) {
nameMap = {};
}
let unionSerde;
if (union) {
unionSerde = new UnionSerde(record, out);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
let fromKey = memberName;
if (jsonName) {
fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
nameMap[fromKey] = memberName;
}
if (union) {
unionSerde.mark(fromKey);
}
if (record[fromKey] != null) {
out[memberName] = this._read(memberSchema, record[fromKey]);
}
}
if (union) {
unionSerde.writeUnknown();
} else if (typeof record.__type === "string") {
for (const k in record) {
const v = record[k];
const t = jsonName ? nameMap[k] ?? k : k;
if (!(t in out)) {
out[t] = v;
}
}
}
return out;
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
const out = [];
for (const item of value) {
out.push(this._read(listMember, item));
}
return out;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const out = {};
for (const _k in value) {
if (_k === "__proto__") {
writeKey(out);
}
out[_k] = this._read(mapMember, value[_k]);
}
return out;
}
}
if (ns.isBlobSchema() && typeof value === "string") {
return fromBase64(value);
}
const mediaType = ns.getMergedTraits().mediaType;
if (ns.isStringSchema() && typeof value === "string" && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
return value;
}
if (ns.isTimestampSchema() && value != null) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return parseRfc3339DateTimeWithOffset(value);
case 6:
return parseRfc7231DateTime(value);
case 7:
return parseEpochTimestamp(value);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", value);
return new Date(value);
}
}
if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
return BigInt(value);
}
if (ns.isBigDecimalSchema() && value != null) {
if (value instanceof NumericValue) {
return value;
}
const untyped = value;
if (untyped.type === "bigDecimal" && "string" in untyped) {
return new NumericValue(untyped.string, untyped.type);
}
return new NumericValue(String(value), "bigDecimal");
}
if (ns.isNumericSchema() && typeof value === "string") {
switch (value) {
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
case "NaN":
return NaN;
}
return value;
}
if (ns.isDocumentSchema()) {
if (isObject) {
const out = Array.isArray(value) ? [] : {};
for (const k in value) {
if (k === "__proto__") {
writeKey(out);
}
const v = value[k];
if (v instanceof NumericValue) {
out[k] = v;
} else {
out[k] = this._read(ns, v);
}
}
return out;
} else {
return structuredClone(value);
}
}
return value;
}
}
var NUMERIC_CONTROL_CHAR = String.fromCharCode(925);
class JsonReplacer {
values = new Map;
counter = 0;
stage = 0;
createReplacer() {
if (this.stage === 1) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer already created.");
}
if (this.stage === 2) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
}
this.stage = 1;
return (key, value) => {
if (value instanceof NumericValue) {
const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string;
this.values.set(`"${v}"`, value.string);
return v;
}
if (typeof value === "bigint") {
const s = value.toString();
const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s;
this.values.set(`"${v}"`, s);
return v;
}
return value;
};
}
replaceInJson(json) {
if (this.stage === 0) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet.");
}
if (this.stage === 2) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
}
this.stage = 2;
if (this.counter === 0) {
return json;
}
for (const [key, value] of this.values) {
json = json.replace(key, value);
}
return json;
}
}
class JsonShapeSerializer extends SerdeContextConfig {
settings;
buffer;
useReplacer = false;
rootSchema;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
this.rootSchema = NormalizedSchema.of(schema);
this.buffer = this._write(this.rootSchema, value);
}
flush() {
const { rootSchema, useReplacer } = this;
this.rootSchema = undefined;
this.useReplacer = false;
if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) {
if (!useReplacer) {
return JSON.stringify(this.buffer);
}
const replacer = new JsonReplacer;
return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0));
}
return this.buffer;
}
writeDiscriminatedDocument(schema, value) {
this.write(schema, value);
if (typeof this.buffer === "object") {
this.buffer.__type = NormalizedSchema.of(schema).getName(true);
}
}
_write(schema, value, container) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
const record = value;
const out = {};
const { jsonName } = this.settings;
let nameMap = undefined;
if (jsonName) {
nameMap = {};
}
let outCount = 0;
for (const [memberName, memberSchema] of ns.structIterator()) {
const serializableValue = this._write(memberSchema, record[memberName], ns);
if (serializableValue !== undefined) {
let targetKey = memberName;
if (jsonName) {
targetKey = memberSchema.getMergedTraits().jsonName ?? memberName;
nameMap[memberName] = targetKey;
}
out[targetKey] = serializableValue;
outCount++;
}
}
if (ns.isUnionSchema() && outCount === 0) {
const { $unknown } = record;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
if (k === "__proto__") {
writeKey(out);
}
out[k] = this._write(15, v);
}
} else if (typeof record.__type === "string") {
for (const k in record) {
const v = record[k];
const targetKey = jsonName ? nameMap[k] ?? k : k;
if (!(targetKey in out)) {
out[targetKey] = this._write(15, v);
}
}
}
return out;
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
const out = [];
const sparse = !!ns.getMergedTraits().sparse;
for (const item of value) {
if (sparse || item != null) {
out.push(this._write(listMember, item));
}
}
return out;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const out = {};
const sparse = !!ns.getMergedTraits().sparse;
for (const _k in value) {
const _v = value[_k];
if (sparse || _v != null) {
if (_k === "__proto__") {
writeKey(out);
}
out[_k] = this._write(mapMember, _v);
}
}
return out;
}
if (value instanceof Uint8Array && ns.isBlobSchema()) {
if (ns === this.rootSchema) {
return value;
}
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return value.toISOString().replace(".000Z", "Z");
case 6:
return dateToUtcString(value);
case 7:
return value.getTime() / 1000;
default:
console.warn("Missing timestamp format, using epoch seconds", value);
return value.getTime() / 1000;
}
}
if (value instanceof NumericValue) {
this.useReplacer = true;
}
}
if (value === null && container?.isStructSchema()) {
return;
}
if (ns.isStringSchema()) {
if (typeof value === "undefined" && ns.isIdempotencyToken()) {
return generateIdempotencyToken();
}
const mediaType = ns.getMergedTraits().mediaType;
if (value != null && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
}
return value;
}
if (typeof value === "number") {
if (Math.abs(value) === Infinity || isNaN(value)) {
return String(value);
}
return value;
}
if (typeof value === "string" && ns.isBlobSchema()) {
if (ns === this.rootSchema) {
return value;
}
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
if (typeof value === "bigint") {
this.useReplacer = true;
}
if (ns.isDocumentSchema()) {
if (isObject) {
if (value instanceof Uint8Array) {
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
const out = Array.isArray(value) ? [] : {};
for (const k in value) {
const v = value[k];
if (k === "__proto__") {
writeKey(out);
}
if (v instanceof NumericValue) {
this.useReplacer = true;
out[k] = v;
} else {
out[k] = this._write(ns, v);
}
}
return out;
} else {
return structuredClone(value);
}
}
return value;
}
}
class JsonCodec extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new JsonShapeSerializer(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new JsonShapeDeserializer(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class XmlShapeDeserializer extends SerdeContextConfig {
settings;
stringDeserializer;
constructor(settings) {
super();
this.settings = settings;
this.stringDeserializer = new FromStringShapeDeserializer(settings);
}
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
this.stringDeserializer.setSerdeContext(serdeContext);
}
read(schema, bytes, key) {
const ns = NormalizedSchema.of(schema);
const memberSchemas = ns.getMemberSchemas();
const isEventPayload = ns.isStructSchema() && ns.isMemberSchema() && !!Object.values(memberSchemas).find((memberNs) => {
return !!memberNs.getMemberTraits().eventPayload;
});
if (isEventPayload) {
const output = {};
const memberName = Object.keys(memberSchemas)[0];
const eventMemberSchema = memberSchemas[memberName];
if (eventMemberSchema.isBlobSchema()) {
output[memberName] = bytes;
} else {
output[memberName] = this.read(memberSchemas[memberName], bytes);
}
return output;
}
const xmlString = (this.serdeContext?.utf8Encoder ?? toUtf8)(bytes);
const parsedObject = this.parseXml(xmlString);
return this.readSchema(schema, key ? parsedObject[key] : parsedObject);
}
readSchema(_schema, value) {
const ns = NormalizedSchema.of(_schema);
if (ns.isUnitSchema()) {
return;
}
const traits = ns.getMergedTraits();
if (ns.isListSchema() && !Array.isArray(value)) {
return this.readSchema(ns, [value]);
}
if (value == null) {
return value;
}
if (typeof value === "object") {
const flat = !!traits.xmlFlattened;
if (ns.isListSchema()) {
const listValue = ns.getValueSchema();
const buffer = [];
const sourceKey = listValue.getMergedTraits().xmlName ?? "member";
const source = flat ? value : (value[0] ?? value)[sourceKey];
if (source == null) {
return buffer;
}
const sourceArray = Array.isArray(source) ? source : [source];
for (const v of sourceArray) {
buffer.push(this.readSchema(listValue, v));
}
return buffer;
}
const buffer = {};
if (ns.isMapSchema()) {
const keyNs = ns.getKeySchema();
const memberNs = ns.getValueSchema();
let entries;
if (flat) {
entries = Array.isArray(value) ? value : [value];
} else {
entries = Array.isArray(value.entry) ? value.entry : [value.entry];
}
const keyProperty = keyNs.getMergedTraits().xmlName ?? "key";
const valueProperty = memberNs.getMergedTraits().xmlName ?? "value";
for (const entry of entries) {
const key = entry[keyProperty];
const value = entry[valueProperty];
if (key === "__proto__") {
writeKey(buffer);
}
buffer[key] = this.readSchema(memberNs, value);
}
return buffer;
}
if (ns.isStructSchema()) {
const union = ns.isUnionSchema();
let unionSerde;
if (union) {
unionSerde = new UnionSerde(value, buffer);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
const memberTraits = memberSchema.getMergedTraits();
const xmlObjectKey = !memberTraits.httpPayload ? memberSchema.getMemberTraits().xmlName ?? memberName : memberTraits.xmlName ?? memberSchema.getName();
if (union) {
unionSerde.mark(xmlObjectKey);
}
if (value[xmlObjectKey] != null) {
buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]);
}
}
if (union) {
unionSerde.writeUnknown();
}
return buffer;
}
if (ns.isDocumentSchema()) {
return value;
}
throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`);
}
if (ns.isListSchema()) {
return [];
}
if (ns.isMapSchema() || ns.isStructSchema()) {
return {};
}
return this.stringDeserializer.read(ns, value);
}
parseXml(xml) {
if (xml.length) {
let parsedObj;
try {
parsedObj = parseXML(xml);
} catch (e) {
if (e && typeof e === "object") {
Object.defineProperty(e, "$responseBodyText", {
value: xml
});
}
throw e;
}
const textNodeName = "#text";
const key = Object.keys(parsedObj)[0];
const parsedObjToReturn = parsedObj[key];
if (parsedObjToReturn[textNodeName]) {
parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
delete parsedObjToReturn[textNodeName];
}
return getValueFromTextNode(parsedObjToReturn);
}
return {};
}
}
class QueryShapeSerializer extends SerdeContextConfig {
settings;
buffer;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value, prefix = "") {
if (this.buffer === undefined) {
this.buffer = "";
}
const ns = NormalizedSchema.of(schema);
if (prefix && !prefix.endsWith(".")) {
prefix += ".";
}
if (ns.isBlobSchema()) {
if (typeof value === "string" || value instanceof Uint8Array) {
this.writeKey(prefix);
this.writeValue((this.serdeContext?.base64Encoder ?? toBase64)(value));
}
} else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(String(value));
} else if (ns.isIdempotencyToken()) {
this.writeKey(prefix);
this.writeValue(generateIdempotencyToken());
}
} else if (ns.isBigIntegerSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(String(value));
}
} else if (ns.isBigDecimalSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(value instanceof NumericValue ? value.string : String(value));
}
} else if (ns.isTimestampSchema()) {
if (value instanceof Date) {
this.writeKey(prefix);
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
this.writeValue(value.toISOString().replace(".000Z", "Z"));
break;
case 6:
this.writeValue(dateToUtcString(value));
break;
case 7:
this.writeValue(String(value.getTime() / 1000));
break;
}
}
} else if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
this.write(64 | 15, value, prefix);
} else if (value instanceof Date) {
this.write(4, value, prefix);
} else if (value instanceof Uint8Array) {
this.write(21, value, prefix);
} else if (value && typeof value === "object") {
this.write(128 | 15, value, prefix);
} else {
this.writeKey(prefix);
this.writeValue(String(value));
}
} else if (ns.isListSchema()) {
if (Array.isArray(value)) {
if (value.length === 0) {
if (this.settings.serializeEmptyLists) {
this.writeKey(prefix);
this.writeValue("");
}
} else {
const member = ns.getValueSchema();
const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened;
let i = 1;
for (const item of value) {
if (item == null) {
continue;
}
const traits = member.getMergedTraits();
const suffix = this.getKey("member", traits.xmlName, traits.ec2QueryName);
const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`;
this.write(member, item, key);
++i;
}
}
}
} else if (ns.isMapSchema()) {
if (value && typeof value === "object") {
const keySchema = ns.getKeySchema();
const memberSchema = ns.getValueSchema();
const flat = ns.getMergedTraits().xmlFlattened;
let i = 1;
for (const k in value) {
const v = value[k];
if (v == null) {
continue;
}
const keyTraits = keySchema.getMergedTraits();
const keySuffix = this.getKey("key", keyTraits.xmlName, keyTraits.ec2QueryName);
const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`;
const valTraits = memberSchema.getMergedTraits();
const valueSuffix = this.getKey("value", valTraits.xmlName, valTraits.ec2QueryName);
const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`;
this.write(keySchema, k, key);
this.write(memberSchema, v, valueKey);
++i;
}
}
} else if (ns.isStructSchema()) {
if (value && typeof value === "object") {
let didWriteMember = false;
for (const [memberName, member] of ns.structIterator()) {
if (value[memberName] == null && !member.isIdempotencyToken()) {
continue;
}
const traits = member.getMergedTraits();
const suffix = this.getKey(memberName, traits.xmlName, traits.ec2QueryName, "struct");
const key = `${prefix}${suffix}`;
this.write(member, value[memberName], key);
didWriteMember = true;
}
if (!didWriteMember && ns.isUnionSchema()) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
const key = `${prefix}${k}`;
this.write(15, v, key);
}
}
}
} else if (ns.isUnitSchema())
;
else {
throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`);
}
}
flush() {
if (this.buffer === undefined) {
throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer.");
}
const str = this.buffer;
delete this.buffer;
return str;
}
getKey(memberName, xmlName, ec2QueryName, keySource) {
const { ec2, capitalizeKeys } = this.settings;
if (ec2 && ec2QueryName) {
return ec2QueryName;
}
const key = xmlName ?? memberName;
if (capitalizeKeys && keySource === "struct") {
return key[0].toUpperCase() + key.slice(1);
}
return key;
}
writeKey(key) {
if (key.endsWith(".")) {
key = key.slice(0, key.length - 1);
}
this.buffer += `&${extendedEncodeURIComponent(key)}=`;
}
writeValue(value) {
this.buffer += extendedEncodeURIComponent(value);
}
}
class AwsQueryProtocol extends RpcProtocol {
options;
serializer;
deserializer;
mixin = new ProtocolLib;
constructor(options) {
super({
defaultNamespace: options.defaultNamespace,
errorTypeRegistries: options.errorTypeRegistries
});
this.options = options;
const settings = {
timestampFormat: {
useTrait: true,
default: 5
},
httpBindings: false,
xmlNamespace: options.xmlNamespace,
serviceNamespace: options.defaultNamespace,
serializeEmptyLists: true
};
this.serializer = new QueryShapeSerializer(settings);
this.deserializer = new XmlShapeDeserializer(settings);
}
getShapeId() {
return "aws.protocols#awsQuery";
}
setSerdeContext(serdeContext) {
this.serializer.setSerdeContext(serdeContext);
this.deserializer.setSerdeContext(serdeContext);
}
getPayloadCodec() {
throw new Error("AWSQuery protocol has no payload codec.");
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (!request.path.endsWith("/")) {
request.path += "/";
}
request.headers["content-type"] = "application/x-www-form-urlencoded";
if (deref(operationSchema.input) === "unit" || !request.body) {
request.body = "";
}
const action = operationSchema.name.split("#")[1] ?? operationSchema.name;
request.body = `Action=${action}&Version=${this.options.version}` + request.body;
if (request.body.endsWith("&")) {
request.body = request.body.slice(-1);
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
const deserializer = this.deserializer;
const ns = NormalizedSchema.of(operationSchema.output);
const dataObject = {};
if (response.statusCode >= 300) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(15, bytes));
}
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
}
for (const header in response.headers) {
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name;
const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : undefined;
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
useNestedResult() {
return true;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const errorData = this.loadQueryError(dataObject) ?? {};
const message = this.loadQueryErrorMessage(dataObject);
errorData.message = message;
errorData.Error = {
Type: errorData.Type,
Code: errorData.Code,
Message: message
};
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, this.mixin.findQueryCompatibleError);
const ns = NormalizedSchema.of(errorSchema);
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {
Type: errorData.Error.Type,
Code: errorData.Error.Code,
Error: errorData.Error
};
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().xmlName ?? name;
const value = errorData[target] ?? dataObject[target];
output[name] = this.deserializer.readSchema(member, value);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
loadQueryErrorCode(output, data) {
const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code;
if (code !== undefined) {
return code;
}
if (output.statusCode == 404) {
return "NotFound";
}
}
loadQueryError(data) {
return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error;
}
loadQueryErrorMessage(data) {
const errorData = this.loadQueryError(data);
return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown";
}
getDefaultContentType() {
return "application/x-www-form-urlencoded";
}
}
class AwsEc2QueryProtocol extends AwsQueryProtocol {
options;
constructor(options) {
super(options);
this.options = options;
const ec2Settings = {
capitalizeKeys: true,
flattenLists: true,
serializeEmptyLists: false,
ec2: true
};
Object.assign(this.serializer.settings, ec2Settings);
}
getShapeId() {
return "aws.protocols#ec2Query";
}
useNestedResult() {
return false;
}
}
var parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
if (encoded.length) {
let parsedObj;
try {
parsedObj = parseXML(encoded);
} catch (e) {
if (e && typeof e === "object") {
Object.defineProperty(e, "$responseBodyText", {
value: encoded
});
}
throw e;
}
const textNodeName = "#text";
const key = Object.keys(parsedObj)[0];
const parsedObjToReturn = parsedObj[key];
if (parsedObjToReturn[textNodeName]) {
parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
delete parsedObjToReturn[textNodeName];
}
return getValueFromTextNode(parsedObjToReturn);
}
return {};
});
var parseXmlErrorBody = async (errorBody, context) => {
const value = await parseXmlBody(errorBody, context);
if (value.Error) {
value.Error.message = value.Error.message ?? value.Error.Message;
}
return value;
};
var loadRestXmlErrorCode = (output, data) => {
if (data?.Error?.Code !== undefined) {
return data.Error.Code;
}
if (data?.Code !== undefined) {
return data.Code;
}
if (output.statusCode == 404) {
return "NotFound";
}
};
class XmlShapeSerializer extends SerdeContextConfig {
settings;
stringBuffer;
byteBuffer;
buffer;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
if (ns.isStringSchema() && typeof value === "string") {
this.stringBuffer = value;
} else if (ns.isBlobSchema()) {
this.byteBuffer = "byteLength" in value ? value : (this.serdeContext?.base64Decoder ?? fromBase64)(value);
} else {
this.buffer = this.writeStruct(ns, value, undefined);
const traits = ns.getMergedTraits();
if (traits.httpPayload && !traits.xmlName) {
this.buffer.withName(ns.getName());
}
}
}
flush() {
if (this.byteBuffer !== undefined) {
const bytes = this.byteBuffer;
delete this.byteBuffer;
return bytes;
}
if (this.stringBuffer !== undefined) {
const str = this.stringBuffer;
delete this.stringBuffer;
return str;
}
const buffer = this.buffer;
if (this.settings.xmlNamespace) {
if (!buffer?.attributes?.["xmlns"]) {
buffer.addAttribute("xmlns", this.settings.xmlNamespace);
}
}
delete this.buffer;
return buffer.toString();
}
writeStruct(ns, value, parentXmlns) {
const traits = ns.getMergedTraits();
const name = ns.isMemberSchema() && !traits.httpPayload ? ns.getMemberTraits().xmlName ?? ns.getMemberName() : traits.xmlName ?? ns.getName();
if (!name || !ns.isStructSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write struct with empty name or non-struct, schema=${ns.getName(true)}.`);
}
const structXmlNode = XmlNode.of(name);
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
for (const [memberName, memberSchema] of ns.structIterator()) {
const val = value[memberName];
if (val != null || memberSchema.isIdempotencyToken()) {
if (memberSchema.getMergedTraits().xmlAttribute) {
structXmlNode.addAttribute(memberSchema.getMergedTraits().xmlName ?? memberName, this.writeSimple(memberSchema, val));
continue;
}
if (memberSchema.isListSchema()) {
this.writeList(memberSchema, val, structXmlNode, xmlns);
} else if (memberSchema.isMapSchema()) {
this.writeMap(memberSchema, val, structXmlNode, xmlns);
} else if (memberSchema.isStructSchema()) {
structXmlNode.addChildNode(this.writeStruct(memberSchema, val, xmlns));
} else {
const memberNode = XmlNode.of(memberSchema.getMergedTraits().xmlName ?? memberSchema.getMemberName());
this.writeSimpleInto(memberSchema, val, memberNode, xmlns);
structXmlNode.addChildNode(memberNode);
}
}
}
const { $unknown } = value;
if ($unknown && ns.isUnionSchema() && Array.isArray($unknown) && Object.keys(value).length === 1) {
const [k, v] = $unknown;
const node = XmlNode.of(k);
if (typeof v !== "string") {
if (value instanceof XmlNode || value instanceof XmlText) {
structXmlNode.addChildNode(value);
} else {
throw new Error(`@aws-sdk - $unknown union member in XML requires ` + `value of type string, @aws-sdk/xml-builder::XmlNode or XmlText.`);
}
}
this.writeSimpleInto(0, v, node, xmlns);
structXmlNode.addChildNode(node);
}
if (xmlns) {
structXmlNode.addAttribute(xmlnsAttr, xmlns);
}
return structXmlNode;
}
writeList(listMember, array, container, parentXmlns) {
if (!listMember.isMemberSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member list: ${listMember.getName(true)}`);
}
const listTraits = listMember.getMergedTraits();
const listValueSchema = listMember.getValueSchema();
const listValueTraits = listValueSchema.getMergedTraits();
const sparse = !!listValueTraits.sparse;
const flat = !!listTraits.xmlFlattened;
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(listMember, parentXmlns);
const writeItem = (container, value) => {
if (listValueSchema.isListSchema()) {
this.writeList(listValueSchema, Array.isArray(value) ? value : [value], container, xmlns);
} else if (listValueSchema.isMapSchema()) {
this.writeMap(listValueSchema, value, container, xmlns);
} else if (listValueSchema.isStructSchema()) {
const struct = this.writeStruct(listValueSchema, value, xmlns);
container.addChildNode(struct.withName(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member"));
} else {
const listItemNode = XmlNode.of(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member");
this.writeSimpleInto(listValueSchema, value, listItemNode, xmlns);
container.addChildNode(listItemNode);
}
};
if (flat) {
for (const value of array) {
if (sparse || value != null) {
writeItem(container, value);
}
}
} else {
const listNode = XmlNode.of(listTraits.xmlName ?? listMember.getMemberName());
if (xmlns) {
listNode.addAttribute(xmlnsAttr, xmlns);
}
for (const value of array) {
if (sparse || value != null) {
writeItem(listNode, value);
}
}
container.addChildNode(listNode);
}
}
writeMap(mapMember, map, container, parentXmlns, containerIsMap = false) {
if (!mapMember.isMemberSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member map: ${mapMember.getName(true)}`);
}
const mapTraits = mapMember.getMergedTraits();
const mapKeySchema = mapMember.getKeySchema();
const mapKeyTraits = mapKeySchema.getMergedTraits();
const keyTag = mapKeyTraits.xmlName ?? "key";
const mapValueSchema = mapMember.getValueSchema();
const mapValueTraits = mapValueSchema.getMergedTraits();
const valueTag = mapValueTraits.xmlName ?? "value";
const sparse = !!mapValueTraits.sparse;
const flat = !!mapTraits.xmlFlattened;
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(mapMember, parentXmlns);
const addKeyValue = (entry, key, val) => {
const keyNode = XmlNode.of(keyTag, key);
const [keyXmlnsAttr, keyXmlns] = this.getXmlnsAttribute(mapKeySchema, xmlns);
if (keyXmlns) {
keyNode.addAttribute(keyXmlnsAttr, keyXmlns);
}
entry.addChildNode(keyNode);
let valueNode = XmlNode.of(valueTag);
if (mapValueSchema.isListSchema()) {
this.writeList(mapValueSchema, val, valueNode, xmlns);
} else if (mapValueSchema.isMapSchema()) {
this.writeMap(mapValueSchema, val, valueNode, xmlns, true);
} else if (mapValueSchema.isStructSchema()) {
valueNode = this.writeStruct(mapValueSchema, val, xmlns);
} else {
this.writeSimpleInto(mapValueSchema, val, valueNode, xmlns);
}
entry.addChildNode(valueNode);
};
if (flat) {
for (const key in map) {
const val = map[key];
if (sparse || val != null) {
const entry = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
addKeyValue(entry, key, val);
container.addChildNode(entry);
}
}
} else {
let mapNode;
if (!containerIsMap) {
mapNode = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
if (xmlns) {
mapNode.addAttribute(xmlnsAttr, xmlns);
}
container.addChildNode(mapNode);
}
for (const key in map) {
const val = map[key];
if (sparse || val != null) {
const entry = XmlNode.of("entry");
addKeyValue(entry, key, val);
(containerIsMap ? container : mapNode).addChildNode(entry);
}
}
}
}
writeSimple(_schema, value) {
if (value === null) {
throw new Error("@aws-sdk/core/protocols - (XML serializer) cannot write null value.");
}
const ns = NormalizedSchema.of(_schema);
let nodeContents = null;
if (value && typeof value === "object") {
if (ns.isBlobSchema()) {
nodeContents = (this.serdeContext?.base64Encoder ?? toBase64)(value);
} else if (ns.isTimestampSchema() && value instanceof Date) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
nodeContents = value.toISOString().replace(".000Z", "Z");
break;
case 6:
nodeContents = dateToUtcString(value);
break;
case 7:
nodeContents = String(value.getTime() / 1000);
break;
default:
console.warn("Missing timestamp format, using http date", value);
nodeContents = dateToUtcString(value);
break;
}
} else if (ns.isBigDecimalSchema() && value) {
if (value instanceof NumericValue) {
return value.string;
}
return String(value);
} else if (ns.isMapSchema() || ns.isListSchema()) {
throw new Error("@aws-sdk/core/protocols - xml serializer, cannot call _write() on List/Map schema, call writeList or writeMap() instead.");
} else {
throw new Error(`@aws-sdk/core/protocols - xml serializer, unhandled schema type for object value and schema: ${ns.getName(true)}`);
}
}
if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
nodeContents = String(value);
}
if (ns.isStringSchema()) {
if (value === undefined && ns.isIdempotencyToken()) {
nodeContents = generateIdempotencyToken();
} else {
nodeContents = String(value);
}
}
if (nodeContents === null) {
throw new Error(`Unhandled schema-value pair ${ns.getName(true)}=${value}`);
}
return nodeContents;
}
writeSimpleInto(_schema, value, into, parentXmlns) {
const nodeContents = this.writeSimple(_schema, value);
const ns = NormalizedSchema.of(_schema);
const content = new XmlText(nodeContents);
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
if (xmlns) {
into.addAttribute(xmlnsAttr, xmlns);
}
into.addChildNode(content);
}
getXmlnsAttribute(ns, parentXmlns) {
const traits = ns.getMergedTraits();
const [prefix, xmlns] = traits.xmlNamespace ?? [];
if (xmlns && xmlns !== parentXmlns) {
return [prefix ? `xmlns:${prefix}` : "xmlns", xmlns];
}
return [undefined, undefined];
}
}
class XmlCodec extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new XmlShapeSerializer(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new XmlShapeDeserializer(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class AwsRestXmlProtocol extends HttpBindingProtocol {
codec;
serializer;
deserializer;
mixin = new ProtocolLib;
constructor(options) {
super(options);
const settings = {
timestampFormat: {
useTrait: true,
default: 5
},
httpBindings: true,
xmlNamespace: options.xmlNamespace,
serviceNamespace: options.defaultNamespace
};
this.codec = new XmlCodec(settings);
this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
}
getPayloadCodec() {
return this.codec;
}
getShapeId() {
return "aws.protocols#restXml";
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
const inputSchema = NormalizedSchema.of(operationSchema.input);
if (!request.headers["content-type"]) {
const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
if (contentType) {
request.headers["content-type"] = contentType;
}
}
if (typeof request.body === "string" && request.headers["content-type"] === this.getDefaultContentType() && !request.body.startsWith("<?xml ") && !this.hasUnstructuredPayloadBinding(inputSchema)) {
request.body = '<?xml version="1.0" encoding="UTF-8"?>' + request.body;
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
return super.deserializeResponse(operationSchema, context, response);
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
if (dataObject.Error && typeof dataObject.Error === "object") {
for (const key of Object.keys(dataObject.Error)) {
dataObject[key] = dataObject.Error[key];
if (key.toLowerCase() === "message") {
dataObject.message = dataObject.Error[key];
}
}
}
if (dataObject.RequestId && !metadata.requestId) {
metadata.requestId = dataObject.RequestId;
}
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().xmlName ?? name;
const value = dataObject.Error?.[target] ?? dataObject[target];
output[name] = errorDeserializer.readSchema(member, value);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
getDefaultContentType() {
return "application/xml";
}
hasUnstructuredPayloadBinding(ns) {
for (const [, member] of ns.structIterator()) {
if (member.getMergedTraits().httpPayload) {
return !(member.isStructSchema() || member.isMapSchema() || member.isListSchema());
}
}
return false;
}
}
var awsExpectUnion = (value) => {
if (value == null) {
return;
}
if (typeof value === "object" && "__type" in value) {
delete value.__type;
}
return expectUnion(value);
};
var _toStr = (val) => {
if (val == null) {
return val;
}
if (typeof val === "number" || typeof val === "bigint") {
const warning = new Error(`Received number ${val} where a string was expected.`);
warning.name = "Warning";
console.warn(warning);
return String(val);
}
if (typeof val === "boolean") {
const warning = new Error(`Received boolean ${val} where a string was expected.`);
warning.name = "Warning";
console.warn(warning);
return String(val);
}
return val;
};
var _toBool = (val) => {
if (val == null) {
return val;
}
if (typeof val === "string") {
const lowercase = val.toLowerCase();
if (val !== "" && lowercase !== "false" && lowercase !== "true") {
const warning = new Error(`Received string "${val}" where a boolean was expected.`);
warning.name = "Warning";
console.warn(warning);
}
return val !== "" && lowercase !== "false";
}
return val;
};
var _toNum = (val) => {
if (val == null) {
return val;
}
if (typeof val === "string") {
const num = Number(val);
if (num.toString() !== val) {
const warning = new Error(`Received string "${val}" where a number was expected.`);
warning.name = "Warning";
console.warn(warning);
return val;
}
return num;
}
return val;
};
exports.AwsEc2QueryProtocol = AwsEc2QueryProtocol;
exports.AwsJson1_0Protocol = AwsJson1_0Protocol;
exports.AwsJson1_1Protocol = AwsJson1_1Protocol;
exports.AwsJsonRpcProtocol = AwsJsonRpcProtocol;
exports.AwsQueryProtocol = AwsQueryProtocol;
exports.AwsRestJsonProtocol = AwsRestJsonProtocol;
exports.AwsRestXmlProtocol = AwsRestXmlProtocol;
exports.AwsSmithyRpcV2CborProtocol = AwsSmithyRpcV2CborProtocol;
exports.JsonCodec = JsonCodec;
exports.JsonCodec2 = JsonCodec2;
exports.JsonShapeDeserializer = JsonShapeDeserializer;
exports.JsonShapeDeserializer2 = JsonShapeDeserializer2;
exports.JsonShapeSerializer = JsonShapeSerializer;
exports.JsonShapeSerializer2 = JsonShapeSerializer2;
exports.QueryShapeSerializer = QueryShapeSerializer;
exports.XmlCodec = XmlCodec;
exports.XmlShapeDeserializer = XmlShapeDeserializer;
exports.XmlShapeSerializer = XmlShapeSerializer;
exports._toBool = _toBool;
exports._toNum = _toNum;
exports._toStr = _toStr;
exports.awsExpectUnion = awsExpectUnion;
exports.loadJsonRpcErrorCode = loadJsonRpcErrorCode;
exports.loadRestJsonErrorCode = loadRestJsonErrorCode;
exports.loadRestXmlErrorCode = loadRestXmlErrorCode;
exports.parseJsonBody = parseJsonBody;
exports.parseJsonErrorBody = parseJsonErrorBody;
exports.parseXmlBody = parseXmlBody;
exports.parseXmlErrorBody = parseXmlErrorBody;
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sso-oidc/index.js
var require_sso_oidc = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsRestJsonProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "sso-oauth",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var defaultSSOOIDCHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "CreateToken": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "sso-oauth"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
var k = "ref";
var a = -1;
var b = true;
var c = "isSet";
var d = "PartitionResult";
var e = "booleanEquals";
var f = "getAttr";
var g = { [k]: "Endpoint" };
var h = { [k]: d };
var i = {};
var j = [{ [k]: "Region" }];
var _data = {
conditions: [
[c, [g]],
[c, j],
["aws.partition", j, d],
[e, [{ [k]: "UseFIPS" }, b]],
[e, [{ [k]: "UseDualStack" }, b]],
[e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
[e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]]
],
results: [
[a],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g, i],
["https://oidc-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://oidc.{Region}.amazonaws.com", i],
["https://oidc-fips.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://oidc.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://oidc.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
13,
3,
1,
4,
r + 12,
2,
5,
r + 12,
3,
8,
6,
4,
7,
r + 11,
5,
r + 9,
r + 10,
4,
11,
9,
6,
10,
r + 8,
7,
r + 6,
r + 7,
5,
12,
r + 5,
6,
r + 4,
r + 5,
3,
r + 1,
14,
4,
r + 2,
r + 3
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
class SSOOIDCServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SSOOIDCServiceException.prototype);
}
}
class AccessDeniedException extends SSOOIDCServiceException {
name = "AccessDeniedException";
$fault = "client";
error;
reason;
error_description;
constructor(opts) {
super({
name: "AccessDeniedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AccessDeniedException.prototype);
this.error = opts.error;
this.reason = opts.reason;
this.error_description = opts.error_description;
}
}
class AuthorizationPendingException extends SSOOIDCServiceException {
name = "AuthorizationPendingException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "AuthorizationPendingException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AuthorizationPendingException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class ExpiredTokenException extends SSOOIDCServiceException {
name = "ExpiredTokenException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "ExpiredTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ExpiredTokenException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InternalServerException extends SSOOIDCServiceException {
name = "InternalServerException";
$fault = "server";
error;
error_description;
constructor(opts) {
super({
name: "InternalServerException",
$fault: "server",
...opts
});
Object.setPrototypeOf(this, InternalServerException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidClientException extends SSOOIDCServiceException {
name = "InvalidClientException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidClientException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidClientException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidGrantException extends SSOOIDCServiceException {
name = "InvalidGrantException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidGrantException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidGrantException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidRequestException extends SSOOIDCServiceException {
name = "InvalidRequestException";
$fault = "client";
error;
reason;
error_description;
constructor(opts) {
super({
name: "InvalidRequestException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidRequestException.prototype);
this.error = opts.error;
this.reason = opts.reason;
this.error_description = opts.error_description;
}
}
class InvalidScopeException extends SSOOIDCServiceException {
name = "InvalidScopeException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidScopeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidScopeException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class SlowDownException extends SSOOIDCServiceException {
name = "SlowDownException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "SlowDownException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, SlowDownException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class UnauthorizedClientException extends SSOOIDCServiceException {
name = "UnauthorizedClientException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "UnauthorizedClientException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnauthorizedClientException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class UnsupportedGrantTypeException extends SSOOIDCServiceException {
name = "UnsupportedGrantTypeException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "UnsupportedGrantTypeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnsupportedGrantTypeException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
var _ADE = "AccessDeniedException";
var _APE = "AuthorizationPendingException";
var _AT = "AccessToken";
var _CS = "ClientSecret";
var _CT = "CreateToken";
var _CTR = "CreateTokenRequest";
var _CTRr = "CreateTokenResponse";
var _CV = "CodeVerifier";
var _ETE = "ExpiredTokenException";
var _ICE = "InvalidClientException";
var _IGE = "InvalidGrantException";
var _IRE = "InvalidRequestException";
var _ISE = "InternalServerException";
var _ISEn = "InvalidScopeException";
var _IT = "IdToken";
var _RT = "RefreshToken";
var _SDE = "SlowDownException";
var _UCE = "UnauthorizedClientException";
var _UGTE = "UnsupportedGrantTypeException";
var _aT = "accessToken";
var _c = "client";
var _cI = "clientId";
var _cS = "clientSecret";
var _cV = "codeVerifier";
var _co = "code";
var _dC = "deviceCode";
var _e = "error";
var _eI = "expiresIn";
var _ed = "error_description";
var _gT = "grantType";
var _h = "http";
var _hE = "httpError";
var _iT = "idToken";
var _r = "reason";
var _rT = "refreshToken";
var _rU = "redirectUri";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.ssooidc";
var _sc = "scope";
var _se = "server";
var _tT = "tokenType";
var n0 = "com.amazonaws.ssooidc";
var _s_registry = TypeRegistry.for(_s);
var SSOOIDCServiceException$ = [-3, _s, "SSOOIDCServiceException", 0, [], []];
_s_registry.registerError(SSOOIDCServiceException$, SSOOIDCServiceException);
var n0_registry = TypeRegistry.for(n0);
var AccessDeniedException$ = [
-3,
n0,
_ADE,
{ [_e]: _c, [_hE]: 400 },
[_e, _r, _ed],
[0, 0, 0]
];
n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
var AuthorizationPendingException$ = [
-3,
n0,
_APE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(AuthorizationPendingException$, AuthorizationPendingException);
var ExpiredTokenException$ = [
-3,
n0,
_ETE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(ExpiredTokenException$, ExpiredTokenException);
var InternalServerException$ = [
-3,
n0,
_ISE,
{ [_e]: _se, [_hE]: 500 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InternalServerException$, InternalServerException);
var InvalidClientException$ = [
-3,
n0,
_ICE,
{ [_e]: _c, [_hE]: 401 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidClientException$, InvalidClientException);
var InvalidGrantException$ = [
-3,
n0,
_IGE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidGrantException$, InvalidGrantException);
var InvalidRequestException$ = [
-3,
n0,
_IRE,
{ [_e]: _c, [_hE]: 400 },
[_e, _r, _ed],
[0, 0, 0]
];
n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
var InvalidScopeException$ = [
-3,
n0,
_ISEn,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidScopeException$, InvalidScopeException);
var SlowDownException$ = [
-3,
n0,
_SDE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(SlowDownException$, SlowDownException);
var UnauthorizedClientException$ = [
-3,
n0,
_UCE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(UnauthorizedClientException$, UnauthorizedClientException);
var UnsupportedGrantTypeException$ = [
-3,
n0,
_UGTE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(UnsupportedGrantTypeException$, UnsupportedGrantTypeException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var AccessToken = [0, n0, _AT, 8, 0];
var ClientSecret = [0, n0, _CS, 8, 0];
var CodeVerifier = [0, n0, _CV, 8, 0];
var IdToken = [0, n0, _IT, 8, 0];
var RefreshToken = [0, n0, _RT, 8, 0];
var CreateTokenRequest$ = [
3,
n0,
_CTR,
0,
[_cI, _cS, _gT, _dC, _co, _rT, _sc, _rU, _cV],
[0, [() => ClientSecret, 0], 0, 0, 0, [() => RefreshToken, 0], 64 | 0, 0, [() => CodeVerifier, 0]],
3
];
var CreateTokenResponse$ = [
3,
n0,
_CTRr,
0,
[_aT, _tT, _eI, _rT, _iT],
[[() => AccessToken, 0], 0, 1, [() => RefreshToken, 0], [() => IdToken, 0]]
];
var CreateToken$ = [
9,
n0,
_CT,
{ [_h]: ["POST", "/token", 200] },
() => CreateTokenRequest$,
() => CreateTokenResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2019-06-10",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOOIDCHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.ssooidc",
errorTypeRegistries,
version: "2019-06-10",
serviceTarget: "AWSSSOOIDCService"
},
serviceId: config?.serviceId ?? "SSO OIDC",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class SSOOIDCClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSSOOIDCHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "AWSSSOOIDCService", "SSOOIDCClient", getEndpointPlugin);
var _ep0 = {};
var _mw0 = (Command, cs, config, o) => [];
class CreateTokenCommand extends command(_ep0, _mw0, "CreateToken", CreateToken$) {
}
var commands = {
CreateTokenCommand
};
class SSOOIDC extends SSOOIDCClient {
}
createAggregatedClient(commands, SSOOIDC);
var AccessDeniedExceptionReason = {
KMS_ACCESS_DENIED: "KMS_AccessDeniedException"
};
var InvalidRequestExceptionReason = {
KMS_DISABLED_KEY: "KMS_DisabledException",
KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException",
KMS_INVALID_STATE: "KMS_InvalidStateException",
KMS_KEY_NOT_FOUND: "KMS_NotFoundException"
};
exports.AccessDeniedException = AccessDeniedException;
exports.AccessDeniedException$ = AccessDeniedException$;
exports.AccessDeniedExceptionReason = AccessDeniedExceptionReason;
exports.AuthorizationPendingException = AuthorizationPendingException;
exports.AuthorizationPendingException$ = AuthorizationPendingException$;
exports.CreateToken$ = CreateToken$;
exports.CreateTokenCommand = CreateTokenCommand;
exports.CreateTokenRequest$ = CreateTokenRequest$;
exports.CreateTokenResponse$ = CreateTokenResponse$;
exports.ExpiredTokenException = ExpiredTokenException;
exports.ExpiredTokenException$ = ExpiredTokenException$;
exports.InternalServerException = InternalServerException;
exports.InternalServerException$ = InternalServerException$;
exports.InvalidClientException = InvalidClientException;
exports.InvalidClientException$ = InvalidClientException$;
exports.InvalidGrantException = InvalidGrantException;
exports.InvalidGrantException$ = InvalidGrantException$;
exports.InvalidRequestException = InvalidRequestException;
exports.InvalidRequestException$ = InvalidRequestException$;
exports.InvalidRequestExceptionReason = InvalidRequestExceptionReason;
exports.InvalidScopeException = InvalidScopeException;
exports.InvalidScopeException$ = InvalidScopeException$;
exports.SSOOIDC = SSOOIDC;
exports.SSOOIDCClient = SSOOIDCClient;
exports.SSOOIDCServiceException = SSOOIDCServiceException;
exports.SSOOIDCServiceException$ = SSOOIDCServiceException$;
exports.SlowDownException = SlowDownException;
exports.SlowDownException$ = SlowDownException$;
exports.UnauthorizedClientException = UnauthorizedClientException;
exports.UnauthorizedClientException$ = UnauthorizedClientException$;
exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException;
exports.UnsupportedGrantTypeException$ = UnsupportedGrantTypeException$;
exports.errorTypeRegistries = errorTypeRegistries;
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js
var getSsoOidcClient = async (ssoRegion, init = {}, callerClientConfig) => {
const { SSOOIDCClient } = await Promise.resolve().then(() => __toESM(require_sso_oidc()));
const coalesce = (prop) => init.clientConfig?.[prop] ?? init.parentClientConfig?.[prop] ?? callerClientConfig?.[prop];
const ssoOidcClient = new SSOOIDCClient(Object.assign({}, init.clientConfig ?? {}, {
region: ssoRegion ?? init.clientConfig?.region,
logger: coalesce("logger"),
userAgentAppId: coalesce("userAgentAppId")
}));
return ssoOidcClient;
};
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js
var getNewSsoOidcToken = async (ssoToken, ssoRegion, init = {}, callerClientConfig) => {
const { CreateTokenCommand } = await Promise.resolve().then(() => __toESM(require_sso_oidc()));
const ssoOidcClient = await getSsoOidcClient(ssoRegion, init, callerClientConfig);
return ssoOidcClient.send(new CreateTokenCommand({
clientId: ssoToken.clientId,
clientSecret: ssoToken.clientSecret,
refreshToken: ssoToken.refreshToken,
grantType: "refresh_token"
}));
};
var init_getNewSsoOidcToken = () => {};
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js
var import_config11, validateTokenExpiry = (token) => {
if (token.expiration && token.expiration.getTime() < Date.now()) {
throw new import_config11.TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false);
}
};
var init_validateTokenExpiry = __esm(() => {
init_constants();
import_config11 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js
var import_config12, validateTokenKey = (key, value, forRefresh = false) => {
if (typeof value === "undefined") {
throw new import_config12.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
}
};
var init_validateTokenKey = __esm(() => {
init_constants();
import_config12 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
import { promises as fsPromises } from "fs";
var import_config13, writeFile, writeSSOTokenToFile = (id, ssoToken) => {
const tokenFilepath = import_config13.getSSOTokenFilepath(id);
const tokenString = JSON.stringify(ssoToken, null, 2);
return writeFile(tokenFilepath, tokenString);
};
var init_writeSSOTokenToFile = __esm(() => {
import_config13 = __toESM(require_config());
({ writeFile } = fsPromises);
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
var import_config14, lastRefreshAttemptTimes, fromSso = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/token-providers - fromSso");
const profiles = await import_config14.parseKnownFiles(init);
const profileName = import_config14.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
});
const profile = profiles[profileName];
if (!profile) {
throw new import_config14.TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false);
} else if (!profile["sso_session"]) {
throw new import_config14.TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`);
}
const ssoSessionName = profile["sso_session"];
const ssoSessions = await import_config14.loadSsoSessionData(init);
const ssoSession = ssoSessions[ssoSessionName];
if (!ssoSession) {
throw new import_config14.TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false);
}
for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) {
if (!ssoSession[ssoSessionRequiredKey]) {
throw new import_config14.TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false);
}
}
const ssoStartUrl = ssoSession["sso_start_url"];
const ssoRegion = ssoSession["sso_region"];
let ssoToken;
try {
ssoToken = await import_config14.getSSOTokenFromFile(ssoSessionName);
} catch (e) {
throw new import_config14.TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false);
}
validateTokenKey("accessToken", ssoToken.accessToken);
validateTokenKey("expiresAt", ssoToken.expiresAt);
const { accessToken, expiresAt } = ssoToken;
const existingToken = {
token: accessToken,
expiration: new Date(expiresAt)
};
if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) {
return existingToken;
}
const lastRefreshAttemptTime = lastRefreshAttemptTimes.get(ssoSessionName) ?? 0;
if (Date.now() - lastRefreshAttemptTime < 30 * 1000) {
validateTokenExpiry(existingToken);
return existingToken;
}
validateTokenKey("clientId", ssoToken.clientId, true);
validateTokenKey("clientSecret", ssoToken.clientSecret, true);
validateTokenKey("refreshToken", ssoToken.refreshToken, true);
try {
lastRefreshAttemptTimes.set(ssoSessionName, Date.now());
const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init, callerClientConfig);
validateTokenKey("accessToken", newSsoOidcToken.accessToken);
validateTokenKey("expiresIn", newSsoOidcToken.expiresIn);
const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1000);
try {
await writeSSOTokenToFile(ssoSessionName, {
...ssoToken,
accessToken: newSsoOidcToken.accessToken,
expiresAt: newTokenExpiration.toISOString(),
refreshToken: newSsoOidcToken.refreshToken
});
} catch (error) {}
return {
token: newSsoOidcToken.accessToken,
expiration: newTokenExpiration
};
} catch (error) {
validateTokenExpiry(existingToken);
return existingToken;
}
};
var init_fromSso = __esm(() => {
init_constants();
init_getNewSsoOidcToken();
init_validateTokenExpiry();
init_validateTokenKey();
init_writeSSOTokenToFile();
import_config14 = __toESM(require_config());
lastRefreshAttemptTimes = new Map;
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/index.js
var init_dist_es4 = __esm(() => {
init_fromSso();
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sso/index.js
function createAwsAuthSigv4HttpAuthOption2(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "awsssoportal",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var awsEndpointFunctions, emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, normalizeProvider2, getSmithyContext2, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient, $Command, resolveDefaultsModeConfig, loadConfig3, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig, BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin, parseUrl2, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin, DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin, TypeRegistry, getSchemaSerdePlugin, resolveAwsSdkSigV4Config2, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength, streamCollector, NodeHttpHandler2, AwsRestJsonProtocol, Sha256, defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext2(context).operation,
region: await normalizeProvider2(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
}, defaultSSOHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "GetRoleCredentials": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption2(authParameters));
}
}
return options;
}, resolveHttpAuthSchemeConfig2 = (config) => {
const config_0 = resolveAwsSdkSigV4Config2(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider2(config.authSchemePreference ?? [])
});
}, resolveClientEndpointParameters2 = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "awsssoportal"
});
}, commonParams2, version = "3.997.43", packageInfo, k = "ref", a = -1, b = true, c = "isSet", d = "PartitionResult", e2 = "booleanEquals", f = "getAttr", g, h, i, j, _data, root = 2, r2 = 1e8, nodes, bdd, cache, defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
}, SSOServiceException, InvalidRequestException, ResourceNotFoundException, TooManyRequestsException, UnauthorizedException, _ATT = "AccessTokenType", _GRC = "GetRoleCredentials", _GRCR = "GetRoleCredentialsRequest", _GRCRe = "GetRoleCredentialsResponse", _IRE = "InvalidRequestException", _RC = "RoleCredentials", _RNFE = "ResourceNotFoundException", _SAKT = "SecretAccessKeyType", _STT = "SessionTokenType", _TMRE = "TooManyRequestsException", _UE = "UnauthorizedException", _aI = "accountId", _aKI = "accessKeyId", _aT = "accessToken", _ai = "account_id", _c = "client", _e = "error", _ex = "expiration", _h = "http", _hE = "httpError", _hH = "httpHeader", _hQ = "httpQuery", _m = "message", _rC = "roleCredentials", _rN = "roleName", _rn = "role_name", _s = "smithy.ts.sdk.synthetic.com.amazonaws.sso", _sAK = "secretAccessKey", _sT = "sessionToken", _xasbt = "x-amz-sso_bearer_token", n0 = "com.amazonaws.sso", _s_registry, SSOServiceException$, n0_registry, InvalidRequestException$, ResourceNotFoundException$, TooManyRequestsException$, UnauthorizedException$, errorTypeRegistries, AccessTokenType, SecretAccessKeyType, SessionTokenType, GetRoleCredentialsRequest$, GetRoleCredentialsResponse$, RoleCredentials$, GetRoleCredentials$, getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2019-06-10",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.sso",
errorTypeRegistries,
version: "2019-06-10",
serviceTarget: "SWBPortalService"
},
serviceId: config?.serviceId ?? "SSO",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl2,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
}, getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig3(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig3(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig3(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler2.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig3({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig3(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig3(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig3(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
}, getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
}, resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
}, resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
}, SSOClient, command, _ep0, _mw0 = (Command, cs, config, o) => [], GetRoleCredentialsCommand, commands, SSO, $GetRoleCredentialsCommand, $SSOClient;
var init_sso = __esm(() => {
({ awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2());
({ NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2());
({ normalizeProvider: normalizeProvider2, getSmithyContext: getSmithyContext2, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client());
({ Command: $Command } = require_client());
({ resolveDefaultsModeConfig, loadConfig: loadConfig3, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config());
({ BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints());
({ parseUrl: parseUrl2, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols());
({ DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry());
({ TypeRegistry, getSchemaSerdePlugin } = require_schema());
({ resolveAwsSdkSigV4Config: resolveAwsSdkSigV4Config2, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes());
({ toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde());
({ streamCollector, NodeHttpHandler: NodeHttpHandler2 } = require_dist_cjs4());
({ AwsRestJsonProtocol } = require_protocols2());
({ Sha256 } = require_checksum());
commonParams2 = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
packageInfo = {
version
};
g = { [k]: "Endpoint" };
h = { [k]: d };
i = {};
j = [{ [k]: "Region" }];
_data = {
conditions: [
[c, [g]],
[c, j],
["aws.partition", j, d],
[e2, [{ [k]: "UseFIPS" }, b]],
[e2, [{ [k]: "UseDualStack" }, b]],
[e2, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
[e2, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]]
],
results: [
[a],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g, i],
["https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://portal.sso.{Region}.amazonaws.com", i],
["https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://portal.sso.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "Invalid Configuration: Missing Region"]
]
};
nodes = new Int32Array([
-1,
1,
-1,
0,
13,
3,
1,
4,
r2 + 12,
2,
5,
r2 + 12,
3,
8,
6,
4,
7,
r2 + 11,
5,
r2 + 9,
r2 + 10,
4,
11,
9,
6,
10,
r2 + 8,
7,
r2 + 6,
r2 + 7,
5,
12,
r2 + 5,
6,
r2 + 4,
r2 + 5,
3,
r2 + 1,
14,
4,
r2 + 2,
r2 + 3
]);
bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
customEndpointFunctions.aws = awsEndpointFunctions;
SSOServiceException = class SSOServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SSOServiceException.prototype);
}
};
InvalidRequestException = class InvalidRequestException extends SSOServiceException {
name = "InvalidRequestException";
$fault = "client";
constructor(opts) {
super({
name: "InvalidRequestException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidRequestException.prototype);
}
};
ResourceNotFoundException = class ResourceNotFoundException extends SSOServiceException {
name = "ResourceNotFoundException";
$fault = "client";
constructor(opts) {
super({
name: "ResourceNotFoundException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
}
};
TooManyRequestsException = class TooManyRequestsException extends SSOServiceException {
name = "TooManyRequestsException";
$fault = "client";
constructor(opts) {
super({
name: "TooManyRequestsException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyRequestsException.prototype);
}
};
UnauthorizedException = class UnauthorizedException extends SSOServiceException {
name = "UnauthorizedException";
$fault = "client";
constructor(opts) {
super({
name: "UnauthorizedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnauthorizedException.prototype);
}
};
_s_registry = TypeRegistry.for(_s);
SSOServiceException$ = [-3, _s, "SSOServiceException", 0, [], []];
_s_registry.registerError(SSOServiceException$, SSOServiceException);
n0_registry = TypeRegistry.for(n0);
InvalidRequestException$ = [
-3,
n0,
_IRE,
{ [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
ResourceNotFoundException$ = [
-3,
n0,
_RNFE,
{ [_e]: _c, [_hE]: 404 },
[_m],
[0]
];
n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
TooManyRequestsException$ = [
-3,
n0,
_TMRE,
{ [_e]: _c, [_hE]: 429 },
[_m],
[0]
];
n0_registry.registerError(TooManyRequestsException$, TooManyRequestsException);
UnauthorizedException$ = [
-3,
n0,
_UE,
{ [_e]: _c, [_hE]: 401 },
[_m],
[0]
];
n0_registry.registerError(UnauthorizedException$, UnauthorizedException);
errorTypeRegistries = [
_s_registry,
n0_registry
];
AccessTokenType = [0, n0, _ATT, 8, 0];
SecretAccessKeyType = [0, n0, _SAKT, 8, 0];
SessionTokenType = [0, n0, _STT, 8, 0];
GetRoleCredentialsRequest$ = [
3,
n0,
_GRCR,
0,
[_rN, _aI, _aT],
[[0, { [_hQ]: _rn }], [0, { [_hQ]: _ai }], [() => AccessTokenType, { [_hH]: _xasbt }]],
3
];
GetRoleCredentialsResponse$ = [
3,
n0,
_GRCRe,
0,
[_rC],
[[() => RoleCredentials$, 0]]
];
RoleCredentials$ = [
3,
n0,
_RC,
0,
[_aKI, _sAK, _sT, _ex],
[0, [() => SecretAccessKeyType, 0], [() => SessionTokenType, 0], 1]
];
GetRoleCredentials$ = [
9,
n0,
_GRC,
{ [_h]: ["GET", "/federation/credentials", 200] },
() => GetRoleCredentialsRequest$,
() => GetRoleCredentialsResponse$
];
SSOClient = class SSOClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters2(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig2(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSSOHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
};
command = makeBuilder(commonParams2, "SWBPortalService", "SSOClient", getEndpointPlugin);
_ep0 = {};
GetRoleCredentialsCommand = class GetRoleCredentialsCommand extends command(_ep0, _mw0, "GetRoleCredentials", GetRoleCredentials$) {
};
commands = {
GetRoleCredentialsCommand
};
SSO = class SSO extends SSOClient {
};
createAggregatedClient(commands, SSO);
$GetRoleCredentialsCommand = GetRoleCredentialsCommand;
$SSOClient = SSOClient;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/loadSso.js
var exports_loadSso = {};
__export(exports_loadSso, {
GetRoleCredentialsCommand: () => $GetRoleCredentialsCommand,
SSOClient: () => $SSOClient
});
var init_loadSso = __esm(() => {
init_sso();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js
var import_client6, import_config15, SHOULD_FAIL_CREDENTIAL_CHAIN = false, resolveSSOCredentials = async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, callerClientConfig, profile, filepath, configFilepath, ignoreCache, logger }) => {
let token;
const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`;
if (ssoSession) {
try {
const _token = await fromSso({
profile,
filepath,
configFilepath,
ignoreCache,
clientConfig,
parentClientConfig,
logger
})({ callerClientConfig });
token = {
accessToken: _token.token,
expiresAt: new Date(_token.expiration).toISOString()
};
} catch (e) {
throw new import_config15.CredentialsProviderError(e.message, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
} else {
try {
token = await import_config15.getSSOTokenFromFile(ssoStartUrl);
} catch (e) {
throw new import_config15.CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
}
if (new Date(token.expiresAt).getTime() - Date.now() <= 0) {
throw new import_config15.CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const { accessToken } = token;
const { SSOClient, GetRoleCredentialsCommand } = await Promise.resolve().then(() => (init_loadSso(), exports_loadSso));
const sso = ssoClient || new SSOClient(Object.assign({}, clientConfig ?? {}, {
logger: clientConfig?.logger ?? callerClientConfig?.logger ?? parentClientConfig?.logger,
region: clientConfig?.region ?? ssoRegion,
userAgentAppId: clientConfig?.userAgentAppId ?? callerClientConfig?.userAgentAppId ?? parentClientConfig?.userAgentAppId
}));
let ssoResp;
try {
ssoResp = await sso.send(new GetRoleCredentialsCommand({
accountId: ssoAccountId,
roleName: ssoRoleName,
accessToken
}));
} catch (e) {
throw new import_config15.CredentialsProviderError(e, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {} } = ssoResp;
if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) {
throw new import_config15.CredentialsProviderError("SSO returns an invalid temporary credential.", {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const credentials = {
accessKeyId,
secretAccessKey,
sessionToken,
expiration: new Date(expiration),
...credentialScope && { credentialScope },
...accountId && { accountId }
};
if (ssoSession) {
import_client6.setCredentialFeature(credentials, "CREDENTIALS_SSO", "s");
} else {
import_client6.setCredentialFeature(credentials, "CREDENTIALS_SSO_LEGACY", "u");
}
return credentials;
};
var init_resolveSSOCredentials = __esm(() => {
init_dist_es4();
import_client6 = __toESM(require_client2());
import_config15 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/validateSsoProfile.js
var import_config16, validateSsoProfile = (profile, logger) => {
const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile;
if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) {
throw new import_config16.CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", ` + `"sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}
Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger });
}
return profile;
};
var init_validateSsoProfile = __esm(() => {
import_config16 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/fromSSO.js
var import_config17, fromSSO = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO");
const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
const { ssoClient } = init;
const profileName = import_config17.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
});
if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
const profiles = await import_config17.parseKnownFiles(init);
const profile = profiles[profileName];
if (!profile) {
throw new import_config17.CredentialsProviderError(`Profile ${profileName} was not found.`, { logger: init.logger });
}
if (!isSsoProfile(profile)) {
throw new import_config17.CredentialsProviderError(`Profile ${profileName} is not configured with SSO credentials.`, {
logger: init.logger
});
}
if (profile?.sso_session) {
const ssoSessions = await import_config17.loadSsoSessionData(init);
const session = ssoSessions[profile.sso_session];
const conflictMsg = ` configurations in profile ${profileName} and sso-session ${profile.sso_session}`;
if (ssoRegion && ssoRegion !== session.sso_region) {
throw new import_config17.CredentialsProviderError(`Conflicting SSO region` + conflictMsg, {
tryNextLink: false,
logger: init.logger
});
}
if (ssoStartUrl && ssoStartUrl !== session.sso_start_url) {
throw new import_config17.CredentialsProviderError(`Conflicting SSO start_url` + conflictMsg, {
tryNextLink: false,
logger: init.logger
});
}
profile.sso_region = session.sso_region;
profile.sso_start_url = session.sso_start_url;
}
const { sso_start_url, sso_account_id, sso_region, sso_role_name, sso_session } = validateSsoProfile(profile, init.logger);
return resolveSSOCredentials({
ssoStartUrl: sso_start_url,
ssoSession: sso_session,
ssoAccountId: sso_account_id,
ssoRegion: sso_region,
ssoRoleName: sso_role_name,
ssoClient,
clientConfig: init.clientConfig,
parentClientConfig: init.parentClientConfig,
callerClientConfig: init.callerClientConfig,
profile: profileName,
filepath: init.filepath,
configFilepath: init.configFilepath,
ignoreCache: init.ignoreCache,
logger: init.logger
});
} else if (!ssoStartUrl || !ssoAccountId || !ssoRegion || !ssoRoleName) {
throw new import_config17.CredentialsProviderError("Incomplete configuration. The fromSSO() argument hash must include " + '"ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', { tryNextLink: false, logger: init.logger });
} else {
return resolveSSOCredentials({
ssoStartUrl,
ssoSession,
ssoAccountId,
ssoRegion,
ssoRoleName,
ssoClient,
clientConfig: init.clientConfig,
parentClientConfig: init.parentClientConfig,
callerClientConfig: init.callerClientConfig,
profile: profileName,
filepath: init.filepath,
configFilepath: init.configFilepath,
ignoreCache: init.ignoreCache,
logger: init.logger
});
}
};
var init_fromSSO = __esm(() => {
init_resolveSSOCredentials();
init_validateSsoProfile();
import_config17 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/index.js
var init_dist_es5 = __esm(() => {
init_fromSSO();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js
var import_client7, import_config18, resolveCredentialSource = (credentialSource, profileName, logger) => {
const sourceProvidersMap = {
EcsContainer: async (options) => {
await Promise.resolve().then(() => init_dist_es3());
await Promise.resolve().then(() => init_dist_es2());
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
return async () => import_config18.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider);
},
Ec2InstanceMetadata: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
await Promise.resolve().then(() => init_dist_es2());
return async () => fromInstanceMetadata(options)().then(setNamedProvider);
},
Environment: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
await Promise.resolve().then(() => init_dist_es());
return async () => fromEnv(options)().then(setNamedProvider);
}
};
if (credentialSource in sourceProvidersMap) {
return sourceProvidersMap[credentialSource];
} else {
throw new import_config18.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger });
}
}, setNamedProvider = (creds) => import_client7.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
var init_resolveCredentialSource = __esm(() => {
import_client7 = __toESM(require_client2());
import_config18 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+signature-v4-multi-region@3.996.46/node_modules/@aws-sdk/signature-v4-multi-region/dist-cjs/index.js
var require_dist_cjs6 = __commonJS(function(exports) {
var { SignatureV4, signatureV4aContainer } = require_dist_cjs3();
var signatureV4CrtContainer = {
CrtSignerV4: null
};
var SESSION_TOKEN_QUERY_PARAM = "X-Amz-S3session-Token";
var SESSION_TOKEN_HEADER = SESSION_TOKEN_QUERY_PARAM.toLowerCase();
class SignatureV4SignWithCredentials extends SignatureV4 {
async signWithCredentials(requestToSign, credentials, options) {
const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
requestToSign.headers[SESSION_TOKEN_HEADER] = credentials.sessionToken;
const privateAccess = this;
setSingleOverride(privateAccess, credentialsWithoutSessionToken);
return privateAccess.signRequest(requestToSign, options ?? {});
}
async presignWithCredentials(requestToSign, credentials, options) {
const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
delete requestToSign.headers[SESSION_TOKEN_HEADER];
requestToSign.headers[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
requestToSign.query = requestToSign.query ?? {};
requestToSign.query[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
const privateAccess = this;
setSingleOverride(privateAccess, credentialsWithoutSessionToken);
return this.presign(requestToSign, options);
}
}
function getCredentialsWithoutSessionToken(credentials) {
return {
accessKeyId: credentials.accessKeyId,
secretAccessKey: credentials.secretAccessKey,
expiration: credentials.expiration
};
}
function setSingleOverride(privateAccess, credentialsWithoutSessionToken) {
const currentCredentialProvider = privateAccess.credentialProvider;
privateAccess.credentialProvider = () => {
privateAccess.credentialProvider = currentCredentialProvider;
return Promise.resolve(credentialsWithoutSessionToken);
};
}
class SignatureV4MultiRegion {
sigv4aSigner;
sigv4Signer;
signerOptions;
static sigv4aDependency() {
if (typeof signatureV4CrtContainer.CrtSignerV4 === "function") {
return "crt";
} else if (typeof signatureV4aContainer.SignatureV4a === "function") {
return "js";
}
return "none";
}
constructor(options) {
this.sigv4Signer = new SignatureV4SignWithCredentials(options);
this.signerOptions = options;
}
async sign(requestToSign, options = {}) {
if (options.signingRegion === "*") {
return this.getSigv4aSigner().sign(requestToSign, options);
}
return this.sigv4Signer.sign(requestToSign, options);
}
async signWithCredentials(requestToSign, credentials, options = {}) {
if (options.signingRegion === "*") {
const signer = this.getSigv4aSigner();
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
if (CrtSignerV4 && signer instanceof CrtSignerV4) {
return signer.signWithCredentials(requestToSign, credentials, options);
} else {
throw new Error(`signWithCredentials with signingRegion '*' is only supported when using the CRT dependency @aws-sdk/signature-v4-crt. ` + `Please check whether you have installed the "@aws-sdk/signature-v4-crt" package explicitly. ` + `You must also register the package by calling [require("@aws-sdk/signature-v4-crt");] ` + `or an ESM equivalent such as [import "@aws-sdk/signature-v4-crt";]. ` + `For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`);
}
}
return this.sigv4Signer.signWithCredentials(requestToSign, credentials, options);
}
async presign(originalRequest, options = {}) {
if (options.signingRegion === "*") {
const signer = this.getSigv4aSigner();
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
if (CrtSignerV4 && signer instanceof CrtSignerV4) {
return signer.presign(originalRequest, options);
} else {
throw new Error(`presign with signingRegion '*' is only supported when using the CRT dependency @aws-sdk/signature-v4-crt. ` + `Please check whether you have installed the "@aws-sdk/signature-v4-crt" package explicitly. ` + `You must also register the package by calling [require("@aws-sdk/signature-v4-crt");] ` + `or an ESM equivalent such as [import "@aws-sdk/signature-v4-crt";]. ` + `For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`);
}
}
return this.sigv4Signer.presign(originalRequest, options);
}
async presignWithCredentials(originalRequest, credentials, options = {}) {
if (options.signingRegion === "*") {
throw new Error("Method presignWithCredentials is not supported for [signingRegion=*].");
}
return this.sigv4Signer.presignWithCredentials(originalRequest, credentials, options);
}
getSigv4aSigner() {
if (!this.sigv4aSigner) {
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
const JsSigV4aSigner = signatureV4aContainer.SignatureV4a;
if (this.signerOptions.runtime === "node") {
if (!CrtSignerV4 && !JsSigV4aSigner) {
throw new Error("Neither CRT nor JS SigV4a implementation is available. " + "Please load either @aws-sdk/signature-v4-crt or @aws-sdk/signature-v4a. " + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt");
}
if (CrtSignerV4 && typeof CrtSignerV4 === "function") {
this.sigv4aSigner = new CrtSignerV4({
...this.signerOptions,
signingAlgorithm: 1
});
} else if (JsSigV4aSigner && typeof JsSigV4aSigner === "function") {
this.sigv4aSigner = new JsSigV4aSigner({
...this.signerOptions
});
} else {
throw new Error("Available SigV4a implementation is not a valid constructor. " + "Please ensure you've properly imported @aws-sdk/signature-v4-crt or @aws-sdk/signature-v4a." + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt");
}
} else {
if (!JsSigV4aSigner || typeof JsSigV4aSigner !== "function") {
throw new Error("JS SigV4a implementation is not available or not a valid constructor. " + "Please check whether you have installed the @aws-sdk/signature-v4a package explicitly. The CRT implementation is not available for browsers. " + "You must also register the package by calling [require('@aws-sdk/signature-v4a');] " + "or an ESM equivalent such as [import '@aws-sdk/signature-v4a';]. " + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#using-javascript-non-crt-implementation-of-sigv4a");
}
this.sigv4aSigner = new JsSigV4aSigner({
...this.signerOptions
});
}
}
return this.sigv4aSigner;
}
}
exports.SignatureV4MultiRegion = SignatureV4MultiRegion;
exports.SignatureV4SignWithCredentials = SignatureV4SignWithCredentials;
exports.signatureV4CrtContainer = signatureV4CrtContainer;
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sts/index.js
var require_sts = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, setCredentialFeature, stsRegionDefaultResolver } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveParams, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, resolveAwsSdkSigV4AConfig, AwsSdkSigV4Signer, AwsSdkSigV4ASigner, NODE_SIGV4A_CONFIG_OPTIONS, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { SignatureV4MultiRegion } = require_dist_cjs6();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsQueryProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var q = "ref";
var a = -1;
var b = true;
var c = "isSet";
var d = "PartitionResult";
var e = "booleanEquals";
var f = "stringEquals";
var g = "getAttr";
var h = "us-east-1";
var i = "sigv4";
var j = "sts";
var k = "https://sts.{Region}.{PartitionResult#dnsSuffix}";
var l = { [q]: "Endpoint" };
var m = { [q]: "Region" };
var n = { [q]: d };
var o = {};
var p = [m];
var _data = {
conditions: [
[c, [l]],
[c, p],
["aws.partition", p, d],
[e, [{ [q]: "UseFIPS" }, b]],
[e, [{ [q]: "UseDualStack" }, b]],
[f, [m, "aws-global"]],
[e, [{ [q]: "UseGlobalEndpoint" }, b]],
[f, [m, "eu-central-1"]],
[e, [{ fn: g, argv: [n, "supportsDualStack"] }, b]],
[e, [{ fn: g, argv: [n, "supportsFIPS"] }, b]],
[f, [m, "ap-south-1"]],
[f, [m, "eu-north-1"]],
[f, [m, "eu-west-1"]],
[f, [m, "eu-west-2"]],
[f, [m, "eu-west-3"]],
[f, [m, "sa-east-1"]],
[f, [m, h]],
[f, [m, "us-east-2"]],
[f, [m, "us-west-2"]],
[f, [m, "us-west-1"]],
[f, [m, "ca-central-1"]],
[f, [m, "ap-southeast-1"]],
[f, [m, "ap-northeast-1"]],
[f, [m, "ap-southeast-2"]],
[f, [{ fn: g, argv: [n, "name"] }, "aws-us-gov"]]
],
results: [
[a],
["https://sts.amazonaws.com", { authSchemes: [{ name: i, signingName: j, signingRegion: h }] }],
[k, { authSchemes: [{ name: i, signingName: j, signingRegion: "{Region}" }] }],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[l, o],
["https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", o],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://sts.{Region}.amazonaws.com", o],
["https://sts-fips.{Region}.{PartitionResult#dnsSuffix}", o],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}", o],
[a, "DualStack is enabled but this partition does not support DualStack"],
[k, o],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
30,
3,
1,
4,
r + 14,
2,
5,
r + 14,
3,
25,
6,
4,
24,
7,
5,
r + 1,
8,
6,
9,
r + 13,
7,
r + 1,
10,
10,
r + 1,
11,
11,
r + 1,
12,
12,
r + 1,
13,
13,
r + 1,
14,
14,
r + 1,
15,
15,
r + 1,
16,
16,
r + 1,
17,
17,
r + 1,
18,
18,
r + 1,
19,
19,
r + 1,
20,
20,
r + 1,
21,
21,
r + 1,
22,
22,
r + 1,
23,
23,
r + 1,
r + 2,
8,
r + 11,
r + 12,
4,
28,
26,
9,
27,
r + 10,
24,
r + 8,
r + 9,
8,
29,
r + 7,
9,
r + 6,
r + 7,
3,
r + 3,
31,
4,
r + 4,
r + 5
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
var createEndpointRuleSetHttpAuthSchemeParametersProvider = (defaultHttpAuthSchemeParametersProvider) => async (config, context, input) => {
if (!input) {
throw new Error("Could not find `input` for `defaultEndpointRuleSetHttpAuthSchemeParametersProvider`");
}
const defaultParameters = await defaultHttpAuthSchemeParametersProvider(config, context, input);
const instructionsFn = getSmithyContext(context)?.commandInstance?.constructor?.getEndpointParameterInstructions;
if (!instructionsFn) {
throw new Error(`getEndpointParameterInstructions() is not defined on '${context.commandName}'`);
}
const endpointParameters = await resolveParams(input, { getEndpointParameterInstructions: instructionsFn }, config);
return Object.assign(defaultParameters, endpointParameters);
};
var _defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
var defaultSTSHttpAuthSchemeParametersProvider = createEndpointRuleSetHttpAuthSchemeParametersProvider(_defaultSTSHttpAuthSchemeParametersProvider);
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "sts",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createAwsAuthSigv4aHttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4a",
signingProperties: {
name: "sts",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var createEndpointRuleSetHttpAuthSchemeProvider = (defaultEndpointResolver, defaultHttpAuthSchemeResolver, createHttpAuthOptionFunctions) => {
const endpointRuleSetHttpAuthSchemeProvider = (authParameters) => {
const endpoint = defaultEndpointResolver(authParameters);
const authSchemes = endpoint.properties?.authSchemes;
if (!authSchemes) {
return defaultHttpAuthSchemeResolver(authParameters);
}
const options = [];
for (const scheme of authSchemes) {
const { name: resolvedName, properties = {}, ...rest } = scheme;
const name = resolvedName.toLowerCase();
if (resolvedName !== name) {
console.warn(`HttpAuthScheme has been normalized with lowercasing: '${resolvedName}' to '${name}'`);
}
let schemeId;
if (name === "sigv4a") {
schemeId = "aws.auth#sigv4a";
const sigv4Present = authSchemes.find((s) => {
const name = s.name.toLowerCase();
return name !== "sigv4a" && name.startsWith("sigv4");
});
if (SignatureV4MultiRegion.sigv4aDependency() === "none" && sigv4Present) {
continue;
}
} else if (name.startsWith("sigv4")) {
schemeId = "aws.auth#sigv4";
} else {
throw new Error(`Unknown HttpAuthScheme found in '@smithy.rules#endpointRuleSet': '${name}'`);
}
const createOption = createHttpAuthOptionFunctions[schemeId];
if (!createOption) {
throw new Error(`Could not find HttpAuthOption create function for '${schemeId}'`);
}
const option = createOption(authParameters);
option.schemeId = schemeId;
option.signingProperties = { ...option.signingProperties || {}, ...rest, ...properties };
options.push(option);
}
return options;
};
return endpointRuleSetHttpAuthSchemeProvider;
};
var _defaultSTSHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "AssumeRoleWithWebIdentity": {
options.push(createSmithyApiNoAuthHttpAuthOption());
options.push(createAwsAuthSigv4aHttpAuthOption(authParameters));
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
options.push(createAwsAuthSigv4aHttpAuthOption(authParameters));
}
}
return options;
};
var defaultSTSHttpAuthSchemeProvider = createEndpointRuleSetHttpAuthSchemeProvider(defaultEndpointResolver, _defaultSTSHttpAuthSchemeProvider, {
"aws.auth#sigv4": createAwsAuthSigv4HttpAuthOption,
"aws.auth#sigv4a": createAwsAuthSigv4aHttpAuthOption,
"smithy.api#noAuth": createSmithyApiNoAuthHttpAuthOption
});
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
const config_1 = resolveAwsSdkSigV4AConfig(config_0);
return Object.assign(config_1, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
useGlobalEndpoint: options.useGlobalEndpoint ?? false,
defaultSigningName: "sts"
});
};
var commonParams = {
UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
class STSServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, STSServiceException.prototype);
}
}
class ExpiredTokenException extends STSServiceException {
name = "ExpiredTokenException";
$fault = "client";
constructor(opts) {
super({
name: "ExpiredTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ExpiredTokenException.prototype);
}
}
class MalformedPolicyDocumentException extends STSServiceException {
name = "MalformedPolicyDocumentException";
$fault = "client";
constructor(opts) {
super({
name: "MalformedPolicyDocumentException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
}
}
class PackedPolicyTooLargeException extends STSServiceException {
name = "PackedPolicyTooLargeException";
$fault = "client";
constructor(opts) {
super({
name: "PackedPolicyTooLargeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PackedPolicyTooLargeException.prototype);
}
}
class RegionDisabledException extends STSServiceException {
name = "RegionDisabledException";
$fault = "client";
constructor(opts) {
super({
name: "RegionDisabledException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, RegionDisabledException.prototype);
}
}
class IDPRejectedClaimException extends STSServiceException {
name = "IDPRejectedClaimException";
$fault = "client";
constructor(opts) {
super({
name: "IDPRejectedClaimException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IDPRejectedClaimException.prototype);
}
}
class InvalidIdentityTokenException extends STSServiceException {
name = "InvalidIdentityTokenException";
$fault = "client";
constructor(opts) {
super({
name: "InvalidIdentityTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidIdentityTokenException.prototype);
}
}
class IDPCommunicationErrorException extends STSServiceException {
name = "IDPCommunicationErrorException";
$fault = "client";
$retryable = {};
constructor(opts) {
super({
name: "IDPCommunicationErrorException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IDPCommunicationErrorException.prototype);
}
}
var _A = "Arn";
var _AKI = "AccessKeyId";
var _AR = "AssumeRole";
var _ARI = "AssumedRoleId";
var _ARR = "AssumeRoleRequest";
var _ARRs = "AssumeRoleResponse";
var _ARU = "AssumedRoleUser";
var _ARWWI = "AssumeRoleWithWebIdentity";
var _ARWWIR = "AssumeRoleWithWebIdentityRequest";
var _ARWWIRs = "AssumeRoleWithWebIdentityResponse";
var _Au = "Audience";
var _C = "Credentials";
var _CA = "ContextAssertion";
var _DS = "DurationSeconds";
var _E = "Expiration";
var _EI = "ExternalId";
var _ETE = "ExpiredTokenException";
var _IDPCEE = "IDPCommunicationErrorException";
var _IDPRCE = "IDPRejectedClaimException";
var _IITE = "InvalidIdentityTokenException";
var _K = "Key";
var _MPDE = "MalformedPolicyDocumentException";
var _P = "Policy";
var _PA = "PolicyArns";
var _PAr = "ProviderArn";
var _PC = "ProvidedContexts";
var _PCLT = "ProvidedContextsListType";
var _PCr = "ProvidedContext";
var _PDT = "PolicyDescriptorType";
var _PI = "ProviderId";
var _PPS = "PackedPolicySize";
var _PPTLE = "PackedPolicyTooLargeException";
var _Pr = "Provider";
var _RA = "RoleArn";
var _RDE = "RegionDisabledException";
var _RSN = "RoleSessionName";
var _SAK = "SecretAccessKey";
var _SFWIT = "SubjectFromWebIdentityToken";
var _SI = "SourceIdentity";
var _SN = "SerialNumber";
var _ST = "SessionToken";
var _T = "Tags";
var _TC = "TokenCode";
var _TTK = "TransitiveTagKeys";
var _Ta = "Tag";
var _V = "Value";
var _WIT = "WebIdentityToken";
var _a = "arn";
var _aKST = "accessKeySecretType";
var _aQE = "awsQueryError";
var _c = "client";
var _cTT = "clientTokenType";
var _e = "error";
var _hE = "httpError";
var _m = "message";
var _pDLT = "policyDescriptorListType";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.sts";
var _tLT = "tagListType";
var n0 = "com.amazonaws.sts";
var _s_registry = TypeRegistry.for(_s);
var STSServiceException$ = [-3, _s, "STSServiceException", 0, [], []];
_s_registry.registerError(STSServiceException$, STSServiceException);
var n0_registry = TypeRegistry.for(n0);
var ExpiredTokenException$ = [
-3,
n0,
_ETE,
{ [_aQE]: [`ExpiredTokenException`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(ExpiredTokenException$, ExpiredTokenException);
var IDPCommunicationErrorException$ = [
-3,
n0,
_IDPCEE,
{ [_aQE]: [`IDPCommunicationError`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(IDPCommunicationErrorException$, IDPCommunicationErrorException);
var IDPRejectedClaimException$ = [
-3,
n0,
_IDPRCE,
{ [_aQE]: [`IDPRejectedClaim`, 403], [_e]: _c, [_hE]: 403 },
[_m],
[0]
];
n0_registry.registerError(IDPRejectedClaimException$, IDPRejectedClaimException);
var InvalidIdentityTokenException$ = [
-3,
n0,
_IITE,
{ [_aQE]: [`InvalidIdentityToken`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(InvalidIdentityTokenException$, InvalidIdentityTokenException);
var MalformedPolicyDocumentException$ = [
-3,
n0,
_MPDE,
{ [_aQE]: [`MalformedPolicyDocument`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(MalformedPolicyDocumentException$, MalformedPolicyDocumentException);
var PackedPolicyTooLargeException$ = [
-3,
n0,
_PPTLE,
{ [_aQE]: [`PackedPolicyTooLarge`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(PackedPolicyTooLargeException$, PackedPolicyTooLargeException);
var RegionDisabledException$ = [
-3,
n0,
_RDE,
{ [_aQE]: [`RegionDisabledException`, 403], [_e]: _c, [_hE]: 403 },
[_m],
[0]
];
n0_registry.registerError(RegionDisabledException$, RegionDisabledException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var accessKeySecretType = [0, n0, _aKST, 8, 0];
var clientTokenType = [0, n0, _cTT, 8, 0];
var AssumedRoleUser$ = [
3,
n0,
_ARU,
0,
[_ARI, _A],
[0, 0],
2
];
var AssumeRoleRequest$ = [
3,
n0,
_ARR,
0,
[_RA, _RSN, _PA, _P, _DS, _T, _TTK, _EI, _SN, _TC, _SI, _PC],
[0, 0, () => policyDescriptorListType, 0, 1, () => tagListType, 64 | 0, 0, 0, 0, 0, () => ProvidedContextsListType],
2
];
var AssumeRoleResponse$ = [
3,
n0,
_ARRs,
0,
[_C, _ARU, _PPS, _SI],
[[() => Credentials$, 0], () => AssumedRoleUser$, 1, 0]
];
var AssumeRoleWithWebIdentityRequest$ = [
3,
n0,
_ARWWIR,
0,
[_RA, _RSN, _WIT, _PI, _PA, _P, _DS],
[0, 0, [() => clientTokenType, 0], 0, () => policyDescriptorListType, 0, 1],
3
];
var AssumeRoleWithWebIdentityResponse$ = [
3,
n0,
_ARWWIRs,
0,
[_C, _SFWIT, _ARU, _PPS, _Pr, _Au, _SI],
[[() => Credentials$, 0], 0, () => AssumedRoleUser$, 1, 0, 0, 0]
];
var Credentials$ = [
3,
n0,
_C,
0,
[_AKI, _SAK, _ST, _E],
[0, [() => accessKeySecretType, 0], 0, 4],
4
];
var PolicyDescriptorType$ = [
3,
n0,
_PDT,
0,
[_a],
[0]
];
var ProvidedContext$ = [
3,
n0,
_PCr,
0,
[_PAr, _CA],
[0, 0]
];
var Tag$ = [
3,
n0,
_Ta,
0,
[_K, _V],
[0, 0],
2
];
var policyDescriptorListType = [
1,
n0,
_pDLT,
0,
() => PolicyDescriptorType$
];
var ProvidedContextsListType = [
1,
n0,
_PCLT,
0,
() => ProvidedContext$
];
var tagListType = [
1,
n0,
_tLT,
0,
() => Tag$
];
var AssumeRole$ = [
9,
n0,
_AR,
0,
() => AssumeRoleRequest$,
() => AssumeRoleResponse$
];
var AssumeRoleWithWebIdentity$ = [
9,
n0,
_ARWWI,
0,
() => AssumeRoleWithWebIdentityRequest$,
() => AssumeRoleWithWebIdentityResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2011-06-15",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSTSHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "aws.auth#sigv4a",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4a"),
signer: new AwsSdkSigV4ASigner
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsQueryProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.sts",
errorTypeRegistries,
xmlNamespace: "https://sts.amazonaws.com/doc/2011-06-15/",
version: "2011-06-15",
serviceTarget: "AWSSecurityTokenServiceV20110615"
},
serviceId: config?.serviceId ?? "STS",
sha256: config?.sha256 ?? Sha256,
signerConstructor: config?.signerConstructor ?? SignatureV4MultiRegion,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4") || (async (idProps) => await config.credentialDefaultProvider(idProps?.__config || {})()),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "aws.auth#sigv4a",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4a"),
signer: new AwsSdkSigV4ASigner
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
sigv4aSigningRegionSet: config?.sigv4aSigningRegionSet ?? loadConfig(NODE_SIGV4A_CONFIG_OPTIONS, loaderConfig),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class STSClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSTSHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials,
"aws.auth#sigv4a": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "AWSSecurityTokenServiceV20110615", "STSClient", getEndpointPlugin);
var _ep0 = {};
var _mw0 = (Command, cs, config, o) => [];
class AssumeRoleCommand extends command(_ep0, _mw0, "AssumeRole", AssumeRole$) {
}
class AssumeRoleWithWebIdentityCommand extends command(_ep0, _mw0, "AssumeRoleWithWebIdentity", AssumeRoleWithWebIdentity$) {
}
var commands = {
AssumeRoleCommand,
AssumeRoleWithWebIdentityCommand
};
class STS extends STSClient {
}
createAggregatedClient(commands, STS);
var getAccountIdFromAssumedRoleUser = (assumedRoleUser) => {
if (typeof assumedRoleUser?.Arn === "string") {
const arnComponents = assumedRoleUser.Arn.split(":");
if (arnComponents.length > 4 && arnComponents[4] !== "") {
return arnComponents[4];
}
}
return;
};
var resolveRegion = async (_region, _parentRegion, credentialProviderLogger, loaderConfig = {}) => {
const region = typeof _region === "function" ? await _region() : _region;
const parentRegion = typeof _parentRegion === "function" ? await _parentRegion() : _parentRegion;
let stsDefaultRegion = "";
const resolvedRegion = region ?? parentRegion ?? (stsDefaultRegion = await stsRegionDefaultResolver(loaderConfig)());
credentialProviderLogger?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${region} (credential provider clientConfig)`, `${parentRegion} (contextual client)`, `${stsDefaultRegion} (STS default: AWS_REGION, profile region, or us-east-1)`);
return resolvedRegion;
};
var getDefaultRoleAssumer$1 = (stsOptions, STSClient) => {
let stsClient;
let closureSourceCreds;
return async (sourceCreds, params) => {
closureSourceCreds = sourceCreds;
if (!stsClient) {
const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
logger,
profile
});
const isCompatibleRequestHandler = !isH2(requestHandler);
stsClient = new STSClient({
...stsOptions,
userAgentAppId,
profile,
credentialDefaultProvider: () => async () => closureSourceCreds,
region: resolvedRegion,
requestHandler: isCompatibleRequestHandler ? requestHandler : undefined,
logger
});
}
const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleCommand(params));
if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`);
}
const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
const credentials = {
accessKeyId: Credentials.AccessKeyId,
secretAccessKey: Credentials.SecretAccessKey,
sessionToken: Credentials.SessionToken,
expiration: Credentials.Expiration,
...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
...accountId && { accountId }
};
setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE", "i");
return credentials;
};
};
var getDefaultRoleAssumerWithWebIdentity$1 = (stsOptions, STSClient) => {
let stsClient;
return async (params) => {
if (!stsClient) {
const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
logger,
profile
});
const isCompatibleRequestHandler = !isH2(requestHandler);
stsClient = new STSClient({
...stsOptions,
userAgentAppId,
profile,
region: resolvedRegion,
requestHandler: isCompatibleRequestHandler ? requestHandler : undefined,
logger
});
}
const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params));
if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`);
}
const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
const credentials = {
accessKeyId: Credentials.AccessKeyId,
secretAccessKey: Credentials.SecretAccessKey,
sessionToken: Credentials.SessionToken,
expiration: Credentials.Expiration,
...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
...accountId && { accountId }
};
if (accountId) {
setCredentialFeature(credentials, "RESOLVED_ACCOUNT_ID", "T");
}
setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k");
return credentials;
};
};
var isH2 = (requestHandler) => {
return requestHandler?.metadata?.handlerProtocol === "h2";
};
var getCustomizableStsClientCtor = (baseCtor, customizations) => {
if (!customizations)
return baseCtor;
else
return class CustomizableSTSClient extends baseCtor {
constructor(config) {
super(config);
for (const customization of customizations) {
this.middlewareStack.use(customization);
}
}
};
};
var getDefaultRoleAssumer = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumer$1(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
var getDefaultRoleAssumerWithWebIdentity = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumerWithWebIdentity$1(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
var decorateDefaultCredentialProvider = (provider) => (input) => provider({
roleAssumer: getDefaultRoleAssumer(input),
roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input),
...input
});
exports.AssumeRole$ = AssumeRole$;
exports.AssumeRoleCommand = AssumeRoleCommand;
exports.AssumeRoleRequest$ = AssumeRoleRequest$;
exports.AssumeRoleResponse$ = AssumeRoleResponse$;
exports.AssumeRoleWithWebIdentity$ = AssumeRoleWithWebIdentity$;
exports.AssumeRoleWithWebIdentityCommand = AssumeRoleWithWebIdentityCommand;
exports.AssumeRoleWithWebIdentityRequest$ = AssumeRoleWithWebIdentityRequest$;
exports.AssumeRoleWithWebIdentityResponse$ = AssumeRoleWithWebIdentityResponse$;
exports.AssumedRoleUser$ = AssumedRoleUser$;
exports.Credentials$ = Credentials$;
exports.ExpiredTokenException = ExpiredTokenException;
exports.ExpiredTokenException$ = ExpiredTokenException$;
exports.IDPCommunicationErrorException = IDPCommunicationErrorException;
exports.IDPCommunicationErrorException$ = IDPCommunicationErrorException$;
exports.IDPRejectedClaimException = IDPRejectedClaimException;
exports.IDPRejectedClaimException$ = IDPRejectedClaimException$;
exports.InvalidIdentityTokenException = InvalidIdentityTokenException;
exports.InvalidIdentityTokenException$ = InvalidIdentityTokenException$;
exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException;
exports.MalformedPolicyDocumentException$ = MalformedPolicyDocumentException$;
exports.PackedPolicyTooLargeException = PackedPolicyTooLargeException;
exports.PackedPolicyTooLargeException$ = PackedPolicyTooLargeException$;
exports.PolicyDescriptorType$ = PolicyDescriptorType$;
exports.ProvidedContext$ = ProvidedContext$;
exports.RegionDisabledException = RegionDisabledException;
exports.RegionDisabledException$ = RegionDisabledException$;
exports.STS = STS;
exports.STSClient = STSClient;
exports.STSServiceException = STSServiceException;
exports.STSServiceException$ = STSServiceException$;
exports.Tag$ = Tag$;
exports.decorateDefaultCredentialProvider = decorateDefaultCredentialProvider;
exports.errorTypeRegistries = errorTypeRegistries;
exports.getDefaultRoleAssumer = getDefaultRoleAssumer;
exports.getDefaultRoleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var import_client8, import_config19, isAssumeRoleProfile = (arg, { profile = "default", logger } = {}) => {
return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile(arg, { profile, logger }) || isCredentialSourceProfile(arg, { profile, logger }));
}, isAssumeRoleWithSourceProfile = (arg, { profile, logger }) => {
const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
if (withSourceProfile) {
logger?.debug?.(` ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
}
return withSourceProfile;
}, isCredentialSourceProfile = (arg, { profile, logger }) => {
const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
if (withProviderProfile) {
logger?.debug?.(` ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
}
return withProviderProfile;
}, resolveAssumeRoleCredentials = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, resolveProfileData) => {
options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
const profileData = profiles[profileName];
const { source_profile, region } = profileData;
if (!options.roleAssumer) {
const { getDefaultRoleAssumer } = await Promise.resolve().then(() => __toESM(require_sts()));
options.roleAssumer = getDefaultRoleAssumer({
...options.clientConfig,
credentialProviderLogger: options.logger,
parentClientConfig: {
...callerClientConfig,
...options?.parentClientConfig,
region: region ?? options?.parentClientConfig?.region ?? callerClientConfig?.region
}
}, options.clientPlugins);
}
if (source_profile && source_profile in visitedProfiles) {
throw new import_config19.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${import_config19.getProfileName(options)}. Profiles visited: ` + Object.keys(visitedProfiles).join(", "), { logger: options.logger });
}
options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`);
const sourceCredsProvider = source_profile ? resolveProfileData(source_profile, profiles, options, callerClientConfig, {
...visitedProfiles,
[source_profile]: true
}, isCredentialSourceWithoutRoleArn(profiles[source_profile] ?? {})) : (await resolveCredentialSource(profileData.credential_source, profileName, options.logger)(options))();
if (isCredentialSourceWithoutRoleArn(profileData)) {
return sourceCredsProvider.then((creds) => import_client8.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
} else {
const params = {
RoleArn: profileData.role_arn,
RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`,
ExternalId: profileData.external_id,
DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10)
};
const { mfa_serial } = profileData;
if (mfa_serial) {
if (!options.mfaCodeProvider) {
throw new import_config19.CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false });
}
params.SerialNumber = mfa_serial;
params.TokenCode = await options.mfaCodeProvider(mfa_serial);
}
const sourceCreds = await sourceCredsProvider;
return options.roleAssumer(sourceCreds, params).then((creds) => import_client8.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
}
}, isCredentialSourceWithoutRoleArn = (section) => {
return !section.role_arn && !!section.credential_source;
};
var init_resolveAssumeRoleCredentials = __esm(() => {
init_resolveCredentialSource();
import_client8 = __toESM(require_client2());
import_config19 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/signin/index.js
var require_signin = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsRestJsonProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var defaultSigninHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "signin",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var defaultSigninHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "CreateOAuth2Token": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "signin"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
var s = "ref";
var a = -1;
var b = false;
var c = true;
var d = "isSet";
var e = "booleanEquals";
var f = "coalesce";
var g = "PartitionResult";
var h = "stringEquals";
var i = "getAttr";
var j = "https://signin.{Region}.{PartitionResult#dualStackDnsSuffix}";
var k = { [s]: "Endpoint" };
var l = { fn: i, argv: [{ [s]: g }, "name"] };
var m = { [s]: "Region" };
var n = { [s]: g };
var o = { authSchemes: [{ name: "sigv4", signingName: "signin", signingRegion: "{Region}" }] };
var p = {};
var q = [m];
var _data = {
conditions: [
[d, q],
[e, [{ fn: f, argv: [{ [s]: "IsControlPlane" }, b] }, c]],
[d, [k]],
["aws.partition", q, g],
[e, [{ [s]: "UseFIPS" }, c]],
[h, [l, "aws"]],
[e, [{ fn: f, argv: [{ [s]: "IsOAuthEndpoint" }, b] }, c]],
[e, [{ [s]: "UseDualStack" }, c]],
[h, [l, "aws-cn"]],
[h, [m, "us-gov-west-1"]],
[h, [l, "aws-us-gov"]],
[e, [{ fn: i, argv: [n, "supportsFIPS"] }, c]],
[h, [l, "aws-iso"]],
[h, [l, "aws-iso-b"]],
[h, [l, "aws-iso-f"]],
[h, [l, "aws-iso-e"]],
[h, [l, "aws-eusc"]],
[e, [{ fn: i, argv: [n, "supportsDualStack"] }, c]]
],
results: [
[a],
["https://signin.{Region}.api.aws", o],
["https://signin.{Region}.api.amazonwebservices.com.cn", o],
[j, o],
[a, "FIPS endpoints are not supported for OAuth operations. Disable FIPS or use a non-OAuth operation."],
["https://{Region}.oauth.signin.aws", o],
["https://{Region}.signin.aws.amazon.com", p],
["https://{Region}.signin.amazonaws.cn", p],
["https://{Region}.signin.amazonaws-us-gov.com", p],
["https://{Region}.signin.c2shome.ic.gov", p],
["https://{Region}.signin.sc2shome.sgov.gov", p],
["https://{Region}.signin.csphome.hci.ic.gov", p],
["https://{Region}.signin.csphome.adc-e.uk", p],
["https://{Region}.signin.amazonaws-eusc.eu", p],
["https://signin-fips.amazonaws-us-gov.com", p],
["https://{Region}.signin-fips.amazonaws-us-gov.com", p],
["https://{Region}.signin.{PartitionResult#dnsSuffix}", p],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[k, p],
["https://signin-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", p],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://signin-fips.{Region}.{PartitionResult#dnsSuffix}", p],
[a, "FIPS is enabled but this partition does not support FIPS"],
[j, p],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://signin.{Region}.{PartitionResult#dnsSuffix}", p],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
6,
3,
2,
36,
4,
4,
5,
r + 27,
6,
r + 4,
r + 27,
1,
29,
7,
2,
36,
8,
3,
9,
31,
4,
22,
10,
5,
19,
11,
7,
21,
12,
8,
r + 7,
13,
10,
r + 8,
14,
12,
r + 9,
15,
13,
r + 10,
16,
14,
r + 11,
17,
15,
r + 12,
18,
16,
r + 13,
r + 16,
6,
r + 5,
20,
7,
21,
r + 6,
17,
r + 24,
r + 25,
6,
r + 4,
23,
7,
27,
24,
9,
r + 14,
25,
10,
r + 15,
26,
11,
r + 22,
r + 23,
11,
28,
r + 21,
17,
r + 20,
r + 21,
2,
35,
30,
3,
39,
31,
4,
32,
r + 27,
6,
r + 4,
33,
7,
r + 27,
34,
9,
r + 14,
r + 27,
3,
39,
36,
4,
38,
37,
7,
r + 18,
r + 19,
6,
r + 4,
r + 17,
5,
r + 1,
40,
8,
r + 2,
r + 3
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "IsControlPlane", "IsOAuthEndpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
class SigninServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SigninServiceException.prototype);
}
}
class AccessDeniedException extends SigninServiceException {
name = "AccessDeniedException";
$fault = "client";
error;
constructor(opts) {
super({
name: "AccessDeniedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AccessDeniedException.prototype);
this.error = opts.error;
}
}
class InternalServerException extends SigninServiceException {
name = "InternalServerException";
$fault = "server";
error;
constructor(opts) {
super({
name: "InternalServerException",
$fault: "server",
...opts
});
Object.setPrototypeOf(this, InternalServerException.prototype);
this.error = opts.error;
}
}
class TooManyRequestsError extends SigninServiceException {
name = "TooManyRequestsError";
$fault = "client";
error;
constructor(opts) {
super({
name: "TooManyRequestsError",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyRequestsError.prototype);
this.error = opts.error;
}
}
class ValidationException extends SigninServiceException {
name = "ValidationException";
$fault = "client";
error;
constructor(opts) {
super({
name: "ValidationException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ValidationException.prototype);
this.error = opts.error;
}
}
var _ADE = "AccessDeniedException";
var _AT = "AccessToken";
var _COAT = "CreateOAuth2Token";
var _COATR = "CreateOAuth2TokenRequest";
var _COATRB = "CreateOAuth2TokenRequestBody";
var _COATRBr = "CreateOAuth2TokenResponseBody";
var _COATRr = "CreateOAuth2TokenResponse";
var _COATWIAM = "CreateOAuth2TokenWithIAM";
var _COATWIAMR = "CreateOAuth2TokenWithIAMRequest";
var _COATWIAMRr = "CreateOAuth2TokenWithIAMResponse";
var _ISE = "InternalServerException";
var _OAAT = "OAuthAccessToken";
var _RT = "RefreshToken";
var _TMRE = "TooManyRequestsError";
var _VE = "ValidationException";
var _aKI = "accessKeyId";
var _aT = "accessToken";
var _at = "access_token";
var _c = "client";
var _cI = "clientId";
var _cV = "codeVerifier";
var _co = "code";
var _e = "error";
var _eI = "expiresIn";
var _ei = "expires_in";
var _gT = "grantType";
var _gt = "grant_type";
var _h = "http";
var _hE = "httpError";
var _iT = "idToken";
var _jN = "jsonName";
var _m = "message";
var _r = "resource";
var _rT = "refreshToken";
var _rU = "redirectUri";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.signin";
var _sAK = "secretAccessKey";
var _sT = "sessionToken";
var _se = "server";
var _tI = "tokenInput";
var _tO = "tokenOutput";
var _tT = "tokenType";
var _tt = "token_type";
var n0 = "com.amazonaws.signin";
var _s_registry = TypeRegistry.for(_s);
var SigninServiceException$ = [-3, _s, "SigninServiceException", 0, [], []];
_s_registry.registerError(SigninServiceException$, SigninServiceException);
var n0_registry = TypeRegistry.for(n0);
var AccessDeniedException$ = [
-3,
n0,
_ADE,
{ [_e]: _c },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
var InternalServerException$ = [
-3,
n0,
_ISE,
{ [_e]: _se, [_hE]: 500 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(InternalServerException$, InternalServerException);
var TooManyRequestsError$ = [
-3,
n0,
_TMRE,
{ [_e]: _c, [_hE]: 429 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(TooManyRequestsError$, TooManyRequestsError);
var ValidationException$ = [
-3,
n0,
_VE,
{ [_e]: _c, [_hE]: 400 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(ValidationException$, ValidationException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var OAuthAccessToken = [0, n0, _OAAT, 8, 0];
var RefreshToken = [0, n0, _RT, 8, 0];
var AccessToken$ = [
3,
n0,
_AT,
8,
[_aKI, _sAK, _sT],
[[0, { [_jN]: _aKI }], [0, { [_jN]: _sAK }], [0, { [_jN]: _sT }]],
3
];
var CreateOAuth2TokenRequest$ = [
3,
n0,
_COATR,
0,
[_tI],
[[() => CreateOAuth2TokenRequestBody$, 16]],
1
];
var CreateOAuth2TokenRequestBody$ = [
3,
n0,
_COATRB,
0,
[_cI, _gT, _co, _rU, _cV, _rT],
[[0, { [_jN]: _cI }], [0, { [_jN]: _gT }], 0, [0, { [_jN]: _rU }], [0, { [_jN]: _cV }], [() => RefreshToken, { [_jN]: _rT }]],
2
];
var CreateOAuth2TokenResponse$ = [
3,
n0,
_COATRr,
0,
[_tO],
[[() => CreateOAuth2TokenResponseBody$, 16]],
1
];
var CreateOAuth2TokenResponseBody$ = [
3,
n0,
_COATRBr,
0,
[_aT, _tT, _eI, _rT, _iT],
[[() => AccessToken$, { [_jN]: _aT }], [0, { [_jN]: _tT }], [1, { [_jN]: _eI }], [() => RefreshToken, { [_jN]: _rT }], [0, { [_jN]: _iT }]],
4
];
var CreateOAuth2TokenWithIAMRequest$ = [
3,
n0,
_COATWIAMR,
0,
[_gT, _r],
[[0, { [_jN]: _gt }], 0],
2
];
var CreateOAuth2TokenWithIAMResponse$ = [
3,
n0,
_COATWIAMRr,
0,
[_aT, _tT, _eI],
[[() => OAuthAccessToken, { [_jN]: _at }], [0, { [_jN]: _tt }], [1, { [_jN]: _ei }]],
3
];
var CreateOAuth2Token$ = [
9,
n0,
_COAT,
{ [_h]: ["POST", "/v1/token", 200] },
() => CreateOAuth2TokenRequest$,
() => CreateOAuth2TokenResponse$
];
var CreateOAuth2TokenWithIAM$ = [
9,
n0,
_COATWIAM,
{ [_h]: ["POST", "/v1/token?x-amz-client-auth-method=iam", 200] },
() => CreateOAuth2TokenWithIAMRequest$,
() => CreateOAuth2TokenWithIAMResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2023-01-01",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSigninHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.signin",
errorTypeRegistries,
version: "2023-01-01",
serviceTarget: "Signin"
},
serviceId: config?.serviceId ?? "Signin",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class SigninClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSigninHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "Signin", "SigninClient", getEndpointPlugin);
var _ep0 = {
IsControlPlane: { type: "staticContextParams", value: false }
};
var _ep1 = {
IsOAuthEndpoint: { type: "staticContextParams", value: true }
};
var _mw0 = (Command, cs, config, o) => [];
class CreateOAuth2TokenCommand extends command(_ep0, _mw0, "CreateOAuth2Token", CreateOAuth2Token$) {
}
class CreateOAuth2TokenWithIAMCommand extends command(_ep1, _mw0, "CreateOAuth2TokenWithIAM", CreateOAuth2TokenWithIAM$) {
}
var commands = {
CreateOAuth2TokenCommand,
CreateOAuth2TokenWithIAMCommand
};
class Signin extends SigninClient {
}
createAggregatedClient(commands, Signin);
var OAuth2ErrorCode = {
AUTHCODE_EXPIRED: "AUTHCODE_EXPIRED",
CONFLICT: "CONFLICT",
INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS",
INVALID_REQUEST: "INVALID_REQUEST",
RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
SERVER_ERROR: "server_error",
SERVICE_QUOTA_EXCEEDED: "SERVICE_QUOTA_EXCEEDED",
TOKEN_EXPIRED: "TOKEN_EXPIRED",
USER_CREDENTIALS_CHANGED: "USER_CREDENTIALS_CHANGED"
};
exports.AccessDeniedException = AccessDeniedException;
exports.AccessDeniedException$ = AccessDeniedException$;
exports.AccessToken$ = AccessToken$;
exports.CreateOAuth2Token$ = CreateOAuth2Token$;
exports.CreateOAuth2TokenCommand = CreateOAuth2TokenCommand;
exports.CreateOAuth2TokenRequest$ = CreateOAuth2TokenRequest$;
exports.CreateOAuth2TokenRequestBody$ = CreateOAuth2TokenRequestBody$;
exports.CreateOAuth2TokenResponse$ = CreateOAuth2TokenResponse$;
exports.CreateOAuth2TokenResponseBody$ = CreateOAuth2TokenResponseBody$;
exports.CreateOAuth2TokenWithIAM$ = CreateOAuth2TokenWithIAM$;
exports.CreateOAuth2TokenWithIAMCommand = CreateOAuth2TokenWithIAMCommand;
exports.CreateOAuth2TokenWithIAMRequest$ = CreateOAuth2TokenWithIAMRequest$;
exports.CreateOAuth2TokenWithIAMResponse$ = CreateOAuth2TokenWithIAMResponse$;
exports.InternalServerException = InternalServerException;
exports.InternalServerException$ = InternalServerException$;
exports.OAuth2ErrorCode = OAuth2ErrorCode;
exports.Signin = Signin;
exports.SigninClient = SigninClient;
exports.SigninServiceException = SigninServiceException;
exports.SigninServiceException$ = SigninServiceException$;
exports.TooManyRequestsError = TooManyRequestsError;
exports.TooManyRequestsError$ = TooManyRequestsError$;
exports.ValidationException = ValidationException;
exports.ValidationException$ = ValidationException$;
exports.errorTypeRegistries = errorTypeRegistries;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
import { createHash, createPrivateKey, createPublicKey, sign } from "crypto";
import { promises as fs2 } from "fs";
import { homedir } from "os";
import { dirname as dirname3, join as join3 } from "path";
var import_config20, import_protocols3, LoginCredentialsFetcher;
var init_LoginCredentialsFetcher = __esm(() => {
import_config20 = __toESM(require_config());
import_protocols3 = __toESM(require_protocols());
LoginCredentialsFetcher = class LoginCredentialsFetcher {
profileData;
init;
callerClientConfig;
static REFRESH_THRESHOLD = 5 * 60 * 1000;
constructor(profileData, init, callerClientConfig) {
this.profileData = profileData;
this.init = init;
this.callerClientConfig = callerClientConfig;
}
async loadCredentials() {
const token = await this.loadToken();
if (!token) {
throw new import_config20.CredentialsProviderError(`Failed to load a token for session ${this.loginSession}, please re-authenticate using aws login`, { tryNextLink: false, logger: this.logger });
}
const accessToken = token.accessToken;
const now = Date.now();
const expiryTime = new Date(accessToken.expiresAt).getTime();
const timeUntilExpiry = expiryTime - now;
if (timeUntilExpiry <= LoginCredentialsFetcher.REFRESH_THRESHOLD) {
return this.refresh(token);
}
return this.toCredentials(token.accessToken);
}
get logger() {
return this.init?.logger;
}
get loginSession() {
return this.profileData.login_session;
}
toCredentials(token) {
return {
accessKeyId: token.accessKeyId,
secretAccessKey: token.secretAccessKey,
sessionToken: token.sessionToken,
accountId: token.accountId,
expiration: new Date(token.expiresAt)
};
}
async refresh(token) {
const diskToken = await this.loadToken().catch(() => token);
const now = Date.now();
const diskExpiry = new Date(diskToken.accessToken.expiresAt).getTime();
const tokenExpiry = new Date(token.accessToken.expiresAt).getTime();
const freshToken = diskExpiry <= now && tokenExpiry > now ? token : diskToken;
const freshExpiry = new Date(freshToken.accessToken.expiresAt).getTime();
if (freshExpiry - Date.now() > LoginCredentialsFetcher.REFRESH_THRESHOLD) {
return this.toCredentials(freshToken.accessToken);
}
const { SigninClient, CreateOAuth2TokenCommand } = await Promise.resolve().then(() => __toESM(require_signin()));
const { logger, userAgentAppId } = this.callerClientConfig ?? {};
const isH2 = (requestHandler) => {
return requestHandler?.metadata?.handlerProtocol === "h2";
};
const requestHandler = isH2(this.callerClientConfig?.requestHandler) ? undefined : this.callerClientConfig?.requestHandler;
const region = this.profileData.region ?? await this.callerClientConfig?.region?.() ?? process.env.AWS_REGION;
const client = new SigninClient({
credentials: {
accessKeyId: "",
secretAccessKey: ""
},
region,
requestHandler,
logger,
userAgentAppId,
...this.init?.clientConfig
});
this.createDPoPInterceptor(client.middlewareStack);
const commandInput = {
tokenInput: {
clientId: freshToken.clientId,
refreshToken: freshToken.refreshToken,
grantType: "refresh_token"
}
};
try {
const response = await client.send(new CreateOAuth2TokenCommand(commandInput));
const { accessKeyId, secretAccessKey, sessionToken } = response.tokenOutput?.accessToken ?? {};
const { refreshToken, expiresIn } = response.tokenOutput ?? {};
if (!accessKeyId || !secretAccessKey || !sessionToken || !refreshToken) {
throw new import_config20.CredentialsProviderError("Token refresh response missing required fields", {
logger: this.logger,
tryNextLink: false
});
}
const expiresInMs = (expiresIn ?? 900) * 1000;
const expiration = new Date(Date.now() + expiresInMs);
const updatedToken = {
...freshToken,
accessToken: {
...freshToken.accessToken,
accessKeyId,
secretAccessKey,
sessionToken,
expiresAt: expiration.toISOString()
},
refreshToken
};
await this.saveToken(updatedToken);
return this.toCredentials(updatedToken.accessToken);
} catch (error) {
if (error.name === "AccessDeniedException") {
const errorType = error.error;
let message;
switch (errorType) {
case "TOKEN_EXPIRED":
message = "Your session has expired. Please reauthenticate.";
break;
case "USER_CREDENTIALS_CHANGED":
message = "Unable to refresh credentials because of a change in your password. Please reauthenticate with your new password.";
break;
case "INSUFFICIENT_PERMISSIONS":
message = "Unable to refresh credentials due to insufficient permissions. You may be missing permission for the 'CreateOAuth2Token' action.";
break;
default:
message = `Failed to refresh token: ${String(error)}. Please re-authenticate using \`aws login\``;
}
throw new import_config20.CredentialsProviderError(message, {
logger: this.logger,
tryNextLink: false
});
}
const tokenExpiry = new Date(freshToken.accessToken.expiresAt).getTime();
if (tokenExpiry > Date.now()) {
this.logger?.warn?.(`Failed to refresh token: ${String(error)}. Using existing token until expiry.`);
return this.toCredentials(freshToken.accessToken);
}
throw new import_config20.CredentialsProviderError(`Failed to refresh token: ${String(error)}. Please re-authenticate using aws login`, { logger: this.logger });
}
}
async loadToken() {
const tokenFilePath = this.getTokenFilePath();
try {
const tokenData = await fs2.readFile(tokenFilePath, "utf8");
const token = JSON.parse(tokenData);
const missingFields = ["accessToken", "clientId", "refreshToken", "dpopKey"].filter((k) => !token[k]);
if (!token.accessToken?.accountId) {
missingFields.push("accountId");
}
if (missingFields.length > 0) {
throw new import_config20.CredentialsProviderError(`Token validation failed, missing fields: ${missingFields.join(", ")}`, {
logger: this.logger,
tryNextLink: false
});
}
return token;
} catch (error) {
throw new import_config20.CredentialsProviderError(`Failed to load token from ${tokenFilePath}: ${String(error)}`, {
logger: this.logger,
tryNextLink: false
});
}
}
async saveToken(token) {
const tokenFilePath = this.getTokenFilePath();
const directory = dirname3(tokenFilePath);
try {
await fs2.mkdir(directory, { recursive: true });
} catch (error) {}
await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
}
getTokenFilePath() {
const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join3(homedir(), ".aws", "login", "cache");
const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
const loginSessionSha256 = createHash("sha256").update(loginSessionBytes).digest("hex");
return join3(directory, `${loginSessionSha256}.json`);
}
derToRawSignature(derSignature) {
let offset = 2;
if (derSignature[offset] !== 2) {
throw new Error("Invalid DER signature");
}
offset++;
const rLength = derSignature[offset++];
let r = derSignature.subarray(offset, offset + rLength);
offset += rLength;
if (derSignature[offset] !== 2) {
throw new Error("Invalid DER signature");
}
offset++;
const sLength = derSignature[offset++];
let s = derSignature.subarray(offset, offset + sLength);
r = r[0] === 0 ? r.subarray(1) : r;
s = s[0] === 0 ? s.subarray(1) : s;
const rPadded = Buffer.concat([Buffer.alloc(32 - r.length), r]);
const sPadded = Buffer.concat([Buffer.alloc(32 - s.length), s]);
return Buffer.concat([rPadded, sPadded]);
}
createDPoPInterceptor(middlewareStack) {
middlewareStack.add((next) => async (args) => {
if (import_protocols3.HttpRequest.isInstance(args.request)) {
const request = args.request;
const actualEndpoint = `${request.protocol}//${request.hostname}${request.port ? `:${request.port}` : ""}${request.path}`;
const dpop = await this.generateDpop(request.method, actualEndpoint);
request.headers = {
...request.headers,
DPoP: dpop
};
}
return next(args);
}, {
step: "finalizeRequest",
name: "dpopInterceptor",
override: true
});
}
async generateDpop(method = "POST", endpoint) {
const token = await this.loadToken();
try {
const privateKey = createPrivateKey({
key: token.dpopKey,
format: "pem",
type: "sec1"
});
const publicKey = createPublicKey(privateKey);
const publicDer = publicKey.export({ format: "der", type: "spki" });
let pointStart = -1;
for (let i = 0;i < publicDer.length; i++) {
if (publicDer[i] === 4) {
pointStart = i;
break;
}
}
const x = publicDer.slice(pointStart + 1, pointStart + 33);
const y = publicDer.slice(pointStart + 33, pointStart + 65);
const header = {
alg: "ES256",
typ: "dpop+jwt",
jwk: {
kty: "EC",
crv: "P-256",
x: x.toString("base64url"),
y: y.toString("base64url")
}
};
const payload = {
jti: crypto.randomUUID(),
htm: method,
htu: endpoint,
iat: Math.floor(Date.now() / 1000)
};
const headerB64 = Buffer.from(JSON.stringify(header)).toString("base64url");
const payloadB64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
const message = `${headerB64}.${payloadB64}`;
const asn1Signature = sign("sha256", Buffer.from(message), privateKey);
const rawSignature = this.derToRawSignature(asn1Signature);
const signatureB64 = rawSignature.toString("base64url");
return `${message}.${signatureB64}`;
} catch (error) {
throw new import_config20.CredentialsProviderError(`Failed to generate Dpop proof: ${error instanceof Error ? error.message : String(error)}`, { logger: this.logger, tryNextLink: false });
}
}
};
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/fromLoginCredentials.js
var import_client9, import_config21, fromLoginCredentials = (init) => async ({ callerClientConfig } = {}) => {
init?.logger?.debug?.("@aws-sdk/credential-providers - fromLoginCredentials");
const profiles = await import_config21.parseKnownFiles(init || {});
const profileName = import_config21.getProfileName({
profile: init?.profile ?? callerClientConfig?.profile
});
const profile = profiles[profileName];
if (!profile?.login_session) {
throw new import_config21.CredentialsProviderError(`Profile ${profileName} does not contain login_session.`, {
tryNextLink: true,
logger: init?.logger
});
}
const fetcher = new LoginCredentialsFetcher(profile, init, callerClientConfig);
const credentials = await fetcher.loadCredentials();
return import_client9.setCredentialFeature(credentials, "CREDENTIALS_LOGIN", "AD");
};
var init_fromLoginCredentials = __esm(() => {
init_LoginCredentialsFetcher();
import_client9 = __toESM(require_client2());
import_config21 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/index.js
var init_dist_es6 = __esm(() => {
init_fromLoginCredentials();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveLoginCredentials.js
var import_client10, isLoginProfile = (data) => {
return Boolean(data && data.login_session);
}, resolveLoginCredentials = async (profileName, options, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es6());
const credentials = await fromLoginCredentials({
...options,
profile: profileName
})({ callerClientConfig });
return import_client10.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_LOGIN", "AC");
};
var init_resolveLoginCredentials = __esm(() => {
import_client10 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js
var import_client11, getValidatedProcessCredentials = (profileName, data, profiles) => {
if (data.Version !== 1) {
throw Error(`Profile ${profileName} credential_process did not return Version 1.`);
}
if (data.AccessKeyId === undefined || data.SecretAccessKey === undefined) {
throw Error(`Profile ${profileName} credential_process returned invalid credentials.`);
}
if (data.Expiration) {
const currentTime = new Date;
const expireTime = new Date(data.Expiration);
if (expireTime < currentTime) {
throw Error(`Profile ${profileName} credential_process returned expired credentials.`);
}
}
let accountId = data.AccountId;
if (!accountId && profiles?.[profileName]?.aws_account_id) {
accountId = profiles[profileName].aws_account_id;
}
const credentials = {
accessKeyId: data.AccessKeyId,
secretAccessKey: data.SecretAccessKey,
...data.SessionToken && { sessionToken: data.SessionToken },
...data.Expiration && { expiration: new Date(data.Expiration) },
...data.CredentialScope && { credentialScope: data.CredentialScope },
...accountId && { accountId }
};
import_client11.setCredentialFeature(credentials, "CREDENTIALS_PROCESS", "w");
return credentials;
};
var init_getValidatedProcessCredentials = __esm(() => {
import_client11 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
import { exec } from "child_process";
import { promisify } from "util";
var import_config22, resolveProcessCredentials = async (profileName, profiles, logger) => {
const profile = profiles[profileName];
if (profiles[profileName]) {
const credentialProcess = profile["credential_process"];
if (credentialProcess !== undefined) {
const execPromise = promisify(import_config22.externalDataInterceptor?.getTokenRecord?.().exec ?? exec);
try {
const { stdout } = await execPromise(credentialProcess);
let data;
try {
data = JSON.parse(stdout.trim());
} catch {
throw Error(`Profile ${profileName} credential_process returned invalid JSON.`);
}
return getValidatedProcessCredentials(profileName, data, profiles);
} catch (error) {
throw new import_config22.CredentialsProviderError(error.message, { logger });
}
} else {
throw new import_config22.CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger });
}
} else {
throw new import_config22.CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`, {
logger
});
}
};
var init_resolveProcessCredentials = __esm(() => {
init_getValidatedProcessCredentials();
import_config22 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js
var import_config23, fromProcess = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-process - fromProcess");
const profiles = await import_config23.parseKnownFiles(init);
return resolveProcessCredentials(import_config23.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init.logger);
};
var init_fromProcess = __esm(() => {
init_resolveProcessCredentials();
import_config23 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/index.js
var init_dist_es7 = __esm(() => {
init_fromProcess();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js
var import_client12, isProcessProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string", resolveProcessCredentials2 = async (options, profile) => {
await Promise.resolve().then(() => init_dist_es7());
const credentials = await fromProcess({
...options,
profile
})();
return import_client12.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_PROCESS", "v");
};
var init_resolveProcessCredentials2 = __esm(() => {
import_client12 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js
var import_client13, resolveSsoCredentials = async (profile, profileData, options = {}, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es5());
return fromSSO({
profile,
logger: options.logger,
parentClientConfig: options.parentClientConfig,
clientConfig: options.clientConfig
})({
callerClientConfig
}).then((creds) => {
if (profileData.sso_session) {
return import_client13.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
} else {
return import_client13.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t");
}
});
}, isSsoProfile3 = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
var init_resolveSsoCredentials = __esm(() => {
import_client13 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js
var import_client14, isStaticCredsProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.aws_access_key_id === "string" && typeof arg.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1, resolveStaticCredentials = async (profile, options) => {
options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
const credentials = {
accessKeyId: profile.aws_access_key_id,
secretAccessKey: profile.aws_secret_access_key,
sessionToken: profile.aws_session_token,
...profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope },
...profile.aws_account_id && { accountId: profile.aws_account_id }
};
return import_client14.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n");
};
var init_resolveStaticCredentials = __esm(() => {
import_client14 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
var fromWebToken = (init) => async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
let { roleAssumerWithWebIdentity } = init;
if (!roleAssumerWithWebIdentity) {
const { getDefaultRoleAssumerWithWebIdentity } = await Promise.resolve().then(() => __toESM(require_sts()));
roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
...init.clientConfig,
credentialProviderLogger: init.logger,
parentClientConfig: {
...awsIdentityProperties?.callerClientConfig,
...init.parentClientConfig
}
}, init.clientPlugins);
}
return roleAssumerWithWebIdentity({
RoleArn: roleArn,
RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
WebIdentityToken: webIdentityToken,
ProviderId: providerId,
PolicyArns: policyArns,
Policy: policy,
DurationSeconds: durationSeconds
});
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
import { readFileSync as readFileSync4 } from "fs";
var import_client15, import_config24, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
if (!webIdentityTokenFile || !roleArn) {
throw new import_config24.CredentialsProviderError("Web identity configuration not specified", {
logger: init.logger
});
}
const credentials = await fromWebToken({
...init,
webIdentityToken: import_config24.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync4(webIdentityTokenFile, { encoding: "ascii" }),
roleArn,
roleSessionName
})(awsIdentityProperties);
if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
import_client15.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
}
return credentials;
};
var init_fromTokenFile = __esm(() => {
import_client15 = __toESM(require_client2());
import_config24 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js
var init_dist_es8 = __esm(() => {
init_fromTokenFile();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js
var import_client16, isWebIdentityProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.web_identity_token_file === "string" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1, resolveWebIdentityCredentials = async (profile, options, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es8());
const credentials = await fromTokenFile({
webIdentityTokenFile: profile.web_identity_token_file,
roleArn: profile.role_arn,
roleSessionName: profile.role_session_name,
roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
logger: options.logger,
parentClientConfig: options.parentClientConfig
})({
callerClientConfig
});
return import_client16.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q");
};
var init_resolveWebIdentityCredentials = __esm(() => {
import_client16 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var import_config25, resolveProfileData = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => {
const data = profiles[profileName];
if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile(data)) {
return resolveStaticCredentials(data, options);
}
if (isAssumeRoleRecursiveCall || isAssumeRoleProfile(data, { profile: profileName, logger: options.logger })) {
return resolveAssumeRoleCredentials(profileName, profiles, options, callerClientConfig, visitedProfiles, resolveProfileData);
}
if (isStaticCredsProfile(data)) {
return resolveStaticCredentials(data, options);
}
if (isWebIdentityProfile(data)) {
return resolveWebIdentityCredentials(data, options, callerClientConfig);
}
if (isProcessProfile(data)) {
return resolveProcessCredentials2(options, profileName);
}
if (isSsoProfile3(data)) {
return await resolveSsoCredentials(profileName, data, options, callerClientConfig);
}
if (isLoginProfile(data)) {
return resolveLoginCredentials(profileName, options, callerClientConfig);
}
throw new import_config25.CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger });
};
var init_resolveProfileData = __esm(() => {
init_resolveAssumeRoleCredentials();
init_resolveLoginCredentials();
init_resolveProcessCredentials2();
init_resolveSsoCredentials();
init_resolveStaticCredentials();
init_resolveWebIdentityCredentials();
import_config25 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var import_config26, fromIni = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
const profiles = await import_config26.parseKnownFiles(init);
return resolveProfileData(import_config26.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init, callerClientConfig);
};
var init_fromIni = __esm(() => {
init_resolveProfileData();
import_config26 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/index.js
var init_dist_es9 = __esm(() => {
init_fromIni();
});
// ../contracts/dist/client/transport.js
import { isIP } from "net";
import { spawnSync } from "child_process";
import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
import { hostname as osHostname } from "os";
import { isAbsolute, join as join2 } from "path";
import { createRequire } from "module";
import { fileURLToPath as fileURLToPath2 } from "url";
import { closeSync, fstatSync, lstatSync, openSync, readFileSync, realpathSync, statSync } from "fs";
import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
import { basename, dirname, join, relative, sep } from "path";
import { fileURLToPath, pathToFileURL } from "url";
function envToken(name) {
return name.toUpperCase().replace(/-/g, "_");
}
function clientTransportEnvKeys(name) {
const envSegment = envToken(name);
return {
apiUrlKeys: [`HASNA_${envSegment}_API_URL`, `${envSegment}_API_URL`],
apiKeyKeys: [`HASNA_${envSegment}_API_KEY`, `${envSegment}_API_KEY`]
};
}
function credentialOverrideEnvKey(name) {
return `HASNA_${envToken(name)}_API_KEY_OVERRIDE`;
}
var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE";
function credentialPointerEnvKey(name) {
return `HASNA_${envToken(name)}_API_KEY_REF`;
}
function e(e2, n, r) {
throw new Error(r ? `No known conditions for "${n}" specifier in "${e2}" package` : `Missing "${n}" specifier in "${e2}" package`);
}
function n(n2, i, o, f) {
let s, u, l = r(n2, o), c = function(e2) {
let n3 = new Set(["default", ...e2.conditions || []]);
return e2.unsafe || n3.add(e2.require ? "require" : "import"), e2.unsafe || n3.add(e2.browser ? "browser" : "node"), n3;
}(f || {}), a = i[l];
if (a === undefined) {
let e2, n3, r, t;
for (t in i)
n3 && t.length < n3.length || (t[t.length - 1] === "/" && l.startsWith(t) ? (u = l.substring(t.length), n3 = t) : t.length > 1 && (r = t.indexOf("*", 1), ~r && (e2 = RegExp("^" + t.substring(0, r) + "(.*)" + t.substring(1 + r) + "$").exec(l), e2 && e2[1] && (u = e2[1], n3 = t))));
a = i[n3];
}
return a || e(n2, l), s = t(a, c), s || e(n2, l, 1), u && function(e2, n3) {
let r, t = 0, i2 = e2.length, o2 = /[*]/g, f2 = /[/]$/;
for (;t < i2; t++)
e2[t] = o2.test(r = e2[t]) ? r.replace(o2, n3) : f2.test(r) ? r + n3 : r;
}(s, u), s;
}
function r(e2, n2, r2) {
if (e2 === n2 || n2 === ".")
return ".";
let t = e2 + "/", i = t.length, o = n2.slice(0, i) === t, f = o ? n2.slice(i) : n2;
return f[0] === "#" ? f : o || !r2 ? f.slice(0, 2) === "./" ? f : "./" + f : f;
}
function t(e2, n2, r2) {
if (e2) {
if (typeof e2 == "string")
return r2 && r2.add(e2), [e2];
let i, o;
if (Array.isArray(e2)) {
for (o = r2 || new Set, i = 0;i < e2.length; i++)
t(e2[i], n2, o);
if (!r2 && o.size)
return [...o];
} else
for (i in e2)
if (n2.has(i))
return t(e2[i], n2, r2);
}
}
function o(e2, r2, t2) {
let i, o2 = e2.exports;
if (o2) {
if (typeof o2 == "string")
o2 = { ".": o2 };
else
for (i in o2) {
i[0] !== "." && (o2 = { ".": o2 });
break;
}
return n(e2.name, o2, r2 || ".", t2);
}
}
var PACKAGE = "@hasna/secrets";
var MAX_PACKAGE_BYTES = 1024 * 1024;
function entryPoint(directory) {
const root = realpathSync(directory);
const fd = openSync(join(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
let pkg;
try {
const stat = fstatSync(fd);
if (!stat.isFile() || stat.size > MAX_PACKAGE_BYTES)
throw new Error("Invalid Secrets package metadata");
pkg = JSON.parse(readFileSync(fd, "utf8"));
} finally {
closeSync(fd);
}
if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== PACKAGE) {
throw new Error("Invalid Secrets package identity");
}
const target = o(pkg, ".")?.[0];
if (typeof target !== "string" || !target.startsWith("./"))
throw new Error("Missing Secrets import export");
const parts = target.slice(2).split("/");
if (/[\\%?#\0]/.test(target) || parts.some((part) => !part || part === "." || part === ".." || part === "node_modules")) {
throw new Error("Invalid Secrets import export");
}
const file = realpathSync(join(root, ...parts));
const within = relative(root, file);
if (!within || within === ".." || within.startsWith(`..${sep}`) || !statSync(file).isFile()) {
throw new Error("Secrets import export escapes its package or is not a file");
}
return pathToFileURL(file).href;
}
function resolveInstalledSecrets(parentUrl) {
let directory = dirname(fileURLToPath(parentUrl));
for (;; ) {
if (basename(directory) !== "node_modules") {
const candidate = join(directory, "node_modules", PACKAGE);
let absent = false;
try {
lstatSync(candidate);
} catch (error) {
if (error.code !== "ENOENT")
throw error;
absent = true;
}
if (!absent)
return entryPoint(candidate);
}
const parent = dirname(directory);
if (parent === directory)
throw new Error("Secrets SDK is not installed for this consumer");
directory = parent;
}
}
class CredentialResolutionError extends Error {
appName;
attempted;
constructor(appName, message, attempted) {
super(message);
this.name = "CredentialResolutionError";
this.appName = appName;
this.attempted = attempted;
}
}
class CredentialFileUnsafeError extends Error {
path;
constructor(path, reason) {
super(`Refusing unsafe credential/config file ${path}: ${reason}.`);
this.name = "CredentialFileUnsafeError";
this.path = path;
}
}
var HASNA_HOME_ENV_KEY = "HASNA_HOME";
var HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME";
var KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION";
var HASNA_HOME_DIR = ".hasna";
var CONFIG_SUBDIR = "config";
var CREDENTIALS_FILE = "credentials";
var KEYCHAIN_SECURITY_BIN = "/usr/bin/security";
var KEYCHAIN_SERVICE_PREFIX = "hasna.credentials";
var KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44;
var KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4;
var MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
var SAFE_APP_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
var SAFE_PROFILE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
var ILLEGAL_IN_HEADER_VALUE = /[^\t\x20-\x7e]/;
var VAULT_POINTER_SHAPE = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-_.]*){2,}$/;
function homeDir(env) {
const home = env.HOME?.trim();
return home ? home : null;
}
function absoluteOverride(env, key) {
const value = env[key]?.trim();
return value && isAbsolute(value) ? value : null;
}
function hasnaHomeDir(env) {
const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
if (override)
return override;
const home = homeDir(env);
return home ? join2(home, HASNA_HOME_DIR) : null;
}
function appConfigDir(name, env) {
const configRoot = absoluteOverride(env, HASNA_CONFIG_HOME_ENV_KEY);
if (configRoot)
return join2(configRoot, name);
const root = hasnaHomeDir(env);
return root ? join2(root, name, CONFIG_SUBDIR) : null;
}
function credentialDiskSourceList(name, env, profile = null) {
if (!SAFE_APP_SLUG.test(name))
return [];
const directory = appConfigDir(name, env);
if (!directory)
return [];
const file = profile ? `${CREDENTIALS_FILE}-${profile}` : CREDENTIALS_FILE;
return [{ path: join2(directory, file), tier: "disk" }];
}
function credentialDiskSources(name, env) {
return credentialDiskSourceList(name, env, null).map((s) => s.path);
}
function profileDiskSources(name, env, profile) {
return credentialDiskSourceList(name, env, profile).map((s) => s.path);
}
function parseEnvFile(text) {
const values = new Map;
const unusable = new Set;
for (const rawLine of text.split(/\r?\n/)) {
const line = rawLine.trim();
if (line.length === 0 || line.startsWith("#"))
continue;
const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
const equals = withoutExport.indexOf("=");
if (equals <= 0)
continue;
const key = withoutExport.slice(0, equals).trim();
if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
continue;
let value = withoutExport.slice(equals + 1).trim();
const quote = value[0];
if (quote === '"' || quote === "'") {
if (value.length < 2 || !value.endsWith(quote)) {
unusable.add(key);
continue;
}
value = value.slice(1, -1);
}
if (value.trim().length === 0) {
unusable.add(key);
continue;
}
if (values.has(key) && values.get(key) !== value)
unusable.add(key);
values.set(key, value);
}
return { values, unusable };
}
function configFileModeAllowed(mode) {
const permissions = mode & 4095;
return permissions === 256 || permissions === 384;
}
function configFileReadsCoherent(before, after) {
return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
}
function readAppConfigFile(path) {
const unsafe = (reason) => {
throw new CredentialFileUnsafeError(path, reason);
};
let fd = -1;
try {
fd = openSync2(path, O_RDONLY2 | O_NOFOLLOW2 | O_NONBLOCK2);
} catch (error) {
const code = error.code;
if (code === "ENOENT" || code === "ENOTDIR")
return null;
if (code === "ELOOP")
unsafe("the path is a symlink");
unsafe(`the path could not be opened (${code ?? "unknown error"})`);
}
try {
const before = fstatSync2(fd);
if (!before.isFile())
unsafe("the path is not a regular file");
if (!configFileModeAllowed(before.mode)) {
unsafe(`permission mode ${(before.mode & 4095).toString(8).padStart(4, "0")} is not owner-only 0400 or 0600`);
}
const uid = process.getuid?.() ?? process.geteuid?.();
if (uid !== undefined && before.uid !== uid)
unsafe("the file is not owned by the current user");
if (before.size > MAX_CREDENTIAL_FILE_BYTES)
unsafe("the file exceeds the size limit");
const bytes = readFileSync2(fd);
const after = fstatSync2(fd);
if (!configFileReadsCoherent(before, after)) {
unsafe("the file changed while being read");
}
return parseEnvFile(bytes.toString("utf8"));
} finally {
if (fd !== -1)
closeSync2(fd);
}
}
function readCredentialFile(path, apiKeyKeys, pointerKey) {
const parsed = readAppConfigFile(path);
if (!parsed)
return null;
for (const key of [...apiKeyKeys, pointerKey]) {
if (parsed.unusable.has(key)) {
throw new CredentialFileUnsafeError(path, `${key} is declared but blank or malformed`);
}
}
const values = apiKeyKeys.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
const pointer = parsed.values.get(pointerKey)?.trim();
if (pointer !== undefined) {
if (!VAULT_POINTER_SHAPE.test(pointer))
throw new CredentialFileUnsafeError(path, `${pointerKey} must name a vault item`);
if (values.length)
throw new CredentialFileUnsafeError(path, "a credential file cannot select both a literal key and a vault reference");
return { apiKey: "", pointerVaultKey: pointer };
}
if (new Set(values).size > 1) {
throw new CredentialFileUnsafeError(path, "credential aliases disagree");
}
return values[0] === undefined ? null : { apiKey: values[0] };
}
var CREDENTIAL_SHAPED_KEY = /(?:^|_)(?:API_KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH)(?:_|$)/;
function appConfigDiskValue(name, env, keys, profile = null) {
if (profile !== null && !SAFE_PROFILE.test(profile)) {
throw new CredentialResolutionError(name, "The selected configuration profile is invalid.", ["profile"]);
}
const wanted = keys.filter((key) => !CREDENTIAL_SHAPED_KEY.test(key));
if (wanted.length === 0)
return null;
for (const path of profileDiskSources(name, env, profile)) {
const parsed = readAppConfigFile(path);
if (!parsed)
continue;
if (wanted.some((key) => parsed.unusable.has(key))) {
return { key: wanted.find((key) => parsed.unusable.has(key)), value: "", path, unusable: true };
}
const values = wanted.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
if (new Set(values).size > 1)
throw new CredentialFileUnsafeError(path, "configuration aliases disagree");
for (const key of wanted) {
if (parsed.unusable.has(key))
return { key, value: "", path, unusable: true };
const value = parsed.values.get(key)?.trim();
if (value)
return { key, value, path };
}
}
return null;
}
function assertUsableCredential(appName, source, value) {
if (VAULT_POINTER_SHAPE.test(value)) {
throw new CredentialResolutionError(appName, `The credential from ${source} looks like a secrets-vault pointer (a path-shaped reference like ` + `'namespace/app/live/api_key'). A vault path is NEVER accepted as a literal API key. ` + `Use ${credentialPointerEnvKey(appName)} to resolve the key through the vault, or provide the actual key value.`, [source]);
}
if (!ILLEGAL_IN_HEADER_VALUE.test(value))
return;
throw new CredentialResolutionError(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
}
var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
var CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
var CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider";
function sealCredential(fields) {
const { apiKey } = fields;
const visible = {
tier: fields.tier,
source: fields.source,
deliberate: fields.deliberate,
diskCandidates: Object.freeze([...fields.diskCandidates]),
warning: fields.warning
};
const sealed = { ...visible };
Object.defineProperty(sealed, "apiKey", {
value: apiKey,
enumerable: false,
writable: false,
configurable: false
});
if (fields.pointerVaultKey !== undefined) {
Object.defineProperty(sealed, "pointerVaultKey", {
value: fields.pointerVaultKey,
enumerable: false,
writable: false,
configurable: false
});
}
Object.defineProperty(sealed, INSPECT_CUSTOM, {
value: () => ({ ...visible, apiKey: "[redacted]" }),
enumerable: false,
writable: false,
configurable: false
});
Object.defineProperty(sealed, CREDENTIAL_SEAL, {
value: true,
enumerable: false,
writable: false,
configurable: false
});
return Object.freeze(sealed);
}
function isSealedCredential(credential) {
return credential[CREDENTIAL_SEAL] === true;
}
function explicitCredential(appName, apiKey) {
const source = "explicit apiKey option";
assertUsableCredential(appName, source, apiKey);
return sealCredential({
apiKey,
tier: "argument",
source,
deliberate: true,
diskCandidates: [],
warning: null
});
}
function validateAndSealResolvedCredential(appName, credential) {
const apiKey = credential.apiKey;
assertUsableCredential(appName, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE, apiKey);
if (!isSealedCredential(credential)) {
return sealCredential({
apiKey,
tier: "argument",
source: CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE,
deliberate: true,
diskCandidates: [],
warning: null
});
}
return sealCredential({
apiKey,
tier: credential.tier,
source: credential.source,
deliberate: credential.deliberate,
diskCandidates: credential.diskCandidates,
warning: credential.warning,
...credential.pointerVaultKey !== undefined ? { pointerVaultKey: credential.pointerVaultKey } : {}
});
}
function firstEnvValue(env, keys) {
for (const key of keys) {
if (!Object.prototype.hasOwnProperty.call(env, key))
continue;
const value = env[key]?.trim();
if (value)
return { key, value };
}
return null;
}
var AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
function isAmbientEnvironment(env) {
return env === process.env || env[AMBIENT_ENVIRONMENT] === true;
}
function defaultKeychainRunner(argv) {
const result = spawnSync(KEYCHAIN_SECURITY_BIN, [...argv], {
encoding: "utf8",
stdio: ["ignore", "pipe", "pipe"],
timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
});
return {
status: result.status,
stdout: result.stdout ?? "",
stderr: result.error ? result.error.message : result.stderr ?? ""
};
}
function keychainTierEnabled(env, options) {
if ((options.platform ?? process.platform) !== "darwin")
return false;
if (options.enabled !== undefined)
return options.enabled;
return options.run !== undefined || isAmbientEnvironment(env);
}
function keychainAccount(env, options) {
const station = env[KEYCHAIN_STATION_ENV_KEY]?.trim();
if (station)
return station;
const host = (options.hostname ?? osHostname)().split(".")[0]?.trim() ?? "";
if (host)
return host;
const user = env.USER?.trim();
return user || null;
}
function keychainFailureHint(text) {
const line = text.split(/\r?\n/).find((entry) => entry.trim().length > 0)?.trim() ?? "";
const clean = line.replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 200);
return clean ? `: ${clean}` : "";
}
function readKeychainItem(name, env, kind, options) {
if (!SAFE_APP_SLUG.test(name) || !keychainTierEnabled(env, options))
return null;
const account = keychainAccount(env, options);
if (!account)
return null;
const service = `${KEYCHAIN_SERVICE_PREFIX}.${name}.${kind}`;
const source = `keychain:${service}@${account}`;
const run = options.run ?? defaultKeychainRunner;
let result;
try {
result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
} catch (error) {
const reason = keychainFailureHint(error instanceof Error ? error.message : String(error));
throw new CredentialResolutionError(name, `The Keychain lookup for ${source} could not run${reason}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
}
if (result.status === KEYCHAIN_ITEM_NOT_FOUND_STATUS)
return null;
if (result.status !== 0) {
throw new CredentialResolutionError(name, `The Keychain lookup for ${source} failed (security exited ` + `${result.status ?? "without a status"}${keychainFailureHint(result.stderr)}). A Keychain item that ` + `exists but cannot be read is never resolved around: unlock the keychain, run from a session that ` + `may use it, or delete the item to fall through to the credential on disk.`, [source]);
}
const value = result.stdout.trim();
if (!value) {
throw new CredentialResolutionError(name, `${source} exists but holds an empty value; a declared item never falls through to another ` + `identity. Store a value in it or delete the item.`, [source]);
}
return { value, source };
}
function keychainConfigValue(name, env, options = {}) {
return readKeychainItem(name, env, "api-url", options);
}
function snapshotClientEnvironment(name, env) {
const keys = clientTransportEnvKeys(name);
const ambient = isAmbientEnvironment(env);
const snapshot = Object.create(null);
for (const key of [
...keys.apiUrlKeys,
...keys.apiKeyKeys,
credentialOverrideEnvKey(name),
credentialPointerEnvKey(name),
CREDENTIAL_PROFILE_ENV_KEY,
"HOME",
HASNA_HOME_ENV_KEY,
HASNA_CONFIG_HOME_ENV_KEY,
KEYCHAIN_STATION_ENV_KEY,
"USER"
]) {
const descriptor = Object.getOwnPropertyDescriptor(env, key);
if (!descriptor)
continue;
if (!("value" in descriptor)) {
throw new CredentialResolutionError(name, `${key} is accessor-backed; client configuration requires own data properties.`, [key]);
}
if (descriptor.value !== undefined && typeof descriptor.value !== "string") {
throw new CredentialResolutionError(name, `${key} must be a string data property.`, [key]);
}
snapshot[key] = descriptor.value;
}
if (ambient) {
Object.defineProperty(snapshot, AMBIENT_ENVIRONMENT, {
value: true,
enumerable: false,
writable: false,
configurable: false
});
}
return Object.freeze(snapshot);
}
function resolveCredential(name, env, options = {}) {
env = snapshotClientEnvironment(name, env);
const { apiKeyKeys } = clientTransportEnvKeys(name);
const diskPaths = credentialDiskSources(name, env);
if (options.apiKey !== undefined) {
const explicitKey = options.apiKey.trim();
if (!explicitKey) {
throw new CredentialResolutionError(name, "The explicit apiKey argument is blank; an explicit credential never falls through to another identity.", ["explicit apiKey argument"]);
}
assertUsableCredential(name, "the explicit apiKey argument", explicitKey);
return sealCredential({
apiKey: explicitKey,
tier: "argument",
source: "explicit apiKey argument",
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
const overrideKeyName = credentialOverrideEnvKey(name);
const overrideRaw = Object.prototype.hasOwnProperty.call(env, overrideKeyName) ? env[overrideKeyName] : undefined;
if (overrideRaw !== undefined) {
const override = overrideRaw.trim();
if (!override) {
throw new CredentialResolutionError(name, `${overrideKeyName} is set but empty. It is a deliberate override, so it is not resolved around: ` + `either give it a real key or unset it to fall back to the credential on disk.`, [overrideKeyName]);
}
assertUsableCredential(name, overrideKeyName, override);
return sealCredential({
apiKey: override,
tier: "override",
source: overrideKeyName,
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
const pointerKeyName = credentialPointerEnvKey(name);
const pointerRaw = Object.prototype.hasOwnProperty.call(env, pointerKeyName) ? env[pointerKeyName] : undefined;
if (pointerRaw !== undefined) {
const pointer = pointerRaw.trim();
if (!pointer) {
throw new CredentialResolutionError(name, `${pointerKeyName} is set but empty. It is a deliberate vault pointer, so it is not resolved around: ` + `either give it a vault item key or unset it to fall back to the credential on disk.`, [pointerKeyName]);
}
if (!VAULT_POINTER_SHAPE.test(pointer)) {
throw new CredentialResolutionError(name, `${pointerKeyName} must name a vault ITEM KEY (a path-shaped reference like ` + `'namespace/app/live/api_key'), not a credential value. A pointer that carries a literal is refused.`, [pointerKeyName]);
}
return sealCredential({
apiKey: "",
pointerVaultKey: pointer,
tier: "pointer",
source: pointerKeyName,
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
if (options.profile !== undefined && !options.profile.trim()) {
throw new CredentialResolutionError(name, "The explicit profile argument is blank; an explicit identity selection never falls through.", ["explicit profile argument"]);
}
const profileRaw = Object.prototype.hasOwnProperty.call(env, CREDENTIAL_PROFILE_ENV_KEY) ? env[CREDENTIAL_PROFILE_ENV_KEY] : undefined;
if (profileRaw !== undefined && !profileRaw.trim()) {
throw new CredentialResolutionError(name, `${CREDENTIAL_PROFILE_ENV_KEY} is set but blank.`, [CREDENTIAL_PROFILE_ENV_KEY]);
}
const profile = options.profile?.trim() || profileRaw?.trim();
if (profile) {
const profileSource = options.profile?.trim() ? "explicit profile argument" : CREDENTIAL_PROFILE_ENV_KEY;
if (!SAFE_PROFILE.test(profile)) {
throw new CredentialResolutionError(name, `Profile name from ${profileSource} is not usable in a path. ` + `Use letters, digits, dot, dash, or underscore.`, [profileSource]);
}
const paths = profileDiskSources(name, env, profile);
for (const path of paths) {
const value = readCredentialFile(path, apiKeyKeys, pointerKeyName);
if (value) {
if (!value.pointerVaultKey)
assertUsableCredential(name, path, value.apiKey);
return sealCredential({
...value,
tier: value.pointerVaultKey ? "pointer" : "profile",
source: path,
deliberate: true,
diskCandidates: paths,
warning: null
});
}
}
throw new CredentialResolutionError(name, `Profile '${profile}' (from ${profileSource}) has no ${apiKeyKeys[0]} or ${pointerKeyName} for '${name}'. ` + `Looked in: ${paths.join(", ") || "<no HOME in this environment>"}. ` + `A profile names WHICH identity to use, so it is never resolved around \u2014 ` + `create the profile's credential file or unset ${CREDENTIAL_PROFILE_ENV_KEY}.`, paths);
}
const definedEnvEntries = apiKeyKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, value: String(env[key]).trim() }));
const blankEnv = definedEnvEntries.find((entry) => entry.value.length === 0);
if (blankEnv) {
throw new CredentialResolutionError(name, `${blankEnv.key} is set but blank; a declared credential never falls through to another alias or identity.`, [blankEnv.key]);
}
if (definedEnvEntries.length > 1 && new Set(definedEnvEntries.map((entry) => entry.value)).size > 1) {
throw new CredentialResolutionError(name, `${definedEnvEntries.map((entry) => entry.key).join(" and ")} disagree; credential aliases must be identical or only one may be set.`, definedEnvEntries.map((entry) => entry.key));
}
const envHit = firstEnvValue(env, apiKeyKeys);
const keychainHit = readKeychainItem(name, env, "api-key", options.keychain ?? {});
if (keychainHit) {
assertUsableCredential(name, keychainHit.source, keychainHit.value);
const warning = envHit && envHit.value !== keychainHit.value ? `Credential sources disagree for '${name}': ${keychainHit.source} and ${envHit.key} hold ` + `different keys. ${keychainHit.source} wins, because the Keychain is re-read on every call while ` + `an environment variable is a snapshot. Reconcile them \u2014 a rotation that updated only one leaves ` + `the other to fail 401 wherever it is loaded first.` : null;
return sealCredential({
apiKey: keychainHit.value,
tier: "keychain",
source: keychainHit.source,
deliberate: false,
diskCandidates: diskPaths,
warning
});
}
const diskSourceList = credentialDiskSourceList(name, env, null);
const diskHits = diskSourceList.map((src) => ({ src, value: readCredentialFile(src.path, apiKeyKeys, pointerKeyName) })).filter((hit) => hit.value !== null);
if (diskHits.length > 0) {
const winner = diskHits[0];
if (winner.value.pointerVaultKey) {
return sealCredential({
...winner.value,
tier: "pointer",
source: winner.src.path,
deliberate: false,
diskCandidates: diskPaths,
warning: null
});
}
assertUsableCredential(name, winner.src.path, winner.value.apiKey);
const divergentSources = [
...diskHits.slice(1).filter((hit) => hit.value.apiKey !== winner.value.apiKey || hit.value.pointerVaultKey !== winner.value.pointerVaultKey).map((hit) => hit.src.path),
...envHit && envHit.value !== winner.value.apiKey ? [envHit.key] : []
];
const warning = divergentSources.length > 0 ? `Credential sources disagree for '${name}': ${winner.src.path} and ` + `${divergentSources.join(", ")} hold different keys. ${winner.src.path} wins, because a file on ` + `disk is re-read on every call while an environment variable is a snapshot. Reconcile them \u2014 ` + `a rotation that updated only one leaves the other to fail 401 wherever it is loaded first.` : null;
return sealCredential({
apiKey: winner.value.apiKey,
tier: winner.src.tier,
source: winner.src.path,
deliberate: false,
diskCandidates: diskPaths,
warning
});
}
if (envHit) {
assertUsableCredential(name, envHit.key, envHit.value);
return sealCredential({
apiKey: envHit.value,
tier: "env",
source: envHit.key,
deliberate: false,
diskCandidates: diskPaths,
warning: null
});
}
return null;
}
var requireSecretsSdk = createRequire(import.meta.url);
async function completePointerCredential(name, pointerResolution, env = process.env) {
const secretsEnv = snapshotClientEnvironment("secrets", env);
const vaultKey = pointerResolution.pointerVaultKey;
const pointerEnvKey = pointerResolution.source;
if (!vaultKey) {
throw new CredentialResolutionError(name, `Pointer resolution from ${pointerEnvKey} carries no vault item key; this is a defect in the resolver.`, [pointerEnvKey]);
}
if (name === "secrets") {
throw new CredentialResolutionError(name, "The Secrets bootstrap credential cannot reference the same hosted vault; configure an independent bootstrap provider.", [pointerEnvKey]);
}
let secretsSdk;
try {
const sdkUrl = resolveInstalledSecrets(import.meta.url);
secretsSdk = requireSecretsSdk(fileURLToPath2(sdkUrl));
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the secrets SDK (@hasna/secrets) is not installed ` + `in this process. A vault pointer is TERMINAL: install @hasna/secrets to resolve it, or unset ${pointerEnvKey}.`, [pointerEnvKey]);
}
let client;
try {
const bootstrap = resolveCredential("secrets", secretsEnv);
if (!bootstrap || bootstrap.tier === "pointer") {
throw new CredentialResolutionError("secrets", "The Secrets vault requires an independent, non-reference bootstrap credential.", bootstrap ? [bootstrap.source] : []);
}
client = secretsSdk.createSecretsClientFromEnv(secretsEnv);
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the secrets client could not be configured from this ` + `environment (the secrets service URL and key env are missing or invalid). A vault pointer is TERMINAL and ` + `never falls through to a literal or disk credential.`, [pointerEnvKey]);
}
let secret;
try {
secret = await client.getSecret({ key: vaultKey });
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the vault could not be reached or the item is ` + `unavailable. A vault pointer is TERMINAL and never falls through to a literal or disk credential.`, [pointerEnvKey]);
}
const value = secret.value;
if (!value) {
throw new CredentialResolutionError(name, `${pointerEnvKey} resolved vault item '${vaultKey}', but it holds no value. A vault pointer is TERMINAL.`, [pointerEnvKey]);
}
assertUsableCredential(name, `${pointerEnvKey} -> vault:${vaultKey}`, value);
return sealCredential({
apiKey: value,
tier: "pointer",
source: `${pointerEnvKey} -> vault:${vaultKey}`,
deliberate: pointerResolution.deliberate,
diskCandidates: pointerResolution.diskCandidates,
warning: null
});
}
var DEFAULT_FLEET_GATEWAY_ORIGIN = "https://api.hasna.com";
var DEFAULT_AUTHORITY_SOURCE = "default";
function defaultFleetGatewayBaseUrl(name) {
return `${DEFAULT_FLEET_GATEWAY_ORIGIN}/${validateAppSlug(name)}`;
}
var ASCII_CONTROL_PATTERN = /[\u0000-\u001f\u007f]/;
var DNS_LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
function isValidDnsDomain(value) {
if (value.length === 0 || value.length > 253 || ASCII_CONTROL_PATTERN.test(value) || /[^\x00-\x7f]/.test(value)) {
return false;
}
return value.split(".").every((label) => label.length <= 63 && !label.startsWith("xn--") && DNS_LABEL_PATTERN.test(label));
}
function validateAppSlug(name) {
if (name.length > 63 || !DNS_LABEL_PATTERN.test(name)) {
throw new Error("App name must be one lowercase DNS label.");
}
return name;
}
function rawAuthority(value) {
const match = /^[a-z][a-z0-9+.-]*:\/\//i.exec(value);
if (!match)
throw new Error("API URL must be absolute.");
const afterScheme = value.slice(match[0].length);
const boundary = afterScheme.search(/[/?#]/);
const authority = boundary === -1 ? afterScheme : afterScheme.slice(0, boundary);
if (!authority)
throw new Error("API URL must include a hostname.");
return authority;
}
function assertCanonicalPort(port) {
if (!/^[0-9]+$/.test(port) || port.length > 1 && port.startsWith("0")) {
throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
}
const numericPort = Number(port);
if (!Number.isSafeInteger(numericPort) || numericPort < 1 || numericPort > 65535) {
throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
}
}
function canonicalAuthorityHostname(authority) {
let rawHostname;
if (authority.startsWith("[")) {
const closingBracket = authority.indexOf("]");
if (closingBracket === -1) {
throw new Error("API URL authority must contain a canonical hostname.");
}
rawHostname = authority.slice(0, closingBracket + 1);
const portSuffix = authority.slice(closingBracket + 1);
if (portSuffix) {
if (!portSuffix.startsWith(":")) {
throw new Error("API URL authority must contain a canonical hostname and port.");
}
assertCanonicalPort(portSuffix.slice(1));
}
if (isIP(rawHostname.slice(1, -1)) !== 6) {
throw new Error("API URL authority must contain a canonical IPv6 literal.");
}
} else {
const firstColon = authority.indexOf(":");
const lastColon = authority.lastIndexOf(":");
if (firstColon !== lastColon) {
throw new Error("IPv6 API URL authorities must use brackets.");
}
if (lastColon !== -1) {
const port = authority.slice(lastColon + 1);
assertCanonicalPort(port);
rawHostname = authority.slice(0, lastColon);
} else {
rawHostname = authority;
}
const ipVersion = isIP(rawHostname);
const numericAddressParts = rawHostname.split(".");
const looksLikeNonCanonicalIpv4 = numericAddressParts.every((part) => /^(?:0x[0-9a-f]+|[0-9]+)$/i.test(part));
if (ipVersion !== 4 && looksLikeNonCanonicalIpv4 || ipVersion !== 4 && !isValidDnsDomain(rawHostname.toLowerCase())) {
throw new Error("API URL authority must contain a canonical ASCII hostname.");
}
}
return rawHostname.toLowerCase();
}
function isDeliberateLoopbackHttpAuthority(authority) {
return /^(?:localhost|127\.0\.0\.1|\[::1\])(?::[0-9]+)?$/i.test(authority);
}
function toV1BaseUrl(apiUrl) {
if (ASCII_CONTROL_PATTERN.test(apiUrl)) {
throw new Error("API URL must not contain ASCII control characters.");
}
const input = apiUrl.trim();
const authority = rawAuthority(input);
if (authority.includes("@") || authority.includes("\\") || authority.includes("%") || /[^\x00-\x7f]/.test(authority)) {
throw new Error("API URL authority must be canonical ASCII without credentials.");
}
const canonicalHostname = canonicalAuthorityHostname(authority);
const url = new URL(input);
if (url.protocol !== "http:" && url.protocol !== "https:") {
throw new Error("API URL must use http or https.");
}
if (url.username || url.password) {
throw new Error("API URL must not include credentials.");
}
if (!url.hostname || url.hostname.endsWith(".")) {
throw new Error("API URL must include a canonical hostname.");
}
if (url.hostname.toLowerCase() !== canonicalHostname) {
throw new Error("API URL authority must not rely on parser hostname normalization.");
}
if (url.hostname.split(".").some((label) => label.toLowerCase().startsWith("xn--"))) {
throw new Error("API URL must not use IDN or punycode hostnames.");
}
if (url.protocol === "http:" && !isDeliberateLoopbackHttpAuthority(authority)) {
throw new Error("API URL may use http only for an exact loopback authority.");
}
if (url.search || url.hash) {
throw new Error("API URL must not include a query string or fragment.");
}
let path = url.pathname.replace(/\/+$/, "");
if (path.endsWith("/v1"))
path = path.slice(0, -"/v1".length);
url.pathname = `${path}/v1`;
return url.toString().replace(/\/+$/, "");
}
class ClientTransportConfigurationError extends Error {
appName;
sources;
constructor(appName, message, sources = []) {
super(message);
this.name = "ClientTransportConfigurationError";
this.appName = appName;
this.sources = Object.freeze([...sources]);
}
}
class ClientCredentialMissingError extends ClientTransportConfigurationError {
authorityConfigured;
constructor(name, message, sources, authorityConfigured) {
super(name, message, sources);
this.authorityConfigured = authorityConfigured;
this.name = "ClientCredentialMissingError";
}
}
function resolveClientAuthoritySnapshot(name, env = process.env, options = {}) {
env = snapshotClientEnvironment(name, env);
const keys = clientTransportEnvKeys(name);
const definedUrlEntries = keys.apiUrlKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, raw: String(env[key]) }));
const blankUrl = definedUrlEntries.find((entry) => entry.raw.trim().length === 0);
if (blankUrl) {
throw new ClientTransportConfigurationError(name, `${blankUrl.key} is set but blank; public clients require an explicit HTTPS API URL and never select local storage.`, [blankUrl.key]);
}
const controlledUrl = definedUrlEntries.find((entry) => ASCII_CONTROL_PATTERN.test(entry.raw));
if (controlledUrl) {
throw new ClientTransportConfigurationError(name, `${controlledUrl.key} contains ASCII control characters.`, [controlledUrl.key]);
}
const usableUrlEntries = definedUrlEntries.map((entry) => ({ key: entry.key, value: entry.raw.trim() }));
const normalizedAuthority = (entry) => {
try {
return toV1BaseUrl(entry.value);
} catch {
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${entry.key}; use an absolute HTTPS URL or exact loopback HTTP authority without credentials, query or fragment.`, [entry.key]);
}
};
if (usableUrlEntries.length > 1 && new Set(usableUrlEntries.map(normalizedAuthority)).size > 1) {
throw new ClientTransportConfigurationError(name, `${usableUrlEntries.map((entry) => entry.key).join(" and ")} disagree; client authority aliases must select the same versioned API authority or only one may be set.`, usableUrlEntries.map((entry) => entry.key));
}
const envUrlHit = usableUrlEntries[0] ?? null;
const keychainUrlHit = keychainConfigValue(name, env, options.credentials?.keychain);
const profile = options.bindUnpairedCredentialsToFleet ? options.credentials?.profile?.trim() || env.HASNA_PROFILE?.trim() || null : null;
const diskConfigUrlHit = appConfigDiskValue(name, env, keys.apiUrlKeys, profile);
if (diskConfigUrlHit?.unusable) {
throw new ClientTransportConfigurationError(name, `${diskConfigUrlHit.key} in ${diskConfigUrlHit.path} is declared but blank or malformed; public clients require a valid HTTPS service authority.`, [diskConfigUrlHit.path]);
}
const urlCandidates = [
...envUrlHit ? [envUrlHit] : [],
...keychainUrlHit ? [{ key: keychainUrlHit.source, value: keychainUrlHit.value }] : [],
...diskConfigUrlHit ? [{ key: diskConfigUrlHit.path, value: diskConfigUrlHit.value.trim() }] : []
];
const configuredUrl = urlCandidates[0] ?? null;
const normalizedUrls = urlCandidates.map(normalizedAuthority);
const divergentUrls = urlCandidates.filter((_, index) => normalizedUrls[index] !== normalizedUrls[0]);
if (configuredUrl && divergentUrls.length > 0) {
throw new ClientTransportConfigurationError(name, `${configuredUrl.key} and ${divergentUrls.map((candidate) => candidate.key).join(" and ")} select different service authorities; refusing to send a credential written for one authority to the other.`, urlCandidates.map((candidate) => candidate.key));
}
if (configuredUrl && options.bindUnpairedCredentialsToFleet) {
try {
toV1BaseUrl(configuredUrl.value);
} catch (error) {
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${configuredUrl.key}: ${error instanceof Error ? error.message : String(error)}`, [configuredUrl.key]);
}
}
return { keys, configuredUrl, envUrlHit, keychainUrlHit, diskConfigUrlHit };
}
function resolveClientTransportSnapshot(name, env = process.env, options = {}) {
env = snapshotClientEnvironment(name, env);
const { keys, configuredUrl, envUrlHit, keychainUrlHit, diskConfigUrlHit } = resolveClientAuthoritySnapshot(name, env, options);
const warnings = [];
if (configuredUrl && !envUrlHit) {
warnings.push(`No ${keys.apiUrlKeys[0]} in the environment; the server URL in ${configuredUrl.key} was used, so this client connects to the server. ` + `Keep that entry aligned with the intended service authority.`);
}
const credential = resolveCredential(name, env, options.credentials);
if (!credential) {
const diskHint = credentialDiskSourcesForMessage(name, env);
const lead = configuredUrl ? `${configuredUrl.key} selects the HTTP server for '${name}', but no API key could be resolved` : `${keys.apiUrlKeys[0]} is not set and no API key could be resolved for '${name}'; a credential is required before the default fleet gateway authority applies`;
warnings.push(`${lead}; refusing to create an unauthenticated client \u2014 public clients never fall back to SQLite or another local store. ` + `Looked in the Keychain (macOS only), then for a credential file at ${diskHint}, then for ${keys.apiKeyKeys[0]} in the environment.`);
const sources = [configuredUrl?.key ?? keys.apiUrlKeys[0]];
if (options.bindUnpairedCredentialsToFleet)
throw new ClientCredentialMissingError(name, warnings.join(" "), sources, configuredUrl !== null);
throw new ClientTransportConfigurationError(name, warnings.join(" "), sources);
}
if (credential.warning)
warnings.push(credential.warning);
let urlHit;
if (configuredUrl) {
urlHit = configuredUrl;
} else {
try {
urlHit = { key: DEFAULT_AUTHORITY_SOURCE, value: defaultFleetGatewayBaseUrl(name) };
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new ClientTransportConfigurationError(name, `No ${keys.apiUrlKeys[0]} is configured and the default fleet gateway authority cannot be composed for '${name}': ${message}`, [keys.apiUrlKeys[0]]);
}
}
const apiUrlSource = urlHit.key;
let baseUrl;
try {
baseUrl = toV1BaseUrl(urlHit.value);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${apiUrlSource}: ${message}`, [apiUrlSource]);
}
if (options.bindUnpairedCredentialsToFleet && baseUrl !== toV1BaseUrl(defaultFleetGatewayBaseUrl(name))) {
const pairedDisk = diskConfigUrlHit?.path === credential.source && (credential.tier === "disk" || credential.tier === "profile" || credential.tier === "pointer");
const pairedKeychain = credential.tier === "keychain" && keychainUrlHit?.source === credential.source.replace(".api-key@", ".api-url@");
const deliberatePair = envUrlHit !== null && (credential.tier === "argument" || credential.tier === "override");
if (!pairedDisk && !pairedKeychain && !deliberatePair) {
throw new ClientTransportConfigurationError(name, "An unpaired legacy credential is bound to the fleet gateway. Configure a stored authority/credential pair or an explicit API key override for the intended authority; no credential was sent.");
}
}
return {
resolution: {
transport: "http",
transportSource: urlHit.key,
baseUrl,
apiUrlSource,
apiKeyPresent: true,
apiKeySource: credential.source,
apiKeyTier: credential.tier,
misconfigured: false,
warning: warnings.length > 0 ? warnings.join(" ") : null
},
credential
};
}
function resolveClientTransport(name, env = process.env, options = {}) {
return resolveClientTransportSnapshot(name, env, options).resolution;
}
function credentialDiskSourcesForMessage(name, env) {
const paths = credentialDiskSources(name, env);
return paths.length > 0 ? paths.join(" or ") : "<no HOME or HASNA_HOME set in this environment, so no credential file was consulted>";
}
class HasnaHttpError extends Error {
status;
method;
path;
credentialSource;
credentialTier;
constructor(method, path, status, body, credential) {
const guidance = credential ? `. ${credential.guidance}` : "";
super(`Hasna cloud request failed: ${method} ${path} -> ${status}${guidance}`);
this.name = "HasnaHttpError";
this.status = status;
this.method = method;
this.path = path;
Object.defineProperty(this, "body", {
value: body,
enumerable: status !== 401 && status !== 403,
writable: false,
configurable: false
});
this.credentialSource = credential?.source ?? null;
this.credentialTier = credential?.tier ?? null;
}
}
function currentCredential(name, apiKey) {
if (typeof apiKey === "function") {
return validateAndSealResolvedCredential(name, apiKey());
}
return explicitCredential(name, apiKey);
}
async function resolveRequestCredential(name, apiKey, env = process.env) {
const resolved = currentCredential(name, apiKey);
if (resolved.tier === "pointer") {
return completePointerCredential(name, resolved, env);
}
return resolved;
}
function authFailureGuidance(credential) {
const origin = `The API key for this request came from ${credential.source}`;
if (credential.deliberate) {
const remedy = credential.source === CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE ? `Fix that provider so it returns the current key, or replace it with resolveCredential() ` + `so diagnostics can name the original source.` : `Rotate that key, or unset the override to use the credential on disk.`;
return `${origin} \u2014 a credential you selected deliberately. It was NOT substituted with any other key: ` + `falling back here would authenticate as a different principal than the one you named, which is ` + `exactly the failure an override exists to prevent. ${remedy}`;
}
if (credential.tier === "env") {
const target = credential.diskCandidates[0];
const remedy = target ? `Store the CURRENT key in the Keychain or write it to ${target} \u2014 both are re-read on every call, so ` + `rotations take effect immediately and in every shell. Do not simply unset ${credential.source}: ` + `nothing was found in the Keychain or on disk, so that would leave this client with no credential at all.` : `This environment has no HOME or HASNA_HOME, so no credential file could be consulted; the disk tier is ` + `unavailable here and there is nothing to fall back to. Set HOME, or supply the key explicitly.`;
return `${origin}, a variable in this process's environment. If a wrapper injected it for this one process, the ` + `wrapper re-reads its store on every invocation and the stored key itself is being rejected \u2014 rotate it. ` + `If this SHELL exported it, the export is a snapshot taken when the shell started: a STALE SHELL that ` + `exported the key before it was rotated keeps sending the old one until it exits. ${remedy}`;
}
if (credential.tier === "keychain") {
return `${origin}, which was re-read from the Keychain on this very call \u2014 so a stale shell is NOT the cause ` + `here. The stored item is genuinely being rejected: update it with the current key, or re-run the fleet ` + `key distribution so this machine gets the current key.`;
}
return `${origin}, which was re-read from disk on this very call \u2014 so a stale shell is NOT the cause here. ` + `The stored credential is genuinely being rejected: rotate it, or re-run the fleet key distribution ` + `so this machine gets the current key.`;
}
var DEFAULT_RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
var AUTHORITY_OVERRIDE_HEADERS = new Set([
"host",
":authority",
"forwarded",
"x-forwarded-host",
"x-original-host"
]);
function assertNoAuthorityOverrideHeaders(headers, source) {
if (!headers)
return;
const forbidden = Object.keys(headers).find((name) => AUTHORITY_OVERRIDE_HEADERS.has(name.trim().toLowerCase()));
if (forbidden) {
throw new Error(`Authenticated ${source} headers must not set authority header '${forbidden}'.`);
}
}
function appendQuery(path, query) {
if (!query)
return path;
const params = query instanceof URLSearchParams ? query : new URLSearchParams;
if (!(query instanceof URLSearchParams)) {
for (const [key, value] of Object.entries(query)) {
if (value === null || value === undefined)
continue;
if (Array.isArray(value)) {
for (const v of value)
params.append(key, String(v));
} else {
params.append(key, String(value));
}
}
}
const qs = params.toString();
if (!qs)
return path;
return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
}
var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function createHasnaHttpTransportInternal(options, requestBindingProvider) {
const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
const base = toV1BaseUrl(options.baseUrl);
const timeoutMs = options.timeoutMs ?? 30000;
const sleep = options.sleepImpl ?? defaultSleep;
const defaultRetry = options.retry;
function resolveRetry(callRetry) {
const chosen = callRetry !== undefined ? callRetry : defaultRetry;
if (chosen === false)
return null;
const r2 = chosen ?? {};
return {
retries: r2.retries ?? 2,
baseDelayMs: r2.baseDelayMs ?? 200,
maxDelayMs: r2.maxDelayMs ?? 2000,
retryStatuses: r2.retryStatuses ?? [...DEFAULT_RETRY_STATUSES]
};
}
async function once(method, rel, body, opts, bind) {
const materializeHeaders = (input) => Object.fromEntries(Object.entries(input ?? {}).map(([key, value]) => [key, String(value)]));
const transportHeaders = materializeHeaders(options.headers);
const requestHeaders = materializeHeaders(opts.headers);
assertNoAuthorityOverrideHeaders(transportHeaders, "transport");
assertNoAuthorityOverrideHeaders(requestHeaders, "request");
const headers = {
Accept: "application/json",
...transportHeaders,
...requestHeaders
};
const idempotencyKey = opts.idempotencyKey;
if (idempotencyKey)
headers["Idempotency-Key"] = String(idempotencyKey);
const init = {
method,
headers,
redirect: "manual"
};
if (body !== undefined) {
headers["Content-Type"] = "application/json";
init.body = JSON.stringify(body);
}
const controller = new AbortController;
const onAbort = () => controller.abort();
const callerSignal = opts.signal;
if (callerSignal) {
if (callerSignal.aborted)
controller.abort();
else
callerSignal.addEventListener("abort", onAbort, { once: true });
}
const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
init.signal = controller.signal;
let response;
let credential;
try {
const binding = bind();
credential = binding.credential;
init.headers = {
"x-api-key": credential.apiKey,
Authorization: `Bearer ${credential.apiKey}`,
...headers
};
try {
response = await fetchImpl(`${binding.baseUrl}${rel}`, init);
} catch (error) {
const err = error instanceof Error ? error : new Error(String(error));
if (callerSignal?.aborted)
return { ok: false, retryable: false, error: err };
return { ok: false, retryable: true, error: err };
}
} finally {
clearTimeout(timer);
if (callerSignal)
callerSignal.removeEventListener("abort", onAbort);
}
const authenticationFailure = response.status === 401 || response.status === 403;
let parsed = undefined;
if (authenticationFailure) {
try {
await response.body?.cancel();
} catch {}
} else {
const text = await response.text();
if (text.length > 0) {
try {
parsed = JSON.parse(text);
} catch {
parsed = text;
}
}
}
if (!response.ok) {
if (response.status >= 300 && response.status < 400) {
return {
ok: false,
retryable: false,
error: new HasnaHttpError(method, rel, response.status, parsed)
};
}
if (authenticationFailure) {
return {
ok: false,
retryable: false,
error: new HasnaHttpError(method, rel, response.status, undefined, {
source: credential.source,
tier: credential.tier,
guidance: authFailureGuidance(credential)
})
};
}
const retry = resolveRetry(opts.retry);
const retryable = retry ? retry.retryStatuses.includes(response.status) : false;
return { ok: false, retryable, error: new HasnaHttpError(method, rel, response.status, parsed) };
}
return { ok: true, value: parsed };
}
async function request(method, path, body, opts = {}) {
const upper = method.toUpperCase();
const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
const retry = resolveRetry(opts.retry);
const methodRetryable = IDEMPOTENT_METHODS.has(upper) || Boolean(opts.idempotencyKey);
const maxAttempts = retry && methodRetryable ? retry.retries + 1 : 1;
let finalize;
if (requestBindingProvider) {
const prepared = requestBindingProvider();
finalize = typeof prepared === "function" ? prepared : await prepared;
} else {
const credential = await resolveRequestCredential(options.name, options.apiKey);
finalize = () => ({ baseUrl: base, credential });
}
let binding;
const bind = () => binding ??= finalize();
let last = null;
for (let attempt = 1;attempt <= maxAttempts; attempt++) {
const result = await once(upper, rel, body, opts, bind);
if (result.ok)
return result.value;
last = result;
const canRetry = retry !== null && methodRetryable && result.retryable && attempt < maxAttempts;
if (!canRetry)
break;
const backoff = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
await sleep(backoff + jitter);
}
throw last.error;
}
return {
baseUrl: base,
request,
get: (path, opts) => request("GET", path, undefined, opts),
post: (path, body, opts) => request("POST", path, body, opts),
put: (path, body, opts) => request("PUT", path, body, opts),
patch: (path, body, opts) => request("PATCH", path, body, opts),
del: (path, body, opts) => request("DELETE", path, body, opts)
};
}
function createClientTransport(name, env = process.env, overrides) {
const credentialOptions = overrides?.credentials;
const snapshotOptions = {
...credentialOptions ? { credentials: credentialOptions } : {},
...overrides?.bindUnpairedCredentialsToFleet === undefined ? {} : { bindUnpairedCredentialsToFleet: overrides.bindUnpairedCredentialsToFleet }
};
const resolution = resolveClientTransportSnapshot(name, env, snapshotOptions).resolution;
const sameBinding = (left, right) => left.resolution.baseUrl === right.resolution.baseUrl && left.credential.apiKey === right.credential.apiKey && left.credential.pointerVaultKey === right.credential.pointerVaultKey && left.credential.source === right.credential.source && left.credential.tier === right.credential.tier;
const unstableConfiguration = () => new ClientTransportConfigurationError(name, "The configured service authority or credential changed while a request was being prepared; no authenticated request was sent.");
const assertPinnedAuthority = (snapshot) => {
if (snapshot.resolution.baseUrl !== resolution.baseUrl) {
throw new ClientTransportConfigurationError(name, "The configured service authority changed; rebuild the client before sending credentials.");
}
};
const requestBindingProvider = () => {
const first = resolveClientTransportSnapshot(name, env, snapshotOptions);
assertPinnedAuthority(first);
const finalize = (reviewed2, completed) => () => {
const final = resolveClientTransportSnapshot(name, env, snapshotOptions);
if (!sameBinding(reviewed2, final))
throw unstableConfiguration();
assertPinnedAuthority(final);
return {
baseUrl: final.resolution.baseUrl,
credential: completed ?? currentCredential(name, () => final.credential)
};
};
if (first.credential.tier !== "pointer")
return finalize(first);
const reviewed = resolveClientTransportSnapshot(name, env, snapshotOptions);
if (!sameBinding(first, reviewed))
throw unstableConfiguration();
assertPinnedAuthority(reviewed);
return resolveRequestCredential(name, () => reviewed.credential, env).then((credential) => finalize(reviewed, credential));
};
return {
transport: "http",
client: createHasnaHttpTransportInternal({
name,
baseUrl: resolution.baseUrl,
apiKey: () => {
throw new Error("The authenticated request binding provider was not invoked.");
},
...overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {},
...overrides?.headers ? { headers: overrides.headers } : {},
...overrides?.timeoutMs ? { timeoutMs: overrides.timeoutMs } : {},
...overrides?.retry !== undefined ? { retry: overrides.retry } : {},
...overrides?.sleepImpl ? { sleepImpl: overrides.sleepImpl } : {}
}, requestBindingProvider),
resolution
};
}
// ../contracts/dist/client/storage.js
import { createRequire as createRequire2 } from "module";
var MAX_PACKAGE_BYTES2 = 1024 * 1024;
var MAX_CREDENTIAL_FILE_BYTES2 = 64 * 1024;
var INSPECT_CUSTOM2 = Symbol.for("nodejs.util.inspect.custom");
var CREDENTIAL_SEAL2 = Symbol.for("hasna:contracts:sealedCredential");
var AMBIENT_ENVIRONMENT2 = Symbol.for("hasna:contracts:ambientClientEnvironment");
var requireSecretsSdk2 = createRequire2(import.meta.url);
var IDEMPOTENT_METHODS2 = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
var AUTHORITY_OVERRIDE_HEADERS2 = new Set([
"host",
":authority",
"forwarded",
"x-forwarded-host",
"x-original-host"
]);
function resourcePath(resource) {
const trimmed = resource.replace(/^\/+|\/+$/g, "");
if (!trimmed)
throw new Error("resource must be a non-empty path segment");
return `/${trimmed}`;
}
function entityPath(resource, id) {
if (id === undefined || id === null || `${id}`.length === 0) {
throw new Error("id must be a non-empty string");
}
return `${resourcePath(resource)}/${encodeURIComponent(String(id))}`;
}
function newIdempotencyKey() {
const g = globalThis;
if (g.crypto?.randomUUID)
return g.crypto.randomUUID();
return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
}
function extractItems(raw) {
if (Array.isArray(raw))
return raw;
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["items", "data", "results", "rows", "records"]) {
if (Array.isArray(obj[key]))
return obj[key];
}
}
return [];
}
function extractTotal(raw) {
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["total", "count", "totalCount", "total_count"]) {
if (typeof obj[key] === "number")
return obj[key];
}
}
return null;
}
function extractCursor(raw) {
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["cursor", "nextCursor", "next_cursor", "next"]) {
if (typeof obj[key] === "string")
return obj[key];
}
}
return null;
}
function isNotFoundHttpError(error) {
return typeof error === "object" && error !== null && error.name === "HasnaHttpError" && error.status === 404;
}
function createHasnaStorageClient(name, transport) {
return {
name,
baseUrl: transport.baseUrl,
transport,
async list(resource, options = {}) {
const raw = await transport.get(resourcePath(resource), options);
return {
items: extractItems(raw),
total: extractTotal(raw),
cursor: extractCursor(raw),
raw
};
},
async get(resource, id, options = {}) {
try {
return await transport.get(entityPath(resource, id), options);
} catch (error) {
if (isNotFoundHttpError(error))
return null;
throw error;
}
},
async create(resource, body, options = {}) {
const { idempotencyKey, ...rest } = options;
return transport.post(resourcePath(resource), body, {
...rest,
idempotencyKey: idempotencyKey ?? newIdempotencyKey()
});
},
async update(resource, id, patch, options = {}) {
const { method = "PATCH", idempotencyKey, ...rest } = options;
const call = method === "PUT" ? transport.put : transport.patch;
return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
},
async delete(resource, id, options = {}) {
try {
await transport.del(entityPath(resource, id), undefined, options);
} catch (error) {
if (isNotFoundHttpError(error))
return;
throw error;
}
}
};
}
// src/lib/client-storage-policy.ts
var LOCAL_PATH_VARS = [
"HASNA_DOMAINS_DB_PATH",
"DOMAINS_DB_PATH",
"HASNA_DOMAINS_DIR",
"DOMAINS_DIR"
];
function explicitLocalPathVar(env = process.env) {
return LOCAL_PATH_VARS.find((key) => (env[key] ?? "").trim() !== "");
}
function domainsAuthorityEnvKeys() {
const keys = clientTransportEnvKeys("domains");
return [
...keys.apiUrlKeys,
...keys.apiKeyKeys,
credentialOverrideEnvKey("domains"),
credentialPointerEnvKey("domains"),
CREDENTIAL_PROFILE_ENV_KEY
];
}
function assertDomainsClientStorage(env = process.env) {
const pathVar = explicitLocalPathVar(env);
if (pathVar)
throw new Error(`domains: ${pathVar} is no longer supported by clients. Unset local database path variables and configure the shared API with HASNA_DOMAINS_API_KEY or saved credentials. Preserve any existing database until its records have been migrated and verified.`);
}
// src/lib/domains-resolver.ts
var DOMAINS_APP_NAME = "domains";
var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
function isAmbientEnv(env) {
if (typeof process !== "undefined" && env === process.env)
return true;
return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
}
function domainsResolverEnv(env) {
const blanks = domainsAuthorityEnvKeys().filter((key) => (key in env) && (env[key] ?? "").trim() === "");
if (blanks.length === 0)
return env;
const next = { ...env };
for (const key of blanks)
delete next[key];
return next;
}
function domainsResolverInputs(env, credentials = {}) {
assertDomainsClientStorage(env);
const normalised = domainsResolverEnv(env);
if (normalised === env)
return { env: normalised, credentials };
const keychain = { ...credentials.keychain };
if (keychain.enabled === undefined && keychain.run === undefined) {
keychain.enabled = isAmbientEnv(env);
}
return { env: normalised, credentials: { ...credentials, keychain } };
}
function resolveDomainsTransport(env = process.env, options = {}) {
const inputs = domainsResolverInputs(env, options.credentials ?? {});
return resolveDomainsTransportWithInputs(inputs.env, inputs.credentials);
}
function resolveDomainsTransportWithInputs(env, credentials) {
try {
const resolution = resolveClientTransport(DOMAINS_APP_NAME, env, { credentials });
const credential = resolveCredential(DOMAINS_APP_NAME, env, credentials);
if (!credential) {
throw new Error(`domains: no API key resolved from any credential tier; refusing to build an unauthenticated client.`);
}
return {
report: {
transport: "http",
baseUrl: resolution.baseUrl,
apiUrlSource: resolution.apiUrlSource ?? "default",
apiKeySource: credential.source,
apiKeyTier: credential.tier
},
credential
};
} catch (error) {
if (error instanceof ClientTransportConfigurationError) {
throw new Error(`domains fails closed: ${error.message}`);
}
throw error;
}
}
function resolveDomainsHttpClient(env = process.env, options = {}) {
const inputs = domainsResolverInputs(env, options.credentials ?? {});
try {
const wired = createClientTransport(DOMAINS_APP_NAME, inputs.env, {
...Object.keys(inputs.credentials).length > 0 ? { credentials: inputs.credentials } : {}
});
return {
transport: "http",
client: createHasnaStorageClient(DOMAINS_APP_NAME, wired.client),
resolution: wired.resolution
};
} catch (error) {
if (error instanceof ClientTransportConfigurationError) {
throw new Error(`domains fails closed: ${error.message}`);
}
throw error;
}
}
// src/db/store.ts
var DOMAINS_PAGE_SIZE = 1000;
function q(params) {
const out = {};
for (const [k, v] of Object.entries(params))
if (v !== undefined && v !== null && v !== "")
out[k] = v;
return out;
}
function enc(id) {
return encodeURIComponent(id);
}
class ApiStore {
client;
transport = "http";
constructor(client) {
this.client = client;
}
get http() {
return this.client.transport;
}
async createDomain(input) {
return this.client.create("domains", input);
}
async getDomain(id) {
return this.client.get("domains", id);
}
async getDomainByName(name) {
const matches = await this.listDomains({ search: name });
return matches.find((d) => d.name === name) ?? null;
}
async getDomainByIdentifier(identifier) {
const byId = await this.client.get("domains", identifier);
if (byId)
return byId;
return this.getDomainByName(identifier);
}
async getDomainDetails(identifier) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
const [offers, emails] = await Promise.all([
this.listDomainOffers(domain.id),
this.listDomainEmailLinks(domain.id)
]);
return { domain, offers, emails };
}
async listDomains(options = {}) {
const needsClientFilter = options.registrar !== undefined || options.is_premium !== undefined;
if (!needsClientFilter && typeof options.limit === "number" && options.limit <= DOMAINS_PAGE_SIZE) {
const result = await this.client.list("domains", {
query: q({
search: options.search,
status: options.status,
limit: options.limit,
offset: options.offset
})
});
const raw = result.raw;
return raw?.domains ?? result.items;
}
let items = await this.listAllDomains(q({ search: options.search, status: options.status }));
if (options.registrar !== undefined)
items = items.filter((d) => d.registrar === options.registrar);
if (options.is_premium !== undefined)
items = items.filter((d) => d.is_premium === options.is_premium);
const offset = options.offset ?? 0;
if (offset > 0)
items = items.slice(offset);
if (typeof options.limit === "number")
items = items.slice(0, options.limit);
return items;
}
async listAllDomains(serverQuery) {
const acc = [];
let offset = 0;
for (;; ) {
const result = await this.client.list("domains", {
query: { ...serverQuery, limit: DOMAINS_PAGE_SIZE, offset }
});
const raw = result.raw;
const page = raw?.domains ?? result.items;
acc.push(...page);
if (page.length < DOMAINS_PAGE_SIZE)
break;
offset += DOMAINS_PAGE_SIZE;
}
return acc;
}
async updateDomain(id, input) {
const existing = await this.client.get("domains", id);
if (!existing)
return null;
return this.client.update("domains", id, input);
}
async deleteDomain(id) {
const existing = await this.client.get("domains", id);
if (!existing)
return false;
await this.client.delete("domains", id);
return true;
}
async countDomains() {
return (await this.getDomainStats()).total;
}
async searchDomains(query) {
return this.listDomains({ search: query });
}
async getByRegistrar(registrar) {
return this.listDomains({ registrar });
}
async listExpiring(days, options = {}) {
const includeLapsed = options.includeLapsed ?? true;
const now = Date.now();
const horizon = now + days * 24 * 60 * 60 * 1000;
const domains = await this.listDomains({ status: "active" });
return domains.filter((d) => {
if (!d.expires_at)
return false;
const exp = Date.parse(d.expires_at);
if (!Number.isFinite(exp))
return false;
if (exp > horizon)
return false;
return includeLapsed ? true : exp >= now;
}).sort((a, b) => Date.parse(a.expires_at ?? "") - Date.parse(b.expires_at ?? ""));
}
async listSslExpiring(days, options = {}) {
const includeLapsed = options.includeLapsed ?? true;
const now = Date.now();
const horizon = now + days * 24 * 60 * 60 * 1000;
const domains = await this.listDomains({});
return domains.filter((d) => {
if (!d.ssl_expires_at)
return false;
const exp = Date.parse(d.ssl_expires_at);
if (!Number.isFinite(exp))
return false;
if (exp > horizon)
return false;
return includeLapsed ? true : exp >= now;
}).sort((a, b) => Date.parse(a.ssl_expires_at ?? "") - Date.parse(b.ssl_expires_at ?? ""));
}
async listPastExpiry() {
const now = Date.now();
const domains = await this.listDomains({ status: "active" });
return domains.filter((d) => {
if (!d.expires_at)
return false;
const exp = Date.parse(d.expires_at);
return Number.isFinite(exp) && exp < now;
}).sort((a, b) => Date.parse(a.expires_at ?? "") - Date.parse(b.expires_at ?? ""));
}
async listSslPastExpiry() {
const now = Date.now();
const domains = await this.listDomains({});
return domains.filter((d) => {
if (!d.ssl_expires_at)
return false;
const exp = Date.parse(d.ssl_expires_at);
return Number.isFinite(exp) && exp < now;
}).sort((a, b) => Date.parse(a.ssl_expires_at ?? "") - Date.parse(b.ssl_expires_at ?? ""));
}
async getDomainStats() {
const result = await this.client.list("stats");
return result.raw;
}
async markDomainPremium(identifier, premiumPrice, standardPrice) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, {
is_premium: true,
premium_price: premiumPrice,
standard_price: standardPrice ?? domain.standard_price,
status: domain.status === "discovered" ? "premium_only" : domain.status
});
}
async updateDomainLifecycleStatus(identifier, status, notes) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, { status, notes: notes ?? domain.notes ?? undefined });
}
async recordDomainPurchase(identifier, input) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, {
registrar: input.registrar,
status: "purchased",
purchase_price: input.price,
purchase_date: input.purchase_date ?? new Date().toISOString(),
expires_at: input.expires_at ?? domain.expires_at ?? undefined,
auto_renew: input.auto_renew ?? domain.auto_renew,
standard_price: input.standard_price ?? domain.standard_price,
notes: input.notes ?? domain.notes ?? undefined
});
}
async createDomainOffer(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/offers`, body);
}
async getDomainOffer(id) {
return this.http.get(`/offers/${enc(id)}`).catch(() => null);
}
async listDomainOffers(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/offers`);
return res.offers ?? [];
}
async linkDomainEmail(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/emails`, body);
}
async getDomainEmailLink(id) {
return this.http.get(`/emails/${enc(id)}`).catch(() => null);
}
async listDomainEmailLinks(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/emails`);
return res.emails ?? [];
}
async createDnsRecord(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/dns`, body);
}
async getDnsRecord(id) {
return this.client.get("dns", id);
}
async listDnsRecords(domainId, type) {
const res = await this.http.get(`/domains/${enc(domainId)}/dns`, { query: q({ type }) });
return res.records ?? [];
}
async updateDnsRecord(id, input) {
const existing = await this.getDnsRecord(id);
if (!existing)
return null;
return this.client.update("dns", id, input);
}
async deleteDnsRecord(id) {
const existing = await this.getDnsRecord(id);
if (!existing)
return false;
await this.client.delete("dns", id);
return true;
}
async createAlert(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/alerts`, body);
}
async getAlert(id) {
return this.client.get("alerts", id);
}
async listAlerts(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/alerts`);
return res.alerts ?? [];
}
async deleteAlert(id) {
const existing = await this.getAlert(id);
if (!existing)
return false;
await this.client.delete("alerts", id);
return true;
}
async createDomainOwner(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/owners`, body);
}
async getDomainOwner(id) {
return this.client.get("owners", id);
}
async getDomainOwnerByDomain(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/owners`);
return res.owners?.[0] ?? null;
}
async getDomainOwnerByDomainName(domainName) {
const domain = await this.getDomainByName(domainName);
if (!domain)
return null;
return this.getDomainOwnerByDomain(domain.id);
}
async listDomainOwners(options = {}) {
const res = await this.client.list("owners", {
query: q({ search: options.search, source: options.source, verified: options.verified })
});
const raw = res.raw;
return raw?.owners ?? res.items;
}
async updateDomainOwner(id, input) {
const existing = await this.getDomainOwner(id);
if (!existing)
return null;
return this.client.update("owners", id, input);
}
async deleteDomainOwner(id) {
const existing = await this.getDomainOwner(id);
if (!existing)
return false;
await this.client.delete("owners", id);
return true;
}
async listDomainsWithOwners() {
const res = await this.http.get(`/owners-portfolio`);
return res.domains ?? [];
}
async createHistoryEntry(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/history`, body);
}
async getHistoryEntry(id) {
return this.client.get("history", id);
}
async getHistoryByDomain(domainId, options) {
const res = await this.http.get(`/domains/${enc(domainId)}/history`, {
query: q({ type: options?.type, limit: options?.limit })
});
return res.history ?? [];
}
async getLatestSnapshot(domainId, type) {
const list = await this.getHistoryByDomain(domainId, { type, limit: 1 });
return list[0] ?? null;
}
async getHistoryByDateRange(startDate, endDate, domainId) {
const res = await this.http.get(`/history`, {
query: q({ start: startDate, end: endDate, domain: domainId })
});
return res.history ?? [];
}
async listDomainsWithHistoryChanges() {
const res = await this.http.get(`/history-changes`);
return res.domains ?? [];
}
async deleteHistoryEntry(id) {
const existing = await this.getHistoryEntry(id);
if (!existing)
return false;
await this.client.delete("history", id);
return true;
}
async deleteHistoryByDomain(domainId) {
const res = await this.http.del(`/domains/${enc(domainId)}/history`);
return Boolean(res.deleted);
}
async upsertDomainReputation(input) {
const { domain_id, ...body } = input;
return this.http.put(`/domains/${enc(domain_id)}/reputation`, body);
}
async getDomainReputation(domainId) {
return this.http.get(`/domains/${enc(domainId)}/reputation`).catch(() => null);
}
async getDomainReputationByName(domainName) {
const domain = await this.getDomainByName(domainName);
if (!domain)
return null;
return this.getDomainReputation(domain.id);
}
async updateDomainReputation(id, input) {
return this.client.update("reputation", id, input);
}
async listBlacklistedDomains() {
const res = await this.client.list("reputation", { query: { blacklisted: true } });
const raw = res.raw;
return raw?.reputation ?? res.items;
}
async listHighThreatDomains(threshold = 70) {
const res = await this.client.list("reputation", { query: { threshold } });
const raw = res.raw;
return raw?.reputation ?? res.items;
}
async deleteDomainReputation(id) {
await this.client.delete("reputation", id);
return true;
}
}
function getStore(env = process.env, options = {}) {
assertDomainsClientStorage(env);
const wired = resolveDomainsHttpClient(env, {
...options.credentials ? { credentials: options.credentials } : {}
});
return new ApiStore(wired.client);
}
function getStoreResolution(env = process.env, options = {}) {
assertDomainsClientStorage(env);
const { report } = resolveDomainsTransport(env, {
...options.credentials ? { credentials: options.credentials } : {}
});
return {
transport: "http",
localPathVar: null,
baseUrl: report.baseUrl,
apiUrlSource: report.apiUrlSource,
apiKeySource: report.apiKeySource,
apiKeyTier: report.apiKeyTier
};
}
function isCloudStore(env = process.env, options = {}) {
return getStoreResolution(env, options).transport === "http";
}
// src/db/domain-records.ts
var DOMAIN_STATUSES = [
"discovered",
"researching",
"offered",
"negotiating",
"purchased",
"active",
"not_available",
"premium_only",
"declined",
"expired",
"transferring",
"redemption"
];
var DOMAIN_OFFER_STATUSES = ["pending", "accepted", "rejected", "countered"];
var DOMAIN_EMAIL_TYPES = [
"inquiry",
"offer",
"counter_offer",
"confirmation",
"renewal_notice",
"transfer"
];
// src/db/dns-tools.ts
import { execFileSync } from "child_process";
import { domainToASCII } from "url";
// src/lib/version.ts
import { readFileSync as readFileSync3 } from "fs";
import { dirname as dirname2, resolve } from "path";
import { fileURLToPath as fileURLToPath3 } from "url";
var cachedVersion = null;
function getPackageVersion() {
if (cachedVersion)
return cachedVersion;
try {
const moduleDir = dirname2(fileURLToPath3(import.meta.url));
const packageJsonPath = resolve(moduleDir, "../../package.json");
const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
cachedVersion = pkg.version ?? "0.0.0";
} catch {
cachedVersion = "0.0.0";
}
return cachedVersion;
}
var USER_AGENT = `open-domains/${getPackageVersion()}`;
// src/db/dns-tools.ts
class DnsToolValidationError extends Error {
constructor(message) {
super(message);
this.name = "DnsToolValidationError";
}
}
var HOSTNAME_LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
var DNS_QUERY_LABEL_RE = /^(?:\*|[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?)$/;
var DNS_RECORD_TYPES = new Set([
"A",
"AAAA",
"CAA",
"CNAME",
"DNSKEY",
"DS",
"HTTPS",
"MX",
"NAPTR",
"NS",
"PTR",
"SOA",
"SPF",
"SRV",
"SSHFP",
"SVCB",
"TLSA",
"TXT"
]);
function normalizeDnsName(value, options) {
if (typeof value !== "string") {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
const ascii = domainToASCII(value.trim().replace(/\.$/, ""));
const labelRe = options.allowUnderscore ? DNS_QUERY_LABEL_RE : HOSTNAME_LABEL_RE;
if (!ascii || ascii.length > 253) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
const normalized = ascii.toLowerCase();
const labels = normalized.split(".");
if (labels.length < 2) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
for (const [index, label] of labels.entries()) {
if (!labelRe.test(label)) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
if (label === "*" && (!options.allowWildcard || index !== 0)) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
}
return normalized;
}
function normalizeDomainName(value) {
return normalizeDnsName(value, { allowUnderscore: false, allowWildcard: false });
}
function normalizeDnsQueryName(value) {
return normalizeDnsName(value, { allowUnderscore: true, allowWildcard: true });
}
function normalizeDnsRecordType(value) {
if (typeof value !== "string") {
throw new DnsToolValidationError("Invalid DNS record type.");
}
const recordType = value.trim().toUpperCase();
if (!DNS_RECORD_TYPES.has(recordType)) {
throw new DnsToolValidationError("Invalid DNS record type.");
}
return recordType;
}
function getVcardPropertyValue(entry) {
return entry.length >= 4 ? entry[3] : entry[2];
}
async function rdapLookup(domainName) {
const domain = normalizeDomainName(domainName);
const url = `https://rdap.org/domain/${encodeURIComponent(domain)}`;
const response = await fetch(url, {
signal: AbortSignal.timeout(15000),
headers: {
Accept: "application/rdap+json, application/json",
"User-Agent": USER_AGENT
}
});
if (!response.ok) {
if (response.status === 404) {
throw new Error(`RDAP: domain "${domain}" not found`);
}
throw new Error(`RDAP request failed with status ${response.status} for ${domain}`);
}
return response.json();
}
function extractRegistrantFromRdap(rdap) {
const result = {
name: null,
email: null,
phone: null,
organization: null
};
if (!rdap.entities)
return result;
const findRegistrant = (entities) => {
for (const entity of entities) {
if (entity.roles?.some((r) => r === "registrant"))
return entity;
if (entity.entities) {
const found = findRegistrant(entity.entities);
if (found)
return found;
}
}
return null;
};
const registrant = findRegistrant(rdap.entities);
if (!registrant?.vcardArray)
return result;
const vcard = registrant.vcardArray[1];
if (!vcard || !Array.isArray(vcard))
return result;
for (const entry of vcard) {
if (!Array.isArray(entry) || entry.length < 3)
continue;
const [prop] = entry;
const value = getVcardPropertyValue(entry);
if (prop === "fn")
result.name = typeof value === "string" ? value : null;
else if (prop === "email")
result.email = typeof value === "string" ? value : null;
else if (prop === "tel")
result.phone = typeof value === "string" ? value : null;
else if (prop === "org") {
const organization = Array.isArray(value) ? value[0] : value;
result.organization = typeof organization === "string" ? organization : null;
} else if (prop === "n" && !result.name) {
const parts = Array.isArray(value) ? value.filter((part) => typeof part === "string" && part.length > 0) : typeof value === "string" ? [value] : [];
result.name = parts.reverse().join(" ").trim() || null;
}
}
if (!result.name && registrant.handle) {
result.name = registrant.handle;
}
return result;
}
function extractRegistrarFromRdap(rdap) {
if (!rdap.entities)
return null;
for (const entity of rdap.entities) {
if (entity.roles?.some((r) => r === "registrar" || r === "sponsor")) {
if (entity.vcardArray?.[1]) {
const vcard = entity.vcardArray[1];
for (const entry of vcard) {
if (Array.isArray(entry) && entry[0] === "fn") {
const value = getVcardPropertyValue(entry);
return typeof value === "string" ? value : null;
}
}
}
if (entity.remarks) {
for (const remark of entity.remarks) {
if (remark.title?.toLowerCase().includes("registrar")) {
const desc = Array.isArray(remark.description) ? remark.description[0] : remark.description;
if (desc)
return desc;
}
}
}
return entity.handle ?? null;
}
}
return null;
}
function extractExpiryFromRdap(rdap) {
if (!rdap.events)
return null;
const expiryEvent = rdap.events.find((e) => e.eventAction === "expiration" || e.eventAction === "expiry");
return expiryEvent?.eventDate ?? null;
}
function extractNameserversFromRdap(rdap) {
if (!rdap.nameservers)
return [];
return rdap.nameservers.map((ns) => (ns.ldhName ?? ns.unicodeName ?? "").toLowerCase()).filter(Boolean);
}
async function whoisLookup(domainName) {
const domain = normalizeDomainName(domainName);
try {
return await rdapWhoisLookup(domain);
} catch {}
return whoisCliLookup(domain);
}
async function rdapWhoisLookup(domainName) {
const domain = normalizeDomainName(domainName);
const rdap = await rdapLookup(domain);
const registrar = extractRegistrarFromRdap(rdap);
const expires_at = extractExpiryFromRdap(rdap);
const nameservers = extractNameserversFromRdap(rdap);
const registrant = extractRegistrantFromRdap(rdap);
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = { whois: rdap };
if (registrar)
updates.registrar = registrar;
if (expires_at)
updates.expires_at = expires_at;
if (nameservers.length > 0)
updates.nameservers = nameservers;
await store.updateDomain(existing.id, updates);
}
return {
domain,
registrar,
expires_at,
nameservers,
raw: JSON.stringify(rdap),
source: "rdap",
registrant
};
}
async function whoisCliLookup(domainName) {
const domain = normalizeDomainName(domainName);
let raw;
try {
raw = execFileSync("whois", [domain], { timeout: 15000, encoding: "utf-8" });
} catch (error) {
const err = error;
raw = err.stdout || err.stderr || "";
if (!raw)
throw new Error(`whois command failed for ${domain}`);
}
const registrarMatch = raw.match(/Registrar:\s*(.+)/i) || raw.match(/registrar:\s*(.+)/i);
const registrar = registrarMatch ? registrarMatch[1].trim() : null;
const expiresMatch = raw.match(/Registry Expiry Date:\s*(.+)/i) || raw.match(/Expir(?:y|ation) Date:\s*(.+)/i) || raw.match(/paid-till:\s*(.+)/i);
let expires_at = null;
if (expiresMatch) {
try {
expires_at = new Date(expiresMatch[1].trim()).toISOString();
} catch {
expires_at = expiresMatch[1].trim();
}
}
const nsMatches = raw.matchAll(/Name Server:\s*(.+)/gi);
const nameservers = [];
for (const m of nsMatches) {
const ns = m[1].trim().toLowerCase();
if (ns && !nameservers.includes(ns))
nameservers.push(ns);
}
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = { whois: { raw } };
if (registrar)
updates.registrar = registrar;
if (expires_at)
updates.expires_at = expires_at;
if (nameservers.length > 0)
updates.nameservers = nameservers;
await store.updateDomain(existing.id, updates);
}
return {
domain,
registrar,
expires_at,
nameservers,
raw,
source: "cli",
registrant: { name: null, email: null, phone: null, organization: null }
};
}
var DNS_SERVERS = ["8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222"];
var DNS_SERVER_NAMES = {
"8.8.8.8": "Google",
"1.1.1.1": "Cloudflare",
"9.9.9.9": "Quad9",
"208.67.222.222": "OpenDNS"
};
function checkDnsPropagation(domain, recordType = "A") {
const queryName = normalizeDnsQueryName(domain);
const normalizedRecordType = normalizeDnsRecordType(recordType);
const servers = [];
for (const server of DNS_SERVERS) {
try {
const output = execFileSync("dig", [`@${server}`, queryName, normalizedRecordType, "+short", "+time=5", "+tries=1"], { timeout: 1e4, encoding: "utf-8" });
const values = output.trim().split(`
`).filter((l) => l.length > 0);
servers.push({
server,
name: DNS_SERVER_NAMES[server] || server,
values,
status: "ok"
});
} catch (error) {
servers.push({
server,
name: DNS_SERVER_NAMES[server] || server,
values: [],
status: "error",
error: error instanceof Error ? error.message : String(error)
});
}
}
const okServers = servers.filter((s) => s.status === "ok");
const consistent = okServers.length > 0 && okServers.every((s) => JSON.stringify(s.values.sort()) === JSON.stringify(okServers[0].values.sort()));
return { domain: queryName, record_type: normalizedRecordType, servers, consistent };
}
async function checkSsl(domainName) {
const domain = normalizeDomainName(domainName);
try {
const certificate = execFileSync("openssl", ["s_client", "-servername", domain, "-connect", `${domain}:443`], { timeout: 15000, encoding: "utf-8", input: `
`, stdio: ["pipe", "pipe", "ignore"] });
const output = execFileSync("openssl", ["x509", "-noout", "-issuer", "-dates", "-subject"], { timeout: 15000, encoding: "utf-8", input: certificate, stdio: ["pipe", "pipe", "ignore"] });
const issuerMatch = output.match(/issuer\s*=\s*(.+)/i);
const notAfterMatch = output.match(/notAfter\s*=\s*(.+)/i);
const subjectMatch = output.match(/subject\s*=\s*(.+)/i);
const issuer = issuerMatch ? issuerMatch[1].trim() : null;
const subject = subjectMatch ? subjectMatch[1].trim() : null;
let expires_at = null;
if (notAfterMatch) {
try {
expires_at = new Date(notAfterMatch[1].trim()).toISOString();
} catch {
expires_at = notAfterMatch[1].trim();
}
}
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = {};
if (expires_at)
updates.ssl_expires_at = expires_at;
if (issuer)
updates.ssl_issuer = issuer;
await store.updateDomain(existing.id, updates);
}
return { domain, issuer, expires_at, subject };
} catch (error) {
return {
domain,
issuer: null,
expires_at: null,
subject: null,
error: error instanceof Error ? error.message : String(error)
};
}
}
async function exportZoneFile(domainId) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const records = await store.listDnsRecords(domainId);
const lines = [];
lines.push(`; Zone file for ${domain.name}`);
lines.push(`; Exported at ${new Date().toISOString()}`);
lines.push(`$ORIGIN ${domain.name}.`);
lines.push(`$TTL 3600`);
lines.push("");
for (const r of records) {
const name = r.name === "@" ? domain.name + "." : r.name;
if (r.type === "MX" || r.type === "SRV") {
const priority = r.priority ?? 10;
lines.push(`${name} ${r.ttl} IN ${r.type} ${priority} ${r.value}`);
} else {
lines.push(`${name} ${r.ttl} IN ${r.type} ${r.value}`);
}
}
return lines.join(`
`) + `
`;
}
async function importZoneFile(domainId, content) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const result = { imported: 0, skipped: 0, errors: [], records: [] };
const lines = content.split(`
`);
const validTypes = new Set(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"]);
for (const rawLine of lines) {
const line = rawLine.trim();
if (!line || line.startsWith(";") || line.startsWith("$")) {
continue;
}
const parts = line.split(/\s+/);
if (parts.length < 4) {
result.errors.push(`Could not parse line: ${line}`);
result.skipped++;
continue;
}
let name = parts[0];
let idx = 1;
let ttl = 3600;
if (/^\d+$/.test(parts[idx])) {
ttl = parseInt(parts[idx]);
idx++;
}
if (parts[idx] && parts[idx].toUpperCase() === "IN") {
idx++;
}
const type = parts[idx]?.toUpperCase();
idx++;
if (!type || !validTypes.has(type)) {
result.errors.push(`Unknown record type '${type}' in: ${line}`);
result.skipped++;
continue;
}
let priority;
if (type === "MX" || type === "SRV") {
if (parts[idx] && /^\d+$/.test(parts[idx])) {
priority = parseInt(parts[idx]);
idx++;
}
}
const value = parts.slice(idx).join(" ");
if (!value) {
result.errors.push(`Missing value in: ${line}`);
result.skipped++;
continue;
}
if (name.endsWith("."))
name = name.slice(0, -1);
if (name === domain.name || name === "")
name = "@";
try {
const record = await store.createDnsRecord({
domain_id: domainId,
type,
name,
value,
ttl,
priority
});
result.records.push(record);
result.imported++;
} catch (error) {
result.errors.push(`Failed to create record: ${error instanceof Error ? error.message : String(error)}`);
result.skipped++;
}
}
return result;
}
async function discoverSubdomains(domain) {
try {
const url = `https://crt.sh/?q=%25.${encodeURIComponent(domain)}&output=json`;
const response = await fetch(url, {
signal: AbortSignal.timeout(15000),
headers: { "User-Agent": USER_AGENT }
});
if (!response.ok) {
return {
domain,
subdomains: [],
source: "crt.sh",
error: `crt.sh returned ${response.status}`
};
}
const data = await response.json();
const subdomainSet = new Set;
for (const entry of data) {
for (const field of [entry.common_name, entry.name_value]) {
if (!field)
continue;
for (const name of field.split(`
`)) {
const cleaned = name.trim().toLowerCase().replace(/^\*\./, "");
if (cleaned.endsWith(domain.toLowerCase()) && cleaned !== domain.toLowerCase()) {
subdomainSet.add(cleaned);
}
}
}
}
const subdomains = [...subdomainSet].sort();
return { domain, subdomains, source: "crt.sh" };
} catch (error) {
return {
domain,
subdomains: [],
source: "crt.sh",
error: error instanceof Error ? error.message : String(error)
};
}
}
async function validateDns(domainId) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const records = await store.listDnsRecords(domainId);
const issues = [];
const byName = new Map;
for (const r of records) {
const key = r.name.toLowerCase();
if (!byName.has(key))
byName.set(key, []);
byName.get(key).push(r);
}
for (const [name, recs] of byName) {
const hasCname = recs.some((r) => r.type === "CNAME");
const hasA = recs.some((r) => r.type === "A" || r.type === "AAAA");
const hasMx = recs.some((r) => r.type === "MX");
const hasNs = recs.some((r) => r.type === "NS");
if (hasCname && hasA) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with A/AAAA record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && hasMx) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with MX record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && hasNs) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with NS record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && recs.filter((r) => r.type === "CNAME").length > 1) {
issues.push({
type: "error",
message: `Multiple CNAME records at '${name}' \u2014 only one CNAME is allowed per name`
});
}
}
const rootRecords = byName.get("@") || [];
const hasMxAtRoot = rootRecords.some((r) => r.type === "MX");
if (!hasMxAtRoot && records.length > 0) {
issues.push({
type: "warning",
message: `No MX record found at root (@) \u2014 email delivery may not work for ${domain.name}`
});
}
for (const r of records) {
if (r.type === "CNAME") {
const target = r.value.toLowerCase().replace(/\.$/, "");
if (target.endsWith(domain.name.toLowerCase())) {
const targetName = target === domain.name.toLowerCase() ? "@" : target.replace(`.${domain.name.toLowerCase()}`, "");
const targetRecords = byName.get(targetName.toLowerCase());
if (!targetRecords || targetRecords.length === 0) {
issues.push({
type: "warning",
record_id: r.id,
message: `CNAME '${r.name}' points to '${r.value}' which has no records in this zone`
});
}
}
}
}
for (const r of records) {
if (r.type === "MX" && r.priority === null) {
issues.push({
type: "warning",
record_id: r.id,
message: `MX record '${r.name}' -> '${r.value}' has no priority set`
});
}
}
return {
domain_id: domainId,
domain_name: domain.name,
issues,
valid: issues.filter((i) => i.type === "error").length === 0
};
}
// src/db/monitoring.ts
async function exportPortfolio(format = "json") {
const domains = await getStore().listDomains();
if (format === "json") {
return JSON.stringify(domains.map((d) => ({
name: d.name,
registrar: d.registrar,
status: d.status,
registered_at: d.registered_at,
expires_at: d.expires_at,
auto_renew: d.auto_renew,
is_premium: d.is_premium,
premium_price: d.premium_price,
standard_price: d.standard_price,
purchase_price: d.purchase_price,
purchase_date: d.purchase_date,
nameservers: d.nameservers,
ssl_expires_at: d.ssl_expires_at,
ssl_issuer: d.ssl_issuer,
notes: d.notes
})), null, 2);
}
const headers = [
"name",
"registrar",
"status",
"registered_at",
"expires_at",
"auto_renew",
"is_premium",
"premium_price",
"standard_price",
"purchase_price",
"purchase_date",
"nameservers",
"ssl_expires_at",
"ssl_issuer",
"notes"
];
const rows = domains.map((d) => [
csvEscape(d.name),
csvEscape(d.registrar || ""),
csvEscape(d.status),
csvEscape(d.registered_at || ""),
csvEscape(d.expires_at || ""),
d.auto_renew ? "true" : "false",
d.is_premium ? "true" : "false",
csvEscape(d.premium_price?.toString() || ""),
csvEscape(d.standard_price?.toString() || ""),
csvEscape(d.purchase_price?.toString() || ""),
csvEscape(d.purchase_date || ""),
csvEscape(d.nameservers.join("; ")),
csvEscape(d.ssl_expires_at || ""),
csvEscape(d.ssl_issuer || ""),
csvEscape(d.notes || "")
].join(","));
return [headers.join(","), ...rows].join(`
`) + `
`;
}
function csvEscape(value) {
if (value.includes(",") || value.includes('"') || value.includes(`
`)) {
return `"${value.replace(/"/g, '""')}"`;
}
return value;
}
var liveBulkCheckDependencies = {
whoisLookup,
checkSsl,
validateDns
};
async function checkAllDomains(dependencies = liveBulkCheckDependencies) {
const domains = await getStore().listDomains();
const results = [];
for (const domain of domains) {
const result = {
domain: domain.name,
domain_id: domain.id
};
try {
const whois = await dependencies.whoisLookup(domain.name);
result.whois = {
registrar: whois.registrar,
expires_at: whois.expires_at
};
} catch (error) {
result.whois = {
registrar: null,
expires_at: null,
error: error instanceof Error ? error.message : String(error)
};
}
try {
const ssl = await dependencies.checkSsl(domain.name);
result.ssl = {
issuer: ssl.issuer,
expires_at: ssl.expires_at,
error: ssl.error
};
} catch (error) {
result.ssl = {
issuer: null,
expires_at: null,
error: error instanceof Error ? error.message : String(error)
};
}
const validation = await dependencies.validateDns(domain.id);
if (validation) {
result.dns_validation = {
valid: validation.valid,
issue_count: validation.issues.length,
errors: validation.issues.map((i) => `[${i.type}] ${i.message}`)
};
}
results.push(result);
}
return results;
}
// src/db/domains.ts
function createDomain(input) {
return getStore().createDomain(input);
}
function getDomain(id) {
return getStore().getDomain(id);
}
function getDomainByName(name) {
return getStore().getDomainByName(name);
}
function getDomainByIdentifier(identifier) {
return getStore().getDomainByIdentifier(identifier);
}
function getDomainDetails(identifier) {
return getStore().getDomainDetails(identifier);
}
function listDomains(options = {}) {
return getStore().listDomains(options);
}
function updateDomain(id, input) {
return getStore().updateDomain(id, input);
}
function deleteDomain(id) {
return getStore().deleteDomain(id);
}
function countDomains() {
return getStore().countDomains();
}
function searchDomains(query) {
return getStore().searchDomains(query);
}
function getByRegistrar(registrar) {
return getStore().getByRegistrar(registrar);
}
function listExpiring(days, options) {
return getStore().listExpiring(days, options);
}
function listSslExpiring(days, options) {
return getStore().listSslExpiring(days, options);
}
function getDomainStats() {
return getStore().getDomainStats();
}
function markDomainPremium(identifier, premiumPrice, standardPrice) {
return getStore().markDomainPremium(identifier, premiumPrice, standardPrice);
}
function updateDomainLifecycleStatus(identifier, status, notes) {
return getStore().updateDomainLifecycleStatus(identifier, status, notes);
}
function recordDomainPurchase(identifier, input) {
return getStore().recordDomainPurchase(identifier, input);
}
function createDomainOffer(input) {
return getStore().createDomainOffer(input);
}
function getDomainOffer(id) {
return getStore().getDomainOffer(id);
}
function listDomainOffers(domainId) {
return getStore().listDomainOffers(domainId);
}
function linkDomainEmail(input) {
return getStore().linkDomainEmail(input);
}
function getDomainEmailLink(id) {
return getStore().getDomainEmailLink(id);
}
function listDomainEmailLinks(domainId) {
return getStore().listDomainEmailLinks(domainId);
}
function createDnsRecord(input) {
return getStore().createDnsRecord(input);
}
function getDnsRecord(id) {
return getStore().getDnsRecord(id);
}
function listDnsRecords(domainId, type) {
return getStore().listDnsRecords(domainId, type);
}
function updateDnsRecord(id, input) {
return getStore().updateDnsRecord(id, input);
}
function deleteDnsRecord(id) {
return getStore().deleteDnsRecord(id);
}
function createAlert(input) {
return getStore().createAlert(input);
}
function getAlert(id) {
return getStore().getAlert(id);
}
function listAlerts(domainId) {
return getStore().listAlerts(domainId);
}
function deleteAlert(id) {
return getStore().deleteAlert(id);
}
// src/db/domain-owners.ts
var DOMAIN_OWNER_SOURCES = ["whois", "manual", "brandsight", "import"];
function parseWhoisOwner(whoisData) {
let name = null;
let email = null;
let phone = null;
let org = null;
if (whoisData.trim().startsWith("{")) {
try {
const rdap = JSON.parse(whoisData);
const registrant = extractRegistrantFromRdapEntities(rdap);
name = registrant.name;
email = registrant.email;
phone = registrant.phone;
org = registrant.organization;
} catch {}
}
if (!name && !email && !org) {
const nameMatch = whoisData.match(/Registrant Name:\s*(.+)/i);
const emailMatch = whoisData.match(/Registrant Email:\s*(.+)/i);
const phoneMatch = whoisData.match(/Registrant Phone:\s*(.+)/i);
const orgMatch = whoisData.match(/Registrant Organization:\s*(.+)/i);
name = nameMatch?.[1]?.trim() ?? null;
email = emailMatch?.[1]?.trim() ?? null;
phone = phoneMatch?.[1]?.trim() ?? null;
org = orgMatch?.[1]?.trim() ?? null;
}
if (!name && !email && !org)
return null;
return { name, email, phone, organization: org };
}
function extractRegistrantFromRdapEntities(rdap) {
const result = { name: null, email: null, phone: null, organization: null };
const entities = rdap.entities;
if (!entities)
return result;
const findRegistrant = (ents) => {
for (const entity of ents) {
if (entity.roles?.some((r) => r === "registrant"))
return entity;
if (entity.entities) {
const found = findRegistrant(entity.entities);
if (found)
return found;
}
}
return null;
};
const registrant = findRegistrant(entities);
if (!registrant?.vcardArray)
return result;
const vcard = registrant.vcardArray[1];
if (!vcard || !Array.isArray(vcard))
return result;
for (const entry of vcard) {
if (!Array.isArray(entry) || entry.length < 3)
continue;
const [prop, _params, type] = entry;
if (prop === "fn")
result.name = type ?? null;
else if (prop === "email")
result.email = type ?? null;
else if (prop === "tel")
result.phone = type ?? null;
else if (prop === "org") {
result.organization = Array.isArray(type) ? type[0] ?? null : type ?? null;
} else if (prop === "n" && !result.name) {
const parts = Array.isArray(type) ? type.filter(Boolean) : [type];
result.name = parts.reverse().join(" ").trim() || null;
}
}
if (!result.name && registrant.handle) {
result.name = registrant.handle;
}
return result;
}
// src/db/owners.ts
function createDomainOwner(input) {
return getStore().createDomainOwner(input);
}
function getDomainOwner(id) {
return getStore().getDomainOwner(id);
}
function getDomainOwnerByDomain(domainId) {
return getStore().getDomainOwnerByDomain(domainId);
}
function getDomainOwnerByDomainName(domainName) {
return getStore().getDomainOwnerByDomainName(domainName);
}
function listDomainOwners(options = {}) {
return getStore().listDomainOwners(options);
}
function updateDomainOwner(id, input) {
return getStore().updateDomainOwner(id, input);
}
function deleteDomainOwner(id) {
return getStore().deleteDomainOwner(id);
}
function listDomainsWithOwners() {
return getStore().listDomainsWithOwners();
}
async function extractOwnerFromWhois(domainName, whoisData) {
const store = getStore();
const domain = await store.getDomainByIdentifier(domainName);
if (!domain)
return null;
const parsed = parseWhoisOwner(whoisData);
if (!parsed)
return null;
const existing = await store.getDomainOwnerByDomain(domain.id);
if (existing) {
return store.updateDomainOwner(existing.id, {
owner_name: parsed.name ?? existing.owner_name ?? undefined,
owner_email: parsed.email ?? existing.owner_email ?? undefined,
owner_phone: parsed.phone ?? existing.owner_phone ?? undefined,
owner_organization: parsed.organization ?? existing.owner_organization ?? undefined,
source: "whois"
});
}
return store.createDomainOwner({
domain_id: domain.id,
owner_name: parsed.name ?? undefined,
owner_email: parsed.email ?? undefined,
owner_phone: parsed.phone ?? undefined,
owner_organization: parsed.organization ?? undefined,
source: "whois"
});
}
async function linkOwnerToContacts(domainId, contactsDbFns) {
const store = getStore();
const owner = await store.getDomainOwnerByDomain(domainId);
if (!owner || !owner.owner_email)
return null;
const existing = contactsDbFns.getContactByEmail(owner.owner_email);
if (existing) {
await store.updateDomainOwner(owner.id, { contact_id: existing.id });
return existing.id;
}
const parts = (owner.owner_name || owner.owner_email.split("@")[0] || "Unknown").split(" ");
const first_name = parts[0] ?? "Unknown";
const last_name = parts.length > 1 ? parts.slice(1).join(" ") : undefined;
const notes = owner.owner_organization ? `Owner of domain via ${owner.owner_organization}` : `Domain owner (linked from open-domains)`;
const contact = contactsDbFns.createContact({
first_name,
last_name,
email: owner.owner_email,
phone: owner.owner_phone ?? undefined,
source: "manual",
notes
});
await store.updateDomainOwner(owner.id, { contact_id: contact.id });
return contact.id;
}
// src/db/domain-history.ts
var HISTORY_TYPES = [
"whois",
"rdap",
"dns",
"ssl",
"reputation",
"exa_research",
"purchase",
"renewal"
];
// src/db/history.ts
function createHistoryEntry(input) {
return getStore().createHistoryEntry(input);
}
function getHistoryEntry(id) {
return getStore().getHistoryEntry(id);
}
function getHistoryByDomain(domainId, options) {
return getStore().getHistoryByDomain(domainId, options);
}
function getLatestSnapshot(domainId, type) {
return getStore().getLatestSnapshot(domainId, type);
}
function getHistoryByDateRange(startDate, endDate, domainId) {
return getStore().getHistoryByDateRange(startDate, endDate, domainId);
}
function listDomainsWithHistoryChanges() {
return getStore().listDomainsWithHistoryChanges();
}
async function getLatestByDomainName(domainName, type) {
const store = getStore();
const domain = await store.getDomainByIdentifier(domainName);
if (!domain)
return null;
return store.getLatestSnapshot(domain.id, type ?? HISTORY_TYPES[0]);
}
function deleteHistoryEntry(id) {
return getStore().deleteHistoryEntry(id);
}
function deleteHistoryByDomain(domainId) {
return getStore().deleteHistoryByDomain(domainId);
}
// src/db/domain-reputation.ts
function checkDnsBlacklist(domainName) {
const result = { listed: false, zones: [], details: [] };
const zones = [
"zen.spamhaus.org",
"bl.spamcop.net",
"dnsbl.sorbs.net",
"b.barracudacentral.org"
];
return result;
}
// src/db/reputation.ts
function upsertDomainReputation(input) {
return getStore().upsertDomainReputation(input);
}
function getDomainReputation(domainId) {
return getStore().getDomainReputation(domainId);
}
function getDomainReputationByName(domainName) {
return getStore().getDomainReputationByName(domainName);
}
function updateDomainReputation(id, input) {
return getStore().updateDomainReputation(id, input);
}
function listBlacklistedDomains() {
return getStore().listBlacklistedDomains();
}
function listHighThreatDomains(threshold) {
return getStore().listHighThreatDomains(threshold);
}
function deleteDomainReputation(id) {
return getStore().deleteDomainReputation(id);
}
async function checkDomainReputation(domainName) {
const store = getStore();
const domain = await store.getDomainByIdentifier(domainName);
if (!domain)
throw new Error(`Domain '${domainName}' not found in database`);
const dnsBlacklist = checkDnsBlacklist(domainName);
const existing = await store.getDomainReputation(domain.id);
if (existing) {
await store.updateDomainReputation(existing.id, { last_checked_at: new Date().toISOString() });
}
await store.createHistoryEntry({
domain_id: domain.id,
snapshot_type: "reputation",
raw_data: { dns_blacklist: dnsBlacklist },
notes: dnsBlacklist.listed ? `Listed in: ${dnsBlacklist.zones.join(", ")}` : "Clean \u2014 no blacklist hits"
});
return { reputation: existing, dnsBlacklist };
}
// src/lib/namecheap.ts
function getConfig() {
const apiKey = process.env["NAMECHEAP_API_KEY"];
const username = process.env["NAMECHEAP_USERNAME"];
const clientIp = process.env["NAMECHEAP_CLIENT_IP"];
if (!apiKey)
throw new Error("NAMECHEAP_API_KEY environment variable is not set");
if (!username)
throw new Error("NAMECHEAP_USERNAME environment variable is not set");
if (!clientIp)
throw new Error("NAMECHEAP_CLIENT_IP environment variable is not set");
return {
apiKey,
username,
clientIp,
sandbox: process.env["NAMECHEAP_SANDBOX"] === "true"
};
}
async function apiRequest(config, command, params = {}) {
const base = config.sandbox ? "https://api.sandbox.namecheap.com/xml.response" : "https://api.namecheap.com/xml.response";
const url = new URL(base);
url.searchParams.set("ApiUser", config.username);
url.searchParams.set("ApiKey", config.apiKey);
url.searchParams.set("UserName", config.username);
url.searchParams.set("ClientIp", config.clientIp);
url.searchParams.set("Command", command);
for (const [k, v] of Object.entries(params)) {
url.searchParams.set(k, v);
}
const response = await fetch(url.toString(), {
signal: AbortSignal.timeout(30000)
});
if (!response.ok) {
throw new Error(`Namecheap API request failed with status ${response.status}`);
}
return response.text();
}
function parseXmlValue(xml, tag) {
const match = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, "i"));
return match ? match[1].trim() : null;
}
function parseXmlAttributes(xml, tag) {
const results = [];
const tagRegex = new RegExp(`<${tag}([^>]*)>`, "gi");
let match;
while ((match = tagRegex.exec(xml)) !== null) {
const attrs = {};
const attrStr = match[1];
const attrRegex = /(\w+)="([^"]*)"/g;
let attrMatch;
while ((attrMatch = attrRegex.exec(attrStr)) !== null) {
attrs[attrMatch[1]] = attrMatch[2];
}
results.push(attrs);
}
return results;
}
async function listNamecheapDomains(config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.getList", { PageSize: "100" });
const domainAttrs = parseXmlAttributes(xml, "Domain");
return domainAttrs.map((attrs) => ({
domain: attrs["Name"] || "",
expiry: attrs["Expires"] || "",
autoRenew: attrs["AutoRenew"] === "true",
isExpired: attrs["IsExpired"] === "true",
isLocked: attrs["IsLocked"] === "true"
}));
}
async function getDomainInfo(domain, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.getInfo", { DomainName: domain });
const created = parseXmlValue(xml, "CreatedDate") || "";
const expires = parseXmlValue(xml, "ExpiredDate") || "";
const nsAttrs = parseXmlAttributes(xml, "Nameserver");
const nameservers = nsAttrs.map((a) => a["NAME"] || "").filter(Boolean);
return {
domain,
registrar: "Namecheap",
created,
expires,
nameservers
};
}
async function renewDomain(domain, years = 1, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.renew", {
DomainName: domain,
Years: String(years)
});
const orderId = parseXmlValue(xml, "OrderId");
const chargedAmount = parseXmlValue(xml, "ChargedAmount");
return {
domain,
success: xml.includes('Status="OK"'),
orderId: orderId || undefined,
chargedAmount: chargedAmount || undefined
};
}
function namecheapContactParams(contact) {
const organization = contact.organization_name || "NA";
const base = {
FirstName: contact.first_name,
LastName: contact.last_name,
OrganizationName: organization,
Address1: contact.address_line_1,
City: contact.city,
StateProvince: contact.state,
PostalCode: contact.zip_code,
Country: contact.country_code,
Phone: contact.phone,
EmailAddress: contact.email
};
const params = {};
for (const prefix of ["Registrant", "Tech", "Admin", "AuxBilling"]) {
for (const [key, value] of Object.entries(base)) {
params[prefix + key] = value;
}
}
return params;
}
async function registerDomain(domain, contact, options = {}, config) {
const cfg = config || getConfig();
const params = {
DomainName: domain,
Years: String(options.years ?? 1),
AddFreeWhoisguard: options.whoisGuard === false ? "no" : "yes",
WGEnabled: options.whoisGuard === false ? "no" : "yes",
...namecheapContactParams(contact)
};
if (options.premiumPrice !== undefined) {
params.IsPremiumDomain = "true";
params.PremiumPrice = String(options.premiumPrice);
}
const xml = await apiRequest(cfg, "namecheap.domains.create", params);
return {
domain,
success: xml.includes('Status="OK"') || xml.includes('Registered="true"'),
orderId: parseXmlValue(xml, "OrderId") || undefined,
chargedAmount: parseXmlValue(xml, "ChargedAmount") || undefined
};
}
async function updateNameservers(domain, nameservers, config) {
if (nameservers.length === 0)
throw new Error("updateNameservers requires at least one nameserver");
const cfg = config || getConfig();
const { sld, tld } = splitDomain(domain);
const xml = await apiRequest(cfg, "namecheap.domains.dns.setCustom", {
SLD: sld,
TLD: tld,
Nameservers: nameservers.join(",")
});
return xml.includes('Status="OK"') || xml.includes('Updated="true"');
}
async function getDnsRecords(_domain, sld, tld, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.dns.getHosts", {
SLD: sld,
TLD: tld
});
const hostAttrs = parseXmlAttributes(xml, "host");
return hostAttrs.map((attrs) => ({
type: attrs["Type"] || "A",
name: attrs["Name"] || "@",
address: attrs["Address"] || "",
ttl: parseInt(attrs["TTL"] || "3600"),
mxPref: attrs["MXPref"] ? parseInt(attrs["MXPref"]) : undefined
}));
}
async function setDnsRecords(_domain, sld, tld, records, config) {
const cfg = config || getConfig();
const params = {
SLD: sld,
TLD: tld
};
records.forEach((r, i) => {
params[`HostName${i + 1}`] = r.name;
params[`RecordType${i + 1}`] = r.type;
params[`Address${i + 1}`] = r.address;
params[`TTL${i + 1}`] = String(r.ttl);
if (r.mxPref !== undefined) {
params[`MXPref${i + 1}`] = String(r.mxPref);
}
});
const xml = await apiRequest(cfg, "namecheap.domains.dns.setHosts", params);
return xml.includes('IsSuccess="true"');
}
async function checkAvailability(domain, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.check", { DomainList: domain });
const domainAttrs = parseXmlAttributes(xml, "DomainCheckResult");
const result = domainAttrs[0] || {};
return {
domain,
available: result["Available"] === "true",
premium: result["IsPremiumName"] === "true",
price: result["PremiumRegistrationPrice"] ? parseFloat(result["PremiumRegistrationPrice"]) : undefined
};
}
function splitDomain(domain) {
const parts = domain.split(".");
if (parts.length < 2) {
throw new Error(`Invalid domain: ${domain}`);
}
if (parts.length >= 3 && ["co", "com", "org", "net", "ac", "gov"].includes(parts[parts.length - 2])) {
return {
sld: parts.slice(0, -2).join("."),
tld: parts.slice(-2).join(".")
};
}
return {
sld: parts.slice(0, -1).join("."),
tld: parts[parts.length - 1]
};
}
async function syncToLocalDb(dbFunctions, config) {
const cfg = config || getConfig();
const result = { synced: 0, errors: [], domains: [] };
const syncedAt = new Date().toISOString();
let ncDomains;
try {
ncDomains = await listNamecheapDomains(cfg);
} catch (error) {
throw new Error(`Failed to list Namecheap domains: ${error instanceof Error ? error.message : String(error)}`);
}
for (const ncDomain of ncDomains) {
try {
let info;
try {
info = await getDomainInfo(ncDomain.domain, cfg);
} catch {
info = {
domain: ncDomain.domain,
registrar: "Namecheap",
created: "",
expires: ncDomain.expiry,
nameservers: []
};
}
const expiresAt = normalizeDate(info.expires || ncDomain.expiry);
const createdAt = normalizeDate(info.created);
const existing = await dbFunctions.getDomainByName(ncDomain.domain);
if (existing) {
await dbFunctions.updateDomain(existing.id, {
registrar: "Namecheap",
status: "active",
registered_at: createdAt || undefined,
expires_at: expiresAt || undefined,
auto_renew: ncDomain.autoRenew,
nameservers: info.nameservers.length > 0 ? info.nameservers : undefined,
expiry_synced_at: syncedAt
});
} else {
await dbFunctions.createDomain({
name: ncDomain.domain,
registrar: "Namecheap",
status: "active",
registered_at: createdAt || undefined,
expires_at: expiresAt || undefined,
auto_renew: ncDomain.autoRenew,
nameservers: info.nameservers,
expiry_synced_at: syncedAt
});
}
result.synced++;
result.domains.push(ncDomain.domain);
} catch (error) {
result.errors.push(`${ncDomain.domain}: ${error instanceof Error ? error.message : String(error)}`);
}
}
return result;
}
function normalizeDate(dateStr) {
if (!dateStr)
return null;
try {
const d = new Date(dateStr);
if (isNaN(d.getTime()))
return null;
return d.toISOString();
} catch {
return null;
}
}
// src/lib/godaddy.ts
class GoDaddyApiError extends Error {
statusCode;
details;
constructor(message, statusCode, details) {
super(message);
this.statusCode = statusCode;
this.details = details;
this.name = "GoDaddyApiError";
}
}
var _overriddenFetch = null;
function getCredentials() {
const apiKey = process.env["GODADDY_API_KEY"];
const apiSecret = process.env["GODADDY_API_SECRET"];
if (!apiKey || !apiSecret) {
throw new Error("GoDaddy API credentials not configured. Set GODADDY_API_KEY and GODADDY_API_SECRET environment variables.");
}
return { apiKey, apiSecret };
}
function getHeaders() {
const { apiKey, apiSecret } = getCredentials();
return {
Authorization: `sso-key ${apiKey}:${apiSecret}`,
"Content-Type": "application/json",
Accept: "application/json"
};
}
var GODADDY_API_BASE = "https://api.godaddy.com";
async function apiRequest2(method, path, body) {
const fetchFn = _overriddenFetch || globalThis.fetch;
const url = `${GODADDY_API_BASE}${path}`;
const headers = getHeaders();
const options = { method, headers };
if (body !== undefined) {
options.body = JSON.stringify(body);
}
const response = await fetchFn(url, options);
if (!response.ok) {
const text = await response.text();
throw new GoDaddyApiError(`GoDaddy API ${method} ${path} failed with status ${response.status}: ${text}`, response.status, { responseBody: text });
}
if (response.status === 204) {
return;
}
return await response.json();
}
async function listGoDaddyDomains() {
return apiRequest2("GET", "/v1/domains");
}
async function getDomainInfo2(domain) {
return apiRequest2("GET", `/v1/domains/${encodeURIComponent(domain)}`);
}
async function renewDomain2(domain) {
return apiRequest2("POST", `/v1/domains/${encodeURIComponent(domain)}/renew`, { period: 1 });
}
async function getDnsRecords2(domain, type) {
const path = type ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}` : `/v1/domains/${encodeURIComponent(domain)}/records`;
return apiRequest2("GET", path);
}
async function setDnsRecords2(domain, records) {
await apiRequest2("PUT", `/v1/domains/${encodeURIComponent(domain)}/records`, records);
}
async function checkAvailability2(domain) {
return apiRequest2("GET", `/v1/domains/available?domain=${encodeURIComponent(domain)}`);
}
function mapGoDaddyStatus(gdStatus) {
const s = gdStatus.toUpperCase();
if (s === "ACTIVE")
return "active";
if (s === "EXPIRED")
return "expired";
if (s === "TRANSFERRED_OUT" || s === "TRANSFERRING" || s === "PENDING_TRANSFER")
return "transferring";
if (s === "REDEMPTION" || s === "PENDING_REDEMPTION")
return "redemption";
return "active";
}
async function syncToLocalDb2(dbFns) {
const result = {
synced: 0,
created: 0,
updated: 0,
errors: []
};
let gdDomains;
try {
gdDomains = await listGoDaddyDomains();
} catch (err) {
result.errors.push(`Failed to list domains: ${err instanceof Error ? err.message : String(err)}`);
return result;
}
const syncedAt = new Date().toISOString();
for (const gd of gdDomains) {
try {
let detail;
try {
detail = await getDomainInfo2(gd.domain);
} catch {
detail = gd;
}
const existing = await dbFns.getDomainByName(gd.domain);
const domainData = {
name: gd.domain,
registrar: "GoDaddy",
status: mapGoDaddyStatus(gd.status),
expires_at: gd.expires ? new Date(gd.expires).toISOString() : undefined,
auto_renew: gd.renewAuto,
nameservers: gd.nameServers || [],
registered_at: detail.createdAt ? new Date(detail.createdAt).toISOString() : undefined,
expiry_synced_at: syncedAt,
metadata: {
godaddy_domain_id: detail.domainId,
provider: "godaddy",
locked: detail.locked,
privacy: detail.privacy
}
};
if (existing) {
await dbFns.updateDomain(existing.id, domainData);
result.updated++;
} else {
await dbFns.createDomain(domainData);
result.created++;
}
result.synced++;
} catch (err) {
result.errors.push(`Failed to sync ${gd.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return result;
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/Route53Client.js
var import_client24 = __toESM(require_client2());
var import_core = __toESM(require_dist_cjs2());
var import_client25 = __toESM(require_client());
var import_config29 = __toESM(require_config());
var import_endpoints3 = __toESM(require_endpoints());
var import_protocols7 = __toESM(require_protocols());
var import_retry4 = __toESM(require_retry());
var import_schema2 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/auth/httpAuthSchemeProvider.js
var import_httpAuthSchemes = __toESM(require_httpAuthSchemes());
var import_client3 = __toESM(require_client());
var defaultRoute53HttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: import_client3.getSmithyContext(context).operation,
region: await import_client3.normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "route53",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
var defaultRoute53HttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = import_httpAuthSchemes.resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: import_client3.normalizeProvider(config.authSchemePreference ?? [])
});
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "route53"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/package.json
var package_default = {
name: "@aws-sdk/client-route-53",
version: "3.1127.0",
description: "AWS SDK for JavaScript Route 53 Client for Node.js, Browser and React Native",
homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-route-53",
license: "Apache-2.0",
author: {
name: "AWS SDK for JavaScript Team",
url: "https://aws.amazon.com/sdk-for-javascript/"
},
repository: {
type: "git",
url: "https://github.com/aws/aws-sdk-js-v3.git",
directory: "clients/client-route-53"
},
files: [
"dist-*/**"
],
sideEffects: false,
main: "./dist-cjs/index.js",
module: "./dist-es/index.js",
browser: {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
},
types: "./dist-types/index.d.ts",
typesVersions: {
"<4.5": {
"dist-types/*": [
"dist-types/ts3.4/*"
]
}
},
"react-native": {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
},
scripts: {
build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
"build:cjs": "node ../../scripts/compilation/inline",
"build:es": "premove dist-es && tsc -p tsconfig.es.json",
"build:include:deps": 'yarn g:turbo run build -F="$npm_package_name"',
"build:types": "premove dist-types && tsc -p tsconfig.types.json",
"build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
clean: "premove dist-cjs dist-es dist-types",
"extract:docs": "api-extractor run --local",
"generate:client": "node ../../scripts/generate-clients/single-service",
test: "yarn g:vitest run --passWithNoTests",
"test:watch": "yarn g:vitest watch --passWithNoTests",
"test:integration": "yarn g:vitest run --passWithNoTests -c vitest.config.integ.mts",
"test:integration:watch": "yarn g:vitest watch --passWithNoTests -c vitest.config.integ.mts",
"test:e2e": "yarn g:vitest run -c vitest.config.e2e.mts",
"test:e2e:watch": "yarn g:vitest watch -c vitest.config.e2e.mts",
"test:index": "tsc -p tsconfig.test.json && node ./test/index-objects.spec.mjs"
},
dependencies: {
"@aws-sdk/core": "^3.977.9",
"@aws-sdk/credential-provider-node": "^3.972.82",
"@aws-sdk/middleware-sdk-route53": "^3.972.26",
"@aws-sdk/types": "^3.974.5",
"@smithy/core": "^3.33.3",
"@smithy/fetch-http-handler": "^5.7.2",
"@smithy/node-http-handler": "^4.11.3",
"@smithy/types": "^4.17.2",
tslib: "^2.6.2"
},
devDependencies: {
"@smithy/snapshot-testing": "^2.3.2",
"@tsconfig/node20": "20.1.8",
"@types/node": "^20.14.8",
concurrently: "7.0.0",
"downlevel-dts": "0.10.1",
premove: "4.0.0",
typescript: "~7.0.2",
vitest: "^4.0.17"
},
engines: {
node: ">=20.0.0"
}
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var import_client20 = __toESM(require_client2());
var import_httpAuthSchemes3 = __toESM(require_httpAuthSchemes());
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
init_dist_es();
var import_config27 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
var import_config10 = __toESM(require_config());
var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
var remoteProvider = async (init) => {
await Promise.resolve().then(() => init_dist_es2());
if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
await Promise.resolve().then(() => init_dist_es3());
return import_config10.chain(fromHttp(init), fromContainerMetadata(init));
}
if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
return async () => {
throw new import_config10.CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger });
};
}
init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
return fromInstanceMetadata(init);
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/runtime/memoize-chain.js
function memoizeChain(providers, treatAsExpired) {
const chain = internalCreateChain(providers);
let activeLock;
let passiveLock;
let credentials;
let forceRefreshLock;
const provider = async (options) => {
if (options?.forceRefresh) {
if (!forceRefreshLock) {
forceRefreshLock = chain(options).then((c) => {
credentials = c;
}).finally(() => {
forceRefreshLock = undefined;
});
}
await forceRefreshLock;
return credentials;
}
if (credentials?.expiration) {
if (credentials?.expiration?.getTime() < Date.now()) {
credentials = undefined;
}
}
if (activeLock) {
await activeLock;
} else if (!credentials || treatAsExpired?.(credentials)) {
if (credentials) {
if (!passiveLock) {
passiveLock = chain(options).then((c) => {
credentials = c;
}).catch(() => {}).finally(() => {
passiveLock = undefined;
});
}
} else {
activeLock = chain(options).then((c) => {
credentials = c;
}).finally(() => {
activeLock = undefined;
});
return provider(options);
}
}
return credentials;
};
return provider;
}
var internalCreateChain = (providers) => async (awsIdentityProperties) => {
let lastProviderError;
for (const provider of providers) {
try {
return await provider(awsIdentityProperties);
} catch (err) {
lastProviderError = err;
if (err?.tryNextLink) {
continue;
}
throw err;
}
}
throw lastProviderError;
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
var multipleCredentialSourceWarningEmitted = false;
var defaultProvider = (init = {}) => memoizeChain([
async () => {
const profile = init.profile ?? process.env[import_config27.ENV_PROFILE];
if (profile) {
const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
if (envStaticCredentialsAreSet) {
if (!multipleCredentialSourceWarningEmitted) {
const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn.bind(init.logger) : console.warn;
warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
Multiple credential sources detected:
Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
This SDK will proceed with the AWS_PROFILE value.
However, a future version may change this behavior to prefer the ENV static credentials.
Please ensure that your environment only sets either the AWS_PROFILE or the
AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
`);
multipleCredentialSourceWarningEmitted = true;
}
}
throw new import_config27.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
logger: init.logger,
tryNextLink: true
});
}
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
return fromEnv(init)();
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
throw new import_config27.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger });
}
await Promise.resolve().then(() => init_dist_es5());
return fromSSO(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
await Promise.resolve().then(() => init_dist_es9());
return fromIni(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
await Promise.resolve().then(() => init_dist_es7());
return fromProcess(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
await Promise.resolve().then(() => init_dist_es8());
return fromTokenFile(init)(awsIdentityProperties);
},
async () => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
return (await remoteProvider(init))();
},
async () => {
throw new import_config27.CredentialsProviderError("Could not load credentials from any providers", {
tryNextLink: false,
logger: init.logger
});
}
], credentialsTreatedAsExpired);
var credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== undefined && credentials.expiration.getTime() - Date.now() < 300000;
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var import_client21 = __toESM(require_client());
var import_config28 = __toESM(require_config());
var import_retry3 = __toESM(require_retry());
var import_serde4 = __toESM(require_serde());
var import_node_http_handler2 = __toESM(require_dist_cjs4());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.shared.js
var import_httpAuthSchemes2 = __toESM(require_httpAuthSchemes());
var import_protocols4 = __toESM(require_protocols2());
var import_checksum = __toESM(require_checksum());
var import_client19 = __toESM(require_client());
var import_protocols5 = __toESM(require_protocols());
var import_serde3 = __toESM(require_serde());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/endpointResolver.js
var import_client17 = __toESM(require_client2());
var import_endpoints2 = __toESM(require_endpoints());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/bdd.js
var import_endpoints = __toESM(require_endpoints());
var s = "ref";
var t2 = "authSchemes";
var u = "name";
var v = "signingRegion";
var a2 = -1;
var b2 = true;
var c2 = "isSet";
var d2 = "PartitionResult";
var e3 = "booleanEquals";
var f2 = "stringEquals";
var g2 = "getAttr";
var h2 = "sigv4";
var i2 = { [s]: "Endpoint" };
var j2 = { fn: g2, argv: [{ [s]: d2 }, "name"] };
var k2 = { [s]: d2 };
var l = { [t2]: [{ [u]: h2, [v]: "us-east-1" }] };
var m = { [t2]: [{ [u]: h2, [v]: "cn-northwest-1" }] };
var n2 = { [t2]: [{ [u]: h2, [v]: "us-gov-west-1" }] };
var o2 = { [t2]: [{ [u]: h2, [v]: "eusc-de-east-1" }] };
var p = { [t2]: [{ [u]: h2, [v]: "{PartitionResult#implicitGlobalRegion}" }] };
var q2 = [{ [s]: "Region" }];
var _data2 = {
conditions: [
[c2, [i2]],
[c2, q2],
["aws.partition", q2, d2],
[e3, [{ [s]: "UseFIPS" }, b2]],
[f2, [j2, "aws"]],
[f2, [j2, "aws-cn"]],
[f2, [j2, "aws-us-gov"]],
[e3, [{ [s]: "UseDualStack" }, b2]],
[e3, [{ fn: g2, argv: [k2, "supportsFIPS"] }, b2]],
[f2, [j2, "aws-iso"]],
[f2, [j2, "aws-iso-b"]],
[f2, [j2, "aws-iso-e"]],
[f2, [j2, "aws-iso-f"]],
[f2, [j2, "aws-eusc"]],
[e3, [{ fn: g2, argv: [k2, "supportsDualStack"] }, b2]]
],
results: [
[a2],
[a2, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a2, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[i2, {}],
["https://route53.amazonaws.com", l],
["https://route53-fips.amazonaws.com", l],
["https://route53.global.api.aws", l],
["https://route53-fips.global.api.aws", l],
["https://route53.amazonaws.com.cn", m],
["https://route53.global.api.amazonwebservices.com.cn", m],
["https://route53.us-gov.amazonaws.com", n2],
["https://route53.us-gov.api.aws", n2],
["https://route53.c2s.ic.gov", { [t2]: [{ [u]: h2, [v]: "us-iso-east-1" }] }],
["https://route53.sc2s.sgov.gov", { [t2]: [{ [u]: h2, [v]: "us-isob-east-1" }] }],
["https://route53.cloud.adc-e.uk", { [t2]: [{ [u]: h2, [v]: "eu-isoe-west-1" }] }],
["https://route53.csp.hci.ic.gov", { [t2]: [{ [u]: h2, [v]: "us-isof-south-1" }] }],
["https://route53.amazonaws.eu", o2],
["https://route53.global.api.amazonwebservices.eu", o2],
["https://route53-fips.{PartitionResult#dualStackDnsSuffix}", p],
[a2, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://route53-fips.{PartitionResult#dnsSuffix}", p],
[a2, "FIPS is enabled but this partition does not support FIPS"],
["https://route53.{PartitionResult#dualStackDnsSuffix}", p],
[a2, "DualStack is enabled but this partition does not support DualStack"],
["https://route53.{PartitionResult#dnsSuffix}", p],
[a2, "Invalid Configuration: Missing Region"]
]
};
var root2 = 2;
var r3 = 1e8;
var nodes2 = new Int32Array([
-1,
1,
-1,
0,
27,
3,
1,
4,
r3 + 25,
2,
5,
r3 + 25,
3,
19,
6,
4,
18,
7,
5,
17,
8,
6,
25,
9,
7,
15,
10,
9,
r3 + 12,
11,
10,
r3 + 13,
12,
11,
r3 + 14,
13,
12,
r3 + 15,
14,
13,
r3 + 16,
r3 + 24,
13,
r3 + 17,
16,
14,
r3 + 22,
r3 + 23,
7,
r3 + 9,
r3 + 8,
7,
r3 + 6,
r3 + 4,
4,
26,
20,
6,
25,
21,
7,
23,
22,
8,
r3 + 20,
r3 + 21,
8,
24,
r3 + 19,
14,
r3 + 18,
r3 + 19,
7,
r3 + 11,
r3 + 10,
7,
r3 + 7,
r3 + 5,
3,
r3 + 1,
28,
7,
r3 + 2,
r3 + 3
]);
var bdd2 = import_endpoints.BinaryDecisionDiagram.from(nodes2, root2, _data2.conditions, _data2.results);
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/endpointResolver.js
var cache2 = new import_endpoints2.EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver2 = (endpointParams, context = {}) => {
return cache2.get(endpointParams, () => import_endpoints2.decideEndpoint(bdd2, {
endpointParams,
logger: context.logger
}));
};
import_endpoints2.customEndpointFunctions.aws = import_client17.awsEndpointFunctions;
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/schemas/schemas_0.js
var import_schema = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/models/Route53ServiceException.js
var import_client18 = __toESM(require_client());
class Route53ServiceException extends import_client18.ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, Route53ServiceException.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/models/errors.js
class ConcurrentModification extends Route53ServiceException {
name = "ConcurrentModification";
$fault = "client";
constructor(opts) {
super({
name: "ConcurrentModification",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConcurrentModification.prototype);
}
}
class InvalidInput extends Route53ServiceException {
name = "InvalidInput";
$fault = "client";
constructor(opts) {
super({
name: "InvalidInput",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidInput.prototype);
}
}
class InvalidKeySigningKeyStatus extends Route53ServiceException {
name = "InvalidKeySigningKeyStatus";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKeySigningKeyStatus",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKeySigningKeyStatus.prototype);
}
}
class InvalidKMSArn extends Route53ServiceException {
name = "InvalidKMSArn";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKMSArn",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKMSArn.prototype);
}
}
class InvalidSigningStatus extends Route53ServiceException {
name = "InvalidSigningStatus";
$fault = "client";
constructor(opts) {
super({
name: "InvalidSigningStatus",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidSigningStatus.prototype);
}
}
class NoSuchKeySigningKey extends Route53ServiceException {
name = "NoSuchKeySigningKey";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchKeySigningKey",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchKeySigningKey.prototype);
}
}
class ConflictingDomainExists extends Route53ServiceException {
name = "ConflictingDomainExists";
$fault = "client";
constructor(opts) {
super({
name: "ConflictingDomainExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConflictingDomainExists.prototype);
}
}
class InvalidVPCId extends Route53ServiceException {
name = "InvalidVPCId";
$fault = "client";
constructor(opts) {
super({
name: "InvalidVPCId",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidVPCId.prototype);
}
}
class LimitsExceeded extends Route53ServiceException {
name = "LimitsExceeded";
$fault = "client";
constructor(opts) {
super({
name: "LimitsExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, LimitsExceeded.prototype);
}
}
class NoSuchHostedZone extends Route53ServiceException {
name = "NoSuchHostedZone";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchHostedZone",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchHostedZone.prototype);
}
}
class NotAuthorizedException extends Route53ServiceException {
name = "NotAuthorizedException";
$fault = "client";
constructor(opts) {
super({
name: "NotAuthorizedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NotAuthorizedException.prototype);
}
}
class PriorRequestNotComplete extends Route53ServiceException {
name = "PriorRequestNotComplete";
$fault = "client";
constructor(opts) {
super({
name: "PriorRequestNotComplete",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PriorRequestNotComplete.prototype);
}
}
class PublicZoneVPCAssociation extends Route53ServiceException {
name = "PublicZoneVPCAssociation";
$fault = "client";
constructor(opts) {
super({
name: "PublicZoneVPCAssociation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PublicZoneVPCAssociation.prototype);
}
}
class CidrBlockInUseException extends Route53ServiceException {
name = "CidrBlockInUseException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrBlockInUseException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrBlockInUseException.prototype);
this.Message = opts.Message;
}
}
class CidrCollectionVersionMismatchException extends Route53ServiceException {
name = "CidrCollectionVersionMismatchException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionVersionMismatchException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionVersionMismatchException.prototype);
this.Message = opts.Message;
}
}
class NoSuchCidrCollectionException extends Route53ServiceException {
name = "NoSuchCidrCollectionException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "NoSuchCidrCollectionException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCidrCollectionException.prototype);
this.Message = opts.Message;
}
}
class InvalidChangeBatch extends Route53ServiceException {
name = "InvalidChangeBatch";
$fault = "client";
messages;
constructor(opts) {
super({
name: "InvalidChangeBatch",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidChangeBatch.prototype);
this.messages = opts.messages;
}
}
class NoSuchHealthCheck extends Route53ServiceException {
name = "NoSuchHealthCheck";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchHealthCheck",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchHealthCheck.prototype);
}
}
class ThrottlingException extends Route53ServiceException {
name = "ThrottlingException";
$fault = "client";
constructor(opts) {
super({
name: "ThrottlingException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ThrottlingException.prototype);
}
}
class CidrCollectionAlreadyExistsException extends Route53ServiceException {
name = "CidrCollectionAlreadyExistsException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionAlreadyExistsException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionAlreadyExistsException.prototype);
this.Message = opts.Message;
}
}
class HealthCheckAlreadyExists extends Route53ServiceException {
name = "HealthCheckAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckAlreadyExists.prototype);
}
}
class TooManyHealthChecks extends Route53ServiceException {
name = "TooManyHealthChecks";
$fault = "client";
constructor(opts) {
super({
name: "TooManyHealthChecks",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyHealthChecks.prototype);
}
}
class DelegationSetNotAvailable extends Route53ServiceException {
name = "DelegationSetNotAvailable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetNotAvailable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetNotAvailable.prototype);
}
}
class DelegationSetNotReusable extends Route53ServiceException {
name = "DelegationSetNotReusable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetNotReusable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetNotReusable.prototype);
}
}
class HostedZoneAlreadyExists extends Route53ServiceException {
name = "HostedZoneAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneAlreadyExists.prototype);
}
}
class InvalidDomainName extends Route53ServiceException {
name = "InvalidDomainName";
$fault = "client";
constructor(opts) {
super({
name: "InvalidDomainName",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidDomainName.prototype);
}
}
class NoSuchDelegationSet extends Route53ServiceException {
name = "NoSuchDelegationSet";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchDelegationSet",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchDelegationSet.prototype);
}
}
class TooManyHostedZones extends Route53ServiceException {
name = "TooManyHostedZones";
$fault = "client";
constructor(opts) {
super({
name: "TooManyHostedZones",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyHostedZones.prototype);
}
}
class InvalidArgument extends Route53ServiceException {
name = "InvalidArgument";
$fault = "client";
constructor(opts) {
super({
name: "InvalidArgument",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidArgument.prototype);
}
}
class InvalidKeySigningKeyName extends Route53ServiceException {
name = "InvalidKeySigningKeyName";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKeySigningKeyName",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKeySigningKeyName.prototype);
}
}
class KeySigningKeyAlreadyExists extends Route53ServiceException {
name = "KeySigningKeyAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyAlreadyExists.prototype);
}
}
class TooManyKeySigningKeys extends Route53ServiceException {
name = "TooManyKeySigningKeys";
$fault = "client";
constructor(opts) {
super({
name: "TooManyKeySigningKeys",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyKeySigningKeys.prototype);
}
}
class InsufficientCloudWatchLogsResourcePolicy extends Route53ServiceException {
name = "InsufficientCloudWatchLogsResourcePolicy";
$fault = "client";
constructor(opts) {
super({
name: "InsufficientCloudWatchLogsResourcePolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InsufficientCloudWatchLogsResourcePolicy.prototype);
}
}
class NoSuchCloudWatchLogsLogGroup extends Route53ServiceException {
name = "NoSuchCloudWatchLogsLogGroup";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchCloudWatchLogsLogGroup",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCloudWatchLogsLogGroup.prototype);
}
}
class QueryLoggingConfigAlreadyExists extends Route53ServiceException {
name = "QueryLoggingConfigAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "QueryLoggingConfigAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, QueryLoggingConfigAlreadyExists.prototype);
}
}
class DelegationSetAlreadyCreated extends Route53ServiceException {
name = "DelegationSetAlreadyCreated";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetAlreadyCreated",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetAlreadyCreated.prototype);
}
}
class DelegationSetAlreadyReusable extends Route53ServiceException {
name = "DelegationSetAlreadyReusable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetAlreadyReusable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetAlreadyReusable.prototype);
}
}
class HostedZoneNotFound extends Route53ServiceException {
name = "HostedZoneNotFound";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotFound.prototype);
}
}
class InvalidTrafficPolicyDocument extends Route53ServiceException {
name = "InvalidTrafficPolicyDocument";
$fault = "client";
constructor(opts) {
super({
name: "InvalidTrafficPolicyDocument",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidTrafficPolicyDocument.prototype);
}
}
class TooManyTrafficPolicies extends Route53ServiceException {
name = "TooManyTrafficPolicies";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicies",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicies.prototype);
}
}
class TrafficPolicyAlreadyExists extends Route53ServiceException {
name = "TrafficPolicyAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyAlreadyExists.prototype);
}
}
class NoSuchTrafficPolicy extends Route53ServiceException {
name = "NoSuchTrafficPolicy";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchTrafficPolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchTrafficPolicy.prototype);
}
}
class TooManyTrafficPolicyInstances extends Route53ServiceException {
name = "TooManyTrafficPolicyInstances";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicyInstances",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicyInstances.prototype);
}
}
class TrafficPolicyInstanceAlreadyExists extends Route53ServiceException {
name = "TrafficPolicyInstanceAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyInstanceAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyInstanceAlreadyExists.prototype);
}
}
class TooManyTrafficPolicyVersionsForCurrentPolicy extends Route53ServiceException {
name = "TooManyTrafficPolicyVersionsForCurrentPolicy";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicyVersionsForCurrentPolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicyVersionsForCurrentPolicy.prototype);
}
}
class TooManyVPCAssociationAuthorizations extends Route53ServiceException {
name = "TooManyVPCAssociationAuthorizations";
$fault = "client";
constructor(opts) {
super({
name: "TooManyVPCAssociationAuthorizations",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyVPCAssociationAuthorizations.prototype);
}
}
class KeySigningKeyInParentDSRecord extends Route53ServiceException {
name = "KeySigningKeyInParentDSRecord";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyInParentDSRecord",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyInParentDSRecord.prototype);
}
}
class KeySigningKeyInUse extends Route53ServiceException {
name = "KeySigningKeyInUse";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyInUse.prototype);
}
}
class CidrCollectionInUseException extends Route53ServiceException {
name = "CidrCollectionInUseException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionInUseException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionInUseException.prototype);
this.Message = opts.Message;
}
}
class HealthCheckInUse extends Route53ServiceException {
name = "HealthCheckInUse";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckInUse.prototype);
}
}
class HostedZoneNotEmpty extends Route53ServiceException {
name = "HostedZoneNotEmpty";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotEmpty",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotEmpty.prototype);
}
}
class NoSuchQueryLoggingConfig extends Route53ServiceException {
name = "NoSuchQueryLoggingConfig";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchQueryLoggingConfig",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchQueryLoggingConfig.prototype);
}
}
class DelegationSetInUse extends Route53ServiceException {
name = "DelegationSetInUse";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetInUse.prototype);
}
}
class TrafficPolicyInUse extends Route53ServiceException {
name = "TrafficPolicyInUse";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyInUse.prototype);
}
}
class NoSuchTrafficPolicyInstance extends Route53ServiceException {
name = "NoSuchTrafficPolicyInstance";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchTrafficPolicyInstance",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchTrafficPolicyInstance.prototype);
}
}
class VPCAssociationAuthorizationNotFound extends Route53ServiceException {
name = "VPCAssociationAuthorizationNotFound";
$fault = "client";
constructor(opts) {
super({
name: "VPCAssociationAuthorizationNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, VPCAssociationAuthorizationNotFound.prototype);
}
}
class DNSSECNotFound extends Route53ServiceException {
name = "DNSSECNotFound";
$fault = "client";
constructor(opts) {
super({
name: "DNSSECNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DNSSECNotFound.prototype);
}
}
class LastVPCAssociation extends Route53ServiceException {
name = "LastVPCAssociation";
$fault = "client";
constructor(opts) {
super({
name: "LastVPCAssociation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, LastVPCAssociation.prototype);
}
}
class VPCAssociationNotFound extends Route53ServiceException {
name = "VPCAssociationNotFound";
$fault = "client";
constructor(opts) {
super({
name: "VPCAssociationNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, VPCAssociationNotFound.prototype);
}
}
class HostedZonePartiallyDelegated extends Route53ServiceException {
name = "HostedZonePartiallyDelegated";
$fault = "client";
constructor(opts) {
super({
name: "HostedZonePartiallyDelegated",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZonePartiallyDelegated.prototype);
}
}
class KeySigningKeyWithActiveStatusNotFound extends Route53ServiceException {
name = "KeySigningKeyWithActiveStatusNotFound";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyWithActiveStatusNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyWithActiveStatusNotFound.prototype);
}
}
class NoSuchChange extends Route53ServiceException {
name = "NoSuchChange";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchChange",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchChange.prototype);
}
}
class NoSuchGeoLocation extends Route53ServiceException {
name = "NoSuchGeoLocation";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchGeoLocation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchGeoLocation.prototype);
}
}
class IncompatibleVersion extends Route53ServiceException {
name = "IncompatibleVersion";
$fault = "client";
constructor(opts) {
super({
name: "IncompatibleVersion",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IncompatibleVersion.prototype);
}
}
class HostedZoneNotPrivate extends Route53ServiceException {
name = "HostedZoneNotPrivate";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotPrivate",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotPrivate.prototype);
}
}
class NoSuchCidrLocationException extends Route53ServiceException {
name = "NoSuchCidrLocationException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "NoSuchCidrLocationException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCidrLocationException.prototype);
this.Message = opts.Message;
}
}
class InvalidPaginationToken extends Route53ServiceException {
name = "InvalidPaginationToken";
$fault = "client";
constructor(opts) {
super({
name: "InvalidPaginationToken",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidPaginationToken.prototype);
}
}
class HealthCheckVersionMismatch extends Route53ServiceException {
name = "HealthCheckVersionMismatch";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckVersionMismatch",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckVersionMismatch.prototype);
}
}
class ConflictingTypes extends Route53ServiceException {
name = "ConflictingTypes";
$fault = "client";
constructor(opts) {
super({
name: "ConflictingTypes",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConflictingTypes.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/schemas/schemas_0.js
var _A = "Action";
var _AI = "AlarmIdentifier";
var _AKSK = "ActivateKeySigningKey";
var _AKSKR = "ActivateKeySigningKeyRequest";
var _AKSKRc = "ActivateKeySigningKeyResponse";
var _AL = "AccountLimit";
var _AR = "AcceleratedRecovery";
var _ARS = "AcceleratedRecoveryStatus";
var _AT = "AliasTarget";
var _ATd = "AddTags";
var _AVPCWHZ = "AssociateVPCWithHostedZone";
var _AVPCWHZR = "AssociateVPCWithHostedZoneRequest";
var _AVPCWHZRs = "AssociateVPCWithHostedZoneResponse";
var _AWSR = "AWSRegion";
var _Ar = "Arn";
var _B = "Bias";
var _C = "Comment";
var _CB = "ChangeBatch";
var _CBIUE = "CidrBlockInUseException";
var _CBS = "CidrBlockSummary";
var _CBSi = "CidrBlockSummaries";
var _CBi = "CidrBlock";
var _CBid = "CidrBlocks";
var _CC = "CidrCollection";
var _CCAEE = "CidrCollectionAlreadyExistsException";
var _CCC = "CidrCollectionChange";
var _CCCR = "ChangeCidrCollectionRequest";
var _CCCRh = "ChangeCidrCollectionResponse";
var _CCCRr = "CreateCidrCollectionRequest";
var _CCCRre = "CreateCidrCollectionResponse";
var _CCCh = "ChangeCidrCollection";
var _CCCi = "CidrCollectionChanges";
var _CCCr = "CreateCidrCollection";
var _CCIUE = "CidrCollectionInUseException";
var _CCVME = "CidrCollectionVersionMismatchException";
var _CCi = "CidrCollections";
var _CCo = "ContinentCode";
var _CCou = "CountryCode";
var _CD = "CreatedDate";
var _CDE = "ConflictingDomainExists";
var _CHC = "ChildHealthChecks";
var _CHCL = "ChildHealthCheckList";
var _CHCR = "CreateHealthCheckRequest";
var _CHCRr = "CreateHealthCheckResponse";
var _CHCh = "ChildHealthCheck";
var _CHCr = "CreateHealthCheck";
var _CHZ = "CreateHostedZone";
var _CHZR = "CreateHostedZoneRequest";
var _CHZRr = "CreateHostedZoneResponse";
var _CI = "ChangeInfo";
var _CIR = "CheckerIpRanges";
var _CIo = "CollectionId";
var _CKSK = "CreateKeySigningKey";
var _CKSKR = "CreateKeySigningKeyRequest";
var _CKSKRr = "CreateKeySigningKeyResponse";
var _CL = "CidrList";
var _CLi = "CidrLocations";
var _CM = "ConcurrentModification";
var _CN = "ContinentName";
var _CNo = "CountryName";
var _CO = "ComparisonOperator";
var _CQLC = "CreateQueryLoggingConfig";
var _CQLCR = "CreateQueryLoggingConfigRequest";
var _CQLCRr = "CreateQueryLoggingConfigResponse";
var _CR = "CallerReference";
var _CRC = "CidrRoutingConfig";
var _CRDS = "CreateReusableDelegationSet";
var _CRDSR = "CreateReusableDelegationSetRequest";
var _CRDSRr = "CreateReusableDelegationSetResponse";
var _CRRS = "ChangeResourceRecordSets";
var _CRRSR = "ChangeResourceRecordSetsRequest";
var _CRRSRh = "ChangeResourceRecordSetsResponse";
var _CS = "CollectionSummary";
var _CSo = "CollectionSummaries";
var _CT = "ConflictingTypes";
var _CTFR = "ChangeTagsForResource";
var _CTFRR = "ChangeTagsForResourceRequest";
var _CTFRRh = "ChangeTagsForResourceResponse";
var _CTP = "CreateTrafficPolicy";
var _CTPI = "CreateTrafficPolicyInstance";
var _CTPIR = "CreateTrafficPolicyInstanceRequest";
var _CTPIRr = "CreateTrafficPolicyInstanceResponse";
var _CTPR = "CreateTrafficPolicyRequest";
var _CTPRr = "CreateTrafficPolicyResponse";
var _CTPV = "CreateTrafficPolicyVersion";
var _CTPVR = "CreateTrafficPolicyVersionRequest";
var _CTPVRr = "CreateTrafficPolicyVersionResponse";
var _CTh = "CheckedTime";
var _CV = "CollectionVersion";
var _CVPCAA = "CreateVPCAssociationAuthorization";
var _CVPCAAR = "CreateVPCAssociationAuthorizationRequest";
var _CVPCAARr = "CreateVPCAssociationAuthorizationResponse";
var _CWAC = "CloudWatchAlarmConfiguration";
var _CWLLGA = "CloudWatchLogsLogGroupArn";
var _Ch = "Change";
var _Cha = "Changes";
var _Ci = "Cidr";
var _Co = "Coordinates";
var _Col = "Collection";
var _Con = "Config";
var _Cou = "Count";
var _D = "Dimensions";
var _DAM = "DigestAlgorithmMnemonic";
var _DAT = "DigestAlgorithmType";
var _DCC = "DeleteCidrCollection";
var _DCCR = "DeleteCidrCollectionRequest";
var _DCCRe = "DeleteCidrCollectionResponse";
var _DHC = "DeleteHealthCheck";
var _DHCR = "DeleteHealthCheckRequest";
var _DHCRe = "DeleteHealthCheckResponse";
var _DHZ = "DeleteHostedZone";
var _DHZDNSSEC = "DisableHostedZoneDNSSEC";
var _DHZDNSSECR = "DisableHostedZoneDNSSECRequest";
var _DHZDNSSECRi = "DisableHostedZoneDNSSECResponse";
var _DHZR = "DeleteHostedZoneRequest";
var _DHZRe = "DeleteHostedZoneResponse";
var _DKSK = "DeactivateKeySigningKey";
var _DKSKR = "DeactivateKeySigningKeyRequest";
var _DKSKRe = "DeactivateKeySigningKeyResponse";
var _DKSKRel = "DeleteKeySigningKeyRequest";
var _DKSKRele = "DeleteKeySigningKeyResponse";
var _DKSKe = "DeleteKeySigningKey";
var _DL = "DimensionList";
var _DNSKEYR = "DNSKEYRecord";
var _DNSN = "DNSName";
var _DNSSECNF = "DNSSECNotFound";
var _DNSSECS = "DNSSECStatus";
var _DQLC = "DeleteQueryLoggingConfig";
var _DQLCR = "DeleteQueryLoggingConfigRequest";
var _DQLCRe = "DeleteQueryLoggingConfigResponse";
var _DRDS = "DeleteReusableDelegationSet";
var _DRDSR = "DeleteReusableDelegationSetRequest";
var _DRDSRe = "DeleteReusableDelegationSetResponse";
var _DS = "DelegationSet";
var _DSAC = "DelegationSetAlreadyCreated";
var _DSAR = "DelegationSetAlreadyReusable";
var _DSI = "DelegationSetId";
var _DSIU = "DelegationSetInUse";
var _DSNA = "DelegationSetNotAvailable";
var _DSNR = "DelegationSetNotReusable";
var _DSNS = "DelegationSetNameServers";
var _DSR = "DSRecord";
var _DSe = "DelegationSets";
var _DTP = "DeleteTrafficPolicy";
var _DTPI = "DeleteTrafficPolicyInstance";
var _DTPIR = "DeleteTrafficPolicyInstanceRequest";
var _DTPIRe = "DeleteTrafficPolicyInstanceResponse";
var _DTPR = "DeleteTrafficPolicyRequest";
var _DTPRe = "DeleteTrafficPolicyResponse";
var _DV = "DigestValue";
var _DVPCAA = "DeleteVPCAssociationAuthorization";
var _DVPCAAR = "DeleteVPCAssociationAuthorizationRequest";
var _DVPCAARe = "DeleteVPCAssociationAuthorizationResponse";
var _DVPCFHZ = "DisassociateVPCFromHostedZone";
var _DVPCFHZR = "DisassociateVPCFromHostedZoneRequest";
var _DVPCFHZRi = "DisassociateVPCFromHostedZoneResponse";
var _De = "Description";
var _Di = "Dimension";
var _Dis = "Disabled";
var _Do = "Document";
var _EAR = "EnableAcceleratedRecovery";
var _EDNSCSIP = "EDNS0ClientSubnetIP";
var _EDNSCSM = "EDNS0ClientSubnetMask";
var _EHZDNSSEC = "EnableHostedZoneDNSSEC";
var _EHZDNSSECR = "EnableHostedZoneDNSSECRequest";
var _EHZDNSSECRn = "EnableHostedZoneDNSSECResponse";
var _EM = "ErrorMessages";
var _EP = "EvaluationPeriods";
var _ESNI = "EnableSNI";
var _ETH = "EvaluateTargetHealth";
var _F = "Features";
var _FQDN = "FullyQualifiedDomainName";
var _FR = "FailureReasons";
var _FT = "FailureThreshold";
var _Fa = "Failover";
var _Fl = "Flag";
var _GAL = "GetAccountLimit";
var _GALR = "GetAccountLimitRequest";
var _GALRe = "GetAccountLimitResponse";
var _GC = "GetChange";
var _GCIR = "GetCheckerIpRanges";
var _GCIRR = "GetCheckerIpRangesRequest";
var _GCIRRe = "GetCheckerIpRangesResponse";
var _GCR = "GetChangeRequest";
var _GCRe = "GetChangeResponse";
var _GDNSSEC = "GetDNSSEC";
var _GDNSSECR = "GetDNSSECRequest";
var _GDNSSECRe = "GetDNSSECResponse";
var _GGL = "GetGeoLocation";
var _GGLR = "GetGeoLocationRequest";
var _GGLRe = "GetGeoLocationResponse";
var _GHC = "GetHealthCheck";
var _GHCC = "GetHealthCheckCount";
var _GHCCR = "GetHealthCheckCountRequest";
var _GHCCRe = "GetHealthCheckCountResponse";
var _GHCLFR = "GetHealthCheckLastFailureReason";
var _GHCLFRR = "GetHealthCheckLastFailureReasonRequest";
var _GHCLFRRe = "GetHealthCheckLastFailureReasonResponse";
var _GHCR = "GetHealthCheckRequest";
var _GHCRe = "GetHealthCheckResponse";
var _GHCS = "GetHealthCheckStatus";
var _GHCSR = "GetHealthCheckStatusRequest";
var _GHCSRe = "GetHealthCheckStatusResponse";
var _GHZ = "GetHostedZone";
var _GHZC = "GetHostedZoneCount";
var _GHZCR = "GetHostedZoneCountRequest";
var _GHZCRe = "GetHostedZoneCountResponse";
var _GHZL = "GetHostedZoneLimit";
var _GHZLR = "GetHostedZoneLimitRequest";
var _GHZLRe = "GetHostedZoneLimitResponse";
var _GHZR = "GetHostedZoneRequest";
var _GHZRe = "GetHostedZoneResponse";
var _GL = "GeoLocation";
var _GLD = "GeoLocationDetails";
var _GLDL = "GeoLocationDetailsList";
var _GPL = "GeoProximityLocation";
var _GQLC = "GetQueryLoggingConfig";
var _GQLCR = "GetQueryLoggingConfigRequest";
var _GQLCRe = "GetQueryLoggingConfigResponse";
var _GRDS = "GetReusableDelegationSet";
var _GRDSL = "GetReusableDelegationSetLimit";
var _GRDSLR = "GetReusableDelegationSetLimitRequest";
var _GRDSLRe = "GetReusableDelegationSetLimitResponse";
var _GRDSR = "GetReusableDelegationSetRequest";
var _GRDSRe = "GetReusableDelegationSetResponse";
var _GTP = "GetTrafficPolicy";
var _GTPI = "GetTrafficPolicyInstance";
var _GTPIC = "GetTrafficPolicyInstanceCount";
var _GTPICR = "GetTrafficPolicyInstanceCountRequest";
var _GTPICRe = "GetTrafficPolicyInstanceCountResponse";
var _GTPIR = "GetTrafficPolicyInstanceRequest";
var _GTPIRe = "GetTrafficPolicyInstanceResponse";
var _GTPR = "GetTrafficPolicyRequest";
var _GTPRe = "GetTrafficPolicyResponse";
var _HC = "HealthCheck";
var _HCAE = "HealthCheckAlreadyExists";
var _HCC = "HealthCheckConfig";
var _HCCe = "HealthCheckCount";
var _HCI = "HealthCheckId";
var _HCIU = "HealthCheckInUse";
var _HCO = "HealthCheckObservations";
var _HCOe = "HealthCheckObservation";
var _HCRL = "HealthCheckRegionList";
var _HCV = "HealthCheckVersion";
var _HCVM = "HealthCheckVersionMismatch";
var _HCe = "HealthChecks";
var _HT = "HealthThreshold";
var _HZ = "HostedZone";
var _HZAE = "HostedZoneAlreadyExists";
var _HZC = "HostedZoneConfig";
var _HZCo = "HostedZoneCount";
var _HZF = "HostedZoneFeatures";
var _HZFR = "HostedZoneFailureReasons";
var _HZI = "HostedZoneId";
var _HZIM = "HostedZoneIdMarker";
var _HZL = "HostedZoneLimit";
var _HZNE = "HostedZoneNotEmpty";
var _HZNF = "HostedZoneNotFound";
var _HZNP = "HostedZoneNotPrivate";
var _HZO = "HostedZoneOwner";
var _HZPD = "HostedZonePartiallyDelegated";
var _HZS = "HostedZoneSummary";
var _HZSo = "HostedZoneSummaries";
var _HZT = "HostedZoneType";
var _HZo = "HostedZones";
var _I = "Id";
var _IA = "InvalidArgument";
var _ICB = "InvalidChangeBatch";
var _ICWLRP = "InsufficientCloudWatchLogsResourcePolicy";
var _IDHS = "InsufficientDataHealthStatus";
var _IDN = "InvalidDomainName";
var _II = "InvalidInput";
var _IKMSA = "InvalidKMSArn";
var _IKSKN = "InvalidKeySigningKeyName";
var _IKSKS = "InvalidKeySigningKeyStatus";
var _IPA = "IPAddress";
var _IPT = "InvalidPaginationToken";
var _ISS = "InvalidSigningStatus";
var _IT = "IsTruncated";
var _ITPD = "InvalidTrafficPolicyDocument";
var _IV = "IncompatibleVersion";
var _IVPCI = "InvalidVPCId";
var _In = "Inverted";
var _K = "Key";
var _KA = "KmsArn";
var _KMSA = "KeyManagementServiceArn";
var _KSK = "KeySigningKey";
var _KSKAE = "KeySigningKeyAlreadyExists";
var _KSKIPDSR = "KeySigningKeyInParentDSRecord";
var _KSKIU = "KeySigningKeyInUse";
var _KSKWASNF = "KeySigningKeyWithActiveStatusNotFound";
var _KSKe = "KeySigningKeys";
var _KT = "KeyTag";
var _L = "Latitude";
var _LCB = "ListCidrBlocks";
var _LCBR = "ListCidrBlocksRequest";
var _LCBRi = "ListCidrBlocksResponse";
var _LCC = "ListCidrCollections";
var _LCCR = "ListCidrCollectionsRequest";
var _LCCRi = "ListCidrCollectionsResponse";
var _LCL = "ListCidrLocations";
var _LCLR = "ListCidrLocationsRequest";
var _LCLRi = "ListCidrLocationsResponse";
var _LE = "LimitsExceeded";
var _LGL = "ListGeoLocations";
var _LGLR = "ListGeoLocationsRequest";
var _LGLRi = "ListGeoLocationsResponse";
var _LHC = "ListHealthChecks";
var _LHCR = "ListHealthChecksRequest";
var _LHCRi = "ListHealthChecksResponse";
var _LHZ = "ListHostedZones";
var _LHZBN = "ListHostedZonesByName";
var _LHZBNR = "ListHostedZonesByNameRequest";
var _LHZBNRi = "ListHostedZonesByNameResponse";
var _LHZBVPC = "ListHostedZonesByVPC";
var _LHZBVPCR = "ListHostedZonesByVPCRequest";
var _LHZBVPCRi = "ListHostedZonesByVPCResponse";
var _LHZR = "ListHostedZonesRequest";
var _LHZRi = "ListHostedZonesResponse";
var _LMD = "LastModifiedDate";
var _LN = "LocationName";
var _LQLC = "ListQueryLoggingConfigs";
var _LQLCR = "ListQueryLoggingConfigsRequest";
var _LQLCRi = "ListQueryLoggingConfigsResponse";
var _LRDS = "ListReusableDelegationSets";
var _LRDSR = "ListReusableDelegationSetsRequest";
var _LRDSRi = "ListReusableDelegationSetsResponse";
var _LRRS = "ListResourceRecordSets";
var _LRRSR = "ListResourceRecordSetsRequest";
var _LRRSRi = "ListResourceRecordSetsResponse";
var _LS = "LinkedService";
var _LSo = "LocationSummary";
var _LSoc = "LocationSummaries";
var _LTFR = "ListTagsForResource";
var _LTFRR = "ListTagsForResourceRequest";
var _LTFRRi = "ListTagsForResourceResponse";
var _LTFRRis = "ListTagsForResourcesRequest";
var _LTFRRist = "ListTagsForResourcesResponse";
var _LTFRi = "ListTagsForResources";
var _LTP = "ListTrafficPolicies";
var _LTPI = "ListTrafficPolicyInstances";
var _LTPIBHZ = "ListTrafficPolicyInstancesByHostedZone";
var _LTPIBHZR = "ListTrafficPolicyInstancesByHostedZoneRequest";
var _LTPIBHZRi = "ListTrafficPolicyInstancesByHostedZoneResponse";
var _LTPIBP = "ListTrafficPolicyInstancesByPolicy";
var _LTPIBPR = "ListTrafficPolicyInstancesByPolicyRequest";
var _LTPIBPRi = "ListTrafficPolicyInstancesByPolicyResponse";
var _LTPIR = "ListTrafficPolicyInstancesRequest";
var _LTPIRi = "ListTrafficPolicyInstancesResponse";
var _LTPR = "ListTrafficPoliciesRequest";
var _LTPRi = "ListTrafficPoliciesResponse";
var _LTPV = "ListTrafficPolicyVersions";
var _LTPVR = "ListTrafficPolicyVersionsRequest";
var _LTPVRi = "ListTrafficPolicyVersionsResponse";
var _LV = "LatestVersion";
var _LVPCA = "LastVPCAssociation";
var _LVPCAA = "ListVPCAssociationAuthorizations";
var _LVPCAAR = "ListVPCAssociationAuthorizationsRequest";
var _LVPCAARi = "ListVPCAssociationAuthorizationsResponse";
var _LZG = "LocalZoneGroup";
var _Li = "Limit";
var _Lo = "Longitude";
var _Loc = "Location";
var _M = "Message";
var _MI = "MaxItems";
var _ML = "MeasureLatency";
var _MN = "MetricName";
var _MR = "MaxResults";
var _MVA = "MultiValueAnswer";
var _Ma = "Marker";
var _N = "Name";
var _NAE = "NotAuthorizedException";
var _NCC = "NextContinentCode";
var _NCCe = "NextCountryCode";
var _NDNSN = "NextDNSName";
var _NHZI = "NextHostedZoneId";
var _NM = "NextMarker";
var _NRI = "NextRecordIdentifier";
var _NRN = "NextRecordName";
var _NRT = "NextRecordType";
var _NS = "NameServers";
var _NSC = "NoSuchChange";
var _NSCCE = "NoSuchCidrCollectionException";
var _NSCLE = "NoSuchCidrLocationException";
var _NSCWLLG = "NoSuchCloudWatchLogsLogGroup";
var _NSCe = "NextSubdivisionCode";
var _NSDS = "NoSuchDelegationSet";
var _NSGL = "NoSuchGeoLocation";
var _NSHC = "NoSuchHealthCheck";
var _NSHZ = "NoSuchHostedZone";
var _NSKSK = "NoSuchKeySigningKey";
var _NSQLC = "NoSuchQueryLoggingConfig";
var _NSTP = "NoSuchTrafficPolicy";
var _NSTPI = "NoSuchTrafficPolicyInstance";
var _NSa = "NameServer";
var _NT = "NextToken";
var _Na = "Namespace";
var _Nam = "Nameserver";
var _O = "Owner";
var _OA = "OwningAccount";
var _OS = "OwningService";
var _P = "Period";
var _PK = "PublicKey";
var _PRNC = "PriorRequestNotComplete";
var _PZ = "PrivateZone";
var _PZVPCA = "PublicZoneVPCAssociation";
var _Po = "Port";
var _Pr = "Protocol";
var _QLC = "QueryLoggingConfig";
var _QLCAE = "QueryLoggingConfigAlreadyExists";
var _QLCu = "QueryLoggingConfigs";
var _R = "Region";
var _RC2 = "ResponseCode";
var _RCA = "RoutingControlArn";
var _RD = "RecordData";
var _RDE = "RecordDataEntry";
var _RDSL = "ReusableDelegationSetLimit";
var _RE = "ResetElements";
var _REN = "ResettableElementName";
var _RENL = "ResettableElementNameList";
var _RI = "ResourceId";
var _RIP = "ResolverIP";
var _RIe = "RequestInterval";
var _RIes = "ResourceIds";
var _RN = "RecordName";
var _RP = "ResourcePath";
var _RR = "ResourceRecord";
var _RRS = "ResourceRecordSet";
var _RRSC = "ResourceRecordSetCount";
var _RRSe = "ResourceRecordSets";
var _RRe = "ResourceRecords";
var _RT = "ResourceType";
var _RTK = "RemoveTagKeys";
var _RTS = "ResourceTagSet";
var _RTSL = "ResourceTagSetList";
var _RTSe = "ResourceTagSets";
var _RTe = "RecordType";
var _Re = "Regions";
var _S = "Status";
var _SA = "SubmittedAt";
var _SAM = "SigningAlgorithmMnemonic";
var _SAT = "SigningAlgorithmType";
var _SC = "SubdivisionCode";
var _SCC = "StartContinentCode";
var _SCCt = "StartCountryCode";
var _SI = "SetIdentifier";
var _SM = "StatusMessage";
var _SN = "SubdivisionName";
var _SP = "ServicePrincipal";
var _SR = "StatusReport";
var _SRI = "StartRecordIdentifier";
var _SRN = "StartRecordName";
var _SRT = "StartRecordType";
var _SS = "ServeSignature";
var _SSC = "StartSubdivisionCode";
var _SSe = "SearchString";
var _St = "Statistic";
var _Sta = "State";
var _T = "Type";
var _TDNSA = "TestDNSAnswer";
var _TDNSAR = "TestDNSAnswerRequest";
var _TDNSARe = "TestDNSAnswerResponse";
var _TE = "ThrottlingException";
var _TKL = "TagKeyList";
var _TL = "TagList";
var _TMHC = "TooManyHealthChecks";
var _TMHZ = "TooManyHostedZones";
var _TMKSK = "TooManyKeySigningKeys";
var _TMTP = "TooManyTrafficPolicies";
var _TMTPI = "TooManyTrafficPolicyInstances";
var _TMTPVFCP = "TooManyTrafficPolicyVersionsForCurrentPolicy";
var _TMVPCAA = "TooManyVPCAssociationAuthorizations";
var _TP = "TrafficPolicy";
var _TPAE = "TrafficPolicyAlreadyExists";
var _TPC = "TrafficPolicyCount";
var _TPI = "TrafficPolicyId";
var _TPIAE = "TrafficPolicyInstanceAlreadyExists";
var _TPIC = "TrafficPolicyInstanceCount";
var _TPII = "TrafficPolicyInstanceId";
var _TPIM = "TrafficPolicyIdMarker";
var _TPINM = "TrafficPolicyInstanceNameMarker";
var _TPITM = "TrafficPolicyInstanceTypeMarker";
var _TPIU = "TrafficPolicyInUse";
var _TPIr = "TrafficPolicyInstance";
var _TPIra = "TrafficPolicyInstances";
var _TPS = "TrafficPolicySummaries";
var _TPSr = "TrafficPolicySummary";
var _TPT = "TrafficPolicyType";
var _TPV = "TrafficPolicyVersion";
var _TPVM = "TrafficPolicyVersionMarker";
var _TPr = "TrafficPolicies";
var _TRIL = "TagResourceIdList";
var _TTL = "TTL";
var _Ta = "Tags";
var _Tag = "Tag";
var _Th = "Threshold";
var _UHC = "UpdateHealthCheck";
var _UHCR = "UpdateHealthCheckRequest";
var _UHCRp = "UpdateHealthCheckResponse";
var _UHZC = "UpdateHostedZoneComment";
var _UHZCR = "UpdateHostedZoneCommentRequest";
var _UHZCRp = "UpdateHostedZoneCommentResponse";
var _UHZF = "UpdateHostedZoneFeatures";
var _UHZFR = "UpdateHostedZoneFeaturesRequest";
var _UHZFRp = "UpdateHostedZoneFeaturesResponse";
var _UTPC = "UpdateTrafficPolicyComment";
var _UTPCR = "UpdateTrafficPolicyCommentRequest";
var _UTPCRp = "UpdateTrafficPolicyCommentResponse";
var _UTPI = "UpdateTrafficPolicyInstance";
var _UTPIR = "UpdateTrafficPolicyInstanceRequest";
var _UTPIRp = "UpdateTrafficPolicyInstanceResponse";
var _V = "Value";
var _VPC = "VPC";
var _VPCAANF = "VPCAssociationAuthorizationNotFound";
var _VPCANF = "VPCAssociationNotFound";
var _VPCI = "VPCId";
var _VPCR = "VPCRegion";
var _VPCs = "VPCs";
var _Ve = "Version";
var _W = "Weight";
var _c2 = "client";
var _co = "continentcode";
var _cou = "countrycode";
var _d = "dnsname";
var _de = "delegationsetid";
var _e2 = "error";
var _ed = "edns0clientsubnetip";
var _edn = "edns0clientsubnetmask";
var _h2 = "hostedzoneid";
var _hE2 = "httpError";
var _hH2 = "httpHeader";
var _hQ2 = "httpQuery";
var _ho = "hostedzonetype";
var _ht = "http";
var _i = "identifier";
var _id = "id";
var _l = "location";
var _m2 = "message";
var _ma = "maxresults";
var _mar = "marker";
var _max = "maxitems";
var _me = "messages";
var _n = "nexttoken";
var _na = "name";
var _r = "recordname";
var _re = "recordtype";
var _res = "resolverip";
var _s2 = "smithy.ts.sdk.synthetic.com.amazonaws.route53";
var _st = "startcontinentcode";
var _sta = "startcountrycode";
var _star = "startsubdivisioncode";
var _su = "subdivisioncode";
var _t = "type";
var _tr = "trafficpolicyid";
var _tra = "trafficpolicyinstancename";
var _traf = "trafficpolicyinstancetype";
var _traff = "trafficpolicyversion";
var _v = "vpcid";
var _ve = "version";
var _vp = "vpcregion";
var _xN = "xmlName";
var n02 = "com.amazonaws.route53";
var _s_registry2 = import_schema.TypeRegistry.for(_s2);
var Route53ServiceException$ = [-3, _s2, "Route53ServiceException", 0, [], []];
_s_registry2.registerError(Route53ServiceException$, Route53ServiceException);
var n0_registry2 = import_schema.TypeRegistry.for(n02);
var CidrBlockInUseException$ = [
-3,
n02,
_CBIUE,
{ [_e2]: _c2, [_hE2]: 400 },
[_M],
[0]
];
n0_registry2.registerError(CidrBlockInUseException$, CidrBlockInUseException);
var CidrCollectionAlreadyExistsException$ = [
-3,
n02,
_CCAEE,
{ [_e2]: _c2 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionAlreadyExistsException$, CidrCollectionAlreadyExistsException);
var CidrCollectionInUseException$ = [
-3,
n02,
_CCIUE,
{ [_e2]: _c2, [_hE2]: 400 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionInUseException$, CidrCollectionInUseException);
var CidrCollectionVersionMismatchException$ = [
-3,
n02,
_CCVME,
{ [_e2]: _c2, [_hE2]: 409 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionVersionMismatchException$, CidrCollectionVersionMismatchException);
var ConcurrentModification$ = [
-3,
n02,
_CM,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ConcurrentModification$, ConcurrentModification);
var ConflictingDomainExists$ = [
-3,
n02,
_CDE,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(ConflictingDomainExists$, ConflictingDomainExists);
var ConflictingTypes$ = [
-3,
n02,
_CT,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ConflictingTypes$, ConflictingTypes);
var DelegationSetAlreadyCreated$ = [
-3,
n02,
_DSAC,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetAlreadyCreated$, DelegationSetAlreadyCreated);
var DelegationSetAlreadyReusable$ = [
-3,
n02,
_DSAR,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetAlreadyReusable$, DelegationSetAlreadyReusable);
var DelegationSetInUse$ = [
-3,
n02,
_DSIU,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetInUse$, DelegationSetInUse);
var DelegationSetNotAvailable$ = [
-3,
n02,
_DSNA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetNotAvailable$, DelegationSetNotAvailable);
var DelegationSetNotReusable$ = [
-3,
n02,
_DSNR,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetNotReusable$, DelegationSetNotReusable);
var DNSSECNotFound$ = [
-3,
n02,
_DNSSECNF,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(DNSSECNotFound$, DNSSECNotFound);
var HealthCheckAlreadyExists$ = [
-3,
n02,
_HCAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckAlreadyExists$, HealthCheckAlreadyExists);
var HealthCheckInUse$ = [
-3,
n02,
_HCIU,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckInUse$, HealthCheckInUse);
var HealthCheckVersionMismatch$ = [
-3,
n02,
_HCVM,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckVersionMismatch$, HealthCheckVersionMismatch);
var HostedZoneAlreadyExists$ = [
-3,
n02,
_HZAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneAlreadyExists$, HostedZoneAlreadyExists);
var HostedZoneNotEmpty$ = [
-3,
n02,
_HZNE,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotEmpty$, HostedZoneNotEmpty);
var HostedZoneNotFound$ = [
-3,
n02,
_HZNF,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotFound$, HostedZoneNotFound);
var HostedZoneNotPrivate$ = [
-3,
n02,
_HZNP,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotPrivate$, HostedZoneNotPrivate);
var HostedZonePartiallyDelegated$ = [
-3,
n02,
_HZPD,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZonePartiallyDelegated$, HostedZonePartiallyDelegated);
var IncompatibleVersion$ = [
-3,
n02,
_IV,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(IncompatibleVersion$, IncompatibleVersion);
var InsufficientCloudWatchLogsResourcePolicy$ = [
-3,
n02,
_ICWLRP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InsufficientCloudWatchLogsResourcePolicy$, InsufficientCloudWatchLogsResourcePolicy);
var InvalidArgument$ = [
-3,
n02,
_IA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidArgument$, InvalidArgument);
var InvalidChangeBatch$ = [
-3,
n02,
_ICB,
{ [_e2]: _c2 },
[_me, _m2],
[[() => ErrorMessages, 0], 0]
];
n0_registry2.registerError(InvalidChangeBatch$, InvalidChangeBatch);
var InvalidDomainName$ = [
-3,
n02,
_IDN,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidDomainName$, InvalidDomainName);
var InvalidInput$ = [
-3,
n02,
_II,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidInput$, InvalidInput);
var InvalidKeySigningKeyName$ = [
-3,
n02,
_IKSKN,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKeySigningKeyName$, InvalidKeySigningKeyName);
var InvalidKeySigningKeyStatus$ = [
-3,
n02,
_IKSKS,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKeySigningKeyStatus$, InvalidKeySigningKeyStatus);
var InvalidKMSArn$ = [
-3,
n02,
_IKMSA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKMSArn$, InvalidKMSArn);
var InvalidPaginationToken$ = [
-3,
n02,
_IPT,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidPaginationToken$, InvalidPaginationToken);
var InvalidSigningStatus$ = [
-3,
n02,
_ISS,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidSigningStatus$, InvalidSigningStatus);
var InvalidTrafficPolicyDocument$ = [
-3,
n02,
_ITPD,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidTrafficPolicyDocument$, InvalidTrafficPolicyDocument);
var InvalidVPCId$ = [
-3,
n02,
_IVPCI,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidVPCId$, InvalidVPCId);
var KeySigningKeyAlreadyExists$ = [
-3,
n02,
_KSKAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyAlreadyExists$, KeySigningKeyAlreadyExists);
var KeySigningKeyInParentDSRecord$ = [
-3,
n02,
_KSKIPDSR,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyInParentDSRecord$, KeySigningKeyInParentDSRecord);
var KeySigningKeyInUse$ = [
-3,
n02,
_KSKIU,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyInUse$, KeySigningKeyInUse);
var KeySigningKeyWithActiveStatusNotFound$ = [
-3,
n02,
_KSKWASNF,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyWithActiveStatusNotFound$, KeySigningKeyWithActiveStatusNotFound);
var LastVPCAssociation$ = [
-3,
n02,
_LVPCA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(LastVPCAssociation$, LastVPCAssociation);
var LimitsExceeded$ = [
-3,
n02,
_LE,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(LimitsExceeded$, LimitsExceeded);
var NoSuchChange$ = [
-3,
n02,
_NSC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchChange$, NoSuchChange);
var NoSuchCidrCollectionException$ = [
-3,
n02,
_NSCCE,
{ [_e2]: _c2, [_hE2]: 404 },
[_M],
[0]
];
n0_registry2.registerError(NoSuchCidrCollectionException$, NoSuchCidrCollectionException);
var NoSuchCidrLocationException$ = [
-3,
n02,
_NSCLE,
{ [_e2]: _c2, [_hE2]: 404 },
[_M],
[0]
];
n0_registry2.registerError(NoSuchCidrLocationException$, NoSuchCidrLocationException);
var NoSuchCloudWatchLogsLogGroup$ = [
-3,
n02,
_NSCWLLG,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchCloudWatchLogsLogGroup$, NoSuchCloudWatchLogsLogGroup);
var NoSuchDelegationSet$ = [
-3,
n02,
_NSDS,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchDelegationSet$, NoSuchDelegationSet);
var NoSuchGeoLocation$ = [
-3,
n02,
_NSGL,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchGeoLocation$, NoSuchGeoLocation);
var NoSuchHealthCheck$ = [
-3,
n02,
_NSHC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchHealthCheck$, NoSuchHealthCheck);
var NoSuchHostedZone$ = [
-3,
n02,
_NSHZ,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchHostedZone$, NoSuchHostedZone);
var NoSuchKeySigningKey$ = [
-3,
n02,
_NSKSK,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchKeySigningKey$, NoSuchKeySigningKey);
var NoSuchQueryLoggingConfig$ = [
-3,
n02,
_NSQLC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchQueryLoggingConfig$, NoSuchQueryLoggingConfig);
var NoSuchTrafficPolicy$ = [
-3,
n02,
_NSTP,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchTrafficPolicy$, NoSuchTrafficPolicy);
var NoSuchTrafficPolicyInstance$ = [
-3,
n02,
_NSTPI,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchTrafficPolicyInstance$, NoSuchTrafficPolicyInstance);
var NotAuthorizedException$ = [
-3,
n02,
_NAE,
{ [_e2]: _c2, [_hE2]: 401 },
[_m2],
[0]
];
n0_registry2.registerError(NotAuthorizedException$, NotAuthorizedException);
var PriorRequestNotComplete$ = [
-3,
n02,
_PRNC,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(PriorRequestNotComplete$, PriorRequestNotComplete);
var PublicZoneVPCAssociation$ = [
-3,
n02,
_PZVPCA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(PublicZoneVPCAssociation$, PublicZoneVPCAssociation);
var QueryLoggingConfigAlreadyExists$ = [
-3,
n02,
_QLCAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(QueryLoggingConfigAlreadyExists$, QueryLoggingConfigAlreadyExists);
var ThrottlingException$ = [
-3,
n02,
_TE,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ThrottlingException$, ThrottlingException);
var TooManyHealthChecks$ = [
-3,
n02,
_TMHC,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyHealthChecks$, TooManyHealthChecks);
var TooManyHostedZones$ = [
-3,
n02,
_TMHZ,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyHostedZones$, TooManyHostedZones);
var TooManyKeySigningKeys$ = [
-3,
n02,
_TMKSK,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyKeySigningKeys$, TooManyKeySigningKeys);
var TooManyTrafficPolicies$ = [
-3,
n02,
_TMTP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicies$, TooManyTrafficPolicies);
var TooManyTrafficPolicyInstances$ = [
-3,
n02,
_TMTPI,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicyInstances$, TooManyTrafficPolicyInstances);
var TooManyTrafficPolicyVersionsForCurrentPolicy$ = [
-3,
n02,
_TMTPVFCP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicyVersionsForCurrentPolicy$, TooManyTrafficPolicyVersionsForCurrentPolicy);
var TooManyVPCAssociationAuthorizations$ = [
-3,
n02,
_TMVPCAA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyVPCAssociationAuthorizations$, TooManyVPCAssociationAuthorizations);
var TrafficPolicyAlreadyExists$ = [
-3,
n02,
_TPAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyAlreadyExists$, TrafficPolicyAlreadyExists);
var TrafficPolicyInstanceAlreadyExists$ = [
-3,
n02,
_TPIAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyInstanceAlreadyExists$, TrafficPolicyInstanceAlreadyExists);
var TrafficPolicyInUse$ = [
-3,
n02,
_TPIU,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyInUse$, TrafficPolicyInUse);
var VPCAssociationAuthorizationNotFound$ = [
-3,
n02,
_VPCAANF,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(VPCAssociationAuthorizationNotFound$, VPCAssociationAuthorizationNotFound);
var VPCAssociationNotFound$ = [
-3,
n02,
_VPCANF,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(VPCAssociationNotFound$, VPCAssociationNotFound);
var errorTypeRegistries2 = [
_s_registry2,
n0_registry2
];
var AccountLimit$ = [
3,
n02,
_AL,
0,
[_T, _V],
[0, 1],
2
];
var ActivateKeySigningKeyRequest$ = [
3,
n02,
_AKSKR,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var ActivateKeySigningKeyResponse$ = [
3,
n02,
_AKSKRc,
0,
[_CI],
[() => ChangeInfo$],
1
];
var AlarmIdentifier$ = [
3,
n02,
_AI,
0,
[_R, _N],
[0, 0],
2
];
var AliasTarget$ = [
3,
n02,
_AT,
0,
[_HZI, _DNSN, _ETH],
[0, 0, 2],
3
];
var AssociateVPCWithHostedZoneRequest$ = [
3,
n02,
_AVPCWHZR,
0,
[_HZI, _VPC, _C],
[[0, 1], () => VPC$, 0],
2
];
var AssociateVPCWithHostedZoneResponse$ = [
3,
n02,
_AVPCWHZRs,
0,
[_CI],
[() => ChangeInfo$],
1
];
var Change$ = [
3,
n02,
_Ch,
0,
[_A, _RRS],
[0, [() => ResourceRecordSet$, 0]],
2
];
var ChangeBatch$ = [
3,
n02,
_CB,
0,
[_Cha, _C],
[[() => Changes, 0], 0],
1
];
var ChangeCidrCollectionRequest$ = [
3,
n02,
_CCCR,
0,
[_I, _Cha, _CV],
[[0, 1], [() => CidrCollectionChanges, 0], 1],
2
];
var ChangeCidrCollectionResponse$ = [
3,
n02,
_CCCRh,
0,
[_I],
[0],
1
];
var ChangeInfo$ = [
3,
n02,
_CI,
0,
[_I, _S, _SA, _C],
[0, 0, 4, 0],
3
];
var ChangeResourceRecordSetsRequest$ = [
3,
n02,
_CRRSR,
0,
[_HZI, _CB],
[[0, 1], [() => ChangeBatch$, 0]],
2
];
var ChangeResourceRecordSetsResponse$ = [
3,
n02,
_CRRSRh,
0,
[_CI],
[() => ChangeInfo$],
1
];
var ChangeTagsForResourceRequest$ = [
3,
n02,
_CTFRR,
0,
[_RT, _RI, _ATd, _RTK],
[[0, 1], [0, 1], [() => TagList, 0], [() => TagKeyList, 0]],
2
];
var ChangeTagsForResourceResponse$ = [
3,
n02,
_CTFRRh,
0,
[],
[]
];
var CidrBlockSummary$ = [
3,
n02,
_CBS,
0,
[_CBi, _LN],
[0, 0]
];
var CidrCollection$ = [
3,
n02,
_CC,
0,
[_Ar, _I, _N, _Ve],
[0, 0, 0, 1]
];
var CidrCollectionChange$ = [
3,
n02,
_CCC,
0,
[_LN, _A, _CL],
[0, 0, [() => CidrList, 0]],
3
];
var CidrRoutingConfig$ = [
3,
n02,
_CRC,
0,
[_CIo, _LN],
[0, 0],
2
];
var CloudWatchAlarmConfiguration$ = [
3,
n02,
_CWAC,
0,
[_EP, _Th, _CO, _P, _MN, _Na, _St, _D],
[1, 1, 0, 1, 0, 0, 0, [() => DimensionList, 0]],
7
];
var CollectionSummary$ = [
3,
n02,
_CS,
0,
[_Ar, _I, _N, _Ve],
[0, 0, 0, 1]
];
var Coordinates$ = [
3,
n02,
_Co,
0,
[_L, _Lo],
[0, 0],
2
];
var CreateCidrCollectionRequest$ = [
3,
n02,
_CCCRr,
0,
[_N, _CR],
[0, 0],
2
];
var CreateCidrCollectionResponse$ = [
3,
n02,
_CCCRre,
0,
[_Col, _Loc],
[() => CidrCollection$, [0, { [_hH2]: _Loc }]]
];
var CreateHealthCheckRequest$ = [
3,
n02,
_CHCR,
0,
[_CR, _HCC],
[0, [() => HealthCheckConfig$, 0]],
2
];
var CreateHealthCheckResponse$ = [
3,
n02,
_CHCRr,
0,
[_HC, _Loc],
[[() => HealthCheck$, 0], [0, { [_hH2]: _Loc }]],
2
];
var CreateHostedZoneRequest$ = [
3,
n02,
_CHZR,
0,
[_N, _CR, _VPC, _HZC, _DSI],
[0, 0, () => VPC$, () => HostedZoneConfig$, 0],
2
];
var CreateHostedZoneResponse$ = [
3,
n02,
_CHZRr,
0,
[_HZ, _CI, _DS, _Loc, _VPC],
[() => HostedZone$, () => ChangeInfo$, [() => DelegationSet$, 0], [0, { [_hH2]: _Loc }], () => VPC$],
4
];
var CreateKeySigningKeyRequest$ = [
3,
n02,
_CKSKR,
0,
[_CR, _HZI, _KMSA, _N, _S],
[0, 0, 0, 0, 0],
5
];
var CreateKeySigningKeyResponse$ = [
3,
n02,
_CKSKRr,
0,
[_CI, _KSK, _Loc],
[() => ChangeInfo$, () => KeySigningKey$, [0, { [_hH2]: _Loc }]],
3
];
var CreateQueryLoggingConfigRequest$ = [
3,
n02,
_CQLCR,
0,
[_HZI, _CWLLGA],
[0, 0],
2
];
var CreateQueryLoggingConfigResponse$ = [
3,
n02,
_CQLCRr,
0,
[_QLC, _Loc],
[() => QueryLoggingConfig$, [0, { [_hH2]: _Loc }]],
2
];
var CreateReusableDelegationSetRequest$ = [
3,
n02,
_CRDSR,
0,
[_CR, _HZI],
[0, 0],
1
];
var CreateReusableDelegationSetResponse$ = [
3,
n02,
_CRDSRr,
0,
[_DS, _Loc],
[[() => DelegationSet$, 0], [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyInstanceRequest$ = [
3,
n02,
_CTPIR,
0,
[_HZI, _N, _TTL, _TPI, _TPV],
[0, 0, 1, 0, 1],
5
];
var CreateTrafficPolicyInstanceResponse$ = [
3,
n02,
_CTPIRr,
0,
[_TPIr, _Loc],
[() => TrafficPolicyInstance$, [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyRequest$ = [
3,
n02,
_CTPR,
0,
[_N, _Do, _C],
[0, 0, 0],
2
];
var CreateTrafficPolicyResponse$ = [
3,
n02,
_CTPRr,
0,
[_TP, _Loc],
[() => TrafficPolicy$, [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyVersionRequest$ = [
3,
n02,
_CTPVR,
0,
[_I, _Do, _C],
[[0, 1], 0, 0],
2
];
var CreateTrafficPolicyVersionResponse$ = [
3,
n02,
_CTPVRr,
0,
[_TP, _Loc],
[() => TrafficPolicy$, [0, { [_hH2]: _Loc }]],
2
];
var CreateVPCAssociationAuthorizationRequest$ = [
3,
n02,
_CVPCAAR,
0,
[_HZI, _VPC],
[[0, 1], () => VPC$],
2
];
var CreateVPCAssociationAuthorizationResponse$ = [
3,
n02,
_CVPCAARr,
0,
[_HZI, _VPC],
[0, () => VPC$],
2
];
var DeactivateKeySigningKeyRequest$ = [
3,
n02,
_DKSKR,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var DeactivateKeySigningKeyResponse$ = [
3,
n02,
_DKSKRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DelegationSet$ = [
3,
n02,
_DS,
0,
[_NS, _I, _CR],
[[() => DelegationSetNameServers, 0], 0, 0],
1
];
var DeleteCidrCollectionRequest$ = [
3,
n02,
_DCCR,
0,
[_I],
[[0, 1]],
1
];
var DeleteCidrCollectionResponse$ = [
3,
n02,
_DCCRe,
0,
[],
[]
];
var DeleteHealthCheckRequest$ = [
3,
n02,
_DHCR,
0,
[_HCI],
[[0, 1]],
1
];
var DeleteHealthCheckResponse$ = [
3,
n02,
_DHCRe,
0,
[],
[]
];
var DeleteHostedZoneRequest$ = [
3,
n02,
_DHZR,
0,
[_I],
[[0, 1]],
1
];
var DeleteHostedZoneResponse$ = [
3,
n02,
_DHZRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DeleteKeySigningKeyRequest$ = [
3,
n02,
_DKSKRel,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var DeleteKeySigningKeyResponse$ = [
3,
n02,
_DKSKRele,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DeleteQueryLoggingConfigRequest$ = [
3,
n02,
_DQLCR,
0,
[_I],
[[0, 1]],
1
];
var DeleteQueryLoggingConfigResponse$ = [
3,
n02,
_DQLCRe,
0,
[],
[]
];
var DeleteReusableDelegationSetRequest$ = [
3,
n02,
_DRDSR,
0,
[_I],
[[0, 1]],
1
];
var DeleteReusableDelegationSetResponse$ = [
3,
n02,
_DRDSRe,
0,
[],
[]
];
var DeleteTrafficPolicyInstanceRequest$ = [
3,
n02,
_DTPIR,
0,
[_I],
[[0, 1]],
1
];
var DeleteTrafficPolicyInstanceResponse$ = [
3,
n02,
_DTPIRe,
0,
[],
[]
];
var DeleteTrafficPolicyRequest$ = [
3,
n02,
_DTPR,
0,
[_I, _Ve],
[[0, 1], [1, 1]],
2
];
var DeleteTrafficPolicyResponse$ = [
3,
n02,
_DTPRe,
0,
[],
[]
];
var DeleteVPCAssociationAuthorizationRequest$ = [
3,
n02,
_DVPCAAR,
0,
[_HZI, _VPC],
[[0, 1], () => VPC$],
2
];
var DeleteVPCAssociationAuthorizationResponse$ = [
3,
n02,
_DVPCAARe,
0,
[],
[]
];
var Dimension$ = [
3,
n02,
_Di,
0,
[_N, _V],
[0, 0],
2
];
var DisableHostedZoneDNSSECRequest$ = [
3,
n02,
_DHZDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var DisableHostedZoneDNSSECResponse$ = [
3,
n02,
_DHZDNSSECRi,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DisassociateVPCFromHostedZoneRequest$ = [
3,
n02,
_DVPCFHZR,
0,
[_HZI, _VPC, _C],
[[0, 1], () => VPC$, 0],
2
];
var DisassociateVPCFromHostedZoneResponse$ = [
3,
n02,
_DVPCFHZRi,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DNSSECStatus$ = [
3,
n02,
_DNSSECS,
0,
[_SS, _SM],
[0, 0]
];
var EnableHostedZoneDNSSECRequest$ = [
3,
n02,
_EHZDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var EnableHostedZoneDNSSECResponse$ = [
3,
n02,
_EHZDNSSECRn,
0,
[_CI],
[() => ChangeInfo$],
1
];
var GeoLocation$ = [
3,
n02,
_GL,
0,
[_CCo, _CCou, _SC],
[0, 0, 0]
];
var GeoLocationDetails$ = [
3,
n02,
_GLD,
0,
[_CCo, _CN, _CCou, _CNo, _SC, _SN],
[0, 0, 0, 0, 0, 0]
];
var GeoProximityLocation$ = [
3,
n02,
_GPL,
0,
[_AWSR, _LZG, _Co, _B],
[0, 0, () => Coordinates$, 1]
];
var GetAccountLimitRequest$ = [
3,
n02,
_GALR,
0,
[_T],
[[0, 1]],
1
];
var GetAccountLimitResponse$ = [
3,
n02,
_GALRe,
0,
[_Li, _Cou],
[() => AccountLimit$, 1],
2
];
var GetChangeRequest$ = [
3,
n02,
_GCR,
0,
[_I],
[[0, 1]],
1
];
var GetChangeResponse$ = [
3,
n02,
_GCRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var GetCheckerIpRangesRequest$ = [
3,
n02,
_GCIRR,
0,
[],
[]
];
var GetCheckerIpRangesResponse$ = [
3,
n02,
_GCIRRe,
0,
[_CIR],
[64 | 0],
1
];
var GetDNSSECRequest$ = [
3,
n02,
_GDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var GetDNSSECResponse$ = [
3,
n02,
_GDNSSECRe,
0,
[_S, _KSKe],
[() => DNSSECStatus$, () => KeySigningKeys],
2
];
var GetGeoLocationRequest$ = [
3,
n02,
_GGLR,
0,
[_CCo, _CCou, _SC],
[[0, { [_hQ2]: _co }], [0, { [_hQ2]: _cou }], [0, { [_hQ2]: _su }]]
];
var GetGeoLocationResponse$ = [
3,
n02,
_GGLRe,
0,
[_GLD],
[() => GeoLocationDetails$],
1
];
var GetHealthCheckCountRequest$ = [
3,
n02,
_GHCCR,
0,
[],
[]
];
var GetHealthCheckCountResponse$ = [
3,
n02,
_GHCCRe,
0,
[_HCCe],
[1],
1
];
var GetHealthCheckLastFailureReasonRequest$ = [
3,
n02,
_GHCLFRR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckLastFailureReasonResponse$ = [
3,
n02,
_GHCLFRRe,
0,
[_HCO],
[[() => HealthCheckObservations, 0]],
1
];
var GetHealthCheckRequest$ = [
3,
n02,
_GHCR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckResponse$ = [
3,
n02,
_GHCRe,
0,
[_HC],
[[() => HealthCheck$, 0]],
1
];
var GetHealthCheckStatusRequest$ = [
3,
n02,
_GHCSR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckStatusResponse$ = [
3,
n02,
_GHCSRe,
0,
[_HCO],
[[() => HealthCheckObservations, 0]],
1
];
var GetHostedZoneCountRequest$ = [
3,
n02,
_GHZCR,
0,
[],
[]
];
var GetHostedZoneCountResponse$ = [
3,
n02,
_GHZCRe,
0,
[_HZCo],
[1],
1
];
var GetHostedZoneLimitRequest$ = [
3,
n02,
_GHZLR,
0,
[_T, _HZI],
[[0, 1], [0, 1]],
2
];
var GetHostedZoneLimitResponse$ = [
3,
n02,
_GHZLRe,
0,
[_Li, _Cou],
[() => HostedZoneLimit$, 1],
2
];
var GetHostedZoneRequest$ = [
3,
n02,
_GHZR,
0,
[_I],
[[0, 1]],
1
];
var GetHostedZoneResponse$ = [
3,
n02,
_GHZRe,
0,
[_HZ, _DS, _VPCs],
[() => HostedZone$, [() => DelegationSet$, 0], [() => VPCs, 0]],
1
];
var GetQueryLoggingConfigRequest$ = [
3,
n02,
_GQLCR,
0,
[_I],
[[0, 1]],
1
];
var GetQueryLoggingConfigResponse$ = [
3,
n02,
_GQLCRe,
0,
[_QLC],
[() => QueryLoggingConfig$],
1
];
var GetReusableDelegationSetLimitRequest$ = [
3,
n02,
_GRDSLR,
0,
[_T, _DSI],
[[0, 1], [0, 1]],
2
];
var GetReusableDelegationSetLimitResponse$ = [
3,
n02,
_GRDSLRe,
0,
[_Li, _Cou],
[() => ReusableDelegationSetLimit$, 1],
2
];
var GetReusableDelegationSetRequest$ = [
3,
n02,
_GRDSR,
0,
[_I],
[[0, 1]],
1
];
var GetReusableDelegationSetResponse$ = [
3,
n02,
_GRDSRe,
0,
[_DS],
[[() => DelegationSet$, 0]],
1
];
var GetTrafficPolicyInstanceCountRequest$ = [
3,
n02,
_GTPICR,
0,
[],
[]
];
var GetTrafficPolicyInstanceCountResponse$ = [
3,
n02,
_GTPICRe,
0,
[_TPIC],
[1],
1
];
var GetTrafficPolicyInstanceRequest$ = [
3,
n02,
_GTPIR,
0,
[_I],
[[0, 1]],
1
];
var GetTrafficPolicyInstanceResponse$ = [
3,
n02,
_GTPIRe,
0,
[_TPIr],
[() => TrafficPolicyInstance$],
1
];
var GetTrafficPolicyRequest$ = [
3,
n02,
_GTPR,
0,
[_I, _Ve],
[[0, 1], [1, 1]],
2
];
var GetTrafficPolicyResponse$ = [
3,
n02,
_GTPRe,
0,
[_TP],
[() => TrafficPolicy$],
1
];
var HealthCheck$ = [
3,
n02,
_HC,
0,
[_I, _CR, _HCC, _HCV, _LS, _CWAC],
[0, 0, [() => HealthCheckConfig$, 0], 1, () => LinkedService$, [() => CloudWatchAlarmConfiguration$, 0]],
4
];
var HealthCheckConfig$ = [
3,
n02,
_HCC,
0,
[_T, _IPA, _Po, _RP, _FQDN, _SSe, _RIe, _FT, _ML, _In, _Dis, _HT, _CHC, _ESNI, _Re, _AI, _IDHS, _RCA],
[0, 0, 1, 0, 0, 0, 1, 1, 2, 2, 2, 1, [() => ChildHealthCheckList, 0], 2, [() => HealthCheckRegionList, 0], () => AlarmIdentifier$, 0, 0],
1
];
var HealthCheckObservation$ = [
3,
n02,
_HCOe,
0,
[_R, _IPA, _SR],
[0, 0, () => StatusReport$]
];
var HostedZone$ = [
3,
n02,
_HZ,
0,
[_I, _N, _CR, _Con, _RRSC, _LS, _F],
[0, 0, 0, () => HostedZoneConfig$, 1, () => LinkedService$, () => HostedZoneFeatures$],
3
];
var HostedZoneConfig$ = [
3,
n02,
_HZC,
0,
[_C, _PZ],
[0, 2]
];
var HostedZoneFailureReasons$ = [
3,
n02,
_HZFR,
0,
[_AR],
[0]
];
var HostedZoneFeatures$ = [
3,
n02,
_HZF,
0,
[_ARS, _FR],
[0, () => HostedZoneFailureReasons$]
];
var HostedZoneLimit$ = [
3,
n02,
_HZL,
0,
[_T, _V],
[0, 1],
2
];
var HostedZoneOwner$ = [
3,
n02,
_HZO,
0,
[_OA, _OS],
[0, 0]
];
var HostedZoneSummary$ = [
3,
n02,
_HZS,
0,
[_HZI, _N, _O],
[0, 0, () => HostedZoneOwner$],
3
];
var KeySigningKey$ = [
3,
n02,
_KSK,
0,
[_N, _KA, _Fl, _SAM, _SAT, _DAM, _DAT, _KT, _DV, _PK, _DSR, _DNSKEYR, _S, _SM, _CD, _LMD],
[0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 4, 4]
];
var LinkedService$ = [
3,
n02,
_LS,
0,
[_SP, _De],
[0, 0]
];
var ListCidrBlocksRequest$ = [
3,
n02,
_LCBR,
0,
[_CIo, _LN, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _l }], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListCidrBlocksResponse$ = [
3,
n02,
_LCBRi,
0,
[_NT, _CBid],
[0, () => CidrBlockSummaries]
];
var ListCidrCollectionsRequest$ = [
3,
n02,
_LCCR,
0,
[_NT, _MR],
[[0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]]
];
var ListCidrCollectionsResponse$ = [
3,
n02,
_LCCRi,
0,
[_NT, _CCi],
[0, () => CollectionSummaries]
];
var ListCidrLocationsRequest$ = [
3,
n02,
_LCLR,
0,
[_CIo, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListCidrLocationsResponse$ = [
3,
n02,
_LCLRi,
0,
[_NT, _CLi],
[0, () => LocationSummaries]
];
var ListGeoLocationsRequest$ = [
3,
n02,
_LGLR,
0,
[_SCC, _SCCt, _SSC, _MI],
[[0, { [_hQ2]: _st }], [0, { [_hQ2]: _sta }], [0, { [_hQ2]: _star }], [1, { [_hQ2]: _max }]]
];
var ListGeoLocationsResponse$ = [
3,
n02,
_LGLRi,
0,
[_GLDL, _IT, _MI, _NCC, _NCCe, _NSCe],
[[() => GeoLocationDetailsList, 0], 2, 1, 0, 0, 0],
3
];
var ListHealthChecksRequest$ = [
3,
n02,
_LHCR,
0,
[_Ma, _MI],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }]]
];
var ListHealthChecksResponse$ = [
3,
n02,
_LHCRi,
0,
[_HCe, _Ma, _IT, _MI, _NM],
[[() => HealthChecks, 0], 0, 2, 1, 0],
4
];
var ListHostedZonesByNameRequest$ = [
3,
n02,
_LHZBNR,
0,
[_DNSN, _HZI, _MI],
[[0, { [_hQ2]: _d }], [0, { [_hQ2]: _h2 }], [1, { [_hQ2]: _max }]]
];
var ListHostedZonesByNameResponse$ = [
3,
n02,
_LHZBNRi,
0,
[_HZo, _IT, _MI, _DNSN, _HZI, _NDNSN, _NHZI],
[[() => HostedZones, 0], 2, 1, 0, 0, 0, 0],
3
];
var ListHostedZonesByVPCRequest$ = [
3,
n02,
_LHZBVPCR,
0,
[_VPCI, _VPCR, _MI, _NT],
[[0, { [_hQ2]: _v }], [0, { [_hQ2]: _vp }], [1, { [_hQ2]: _max }], [0, { [_hQ2]: _n }]],
2
];
var ListHostedZonesByVPCResponse$ = [
3,
n02,
_LHZBVPCRi,
0,
[_HZSo, _MI, _NT],
[[() => HostedZoneSummaries, 0], 1, 0],
2
];
var ListHostedZonesRequest$ = [
3,
n02,
_LHZR,
0,
[_Ma, _MI, _DSI, _HZT],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }], [0, { [_hQ2]: _de }], [0, { [_hQ2]: _ho }]]
];
var ListHostedZonesResponse$ = [
3,
n02,
_LHZRi,
0,
[_HZo, _Ma, _IT, _MI, _NM],
[[() => HostedZones, 0], 0, 2, 1, 0],
4
];
var ListQueryLoggingConfigsRequest$ = [
3,
n02,
_LQLCR,
0,
[_HZI, _NT, _MR],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]]
];
var ListQueryLoggingConfigsResponse$ = [
3,
n02,
_LQLCRi,
0,
[_QLCu, _NT],
[[() => QueryLoggingConfigs, 0], 0],
1
];
var ListResourceRecordSetsRequest$ = [
3,
n02,
_LRRSR,
0,
[_HZI, _SRN, _SRT, _SRI, _MI],
[[0, 1], [0, { [_hQ2]: _na }], [0, { [_hQ2]: _t }], [0, { [_hQ2]: _i }], [1, { [_hQ2]: _max }]],
1
];
var ListResourceRecordSetsResponse$ = [
3,
n02,
_LRRSRi,
0,
[_RRSe, _IT, _MI, _NRN, _NRT, _NRI],
[[() => ResourceRecordSets, 0], 2, 1, 0, 0, 0],
3
];
var ListReusableDelegationSetsRequest$ = [
3,
n02,
_LRDSR,
0,
[_Ma, _MI],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }]]
];
var ListReusableDelegationSetsResponse$ = [
3,
n02,
_LRDSRi,
0,
[_DSe, _Ma, _IT, _MI, _NM],
[[() => DelegationSets, 0], 0, 2, 1, 0],
4
];
var ListTagsForResourceRequest$ = [
3,
n02,
_LTFRR,
0,
[_RT, _RI],
[[0, 1], [0, 1]],
2
];
var ListTagsForResourceResponse$ = [
3,
n02,
_LTFRRi,
0,
[_RTS],
[[() => ResourceTagSet$, 0]],
1
];
var ListTagsForResourcesRequest$ = [
3,
n02,
_LTFRRis,
0,
[_RT, _RIes],
[[0, 1], [() => TagResourceIdList, 0]],
2
];
var ListTagsForResourcesResponse$ = [
3,
n02,
_LTFRRist,
0,
[_RTSe],
[[() => ResourceTagSetList, 0]],
1
];
var ListTrafficPoliciesRequest$ = [
3,
n02,
_LTPR,
0,
[_TPIM, _MI],
[[0, { [_hQ2]: _tr }], [1, { [_hQ2]: _max }]]
];
var ListTrafficPoliciesResponse$ = [
3,
n02,
_LTPRi,
0,
[_TPS, _IT, _TPIM, _MI],
[[() => TrafficPolicySummaries, 0], 2, 0, 1],
4
];
var ListTrafficPolicyInstancesByHostedZoneRequest$ = [
3,
n02,
_LTPIBHZR,
0,
[_HZI, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _id }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]],
1
];
var ListTrafficPolicyInstancesByHostedZoneResponse$ = [
3,
n02,
_LTPIBHZRi,
0,
[_TPIra, _IT, _MI, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0],
3
];
var ListTrafficPolicyInstancesByPolicyRequest$ = [
3,
n02,
_LTPIBPR,
0,
[_TPI, _TPV, _HZIM, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _id }], [1, { [_hQ2]: _ve }], [0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]],
2
];
var ListTrafficPolicyInstancesByPolicyResponse$ = [
3,
n02,
_LTPIBPRi,
0,
[_TPIra, _IT, _MI, _HZIM, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0, 0],
3
];
var ListTrafficPolicyInstancesRequest$ = [
3,
n02,
_LTPIR,
0,
[_HZIM, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]]
];
var ListTrafficPolicyInstancesResponse$ = [
3,
n02,
_LTPIRi,
0,
[_TPIra, _IT, _MI, _HZIM, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0, 0],
3
];
var ListTrafficPolicyVersionsRequest$ = [
3,
n02,
_LTPVR,
0,
[_I, _TPVM, _MI],
[[0, 1], [0, { [_hQ2]: _traff }], [1, { [_hQ2]: _max }]],
1
];
var ListTrafficPolicyVersionsResponse$ = [
3,
n02,
_LTPVRi,
0,
[_TPr, _IT, _TPVM, _MI],
[[() => TrafficPolicies, 0], 2, 0, 1],
4
];
var ListVPCAssociationAuthorizationsRequest$ = [
3,
n02,
_LVPCAAR,
0,
[_HZI, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListVPCAssociationAuthorizationsResponse$ = [
3,
n02,
_LVPCAARi,
0,
[_HZI, _VPCs, _NT],
[0, [() => VPCs, 0], 0],
2
];
var LocationSummary$ = [
3,
n02,
_LSo,
0,
[_LN],
[0]
];
var QueryLoggingConfig$ = [
3,
n02,
_QLC,
0,
[_I, _HZI, _CWLLGA],
[0, 0, 0],
3
];
var ResourceRecord$ = [
3,
n02,
_RR,
0,
[_V],
[0],
1
];
var ResourceRecordSet$ = [
3,
n02,
_RRS,
0,
[_N, _T, _SI, _W, _R, _GL, _Fa, _MVA, _TTL, _RRe, _AT, _HCI, _TPII, _CRC, _GPL],
[0, 0, 0, 1, 0, () => GeoLocation$, 0, 2, 1, [() => ResourceRecords, 0], () => AliasTarget$, 0, 0, () => CidrRoutingConfig$, () => GeoProximityLocation$],
2
];
var ResourceTagSet$ = [
3,
n02,
_RTS,
0,
[_RT, _RI, _Ta],
[0, 0, [() => TagList, 0]]
];
var ReusableDelegationSetLimit$ = [
3,
n02,
_RDSL,
0,
[_T, _V],
[0, 1],
2
];
var StatusReport$ = [
3,
n02,
_SR,
0,
[_S, _CTh],
[0, 4]
];
var Tag$ = [
3,
n02,
_Tag,
0,
[_K, _V],
[0, 0]
];
var TestDNSAnswerRequest$ = [
3,
n02,
_TDNSAR,
0,
[_HZI, _RN, _RTe, _RIP, _EDNSCSIP, _EDNSCSM],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _r }], [0, { [_hQ2]: _re }], [0, { [_hQ2]: _res }], [0, { [_hQ2]: _ed }], [0, { [_hQ2]: _edn }]],
3
];
var TestDNSAnswerResponse$ = [
3,
n02,
_TDNSARe,
0,
[_Nam, _RN, _RTe, _RD, _RC2, _Pr],
[0, 0, 0, [() => RecordData, 0], 0, 0],
6
];
var TrafficPolicy$ = [
3,
n02,
_TP,
0,
[_I, _Ve, _N, _T, _Do, _C],
[0, 1, 0, 0, 0, 0],
5
];
var TrafficPolicyInstance$ = [
3,
n02,
_TPIr,
0,
[_I, _HZI, _N, _TTL, _Sta, _M, _TPI, _TPV, _TPT],
[0, 0, 0, 1, 0, 0, 0, 1, 0],
9
];
var TrafficPolicySummary$ = [
3,
n02,
_TPSr,
0,
[_I, _N, _T, _LV, _TPC],
[0, 0, 0, 1, 1],
5
];
var UpdateHealthCheckRequest$ = [
3,
n02,
_UHCR,
0,
[_HCI, _HCV, _IPA, _Po, _RP, _FQDN, _SSe, _FT, _In, _Dis, _HT, _CHC, _ESNI, _Re, _AI, _IDHS, _RE],
[[0, 1], 1, 0, 1, 0, 0, 0, 1, 2, 2, 1, [() => ChildHealthCheckList, 0], 2, [() => HealthCheckRegionList, 0], () => AlarmIdentifier$, 0, [() => ResettableElementNameList, 0]],
1
];
var UpdateHealthCheckResponse$ = [
3,
n02,
_UHCRp,
0,
[_HC],
[[() => HealthCheck$, 0]],
1
];
var UpdateHostedZoneCommentRequest$ = [
3,
n02,
_UHZCR,
0,
[_I, _C],
[[0, 1], 0],
1
];
var UpdateHostedZoneCommentResponse$ = [
3,
n02,
_UHZCRp,
0,
[_HZ],
[() => HostedZone$],
1
];
var UpdateHostedZoneFeaturesRequest$ = [
3,
n02,
_UHZFR,
0,
[_HZI, _EAR],
[[0, 1], 2],
1
];
var UpdateHostedZoneFeaturesResponse$ = [
3,
n02,
_UHZFRp,
0,
[],
[]
];
var UpdateTrafficPolicyCommentRequest$ = [
3,
n02,
_UTPCR,
0,
[_I, _Ve, _C],
[[0, 1], [1, 1], 0],
3
];
var UpdateTrafficPolicyCommentResponse$ = [
3,
n02,
_UTPCRp,
0,
[_TP],
[() => TrafficPolicy$],
1
];
var UpdateTrafficPolicyInstanceRequest$ = [
3,
n02,
_UTPIR,
0,
[_I, _TTL, _TPI, _TPV],
[[0, 1], 1, 0, 1],
4
];
var UpdateTrafficPolicyInstanceResponse$ = [
3,
n02,
_UTPIRp,
0,
[_TPIr],
[() => TrafficPolicyInstance$],
1
];
var VPC$ = [
3,
n02,
_VPC,
0,
[_VPCR, _VPCI],
[0, 0]
];
var Changes = [
1,
n02,
_Cha,
0,
[
() => Change$,
{ [_xN]: _Ch }
]
];
var CheckerIpRanges = 64 | 0;
var ChildHealthCheckList = [
1,
n02,
_CHCL,
0,
[
0,
{ [_xN]: _CHCh }
]
];
var CidrBlockSummaries = [
1,
n02,
_CBSi,
0,
() => CidrBlockSummary$
];
var CidrCollectionChanges = [
1,
n02,
_CCCi,
0,
[
() => CidrCollectionChange$,
0
]
];
var CidrList = [
1,
n02,
_CL,
0,
[
0,
{ [_xN]: _Ci }
]
];
var CollectionSummaries = [
1,
n02,
_CSo,
0,
() => CollectionSummary$
];
var DelegationSetNameServers = [
1,
n02,
_DSNS,
0,
[
0,
{ [_xN]: _NSa }
]
];
var DelegationSets = [
1,
n02,
_DSe,
0,
[
() => DelegationSet$,
{ [_xN]: _DS }
]
];
var DimensionList = [
1,
n02,
_DL,
0,
[
() => Dimension$,
{ [_xN]: _Di }
]
];
var ErrorMessages = [
1,
n02,
_EM,
0,
[
0,
{ [_xN]: _M }
]
];
var GeoLocationDetailsList = [
1,
n02,
_GLDL,
0,
[
() => GeoLocationDetails$,
{ [_xN]: _GLD }
]
];
var HealthCheckObservations = [
1,
n02,
_HCO,
0,
[
() => HealthCheckObservation$,
{ [_xN]: _HCOe }
]
];
var HealthCheckRegionList = [
1,
n02,
_HCRL,
0,
[
0,
{ [_xN]: _R }
]
];
var HealthChecks = [
1,
n02,
_HCe,
0,
[
() => HealthCheck$,
{ [_xN]: _HC }
]
];
var HostedZones = [
1,
n02,
_HZo,
0,
[
() => HostedZone$,
{ [_xN]: _HZ }
]
];
var HostedZoneSummaries = [
1,
n02,
_HZSo,
0,
[
() => HostedZoneSummary$,
{ [_xN]: _HZS }
]
];
var KeySigningKeys = [
1,
n02,
_KSKe,
0,
() => KeySigningKey$
];
var LocationSummaries = [
1,
n02,
_LSoc,
0,
() => LocationSummary$
];
var QueryLoggingConfigs = [
1,
n02,
_QLCu,
0,
[
() => QueryLoggingConfig$,
{ [_xN]: _QLC }
]
];
var RecordData = [
1,
n02,
_RD,
0,
[
0,
{ [_xN]: _RDE }
]
];
var ResettableElementNameList = [
1,
n02,
_RENL,
0,
[
0,
{ [_xN]: _REN }
]
];
var ResourceRecords = [
1,
n02,
_RRe,
0,
[
() => ResourceRecord$,
{ [_xN]: _RR }
]
];
var ResourceRecordSets = [
1,
n02,
_RRSe,
0,
[
() => ResourceRecordSet$,
{ [_xN]: _RRS }
]
];
var ResourceTagSetList = [
1,
n02,
_RTSL,
0,
[
() => ResourceTagSet$,
{ [_xN]: _RTS }
]
];
var TagKeyList = [
1,
n02,
_TKL,
0,
[
0,
{ [_xN]: _K }
]
];
var TagList = [
1,
n02,
_TL,
0,
[
() => Tag$,
{ [_xN]: _Tag }
]
];
var TagResourceIdList = [
1,
n02,
_TRIL,
0,
[
0,
{ [_xN]: _RI }
]
];
var TrafficPolicies = [
1,
n02,
_TPr,
0,
[
() => TrafficPolicy$,
{ [_xN]: _TP }
]
];
var TrafficPolicyInstances = [
1,
n02,
_TPIra,
0,
[
() => TrafficPolicyInstance$,
{ [_xN]: _TPIr }
]
];
var TrafficPolicySummaries = [
1,
n02,
_TPS,
0,
[
() => TrafficPolicySummary$,
{ [_xN]: _TPSr }
]
];
var VPCs = [
1,
n02,
_VPCs,
0,
[
() => VPC$,
{ [_xN]: _VPC }
]
];
var ActivateKeySigningKey$ = [
9,
n02,
_AKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate", 200] },
() => ActivateKeySigningKeyRequest$,
() => ActivateKeySigningKeyResponse$
];
var AssociateVPCWithHostedZone$ = [
9,
n02,
_AVPCWHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/associatevpc", 200] },
() => AssociateVPCWithHostedZoneRequest$,
() => AssociateVPCWithHostedZoneResponse$
];
var ChangeCidrCollection$ = [
9,
n02,
_CCCh,
{ [_ht]: ["POST", "/2013-04-01/cidrcollection/{Id}", 200] },
() => ChangeCidrCollectionRequest$,
() => ChangeCidrCollectionResponse$
];
var ChangeResourceRecordSets$ = [
9,
n02,
_CRRS,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/rrset", 200] },
() => ChangeResourceRecordSetsRequest$,
() => ChangeResourceRecordSetsResponse$
];
var ChangeTagsForResource$ = [
9,
n02,
_CTFR,
{ [_ht]: ["POST", "/2013-04-01/tags/{ResourceType}/{ResourceId}", 200] },
() => ChangeTagsForResourceRequest$,
() => ChangeTagsForResourceResponse$
];
var CreateCidrCollection$ = [
9,
n02,
_CCCr,
{ [_ht]: ["POST", "/2013-04-01/cidrcollection", 201] },
() => CreateCidrCollectionRequest$,
() => CreateCidrCollectionResponse$
];
var CreateHealthCheck$ = [
9,
n02,
_CHCr,
{ [_ht]: ["POST", "/2013-04-01/healthcheck", 201] },
() => CreateHealthCheckRequest$,
() => CreateHealthCheckResponse$
];
var CreateHostedZone$ = [
9,
n02,
_CHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone", 201] },
() => CreateHostedZoneRequest$,
() => CreateHostedZoneResponse$
];
var CreateKeySigningKey$ = [
9,
n02,
_CKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey", 201] },
() => CreateKeySigningKeyRequest$,
() => CreateKeySigningKeyResponse$
];
var CreateQueryLoggingConfig$ = [
9,
n02,
_CQLC,
{ [_ht]: ["POST", "/2013-04-01/queryloggingconfig", 201] },
() => CreateQueryLoggingConfigRequest$,
() => CreateQueryLoggingConfigResponse$
];
var CreateReusableDelegationSet$ = [
9,
n02,
_CRDS,
{ [_ht]: ["POST", "/2013-04-01/delegationset", 201] },
() => CreateReusableDelegationSetRequest$,
() => CreateReusableDelegationSetResponse$
];
var CreateTrafficPolicy$ = [
9,
n02,
_CTP,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy", 201] },
() => CreateTrafficPolicyRequest$,
() => CreateTrafficPolicyResponse$
];
var CreateTrafficPolicyInstance$ = [
9,
n02,
_CTPI,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicyinstance", 201] },
() => CreateTrafficPolicyInstanceRequest$,
() => CreateTrafficPolicyInstanceResponse$
];
var CreateTrafficPolicyVersion$ = [
9,
n02,
_CTPV,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy/{Id}", 201] },
() => CreateTrafficPolicyVersionRequest$,
() => CreateTrafficPolicyVersionResponse$
];
var CreateVPCAssociationAuthorization$ = [
9,
n02,
_CVPCAA,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation", 200] },
() => CreateVPCAssociationAuthorizationRequest$,
() => CreateVPCAssociationAuthorizationResponse$
];
var DeactivateKeySigningKey$ = [
9,
n02,
_DKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/deactivate", 200] },
() => DeactivateKeySigningKeyRequest$,
() => DeactivateKeySigningKeyResponse$
];
var DeleteCidrCollection$ = [
9,
n02,
_DCC,
{ [_ht]: ["DELETE", "/2013-04-01/cidrcollection/{Id}", 200] },
() => DeleteCidrCollectionRequest$,
() => DeleteCidrCollectionResponse$
];
var DeleteHealthCheck$ = [
9,
n02,
_DHC,
{ [_ht]: ["DELETE", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => DeleteHealthCheckRequest$,
() => DeleteHealthCheckResponse$
];
var DeleteHostedZone$ = [
9,
n02,
_DHZ,
{ [_ht]: ["DELETE", "/2013-04-01/hostedzone/{Id}", 200] },
() => DeleteHostedZoneRequest$,
() => DeleteHostedZoneResponse$
];
var DeleteKeySigningKey$ = [
9,
n02,
_DKSKe,
{ [_ht]: ["DELETE", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}", 200] },
() => DeleteKeySigningKeyRequest$,
() => DeleteKeySigningKeyResponse$
];
var DeleteQueryLoggingConfig$ = [
9,
n02,
_DQLC,
{ [_ht]: ["DELETE", "/2013-04-01/queryloggingconfig/{Id}", 200] },
() => DeleteQueryLoggingConfigRequest$,
() => DeleteQueryLoggingConfigResponse$
];
var DeleteReusableDelegationSet$ = [
9,
n02,
_DRDS,
{ [_ht]: ["DELETE", "/2013-04-01/delegationset/{Id}", 200] },
() => DeleteReusableDelegationSetRequest$,
() => DeleteReusableDelegationSetResponse$
];
var DeleteTrafficPolicy$ = [
9,
n02,
_DTP,
{ [_ht]: ["DELETE", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => DeleteTrafficPolicyRequest$,
() => DeleteTrafficPolicyResponse$
];
var DeleteTrafficPolicyInstance$ = [
9,
n02,
_DTPI,
{ [_ht]: ["DELETE", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => DeleteTrafficPolicyInstanceRequest$,
() => DeleteTrafficPolicyInstanceResponse$
];
var DeleteVPCAssociationAuthorization$ = [
9,
n02,
_DVPCAA,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/deauthorizevpcassociation", 200] },
() => DeleteVPCAssociationAuthorizationRequest$,
() => DeleteVPCAssociationAuthorizationResponse$
];
var DisableHostedZoneDNSSEC$ = [
9,
n02,
_DHZDNSSEC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/disable-dnssec", 200] },
() => DisableHostedZoneDNSSECRequest$,
() => DisableHostedZoneDNSSECResponse$
];
var DisassociateVPCFromHostedZone$ = [
9,
n02,
_DVPCFHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/disassociatevpc", 200] },
() => DisassociateVPCFromHostedZoneRequest$,
() => DisassociateVPCFromHostedZoneResponse$
];
var EnableHostedZoneDNSSEC$ = [
9,
n02,
_EHZDNSSEC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/enable-dnssec", 200] },
() => EnableHostedZoneDNSSECRequest$,
() => EnableHostedZoneDNSSECResponse$
];
var GetAccountLimit$ = [
9,
n02,
_GAL,
{ [_ht]: ["GET", "/2013-04-01/accountlimit/{Type}", 200] },
() => GetAccountLimitRequest$,
() => GetAccountLimitResponse$
];
var GetChange$ = [
9,
n02,
_GC,
{ [_ht]: ["GET", "/2013-04-01/change/{Id}", 200] },
() => GetChangeRequest$,
() => GetChangeResponse$
];
var GetCheckerIpRanges$ = [
9,
n02,
_GCIR,
{ [_ht]: ["GET", "/2013-04-01/checkeripranges", 200] },
() => GetCheckerIpRangesRequest$,
() => GetCheckerIpRangesResponse$
];
var GetDNSSEC$ = [
9,
n02,
_GDNSSEC,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/dnssec", 200] },
() => GetDNSSECRequest$,
() => GetDNSSECResponse$
];
var GetGeoLocation$ = [
9,
n02,
_GGL,
{ [_ht]: ["GET", "/2013-04-01/geolocation", 200] },
() => GetGeoLocationRequest$,
() => GetGeoLocationResponse$
];
var GetHealthCheck$ = [
9,
n02,
_GHC,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => GetHealthCheckRequest$,
() => GetHealthCheckResponse$
];
var GetHealthCheckCount$ = [
9,
n02,
_GHCC,
{ [_ht]: ["GET", "/2013-04-01/healthcheckcount", 200] },
() => GetHealthCheckCountRequest$,
() => GetHealthCheckCountResponse$
];
var GetHealthCheckLastFailureReason$ = [
9,
n02,
_GHCLFR,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason", 200] },
() => GetHealthCheckLastFailureReasonRequest$,
() => GetHealthCheckLastFailureReasonResponse$
];
var GetHealthCheckStatus$ = [
9,
n02,
_GHCS,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}/status", 200] },
() => GetHealthCheckStatusRequest$,
() => GetHealthCheckStatusResponse$
];
var GetHostedZone$ = [
9,
n02,
_GHZ,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{Id}", 200] },
() => GetHostedZoneRequest$,
() => GetHostedZoneResponse$
];
var GetHostedZoneCount$ = [
9,
n02,
_GHZC,
{ [_ht]: ["GET", "/2013-04-01/hostedzonecount", 200] },
() => GetHostedZoneCountRequest$,
() => GetHostedZoneCountResponse$
];
var GetHostedZoneLimit$ = [
9,
n02,
_GHZL,
{ [_ht]: ["GET", "/2013-04-01/hostedzonelimit/{HostedZoneId}/{Type}", 200] },
() => GetHostedZoneLimitRequest$,
() => GetHostedZoneLimitResponse$
];
var GetQueryLoggingConfig$ = [
9,
n02,
_GQLC,
{ [_ht]: ["GET", "/2013-04-01/queryloggingconfig/{Id}", 200] },
() => GetQueryLoggingConfigRequest$,
() => GetQueryLoggingConfigResponse$
];
var GetReusableDelegationSet$ = [
9,
n02,
_GRDS,
{ [_ht]: ["GET", "/2013-04-01/delegationset/{Id}", 200] },
() => GetReusableDelegationSetRequest$,
() => GetReusableDelegationSetResponse$
];
var GetReusableDelegationSetLimit$ = [
9,
n02,
_GRDSL,
{ [_ht]: ["GET", "/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}", 200] },
() => GetReusableDelegationSetLimitRequest$,
() => GetReusableDelegationSetLimitResponse$
];
var GetTrafficPolicy$ = [
9,
n02,
_GTP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => GetTrafficPolicyRequest$,
() => GetTrafficPolicyResponse$
];
var GetTrafficPolicyInstance$ = [
9,
n02,
_GTPI,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => GetTrafficPolicyInstanceRequest$,
() => GetTrafficPolicyInstanceResponse$
];
var GetTrafficPolicyInstanceCount$ = [
9,
n02,
_GTPIC,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstancecount", 200] },
() => GetTrafficPolicyInstanceCountRequest$,
() => GetTrafficPolicyInstanceCountResponse$
];
var ListCidrBlocks$ = [
9,
n02,
_LCB,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection/{CollectionId}/cidrblocks", 200] },
() => ListCidrBlocksRequest$,
() => ListCidrBlocksResponse$
];
var ListCidrCollections$ = [
9,
n02,
_LCC,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection", 200] },
() => ListCidrCollectionsRequest$,
() => ListCidrCollectionsResponse$
];
var ListCidrLocations$ = [
9,
n02,
_LCL,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection/{CollectionId}", 200] },
() => ListCidrLocationsRequest$,
() => ListCidrLocationsResponse$
];
var ListGeoLocations$ = [
9,
n02,
_LGL,
{ [_ht]: ["GET", "/2013-04-01/geolocations", 200] },
() => ListGeoLocationsRequest$,
() => ListGeoLocationsResponse$
];
var ListHealthChecks$ = [
9,
n02,
_LHC,
{ [_ht]: ["GET", "/2013-04-01/healthcheck", 200] },
() => ListHealthChecksRequest$,
() => ListHealthChecksResponse$
];
var ListHostedZones$ = [
9,
n02,
_LHZ,
{ [_ht]: ["GET", "/2013-04-01/hostedzone", 200] },
() => ListHostedZonesRequest$,
() => ListHostedZonesResponse$
];
var ListHostedZonesByName$ = [
9,
n02,
_LHZBN,
{ [_ht]: ["GET", "/2013-04-01/hostedzonesbyname", 200] },
() => ListHostedZonesByNameRequest$,
() => ListHostedZonesByNameResponse$
];
var ListHostedZonesByVPC$ = [
9,
n02,
_LHZBVPC,
{ [_ht]: ["GET", "/2013-04-01/hostedzonesbyvpc", 200] },
() => ListHostedZonesByVPCRequest$,
() => ListHostedZonesByVPCResponse$
];
var ListQueryLoggingConfigs$ = [
9,
n02,
_LQLC,
{ [_ht]: ["GET", "/2013-04-01/queryloggingconfig", 200] },
() => ListQueryLoggingConfigsRequest$,
() => ListQueryLoggingConfigsResponse$
];
var ListResourceRecordSets$ = [
9,
n02,
_LRRS,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/rrset", 200] },
() => ListResourceRecordSetsRequest$,
() => ListResourceRecordSetsResponse$
];
var ListReusableDelegationSets$ = [
9,
n02,
_LRDS,
{ [_ht]: ["GET", "/2013-04-01/delegationset", 200] },
() => ListReusableDelegationSetsRequest$,
() => ListReusableDelegationSetsResponse$
];
var ListTagsForResource$ = [
9,
n02,
_LTFR,
{ [_ht]: ["GET", "/2013-04-01/tags/{ResourceType}/{ResourceId}", 200] },
() => ListTagsForResourceRequest$,
() => ListTagsForResourceResponse$
];
var ListTagsForResources$ = [
9,
n02,
_LTFRi,
{ [_ht]: ["POST", "/2013-04-01/tags/{ResourceType}", 200] },
() => ListTagsForResourcesRequest$,
() => ListTagsForResourcesResponse$
];
var ListTrafficPolicies$ = [
9,
n02,
_LTP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicies", 200] },
() => ListTrafficPoliciesRequest$,
() => ListTrafficPoliciesResponse$
];
var ListTrafficPolicyInstances$ = [
9,
n02,
_LTPI,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances", 200] },
() => ListTrafficPolicyInstancesRequest$,
() => ListTrafficPolicyInstancesResponse$
];
var ListTrafficPolicyInstancesByHostedZone$ = [
9,
n02,
_LTPIBHZ,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances/hostedzone", 200] },
() => ListTrafficPolicyInstancesByHostedZoneRequest$,
() => ListTrafficPolicyInstancesByHostedZoneResponse$
];
var ListTrafficPolicyInstancesByPolicy$ = [
9,
n02,
_LTPIBP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances/trafficpolicy", 200] },
() => ListTrafficPolicyInstancesByPolicyRequest$,
() => ListTrafficPolicyInstancesByPolicyResponse$
];
var ListTrafficPolicyVersions$ = [
9,
n02,
_LTPV,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicies/{Id}/versions", 200] },
() => ListTrafficPolicyVersionsRequest$,
() => ListTrafficPolicyVersionsResponse$
];
var ListVPCAssociationAuthorizations$ = [
9,
n02,
_LVPCAA,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation", 200] },
() => ListVPCAssociationAuthorizationsRequest$,
() => ListVPCAssociationAuthorizationsResponse$
];
var TestDNSAnswer$ = [
9,
n02,
_TDNSA,
{ [_ht]: ["GET", "/2013-04-01/testdnsanswer", 200] },
() => TestDNSAnswerRequest$,
() => TestDNSAnswerResponse$
];
var UpdateHealthCheck$ = [
9,
n02,
_UHC,
{ [_ht]: ["POST", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => UpdateHealthCheckRequest$,
() => UpdateHealthCheckResponse$
];
var UpdateHostedZoneComment$ = [
9,
n02,
_UHZC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{Id}", 200] },
() => UpdateHostedZoneCommentRequest$,
() => UpdateHostedZoneCommentResponse$
];
var UpdateHostedZoneFeatures$ = [
9,
n02,
_UHZF,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/features", 200] },
() => UpdateHostedZoneFeaturesRequest$,
() => UpdateHostedZoneFeaturesResponse$
];
var UpdateTrafficPolicyComment$ = [
9,
n02,
_UTPC,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => UpdateTrafficPolicyCommentRequest$,
() => UpdateTrafficPolicyCommentResponse$
];
var UpdateTrafficPolicyInstance$ = [
9,
n02,
_UTPI,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => UpdateTrafficPolicyInstanceRequest$,
() => UpdateTrafficPolicyInstanceResponse$
];
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.shared.js
var getRuntimeConfig2 = (config) => {
return {
apiVersion: "2013-04-01",
base64Decoder: config?.base64Decoder ?? import_serde3.fromBase64,
base64Encoder: config?.base64Encoder ?? import_serde3.toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver2,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultRoute53HttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new import_httpAuthSchemes2.AwsSdkSigV4Signer
}
],
logger: config?.logger ?? new import_client19.NoOpLogger,
protocol: config?.protocol ?? import_protocols4.AwsRestXmlProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.route53",
errorTypeRegistries: errorTypeRegistries2,
xmlNamespace: "https://route53.amazonaws.com/doc/2013-04-01/",
version: "2013-04-01",
serviceTarget: "AWSDnsV20130401"
},
serviceId: config?.serviceId ?? "Route 53",
sha256: config?.sha256 ?? import_checksum.Sha256,
urlParser: config?.urlParser ?? import_protocols5.parseUrl,
utf8Decoder: config?.utf8Decoder ?? import_serde3.fromUtf8,
utf8Encoder: config?.utf8Encoder ?? import_serde3.toUtf8
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var getRuntimeConfig3 = (config) => {
import_client21.emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = import_config28.resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(import_client21.loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig2(config);
import_client20.emitWarningIfUnsupportedVersion(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? import_config28.loadConfig(import_httpAuthSchemes3.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? import_serde4.calculateBodyLength,
credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? import_client20.createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default.version }),
maxAttempts: config?.maxAttempts ?? import_config28.loadConfig(import_retry3.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? import_config28.loadConfig(import_config28.NODE_REGION_CONFIG_OPTIONS, { ...import_config28.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: import_node_http_handler2.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config28.loadConfig({
...import_retry3.NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || import_retry3.DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? import_node_http_handler2.streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? import_config28.loadConfig(import_config28.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? import_config28.loadConfig(import_config28.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? import_config28.loadConfig(import_client20.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeExtensions.js
var import_client22 = __toESM(require_client2());
var import_client23 = __toESM(require_client());
var import_protocols6 = __toESM(require_protocols());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration2 = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig2 = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions2 = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(import_client22.getAwsRegionExtensionConfiguration(runtimeConfig), import_client23.getDefaultExtensionConfiguration(runtimeConfig), import_protocols6.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration2(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, import_client22.resolveAwsRegionExtensionConfiguration(extensionConfiguration), import_client23.resolveDefaultRuntimeConfig(extensionConfiguration), import_protocols6.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig2(extensionConfiguration));
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/Route53Client.js
class Route53Client extends import_client25.Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig3(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = import_client24.resolveUserAgentConfig(_config_1);
const _config_3 = import_retry4.resolveRetryConfig(_config_2);
const _config_4 = import_config29.resolveRegionConfig(_config_3);
const _config_5 = import_client24.resolveHostHeaderConfig(_config_4);
const _config_6 = import_endpoints3.resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions2(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(import_schema2.getSchemaSerdePlugin(this.config));
this.middlewareStack.use(import_client24.getUserAgentPlugin(this.config));
this.middlewareStack.use(import_retry4.getRetryPlugin(this.config));
this.middlewareStack.use(import_protocols7.getContentLengthPlugin(this.config));
this.middlewareStack.use(import_client24.getHostHeaderPlugin(this.config));
this.middlewareStack.use(import_client24.getLoggerPlugin(this.config));
this.middlewareStack.use(import_client24.getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(import_core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53HttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(import_core.getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/constants.js
var IDENTIFIER_PREFIX_PATTERN = /^\/(hostedzone|change|delegationset)\//;
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/change-resource-record-sets.js
function changeResourceRecordSetsMiddleware() {
return (next) => async (args) => {
const { ChangeBatch } = args.input;
const Changes = [];
for (const change of ChangeBatch?.Changes ?? []) {
const { AliasTarget } = change.ResourceRecordSet ?? {};
if (AliasTarget) {
Changes.push({
...change,
ResourceRecordSet: {
...change.ResourceRecordSet,
AliasTarget: {
...AliasTarget,
HostedZoneId: AliasTarget.HostedZoneId.replace(IDENTIFIER_PREFIX_PATTERN, "")
}
}
});
} else {
Changes.push(change);
}
}
return next({
...args,
input: {
...args.input,
ChangeBatch: {
...ChangeBatch,
Changes
}
}
});
};
}
var changeResourceRecordSetsMiddlewareOptions = {
step: "initialize",
tags: ["ROUTE53_IDS", "CHANGE_RESOURCE_RECORD_SETS"],
name: "changeResourceRecordSetsMiddleware",
override: true
};
var getChangeResourceRecordSetsPlugin = (unused) => ({
applyToStack: (clientStack) => {
clientStack.add(changeResourceRecordSetsMiddleware(), changeResourceRecordSetsMiddlewareOptions);
}
});
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/id-normalizer.js
var IDENTIFIER_PARAMETERS = ["DelegationSetId", "HostedZoneId", "Id"];
function idNormalizerMiddleware() {
return (next) => async (args) => {
const input = { ...args.input };
for (const paramName of IDENTIFIER_PARAMETERS) {
const param = input[paramName];
if (param) {
input[paramName] = param.replace(IDENTIFIER_PREFIX_PATTERN, "");
}
}
return next({
...args,
input
});
};
}
var idNormalizerMiddlewareOptions = {
step: "initialize",
tags: ["ROUTE53_IDS"],
name: "idNormalizerMiddleware",
override: true
};
var getIdNormalizerPlugin = (unused) => ({
applyToStack: (clientStack) => {
clientStack.add(idNormalizerMiddleware(), idNormalizerMiddlewareOptions);
}
});
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commandBuilder.js
var import_client26 = __toESM(require_client());
var import_endpoints4 = __toESM(require_endpoints());
var command2 = import_client26.makeBuilder(commonParams, "AWSDnsV20130401", "Route53Client", import_endpoints4.getEndpointPlugin);
var _ep02 = {};
var _mw02 = (Command, cs, config, o) => [
getIdNormalizerPlugin(config)
];
var _mw1 = (Command, cs, config, o) => [
getChangeResourceRecordSetsPlugin(config),
getIdNormalizerPlugin(config)
];
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ChangeResourceRecordSetsCommand.js
class ChangeResourceRecordSetsCommand extends command2(_ep02, _mw1, "ChangeResourceRecordSets", ChangeResourceRecordSets$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/CreateHostedZoneCommand.js
class CreateHostedZoneCommand extends command2(_ep02, _mw02, "CreateHostedZone", CreateHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/DeleteHostedZoneCommand.js
class DeleteHostedZoneCommand extends command2(_ep02, _mw02, "DeleteHostedZone", DeleteHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/GetHostedZoneCommand.js
class GetHostedZoneCommand extends command2(_ep02, _mw02, "GetHostedZone", GetHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ListHostedZonesByNameCommand.js
class ListHostedZonesByNameCommand extends command2(_ep02, _mw02, "ListHostedZonesByName", ListHostedZonesByName$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ListHostedZonesCommand.js
class ListHostedZonesCommand extends command2(_ep02, _mw02, "ListHostedZones", ListHostedZones$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ListResourceRecordSetsCommand.js
class ListResourceRecordSetsCommand extends command2(_ep02, _mw02, "ListResourceRecordSets", ListResourceRecordSets$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/Route53DomainsClient.js
var import_client35 = __toESM(require_client2());
var import_core2 = __toESM(require_dist_cjs2());
var import_client36 = __toESM(require_client());
var import_config31 = __toESM(require_config());
var import_endpoints7 = __toESM(require_endpoints());
var import_protocols11 = __toESM(require_protocols());
var import_retry6 = __toESM(require_retry());
var import_schema4 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/auth/httpAuthSchemeProvider.js
var import_httpAuthSchemes4 = __toESM(require_httpAuthSchemes());
var import_client27 = __toESM(require_client());
var defaultRoute53DomainsHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: import_client27.getSmithyContext(context).operation,
region: await import_client27.normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption3(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "route53domains",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
var defaultRoute53DomainsHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
default: {
options.push(createAwsAuthSigv4HttpAuthOption3(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig3 = (config) => {
const config_0 = import_httpAuthSchemes4.resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: import_client27.normalizeProvider(config.authSchemePreference ?? [])
});
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters3 = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "route53domains"
});
};
var commonParams3 = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/package.json
var package_default2 = {
name: "@aws-sdk/client-route-53-domains",
version: "3.1127.0",
description: "AWS SDK for JavaScript Route 53 Domains Client for Node.js, Browser and React Native",
homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-route-53-domains",
license: "Apache-2.0",
author: {
name: "AWS SDK for JavaScript Team",
url: "https://aws.amazon.com/sdk-for-javascript/"
},
repository: {
type: "git",
url: "https://github.com/aws/aws-sdk-js-v3.git",
directory: "clients/client-route-53-domains"
},
files: [
"dist-*/**"
],
sideEffects: false,
main: "./dist-cjs/index.js",
module: "./dist-es/index.js",
browser: {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
},
types: "./dist-types/index.d.ts",
typesVersions: {
"<4.5": {
"dist-types/*": [
"dist-types/ts3.4/*"
]
}
},
"react-native": {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
},
scripts: {
build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
"build:cjs": "node ../../scripts/compilation/inline",
"build:es": "premove dist-es && tsc -p tsconfig.es.json",
"build:include:deps": 'yarn g:turbo run build -F="$npm_package_name"',
"build:types": "premove dist-types && tsc -p tsconfig.types.json",
"build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
clean: "premove dist-cjs dist-es dist-types",
"extract:docs": "api-extractor run --local",
"generate:client": "node ../../scripts/generate-clients/single-service",
"test:e2e": "yarn g:vitest run -c vitest.config.e2e.mts",
"test:e2e:watch": "yarn g:vitest watch -c vitest.config.e2e.mts",
"test:index": "tsc -p tsconfig.test.json && node ./test/index-objects.spec.mjs"
},
dependencies: {
"@aws-sdk/core": "^3.977.9",
"@aws-sdk/credential-provider-node": "^3.972.82",
"@aws-sdk/types": "^3.974.5",
"@smithy/core": "^3.33.3",
"@smithy/fetch-http-handler": "^5.7.2",
"@smithy/node-http-handler": "^4.11.3",
"@smithy/types": "^4.17.2",
tslib: "^2.6.2"
},
devDependencies: {
"@tsconfig/node20": "20.1.8",
"@types/node": "^20.14.8",
concurrently: "7.0.0",
"downlevel-dts": "0.10.1",
premove: "4.0.0",
typescript: "~7.0.2"
},
engines: {
node: ">=20.0.0"
}
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.js
var import_client31 = __toESM(require_client2());
var import_httpAuthSchemes6 = __toESM(require_httpAuthSchemes());
var import_client32 = __toESM(require_client());
var import_config30 = __toESM(require_config());
var import_retry5 = __toESM(require_retry());
var import_serde6 = __toESM(require_serde());
var import_node_http_handler3 = __toESM(require_dist_cjs4());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.shared.js
var import_httpAuthSchemes5 = __toESM(require_httpAuthSchemes());
var import_protocols8 = __toESM(require_protocols2());
var import_checksum2 = __toESM(require_checksum());
var import_client30 = __toESM(require_client());
var import_protocols9 = __toESM(require_protocols());
var import_serde5 = __toESM(require_serde());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/endpointResolver.js
var import_client28 = __toESM(require_client2());
var import_endpoints6 = __toESM(require_endpoints());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/bdd.js
var import_endpoints5 = __toESM(require_endpoints());
var k3 = "ref";
var a3 = -1;
var b3 = true;
var c3 = "isSet";
var d3 = "PartitionResult";
var e4 = "booleanEquals";
var f3 = "getAttr";
var g3 = { [k3]: "Endpoint" };
var h3 = { [k3]: d3 };
var i3 = {};
var j3 = [{ [k3]: "Region" }];
var _data3 = {
conditions: [
[c3, [g3]],
[c3, j3],
["aws.partition", j3, d3],
[e4, [{ [k3]: "UseFIPS" }, b3]],
[e4, [{ [k3]: "UseDualStack" }, b3]],
[e4, [{ fn: f3, argv: [h3, "supportsDualStack"] }, b3]],
[e4, [{ fn: f3, argv: [h3, "supportsFIPS"] }, b3]]
],
results: [
[a3],
[a3, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a3, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g3, i3],
["https://route53domains-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i3],
[a3, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://route53domains-fips.{Region}.{PartitionResult#dnsSuffix}", i3],
[a3, "FIPS is enabled but this partition does not support FIPS"],
["https://route53domains.{Region}.{PartitionResult#dualStackDnsSuffix}", i3],
[a3, "DualStack is enabled but this partition does not support DualStack"],
["https://route53domains.{Region}.{PartitionResult#dnsSuffix}", i3],
[a3, "Invalid Configuration: Missing Region"]
]
};
var root3 = 2;
var r4 = 1e8;
var nodes3 = new Int32Array([
-1,
1,
-1,
0,
12,
3,
1,
4,
r4 + 11,
2,
5,
r4 + 11,
3,
8,
6,
4,
7,
r4 + 10,
5,
r4 + 8,
r4 + 9,
4,
10,
9,
6,
r4 + 6,
r4 + 7,
5,
11,
r4 + 5,
6,
r4 + 4,
r4 + 5,
3,
r4 + 1,
13,
4,
r4 + 2,
r4 + 3
]);
var bdd3 = import_endpoints5.BinaryDecisionDiagram.from(nodes3, root3, _data3.conditions, _data3.results);
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/endpointResolver.js
var cache3 = new import_endpoints6.EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver3 = (endpointParams, context = {}) => {
return cache3.get(endpointParams, () => import_endpoints6.decideEndpoint(bdd3, {
endpointParams,
logger: context.logger
}));
};
import_endpoints6.customEndpointFunctions.aws = import_client28.awsEndpointFunctions;
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/schemas/schemas_0.js
var import_schema3 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/models/Route53DomainsServiceException.js
var import_client29 = __toESM(require_client());
class Route53DomainsServiceException extends import_client29.ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, Route53DomainsServiceException.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/models/errors.js
class DomainLimitExceeded extends Route53DomainsServiceException {
name = "DomainLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "DomainLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DomainLimitExceeded.prototype);
}
}
class InvalidInput2 extends Route53DomainsServiceException {
name = "InvalidInput";
$fault = "client";
constructor(opts) {
super({
name: "InvalidInput",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidInput2.prototype);
}
}
class OperationLimitExceeded extends Route53DomainsServiceException {
name = "OperationLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "OperationLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, OperationLimitExceeded.prototype);
}
}
class UnsupportedTLD extends Route53DomainsServiceException {
name = "UnsupportedTLD";
$fault = "client";
constructor(opts) {
super({
name: "UnsupportedTLD",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnsupportedTLD.prototype);
}
}
class DnssecLimitExceeded extends Route53DomainsServiceException {
name = "DnssecLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "DnssecLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DnssecLimitExceeded.prototype);
}
}
class DuplicateRequest extends Route53DomainsServiceException {
name = "DuplicateRequest";
$fault = "client";
requestId;
constructor(opts) {
super({
name: "DuplicateRequest",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DuplicateRequest.prototype);
this.requestId = opts.requestId;
}
}
class TLDRulesViolation extends Route53DomainsServiceException {
name = "TLDRulesViolation";
$fault = "client";
constructor(opts) {
super({
name: "TLDRulesViolation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TLDRulesViolation.prototype);
}
}
class TLDInMaintenance extends Route53DomainsServiceException {
name = "TLDInMaintenance";
$fault = "client";
tld;
constructor(opts) {
super({
name: "TLDInMaintenance",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TLDInMaintenance.prototype);
this.tld = opts.tld;
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/schemas/schemas_0.js
var _A2 = "Availability";
var _AC = "AuthCode";
var _ACE = "AbuseContactEmail";
var _ACP = "AbuseContactPhone";
var _ACd = "AdminContact";
var _AL2 = "AddressLine";
var _ALd = "AddressLine1";
var _ALdd = "AddressLine2";
var _AP = "AdminPrivacy";
var _AR2 = "AutoRenew";
var _Al = "Algorithm";
var _BC = "BillingContact";
var _BP = "BillingPrivacy";
var _C2 = "City";
var _CC2 = "CountryCode";
var _CD2 = "ContactDetail";
var _CDA = "CheckDomainAvailability";
var _CDAR = "CheckDomainAvailabilityRequest";
var _CDARh = "CheckDomainAvailabilityResponse";
var _CDr = "CreationDate";
var _CN2 = "ContactName";
var _CNo2 = "ContactNumber";
var _COP = "ChangeOwnershipPrice";
var _CT2 = "ContactType";
var _Cu = "Currency";
var _D2 = "Digest";
var _DAC = "DomainAuthCode";
var _DDTL = "DisableDomainTransferLock";
var _DDTLR = "DisableDomainTransferLockRequest";
var _DDTLRi = "DisableDomainTransferLockResponse";
var _DIY = "DurationInYears";
var _DK = "DnssecKey";
var _DKL = "DnssecKeyList";
var _DKn = "DnssecKeys";
var _DLE = "DnssecLimitExceeded";
var _DLEo = "DomainLimitExceeded";
var _DN = "DomainName";
var _DP = "DomainPrice";
var _DPL = "DomainPriceList";
var _DR = "DuplicateRequest";
var _DSLo = "DomainSummaryList";
var _DSn = "DnsSec";
var _DSo = "DomainSummary";
var _DT = "DigestType";
var _DTFDR = "DeleteTagsForDomainRequest";
var _Do2 = "Domains";
var _E = "Email";
var _ED = "ExpirationDate";
var _EP2 = "ExtraParams";
var _EPL = "ExtraParamList";
var _EPV = "ExtraParamValue";
var _EPx = "ExtraParam";
var _Ex = "Expiry";
var _F2 = "Fax";
var _FC = "FilterCondition";
var _FCi = "FilterConditions";
var _FIAK = "FIAuthKey";
var _FN = "FirstName";
var _Fl2 = "Flags";
var _GDD = "GetDomainDetail";
var _GDDR = "GetDomainDetailRequest";
var _GDDRe = "GetDomainDetailResponse";
var _GI = "GlueIps";
var _GOD = "GetOperationDetail";
var _GODR = "GetOperationDetailRequest";
var _GODRe = "GetOperationDetailResponse";
var _I2 = "Id";
var _II2 = "InvalidInput";
var _ILC = "IdnLangCode";
var _KT2 = "KeyTag";
var _LD = "ListDomains";
var _LDR = "ListDomainsRequest";
var _LDRi = "ListDomainsResponse";
var _LN2 = "LastName";
var _LOR = "ListOperationsRequest";
var _LP = "ListPrices";
var _LPR = "ListPricesRequest";
var _LPRi = "ListPricesResponse";
var _LUD = "LastUpdatedDate";
var _M2 = "Message";
var _MI2 = "MaxItems";
var _Ma2 = "Marker";
var _N2 = "Name";
var _NL = "NameserverList";
var _NPM = "NextPageMarker";
var _Na2 = "Nameservers";
var _Nam2 = "Nameserver";
var _OI = "OperationId";
var _OLE = "OperationLimitExceeded";
var _ON = "OrganizationName";
var _Op = "Operator";
var _PK2 = "PublicKey";
var _PN = "PhoneNumber";
var _PPAC = "PrivacyProtectAdminContact";
var _PPBC = "PrivacyProtectBillingContact";
var _PPRC = "PrivacyProtectRegistrantContact";
var _PPTC = "PrivacyProtectTechContact";
var _PWC = "PriceWithCurrency";
var _Pr2 = "Price";
var _Pri = "Prices";
var _R2 = "Reseller";
var _RC3 = "RegistrantContact";
var _RD2 = "RegisterDomain";
var _RDAC = "RetrieveDomainAuthCode";
var _RDACR = "RetrieveDomainAuthCodeRequest";
var _RDACRe = "RetrieveDomainAuthCodeResponse";
var _RDI = "RegistryDomainId";
var _RDR = "RegisterDomainRequest";
var _RDRe = "RegisterDomainResponse";
var _RN2 = "RegistrarName";
var _RP2 = "RegistrationPrice";
var _RPe = "RenewalPrice";
var _RPeg = "RegistrantPrivacy";
var _RPes = "RestorationPrice";
var _RU = "RegistrarUrl";
var _S2 = "State";
var _SB = "SortBy";
var _SCo = "SortCondition";
var _SD = "SubmittedDate";
var _SF = "StatusFlag";
var _SL = "StatusList";
var _SO = "SortOrder";
var _SS2 = "SubmittedSince";
var _St2 = "Status";
var _TC = "TechContact";
var _TD = "TransferDomain";
var _TDR = "TransferDomainRequest";
var _TDRr = "TransferDomainResponse";
var _TL2 = "TransferLock";
var _TLDIM = "TLDInMaintenance";
var _TLDRV = "TLDRulesViolation";
var _TP2 = "TransferPrice";
var _TPe = "TechPrivacy";
var _TTD = "TagsToDelete";
var _Tl = "Tld";
var _Ty = "Type";
var _UD = "UpdatedDate";
var _UDN = "UpdateDomainNameservers";
var _UDNR = "UpdateDomainNameserversRequest";
var _UDNRp = "UpdateDomainNameserversResponse";
var _UTLD = "UnsupportedTLD";
var _V2 = "Value";
var _Va = "Values";
var _WIS = "WhoIsServer";
var _ZC = "ZipCode";
var _c3 = "client";
var _e3 = "error";
var _hE3 = "httpError";
var _m3 = "message";
var _rI = "requestId";
var _s3 = "smithy.ts.sdk.synthetic.com.amazonaws.route53domains";
var _t2 = "tld";
var n03 = "com.amazonaws.route53domains";
var _s_registry3 = import_schema3.TypeRegistry.for(_s3);
var Route53DomainsServiceException$ = [-3, _s3, "Route53DomainsServiceException", 0, [], []];
_s_registry3.registerError(Route53DomainsServiceException$, Route53DomainsServiceException);
var n0_registry3 = import_schema3.TypeRegistry.for(n03);
var DnssecLimitExceeded$ = [
-3,
n03,
_DLE,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(DnssecLimitExceeded$, DnssecLimitExceeded);
var DomainLimitExceeded$ = [
-3,
n03,
_DLEo,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(DomainLimitExceeded$, DomainLimitExceeded);
var DuplicateRequest$ = [
-3,
n03,
_DR,
{ [_e3]: _c3, [_hE3]: 400 },
[_rI, _m3],
[0, 0]
];
n0_registry3.registerError(DuplicateRequest$, DuplicateRequest);
var InvalidInput$2 = [
-3,
n03,
_II2,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(InvalidInput$2, InvalidInput2);
var OperationLimitExceeded$ = [
-3,
n03,
_OLE,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(OperationLimitExceeded$, OperationLimitExceeded);
var TLDInMaintenance$ = [
-3,
n03,
_TLDIM,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3, _t2],
[0, 0]
];
n0_registry3.registerError(TLDInMaintenance$, TLDInMaintenance);
var TLDRulesViolation$ = [
-3,
n03,
_TLDRV,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(TLDRulesViolation$, TLDRulesViolation);
var UnsupportedTLD$ = [
-3,
n03,
_UTLD,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(UnsupportedTLD$, UnsupportedTLD);
var errorTypeRegistries3 = [
_s_registry3,
n0_registry3
];
var AddressLine = [0, n03, _AL2, 8, 0];
var City = [0, n03, _C2, 8, 0];
var ContactName = [0, n03, _CN2, 8, 0];
var ContactNumber = [0, n03, _CNo2, 8, 0];
var CountryCode = [0, n03, _CC2, 8, 0];
var DomainAuthCode = [0, n03, _DAC, 8, 0];
var Email = [0, n03, _E, 8, 0];
var ExtraParamValue = [0, n03, _EPV, 8, 0];
var FIAuthKey = [0, n03, _FIAK, 8, 0];
var State = [0, n03, _S2, 8, 0];
var ZipCode = [0, n03, _ZC, 8, 0];
var CheckDomainAvailabilityRequest$ = [
3,
n03,
_CDAR,
0,
[_DN, _ILC],
[0, 0],
1
];
var CheckDomainAvailabilityResponse$ = [
3,
n03,
_CDARh,
0,
[_A2],
[0]
];
var ContactDetail$ = [
3,
n03,
_CD2,
8,
[_FN, _LN2, _CT2, _ON, _ALd, _ALdd, _C2, _S2, _CC2, _ZC, _PN, _E, _F2, _EP2],
[[() => ContactName, 0], [() => ContactName, 0], 0, [() => ContactName, 0], [() => AddressLine, 0], [() => AddressLine, 0], [() => City, 0], [() => State, 0], [() => CountryCode, 0], [() => ZipCode, 0], [() => ContactNumber, 0], [() => Email, 0], [() => ContactNumber, 0], [() => ExtraParamList, 0]]
];
var DeleteTagsForDomainRequest$ = [
3,
n03,
_DTFDR,
0,
[_DN, _TTD],
[0, 64 | 0],
2
];
var DisableDomainTransferLockRequest$ = [
3,
n03,
_DDTLR,
0,
[_DN],
[0],
1
];
var DisableDomainTransferLockResponse$ = [
3,
n03,
_DDTLRi,
0,
[_OI],
[0]
];
var DnssecKey$ = [
3,
n03,
_DK,
0,
[_Al, _Fl2, _PK2, _DT, _D2, _KT2, _I2],
[1, 1, 0, 1, 0, 1, 0]
];
var DomainPrice$ = [
3,
n03,
_DP,
0,
[_N2, _RP2, _TP2, _RPe, _COP, _RPes],
[0, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$]
];
var DomainSummary$ = [
3,
n03,
_DSo,
0,
[_DN, _AR2, _TL2, _Ex],
[0, 2, 2, 4]
];
var ExtraParam$ = [
3,
n03,
_EPx,
0,
[_N2, _V2],
[0, [() => ExtraParamValue, 0]],
2
];
var FilterCondition$ = [
3,
n03,
_FC,
0,
[_N2, _Op, _Va],
[0, 0, 64 | 0],
3
];
var GetDomainDetailRequest$ = [
3,
n03,
_GDDR,
0,
[_DN],
[0],
1
];
var GetDomainDetailResponse$ = [
3,
n03,
_GDDRe,
0,
[_DN, _Na2, _AR2, _ACd, _RC3, _TC, _AP, _RPeg, _TPe, _RN2, _WIS, _RU, _ACE, _ACP, _RDI, _CDr, _UD, _ED, _R2, _DSn, _SL, _DKn, _BC, _BP],
[0, () => NameserverList, 2, [() => ContactDetail$, 0], [() => ContactDetail$, 0], [() => ContactDetail$, 0], 2, 2, 2, 0, 0, 0, [() => Email, 0], [() => ContactNumber, 0], 0, 4, 4, 4, 0, 0, 64 | 0, () => DnssecKeyList, [() => ContactDetail$, 0], 2]
];
var GetOperationDetailRequest$ = [
3,
n03,
_GODR,
0,
[_OI],
[0],
1
];
var GetOperationDetailResponse$ = [
3,
n03,
_GODRe,
0,
[_OI, _St2, _M2, _DN, _Ty, _SD, _LUD, _SF],
[0, 0, 0, 0, 0, 4, 4, 0]
];
var ListDomainsRequest$ = [
3,
n03,
_LDR,
0,
[_FCi, _SCo, _Ma2, _MI2],
[() => FilterConditions, () => SortCondition$, 0, 1]
];
var ListDomainsResponse$ = [
3,
n03,
_LDRi,
0,
[_Do2, _NPM],
[() => DomainSummaryList, 0]
];
var ListOperationsRequest$ = [
3,
n03,
_LOR,
0,
[_SS2, _Ma2, _MI2, _St2, _Ty, _SB, _SO],
[4, 0, 1, 64 | 0, 64 | 0, 0, 0]
];
var ListPricesRequest$ = [
3,
n03,
_LPR,
0,
[_Tl, _Ma2, _MI2],
[0, 0, 1]
];
var ListPricesResponse$ = [
3,
n03,
_LPRi,
0,
[_Pri, _NPM],
[() => DomainPriceList, 0]
];
var Nameserver$ = [
3,
n03,
_Nam2,
0,
[_N2, _GI],
[0, 64 | 0],
1
];
var PriceWithCurrency$ = [
3,
n03,
_PWC,
0,
[_Pr2, _Cu],
[1, 0],
2
];
var RegisterDomainRequest$ = [
3,
n03,
_RDR,
0,
[_DN, _DIY, _ACd, _RC3, _TC, _ILC, _AR2, _PPAC, _PPRC, _PPTC, _BC, _PPBC],
[0, 1, [() => ContactDetail$, 0], [() => ContactDetail$, 0], [() => ContactDetail$, 0], 0, 2, 2, 2, 2, [() => ContactDetail$, 0], 2],
5
];
var RegisterDomainResponse$ = [
3,
n03,
_RDRe,
0,
[_OI],
[0]
];
var RetrieveDomainAuthCodeRequest$ = [
3,
n03,
_RDACR,
0,
[_DN],
[0],
1
];
var RetrieveDomainAuthCodeResponse$ = [
3,
n03,
_RDACRe,
0,
[_AC],
[[() => DomainAuthCode, 0]]
];
var SortCondition$ = [
3,
n03,
_SCo,
0,
[_N2, _SO],
[0, 0],
2
];
var TransferDomainRequest$ = [
3,
n03,
_TDR,
0,
[_DN, _ACd, _RC3, _TC, _ILC, _DIY, _Na2, _AC, _AR2, _PPAC, _PPRC, _PPTC, _BC, _PPBC],
[0, [() => ContactDetail$, 0], [() => ContactDetail$, 0], [() => ContactDetail$, 0], 0, 1, () => NameserverList, [() => DomainAuthCode, 0], 2, 2, 2, 2, [() => ContactDetail$, 0], 2],
4
];
var TransferDomainResponse$ = [
3,
n03,
_TDRr,
0,
[_OI],
[0]
];
var UpdateDomainNameserversRequest$ = [
3,
n03,
_UDNR,
0,
[_DN, _Na2, _FIAK],
[0, () => NameserverList, [() => FIAuthKey, 0]],
2
];
var UpdateDomainNameserversResponse$ = [
3,
n03,
_UDNRp,
0,
[_OI],
[0]
];
var DnssecKeyList = [
1,
n03,
_DKL,
0,
() => DnssecKey$
];
var DomainPriceList = [
1,
n03,
_DPL,
0,
() => DomainPrice$
];
var DomainStatusList = 64 | 0;
var DomainSummaryList = [
1,
n03,
_DSLo,
0,
() => DomainSummary$
];
var ExtraParamList = [
1,
n03,
_EPL,
0,
[
() => ExtraParam$,
0
]
];
var FilterConditions = [
1,
n03,
_FCi,
0,
() => FilterCondition$
];
var GlueIpList = 64 | 0;
var NameserverList = [
1,
n03,
_NL,
0,
() => Nameserver$
];
var OperationStatusList = 64 | 0;
var OperationTypeList = 64 | 0;
var TagKeyList2 = 64 | 0;
var Values = 64 | 0;
var CheckDomainAvailability$ = [
9,
n03,
_CDA,
0,
() => CheckDomainAvailabilityRequest$,
() => CheckDomainAvailabilityResponse$
];
var DisableDomainTransferLock$ = [
9,
n03,
_DDTL,
0,
() => DisableDomainTransferLockRequest$,
() => DisableDomainTransferLockResponse$
];
var GetDomainDetail$ = [
9,
n03,
_GDD,
0,
() => GetDomainDetailRequest$,
() => GetDomainDetailResponse$
];
var GetOperationDetail$ = [
9,
n03,
_GOD,
0,
() => GetOperationDetailRequest$,
() => GetOperationDetailResponse$
];
var ListDomains$ = [
9,
n03,
_LD,
0,
() => ListDomainsRequest$,
() => ListDomainsResponse$
];
var ListPrices$ = [
9,
n03,
_LP,
0,
() => ListPricesRequest$,
() => ListPricesResponse$
];
var RegisterDomain$ = [
9,
n03,
_RD2,
0,
() => RegisterDomainRequest$,
() => RegisterDomainResponse$
];
var RetrieveDomainAuthCode$ = [
9,
n03,
_RDAC,
0,
() => RetrieveDomainAuthCodeRequest$,
() => RetrieveDomainAuthCodeResponse$
];
var TransferDomain$ = [
9,
n03,
_TD,
0,
() => TransferDomainRequest$,
() => TransferDomainResponse$
];
var UpdateDomainNameservers$ = [
9,
n03,
_UDN,
0,
() => UpdateDomainNameserversRequest$,
() => UpdateDomainNameserversResponse$
];
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.shared.js
var getRuntimeConfig4 = (config) => {
return {
apiVersion: "2014-05-15",
base64Decoder: config?.base64Decoder ?? import_serde5.fromBase64,
base64Encoder: config?.base64Encoder ?? import_serde5.toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver3,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultRoute53DomainsHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new import_httpAuthSchemes5.AwsSdkSigV4Signer
}
],
logger: config?.logger ?? new import_client30.NoOpLogger,
protocol: config?.protocol ?? import_protocols8.AwsJson1_1Protocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.route53domains",
errorTypeRegistries: errorTypeRegistries3,
xmlNamespace: "https://route53domains.amazonaws.com/doc/2014-05-15/",
version: "2014-05-15",
serviceTarget: "Route53Domains_v20140515"
},
serviceId: config?.serviceId ?? "Route 53 Domains",
sha256: config?.sha256 ?? import_checksum2.Sha256,
urlParser: config?.urlParser ?? import_protocols9.parseUrl,
utf8Decoder: config?.utf8Decoder ?? import_serde5.fromUtf8,
utf8Encoder: config?.utf8Encoder ?? import_serde5.toUtf8
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.js
var getRuntimeConfig5 = (config) => {
import_client32.emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = import_config30.resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(import_client32.loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig4(config);
import_client31.emitWarningIfUnsupportedVersion(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? import_config30.loadConfig(import_httpAuthSchemes6.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? import_serde6.calculateBodyLength,
credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? import_client31.createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default2.version }),
maxAttempts: config?.maxAttempts ?? import_config30.loadConfig(import_retry5.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? import_config30.loadConfig(import_config30.NODE_REGION_CONFIG_OPTIONS, { ...import_config30.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: import_node_http_handler3.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config30.loadConfig({
...import_retry5.NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || import_retry5.DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? import_node_http_handler3.streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? import_config30.loadConfig(import_config30.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? import_config30.loadConfig(import_config30.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? import_config30.loadConfig(import_client31.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeExtensions.js
var import_client33 = __toESM(require_client2());
var import_client34 = __toESM(require_client());
var import_protocols10 = __toESM(require_protocols());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration3 = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig3 = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions3 = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(import_client33.getAwsRegionExtensionConfiguration(runtimeConfig), import_client34.getDefaultExtensionConfiguration(runtimeConfig), import_protocols10.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration3(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, import_client33.resolveAwsRegionExtensionConfiguration(extensionConfiguration), import_client34.resolveDefaultRuntimeConfig(extensionConfiguration), import_protocols10.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig3(extensionConfiguration));
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/Route53DomainsClient.js
class Route53DomainsClient extends import_client36.Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig5(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters3(_config_0);
const _config_2 = import_client35.resolveUserAgentConfig(_config_1);
const _config_3 = import_retry6.resolveRetryConfig(_config_2);
const _config_4 = import_config31.resolveRegionConfig(_config_3);
const _config_5 = import_client35.resolveHostHeaderConfig(_config_4);
const _config_6 = import_endpoints7.resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig3(_config_6);
const _config_8 = resolveRuntimeExtensions3(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(import_schema4.getSchemaSerdePlugin(this.config));
this.middlewareStack.use(import_client35.getUserAgentPlugin(this.config));
this.middlewareStack.use(import_retry6.getRetryPlugin(this.config));
this.middlewareStack.use(import_protocols11.getContentLengthPlugin(this.config));
this.middlewareStack.use(import_client35.getHostHeaderPlugin(this.config));
this.middlewareStack.use(import_client35.getLoggerPlugin(this.config));
this.middlewareStack.use(import_client35.getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(import_core2.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53DomainsHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core2.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(import_core2.getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commandBuilder.js
var import_client37 = __toESM(require_client());
var import_endpoints8 = __toESM(require_endpoints());
var command3 = import_client37.makeBuilder(commonParams3, "Route53Domains_v20140515", "Route53DomainsClient", import_endpoints8.getEndpointPlugin);
var _ep03 = {};
var _mw03 = (Command, cs, config, o) => [];
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/CheckDomainAvailabilityCommand.js
class CheckDomainAvailabilityCommand extends command3(_ep03, _mw03, "CheckDomainAvailability", CheckDomainAvailability$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/DisableDomainTransferLockCommand.js
class DisableDomainTransferLockCommand extends command3(_ep03, _mw03, "DisableDomainTransferLock", DisableDomainTransferLock$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/GetDomainDetailCommand.js
class GetDomainDetailCommand extends command3(_ep03, _mw03, "GetDomainDetail", GetDomainDetail$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/GetOperationDetailCommand.js
class GetOperationDetailCommand extends command3(_ep03, _mw03, "GetOperationDetail", GetOperationDetail$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/ListDomainsCommand.js
class ListDomainsCommand extends command3(_ep03, _mw03, "ListDomains", ListDomains$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/ListPricesCommand.js
class ListPricesCommand extends command3(_ep03, _mw03, "ListPrices", ListPrices$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/RegisterDomainCommand.js
class RegisterDomainCommand extends command3(_ep03, _mw03, "RegisterDomain", RegisterDomain$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/RetrieveDomainAuthCodeCommand.js
class RetrieveDomainAuthCodeCommand extends command3(_ep03, _mw03, "RetrieveDomainAuthCode", RetrieveDomainAuthCode$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/TransferDomainCommand.js
class TransferDomainCommand extends command3(_ep03, _mw03, "TransferDomain", TransferDomain$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/UpdateDomainNameserversCommand.js
class UpdateDomainNameserversCommand extends command3(_ep03, _mw03, "UpdateDomainNameservers", UpdateDomainNameservers$) {
}
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var import_config35 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var import_config34 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var import_client39 = __toESM(require_client2());
var import_config33 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js
var import_client38 = __toESM(require_client2());
var import_config32 = __toESM(require_config());
var resolveCredentialSource2 = (credentialSource, profileName, logger) => {
const sourceProvidersMap = {
EcsContainer: async (options) => {
await Promise.resolve().then(() => init_dist_es3());
await Promise.resolve().then(() => init_dist_es2());
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
return async () => import_config32.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider2);
},
Ec2InstanceMetadata: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
await Promise.resolve().then(() => init_dist_es2());
return async () => fromInstanceMetadata(options)().then(setNamedProvider2);
},
Environment: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
await Promise.resolve().then(() => init_dist_es());
return async () => fromEnv(options)().then(setNamedProvider2);
}
};
if (credentialSource in sourceProvidersMap) {
return sourceProvidersMap[credentialSource];
} else {
throw new import_config32.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger });
}
};
var setNamedProvider2 = (creds) => import_client38.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var isAssumeRoleProfile2 = (arg, { profile = "default", logger } = {}) => {
return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile2(arg, { profile, logger }) || isCredentialSourceProfile2(arg, { profile, logger }));
};
var isAssumeRoleWithSourceProfile2 = (arg, { profile, logger }) => {
const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
if (withSourceProfile) {
logger?.debug?.(` ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
}
return withSourceProfile;
};
var isCredentialSourceProfile2 = (arg, { profile, logger }) => {
const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
if (withProviderProfile) {
logger?.debug?.(` ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
}
return withProviderProfile;
};
var resolveAssumeRoleCredentials2 = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, resolveProfileData) => {
options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
const profileData = profiles[profileName];
const { source_profile, region } = profileData;
if (!options.roleAssumer) {
const { getDefaultRoleAssumer } = await Promise.resolve().then(() => __toESM(require_sts()));
options.roleAssumer = getDefaultRoleAssumer({
...options.clientConfig,
credentialProviderLogger: options.logger,
parentClientConfig: {
...callerClientConfig,
...options?.parentClientConfig,
region: region ?? options?.parentClientConfig?.region ?? callerClientConfig?.region
}
}, options.clientPlugins);
}
if (source_profile && source_profile in visitedProfiles) {
throw new import_config33.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${import_config33.getProfileName(options)}. Profiles visited: ` + Object.keys(visitedProfiles).join(", "), { logger: options.logger });
}
options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`);
const sourceCredsProvider = source_profile ? resolveProfileData(source_profile, profiles, options, callerClientConfig, {
...visitedProfiles,
[source_profile]: true
}, isCredentialSourceWithoutRoleArn2(profiles[source_profile] ?? {})) : (await resolveCredentialSource2(profileData.credential_source, profileName, options.logger)(options))();
if (isCredentialSourceWithoutRoleArn2(profileData)) {
return sourceCredsProvider.then((creds) => import_client39.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
} else {
const params = {
RoleArn: profileData.role_arn,
RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`,
ExternalId: profileData.external_id,
DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10)
};
const { mfa_serial } = profileData;
if (mfa_serial) {
if (!options.mfaCodeProvider) {
throw new import_config33.CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false });
}
params.SerialNumber = mfa_serial;
params.TokenCode = await options.mfaCodeProvider(mfa_serial);
}
const sourceCreds = await sourceCredsProvider;
return options.roleAssumer(sourceCreds, params).then((creds) => import_client39.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
}
};
var isCredentialSourceWithoutRoleArn2 = (section) => {
return !section.role_arn && !!section.credential_source;
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveLoginCredentials.js
init_dist_es6();
var import_client40 = __toESM(require_client2());
var isLoginProfile2 = (data) => {
return Boolean(data && data.login_session);
};
var resolveLoginCredentials2 = async (profileName, options, callerClientConfig) => {
const credentials = await fromLoginCredentials({
...options,
profile: profileName
})({ callerClientConfig });
return import_client40.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_LOGIN", "AC");
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js
var import_client41 = __toESM(require_client2());
var isProcessProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string";
var resolveProcessCredentials3 = async (options, profile) => Promise.resolve().then(() => (init_dist_es7(), {})).then(({}) => fromProcess({
...options,
profile
})().then((creds) => import_client41.setCredentialFeature(creds, "CREDENTIALS_PROFILE_PROCESS", "v")));
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js
var import_client42 = __toESM(require_client2());
var resolveSsoCredentials2 = async (profile, profileData, options = {}, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es5());
return fromSSO({
profile,
logger: options.logger,
parentClientConfig: options.parentClientConfig,
clientConfig: options.clientConfig
})({
callerClientConfig
}).then((creds) => {
if (profileData.sso_session) {
return import_client42.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
} else {
return import_client42.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t");
}
});
};
var isSsoProfile4 = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js
var import_client43 = __toESM(require_client2());
var isStaticCredsProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.aws_access_key_id === "string" && typeof arg.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1;
var resolveStaticCredentials2 = async (profile, options) => {
options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
const credentials = {
accessKeyId: profile.aws_access_key_id,
secretAccessKey: profile.aws_secret_access_key,
sessionToken: profile.aws_session_token,
...profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope },
...profile.aws_account_id && { accountId: profile.aws_account_id }
};
return import_client43.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n");
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js
var import_client44 = __toESM(require_client2());
var isWebIdentityProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.web_identity_token_file === "string" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1;
var resolveWebIdentityCredentials2 = async (profile, options, callerClientConfig) => Promise.resolve().then(() => (init_dist_es8(), {})).then(({}) => fromTokenFile({
webIdentityTokenFile: profile.web_identity_token_file,
roleArn: profile.role_arn,
roleSessionName: profile.role_session_name,
roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
logger: options.logger,
parentClientConfig: options.parentClientConfig
})({
callerClientConfig
}).then((creds) => import_client44.setCredentialFeature(creds, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q")));
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var resolveProfileData2 = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => {
const data = profiles[profileName];
if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile2(data)) {
return resolveStaticCredentials2(data, options);
}
if (isAssumeRoleRecursiveCall || isAssumeRoleProfile2(data, { profile: profileName, logger: options.logger })) {
return resolveAssumeRoleCredentials2(profileName, profiles, options, callerClientConfig, visitedProfiles, resolveProfileData2);
}
if (isStaticCredsProfile2(data)) {
return resolveStaticCredentials2(data, options);
}
if (isWebIdentityProfile2(data)) {
return resolveWebIdentityCredentials2(data, options, callerClientConfig);
}
if (isProcessProfile2(data)) {
return resolveProcessCredentials3(options, profileName);
}
if (isSsoProfile4(data)) {
return await resolveSsoCredentials2(profileName, data, options, callerClientConfig);
}
if (isLoginProfile2(data)) {
return resolveLoginCredentials2(profileName, options, callerClientConfig);
}
throw new import_config34.CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger });
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var fromIni2 = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
const profiles = await import_config35.parseKnownFiles(init);
return resolveProfileData2(import_config35.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init, callerClientConfig);
};
// src/lib/route53.ts
function getConfig2() {
return {
region: process.env["ROUTE53_REGION"] || process.env["ROUTE53_AWS_REGION"] || process.env["AWS_REGION"] || "us-east-1",
accessKeyId: process.env["ROUTE53_ACCESS_KEY_ID"] || process.env["AWS_ACCESS_KEY_ID"],
secretAccessKey: process.env["ROUTE53_SECRET_ACCESS_KEY"] || process.env["AWS_SECRET_ACCESS_KEY"],
sessionToken: process.env["ROUTE53_SESSION_TOKEN"] || process.env["AWS_SESSION_TOKEN"],
profile: process.env["ROUTE53_AWS_PROFILE"] || process.env["AWS_PROFILE"]
};
}
function makeClients(config) {
const cfg = config ?? getConfig2();
const region = cfg.region || "us-east-1";
const credentials = cfg.credentials ?? (cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } : cfg.profile ? fromIni2({ profile: cfg.profile }) : undefined);
return {
route53: new Route53Client({ region, credentials }),
domains: new Route53DomainsClient({ region: "us-east-1", credentials })
};
}
async function checkAvailability3(domain, config) {
const { domains } = makeClients(config);
const result = await domains.send(new CheckDomainAvailabilityCommand({ DomainName: domain }));
const availability = {
domain,
available: result.Availability === "AVAILABLE",
availability: result.Availability ?? "UNKNOWN"
};
if (availability.available) {
try {
const tld = domain.split(".").slice(1).join(".");
const price = await getTldPrice(tld, config);
if (price) {
availability.currency = price.currency;
availability.price = price.registration_price;
availability.renewal_price = price.renewal_price;
availability.transfer_price = price.transfer_price;
}
} catch {}
}
return availability;
}
function normalizeTld(tld) {
return tld.trim().replace(/^\./, "");
}
function priceString(value) {
return value == null ? undefined : value.toString();
}
function tldPriceFromRoute53Price(tld, price) {
return {
tld: price.Name || tld,
registration_price: priceString(price.RegistrationPrice?.Price),
renewal_price: priceString(price.RenewalPrice?.Price),
transfer_price: priceString(price.TransferPrice?.Price),
currency: price.RegistrationPrice?.Currency ?? price.RenewalPrice?.Currency ?? price.TransferPrice?.Currency
};
}
async function getTldPrice(tld, config) {
const { domains } = makeClients(config);
const normalized = normalizeTld(tld);
const prices = await domains.send(new ListPricesCommand({ Tld: normalized, MaxItems: 1 }));
const price = prices.Prices?.[0];
return price ? tldPriceFromRoute53Price(normalized, price) : null;
}
async function listTldPrices(config) {
const { domains } = makeClients(config);
const prices = [];
let marker;
do {
const result = await domains.send(new ListPricesCommand({ Marker: marker, MaxItems: 100 }));
for (const price of result.Prices ?? []) {
prices.push(tldPriceFromRoute53Price(price.Name || "", price));
}
marker = result.NextPageMarker;
} while (marker);
return prices;
}
async function registerDomain2(domain, contact, durationYears = 1, autoRenew = true, config, options = {}) {
const { domains } = makeClients(config);
const contactDetail = contactToRoute53Contact(contact);
const result = await domains.send(new RegisterDomainCommand({
DomainName: domain,
DurationInYears: durationYears,
AutoRenew: autoRenew,
AdminContact: contactDetail,
RegistrantContact: contactDetail,
TechContact: contactDetail,
PrivacyProtectAdminContact: options.privacy_protected ?? true,
PrivacyProtectRegistrantContact: options.privacy_protected ?? true,
PrivacyProtectTechContact: options.privacy_protected ?? true,
...options.nameservers?.length ? { Nameservers: options.nameservers.map((Name) => ({ Name })) } : {}
}));
return { operationId: result.OperationId ?? "" };
}
function contactToRoute53Contact(contact) {
return {
FirstName: contact.first_name,
LastName: contact.last_name,
Email: contact.email,
PhoneNumber: contact.phone,
AddressLine1: contact.address_line_1,
...contact.address_line_2 ? { AddressLine2: contact.address_line_2 } : {},
City: contact.city,
...contact.state ? { State: contact.state } : {},
CountryCode: contact.country_code.toUpperCase(),
ZipCode: contact.zip_code,
ContactType: contact.organization_name ? "COMPANY" : "PERSON",
...contact.organization_name ? { OrganizationName: contact.organization_name } : {}
};
}
async function transferDomain(domain, authCode, contact, durationYears = 1, autoRenew = true, config, options = {}) {
const { domains } = makeClients(config);
const contactDetail = contactToRoute53Contact(contact);
const result = await domains.send(new TransferDomainCommand({
DomainName: domain,
AuthCode: authCode,
DurationInYears: durationYears,
AutoRenew: autoRenew,
AdminContact: contactDetail,
RegistrantContact: contactDetail,
TechContact: contactDetail,
PrivacyProtectAdminContact: options.privacy_protected ?? true,
PrivacyProtectRegistrantContact: options.privacy_protected ?? true,
PrivacyProtectTechContact: options.privacy_protected ?? true,
...options.nameservers?.length ? { Nameservers: options.nameservers.map((Name) => ({ Name })) } : {}
}));
return { operationId: result.OperationId ?? "" };
}
async function getRegistrationStatus(operationId, config) {
const { domains } = makeClients(config);
const result = await domains.send(new GetOperationDetailCommand({ OperationId: operationId }));
return {
status: result.Status ?? "UNKNOWN",
domain: result.DomainName,
message: result.Message
};
}
async function getDomainDetail(domain, config) {
const { domains } = makeClients(config);
const [result, summary] = await Promise.all([
domains.send(new GetDomainDetailCommand({ DomainName: domain })),
getDomainSummary(domain, config)
]);
const privacy = result;
return {
domain: result.DomainName ?? domain,
expiry: result.ExpirationDate?.toISOString() ?? summary?.expiry ?? "",
auto_renew: result.AutoRenew ?? summary?.auto_renew ?? null,
transfer_lock: summary?.transfer_lock ?? (result.StatusList?.includes("TRANSFER_LOCK") ? true : null),
created: result.CreationDate?.toISOString() ?? "",
updated: result.UpdatedDate?.toISOString() ?? "",
nameservers: (result.Nameservers ?? []).map((ns) => ns.Name ?? "").filter(Boolean),
status_list: result.StatusList ?? [],
registrar_name: result.RegistrarName,
privacy_protected: privacy.RegistrantPrivacy ?? privacy.AdminPrivacy ?? privacy.TechPrivacy ?? null
};
}
async function getDomainSummary(domain, config) {
let marker;
do {
const { domains } = makeClients(config);
const result = await domains.send(new ListDomainsCommand({ Marker: marker, MaxItems: 100 }));
const summary = (result.Domains ?? []).find((item) => item.DomainName === domain);
if (summary) {
return {
domain: summary.DomainName ?? domain,
expiry: summary.Expiry?.toISOString() ?? "",
auto_renew: summary.AutoRenew ?? false,
transfer_lock: summary.TransferLock ?? false
};
}
marker = result.NextPageMarker;
} while (marker);
return null;
}
async function requestTransferOutAuthCode(domain, config) {
const { domains } = makeClients(config);
const detail = await getDomainDetail(domain, config);
let transferLockDisabled = false;
let transferLockOperationId = null;
if (detail.transfer_lock) {
const result = await domains.send(new DisableDomainTransferLockCommand({ DomainName: domain }));
transferLockDisabled = true;
transferLockOperationId = result.OperationId ?? null;
}
const authCodeResult = await domains.send(new RetrieveDomainAuthCodeCommand({ DomainName: domain }));
if (!authCodeResult.AuthCode) {
throw new Error("Route53 did not return a domain transfer authorization code");
}
return {
auth_code: authCodeResult.AuthCode,
transfer_lock_disabled: transferLockDisabled,
transfer_lock_operation_id: transferLockOperationId
};
}
async function updateNameservers2(domain, nameservers, config, client) {
if (!nameservers.length) {
throw new Error("updateNameservers requires at least one nameserver");
}
const domains = client ?? makeClients(config).domains;
const result = await domains.send(new UpdateDomainNameserversCommand({
DomainName: domain,
Nameservers: nameservers.map((name) => ({ Name: name }))
}));
return { operationId: result.OperationId ?? "" };
}
async function listRegisteredDomains(config) {
const { domains } = makeClients(config);
const all = [];
let nextPageMarker;
do {
const result = await domains.send(new ListDomainsCommand({ Marker: nextPageMarker }));
for (const d of result.Domains ?? []) {
all.push({
domain: d.DomainName ?? "",
expiry: d.Expiry?.toISOString() ?? "",
auto_renew: d.AutoRenew ?? false,
transfer_lock: d.TransferLock ?? false
});
}
nextPageMarker = result.NextPageMarker;
} while (nextPageMarker);
return all;
}
function cleanZoneId(id) {
return id.replace("/hostedzone/", "");
}
function normalizeZoneId(id) {
return cleanZoneId(id.trim());
}
function normalizeNameserver(value) {
return value.trim().toLowerCase().replace(/\.$/, "");
}
function nameserversMatch(a, b) {
if (a.length !== b.length)
return false;
const left = [...new Set(a.map(normalizeNameserver))].sort();
const right = [...new Set(b.map(normalizeNameserver))].sort();
return left.length === right.length && left.every((value, index) => value === right[index]);
}
function cleanChangeId(id) {
return id?.replace("/change/", "") || null;
}
async function createHostedZone(domain, comment, config, options) {
const { route53 } = makeClients(config);
const callerRef = options?.callerReference ?? `domains-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
const result = await route53.send(new CreateHostedZoneCommand({
Name: domain,
CallerReference: callerRef,
HostedZoneConfig: comment ? { Comment: comment } : undefined
}));
return {
id: cleanZoneId(result.HostedZone?.Id ?? ""),
name: result.HostedZone?.Name ?? domain,
record_count: result.HostedZone?.ResourceRecordSetCount ?? 0,
comment,
name_servers: result.DelegationSet?.NameServers ?? []
};
}
async function listHostedZones(config) {
const { route53 } = makeClients(config);
const zones = [];
let marker;
do {
const result = await route53.send(new ListHostedZonesCommand({ Marker: marker }));
for (const z of result.HostedZones ?? []) {
zones.push({
id: cleanZoneId(z.Id ?? ""),
name: z.Name ?? "",
record_count: z.ResourceRecordSetCount ?? 0,
comment: z.Config?.Comment,
private_zone: z.Config?.PrivateZone
});
}
marker = result.IsTruncated ? result.NextMarker : undefined;
} while (marker);
return zones;
}
async function getHostedZone(hostedZoneId, config) {
const { route53 } = makeClients(config);
const result = await route53.send(new GetHostedZoneCommand({ Id: normalizeZoneId(hostedZoneId) }));
return {
id: cleanZoneId(result.HostedZone?.Id ?? ""),
name: result.HostedZone?.Name ?? "",
record_count: result.HostedZone?.ResourceRecordSetCount ?? 0,
comment: result.HostedZone?.Config?.Comment,
name_servers: result.DelegationSet?.NameServers ?? [],
private_zone: result.HostedZone?.Config?.PrivateZone
};
}
async function deleteHostedZone(hostedZoneId, config) {
const { route53 } = makeClients(config);
const zoneId = normalizeZoneId(hostedZoneId);
const managedRecords = [];
let nextName;
let nextType;
let nextIdentifier;
do {
const result = await route53.send(new ListResourceRecordSetsCommand({
HostedZoneId: zoneId,
StartRecordName: nextName,
StartRecordType: nextType,
StartRecordIdentifier: nextIdentifier
}));
managedRecords.push(...result.ResourceRecordSets?.filter((record) => record.Type !== "NS" && record.Type !== "SOA") ?? []);
nextName = result.IsTruncated ? result.NextRecordName : undefined;
nextType = result.IsTruncated ? result.NextRecordType : undefined;
nextIdentifier = result.IsTruncated ? result.NextRecordIdentifier : undefined;
} while (nextName && nextType);
for (let index = 0;index < managedRecords.length; index += 100) {
const batch = managedRecords.slice(index, index + 100);
if (batch.length === 0)
continue;
await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: zoneId,
ChangeBatch: {
Changes: batch.map((record) => ({
Action: "DELETE",
ResourceRecordSet: record
}))
}
}));
}
await route53.send(new DeleteHostedZoneCommand({ Id: zoneId }));
}
async function findHostedZoneByDomain(domain, config) {
const zones = await listHostedZones(config);
const normalized = domain.endsWith(".") ? domain : `${domain}.`;
const matches = zones.filter((z) => z.name === normalized);
if (matches.length === 0)
return null;
const publicMatches = matches.filter((z) => !z.private_zone);
const candidates = publicMatches.length > 0 ? publicMatches : matches;
if (candidates.length > 1) {
throw new Error(`Multiple Route 53 hosted zones found for ${domain}; specify hosted zone id`);
}
return candidates[0] ?? null;
}
async function findHostedZoneByNameservers(domain, nameservers, config) {
if (!nameservers.length)
return null;
const { route53 } = makeClients(config);
const result = await route53.send(new ListHostedZonesByNameCommand({ DNSName: domain }));
const zones = (result.HostedZones ?? []).filter((zone) => zone.Name?.replace(/\.$/, "") === domain && !zone.Config?.PrivateZone);
for (const zone of zones) {
const id = cleanZoneId(zone.Id ?? "");
if (!id)
continue;
const detail = await getHostedZone(id, config);
const delegatedNameservers = detail.name_servers ?? [];
if (nameserversMatch(delegatedNameservers, nameservers)) {
return { ...detail, id, name_servers: delegatedNameservers };
}
}
return null;
}
function rrsToRecord(rrs) {
if (rrs.AliasTarget) {
return {
name: rrs.Name ?? "",
type: rrs.Type ?? "",
ttl: 0,
values: [],
alias_target: {
hosted_zone_id: rrs.AliasTarget.HostedZoneId ?? "",
dns_name: rrs.AliasTarget.DNSName ?? ""
}
};
}
return {
name: rrs.Name ?? "",
type: rrs.Type ?? "",
ttl: rrs.TTL ?? 0,
values: (rrs.ResourceRecords ?? []).map((r) => r.Value ?? "")
};
}
function recordToRrs(record) {
if (record.alias_target) {
return {
Name: record.name,
Type: record.type,
AliasTarget: {
HostedZoneId: record.alias_target.hosted_zone_id,
DNSName: record.alias_target.dns_name,
EvaluateTargetHealth: false
}
};
}
return {
Name: record.name,
Type: record.type,
TTL: record.ttl ?? 300,
ResourceRecords: record.values.map((v) => ({ Value: v }))
};
}
async function listRecords(hostedZoneId, config, options = {}) {
const { route53 } = makeClients(config);
const records = [];
let nextName;
let nextType;
do {
const result = await route53.send(new ListResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
StartRecordName: nextName,
StartRecordType: nextType
}));
for (const rrs of result.ResourceRecordSets ?? []) {
if (options.requireSimpleRouting && (rrs.SetIdentifier !== undefined || rrs.Weight !== undefined || rrs.Region !== undefined || rrs.GeoLocation !== undefined || rrs.Failover !== undefined || rrs.HealthCheckId !== undefined || rrs.TrafficPolicyInstanceId !== undefined || rrs.CidrRoutingConfig !== undefined || rrs.GeoProximityLocation !== undefined || rrs.MultiValueAnswer !== undefined && rrs.MultiValueAnswer !== false)) {
throw new Error("Route 53 routing policy or health check cannot be preserved automatically");
}
records.push(rrsToRecord(rrs));
}
if (result.IsTruncated) {
nextName = result.NextRecordName;
nextType = result.NextRecordType;
} else {
nextName = undefined;
nextType = undefined;
}
} while (nextName);
return records;
}
async function upsertRecord(hostedZoneId, record, config, options) {
const { route53 } = makeClients(config);
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: [{ Action: "UPSERT", ResourceRecordSet: recordToRrs(record) }]
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
async function deleteRecord(hostedZoneId, record, config, options) {
const { route53 } = makeClients(config);
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: [{ Action: "DELETE", ResourceRecordSet: recordToRrs(record) }]
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
async function upsertRecords(hostedZoneId, records, config, options) {
if (records.length === 0)
return { changeId: null };
const { route53 } = makeClients(config);
const changes = records.map((r) => ({
Action: "UPSERT",
ResourceRecordSet: recordToRrs(r)
}));
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: changes
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
function parseMxValue(raw) {
const match = /^([0-9]+)[ \t]+([^\s]+)$/u.exec(raw.trim());
const priority = match ? Number(match[1]) : NaN;
if (!match || !Number.isInteger(priority) || priority < 0 || priority > 65535) {
throw new Error("Route 53 contains an invalid MX preference or exchange");
}
return { priority, value: match[2] };
}
function createRoute53Provider(config) {
const cfg = config ?? getConfig2();
const registerWithRoute53 = registerDomain2;
const updateRoute53Nameservers = updateNameservers2;
async function listDomainInventory() {
const byDomain = new Map;
try {
const registered = await listRegisteredDomains(cfg);
for (const d of registered) {
byDomain.set(d.domain, {
domain: d.domain,
registrar: "AWS Route 53",
created: "",
expires: d.expiry,
nameservers: [],
status: "active",
auto_renew: d.auto_renew
});
}
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!message.includes("route53domains:ListDomains") && !message.includes("AccessDenied")) {
throw error;
}
}
const zones = await listHostedZones(cfg);
for (const z of zones) {
const zone = z.name_servers?.length ? z : await getHostedZone(z.id, cfg).catch(() => z);
const domain = zone.name.replace(/\.$/, "");
const nameservers = zone.name_servers ?? [];
const existing = byDomain.get(domain);
if (existing) {
existing.nameservers = nameservers.length > 0 ? nameservers : existing.nameservers;
continue;
}
byDomain.set(domain, {
domain,
registrar: "AWS Route 53 DNS",
created: "",
expires: "",
nameservers,
status: "active",
auto_renew: false
});
}
return Array.from(byDomain.values());
}
return {
name: "route53",
dnsWriteScope: "changed-groups",
async listDomains() {
return listDomainInventory();
},
async getDomainInfo(domain) {
const detail = await getDomainDetail(domain, cfg);
return {
domain: detail.domain,
registrar: "AWS Route 53",
created: detail.created,
expires: detail.expiry,
nameservers: detail.nameservers,
status: "active",
auto_renew: detail.auto_renew ?? false
};
},
async registerDomain(domain, contact, options = {}) {
const result = await registerWithRoute53(domain, contact, options.years ?? 1, options.autoRenew ?? true, cfg);
return { domain, success: !!result.operationId, operationId: result.operationId };
},
async updateNameservers(domain, nameservers) {
const result = await updateRoute53Nameservers(domain, nameservers, cfg);
return { domain, success: !!result.operationId, operationId: result.operationId };
},
async renewDomain(_domain) {
return { domain: _domain, success: false, orderId: undefined, chargedAmount: undefined };
},
async getDnsRecords(domain) {
const zone = await findHostedZoneByDomain(domain, cfg);
if (!zone)
return [];
const records = await listRecords(zone.id, cfg, { requireSimpleRouting: true });
const result = [];
for (const r of records) {
if (r.alias_target) {
result.push({ type: r.type, name: r.name, value: r.alias_target.dns_name, ttl: 0 });
} else {
for (const v of r.values) {
const mx = r.type === "MX" ? parseMxValue(v) : undefined;
result.push({
type: r.type,
name: r.name,
value: mx?.value ?? v,
ttl: r.ttl,
...mx === undefined ? {} : { priority: mx.priority }
});
}
}
}
return result;
},
async setDnsRecords(domain, records) {
const zone = await findHostedZoneByDomain(domain, cfg);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const grouped = new Map;
for (const r of records) {
const mx = r.type === "MX" ? parseMxValue(r.priority === undefined ? r.value : `${r.priority} ${r.value}`) : undefined;
const value = mx === undefined ? r.value : `${mx.priority} ${mx.value}`;
const key = `${r.name}|${r.type}`;
const existing = grouped.get(key);
if (existing) {
existing.values.push(value);
} else {
grouped.set(key, { name: r.name, type: r.type, ttl: r.ttl, values: [value] });
}
}
await upsertRecords(zone.id, Array.from(grouped.values()), cfg);
return true;
},
async checkAvailability(domain) {
const result = await checkAvailability3(domain, cfg);
return {
domain: result.domain,
available: result.available,
standard_price: result.price ? Number(result.price) : undefined,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
const domains = await listDomainInventory();
const syncedAt = new Date().toISOString();
let synced = 0;
let created = 0;
let updated = 0;
const errors = [];
for (const d of domains) {
try {
const existing = await dbFns.getDomainByName(d.domain);
if (existing) {
const existingRoute53 = existing.metadata["route53"];
const staleDnsOnlyRegistrar = d.registrar !== "AWS Route 53" && (existing.registrar === "AWS Route 53 DNS" || existing.registrar === "AWS Route 53" && existingRoute53?.source === "route53:hosted_zones");
await dbFns.updateDomain(existing.id, {
...d.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
...staleDnsOnlyRegistrar ? { registrar: null } : {},
...d.registrar === "AWS Route 53" ? { expiry_synced_at: syncedAt } : {},
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
nameservers: d.nameservers.length > 0 ? d.nameservers : existing.nameservers,
metadata: {
...existing.metadata,
route53: {
source: d.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
synced_at: syncedAt
}
},
status: "active"
});
updated++;
} else {
await dbFns.createDomain({
name: d.domain,
...d.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
...d.registrar === "AWS Route 53" ? { expiry_synced_at: syncedAt } : {},
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
nameservers: d.nameservers,
status: "active",
notes: d.registrar === "AWS Route 53 DNS" ? "Discovered from Route 53 hosted zones; registrar ownership was not inferred." : undefined,
metadata: {
route53: {
source: d.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
synced_at: syncedAt
}
}
});
created++;
}
synced++;
} catch (err) {
errors.push(`${d.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
}
};
}
// src/lib/env-aliases.ts
function firstEnv(env, names) {
for (const key of names) {
const value = env[key];
if (value)
return { key, value };
}
return;
}
function hasEveryEnv(env, groups) {
return groups.every((names) => !!firstEnv(env, names));
}
function flattenEnvNames(groups) {
return Array.from(new Set(groups.flatMap((names) => [...names])));
}
var NAMECHEAP_ENV = {
apiKey: ["NAMECHEAP_API_KEY"],
username: ["NAMECHEAP_USERNAME"],
clientIp: ["NAMECHEAP_CLIENT_IP"]
};
var GODADDY_ENV = {
apiKey: ["GODADDY_API_KEY"],
apiSecret: ["GODADDY_API_SECRET"]
};
var BRANDSIGHT_ENV = {
apiKey: ["BRANDSIGHT_API_KEY"],
apiSecret: ["BRANDSIGHT_API_SECRET"],
customerId: ["BRANDSIGHT_CUSTOMER_ID"],
shopperId: ["BRANDSIGHT_SHOPPER_ID"],
accountId: ["BRANDSIGHT_ACCOUNT_ID"]
};
var SEDO_ENV = {
partnerId: ["SEDO_PARTNER_ID"],
signKey: ["SEDO_API_KEY", "SEDO_SIGN_KEY"],
username: ["SEDO_USERNAME", "SEDO_EMAIL"],
password: ["SEDO_PASSWORD"]
};
var CLOUDFLARE_ENV = {
apiToken: ["CLOUDFLARE_API_TOKEN"],
apiKey: ["CLOUDFLARE_API_KEY"],
email: ["CLOUDFLARE_EMAIL"],
accountId: ["CLOUDFLARE_ACCOUNT_ID"]
};
var ROUTE53_ENV = {
accessKeyId: ["ROUTE53_ACCESS_KEY_ID", "AWS_ACCESS_KEY_ID"],
secretAccessKey: ["ROUTE53_SECRET_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY"],
sessionToken: ["ROUTE53_SESSION_TOKEN", "AWS_SESSION_TOKEN"],
profile: ["ROUTE53_AWS_PROFILE", "AWS_PROFILE"],
region: ["ROUTE53_REGION", "ROUTE53_AWS_REGION", "AWS_REGION"],
webIdentityTokenFile: ["AWS_WEB_IDENTITY_TOKEN_FILE"],
roleArn: ["AWS_ROLE_ARN"],
containerCredentials: [
"AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
"AWS_CONTAINER_CREDENTIALS_FULL_URI"
]
};
function providerEnvNames(provider) {
switch (provider.toLowerCase()) {
case "namecheap":
return flattenEnvNames([NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
case "godaddy":
return flattenEnvNames([GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
case "brandsight":
return flattenEnvNames([
BRANDSIGHT_ENV.apiKey,
BRANDSIGHT_ENV.apiSecret,
BRANDSIGHT_ENV.customerId,
BRANDSIGHT_ENV.shopperId,
BRANDSIGHT_ENV.accountId
]);
case "sedo":
return flattenEnvNames([SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
case "cloudflare":
return flattenEnvNames([CLOUDFLARE_ENV.apiToken, CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email, CLOUDFLARE_ENV.accountId]);
case "route53":
return flattenEnvNames([
ROUTE53_ENV.profile,
ROUTE53_ENV.accessKeyId,
ROUTE53_ENV.secretAccessKey,
ROUTE53_ENV.sessionToken,
ROUTE53_ENV.region,
ROUTE53_ENV.webIdentityTokenFile,
ROUTE53_ENV.roleArn,
ROUTE53_ENV.containerCredentials
]);
default:
return [];
}
}
function hasProviderCredentials(provider, env = process.env) {
switch (provider.toLowerCase()) {
case "namecheap":
return hasEveryEnv(env, [NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
case "godaddy":
return hasEveryEnv(env, [GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
case "brandsight":
return hasEveryEnv(env, [BRANDSIGHT_ENV.apiKey, BRANDSIGHT_ENV.apiSecret, BRANDSIGHT_ENV.customerId]);
case "sedo":
return hasEveryEnv(env, [SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
case "cloudflare": {
const tokenMode = !!firstEnv(env, CLOUDFLARE_ENV.apiToken);
const keyMode = hasEveryEnv(env, [CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email]);
return tokenMode || keyMode;
}
case "route53": {
const profileMode = !!firstEnv(env, ROUTE53_ENV.profile);
const keyMode = hasEveryEnv(env, [ROUTE53_ENV.accessKeyId, ROUTE53_ENV.secretAccessKey]);
const webIdentityMode = hasEveryEnv(env, [ROUTE53_ENV.webIdentityTokenFile, ROUTE53_ENV.roleArn]);
const containerMode = !!firstEnv(env, ROUTE53_ENV.containerCredentials);
return profileMode || keyMode || webIdentityMode || containerMode;
}
default:
return false;
}
}
// src/lib/cloudflare-auth.ts
function resolveCloudflareConfig(env = process.env) {
const accountId = firstEnv(env, CLOUDFLARE_ENV.accountId)?.value;
const apiToken = firstEnv(env, CLOUDFLARE_ENV.apiToken)?.value;
if (apiToken)
return { apiToken, accountId };
const apiKey = firstEnv(env, CLOUDFLARE_ENV.apiKey)?.value;
const email = firstEnv(env, CLOUDFLARE_ENV.email)?.value;
if (apiKey && email)
return { apiKey, email, accountId };
return accountId ? { accountId } : {};
}
function cloudflareAuthHeaders(cfg) {
if (cfg.apiToken)
return { Authorization: `Bearer ${cfg.apiToken}` };
if (cfg.apiKey && cfg.email)
return { "X-Auth-Key": cfg.apiKey, "X-Auth-Email": cfg.email };
throw new Error("Cloudflare credentials not configured. Set CLOUDFLARE_API_TOKEN, or CLOUDFLARE_API_KEY + CLOUDFLARE_EMAIL.");
}
// src/lib/cloudflare.ts
class CloudflareApiError extends Error {
statusCode;
providerCode;
constructor(message, statusCode, providerCode) {
const code = providerCode ? `, code ${providerCode}` : "";
super(`Cloudflare API error (HTTP ${statusCode}${code}): ${message}`);
this.statusCode = statusCode;
this.providerCode = providerCode;
this.name = "CloudflareApiError";
}
}
function getConfig3() {
return resolveCloudflareConfig();
}
function checkCredentials(cfg) {
cloudflareAuthHeaders(cfg);
}
var CF_BASE = "https://api.cloudflare.com/client/v4";
var DEFAULT_CF_TIMEOUT_MS = 30000;
var MAX_CF_TIMEOUT_MS = 120000;
var DEFAULT_CF_MAX_RESPONSE_BYTES = 1048576;
var MAX_CF_RESPONSE_BYTES = 4194304;
function positiveBoundedEnv(name, fallback, maximum) {
const raw = process.env[name]?.trim();
if (!raw)
return fallback;
const value = Number(raw);
if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
throw new Error(`${name} must be an integer between 1 and ${maximum}`);
}
return value;
}
async function boundedResponseText(response, maxBytes, signal) {
const contentLength = Number(response.headers.get("content-length"));
if (Number.isFinite(contentLength) && contentLength > maxBytes) {
throw new Error(`Cloudflare API response exceeds ${maxBytes} bytes`);
}
if (!response.body)
return "";
const reader = response.body.getReader();
const abort = () => void reader.cancel("Cloudflare API request aborted");
if (signal.aborted)
abort();
signal.addEventListener("abort", abort, { once: true });
const chunks = [];
let length = 0;
try {
while (true) {
const { done, value } = await reader.read();
if (done)
break;
length += value.byteLength;
if (length > maxBytes) {
await reader.cancel("Cloudflare API response exceeds bounded size");
throw new Error(`Cloudflare API response exceeds ${maxBytes} bytes`);
}
chunks.push(value);
}
} finally {
signal.removeEventListener("abort", abort);
}
const bytes = new Uint8Array(length);
let offset = 0;
for (const chunk of chunks) {
bytes.set(chunk, offset);
offset += chunk.byteLength;
}
return new TextDecoder().decode(bytes);
}
async function cfFetch(path, opts = {}) {
const cfg = opts.config ?? getConfig3();
checkCredentials(cfg);
const timeoutMs = Math.min(opts.timeoutMs ?? MAX_CF_TIMEOUT_MS, positiveBoundedEnv("DOMAINS_PROVIDER_HTTP_TIMEOUT_MS", DEFAULT_CF_TIMEOUT_MS, MAX_CF_TIMEOUT_MS));
const maxResponseBytes = positiveBoundedEnv("DOMAINS_PROVIDER_MAX_RESPONSE_BYTES", DEFAULT_CF_MAX_RESPONSE_BYTES, MAX_CF_RESPONSE_BYTES);
const controller = new AbortController;
let timer;
const timeout = new Promise((_resolve, reject) => {
timer = setTimeout(() => {
controller.abort();
reject(new Error(`Cloudflare API request exceeded ${timeoutMs}ms`));
}, timeoutMs);
});
let json;
let status = 0;
try {
({ json, status } = await Promise.race([
(async () => {
const response = await fetch(`${CF_BASE}${path}`, {
method: opts.method ?? "GET",
headers: {
...cloudflareAuthHeaders(cfg),
"Content-Type": "application/json"
},
body: opts.body ? JSON.stringify(opts.body) : undefined,
signal: controller.signal
});
const text = await boundedResponseText(response, maxResponseBytes, controller.signal);
try {
return {
status: response.status,
json: JSON.parse(text)
};
} catch {
throw new Error(`Cloudflare API returned invalid JSON (${response.status})`);
}
})(),
timeout
]));
} finally {
if (timer !== undefined)
clearTimeout(timer);
}
if (status < 200 || status >= 300 || json.success !== true) {
const first = json.errors?.[0];
const msg = first?.message ?? "request failed";
const providerCode = typeof first?.code === "string" || typeof first?.code === "number" ? String(first.code) : undefined;
throw new CloudflareApiError(msg, status, providerCode);
}
opts.onResultInfo?.(json.result_info);
return json.result;
}
async function listZones(config) {
const zones = [];
let page = 1;
while (true) {
const result = await cfFetch(`/zones?per_page=50&page=${page}`, { config });
if (!result || result.length === 0)
break;
for (const z of result) {
zones.push({ id: z.id, name: z.name, status: z.status, nameservers: z.name_servers, original_nameservers: z.original_name_servers });
}
if (result.length < 50)
break;
page++;
}
return zones;
}
async function getZone(domain, config) {
const result = await cfFetch(`/zones?name=${encodeURIComponent(domain)}`, { config });
if (!result || result.length === 0)
return null;
const z = result[0];
return { id: z.id, name: z.name, status: z.status, nameservers: z.name_servers, original_nameservers: z.original_name_servers };
}
async function createZone(domain, config) {
const cfg = config ?? getConfig3();
if (!cfg.accountId) {
throw new Error("CLOUDFLARE_ACCOUNT_ID is required to create a zone.");
}
const result = await cfFetch("/zones", { method: "POST", body: { name: domain, account: { id: cfg.accountId }, jump_start: false }, config: cfg });
return { id: result.id, name: result.name, status: result.status, nameservers: result.name_servers };
}
async function ensureZone(domain, config, deps) {
const get = deps?.getZone ?? getZone;
const create = deps?.createZone ?? createZone;
const existing = await get(domain, config);
const zone = existing ?? await create(domain, config);
if (!zone.nameservers || zone.nameservers.length === 0) {
throw new Error(`Cloudflare zone for ${domain} has no nameservers yet`);
}
return zone;
}
class CloudflareDnsPaginationError extends Error {
constructor(reason, page, count, metadata) {
const numeric = metadata ? Object.fromEntries(["page", "per_page", "count", "total_count", "total_pages"].map((key) => [key, typeof metadata[key] === "number" && Number.isFinite(metadata[key]) ? metadata[key] : null])) : null;
super(`Cloudflare DNS pagination ${reason} (page=${page}, returned=${count}, metadata=${JSON.stringify(numeric)})`);
this.name = "CloudflareDnsPaginationError";
}
}
async function listRecords2(zoneId, config, options = {}) {
const deadline = Math.min(performance.now() + 1e4, options.deadline ?? Infinity);
if (!Number.isFinite(deadline))
throw new Error("Invalid DNS enumeration deadline");
const assertRead = async () => {
await options.assertLease?.();
if (performance.now() >= deadline)
throw new Error("Cloudflare DNS enumeration time budget exhausted");
};
for (let attempt = 1;; attempt++) {
await assertRead();
try {
const records = await listRecordsAttempt(zoneId, config, assertRead, deadline);
await assertRead();
return records;
} catch (error) {
if (!(error instanceof CloudflareDnsPaginationError) || attempt >= 6)
throw error;
await assertRead();
const delay = 250 * 2 ** (attempt - 1);
if (performance.now() + delay >= deadline)
throw error;
await new Promise((resolve) => setTimeout(resolve, delay));
}
}
}
var CF_DNS_READ_TYPES = new Set(["A", "AAAA", "CAA", "CERT", "CNAME", "DNSKEY", "DS", "HTTPS", "LOC", "MX", "NAPTR", "NS", "OPENPGPKEY", "PTR", "SMIMEA", "SRV", "SSHFP", "SVCB", "TLSA", "TXT", "URI"]);
function readDnsRecord(value) {
const malformed = () => new Error("Cloudflare returned a malformed DNS record");
if (!value || typeof value !== "object" || Array.isArray(value))
throw malformed();
const r = value;
if (typeof r.id !== "string" || !/^[A-Za-z0-9_-]{1,128}$/u.test(r.id) || typeof r.type !== "string" || !CF_DNS_READ_TYPES.has(r.type) || typeof r.name !== "string" || r.name.length > 253 || !/^(?:\*|[A-Za-z0-9_-]+)(?:\.[A-Za-z0-9_-]+)+\.?$/u.test(r.name) || typeof r.content !== "string" || r.content.length === 0 && r.type !== "TXT" || typeof r.ttl !== "number" || !Number.isSafeInteger(r.ttl) || !(r.ttl === 1 || r.ttl >= 30 && r.ttl <= 86400) || (r.type === "MX" || r.priority !== undefined) && (typeof r.priority !== "number" || !Number.isSafeInteger(r.priority) || r.priority < 0 || r.priority > 65535) || r.proxied !== undefined && typeof r.proxied !== "boolean")
throw malformed();
return {
id: r.id,
type: r.type,
name: r.name,
content: r.content,
ttl: r.ttl,
priority: r.priority,
proxied: r.proxied
};
}
async function listRecordsAttempt(zoneId, config, assertRead, deadline) {
const records = [];
let page = 1;
const seenIds = new Set;
let pagination;
while (true) {
await assertRead();
let resultInfo;
const result = await cfFetch(`/zones/${zoneId}/dns_records?per_page=100&page=${page}`, { config, onResultInfo: (value) => {
resultInfo = value;
}, timeoutMs: Math.max(1, Math.ceil(deadline - performance.now())) });
await assertRead();
if (!Array.isArray(result))
throw new Error("Cloudflare DNS list result is not an array");
const pageRecords = result.map(readDnsRecord);
for (const record of pageRecords) {
if (seenIds.has(record.id))
throw new Error("Cloudflare DNS pagination repeated a record identity");
seenIds.add(record.id);
}
if (resultInfo !== undefined) {
if (!resultInfo || typeof resultInfo !== "object")
throw new Error("Cloudflare DNS pagination is malformed");
const info = resultInfo;
const values = [info.page, info.per_page, info.count, info.total_count, info.total_pages];
if (!values.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0))
throw new CloudflareDnsPaginationError("is incomplete", page, result.length, info);
const current = { perPage: info.per_page, totalCount: info.total_count, totalPages: info.total_pages };
const expectedPages = Math.ceil(current.totalCount / current.perPage);
if (info.page !== page || current.perPage < 1 || current.perPage > 100)
throw new Error("Cloudflare DNS pagination has invalid page identity or size");
if (info.count !== result.length || current.totalPages !== expectedPages && !(current.totalCount === 0 && current.totalPages === 1) || result.length !== Math.min(current.perPage, Math.max(0, current.totalCount - (page - 1) * current.perPage)) || pagination && JSON.stringify(pagination) !== JSON.stringify(current))
throw new CloudflareDnsPaginationError("changed or contradicts the result", page, result.length, info);
pagination = current;
} else if (pagination)
throw new CloudflareDnsPaginationError("disappeared before completion", page, result.length);
records.push(...pageRecords);
if (pagination ? page >= pagination.totalPages : result.length < 100) {
if (pagination && records.length !== pagination.totalCount)
throw new CloudflareDnsPaginationError("did not yield the complete population", page, result.length);
break;
}
page++;
}
return records;
}
async function listRecordsByNameType(zoneId, type, name, config) {
const result = await cfFetch(`/zones/${zoneId}/dns_records?type=${encodeURIComponent(type)}&name=${encodeURIComponent(name)}`, { config });
return (result ?? []).map((r) => ({
id: r.id,
type: r.type,
name: r.name,
content: r.content,
ttl: r.ttl,
priority: r.priority,
proxied: r.proxied
}));
}
async function upsertRecord2(zoneId, record, config) {
const existing = await listRecordsByNameType(zoneId, record.type, record.name, config);
const body = {
type: record.type,
name: record.name,
content: record.content,
ttl: record.ttl ?? 1,
priority: record.priority,
proxied: record.proxied ?? false
};
const sameRecord = existing.find((r) => r.content === record.content && (r.priority ?? undefined) === (record.priority ?? undefined) && (r.proxied ?? false) === (record.proxied ?? false));
if (sameRecord?.id) {
await cfFetch(`/zones/${zoneId}/dns_records/${sameRecord.id}`, { method: "PUT", body, config });
} else {
await cfFetch(`/zones/${zoneId}/dns_records`, { method: "POST", body, config });
}
}
function sameRecordIdentity(a, b) {
return a.type === b.type && a.name === b.name && a.content === b.content && (a.priority ?? undefined) === (b.priority ?? undefined);
}
function resolveDesiredProxied(records, existing) {
const omitted = records.filter((record) => record.proxied === undefined);
if (omitted.length === 0)
return records;
const { type, name } = records[0];
if (omitted.length === records.length) {
const proxyStates = new Set(existing.map((record) => record.proxied));
if (proxyStates.size > 1) {
throw new Error(`Cannot safely preserve Cloudflare proxied state for ${type} ${name}: ` + "existing records have mixed proxied values while desired records omit proxied; " + "set proxied explicitly on every desired record");
}
const inherited = existing[0]?.proxied;
return inherited === undefined ? records : records.map((record) => ({ ...record, proxied: inherited }));
}
const existingHasProxyState = existing.some((record) => record.proxied !== undefined);
return records.map((record) => {
if (record.proxied !== undefined)
return record;
const matches = existing.filter((candidate) => sameRecordIdentity(candidate, record));
if (matches.length === 1 && matches[0].proxied !== undefined) {
return { ...record, proxied: matches[0].proxied };
}
if (!existingHasProxyState)
return record;
throw new Error(`Cannot safely preserve Cloudflare proxied state for ${type} ${name} record ${record.content}: ` + "omitted proxied does not resolve to exactly one existing value; " + "set proxied explicitly on this desired record");
});
}
async function prepareRecordsByNameType(zoneId, records, config) {
if (records.length === 0)
return;
const { type, name } = records[0];
const existing = await listRecordsByNameType(zoneId, type, name, config);
if (existing.length === records.length && records.every((record) => existing.some((candidate) => sameRecordIdentity(candidate, record) && candidate.ttl === record.ttl && (record.proxied === undefined || candidate.proxied === record.proxied)))) {
return;
}
return { existing, desired: resolveDesiredProxied(records, existing) };
}
async function replaceRecordsByNameType(zoneId, replacement, config) {
for (const record of replacement.existing) {
if (record.id)
await deleteRecord2(zoneId, record.id, config);
}
for (const record of replacement.desired) {
await cfFetch(`/zones/${zoneId}/dns_records`, {
method: "POST",
body: {
type: record.type,
name: record.name,
content: record.content,
ttl: record.ttl ?? 1,
priority: record.priority,
...record.proxied === undefined ? {} : { proxied: record.proxied }
},
config
});
}
}
async function reconcileRecords(zoneId, records, config) {
const grouped = new Map;
for (const record of records) {
const key = `${record.type}|${record.name}`;
const group = grouped.get(key) ?? [];
group.push(record);
grouped.set(key, group);
}
const replacements = [];
for (const group of grouped.values()) {
const replacement = await prepareRecordsByNameType(zoneId, group, config);
if (replacement)
replacements.push(replacement);
}
for (const replacement of replacements) {
await replaceRecordsByNameType(zoneId, replacement, config);
}
}
async function deleteRecord2(zoneId, recordId, config) {
await cfFetch(`/zones/${zoneId}/dns_records/${recordId}`, { method: "DELETE", config });
}
function zoneToDomainInfo(zone) {
return {
domain: zone.name,
registrar: "Cloudflare DNS",
created: "",
expires: "",
nameservers: zone.nameservers,
status: zone.status === "active" ? "active" : "discovered",
auto_renew: false
};
}
function withCloudflareMetadata(existing, zone) {
return {
...existing,
cloudflare: {
zone_id: zone.id,
zone_status: zone.status,
source: "cloudflare:zones",
synced_at: new Date().toISOString()
}
};
}
function createCloudflareProvider(config) {
const cfg = config ?? getConfig3();
return {
name: "cloudflare",
dnsWriteScope: "changed-groups",
async listDomains() {
const zones = await listZones(cfg);
return zones.map(zoneToDomainInfo);
},
async syncToLocalDb(dbFns) {
const zones = await listZones(cfg);
let synced = 0;
let created = 0;
let updated = 0;
const errors = [];
for (const zone of zones) {
try {
const info = zoneToDomainInfo(zone);
const existing = await dbFns.getDomainByName(zone.name);
if (existing) {
await dbFns.updateDomain(existing.id, {
...existing.registrar === "Cloudflare DNS" ? { registrar: null } : {},
status: existing.status === "discovered" && info.status === "active" ? "active" : existing.status,
nameservers: zone.nameservers,
metadata: withCloudflareMetadata(existing.metadata, zone)
});
updated++;
} else {
await dbFns.createDomain({
name: zone.name,
status: info.status === "active" ? "active" : "discovered",
auto_renew: false,
nameservers: zone.nameservers,
notes: "Discovered from Cloudflare zones; registrar ownership was not inferred.",
metadata: withCloudflareMetadata({}, zone)
});
created++;
}
synced++;
} catch (err) {
errors.push(`${zone.name}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
},
async getDnsRecords(domain) {
const zone = await getZone(domain, cfg);
if (!zone)
return [];
const records = await listRecords2(zone.id, cfg);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.content,
ttl: r.ttl === 1 ? 0 : r.ttl,
priority: r.priority,
...r.proxied === undefined ? {} : { proxied: r.proxied }
}));
},
async setDnsRecords(domain, records) {
const zone = await getZone(domain, cfg);
if (!zone)
throw new Error(`No Cloudflare zone found for ${domain}`);
await reconcileRecords(zone.id, records.map((r) => ({
type: r.type,
name: r.name,
content: r.value,
ttl: r.ttl || 1,
priority: r.priority,
...r.proxied === undefined ? {} : { proxied: r.proxied }
})), cfg);
return true;
},
async deleteDnsRecords(domain, records) {
const zone = await getZone(domain, cfg);
if (!zone)
throw new Error(`No Cloudflare zone found for ${domain}`);
const grouped = new Map;
for (const record of records) {
const key = `${record.type}|${record.name}`;
const group = grouped.get(key) ?? [];
group.push(record);
grouped.set(key, group);
}
for (const group of grouped.values()) {
const { type, name } = group[0];
const existing = await listRecordsByNameType(zone.id, type, name, cfg);
for (const record of group) {
const match = existing.find((candidate) => candidate.content === record.value && (candidate.priority ?? undefined) === (record.priority ?? undefined));
if (match?.id) {
await deleteRecord2(zone.id, match.id, cfg);
}
}
}
return true;
}
};
}
// src/lib/brandsight.ts
function resolveBrandsightConfig(env = process.env) {
const apiKey = firstEnv(env, BRANDSIGHT_ENV.apiKey)?.value ?? "";
const apiSecret = firstEnv(env, BRANDSIGHT_ENV.apiSecret)?.value;
const customerId = firstEnv(env, BRANDSIGHT_ENV.customerId)?.value;
const shopperId = firstEnv(env, BRANDSIGHT_ENV.shopperId)?.value;
const accountId = firstEnv(env, BRANDSIGHT_ENV.accountId)?.value;
return {
apiKey,
apiSecret,
customerId,
shopperId,
accountId,
baseUrl: env["BRANDSIGHT_BASE_URL"]
};
}
class BrandsightApiError extends Error {
statusCode;
responseBody;
constructor(message, statusCode, responseBody) {
super(message);
this.statusCode = statusCode;
this.responseBody = responseBody;
this.name = "BrandsightApiError";
}
}
var _fetchFn = null;
function getConfig4() {
return resolveBrandsightConfig();
}
var BRANDSIGHT_DOMAIN_BASE = "https://api.godaddy.com/v2";
var BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES = 1048576;
function brandsightDomainTimeoutMs() {
const raw = process.env["DOMAINS_PROVIDER_HTTP_TIMEOUT_MS"]?.trim();
if (!raw)
return 30000;
const timeout = Number(raw);
if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 120000) {
throw new BrandsightApiError("DOMAINS_PROVIDER_HTTP_TIMEOUT_MS must be an integer between 1 and 120000");
}
return timeout;
}
async function boundedDomainResponseText(response, signal) {
const declaredLength = response.headers.get("content-length");
if (declaredLength !== null) {
const parsed = Number(declaredLength);
if (Number.isFinite(parsed) && parsed > BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES) {
throw new BrandsightApiError(`Brandsight Domain API response exceeds ${BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES} bytes`, response.status);
}
}
if (!response.body)
return "";
const reader = response.body.getReader();
const abort = () => void reader.cancel("Brandsight Domain API request aborted");
if (signal.aborted)
abort();
signal.addEventListener("abort", abort, { once: true });
const chunks = [];
let total = 0;
try {
while (true) {
if (signal.aborted)
throw signal.reason;
const { done, value } = await reader.read();
if (done)
break;
if (!value)
continue;
total += value.byteLength;
if (total > BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES) {
await reader.cancel();
throw new BrandsightApiError(`Brandsight Domain API response exceeds ${BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES} bytes`, response.status);
}
chunks.push(value);
}
} finally {
signal.removeEventListener("abort", abort);
reader.releaseLock();
}
if (signal.aborted)
throw signal.reason;
const joined = new Uint8Array(total);
let offset = 0;
for (const chunk of chunks) {
joined.set(chunk, offset);
offset += chunk.byteLength;
}
return new TextDecoder().decode(joined);
}
function requireDomainConfig(config) {
const cfg = config ?? getConfig4();
if (!cfg.apiKey || !cfg.apiSecret || !cfg.customerId) {
throw new BrandsightApiError("Brandsight Domain API credentials are not configured. Set BRANDSIGHT_API_KEY, BRANDSIGHT_API_SECRET, and BRANDSIGHT_CUSTOMER_ID.");
}
return cfg;
}
function domainBaseUrl(cfg) {
return cfg.baseUrl ?? BRANDSIGHT_DOMAIN_BASE;
}
function domainHeaders(cfg) {
return {
Authorization: `sso-key ${cfg.apiKey}:${cfg.apiSecret}`,
"Content-Type": "application/json",
Accept: "application/json",
"User-Agent": USER_AGENT
};
}
async function domainApiRequest(method, path, config, body) {
const cfg = requireDomainConfig(config);
const fetchFn = _fetchFn || globalThis.fetch;
const signal = AbortSignal.timeout(brandsightDomainTimeoutMs());
const response = await fetchFn(`${domainBaseUrl(cfg)}${path}`, {
method,
headers: domainHeaders(cfg),
body: body ? JSON.stringify(body) : undefined,
signal
});
const text = await boundedDomainResponseText(response, signal);
if (!response.ok) {
throw new BrandsightApiError(`Brandsight Domain API ${method} ${path} failed with status ${response.status}`, response.status, text);
}
if (!text.trim())
return {};
return JSON.parse(text);
}
function normalizeBrandsightDomain(raw) {
const nameServers = raw.nameServers ?? raw.nameservers ?? [];
const expiresAt = raw.expiresAt ?? raw.expires ?? "";
const createdAt = raw.createdAt ?? raw.created ?? "";
const renewAuto = raw.renewAuto ?? raw.auto_renew ?? false;
return {
...raw,
domain: String(raw.domain ?? ""),
status: String(raw.status ?? "UNKNOWN"),
created: createdAt,
expires: expiresAt,
auto_renew: renewAuto,
locked: Boolean(raw.locked),
nameservers: nameServers,
createdAt,
expiresAt,
nameServers,
renewAuto
};
}
function customerPath(cfg, path) {
return `/customers/${encodeURIComponent(cfg.customerId)}${path}`;
}
function domainTld(domain) {
const parts = domain.split(".").filter(Boolean);
if (parts.length < 2)
throw new BrandsightApiError(`Invalid domain name: ${domain}`);
return parts.slice(1).join(".");
}
function brandsightContact(contact) {
return {
addressMailing: {
address1: contact.address_line_1,
city: contact.city,
country: contact.country_code,
postalCode: contact.zip_code,
state: contact.state
},
email: contact.email,
encoding: "ASCII",
nameFirst: contact.first_name,
nameLast: contact.last_name,
organization: contact.organization_name,
phone: contact.phone
};
}
async function domainAvailability(domain, cfg, type, period = 1) {
const params = new URLSearchParams({
domain,
period: String(period),
type,
optimizeFor: "ACCURACY"
});
const result = await domainApiRequest("GET", `/domains/available?${params.toString()}`, cfg);
return {
domain: result.domain ?? domain,
available: Boolean(result.available),
price: result.price,
currency: result.currency,
registryPremiumPricing: result.registryPremiumPricing
};
}
async function listDomains2(config) {
const cfg = requireDomainConfig(config);
const domains = [];
const seenDomains = new Set;
const seenMarkers = new Set;
let marker;
while (true) {
const params = new URLSearchParams({ limit: "500" });
if (marker)
params.set("marker", marker);
const batch = await domainApiRequest("GET", customerPath(cfg, `/domains?${params.toString()}`), cfg);
if (!Array.isArray(batch) || batch.length === 0)
break;
for (const normalized of batch.map(normalizeBrandsightDomain)) {
if (!normalized.domain || seenDomains.has(normalized.domain))
continue;
seenDomains.add(normalized.domain);
domains.push(normalized);
}
if (batch.length < 500)
break;
const nextMarker = String(batch[batch.length - 1]?.domain ?? "");
if (!nextMarker || seenMarkers.has(nextMarker))
break;
seenMarkers.add(nextMarker);
marker = nextMarker;
}
return domains;
}
async function getDomainInfo3(domain, config) {
const cfg = requireDomainConfig(config);
const result = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}`), cfg);
return normalizeBrandsightDomain(result);
}
async function checkAvailability4(domain, config) {
const cfg = requireDomainConfig(config);
return domainAvailability(domain, cfg, "REGISTRATION", 1);
}
async function renewDomain3(domain, years = 1, config) {
const cfg = requireDomainConfig(config);
const current = await getDomainInfo3(domain, cfg);
if (!current?.expires)
throw new BrandsightApiError(`Cannot renew ${domain}: current expiry is unavailable`);
const quote = await domainAvailability(domain, cfg, "RENEWAL", years);
const price = quote.price ?? current.renewal?.price;
const currency = quote.currency ?? current.renewal?.currency;
if (price == null || !currency) {
throw new BrandsightApiError(`Cannot renew ${domain}: renewal quote did not include an exact price and currency`);
}
const result = await domainApiRequest("POST", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/renew`), cfg, {
consent: {
agreedAt: new Date().toISOString(),
agreedBy: cfg.shopperId ?? "domains-cli",
currency,
price,
registryPremiumPricing: quote.registryPremiumPricing ?? false
},
expires: current.expires,
period: years
});
return { success: true, orderId: result.orderId ?? result.id };
}
async function getLegalAgreements(tld, privacy = false, config) {
const cfg = requireDomainConfig(config);
const params = new URLSearchParams({
privacy: String(privacy),
tlds: tld
});
return domainApiRequest("GET", customerPath(cfg, `/domains/agreements?${params.toString()}`), cfg);
}
async function getRegistrationSchema(tld, config) {
const cfg = requireDomainConfig(config);
return domainApiRequest("GET", customerPath(cfg, `/domains/register/schema/${encodeURIComponent(tld)}`), cfg);
}
async function validateRegistrationRequest(payload, config) {
const cfg = requireDomainConfig(config);
await domainApiRequest("POST", customerPath(cfg, "/domains/register/validate"), cfg, payload);
return true;
}
async function registerBrandsightDomain(domain, contact, options = {}, config) {
const cfg = requireDomainConfig(config);
const period = options.years ?? 1;
const availability = await domainAvailability(domain, cfg, "REGISTRATION", period);
if (!availability.available)
throw new BrandsightApiError(`${domain} is not available for registration`);
const price = options.premiumPrice ?? availability.price;
if (price == null || !availability.currency) {
throw new BrandsightApiError(`Cannot register ${domain}: availability quote did not include an exact price and currency`);
}
const tld = domainTld(domain);
const schema = await getRegistrationSchema(tld, cfg);
const required = Array.isArray(schema["required"]) ? schema["required"] : [];
if (required.includes("metadata") && !options.metadata) {
throw new BrandsightApiError(`Cannot register ${domain}: ${tld} requires TLD-specific metadata; pass registration metadata before validation`);
}
const privacy = options.privacy ?? false;
const agreements = await getLegalAgreements(tld, privacy, cfg);
const agreementKeys = agreements.map((a) => a.agreementKey).filter(Boolean);
const c = brandsightContact(contact);
const payload = {
consent: {
agreedAt: new Date().toISOString(),
agreedBy: contact.email || cfg.shopperId || "domains-cli",
agreementKeys,
currency: availability.currency,
price,
registryPremiumPricing: availability.registryPremiumPricing ?? !!options.premiumPrice
},
contacts: {
admin: c,
billing: c,
registrant: c,
tech: c
},
domain,
metadata: options.metadata ?? {},
nameServers: options.nameservers ?? [],
period,
privacy,
renewAuto: options.autoRenew ?? true
};
await validateRegistrationRequest(payload, cfg);
const result = await domainApiRequest("POST", customerPath(cfg, "/domains/register"), cfg, payload);
return {
success: true,
orderId: result.orderId ?? result.id,
operationId: result.operationId ?? result.id,
chargedAmount: String(price)
};
}
async function updateNameservers3(domain, nameservers, config) {
const cfg = requireDomainConfig(config);
const result = await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/nameServers`), cfg, { nameServers: nameservers });
return { success: true, operationId: result.operationId ?? result.id };
}
async function getDnsRecords3(domain, config) {
const cfg = requireDomainConfig(config);
const records = [];
let offset = 0;
const limit = 1000;
while (true) {
const batch = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records?offset=${offset}&limit=${limit}`), cfg);
if (!Array.isArray(batch) || batch.length === 0)
break;
if (records.length + batch.length > 5000) {
throw new BrandsightApiError("Brandsight DNS record inventory exceeds the 5000-record safety bound");
}
records.push(...batch);
if (batch.length < limit)
break;
offset += limit;
}
return records;
}
function normalizeBrandsightDnsRecord(record) {
return {
...record,
ttl: Math.max(record.ttl || 600, 600)
};
}
async function setDnsRecords3(domain, records, config) {
const cfg = requireDomainConfig(config);
await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records`), cfg, records.map(normalizeBrandsightDnsRecord));
return true;
}
async function syncToLocalDb3(dbFns, config) {
const domains = await listDomains2(config);
let synced = 0, created = 0, updated = 0;
const errors = [];
const syncedAt = new Date().toISOString();
for (const d of domains) {
try {
const existing = await dbFns.getDomainByName(d.domain);
if (existing) {
await dbFns.updateDomain(existing.id, {
registrar: "Brandsight",
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
status: "active",
nameservers: d.nameservers,
expiry_synced_at: syncedAt
});
updated++;
} else {
await dbFns.createDomain({
name: d.domain,
registrar: "Brandsight",
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
status: "active",
nameservers: d.nameservers,
expiry_synced_at: syncedAt
});
created++;
}
synced++;
} catch (err) {
errors.push(`${d.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
}
function createBrandsightProvider(config) {
const cfg = config ?? getConfig4();
return {
name: "brandsight",
async listDomains() {
const domains = await listDomains2(cfg);
return domains.map((d) => ({
domain: d.domain,
registrar: "Brandsight",
created: d.created ?? "",
expires: d.expires,
nameservers: d.nameservers,
status: d.status === "ACTIVE" ? "active" : d.status.toLowerCase(),
auto_renew: d.auto_renew
}));
},
async getDomainInfo(domain) {
const d = await getDomainInfo3(domain, cfg);
if (!d)
throw new Error(`Domain not found in Brandsight: ${domain}`);
return {
domain: d.domain,
registrar: "Brandsight",
created: d.created ?? "",
expires: d.expires,
nameservers: d.nameservers,
status: d.status === "ACTIVE" ? "active" : d.status.toLowerCase(),
auto_renew: d.auto_renew
};
},
async renewDomain(domain, years = 1) {
const result = await renewDomain3(domain, years, cfg);
return { domain, success: result.success, orderId: result.orderId };
},
async registerDomain(domain, contact, options) {
const result = await registerBrandsightDomain(domain, contact, options, cfg);
return {
domain,
success: result.success,
orderId: result.orderId,
operationId: result.operationId,
chargedAmount: result.chargedAmount
};
},
async updateNameservers(domain, nameservers) {
const result = await updateNameservers3(domain, nameservers, cfg);
return { domain, success: result.success, operationId: result.operationId };
},
async getDnsRecords(domain) {
const records = await getDnsRecords3(domain, cfg);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.data,
ttl: r.ttl,
priority: r.priority
}));
},
async setDnsRecords(domain, records) {
return setDnsRecords3(domain, records.map((r) => ({
type: r.type,
name: r.name,
data: r.value,
ttl: r.ttl,
priority: r.priority
})), cfg);
},
async checkAvailability(domain) {
const result = await checkAvailability4(domain, cfg);
return {
domain: result.domain,
available: result.available,
is_premium: result.registryPremiumPricing,
premium_price: result.registryPremiumPricing ? result.price : undefined,
standard_price: result.registryPremiumPricing ? undefined : result.price,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
return syncToLocalDb3(dbFns, cfg);
}
};
}
// src/lib/registrar.ts
function createNamecheapProvider() {
return {
name: "namecheap",
async listDomains() {
const config = getConfig();
const domains = await listNamecheapDomains(config);
return domains.map((d) => ({
domain: d.domain,
registrar: "Namecheap",
created: "",
expires: d.expiry,
nameservers: [],
status: "active",
auto_renew: d.autoRenew
}));
},
async getDomainInfo(domain) {
const config = getConfig();
const info = await getDomainInfo(domain, config);
return {
domain: info.domain,
registrar: info.registrar,
created: info.created,
expires: info.expires,
nameservers: info.nameservers,
status: "active",
auto_renew: true
};
},
async registerDomain(domain, contact, options = {}) {
const config = getConfig();
const result = await registerDomain(domain, contact, {
years: options.years,
premiumPrice: options.premiumPrice
}, config);
return {
domain: result.domain,
success: result.success,
orderId: result.orderId,
chargedAmount: result.chargedAmount
};
},
async updateNameservers(domain, nameservers) {
const config = getConfig();
const success = await updateNameservers(domain, nameservers, config);
return { domain, success };
},
async renewDomain(domain, years = 1) {
const config = getConfig();
const result = await renewDomain(domain, years, config);
return {
domain: result.domain,
success: result.success,
orderId: result.orderId,
chargedAmount: result.chargedAmount
};
},
async getDnsRecords(domain) {
const config = getConfig();
const { sld, tld } = splitDomain(domain);
const records = await getDnsRecords(domain, sld, tld, config);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.address,
ttl: r.ttl,
priority: r.mxPref
}));
},
async setDnsRecords(domain, records) {
const config = getConfig();
const { sld, tld } = splitDomain(domain);
const ncRecords = records.map((r) => ({
type: r.type,
name: r.name,
address: r.value,
ttl: r.ttl,
mxPref: r.priority
}));
return setDnsRecords(domain, sld, tld, ncRecords, config);
},
async checkAvailability(domain) {
const config = getConfig();
const result = await checkAvailability(domain, config);
return {
domain: result.domain,
available: result.available,
is_premium: result.premium,
premium_price: result.price
};
},
async syncToLocalDb(dbFns) {
const result = await syncToLocalDb(dbFns);
return {
synced: result.synced,
created: 0,
updated: 0,
errors: result.errors
};
}
};
}
function createGoDaddyProvider() {
return {
name: "godaddy",
async listDomains() {
const domains = await listGoDaddyDomains();
return domains.map((d) => ({
domain: d.domain,
registrar: "GoDaddy",
created: "",
expires: d.expires,
nameservers: d.nameServers || [],
status: d.status.toLowerCase(),
auto_renew: d.renewAuto
}));
},
async getDomainInfo(domain) {
const detail = await getDomainInfo2(domain);
return {
domain: detail.domain,
registrar: "GoDaddy",
created: detail.createdAt || "",
expires: detail.expires,
nameservers: detail.nameServers || [],
status: detail.status.toLowerCase(),
auto_renew: detail.renewAuto
};
},
async renewDomain(domain) {
const result = await renewDomain2(domain);
return {
domain,
success: true,
orderId: String(result.orderId),
chargedAmount: String(result.total)
};
},
async getDnsRecords(domain) {
const records = await getDnsRecords2(domain);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.data,
ttl: r.ttl,
priority: r.priority
}));
},
async setDnsRecords(domain, records) {
const gdRecords = records.map((r) => ({
type: r.type,
name: r.name,
data: r.value,
ttl: r.ttl,
priority: r.priority
}));
await setDnsRecords2(domain, gdRecords);
return true;
},
async checkAvailability(domain) {
const result = await checkAvailability2(domain);
return {
domain: result.domain,
available: result.available,
standard_price: result.price,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
const result = await syncToLocalDb2(dbFns);
return {
synced: result.synced,
created: result.created,
updated: result.updated,
errors: result.errors
};
}
};
}
var providerRegistry = new Map([
["namecheap", {
info: {
name: "namecheap",
type: "full",
configured: false,
envVars: providerEnvNames("namecheap")
},
createInventory: createNamecheapProvider,
createRegistrar: createNamecheapProvider,
createDns: createNamecheapProvider
}],
["godaddy", {
info: {
name: "godaddy",
type: "full",
configured: false,
envVars: providerEnvNames("godaddy")
},
createInventory: createGoDaddyProvider,
createRegistrar: createGoDaddyProvider,
createDns: createGoDaddyProvider
}],
["route53", {
info: {
name: "route53",
type: "full",
configured: false,
envVars: providerEnvNames("route53")
},
createInventory: () => createRoute53Provider(),
createRegistrar: () => createRoute53Provider(),
createDns: () => createRoute53Provider()
}],
["cloudflare", {
info: {
name: "cloudflare",
type: "dns",
configured: false,
envVars: providerEnvNames("cloudflare")
},
createInventory: () => createCloudflareProvider(),
createDns: createCloudflareProvider
}],
["brandsight", {
info: {
name: "brandsight",
type: "full",
configured: false,
envVars: providerEnvNames("brandsight")
},
createInventory: createBrandsightProvider,
createRegistrar: createBrandsightProvider,
createDns: createBrandsightProvider
}],
["sedo", {
info: {
name: "sedo",
type: "marketplace",
configured: false,
envVars: providerEnvNames("sedo")
}
}]
]);
function isConfigured(providerName) {
return hasProviderCredentials(providerName);
}
function getAvailableProviders() {
return Array.from(providerRegistry.values()).map((e) => ({
...e.info,
configured: isConfigured(e.info.name),
inventory: !!e.createInventory
}));
}
function getProviderInfo(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry)
return null;
return { ...entry.info, configured: isConfigured(entry.info.name), inventory: !!entry.createInventory };
}
function providerHasRegistrar(name) {
return !!providerRegistry.get(name.toLowerCase())?.createRegistrar;
}
function providerHasDns(name) {
return !!providerRegistry.get(name.toLowerCase())?.createDns;
}
function providerHasInventory(name) {
return !!providerRegistry.get(name.toLowerCase())?.createInventory;
}
function getDomainInventoryProvider(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry?.createInventory)
throw new Error(`No domain inventory provider: ${name}`);
return entry.createInventory();
}
function getRegistrarProvider(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry?.createRegistrar)
throw new Error(`No registrar provider: ${name}`);
return entry.createRegistrar();
}
function getProvider(name) {
return getRegistrarProvider(name);
}
async function syncAll(dbFns) {
const available = getAvailableProviders().filter((p) => p.configured && providerHasInventory(p.name));
const result = { providers: [], totalSynced: 0, totalErrors: [] };
for (const info of available) {
try {
const provider = getDomainInventoryProvider(info.name);
const syncResult = await provider.syncToLocalDb(dbFns);
result.providers.push({ name: info.name, result: syncResult });
result.totalSynced += syncResult.synced;
result.totalErrors.push(...syncResult.errors.map((e) => `[${info.name}] ${e}`));
} catch (error) {
const msg = `[${info.name}] Sync failed: ${error instanceof Error ? error.message : String(error)}`;
result.totalErrors.push(msg);
result.providers.push({ name: info.name, result: { synced: 0, created: 0, updated: 0, errors: [msg] } });
}
}
return result;
}
async function autoDetectRegistrar(domain, getDomainByName) {
const dbDomain = await getDomainByName(domain);
if (!dbDomain?.registrar)
return null;
const r = dbDomain.registrar.toLowerCase();
if (r.includes("cloudflare dns") || r.includes("route 53 dns") || r.includes("route53 dns"))
return null;
if (r.includes("namecheap"))
return "namecheap";
if (r.includes("godaddy"))
return "godaddy";
if (r.includes("route 53") || r.includes("route53"))
return "route53";
if (r.includes("cloudflare"))
return null;
if (r.includes("brandsight"))
return "brandsight";
return null;
}
// src/lib/delegate.ts
async function delegateDomainToCloudflare(domain, deps) {
const zone = await deps.createCloudflareZone(domain);
if (!zone.nameservers || zone.nameservers.length === 0) {
throw new Error(`Cloudflare zone for ${domain} returned no nameservers; cannot delegate`);
}
const { operationId } = await deps.updateNameservers(domain, zone.nameservers);
return { zoneId: zone.id, nameservers: zone.nameservers, operationId };
}
// src/lib/capability.ts
var PROVIDER_CAPABILITIES = {
route53: { canBuy: true, canDns: true, gated: false, notes: "Full self-serve buy + hosted zones via AWS API; primary buy path." },
cloudflare: { canBuy: false, canDns: true, gated: false, notes: "DNS/zone management only; not a registrar." },
namecheap: { canBuy: true, canDns: true, gated: false, notes: "Buy + DNS via API; requires API access + whitelisted IP." },
godaddy: { canBuy: false, canDns: true, gated: true, notes: "Availability remains threshold-gated; this CLI supports sync/renew/DNS records where account access qualifies, but not direct automated purchase." },
brandsight: { canBuy: true, canDns: true, gated: true, notes: "GoDaddy Corporate Domains (enterprise/contract-only); this CLI supports portfolio, registration, renewal, nameserver, and DNS operations through the official v2 API when the account contract permits it." },
sedo: { canBuy: false, canDns: false, gated: true, notes: "Marketplace API only: search/portfolio/listings and recorded purchases; no registrar DNS or direct registration API in this CLI." }
};
var UNKNOWN = { canBuy: false, canDns: false, gated: true, notes: "Unknown provider." };
function getCapability(name) {
return PROVIDER_CAPABILITIES[name.toLowerCase()] ?? UNKNOWN;
}
function canBuy(name) {
const c = getCapability(name);
return c.canBuy && !c.gated;
}
function selectBuyRegistrar(preference) {
if (preference) {
const c = getCapability(preference);
if (!c.canBuy)
throw new Error(`Registrar '${preference}' cannot buy domains`);
if (c.gated)
throw new Error(`Registrar '${preference}' is gated/enterprise-only and not available for automated purchase: ${c.notes}`);
return preference.toLowerCase();
}
return "route53";
}
function selectDnsProvider(preference) {
if (preference) {
const c = getCapability(preference);
if (!c.canDns)
throw new Error(`Provider '${preference}' cannot manage DNS`);
if (c.gated)
throw new Error(`Provider '${preference}' DNS is gated and may require account approval: ${c.notes}`);
return preference.toLowerCase();
}
return "cloudflare";
}
// src/lib/registration-poll.ts
function classifyRegistrationStatus(status) {
const s = status.toUpperCase();
if (s === "SUCCESSFUL")
return "success";
if (s === "ERROR" || s === "FAILED")
return "failed";
return "pending";
}
async function pollRegistrationUntilDone(operationId, opts) {
const maxAttempts = opts.maxAttempts ?? 60;
const intervalMs = opts.intervalMs ?? 1e4;
const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
let attempts = 0;
while (attempts < maxAttempts) {
const { status, message } = await opts.getStatus(operationId);
attempts++;
const verdict = classifyRegistrationStatus(status);
if (verdict === "success")
return { status: "success", attempts, message };
if (verdict === "failed")
return { status: "failed", attempts, message };
if (attempts < maxAttempts)
await sleep(intervalMs);
}
return { status: "timeout", attempts };
}
export {
ApiStore,
DOMAIN_EMAIL_TYPES,
DOMAIN_OFFER_STATUSES,
DOMAIN_OWNER_SOURCES,
DOMAIN_STATUSES,
HISTORY_TYPES,
PROVIDER_CAPABILITIES,
autoDetectRegistrar,
canBuy,
createZone as cfCreateZone,
ensureZone as cfEnsureZone,
getZone as cfGetZone,
upsertRecord2 as cfUpsertRecord,
checkAllDomains,
checkDnsBlacklist,
checkDnsPropagation,
checkDomainReputation,
checkSsl,
classifyRegistrationStatus,
cloudflareAuthHeaders,
countDomains,
createAlert,
createDnsRecord,
createDomain,
createDomainOffer,
createDomainOwner,
createHistoryEntry,
createRoute53Provider,
delegateDomainToCloudflare,
deleteAlert,
deleteDnsRecord,
deleteDomain,
deleteDomainOwner,
deleteDomainReputation,
deleteHistoryByDomain,
deleteHistoryEntry,
discoverSubdomains,
exportPortfolio,
exportZoneFile,
extractOwnerFromWhois,
getAlert,
getAvailableProviders,
getByRegistrar,
getCapability,
getDnsRecord,
getDomain,
getDomainByIdentifier,
getDomainByName,
getDomainDetails,
getDomainEmailLink,
getDomainInventoryProvider,
getDomainOffer,
getDomainOwner,
getDomainOwnerByDomain,
getDomainOwnerByDomainName,
getDomainReputation,
getDomainReputationByName,
getDomainStats,
getHistoryByDateRange,
getHistoryByDomain,
getHistoryEntry,
getLatestByDomainName,
getLatestSnapshot,
getProvider,
getProviderInfo,
getStore,
importZoneFile,
isCloudStore,
linkDomainEmail,
linkOwnerToContacts,
listAlerts,
listBlacklistedDomains,
listDnsRecords,
listDomainEmailLinks,
listDomainOffers,
listDomainOwners,
listDomains,
listDomainsWithHistoryChanges,
listDomainsWithOwners,
listExpiring,
listHighThreatDomains,
listSslExpiring,
markDomainPremium,
pollRegistrationUntilDone,
providerHasDns,
providerHasInventory,
providerHasRegistrar,
checkAvailability3 as r53CheckAvailability,
createHostedZone as r53CreateHostedZone,
deleteHostedZone as r53DeleteHostedZone,
deleteRecord as r53DeleteRecord,
findHostedZoneByDomain as r53FindHostedZoneByDomain,
findHostedZoneByNameservers as r53FindHostedZoneByNameservers,
getConfig2 as r53GetConfig,
getHostedZone as r53GetHostedZone,
getRegistrationStatus as r53GetRegistrationStatus,
getTldPrice as r53GetTldPrice,
listHostedZones as r53ListHostedZones,
listRecords as r53ListRecords,
listRegisteredDomains as r53ListRegisteredDomains,
listTldPrices as r53ListTldPrices,
registerDomain2 as r53RegisterDomain,
requestTransferOutAuthCode as r53RequestTransferOutAuthCode,
transferDomain as r53TransferDomain,
updateNameservers2 as r53UpdateNameservers,
upsertRecord as r53UpsertRecord,
upsertRecords as r53UpsertRecords,
recordDomainPurchase,
resolveCloudflareConfig,
searchDomains,
selectBuyRegistrar,
selectDnsProvider,
syncAll,
updateDnsRecord,
updateDomain,
updateDomainLifecycleStatus,
updateDomainOwner,
updateDomainReputation,
upsertDomainReputation,
validateDns,
whoisLookup
};