@hanzo/s3 0.6.4 → 8.0.7

package/dist/main/CredentialProvider.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Credentials = require("./Credentials.js");
+class CredentialProvider {
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }) {
+    this.credentials = new _Credentials.Credentials({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+  }
+  async getCredentials() {
+    return this.credentials.get();
+  }
+  setCredentials(credentials) {
+    if (credentials instanceof _Credentials.Credentials) {
+      this.credentials = credentials;
+    } else {
+      throw new Error('Unable to set Credentials. it should be an instance of Credentials class');
+    }
+  }
+  setAccessKey(accessKey) {
+    this.credentials.setAccessKey(accessKey);
+  }
+  getAccessKey() {
+    return this.credentials.getAccessKey();
+  }
+  setSecretKey(secretKey) {
+    this.credentials.setSecretKey(secretKey);
+  }
+  getSecretKey() {
+    return this.credentials.getSecretKey();
+  }
+  setSessionToken(sessionToken) {
+    this.credentials.setSessionToken(sessionToken);
+  }
+  getSessionToken() {
+    return this.credentials.getSessionToken();
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+exports.CredentialProvider = CredentialProvider;
+var _default = CredentialProvider;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/main/Credentials.d.ts

@@ -0,0 +1,22 @@
+export declare class Credentials {
+  accessKey: string;
+  secretKey: string;
+  sessionToken?: string;
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }: {
+    accessKey: string;
+    secretKey: string;
+    sessionToken?: string;
+  });
+  setAccessKey(accessKey: string): void;
+  getAccessKey(): string;
+  setSecretKey(secretKey: string): void;
+  getSecretKey(): string;
+  setSessionToken(sessionToken: string): void;
+  getSessionToken(): string | undefined;
+  get(): Credentials;
+}
+export default Credentials;

package/dist/main/Credentials.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+class Credentials {
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }) {
+    this.accessKey = accessKey;
+    this.secretKey = secretKey;
+    this.sessionToken = sessionToken;
+  }
+  setAccessKey(accessKey) {
+    this.accessKey = accessKey;
+  }
+  getAccessKey() {
+    return this.accessKey;
+  }
+  setSecretKey(secretKey) {
+    this.secretKey = secretKey;
+  }
+  getSecretKey() {
+    return this.secretKey;
+  }
+  setSessionToken(sessionToken) {
+    this.sessionToken = sessionToken;
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  get() {
+    return this;
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+exports.Credentials = Credentials;
+var _default = Credentials;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/main/IamAwsProvider.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { CredentialProvider } from "./CredentialProvider.js";
+import { Credentials } from "./Credentials.js";
+export interface IamAwsProviderOptions {
+  customEndpoint?: string;
+  transportAgent?: http.Agent;
+}
+export declare class IamAwsProvider extends CredentialProvider {
+  private readonly customEndpoint?;
+  private _credentials;
+  private readonly transportAgent?;
+  private accessExpiresAt;
+  constructor({
+    customEndpoint,
+    transportAgent
+  }: IamAwsProviderOptions);
+  getCredentials(): Promise<Credentials>;
+  private fetchCredentials;
+  private fetchCredentialsUsingTokenFile;
+  private fetchImdsToken;
+  private getIamRoleNamedUrl;
+  private getIamRoleName;
+  private requestCredentials;
+  private isAboutToExpire;
+}
+export default IamAwsProvider;

package/dist/main/IamAwsProvider.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var fs = _interopRequireWildcard(require("fs/promises"), true);
+var http = _interopRequireWildcard(require("http"), true);
+var https = _interopRequireWildcard(require("https"), true);
+var _url = require("url");
+var _CredentialProvider = require("./CredentialProvider.js");
+var _Credentials = require("./Credentials.js");
+var _helper = require("./internal/helper.js");
+var _request = require("./internal/request.js");
+var _response = require("./internal/response.js");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class IamAwsProvider extends _CredentialProvider.CredentialProvider {
+  accessExpiresAt = '';
+  constructor({
+    customEndpoint = undefined,
+    transportAgent = undefined
+  }) {
+    super({
+      accessKey: '',
+      secretKey: ''
+    });
+    this.customEndpoint = customEndpoint;
+    this.transportAgent = transportAgent;
+
+    /**
+     * Internal Tracking variables
+     */
+    this._credentials = null;
+  }
+  async getCredentials() {
+    if (!this._credentials || this.isAboutToExpire()) {
+      this._credentials = await this.fetchCredentials();
+    }
+    return this._credentials;
+  }
+  async fetchCredentials() {
+    try {
+      // check for IRSA (https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)
+      const tokenFile = process.env.AWS_WEB_IDENTITY_TOKEN_FILE;
+      if (tokenFile) {
+        return await this.fetchCredentialsUsingTokenFile(tokenFile);
+      }
+
+      // try with IAM role for EC2 instances (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)
+      let tokenHeader = 'Authorization';
+      let token = process.env.AWS_CONTAINER_AUTHORIZATION_TOKEN;
+      const relativeUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI;
+      const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI;
+      let url;
+      if (relativeUri) {
+        url = new _url.URL(relativeUri, 'http://169.254.170.2');
+      } else if (fullUri) {
+        url = new _url.URL(fullUri);
+      } else {
+        token = await this.fetchImdsToken();
+        tokenHeader = 'X-aws-ec2-metadata-token';
+        url = await this.getIamRoleNamedUrl(token);
+      }
+      return this.requestCredentials(url, tokenHeader, token);
+    } catch (err) {
+      throw new Error(`Failed to get Credentials: ${err}`, {
+        cause: err
+      });
+    }
+  }
+  async fetchCredentialsUsingTokenFile(tokenFile) {
+    const token = await fs.readFile(tokenFile, {
+      encoding: 'utf8'
+    });
+    const region = process.env.AWS_REGION;
+    const stsEndpoint = new _url.URL(region ? `https://sts.${region}.amazonaws.com` : 'https://sts.amazonaws.com');
+    const hostValue = stsEndpoint.hostname;
+    const portValue = stsEndpoint.port;
+    const qryParams = new _url.URLSearchParams({
+      Action: 'AssumeRoleWithWebIdentity',
+      Version: '2011-06-15'
+    });
+    const roleArn = process.env.AWS_ROLE_ARN;
+    if (roleArn) {
+      qryParams.set('RoleArn', roleArn);
+      const roleSessionName = process.env.AWS_ROLE_SESSION_NAME;
+      qryParams.set('RoleSessionName', roleSessionName ? roleSessionName : Date.now().toString());
+    }
+    qryParams.set('WebIdentityToken', token);
+    qryParams.sort();
+    const requestOptions = {
+      hostname: hostValue,
+      port: portValue,
+      path: `${stsEndpoint.pathname}?${qryParams.toString()}`,
+      protocol: stsEndpoint.protocol,
+      method: 'POST',
+      headers: {},
+      agent: this.transportAgent
+    };
+    const transport = stsEndpoint.protocol === 'http:' ? http : https;
+    const res = await (0, _request.request)(transport, requestOptions, null);
+    const body = await (0, _response.readAsString)(res);
+    const assumeRoleResponse = (0, _helper.parseXml)(body);
+    const creds = assumeRoleResponse.AssumeRoleWithWebIdentityResponse.AssumeRoleWithWebIdentityResult.Credentials;
+    this.accessExpiresAt = creds.Expiration;
+    return new _Credentials.Credentials({
+      accessKey: creds.AccessKeyId,
+      secretKey: creds.SecretAccessKey,
+      sessionToken: creds.SessionToken
+    });
+  }
+  async fetchImdsToken() {
+    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254';
+    const url = new _url.URL('/latest/api/token', endpoint);
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'PUT',
+      headers: {
+        'X-aws-ec2-metadata-token-ttl-seconds': '21600'
+      },
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await (0, _request.request)(transport, requestOptions, null);
+    return await (0, _response.readAsString)(res);
+  }
+  async getIamRoleNamedUrl(token) {
+    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254';
+    const url = new _url.URL('latest/meta-data/iam/security-credentials/', endpoint);
+    const roleName = await this.getIamRoleName(url, token);
+    return new _url.URL(`${url.pathname}/${encodeURIComponent(roleName)}`, url.origin);
+  }
+  async getIamRoleName(url, token) {
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'GET',
+      headers: {
+        'X-aws-ec2-metadata-token': token
+      },
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await (0, _request.request)(transport, requestOptions, null);
+    const body = await (0, _response.readAsString)(res);
+    const roleNames = body.split(/\r\n|[\n\r\u2028\u2029]/);
+    if (roleNames.length === 0) {
+      throw new Error(`No IAM roles attached to EC2 service ${url}`);
+    }
+    return roleNames[0];
+  }
+  async requestCredentials(url, tokenHeader, token) {
+    const headers = {};
+    if (token) {
+      headers[tokenHeader] = token;
+    }
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'GET',
+      headers: headers,
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await (0, _request.request)(transport, requestOptions, null);
+    const body = await (0, _response.readAsString)(res);
+    const ecsCredentials = JSON.parse(body);
+    if (!ecsCredentials.Code || ecsCredentials.Code != 'Success') {
+      throw new Error(`${url} failed with code ${ecsCredentials.Code} and message ${ecsCredentials.Message}`);
+    }
+    this.accessExpiresAt = ecsCredentials.Expiration;
+    return new _Credentials.Credentials({
+      accessKey: ecsCredentials.AccessKeyID,
+      secretKey: ecsCredentials.SecretAccessKey,
+      sessionToken: ecsCredentials.Token
+    });
+  }
+  isAboutToExpire() {
+    const expiresAt = new Date(this.accessExpiresAt);
+    const provisionalExpiry = new Date(Date.now() + 1000 * 10); // 10 seconds leeway
+    return provisionalExpiry > expiresAt;
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+exports.IamAwsProvider = IamAwsProvider;
+var _default = IamAwsProvider;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","http","https","_url","_CredentialProvider","_Credentials","_helper","_request","_response","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","IamAwsProvider","CredentialProvider","accessExpiresAt","constructor","customEndpoint","undefined","transportAgent","accessKey","secretKey","_credentials","getCredentials","isAboutToExpire","fetchCredentials","tokenFile","process","env","AWS_WEB_IDENTITY_TOKEN_FILE","fetchCredentialsUsingTokenFile","tokenHeader","token","AWS_CONTAINER_AUTHORIZATION_TOKEN","relativeUri","AWS_CONTAINER_CREDENTIALS_RELATIVE_URI","fullUri","AWS_CONTAINER_CREDENTIALS_FULL_URI","url","URL","fetchImdsToken","getIamRoleNamedUrl","requestCredentials","err","Error","cause","readFile","encoding","region","AWS_REGION","stsEndpoint","hostValue","hostname","portValue","port","qryParams","URLSearchParams","Action","Version","roleArn","AWS_ROLE_ARN","roleSessionName","AWS_ROLE_SESSION_NAME","Date","now","toString","sort","requestOptions","path","pathname","protocol","method","headers","agent","transport","res","request","body","readAsString","assumeRoleResponse","parseXml","creds","AssumeRoleWithWebIdentityResponse","AssumeRoleWithWebIdentityResult","Credentials","Expiration","AccessKeyId","SecretAccessKey","sessionToken","SessionToken","endpoint","search","roleName","getIamRoleName","encodeURIComponent","origin","roleNames","split","length","ecsCredentials","JSON","parse","Code","Message","AccessKeyID","Token","expiresAt","provisionalExpiry","exports","_default"],"sources":["IamAwsProvider.ts"],"sourcesContent":["import * as fs from 'node:fs/promises'\nimport * as http from 'node:http'\nimport * as https from 'node:https'\nimport { URL, URLSearchParams } from 'node:url'\n\nimport { CredentialProvider } from './CredentialProvider.ts'\nimport { Credentials } from './Credentials.ts'\nimport { parseXml } from './internal/helper.ts'\nimport { request } from './internal/request.ts'\nimport { readAsString } from './internal/response.ts'\n\ninterface AssumeRoleResponse {\n  AssumeRoleWithWebIdentityResponse: {\n    AssumeRoleWithWebIdentityResult: {\n      Credentials: {\n        AccessKeyId: string\n        SecretAccessKey: string\n        SessionToken: string\n        Expiration: string\n      }\n    }\n  }\n}\n\ninterface EcsCredentials {\n  AccessKeyID: string\n  SecretAccessKey: string\n  Token: string\n  Expiration: string\n  Code: string\n  Message: string\n}\n\nexport interface IamAwsProviderOptions {\n  customEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport class IamAwsProvider extends CredentialProvider {\n  private readonly customEndpoint?: string\n\n  private _credentials: Credentials | null\n  private readonly transportAgent?: http.Agent\n  private accessExpiresAt = ''\n\n  constructor({ customEndpoint = undefined, transportAgent = undefined }: IamAwsProviderOptions) {\n    super({ accessKey: '', secretKey: '' })\n\n    this.customEndpoint = customEndpoint\n    this.transportAgent = transportAgent\n\n    /**\n     * Internal Tracking variables\n     */\n    this._credentials = null\n  }\n\n  async getCredentials(): Promise<Credentials> {\n    if (!this._credentials || this.isAboutToExpire()) {\n      this._credentials = await this.fetchCredentials()\n    }\n    return this._credentials\n  }\n\n  private async fetchCredentials(): Promise<Credentials> {\n    try {\n      // check for IRSA (https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)\n      const tokenFile = process.env.AWS_WEB_IDENTITY_TOKEN_FILE\n      if (tokenFile) {\n        return await this.fetchCredentialsUsingTokenFile(tokenFile)\n      }\n\n      // try with IAM role for EC2 instances (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)\n      let tokenHeader = 'Authorization'\n      let token = process.env.AWS_CONTAINER_AUTHORIZATION_TOKEN\n      const relativeUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI\n      const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI\n      let url: URL\n      if (relativeUri) {\n        url = new URL(relativeUri, 'http://169.254.170.2')\n      } else if (fullUri) {\n        url = new URL(fullUri)\n      } else {\n        token = await this.fetchImdsToken()\n        tokenHeader = 'X-aws-ec2-metadata-token'\n        url = await this.getIamRoleNamedUrl(token)\n      }\n\n      return this.requestCredentials(url, tokenHeader, token)\n    } catch (err) {\n      throw new Error(`Failed to get Credentials: ${err}`, { cause: err })\n    }\n  }\n\n  private async fetchCredentialsUsingTokenFile(tokenFile: string): Promise<Credentials> {\n    const token = await fs.readFile(tokenFile, { encoding: 'utf8' })\n    const region = process.env.AWS_REGION\n    const stsEndpoint = new URL(region ? `https://sts.${region}.amazonaws.com` : 'https://sts.amazonaws.com')\n\n    const hostValue = stsEndpoint.hostname\n    const portValue = stsEndpoint.port\n    const qryParams = new URLSearchParams({\n      Action: 'AssumeRoleWithWebIdentity',\n      Version: '2011-06-15',\n    })\n\n    const roleArn = process.env.AWS_ROLE_ARN\n    if (roleArn) {\n      qryParams.set('RoleArn', roleArn)\n      const roleSessionName = process.env.AWS_ROLE_SESSION_NAME\n      qryParams.set('RoleSessionName', roleSessionName ? roleSessionName : Date.now().toString())\n    }\n\n    qryParams.set('WebIdentityToken', token)\n    qryParams.sort()\n\n    const requestOptions = {\n      hostname: hostValue,\n      port: portValue,\n      path: `${stsEndpoint.pathname}?${qryParams.toString()}`,\n      protocol: stsEndpoint.protocol,\n      method: 'POST',\n      headers: {},\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = stsEndpoint.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n\n    const assumeRoleResponse: AssumeRoleResponse = parseXml(body)\n    const creds = assumeRoleResponse.AssumeRoleWithWebIdentityResponse.AssumeRoleWithWebIdentityResult.Credentials\n    this.accessExpiresAt = creds.Expiration\n    return new Credentials({\n      accessKey: creds.AccessKeyId,\n      secretKey: creds.SecretAccessKey,\n      sessionToken: creds.SessionToken,\n    })\n  }\n\n  private async fetchImdsToken() {\n    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254'\n    const url = new URL('/latest/api/token', endpoint)\n\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'PUT',\n      headers: {\n        'X-aws-ec2-metadata-token-ttl-seconds': '21600',\n      },\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    return await readAsString(res)\n  }\n\n  private async getIamRoleNamedUrl(token: string) {\n    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254'\n    const url = new URL('latest/meta-data/iam/security-credentials/', endpoint)\n\n    const roleName = await this.getIamRoleName(url, token)\n    return new URL(`${url.pathname}/${encodeURIComponent(roleName)}`, url.origin)\n  }\n\n  private async getIamRoleName(url: URL, token: string): Promise<string> {\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'GET',\n      headers: {\n        'X-aws-ec2-metadata-token': token,\n      },\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n    const roleNames = body.split(/\\r\\n|[\\n\\r\\u2028\\u2029]/)\n    if (roleNames.length === 0) {\n      throw new Error(`No IAM roles attached to EC2 service ${url}`)\n    }\n    return roleNames[0] as string\n  }\n\n  private async requestCredentials(url: URL, tokenHeader: string, token: string | undefined): Promise<Credentials> {\n    const headers: Record<string, string> = {}\n    if (token) {\n      headers[tokenHeader] = token\n    }\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'GET',\n      headers: headers,\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n    const ecsCredentials = JSON.parse(body) as EcsCredentials\n    if (!ecsCredentials.Code || ecsCredentials.Code != 'Success') {\n      throw new Error(`${url} failed with code ${ecsCredentials.Code} and message ${ecsCredentials.Message}`)\n    }\n\n    this.accessExpiresAt = ecsCredentials.Expiration\n    return new Credentials({\n      accessKey: ecsCredentials.AccessKeyID,\n      secretKey: ecsCredentials.SecretAccessKey,\n      sessionToken: ecsCredentials.Token,\n    })\n  }\n\n  private isAboutToExpire() {\n    const expiresAt = new Date(this.accessExpiresAt)\n    const provisionalExpiry = new Date(Date.now() + 1000 * 10) // 10 seconds leeway\n    return provisionalExpiry > expiresAt\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default IamAwsProvider\n"],"mappings":";;;;;AAAA,IAAAA,EAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,IAAA,GAAAF,uBAAA,CAAAC,OAAA;AACA,IAAAE,KAAA,GAAAH,uBAAA,CAAAC,OAAA;AACA,IAAAG,IAAA,GAAAH,OAAA;AAEA,IAAAI,mBAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AACA,IAAAO,QAAA,GAAAP,OAAA;AACA,IAAAQ,SAAA,GAAAR,OAAA;AAAqD,SAAAS,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAX,wBAAAe,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,CAAAJ,OAAA,GAAAF,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AA6B9C,MAAMW,cAAc,SAASC,sCAAkB,CAAC;EAK7CC,eAAe,GAAG,EAAE;EAE5BC,WAAWA,CAAC;IAAEC,cAAc,GAAGC,SAAS;IAAEC,cAAc,GAAGD;EAAiC,CAAC,EAAE;IAC7F,KAAK,CAAC;MAAEE,SAAS,EAAE,EAAE;MAAEC,SAAS,EAAE;IAAG,CAAC,CAAC;IAEvC,IAAI,CAACJ,cAAc,GAAGA,cAAc;IACpC,IAAI,CAACE,cAAc,GAAGA,cAAc;;IAEpC;AACJ;AACA;IACI,IAAI,CAACG,YAAY,GAAG,IAAI;EAC1B;EAEA,MAAMC,cAAcA,CAAA,EAAyB;IAC3C,IAAI,CAAC,IAAI,CAACD,YAAY,IAAI,IAAI,CAACE,eAAe,CAAC,CAAC,EAAE;MAChD,IAAI,CAACF,YAAY,GAAG,MAAM,IAAI,CAACG,gBAAgB,CAAC,CAAC;IACnD;IACA,OAAO,IAAI,CAACH,YAAY;EAC1B;EAEA,MAAcG,gBAAgBA,CAAA,EAAyB;IACrD,IAAI;MACF;MACA,MAAMC,SAAS,GAAGC,OAAO,CAACC,GAAG,CAACC,2BAA2B;MACzD,IAAIH,SAAS,EAAE;QACb,OAAO,MAAM,IAAI,CAACI,8BAA8B,CAACJ,SAAS,CAAC;MAC7D;;MAEA;MACA,IAAIK,WAAW,GAAG,eAAe;MACjC,IAAIC,KAAK,GAAGL,OAAO,CAACC,GAAG,CAACK,iCAAiC;MACzD,MAAMC,WAAW,GAAGP,OAAO,CAACC,GAAG,CAACO,sCAAsC;MACtE,MAAMC,OAAO,GAAGT,OAAO,CAACC,GAAG,CAACS,kCAAkC;MAC9D,IAAIC,GAAQ;MACZ,IAAIJ,WAAW,EAAE;QACfI,GAAG,GAAG,IAAIC,QAAG,CAACL,WAAW,EAAE,sBAAsB,CAAC;MACpD,CAAC,MAAM,IAAIE,OAAO,EAAE;QAClBE,GAAG,GAAG,IAAIC,QAAG,CAACH,OAAO,CAAC;MACxB,CAAC,MAAM;QACLJ,KAAK,GAAG,MAAM,IAAI,CAACQ,cAAc,CAAC,CAAC;QACnCT,WAAW,GAAG,0BAA0B;QACxCO,GAAG,GAAG,MAAM,IAAI,CAACG,kBAAkB,CAACT,KAAK,CAAC;MAC5C;MAEA,OAAO,IAAI,CAACU,kBAAkB,CAACJ,GAAG,EAAEP,WAAW,EAAEC,KAAK,CAAC;IACzD,CAAC,CAAC,OAAOW,GAAG,EAAE;MACZ,MAAM,IAAIC,KAAK,CAAE,8BAA6BD,GAAI,EAAC,EAAE;QAAEE,KAAK,EAAEF;MAAI,CAAC,CAAC;IACtE;EACF;EAEA,MAAcb,8BAA8BA,CAACJ,SAAiB,EAAwB;IACpF,MAAMM,KAAK,GAAG,MAAMpD,EAAE,CAACkE,QAAQ,CAACpB,SAAS,EAAE;MAAEqB,QAAQ,EAAE;IAAO,CAAC,CAAC;IAChE,MAAMC,MAAM,GAAGrB,OAAO,CAACC,GAAG,CAACqB,UAAU;IACrC,MAAMC,WAAW,GAAG,IAAIX,QAAG,CAACS,MAAM,GAAI,eAAcA,MAAO,gBAAe,GAAG,2BAA2B,CAAC;IAEzG,MAAMG,SAAS,GAAGD,WAAW,CAACE,QAAQ;IACtC,MAAMC,SAAS,GAAGH,WAAW,CAACI,IAAI;IAClC,MAAMC,SAAS,GAAG,IAAIC,oBAAe,CAAC;MACpCC,MAAM,EAAE,2BAA2B;MACnCC,OAAO,EAAE;IACX,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGhC,OAAO,CAACC,GAAG,CAACgC,YAAY;IACxC,IAAID,OAAO,EAAE;MACXJ,SAAS,CAAC3C,GAAG,CAAC,SAAS,EAAE+C,OAAO,CAAC;MACjC,MAAME,eAAe,GAAGlC,OAAO,CAACC,GAAG,CAACkC,qBAAqB;MACzDP,SAAS,CAAC3C,GAAG,CAAC,iBAAiB,EAAEiD,eAAe,GAAGA,eAAe,GAAGE,IAAI,CAACC,GAAG,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC,CAAC;IAC7F;IAEAV,SAAS,CAAC3C,GAAG,CAAC,kBAAkB,EAAEoB,KAAK,CAAC;IACxCuB,SAAS,CAACW,IAAI,CAAC,CAAC;IAEhB,MAAMC,cAAc,GAAG;MACrBf,QAAQ,EAAED,SAAS;MACnBG,IAAI,EAAED,SAAS;MACfe,IAAI,EAAG,GAAElB,WAAW,CAACmB,QAAS,IAAGd,SAAS,CAACU,QAAQ,CAAC,CAAE,EAAC;MACvDK,QAAQ,EAAEpB,WAAW,CAACoB,QAAQ;MAC9BC,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE,CAAC,CAAC;MACXC,KAAK,EAAE,IAAI,CAACtD;IACd,CAA+B;IAE/B,MAAMuD,SAAS,GAAGxB,WAAW,CAACoB,QAAQ,KAAK,OAAO,GAAGvF,IAAI,GAAGC,KAAK;IACjE,MAAM2F,GAAG,GAAG,MAAM,IAAAC,gBAAO,EAACF,SAAS,EAAEP,cAAc,EAAE,IAAI,CAAC;IAC1D,MAAMU,IAAI,GAAG,MAAM,IAAAC,sBAAY,EAACH,GAAG,CAAC;IAEpC,MAAMI,kBAAsC,GAAG,IAAAC,gBAAQ,EAACH,IAAI,CAAC;IAC7D,MAAMI,KAAK,GAAGF,kBAAkB,CAACG,iCAAiC,CAACC,+BAA+B,CAACC,WAAW;IAC9G,IAAI,CAACrE,eAAe,GAAGkE,KAAK,CAACI,UAAU;IACvC,OAAO,IAAID,wBAAW,CAAC;MACrBhE,SAAS,EAAE6D,KAAK,CAACK,WAAW;MAC5BjE,SAAS,EAAE4D,KAAK,CAACM,eAAe;MAChCC,YAAY,EAAEP,KAAK,CAACQ;IACtB,CAAC,CAAC;EACJ;EAEA,MAAcjD,cAAcA,CAAA,EAAG;IAC7B,MAAMkD,QAAQ,GAAG,IAAI,CAACzE,cAAc,GAAG,IAAI,CAACA,cAAc,GAAG,wBAAwB;IACrF,MAAMqB,GAAG,GAAG,IAAIC,QAAG,CAAC,mBAAmB,EAAEmD,QAAQ,CAAC;IAElD,MAAMvB,cAAc,GAAG;MACrBf,QAAQ,EAAEd,GAAG,CAACc,QAAQ;MACtBE,IAAI,EAAEhB,GAAG,CAACgB,IAAI;MACdc,IAAI,EAAG,GAAE9B,GAAG,CAAC+B,QAAS,GAAE/B,GAAG,CAACqD,MAAO,EAAC;MACpCrB,QAAQ,EAAEhC,GAAG,CAACgC,QAAQ;MACtBC,MAAM,EAAE,KAAK;MACbC,OAAO,EAAE;QACP,sCAAsC,EAAE;MAC1C,CAAC;MACDC,KAAK,EAAE,IAAI,CAACtD;IACd,CAA+B;IAE/B,MAAMuD,SAAS,GAAGpC,GAAG,CAACgC,QAAQ,KAAK,OAAO,GAAGvF,IAAI,GAAGC,KAAK;IACzD,MAAM2F,GAAG,GAAG,MAAM,IAAAC,gBAAO,EAACF,SAAS,EAAEP,cAAc,EAAE,IAAI,CAAC;IAC1D,OAAO,MAAM,IAAAW,sBAAY,EAACH,GAAG,CAAC;EAChC;EAEA,MAAclC,kBAAkBA,CAACT,KAAa,EAAE;IAC9C,MAAM0D,QAAQ,GAAG,IAAI,CAACzE,cAAc,GAAG,IAAI,CAACA,cAAc,GAAG,wBAAwB;IACrF,MAAMqB,GAAG,GAAG,IAAIC,QAAG,CAAC,4CAA4C,EAAEmD,QAAQ,CAAC;IAE3E,MAAME,QAAQ,GAAG,MAAM,IAAI,CAACC,cAAc,CAACvD,GAAG,EAAEN,KAAK,CAAC;IACtD,OAAO,IAAIO,QAAG,CAAE,GAAED,GAAG,CAAC+B,QAAS,IAAGyB,kBAAkB,CAACF,QAAQ,CAAE,EAAC,EAAEtD,GAAG,CAACyD,MAAM,CAAC;EAC/E;EAEA,MAAcF,cAAcA,CAACvD,GAAQ,EAAEN,KAAa,EAAmB;IACrE,MAAMmC,cAAc,GAAG;MACrBf,QAAQ,EAAEd,GAAG,CAACc,QAAQ;MACtBE,IAAI,EAAEhB,GAAG,CAACgB,IAAI;MACdc,IAAI,EAAG,GAAE9B,GAAG,CAAC+B,QAAS,GAAE/B,GAAG,CAACqD,MAAO,EAAC;MACpCrB,QAAQ,EAAEhC,GAAG,CAACgC,QAAQ;MACtBC,MAAM,EAAE,KAAK;MACbC,OAAO,EAAE;QACP,0BAA0B,EAAExC;MAC9B,CAAC;MACDyC,KAAK,EAAE,IAAI,CAACtD;IACd,CAA+B;IAE/B,MAAMuD,SAAS,GAAGpC,GAAG,CAACgC,QAAQ,KAAK,OAAO,GAAGvF,IAAI,GAAGC,KAAK;IACzD,MAAM2F,GAAG,GAAG,MAAM,IAAAC,gBAAO,EAACF,SAAS,EAAEP,cAAc,EAAE,IAAI,CAAC;IAC1D,MAAMU,IAAI,GAAG,MAAM,IAAAC,sBAAY,EAACH,GAAG,CAAC;IACpC,MAAMqB,SAAS,GAAGnB,IAAI,CAACoB,KAAK,CAAC,yBAAyB,CAAC;IACvD,IAAID,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;MAC1B,MAAM,IAAItD,KAAK,CAAE,wCAAuCN,GAAI,EAAC,CAAC;IAChE;IACA,OAAO0D,SAAS,CAAC,CAAC,CAAC;EACrB;EAEA,MAActD,kBAAkBA,CAACJ,GAAQ,EAAEP,WAAmB,EAAEC,KAAyB,EAAwB;IAC/G,MAAMwC,OAA+B,GAAG,CAAC,CAAC;IAC1C,IAAIxC,KAAK,EAAE;MACTwC,OAAO,CAACzC,WAAW,CAAC,GAAGC,KAAK;IAC9B;IACA,MAAMmC,cAAc,GAAG;MACrBf,QAAQ,EAAEd,GAAG,CAACc,QAAQ;MACtBE,IAAI,EAAEhB,GAAG,CAACgB,IAAI;MACdc,IAAI,EAAG,GAAE9B,GAAG,CAAC+B,QAAS,GAAE/B,GAAG,CAACqD,MAAO,EAAC;MACpCrB,QAAQ,EAAEhC,GAAG,CAACgC,QAAQ;MACtBC,MAAM,EAAE,KAAK;MACbC,OAAO,EAAEA,OAAO;MAChBC,KAAK,EAAE,IAAI,CAACtD;IACd,CAA+B;IAE/B,MAAMuD,SAAS,GAAGpC,GAAG,CAACgC,QAAQ,KAAK,OAAO,GAAGvF,IAAI,GAAGC,KAAK;IACzD,MAAM2F,GAAG,GAAG,MAAM,IAAAC,gBAAO,EAACF,SAAS,EAAEP,cAAc,EAAE,IAAI,CAAC;IAC1D,MAAMU,IAAI,GAAG,MAAM,IAAAC,sBAAY,EAACH,GAAG,CAAC;IACpC,MAAMwB,cAAc,GAAGC,IAAI,CAACC,KAAK,CAACxB,IAAI,CAAmB;IACzD,IAAI,CAACsB,cAAc,CAACG,IAAI,IAAIH,cAAc,CAACG,IAAI,IAAI,SAAS,EAAE;MAC5D,MAAM,IAAI1D,KAAK,CAAE,GAAEN,GAAI,qBAAoB6D,cAAc,CAACG,IAAK,gBAAeH,cAAc,CAACI,OAAQ,EAAC,CAAC;IACzG;IAEA,IAAI,CAACxF,eAAe,GAAGoF,cAAc,CAACd,UAAU;IAChD,OAAO,IAAID,wBAAW,CAAC;MACrBhE,SAAS,EAAE+E,cAAc,CAACK,WAAW;MACrCnF,SAAS,EAAE8E,cAAc,CAACZ,eAAe;MACzCC,YAAY,EAAEW,cAAc,CAACM;IAC/B,CAAC,CAAC;EACJ;EAEQjF,eAAeA,CAAA,EAAG;IACxB,MAAMkF,SAAS,GAAG,IAAI3C,IAAI,CAAC,IAAI,CAAChD,eAAe,CAAC;IAChD,MAAM4F,iBAAiB,GAAG,IAAI5C,IAAI,CAACA,IAAI,CAACC,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC,EAAC;IAC3D,OAAO2C,iBAAiB,GAAGD,SAAS;EACtC;AACF;;AAEA;AACA;AACA;AAAAE,OAAA,CAAA/F,cAAA,GAAAA,cAAA;AAAA,IAAAgG,QAAA,GACehG,cAAc;AAAA+F,OAAA,CAAA9G,OAAA,GAAA+G,QAAA"}

package/dist/main/errors.d.ts

@@ -0,0 +1,82 @@
+/// <reference lib="es2022.error" />
+declare class ExtendableError extends Error {
+  constructor(message?: string, opt?: ErrorOptions);
+}
+/**
+ * AnonymousRequestError is generated for anonymous keys on specific
+ * APIs. NOTE: PresignedURL generation always requires access keys.
+ */
+export declare class AnonymousRequestError extends ExtendableError {}
+/**
+ * InvalidArgumentError is generated for all invalid arguments.
+ */
+export declare class InvalidArgumentError extends ExtendableError {}
+/**
+ * InvalidPortError is generated when a non integer value is provided
+ * for ports.
+ */
+export declare class InvalidPortError extends ExtendableError {}
+/**
+ * InvalidEndpointError is generated when an invalid end point value is
+ * provided which does not follow domain standards.
+ */
+export declare class InvalidEndpointError extends ExtendableError {}
+/**
+ * InvalidBucketNameError is generated when an invalid bucket name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+export declare class InvalidBucketNameError extends ExtendableError {}
+/**
+ * InvalidObjectNameError is generated when an invalid object name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+ */
+export declare class InvalidObjectNameError extends ExtendableError {}
+/**
+ * AccessKeyRequiredError generated by signature methods when access
+ * key is not found.
+ */
+export declare class AccessKeyRequiredError extends ExtendableError {}
+/**
+ * SecretKeyRequiredError generated by signature methods when secret
+ * key is not found.
+ */
+export declare class SecretKeyRequiredError extends ExtendableError {}
+/**
+ * ExpiresParamError generated when expires parameter value is not
+ * well within stipulated limits.
+ */
+export declare class ExpiresParamError extends ExtendableError {}
+/**
+ * InvalidDateError generated when invalid date is found.
+ */
+export declare class InvalidDateError extends ExtendableError {}
+/**
+ * InvalidPrefixError generated when object prefix provided is invalid
+ * or does not conform to AWS S3 object key restrictions.
+ */
+export declare class InvalidPrefixError extends ExtendableError {}
+/**
+ * InvalidBucketPolicyError generated when the given bucket policy is invalid.
+ */
+export declare class InvalidBucketPolicyError extends ExtendableError {}
+/**
+ * IncorrectSizeError generated when total data read mismatches with
+ * the input size.
+ */
+export declare class IncorrectSizeError extends ExtendableError {}
+/**
+ * InvalidXMLError generated when an unknown XML is found.
+ */
+export declare class InvalidXMLError extends ExtendableError {}
+/**
+ * S3Error is generated for errors returned from S3 server.
+ * see getErrorTransformer for details
+ */
+export declare class S3Error extends ExtendableError {
+  code?: string;
+  region?: string;
+}
+export declare class IsValidBucketNameError extends ExtendableError {}
+export {};

package/dist/main/errors.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// <reference lib="ES2022.Error" />
+
+class ExtendableError extends Error {
+  constructor(message, opt) {
+    // error Option {cause?: unknown} is a 'nice to have',
+    // don't use it internally
+    super(message, opt);
+    // set error name, otherwise it's always 'Error'
+    this.name = this.constructor.name;
+  }
+}
+
+/**
+ * AnonymousRequestError is generated for anonymous keys on specific
+ * APIs. NOTE: PresignedURL generation always requires access keys.
+ */
+class AnonymousRequestError extends ExtendableError {}
+
+/**
+ * InvalidArgumentError is generated for all invalid arguments.
+ */
+exports.AnonymousRequestError = AnonymousRequestError;
+class InvalidArgumentError extends ExtendableError {}
+
+/**
+ * InvalidPortError is generated when a non integer value is provided
+ * for ports.
+ */
+exports.InvalidArgumentError = InvalidArgumentError;
+class InvalidPortError extends ExtendableError {}
+
+/**
+ * InvalidEndpointError is generated when an invalid end point value is
+ * provided which does not follow domain standards.
+ */
+exports.InvalidPortError = InvalidPortError;
+class InvalidEndpointError extends ExtendableError {}
+
+/**
+ * InvalidBucketNameError is generated when an invalid bucket name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+exports.InvalidEndpointError = InvalidEndpointError;
+class InvalidBucketNameError extends ExtendableError {}
+
+/**
+ * InvalidObjectNameError is generated when an invalid object name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+ */
+exports.InvalidBucketNameError = InvalidBucketNameError;
+class InvalidObjectNameError extends ExtendableError {}
+
+/**
+ * AccessKeyRequiredError generated by signature methods when access
+ * key is not found.
+ */
+exports.InvalidObjectNameError = InvalidObjectNameError;
+class AccessKeyRequiredError extends ExtendableError {}
+
+/**
+ * SecretKeyRequiredError generated by signature methods when secret
+ * key is not found.
+ */
+exports.AccessKeyRequiredError = AccessKeyRequiredError;
+class SecretKeyRequiredError extends ExtendableError {}
+
+/**
+ * ExpiresParamError generated when expires parameter value is not
+ * well within stipulated limits.
+ */
+exports.SecretKeyRequiredError = SecretKeyRequiredError;
+class ExpiresParamError extends ExtendableError {}
+
+/**
+ * InvalidDateError generated when invalid date is found.
+ */
+exports.ExpiresParamError = ExpiresParamError;
+class InvalidDateError extends ExtendableError {}
+
+/**
+ * InvalidPrefixError generated when object prefix provided is invalid
+ * or does not conform to AWS S3 object key restrictions.
+ */
+exports.InvalidDateError = InvalidDateError;
+class InvalidPrefixError extends ExtendableError {}
+
+/**
+ * InvalidBucketPolicyError generated when the given bucket policy is invalid.
+ */
+exports.InvalidPrefixError = InvalidPrefixError;
+class InvalidBucketPolicyError extends ExtendableError {}
+
+/**
+ * IncorrectSizeError generated when total data read mismatches with
+ * the input size.
+ */
+exports.InvalidBucketPolicyError = InvalidBucketPolicyError;
+class IncorrectSizeError extends ExtendableError {}
+
+/**
+ * InvalidXMLError generated when an unknown XML is found.
+ */
+exports.IncorrectSizeError = IncorrectSizeError;
+class InvalidXMLError extends ExtendableError {}
+
+/**
+ * S3Error is generated for errors returned from S3 server.
+ * see getErrorTransformer for details
+ */
+exports.InvalidXMLError = InvalidXMLError;
+class S3Error extends ExtendableError {}
+exports.S3Error = S3Error;
+class IsValidBucketNameError extends ExtendableError {}
+exports.IsValidBucketNameError = IsValidBucketNameError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ExtendableError","Error","constructor","message","opt","name","AnonymousRequestError","exports","InvalidArgumentError","InvalidPortError","InvalidEndpointError","InvalidBucketNameError","InvalidObjectNameError","AccessKeyRequiredError","SecretKeyRequiredError","ExpiresParamError","InvalidDateError","InvalidPrefixError","InvalidBucketPolicyError","IncorrectSizeError","InvalidXMLError","S3Error","IsValidBucketNameError"],"sources":["errors.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/// <reference lib=\"ES2022.Error\" />\n\nclass ExtendableError extends Error {\n  constructor(message?: string, opt?: ErrorOptions) {\n    // error Option {cause?: unknown} is a 'nice to have',\n    // don't use it internally\n    super(message, opt)\n    // set error name, otherwise it's always 'Error'\n    this.name = this.constructor.name\n  }\n}\n\n/**\n * AnonymousRequestError is generated for anonymous keys on specific\n * APIs. NOTE: PresignedURL generation always requires access keys.\n */\nexport class AnonymousRequestError extends ExtendableError {}\n\n/**\n * InvalidArgumentError is generated for all invalid arguments.\n */\nexport class InvalidArgumentError extends ExtendableError {}\n\n/**\n * InvalidPortError is generated when a non integer value is provided\n * for ports.\n */\nexport class InvalidPortError extends ExtendableError {}\n\n/**\n * InvalidEndpointError is generated when an invalid end point value is\n * provided which does not follow domain standards.\n */\nexport class InvalidEndpointError extends ExtendableError {}\n\n/**\n * InvalidBucketNameError is generated when an invalid bucket name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html\n */\nexport class InvalidBucketNameError extends ExtendableError {}\n\n/**\n * InvalidObjectNameError is generated when an invalid object name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\n */\nexport class InvalidObjectNameError extends ExtendableError {}\n\n/**\n * AccessKeyRequiredError generated by signature methods when access\n * key is not found.\n */\nexport class AccessKeyRequiredError extends ExtendableError {}\n\n/**\n * SecretKeyRequiredError generated by signature methods when secret\n * key is not found.\n */\nexport class SecretKeyRequiredError extends ExtendableError {}\n\n/**\n * ExpiresParamError generated when expires parameter value is not\n * well within stipulated limits.\n */\nexport class ExpiresParamError extends ExtendableError {}\n\n/**\n * InvalidDateError generated when invalid date is found.\n */\nexport class InvalidDateError extends ExtendableError {}\n\n/**\n * InvalidPrefixError generated when object prefix provided is invalid\n * or does not conform to AWS S3 object key restrictions.\n */\nexport class InvalidPrefixError extends ExtendableError {}\n\n/**\n * InvalidBucketPolicyError generated when the given bucket policy is invalid.\n */\nexport class InvalidBucketPolicyError extends ExtendableError {}\n\n/**\n * IncorrectSizeError generated when total data read mismatches with\n * the input size.\n */\nexport class IncorrectSizeError extends ExtendableError {}\n\n/**\n * InvalidXMLError generated when an unknown XML is found.\n */\nexport class InvalidXMLError extends ExtendableError {}\n\n/**\n * S3Error is generated for errors returned from S3 server.\n * see getErrorTransformer for details\n */\nexport class S3Error extends ExtendableError {\n  code?: string\n  region?: string\n}\n\nexport class IsValidBucketNameError extends ExtendableError {}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,MAAMA,eAAe,SAASC,KAAK,CAAC;EAClCC,WAAWA,CAACC,OAAgB,EAAEC,GAAkB,EAAE;IAChD;IACA;IACA,KAAK,CAACD,OAAO,EAAEC,GAAG,CAAC;IACnB;IACA,IAAI,CAACC,IAAI,GAAG,IAAI,CAACH,WAAW,CAACG,IAAI;EACnC;AACF;;AAEA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,SAASN,eAAe,CAAC;;AAE3D;AACA;AACA;AAFAO,OAAA,CAAAD,qBAAA,GAAAA,qBAAA;AAGO,MAAME,oBAAoB,SAASR,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AAHAO,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAIO,MAAMC,gBAAgB,SAAST,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAE,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,oBAAoB,SAASV,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAG,oBAAA,GAAAA,oBAAA;AAKO,MAAMC,sBAAsB,SAASX,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAI,sBAAA,GAAAA,sBAAA;AAKO,MAAMC,sBAAsB,SAASZ,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAK,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASb,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAM,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASd,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,iBAAiB,SAASf,eAAe,CAAC;;AAEvD;AACA;AACA;AAFAO,OAAA,CAAAQ,iBAAA,GAAAA,iBAAA;AAGO,MAAMC,gBAAgB,SAAShB,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAS,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,kBAAkB,SAASjB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAU,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,wBAAwB,SAASlB,eAAe,CAAC;;AAE9D;AACA;AACA;AACA;AAHAO,OAAA,CAAAW,wBAAA,GAAAA,wBAAA;AAIO,MAAMC,kBAAkB,SAASnB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAY,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,eAAe,SAASpB,eAAe,CAAC;;AAErD;AACA;AACA;AACA;AAHAO,OAAA,CAAAa,eAAA,GAAAA,eAAA;AAIO,MAAMC,OAAO,SAASrB,eAAe,CAAC;AAG5CO,OAAA,CAAAc,OAAA,GAAAA,OAAA;AAEM,MAAMC,sBAAsB,SAAStB,eAAe,CAAC;AAAEO,OAAA,CAAAe,sBAAA,GAAAA,sBAAA"}