[#94] Backend

https://project.mdnd-it.cc/work_packages/94

SerpentRace_Backend/node_modules/minio/dist/main/AssumeRoleProvider.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { CredentialProvider } from "./CredentialProvider.js";
+import { Credentials } from "./Credentials.js";
+/**
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+ */
+type CredentialResponse = {
+  ErrorResponse?: {
+    Error?: {
+      Code?: string;
+      Message?: string;
+    };
+  };
+  AssumeRoleResponse: {
+    AssumeRoleResult: {
+      Credentials: {
+        AccessKeyId: string;
+        SecretAccessKey: string;
+        SessionToken: string;
+        Expiration: string;
+      };
+    };
+  };
+};
+export interface AssumeRoleProviderOptions {
+  stsEndpoint: string;
+  accessKey: string;
+  secretKey: string;
+  durationSeconds?: number;
+  sessionToken?: string;
+  policy?: string;
+  region?: string;
+  roleArn?: string;
+  roleSessionName?: string;
+  externalId?: string;
+  token?: string;
+  webIdentityToken?: string;
+  action?: string;
+  transportAgent?: http.Agent;
+}
+export declare class AssumeRoleProvider extends CredentialProvider {
+  private readonly stsEndpoint;
+  private readonly accessKey;
+  private readonly secretKey;
+  private readonly durationSeconds;
+  private readonly policy?;
+  private readonly region;
+  private readonly roleArn?;
+  private readonly roleSessionName?;
+  private readonly externalId?;
+  private readonly token?;
+  private readonly webIdentityToken?;
+  private readonly action;
+  private _credentials;
+  private readonly expirySeconds;
+  private accessExpiresAt;
+  private readonly transportAgent?;
+  private readonly transport;
+  constructor({
+    stsEndpoint,
+    accessKey,
+    secretKey,
+    durationSeconds,
+    sessionToken,
+    policy,
+    region,
+    roleArn,
+    roleSessionName,
+    externalId,
+    token,
+    webIdentityToken,
+    action,
+    transportAgent
+  }: AssumeRoleProviderOptions);
+  getRequestConfig(): {
+    requestOptions: http.RequestOptions;
+    requestData: string;
+  };
+  performRequest(): Promise<CredentialResponse>;
+  parseCredentials(respObj: CredentialResponse): Credentials;
+  refreshCredentials(): Promise<Credentials>;
+  getCredentials(): Promise<Credentials>;
+  isAboutToExpire(): boolean;
+}
+export default AssumeRoleProvider;

SerpentRace_Backend/node_modules/minio/dist/main/AssumeRoleProvider.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: 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");
+var _signing = require("./signing.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; }
+/**
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+ */
+
+const defaultExpirySeconds = 900;
+class AssumeRoleProvider extends _CredentialProvider.CredentialProvider {
+  accessExpiresAt = '';
+  constructor({
+    stsEndpoint,
+    accessKey,
+    secretKey,
+    durationSeconds = defaultExpirySeconds,
+    sessionToken,
+    policy,
+    region = '',
+    roleArn,
+    roleSessionName,
+    externalId,
+    token,
+    webIdentityToken,
+    action = 'AssumeRole',
+    transportAgent = undefined
+  }) {
+    super({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+    this.stsEndpoint = new _url.URL(stsEndpoint);
+    this.accessKey = accessKey;
+    this.secretKey = secretKey;
+    this.policy = policy;
+    this.region = region;
+    this.roleArn = roleArn;
+    this.roleSessionName = roleSessionName;
+    this.externalId = externalId;
+    this.token = token;
+    this.webIdentityToken = webIdentityToken;
+    this.action = action;
+    this.durationSeconds = parseInt(durationSeconds);
+    let expirySeconds = this.durationSeconds;
+    if (this.durationSeconds < defaultExpirySeconds) {
+      expirySeconds = defaultExpirySeconds;
+    }
+    this.expirySeconds = expirySeconds; // for calculating refresh of credentials.
+
+    // By default, nodejs uses a global agent if the 'agent' property
+    // is set to undefined. Otherwise, it's okay to assume the users
+    // know what they're doing if they specify a custom transport agent.
+    this.transportAgent = transportAgent;
+    const isHttp = this.stsEndpoint.protocol === 'http:';
+    this.transport = isHttp ? http : https;
+
+    /**
+     * Internal Tracking variables
+     */
+    this._credentials = null;
+  }
+  getRequestConfig() {
+    const hostValue = this.stsEndpoint.hostname;
+    const portValue = this.stsEndpoint.port;
+    const qryParams = new _url.URLSearchParams({
+      Action: this.action,
+      Version: '2011-06-15'
+    });
+    qryParams.set('DurationSeconds', this.expirySeconds.toString());
+    if (this.policy) {
+      qryParams.set('Policy', this.policy);
+    }
+    if (this.roleArn) {
+      qryParams.set('RoleArn', this.roleArn);
+    }
+    if (this.roleSessionName != null) {
+      qryParams.set('RoleSessionName', this.roleSessionName);
+    }
+    if (this.token != null) {
+      qryParams.set('Token', this.token);
+    }
+    if (this.webIdentityToken) {
+      qryParams.set('WebIdentityToken', this.webIdentityToken);
+    }
+    if (this.externalId) {
+      qryParams.set('ExternalId', this.externalId);
+    }
+    const urlParams = qryParams.toString();
+    const contentSha256 = (0, _helper.toSha256)(urlParams);
+    const date = new Date();
+    const requestOptions = {
+      hostname: hostValue,
+      port: portValue,
+      path: '/',
+      protocol: this.stsEndpoint.protocol,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'content-length': urlParams.length.toString(),
+        host: hostValue,
+        'x-amz-date': (0, _helper.makeDateLong)(date),
+        'x-amz-content-sha256': contentSha256
+      },
+      agent: this.transportAgent
+    };
+    requestOptions.headers.authorization = (0, _signing.signV4ByServiceName)(requestOptions, this.accessKey, this.secretKey, this.region, date, contentSha256, 'sts');
+    return {
+      requestOptions,
+      requestData: urlParams
+    };
+  }
+  async performRequest() {
+    const {
+      requestOptions,
+      requestData
+    } = this.getRequestConfig();
+    const res = await (0, _request.request)(this.transport, requestOptions, requestData);
+    const body = await (0, _response.readAsString)(res);
+    return (0, _helper.parseXml)(body);
+  }
+  parseCredentials(respObj) {
+    if (respObj.ErrorResponse) {
+      var _respObj$ErrorRespons, _respObj$ErrorRespons2, _respObj$ErrorRespons3, _respObj$ErrorRespons4;
+      throw new Error(`Unable to obtain credentials: ${(_respObj$ErrorRespons = respObj.ErrorResponse) === null || _respObj$ErrorRespons === void 0 ? void 0 : (_respObj$ErrorRespons2 = _respObj$ErrorRespons.Error) === null || _respObj$ErrorRespons2 === void 0 ? void 0 : _respObj$ErrorRespons2.Code} ${(_respObj$ErrorRespons3 = respObj.ErrorResponse) === null || _respObj$ErrorRespons3 === void 0 ? void 0 : (_respObj$ErrorRespons4 = _respObj$ErrorRespons3.Error) === null || _respObj$ErrorRespons4 === void 0 ? void 0 : _respObj$ErrorRespons4.Message}`, {
+        cause: respObj
+      });
+    }
+    const {
+      AssumeRoleResponse: {
+        AssumeRoleResult: {
+          Credentials: {
+            AccessKeyId: accessKey,
+            SecretAccessKey: secretKey,
+            SessionToken: sessionToken,
+            Expiration: expiresAt
+          }
+        }
+      }
+    } = respObj;
+    this.accessExpiresAt = expiresAt;
+    return new _Credentials.Credentials({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+  }
+  async refreshCredentials() {
+    try {
+      const assumeRoleCredentials = await this.performRequest();
+      this._credentials = this.parseCredentials(assumeRoleCredentials);
+    } catch (err) {
+      throw new Error(`Failed to get Credentials: ${err}`, {
+        cause: err
+      });
+    }
+    return this._credentials;
+  }
+  async getCredentials() {
+    if (this._credentials && !this.isAboutToExpire()) {
+      return this._credentials;
+    }
+    this._credentials = await this.refreshCredentials();
+    return this._credentials;
+  }
+  isAboutToExpire() {
+    const expiresAt = new Date(this.accessExpiresAt);
+    const provisionalExpiry = new Date(Date.now() + 1000 * 10); // check before 10 seconds.
+    return provisionalExpiry > expiresAt;
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+exports.AssumeRoleProvider = AssumeRoleProvider;
+var _default = AssumeRoleProvider;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/CredentialProvider.d.ts

@@ -0,0 +1,22 @@
+import { Credentials } from "./Credentials.js";
+export declare class CredentialProvider {
+  private credentials;
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }: {
+    accessKey: string;
+    secretKey: string;
+    sessionToken?: string;
+  });
+  getCredentials(): Promise<Credentials>;
+  setCredentials(credentials: Credentials): void;
+  setAccessKey(accessKey: string): void;
+  getAccessKey(): string;
+  setSecretKey(secretKey: string): void;
+  getSecretKey(): string;
+  setSessionToken(sessionToken: string): void;
+  getSessionToken(): string | undefined;
+}
+export default CredentialProvider;

SerpentRace_Backend/node_modules/minio/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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

SerpentRace_Backend/node_modules/minio/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;

SerpentRace_Backend/node_modules/minio/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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

SerpentRace_Backend/node_modules/minio/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;

SerpentRace_Backend/node_modules/minio/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,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
Line truncated

SerpentRace_Backend/node_modules/minio/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 {};

SerpentRace_Backend/node_modules/minio/dist/main/errors.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, 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,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/helpers.d.ts

@@ -0,0 +1,156 @@
+import type { Encryption, ObjectMetaData, RequestHeaders } from "./internal/type.js";
+import { RETENTION_MODES } from "./internal/type.js";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.js";
+export declare const DEFAULT_REGION = "us-east-1";
+export declare const PRESIGN_EXPIRY_DAYS_MAX: number;
+export interface ICopySourceOptions {
+  Bucket: string;
+  Object: string;
+  /**
+   * Valid versionId
+   */
+  VersionID?: string;
+  /**
+   * Etag to match
+   */
+  MatchETag?: string;
+  /**
+   * Etag to exclude
+   */
+  NoMatchETag?: string;
+  /**
+   * Modified Date of the object/part.  UTC Date in string format
+   */
+  MatchModifiedSince?: string | null;
+  /**
+   * Modified Date of the object/part to exclude UTC Date in string format
+   */
+  MatchUnmodifiedSince?: string | null;
+  /**
+   * true or false Object range to match
+   */
+  MatchRange?: boolean;
+  Start?: number;
+  End?: number;
+  Encryption?: Encryption;
+}
+export declare class CopySourceOptions {
+  readonly Bucket: string;
+  readonly Object: string;
+  readonly VersionID: string;
+  MatchETag: string;
+  private readonly NoMatchETag;
+  private readonly MatchModifiedSince;
+  private readonly MatchUnmodifiedSince;
+  readonly MatchRange: boolean;
+  readonly Start: number;
+  readonly End: number;
+  private readonly Encryption?;
+  constructor({
+    Bucket,
+    Object,
+    VersionID,
+    MatchETag,
+    NoMatchETag,
+    MatchModifiedSince,
+    MatchUnmodifiedSince,
+    MatchRange,
+    Start,
+    End,
+    Encryption
+  }: ICopySourceOptions);
+  validate(): boolean;
+  getHeaders(): RequestHeaders;
+}
+/**
+ * @deprecated use nodejs fs module
+ */
+export declare function removeDirAndFiles(dirPath: string, removeSelf?: boolean): void;
+export interface ICopyDestinationOptions {
+  /**
+   * Bucket name
+   */
+  Bucket: string;
+  /**
+   * Object Name for the destination (composed/copied) object defaults
+   */
+  Object: string;
+  /**
+   * Encryption configuration defaults to {}
+   * @default {}
+   */
+  Encryption?: Encryption;
+  UserMetadata?: ObjectMetaData;
+  /**
+   * query-string encoded string or Record<string, string> Object
+   */
+  UserTags?: Record<string, string> | string;
+  LegalHold?: 'on' | 'off';
+  /**
+   * UTC Date String
+   */
+  RetainUntilDate?: string;
+  Mode?: RETENTION_MODES;
+  MetadataDirective?: 'COPY' | 'REPLACE';
+  /**
+   * Extra headers for the target object
+   */
+  Headers?: Record<string, string>;
+}
+export declare class CopyDestinationOptions {
+  readonly Bucket: string;
+  readonly Object: string;
+  private readonly Encryption?;
+  private readonly UserMetadata?;
+  private readonly UserTags?;
+  private readonly LegalHold?;
+  private readonly RetainUntilDate?;
+  private readonly Mode?;
+  private readonly MetadataDirective?;
+  private readonly Headers?;
+  constructor({
+    Bucket,
+    Object,
+    Encryption,
+    UserMetadata,
+    UserTags,
+    LegalHold,
+    RetainUntilDate,
+    Mode,
+    MetadataDirective,
+    Headers
+  }: ICopyDestinationOptions);
+  getHeaders(): RequestHeaders;
+  validate(): boolean;
+}
+/**
+ * maybe this should be a generic type for Records, leave it for later refactor
+ */
+export declare class SelectResults {
+  private records?;
+  private response?;
+  private stats?;
+  private progress?;
+  constructor({
+    records,
+    // parsed data as stream
+    response,
+    // original response stream
+    stats,
+    // stats as xml
+    progress
+  }: {
+    records?: unknown;
+    response?: unknown;
+    stats?: string;
+    progress?: unknown;
+  });
+  setStats(stats: string): void;
+  getStats(): string | undefined;
+  setProgress(progress: unknown): void;
+  getProgress(): unknown;
+  setResponse(response: unknown): void;
+  getResponse(): unknown;
+  setRecords(records: unknown): void;
+  getRecords(): unknown;
+}

SerpentRace_Backend/node_modules/minio/dist/main/helpers.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeDirAndFiles = removeDirAndFiles;
+var fs = _interopRequireWildcard(require("fs"), true);
+var path = _interopRequireWildcard(require("path"), true);
+var querystring = _interopRequireWildcard(require("query-string"), true);
+var errors = _interopRequireWildcard(require("./errors.js"), true);
+var _helper = require("./internal/helper.js");
+var _type = require("./internal/type.js");
+exports.RETENTION_MODES = _type.RETENTION_MODES;
+exports.ENCRYPTION_TYPES = _type.ENCRYPTION_TYPES;
+exports.LEGAL_HOLD_STATUS = _type.LEGAL_HOLD_STATUS;
+exports.RETENTION_VALIDITY_UNITS = _type.RETENTION_VALIDITY_UNITS;
+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; }
+const DEFAULT_REGION = 'us-east-1';
+exports.DEFAULT_REGION = DEFAULT_REGION;
+const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7; // 7 days in seconds
+exports.PRESIGN_EXPIRY_DAYS_MAX = PRESIGN_EXPIRY_DAYS_MAX;
+class CopySourceOptions {
+  constructor({
+    Bucket,
+    Object,
+    VersionID = '',
+    MatchETag = '',
+    NoMatchETag = '',
+    MatchModifiedSince = null,
+    MatchUnmodifiedSince = null,
+    MatchRange = false,
+    Start = 0,
+    End = 0,
+    Encryption = undefined
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.VersionID = VersionID;
+    this.MatchETag = MatchETag;
+    this.NoMatchETag = NoMatchETag;
+    this.MatchModifiedSince = MatchModifiedSince;
+    this.MatchUnmodifiedSince = MatchUnmodifiedSince;
+    this.MatchRange = MatchRange;
+    this.Start = Start;
+    this.End = End;
+    this.Encryption = Encryption;
+  }
+  validate() {
+    if (!(0, _helper.isValidBucketName)(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket);
+    }
+    if (!(0, _helper.isValidObjectName)(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Source object name: ${this.Object}`);
+    }
+    if (this.MatchRange && this.Start !== -1 && this.End !== -1 && this.Start > this.End || this.Start < 0) {
+      throw new errors.InvalidObjectNameError('Source start must be non-negative, and start must be at most end.');
+    } else if (this.MatchRange && !(0, _helper.isNumber)(this.Start) || !(0, _helper.isNumber)(this.End)) {
+      throw new errors.InvalidObjectNameError('MatchRange is specified. But Invalid Start and End values are specified.');
+    }
+    return true;
+  }
+  getHeaders() {
+    const headerOptions = {};
+    headerOptions['x-amz-copy-source'] = encodeURI(this.Bucket + '/' + this.Object);
+    if (!(0, _helper.isEmpty)(this.VersionID)) {
+      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchETag)) {
+      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag;
+    }
+    if (!(0, _helper.isEmpty)(this.NoMatchETag)) {
+      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchModifiedSince)) {
+      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchUnmodifiedSince)) {
+      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince;
+    }
+    return headerOptions;
+  }
+}
+
+/**
+ * @deprecated use nodejs fs module
+ */
+exports.CopySourceOptions = CopySourceOptions;
+function removeDirAndFiles(dirPath, removeSelf = true) {
+  if (removeSelf) {
+    return fs.rmSync(dirPath, {
+      recursive: true,
+      force: true
+    });
+  }
+  fs.readdirSync(dirPath).forEach(item => {
+    fs.rmSync(path.join(dirPath, item), {
+      recursive: true,
+      force: true
+    });
+  });
+}
+class CopyDestinationOptions {
+  constructor({
+    Bucket,
+    Object,
+    Encryption,
+    UserMetadata,
+    UserTags,
+    LegalHold,
+    RetainUntilDate,
+    Mode,
+    MetadataDirective,
+    Headers
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.Encryption = Encryption ?? undefined; // null input will become undefined, easy for runtime assert
+    this.UserMetadata = UserMetadata;
+    this.UserTags = UserTags;
+    this.LegalHold = LegalHold;
+    this.Mode = Mode; // retention mode
+    this.RetainUntilDate = RetainUntilDate;
+    this.MetadataDirective = MetadataDirective;
+    this.Headers = Headers;
+  }
+  getHeaders() {
+    const replaceDirective = 'REPLACE';
+    const headerOptions = {};
+    const userTags = this.UserTags;
+    if (!(0, _helper.isEmpty)(userTags)) {
+      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective;
+      headerOptions['X-Amz-Tagging'] = (0, _helper.isObject)(userTags) ? querystring.stringify(userTags) : (0, _helper.isString)(userTags) ? userTags : '';
+    }
+    if (this.Mode) {
+      headerOptions['X-Amz-Object-Lock-Mode'] = this.Mode; // GOVERNANCE or COMPLIANCE
+    }
+
+    if (this.RetainUntilDate) {
+      headerOptions['X-Amz-Object-Lock-Retain-Until-Date'] = this.RetainUntilDate; // needs to be UTC.
+    }
+
+    if (this.LegalHold) {
+      headerOptions['X-Amz-Object-Lock-Legal-Hold'] = this.LegalHold; // ON or OFF
+    }
+
+    if (this.UserMetadata) {
+      for (const [key, value] of Object.entries(this.UserMetadata)) {
+        headerOptions[`X-Amz-Meta-${key}`] = value.toString();
+      }
+    }
+    if (this.MetadataDirective) {
+      headerOptions[`X-Amz-Metadata-Directive`] = this.MetadataDirective;
+    }
+    if (this.Encryption) {
+      const encryptionHeaders = (0, _helper.getEncryptionHeaders)(this.Encryption);
+      for (const [key, value] of Object.entries(encryptionHeaders)) {
+        headerOptions[key] = value;
+      }
+    }
+    if (this.Headers) {
+      for (const [key, value] of Object.entries(this.Headers)) {
+        headerOptions[key] = value;
+      }
+    }
+    return headerOptions;
+  }
+  validate() {
+    if (!(0, _helper.isValidBucketName)(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket);
+    }
+    if (!(0, _helper.isValidObjectName)(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`);
+    }
+    if (!(0, _helper.isEmpty)(this.UserMetadata) && !(0, _helper.isObject)(this.UserMetadata)) {
+      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`);
+    }
+    if (!(0, _helper.isEmpty)(this.Mode) && ![_type.RETENTION_MODES.GOVERNANCE, _type.RETENTION_MODES.COMPLIANCE].includes(this.Mode)) {
+      throw new errors.InvalidObjectNameError(`Invalid Mode specified for destination object it should be one of [GOVERNANCE,COMPLIANCE]`);
+    }
+    if (this.Encryption !== undefined && (0, _helper.isEmptyObject)(this.Encryption)) {
+      throw new errors.InvalidObjectNameError(`Invalid Encryption configuration for destination object `);
+    }
+    return true;
+  }
+}
+
+/**
+ * maybe this should be a generic type for Records, leave it for later refactor
+ */
+exports.CopyDestinationOptions = CopyDestinationOptions;
+class SelectResults {
+  constructor({
+    records,
+    // parsed data as stream
+    response,
+    // original response stream
+    stats,
+    // stats as xml
+    progress // stats as xml
+  }) {
+    this.records = records;
+    this.response = response;
+    this.stats = stats;
+    this.progress = progress;
+  }
+  setStats(stats) {
+    this.stats = stats;
+  }
+  getStats() {
+    return this.stats;
+  }
+  setProgress(progress) {
+    this.progress = progress;
+  }
+  getProgress() {
+    return this.progress;
+  }
+  setResponse(response) {
+    this.response = response;
+  }
+  getResponse() {
+    return this.response;
+  }
+  setRecords(records) {
+    this.records = records;
+  }
+  getRecords() {
+    return this.records;
+  }
+}
+exports.SelectResults = SelectResults;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/async.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as fs from 'node:fs';
+import * as stream from 'node:stream';
+export { promises as fsp } from 'node:fs';
+export declare const streamPromise: {
+  pipeline: typeof stream.pipeline.__promisify__;
+};
+export declare const fstat: typeof fs.fstat.__promisify__;

SerpentRace_Backend/node_modules/minio/dist/main/internal/async.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var fs = _interopRequireWildcard(require("fs"), true);
+var stream = _interopRequireWildcard(require("stream"), true);
+var _util = require("util");
+var _nodeFs = require("fs");
+exports.fsp = _nodeFs.promises;
+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; }
+// promise helper for stdlib
+
+// TODO: use "node:fs/promise" directly after we stop testing on nodejs 12
+
+const streamPromise = {
+  // node:stream/promises Added in: v15.0.0
+  pipeline: (0, _util.promisify)(stream.pipeline)
+};
+exports.streamPromise = streamPromise;
+const fstat = (0, _util.promisify)(fs.fstat);
+exports.fstat = fstat;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/main/internal/callbackify.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.callbackify = callbackify;
+// wrapper an async function that support callback style API.
+// It will preserve 'this'.
+function callbackify(fn) {
+  return function () {
+    const args = [...arguments];
+    const callback = args.pop();
+
+    // If the last argument is a function, assume it's the callback.
+    if (typeof callback === 'function') {
+      return fn.apply(this, args).then(result => callback(null, result), err => callback(err));
+    }
+    return fn.apply(this, arguments);
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImFyZ3VtZW50cyIsImNhbGxiYWNrIiwicG9wIiwiYXBwbHkiLCJ0aGVuIiwicmVzdWx0IiwiZXJyIl0sInNvdXJjZXMiOlsiY2FsbGJhY2tpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gd3JhcHBlciBhbiBhc3luYyBmdW5jdGlvbiB0aGF0IHN1cHBvcnQgY2FsbGJhY2sgc3R5bGUgQVBJLlxuLy8gSXQgd2lsbCBwcmVzZXJ2ZSAndGhpcycuXG5leHBvcnQgZnVuY3Rpb24gY2FsbGJhY2tpZnkoZm4pIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICgpIHtcbiAgICBjb25zdCBhcmdzID0gWy4uLmFyZ3VtZW50c11cbiAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcblxuICAgIC8vIElmIHRoZSBsYXN0IGFyZ3VtZW50IGlzIGEgZnVuY3Rpb24sIGFzc3VtZSBpdCdzIHRoZSBjYWxsYmFjay5cbiAgICBpZiAodHlwZW9mIGNhbGxiYWNrID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncykudGhlbihcbiAgICAgICAgKHJlc3VsdCkgPT4gY2FsbGJhY2sobnVsbCwgcmVzdWx0KSxcbiAgICAgICAgKGVycikgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJndW1lbnRzKVxuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7QUFDTyxTQUFTQSxXQUFXQSxDQUFDQyxFQUFFLEVBQUU7RUFDOUIsT0FBTyxZQUFZO0lBQ2pCLE1BQU1DLElBQUksR0FBRyxDQUFDLEdBQUdDLFNBQVMsQ0FBQztJQUMzQixNQUFNQyxRQUFRLEdBQUdGLElBQUksQ0FBQ0csR0FBRyxDQUFDLENBQUM7O0lBRTNCO0lBQ0EsSUFBSSxPQUFPRCxRQUFRLEtBQUssVUFBVSxFQUFFO01BQ2xDLE9BQU9ILEVBQUUsQ0FBQ0ssS0FBSyxDQUFDLElBQUksRUFBRUosSUFBSSxDQUFDLENBQUNLLElBQUksQ0FDN0JDLE1BQU0sSUFBS0osUUFBUSxDQUFDLElBQUksRUFBRUksTUFBTSxDQUFDLEVBQ2pDQyxHQUFHLElBQUtMLFFBQVEsQ0FBQ0ssR0FBRyxDQUN2QixDQUFDO0lBQ0g7SUFFQSxPQUFPUixFQUFFLENBQUNLLEtBQUssQ0FBQyxJQUFJLEVBQUVILFNBQVMsQ0FBQztFQUNsQyxDQUFDO0FBQ0gifQ==

SerpentRace_Backend/node_modules/minio/dist/main/internal/client.d.ts

@@ -0,0 +1,359 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'node:http';
+import * as https from 'node:https';
+import * as stream from 'node:stream';
+import { CredentialProvider } from "../CredentialProvider.js";
+import type { SelectResults } from "../helpers.js";
+import { CopyDestinationOptions, CopySourceOptions, LEGAL_HOLD_STATUS } from "../helpers.js";
+import type { PostPolicyResult } from "../minio.js";
+import { CopyConditions } from "./copy-conditions.js";
+import { Extensions } from "./extensions.js";
+import { PostPolicy } from "./post-policy.js";
+import type { Region } from "./s3-endpoints.js";
+import type { Binary, BucketItemFromList, BucketItemStat, BucketStream, BucketVersioningConfiguration, CopyObjectResult, EncryptionConfig, GetObjectLegalHoldOptions, GetObjectOpts, GetObjectRetentionOpts, IncompleteUploadedBucketItem, IRequest, ItemBucketMetadata, LifecycleConfig, LifeCycleConfigParam, ListObjectQueryOpts, ObjectInfo, ObjectLockInfo, ObjectMetaData, ObjectRetentionInfo, PreSignRequestParams, PutObjectLegalHoldOptions, RemoveObjectsParam, RemoveObjectsResponse, ReplicationConfig, ReplicationConfigOpts, RequestHeaders, ResultCallback, Retention, SelectOptions, StatObjectOpts, Tag, TaggingOpts, Tags, Transport, UploadedObjectInfo } from "./type.js";
+import type { ListMultipartResult, UploadedPart } from "./xml-parser.js";
+declare const requestOptionProperties: readonly ["agent", "ca", "cert", "ciphers", "clientCertEngine", "crl", "dhparam", "ecdhCurve", "family", "honorCipherOrder", "key", "passphrase", "pfx", "rejectUnauthorized", "secureOptions", "secureProtocol", "servername", "sessionIdContext"];
+export interface ClientOptions {
+  endPoint: string;
+  accessKey?: string;
+  secretKey?: string;
+  useSSL?: boolean;
+  port?: number;
+  region?: Region;
+  transport?: Transport;
+  sessionToken?: string;
+  partSize?: number;
+  pathStyle?: boolean;
+  credentialsProvider?: CredentialProvider;
+  s3AccelerateEndpoint?: string;
+  transportAgent?: http.Agent;
+}
+export type RequestOption = Partial<IRequest> & {
+  method: string;
+  bucketName?: string;
+  objectName?: string;
+  query?: string;
+  pathStyle?: boolean;
+};
+export type NoResultCallback = (error: unknown) => void;
+export interface MakeBucketOpt {
+  ObjectLocking?: boolean;
+}
+export interface RemoveOptions {
+  versionId?: string;
+  governanceBypass?: boolean;
+  forceDelete?: boolean;
+}
+export declare class TypedClient {
+  protected transport: Transport;
+  protected host: string;
+  protected port: number;
+  protected protocol: string;
+  protected accessKey: string;
+  protected secretKey: string;
+  protected sessionToken?: string;
+  protected userAgent: string;
+  protected anonymous: boolean;
+  protected pathStyle: boolean;
+  protected regionMap: Record<string, string>;
+  region?: string;
+  protected credentialsProvider?: CredentialProvider;
+  partSize: number;
+  protected overRidePartSize?: boolean;
+  protected maximumPartSize: number;
+  protected maxObjectSize: number;
+  enableSHA256: boolean;
+  protected s3AccelerateEndpoint?: string;
+  protected reqOptions: Record<string, unknown>;
+  protected transportAgent: http.Agent;
+  private readonly clientExtensions;
+  constructor(params: ClientOptions);
+  /**
+   * Minio extensions that aren't necessary present for Amazon S3 compatible storage servers
+   */
+  get extensions(): Extensions;
+  /**
+   * @param endPoint - valid S3 acceleration end point
+   */
+  setS3TransferAccelerate(endPoint: string): void;
+  /**
+   * Sets the supported request options.
+   */
+  setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>): void;
+  /**
+   *  This is s3 Specific and does not hold validity in any other Object storage.
+   */
+  private getAccelerateEndPointIfSet;
+  /**
+   *   Set application specific information.
+   *   Generates User-Agent in the following style.
+   *   MinIO (OS; ARCH) LIB/VER APP/VER
+   */
+  setAppInfo(appName: string, appVersion: string): void;
+  /**
+   * returns options object that can be used with http.request()
+   * Takes care of constructing virtual-host-style or path-style hostname
+   */
+  protected getRequestOptions(opts: RequestOption & {
+    region: string;
+  }): IRequest & {
+    host: string;
+    headers: Record<string, string>;
+  };
+  setCredentialsProvider(credentialsProvider: CredentialProvider): Promise<void>;
+  private checkAndRefreshCreds;
+  private logStream?;
+  /**
+   * log the request, response, error
+   */
+  private logHTTP;
+  /**
+   * Enable tracing
+   */
+  traceOn(stream?: stream.Writable): void;
+  /**
+   * Disable tracing
+   */
+  traceOff(): void;
+  /**
+   * makeRequest is the primitive used by the apis for making S3 requests.
+   * payload can be empty string in case of no payload.
+   * statusCode is the expected statusCode. If response.statusCode does not match
+   * we parse the XML error and call the callback with the error message.
+   *
+   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.
+   *
+   * @internal
+   */
+  makeRequestAsync(options: RequestOption, payload?: Binary, expectedCodes?: number[], region?: string): Promise<http.IncomingMessage>;
+  /**
+   * new request with promise
+   *
+   * No need to drain response, response body is not valid
+   */
+  makeRequestAsyncOmit(options: RequestOption, payload?: Binary, statusCodes?: number[], region?: string): Promise<Omit<http.IncomingMessage, 'on'>>;
+  /**
+   * makeRequestStream will be used directly instead of makeRequest in case the payload
+   * is available as a stream. for ex. putObject
+   *
+   * @internal
+   */
+  makeRequestStreamAsync(options: RequestOption, body: stream.Readable | Binary, sha256sum: string, statusCodes: number[], region: string): Promise<http.IncomingMessage>;
+  /**
+   * gets the region of the bucket
+   *
+   * @param bucketName
+   *
+   * @internal
+   */
+  protected getBucketRegionAsync(bucketName: string): Promise<string>;
+  /**
+   * makeRequest is the primitive used by the apis for making S3 requests.
+   * payload can be empty string in case of no payload.
+   * statusCode is the expected statusCode. If response.statusCode does not match
+   * we parse the XML error and call the callback with the error message.
+   * A valid region is passed by the calls - listBuckets, makeBucket and
+   * getBucketRegion.
+   *
+   * @deprecated use `makeRequestAsync` instead
+   */
+  makeRequest(options: RequestOption, payload: Binary | undefined, expectedCodes: number[] | undefined, region: string | undefined, returnResponse: boolean, cb: (cb: unknown, result: http.IncomingMessage) => void): void;
+  /**
+   * makeRequestStream will be used directly instead of makeRequest in case the payload
+   * is available as a stream. for ex. putObject
+   *
+   * @deprecated use `makeRequestStreamAsync` instead
+   */
+  makeRequestStream(options: RequestOption, stream: stream.Readable | Buffer, sha256sum: string, statusCodes: number[], region: string, returnResponse: boolean, cb: (cb: unknown, result: http.IncomingMessage) => void): void;
+  /**
+   * @deprecated use `getBucketRegionAsync` instead
+   */
+  getBucketRegion(bucketName: string, cb: (err: unknown, region: string) => void): Promise<void>;
+  /**
+   * Creates the bucket `bucketName`.
+   *
+   */
+  makeBucket(bucketName: string, region?: Region, makeOpts?: MakeBucketOpt): Promise<void>;
+  /**
+   * To check if a bucket already exists.
+   */
+  bucketExists(bucketName: string): Promise<boolean>;
+  removeBucket(bucketName: string): Promise<void>;
+  /**
+   * @deprecated use promise style API
+   */
+  removeBucket(bucketName: string, callback: NoResultCallback): void;
+  /**
+   * Callback is called with readable stream of the object content.
+   */
+  getObject(bucketName: string, objectName: string, getOpts?: GetObjectOpts): Promise<stream.Readable>;
+  /**
+   * Callback is called with readable stream of the partial object content.
+   * @param bucketName
+   * @param objectName
+   * @param offset
+   * @param length - length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)
+   * @param getOpts
+   */
+  getPartialObject(bucketName: string, objectName: string, offset: number, length?: number, getOpts?: GetObjectOpts): Promise<stream.Readable>;
+  /**
+   * download object content to a file.
+   * This method will create a temp file named `${filename}.${base64(etag)}.part.minio` when downloading.
+   *
+   * @param bucketName - name of the bucket
+   * @param objectName - name of the object
+   * @param filePath - path to which the object data will be written to
+   * @param getOpts - Optional object get option
+   */
+  fGetObject(bucketName: string, objectName: string, filePath: string, getOpts?: GetObjectOpts): Promise<void>;
+  /**
+   * Stat information of the object.
+   */
+  statObject(bucketName: string, objectName: string, statOpts?: StatObjectOpts): Promise<BucketItemStat>;
+  removeObject(bucketName: string, objectName: string, removeOpts?: RemoveOptions): Promise<void>;
+  listIncompleteUploads(bucket: string, prefix: string, recursive: boolean): BucketStream<IncompleteUploadedBucketItem>;
+  /**
+   * Called by listIncompleteUploads to fetch a batch of incomplete uploads.
+   */
+  listIncompleteUploadsQuery(bucketName: string, prefix: string, keyMarker: string, uploadIdMarker: string, delimiter: string): Promise<ListMultipartResult>;
+  /**
+   * Initiate a new multipart upload.
+   * @internal
+   */
+  initiateNewMultipartUpload(bucketName: string, objectName: string, headers: RequestHeaders): Promise<string>;
+  /**
+   * Internal Method to abort a multipart upload request in case of any errors.
+   *
+   * @param bucketName - Bucket Name
+   * @param objectName - Object Name
+   * @param uploadId - id of a multipart upload to cancel during compose object sequence.
+   */
+  abortMultipartUpload(bucketName: string, objectName: string, uploadId: string): Promise<void>;
+  findUploadId(bucketName: string, objectName: string): Promise<string | undefined>;
+  /**
+   * this call will aggregate the parts on the server into a single object.
+   */
+  completeMultipartUpload(bucketName: string, objectName: string, uploadId: string, etags: {
+    part: number;
+    etag?: string;
+  }[]): Promise<{
+    etag: string;
+    versionId: string | null;
+  }>;
+  /**
+   * Get part-info of all parts of an incomplete upload specified by uploadId.
+   */
+  protected listParts(bucketName: string, objectName: string, uploadId: string): Promise<UploadedPart[]>;
+  /**
+   * Called by listParts to fetch a batch of part-info
+   */
+  private listPartsQuery;
+  listBuckets(): Promise<BucketItemFromList[]>;
+  /**
+   * Calculate part size given the object size. Part size will be atleast this.partSize
+   */
+  calculatePartSize(size: number): number;
+  /**
+   * Uploads the object using contents from a file
+   */
+  fPutObject(bucketName: string, objectName: string, filePath: string, metaData?: ObjectMetaData): Promise<UploadedObjectInfo>;
+  /**
+   *  Uploading a stream, "Buffer" or "string".
+   *  It's recommended to pass `size` argument with stream.
+   */
+  putObject(bucketName: string, objectName: string, stream: stream.Readable | Buffer | string, size?: number, metaData?: ItemBucketMetadata): Promise<UploadedObjectInfo>;
+  /**
+   * method to upload buffer in one call
+   * @private
+   */
+  private uploadBuffer;
+  /**
+   * upload stream with MultipartUpload
+   * @private
+   */
+  private uploadStream;
+  removeBucketReplication(bucketName: string): Promise<void>;
+  removeBucketReplication(bucketName: string, callback: NoResultCallback): void;
+  setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): void;
+  setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): Promise<void>;
+  getBucketReplication(bucketName: string): void;
+  getBucketReplication(bucketName: string): Promise<ReplicationConfig>;
+  getObjectLegalHold(bucketName: string, objectName: string, getOpts?: GetObjectLegalHoldOptions, callback?: ResultCallback<LEGAL_HOLD_STATUS>): Promise<LEGAL_HOLD_STATUS>;
+  setObjectLegalHold(bucketName: string, objectName: string, setOpts?: PutObjectLegalHoldOptions): void;
+  /**
+   * Get Tags associated with a Bucket
+   */
+  getBucketTagging(bucketName: string): Promise<Tag[]>;
+  /**
+   *  Get the tags associated with a bucket OR an object
+   */
+  getObjectTagging(bucketName: string, objectName: string, getOpts?: GetObjectOpts): Promise<Tag[]>;
+  /**
+   *  Set the policy on a bucket or an object prefix.
+   */
+  setBucketPolicy(bucketName: string, policy: string): Promise<void>;
+  /**
+   * Get the policy on a bucket or an object prefix.
+   */
+  getBucketPolicy(bucketName: string): Promise<string>;
+  putObjectRetention(bucketName: string, objectName: string, retentionOpts?: Retention): Promise<void>;
+  getObjectLockConfig(bucketName: string, callback: ResultCallback<ObjectLockInfo>): void;
+  getObjectLockConfig(bucketName: string): void;
+  getObjectLockConfig(bucketName: string): Promise<ObjectLockInfo>;
+  setObjectLockConfig(bucketName: string, lockConfigOpts: Omit<ObjectLockInfo, 'objectLockEnabled'>): void;
+  setObjectLockConfig(bucketName: string, lockConfigOpts: Omit<ObjectLockInfo, 'objectLockEnabled'>): Promise<void>;
+  getBucketVersioning(bucketName: string): Promise<BucketVersioningConfiguration>;
+  setBucketVersioning(bucketName: string, versionConfig: BucketVersioningConfiguration): Promise<void>;
+  private setTagging;
+  private removeTagging;
+  setBucketTagging(bucketName: string, tags: Tags): Promise<void>;
+  removeBucketTagging(bucketName: string): Promise<void>;
+  setObjectTagging(bucketName: string, objectName: string, tags: Tags, putOpts?: TaggingOpts): Promise<void>;
+  removeObjectTagging(bucketName: string, objectName: string, removeOpts: TaggingOpts): Promise<void>;
+  selectObjectContent(bucketName: string, objectName: string, selectOpts: SelectOptions): Promise<SelectResults | undefined>;
+  private applyBucketLifecycle;
+  removeBucketLifecycle(bucketName: string): Promise<void>;
+  setBucketLifecycle(bucketName: string, lifeCycleConfig: LifeCycleConfigParam): Promise<void>;
+  getBucketLifecycle(bucketName: string): Promise<LifecycleConfig | null>;
+  setBucketEncryption(bucketName: string, encryptionConfig?: EncryptionConfig): Promise<void>;
+  getBucketEncryption(bucketName: string): Promise<any>;
+  removeBucketEncryption(bucketName: string): Promise<void>;
+  getObjectRetention(bucketName: string, objectName: string, getOpts?: GetObjectRetentionOpts): Promise<ObjectRetentionInfo | null | undefined>;
+  removeObjects(bucketName: string, objectsList: RemoveObjectsParam): Promise<RemoveObjectsResponse[]>;
+  removeIncompleteUpload(bucketName: string, objectName: string): Promise<void>;
+  private copyObjectV1;
+  private copyObjectV2;
+  copyObject(source: CopySourceOptions, dest: CopyDestinationOptions): Promise<CopyObjectResult>;
+  copyObject(targetBucketName: string, targetObjectName: string, sourceBucketNameAndObjectName: string, conditions?: CopyConditions): Promise<CopyObjectResult>;
+  uploadPart(partConfig: {
+    bucketName: string;
+    objectName: string;
+    uploadID: string;
+    partNumber: number;
+    headers: RequestHeaders;
+  }, payload?: Binary): Promise<{
+    etag: string;
+    key: string;
+    part: number;
+  }>;
+  composeObject(destObjConfig: CopyDestinationOptions, sourceObjList: CopySourceOptions[]): Promise<boolean | {
+    etag: string;
+    versionId: string | null;
+  } | Promise<void> | CopyObjectResult>;
+  presignedUrl(method: string, bucketName: string, objectName: string, expires?: number | PreSignRequestParams | undefined, reqParams?: PreSignRequestParams | Date, requestDate?: Date): Promise<string>;
+  presignedGetObject(bucketName: string, objectName: string, expires?: number, respHeaders?: PreSignRequestParams | Date, requestDate?: Date): Promise<string>;
+  presignedPutObject(bucketName: string, objectName: string, expires?: number): Promise<string>;
+  newPostPolicy(): PostPolicy;
+  presignedPostPolicy(postPolicy: PostPolicy): Promise<PostPolicyResult>;
+  listObjectsQuery(bucketName: string, prefix?: string, marker?: string, listQueryOpts?: ListObjectQueryOpts): Promise<{
+    objects: ObjectInfo[];
+    isTruncated?: boolean | undefined;
+    nextMarker?: string | undefined;
+    versionIdMarker?: string | undefined;
+  }>;
+  listObjects(bucketName: string, prefix?: string, recursive?: boolean, listOpts?: ListObjectQueryOpts | undefined): BucketStream<ObjectInfo>;
+}
+export {};

SerpentRace_Backend/node_modules/minio/dist/main/internal/copy-conditions.d.ts

@@ -0,0 +1,10 @@
+export declare class CopyConditions {
+  modified: string;
+  unmodified: string;
+  matchETag: string;
+  matchETagExcept: string;
+  setModified(date: Date): void;
+  setUnmodified(date: Date): void;
+  setMatchETag(etag: string): void;
+  setMatchETagExcept(etag: string): void;
+}

SerpentRace_Backend/node_modules/minio/dist/main/internal/copy-conditions.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+class CopyConditions {
+  modified = '';
+  unmodified = '';
+  matchETag = '';
+  matchETagExcept = '';
+  setModified(date) {
+    if (!(date instanceof Date)) {
+      throw new TypeError('date must be of type Date');
+    }
+    this.modified = date.toUTCString();
+  }
+  setUnmodified(date) {
+    if (!(date instanceof Date)) {
+      throw new TypeError('date must be of type Date');
+    }
+    this.unmodified = date.toUTCString();
+  }
+  setMatchETag(etag) {
+    this.matchETag = etag;
+  }
+  setMatchETagExcept(etag) {
+    this.matchETagExcept = etag;
+  }
+}
+exports.CopyConditions = CopyConditions;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/main/internal/extensions.d.ts

@@ -0,0 +1,18 @@
+import type { TypedClient } from "./client.js";
+import type { BucketItemWithMetadata, BucketStream } from "./type.js";
+export declare class Extensions {
+  private readonly client;
+  constructor(client: TypedClient);
+  /**
+   * List the objects in the bucket using S3 ListObjects V2 With Metadata
+   *
+   * @param bucketName - name of the bucket
+   * @param prefix - the prefix of the objects that should be listed (optional, default `''`)
+   * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)
+   * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`)
+   * @returns stream emitting the objects in the bucket, the object is of the format:
+   */
+  listObjectsV2WithMetadata(bucketName: string, prefix?: string, recursive?: boolean, startAfter?: string): BucketStream<BucketItemWithMetadata>;
+  private listObjectsV2WithMetadataGen;
+  private listObjectsV2WithMetadataQuery;
+}

SerpentRace_Backend/node_modules/minio/dist/main/internal/extensions.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var stream = _interopRequireWildcard(require("stream"), true);
+var errors = _interopRequireWildcard(require("../errors.js"), true);
+var _helper = require("./helper.js");
+var _response = require("./response.js");
+var _xmlParser = require("./xml-parser.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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, 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.
+ */
+
+class Extensions {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /**
+   * List the objects in the bucket using S3 ListObjects V2 With Metadata
+   *
+   * @param bucketName - name of the bucket
+   * @param prefix - the prefix of the objects that should be listed (optional, default `''`)
+   * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)
+   * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`)
+   * @returns stream emitting the objects in the bucket, the object is of the format:
+   */
+  listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) {
+    if (prefix === undefined) {
+      prefix = '';
+    }
+    if (recursive === undefined) {
+      recursive = false;
+    }
+    if (startAfter === undefined) {
+      startAfter = '';
+    }
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isBoolean)(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (!(0, _helper.isString)(startAfter)) {
+      throw new TypeError('startAfter should be of type "string"');
+    }
+
+    // if recursive is false set delimiter to '/'
+    const delimiter = recursive ? '' : '/';
+    return stream.Readable.from(this.listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter), {
+      objectMode: true
+    });
+  }
+  async *listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter) {
+    let ended = false;
+    let continuationToken = '';
+    do {
+      const result = await this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter);
+      ended = !result.isTruncated;
+      continuationToken = result.nextContinuationToken;
+      for (const obj of result.objects) {
+        yield obj;
+      }
+    } while (!ended);
+  }
+  async listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter) {
+    const queries = [];
+
+    // Call for listing objects v2 API
+    queries.push(`list-type=2`);
+    queries.push(`encoding-type=url`);
+    // escape every value in query string, except maxKeys
+    queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`);
+    queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`);
+    queries.push(`metadata=true`);
+    if (continuationToken) {
+      continuationToken = (0, _helper.uriEscape)(continuationToken);
+      queries.push(`continuation-token=${continuationToken}`);
+    }
+    // Set start-after
+    if (startAfter) {
+      startAfter = (0, _helper.uriEscape)(startAfter);
+      queries.push(`start-after=${startAfter}`);
+    }
+    queries.push(`max-keys=1000`);
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const method = 'GET';
+    const res = await this.client.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    return (0, _xmlParser.parseListObjectsV2WithMetadata)(await (0, _response.readAsString)(res));
+  }
+}
+exports.Extensions = Extensions;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/helper.d.ts

@@ -0,0 +1,173 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as stream from 'node:stream';
+import _ from 'lodash';
+import type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from "./type.js";
+export declare function hashBinary(buf: Buffer, enableSHA256: boolean): {
+  md5sum: string;
+  sha256sum: string;
+};
+export declare function uriEscape(uriStr: string): string;
+export declare function uriResourceEscape(string: string): string;
+export declare function getScope(region: string, date: Date, serviceName?: string): string;
+/**
+ * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'
+ */
+export declare function isAmazonEndpoint(endpoint: string): boolean;
+/**
+ * isVirtualHostStyle - verify if bucket name is support with virtual
+ * hosts. bucketNames with periods should be always treated as path
+ * style if the protocol is 'https:', this is due to SSL wildcard
+ * limitation. For all other buckets and Amazon S3 endpoint we will
+ * default to virtual host style.
+ */
+export declare function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean): boolean;
+export declare function isValidIP(ip: string): boolean;
+/**
+ * @returns if endpoint is valid domain.
+ */
+export declare function isValidEndpoint(endpoint: string): boolean;
+/**
+ * @returns if input host is a valid domain.
+ */
+export declare function isValidDomain(host: string): boolean;
+/**
+ * Probes contentType using file extensions.
+ *
+ * @example
+ * ```
+ * // return 'image/png'
+ * probeContentType('file.png')
+ * ```
+ */
+export declare function probeContentType(path: string): string;
+/**
+ * is input port valid.
+ */
+export declare function isValidPort(port: unknown): port is number;
+export declare function isValidBucketName(bucket: unknown): boolean;
+/**
+ * check if objectName is a valid object name
+ */
+export declare function isValidObjectName(objectName: unknown): boolean;
+/**
+ * check if prefix is valid
+ */
+export declare function isValidPrefix(prefix: unknown): prefix is string;
+/**
+ * check if typeof arg number
+ */
+export declare function isNumber(arg: unknown): arg is number;
+export type AnyFunction = (...args: any[]) => any;
+/**
+ * check if typeof arg function
+ */
+export declare function isFunction(arg: unknown): arg is AnyFunction;
+/**
+ * check if typeof arg string
+ */
+export declare function isString(arg: unknown): arg is string;
+/**
+ * check if typeof arg object
+ */
+export declare function isObject(arg: unknown): arg is object;
+/**
+ * check if object is readable stream
+ */
+export declare function isReadableStream(arg: unknown): arg is stream.Readable;
+/**
+ * check if arg is boolean
+ */
+export declare function isBoolean(arg: unknown): arg is boolean;
+export declare function isEmpty(o: unknown): o is null | undefined;
+export declare function isEmptyObject(o: Record<string, unknown>): boolean;
+export declare function isDefined<T>(o: T): o is Exclude<T, null | undefined>;
+/**
+ * check if arg is a valid date
+ */
+export declare function isValidDate(arg: unknown): arg is Date;
+/**
+ * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z
+ */
+export declare function makeDateLong(date?: Date): string;
+/**
+ * Create a Date string with format: 'YYYYMMDD'
+ */
+export declare function makeDateShort(date?: Date): string;
+/**
+ * pipesetup sets up pipe() from left to right os streams array
+ * pipesetup will also make sure that error emitted at any of the upstream Stream
+ * will be emitted at the last stream. This makes error handling simple
+ */
+export declare function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]): stream.Readable | stream.Duplex | stream.Writable;
+/**
+ * return a Readable stream that emits data
+ */
+export declare function readableStream(data: unknown): stream.Readable;
+/**
+ * Process metadata to insert appropriate value to `content-type` attribute
+ */
+export declare function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData;
+/**
+ * Function prepends metadata with the appropriate prefix if it is not already on
+ */
+export declare function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders;
+/**
+ * Checks if it is a valid header according to the AmazonS3 API
+ */
+export declare function isAmzHeader(key: string): boolean;
+/**
+ * Checks if it is a supported Header
+ */
+export declare function isSupportedHeader(key: string): boolean;
+/**
+ * Checks if it is a storage header
+ */
+export declare function isStorageClassHeader(key: string): boolean;
+export declare function extractMetadata(headers: ResponseHeader): _.Dictionary<string>;
+export declare function getVersionId(headers?: ResponseHeader): string | null;
+export declare function getSourceVersionId(headers?: ResponseHeader): string | null;
+export declare function sanitizeETag(etag?: string): string;
+export declare function toMd5(payload: Binary): string;
+export declare function toSha256(payload: Binary): string;
+/**
+ * toArray returns a single element array with param being the element,
+ * if param is just a string, and returns 'param' back if it is an array
+ * So, it makes sure param is always an array
+ */
+export declare function toArray<T = unknown>(param: T | T[]): Array<T>;
+export declare function sanitizeObjectKey(objectName: string): string;
+export declare function sanitizeSize(size?: string): number | undefined;
+export declare const PART_CONSTRAINTS: {
+  ABS_MIN_PART_SIZE: number;
+  MIN_PART_SIZE: number;
+  MAX_PARTS_COUNT: number;
+  MAX_PART_SIZE: number;
+  MAX_SINGLE_PUT_OBJECT_SIZE: number;
+  MAX_MULTIPART_PUT_OBJECT_SIZE: number;
+};
+/**
+ * Return Encryption headers
+ * @param encConfig
+ * @returns an object with key value pairs that can be used in headers.
+ */
+export declare function getEncryptionHeaders(encConfig: Encryption): RequestHeaders;
+export declare function partsRequired(size: number): number;
+/**
+ * calculateEvenSplits - computes splits for a source and returns
+ * start and end index slices. Splits happen evenly to be sure that no
+ * part is less than 5MiB, as that could fail the multipart request if
+ * it is not the last part.
+ */
+export declare function calculateEvenSplits<T extends {
+  Start?: number;
+}>(size: number, objInfo: T): {
+  startIndex: number[];
+  objInfo: T;
+  endIndex: number[];
+} | null;
+export declare function parseXml(xml: string): any;
+/**
+ * get content size of object content to upload
+ */
+export declare function getContentLength(s: stream.Readable | Buffer | string): Promise<number | null>;

SerpentRace_Backend/node_modules/minio/dist/main/internal/helper.js

@@ -0,0 +1,602 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateEvenSplits = calculateEvenSplits;
+exports.extractMetadata = extractMetadata;
+exports.getContentLength = getContentLength;
+exports.getEncryptionHeaders = getEncryptionHeaders;
+exports.getScope = getScope;
+exports.getSourceVersionId = getSourceVersionId;
+exports.getVersionId = getVersionId;
+exports.hashBinary = hashBinary;
+exports.insertContentType = insertContentType;
+exports.isAmazonEndpoint = isAmazonEndpoint;
+exports.isAmzHeader = isAmzHeader;
+exports.isBoolean = isBoolean;
+exports.isDefined = isDefined;
+exports.isEmpty = isEmpty;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isReadableStream = isReadableStream;
+exports.isStorageClassHeader = isStorageClassHeader;
+exports.isString = isString;
+exports.isSupportedHeader = isSupportedHeader;
+exports.isValidBucketName = isValidBucketName;
+exports.isValidDate = isValidDate;
+exports.isValidDomain = isValidDomain;
+exports.isValidEndpoint = isValidEndpoint;
+exports.isValidIP = isValidIP;
+exports.isValidObjectName = isValidObjectName;
+exports.isValidPort = isValidPort;
+exports.isValidPrefix = isValidPrefix;
+exports.isVirtualHostStyle = isVirtualHostStyle;
+exports.makeDateLong = makeDateLong;
+exports.makeDateShort = makeDateShort;
+exports.parseXml = parseXml;
+exports.partsRequired = partsRequired;
+exports.pipesetup = pipesetup;
+exports.prependXAMZMeta = prependXAMZMeta;
+exports.probeContentType = probeContentType;
+exports.readableStream = readableStream;
+exports.sanitizeETag = sanitizeETag;
+exports.sanitizeObjectKey = sanitizeObjectKey;
+exports.sanitizeSize = sanitizeSize;
+exports.toArray = toArray;
+exports.toMd5 = toMd5;
+exports.toSha256 = toSha256;
+exports.uriEscape = uriEscape;
+exports.uriResourceEscape = uriResourceEscape;
+var crypto = _interopRequireWildcard(require("crypto"), true);
+var stream = _interopRequireWildcard(require("stream"), true);
+var _fastXmlParser = require("fast-xml-parser");
+var _ipaddr = require("ipaddr.js");
+var _lodash = require("lodash");
+var mime = _interopRequireWildcard(require("mime-types"), true);
+var _async = require("./async.js");
+var _type = require("./type.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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, 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.
+ */
+
+const MetaDataHeaderPrefix = 'x-amz-meta-';
+function hashBinary(buf, enableSHA256) {
+  let sha256sum = '';
+  if (enableSHA256) {
+    sha256sum = crypto.createHash('sha256').update(buf).digest('hex');
+  }
+  const md5sum = crypto.createHash('md5').update(buf).digest('base64');
+  return {
+    md5sum,
+    sha256sum
+  };
+}
+
+// S3 percent-encodes some extra non-standard characters in a URI . So comply with S3.
+const encodeAsHex = c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+function uriEscape(uriStr) {
+  return encodeURIComponent(uriStr).replace(/[!'()*]/g, encodeAsHex);
+}
+function uriResourceEscape(string) {
+  return uriEscape(string).replace(/%2F/g, '/');
+}
+function getScope(region, date, serviceName = 's3') {
+  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`;
+}
+
+/**
+ * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'
+ */
+function isAmazonEndpoint(endpoint) {
+  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn';
+}
+
+/**
+ * isVirtualHostStyle - verify if bucket name is support with virtual
+ * hosts. bucketNames with periods should be always treated as path
+ * style if the protocol is 'https:', this is due to SSL wildcard
+ * limitation. For all other buckets and Amazon S3 endpoint we will
+ * default to virtual host style.
+ */
+function isVirtualHostStyle(endpoint, protocol, bucket, pathStyle) {
+  if (protocol === 'https:' && bucket.includes('.')) {
+    return false;
+  }
+  return isAmazonEndpoint(endpoint) || !pathStyle;
+}
+function isValidIP(ip) {
+  return _ipaddr.isValid(ip);
+}
+
+/**
+ * @returns if endpoint is valid domain.
+ */
+function isValidEndpoint(endpoint) {
+  return isValidDomain(endpoint) || isValidIP(endpoint);
+}
+
+/**
+ * @returns if input host is a valid domain.
+ */
+function isValidDomain(host) {
+  if (!isString(host)) {
+    return false;
+  }
+  // See RFC 1035, RFC 3696.
+  if (host.length === 0 || host.length > 255) {
+    return false;
+  }
+  // Host cannot start or end with a '-'
+  if (host[0] === '-' || host.slice(-1) === '-') {
+    return false;
+  }
+  // Host cannot start or end with a '_'
+  if (host[0] === '_' || host.slice(-1) === '_') {
+    return false;
+  }
+  // Host cannot start with a '.'
+  if (host[0] === '.') {
+    return false;
+  }
+  const nonAlphaNumerics = '`~!@#$%^&*()+={}[]|\\"\';:><?/';
+  // All non alphanumeric characters are invalid.
+  for (const char of nonAlphaNumerics) {
+    if (host.includes(char)) {
+      return false;
+    }
+  }
+  // No need to regexp match, since the list is non-exhaustive.
+  // We let it be valid and fail later.
+  return true;
+}
+
+/**
+ * Probes contentType using file extensions.
+ *
+ * @example
+ * ```
+ * // return 'image/png'
+ * probeContentType('file.png')
+ * ```
+ */
+function probeContentType(path) {
+  let contentType = mime.lookup(path);
+  if (!contentType) {
+    contentType = 'application/octet-stream';
+  }
+  return contentType;
+}
+
+/**
+ * is input port valid.
+ */
+function isValidPort(port) {
+  // Convert string port to number if needed
+  const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
+
+  // verify if port is a valid number
+  if (!isNumber(portNum) || isNaN(portNum)) {
+    return false;
+  }
+
+  // port `0` is valid and special case
+  return 0 <= portNum && portNum <= 65535;
+}
+function isValidBucketName(bucket) {
+  if (!isString(bucket)) {
+    return false;
+  }
+
+  // bucket length should be less than and no more than 63
+  // characters long.
+  if (bucket.length < 3 || bucket.length > 63) {
+    return false;
+  }
+  // bucket with successive periods is invalid.
+  if (bucket.includes('..')) {
+    return false;
+  }
+  // bucket cannot have ip address style.
+  if (/[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/.test(bucket)) {
+    return false;
+  }
+  // bucket should begin with alphabet/number and end with alphabet/number,
+  // with alphabet/number/.- in the middle.
+  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * check if objectName is a valid object name
+ */
+function isValidObjectName(objectName) {
+  if (!isValidPrefix(objectName)) {
+    return false;
+  }
+  return objectName.length !== 0;
+}
+
+/**
+ * check if prefix is valid
+ */
+function isValidPrefix(prefix) {
+  if (!isString(prefix)) {
+    return false;
+  }
+  if (prefix.length > 1024) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * check if typeof arg number
+ */
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * check if typeof arg function
+ */
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+/**
+ * check if typeof arg string
+ */
+function isString(arg) {
+  return typeof arg === 'string';
+}
+
+/**
+ * check if typeof arg object
+ */
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+/**
+ * check if object is readable stream
+ */
+function isReadableStream(arg) {
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  return isObject(arg) && isFunction(arg._read);
+}
+
+/**
+ * check if arg is boolean
+ */
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+function isEmpty(o) {
+  return _lodash.isEmpty(o);
+}
+function isEmptyObject(o) {
+  return Object.values(o).filter(x => x !== undefined).length !== 0;
+}
+function isDefined(o) {
+  return o !== null && o !== undefined;
+}
+
+/**
+ * check if arg is a valid date
+ */
+function isValidDate(arg) {
+  // @ts-expect-error checknew Date(Math.NaN)
+  return arg instanceof Date && !isNaN(arg);
+}
+
+/**
+ * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z
+ */
+function makeDateLong(date) {
+  date = date || new Date();
+
+  // Gives format like: '2017-08-07T16:28:59.889Z'
+  const s = date.toISOString();
+  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z';
+}
+
+/**
+ * Create a Date string with format: 'YYYYMMDD'
+ */
+function makeDateShort(date) {
+  date = date || new Date();
+
+  // Gives format like: '2017-08-07T16:28:59.889Z'
+  const s = date.toISOString();
+  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10);
+}
+
+/**
+ * pipesetup sets up pipe() from left to right os streams array
+ * pipesetup will also make sure that error emitted at any of the upstream Stream
+ * will be emitted at the last stream. This makes error handling simple
+ */
+function pipesetup(...streams) {
+  // @ts-expect-error ts can't narrow this
+  return streams.reduce((src, dst) => {
+    src.on('error', err => dst.emit('error', err));
+    return src.pipe(dst);
+  });
+}
+
+/**
+ * return a Readable stream that emits data
+ */
+function readableStream(data) {
+  const s = new stream.Readable();
+  s._read = () => {};
+  s.push(data);
+  s.push(null);
+  return s;
+}
+
+/**
+ * Process metadata to insert appropriate value to `content-type` attribute
+ */
+function insertContentType(metaData, filePath) {
+  // check if content-type attribute present in metaData
+  for (const key in metaData) {
+    if (key.toLowerCase() === 'content-type') {
+      return metaData;
+    }
+  }
+
+  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath
+  return {
+    ...metaData,
+    'content-type': probeContentType(filePath)
+  };
+}
+
+/**
+ * Function prepends metadata with the appropriate prefix if it is not already on
+ */
+function prependXAMZMeta(metaData) {
+  if (!metaData) {
+    return {};
+  }
+  return _lodash.mapKeys(metaData, (value, key) => {
+    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {
+      return key;
+    }
+    return MetaDataHeaderPrefix + key;
+  });
+}
+
+/**
+ * Checks if it is a valid header according to the AmazonS3 API
+ */
+function isAmzHeader(key) {
+  const temp = key.toLowerCase();
+  return temp.startsWith(MetaDataHeaderPrefix) || temp === 'x-amz-acl' || temp.startsWith('x-amz-server-side-encryption-') || temp === 'x-amz-server-side-encryption';
+}
+
+/**
+ * Checks if it is a supported Header
+ */
+function isSupportedHeader(key) {
+  const supported_headers = ['content-type', 'cache-control', 'content-encoding', 'content-disposition', 'content-language', 'x-amz-website-redirect-location', 'if-none-match', 'if-match'];
+  return supported_headers.includes(key.toLowerCase());
+}
+
+/**
+ * Checks if it is a storage header
+ */
+function isStorageClassHeader(key) {
+  return key.toLowerCase() === 'x-amz-storage-class';
+}
+function extractMetadata(headers) {
+  return _lodash.mapKeys(_lodash.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)), (value, key) => {
+    const lower = key.toLowerCase();
+    if (lower.startsWith(MetaDataHeaderPrefix)) {
+      return lower.slice(MetaDataHeaderPrefix.length);
+    }
+    return key;
+  });
+}
+function getVersionId(headers = {}) {
+  return headers['x-amz-version-id'] || null;
+}
+function getSourceVersionId(headers = {}) {
+  return headers['x-amz-copy-source-version-id'] || null;
+}
+function sanitizeETag(etag = '') {
+  const replaceChars = {
+    '"': '',
+    '&quot;': '',
+    '&#34;': '',
+    '&QUOT;': '',
+    '&#x00022': ''
+  };
+  return etag.replace(/^("|&quot;|&#34;)|("|&quot;|&#34;)$/g, m => replaceChars[m]);
+}
+function toMd5(payload) {
+  // use string from browser and buffer from nodejs
+  // browser support is tested only against minio server
+  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64');
+}
+function toSha256(payload) {
+  return crypto.createHash('sha256').update(payload).digest('hex');
+}
+
+/**
+ * toArray returns a single element array with param being the element,
+ * if param is just a string, and returns 'param' back if it is an array
+ * So, it makes sure param is always an array
+ */
+function toArray(param) {
+  if (!Array.isArray(param)) {
+    return [param];
+  }
+  return param;
+}
+function sanitizeObjectKey(objectName) {
+  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.
+  const asStrName = (objectName ? objectName.toString() : '').replace(/\+/g, ' ');
+  return decodeURIComponent(asStrName);
+}
+function sanitizeSize(size) {
+  return size ? Number.parseInt(size) : undefined;
+}
+const PART_CONSTRAINTS = {
+  // absMinPartSize - absolute minimum part size (5 MiB)
+  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,
+  // MIN_PART_SIZE - minimum part size 16MiB per object after which
+  MIN_PART_SIZE: 1024 * 1024 * 16,
+  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.
+  MAX_PARTS_COUNT: 10000,
+  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload
+  // operation.
+  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,
+  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT
+  // operation.
+  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,
+  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for
+  // Multipart operation.
+  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5
+};
+exports.PART_CONSTRAINTS = PART_CONSTRAINTS;
+const GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption';
+const ENCRYPTION_HEADERS = {
+  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.
+  sseGenericHeader: GENERIC_SSE_HEADER,
+  // sseKmsKeyID is the AWS SSE-KMS key id.
+  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id'
+};
+
+/**
+ * Return Encryption headers
+ * @param encConfig
+ * @returns an object with key value pairs that can be used in headers.
+ */
+function getEncryptionHeaders(encConfig) {
+  const encType = encConfig.type;
+  if (!isEmpty(encType)) {
+    if (encType === _type.ENCRYPTION_TYPES.SSEC) {
+      return {
+        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256'
+      };
+    } else if (encType === _type.ENCRYPTION_TYPES.KMS) {
+      return {
+        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,
+        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID
+      };
+    }
+  }
+  return {};
+}
+function partsRequired(size) {
+  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1);
+  let requiredPartSize = size / maxPartSize;
+  if (size % maxPartSize > 0) {
+    requiredPartSize++;
+  }
+  requiredPartSize = Math.trunc(requiredPartSize);
+  return requiredPartSize;
+}
+
+/**
+ * calculateEvenSplits - computes splits for a source and returns
+ * start and end index slices. Splits happen evenly to be sure that no
+ * part is less than 5MiB, as that could fail the multipart request if
+ * it is not the last part.
+ */
+function calculateEvenSplits(size, objInfo) {
+  if (size === 0) {
+    return null;
+  }
+  const reqParts = partsRequired(size);
+  const startIndexParts = [];
+  const endIndexParts = [];
+  let start = objInfo.Start;
+  if (isEmpty(start) || start === -1) {
+    start = 0;
+  }
+  const divisorValue = Math.trunc(size / reqParts);
+  const reminderValue = size % reqParts;
+  let nextStart = start;
+  for (let i = 0; i < reqParts; i++) {
+    let curPartSize = divisorValue;
+    if (i < reminderValue) {
+      curPartSize++;
+    }
+    const currentStart = nextStart;
+    const currentEnd = currentStart + curPartSize - 1;
+    nextStart = currentEnd + 1;
+    startIndexParts.push(currentStart);
+    endIndexParts.push(currentEnd);
+  }
+  return {
+    startIndex: startIndexParts,
+    endIndex: endIndexParts,
+    objInfo: objInfo
+  };
+}
+const fxp = new _fastXmlParser.XMLParser({
+  numberParseOptions: {
+    eNotation: false,
+    hex: true,
+    leadingZeros: true
+  }
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseXml(xml) {
+  const result = fxp.parse(xml);
+  if (result.Error) {
+    throw result.Error;
+  }
+  return result;
+}
+
+/**
+ * get content size of object content to upload
+ */
+async function getContentLength(s) {
+  // use length property of string | Buffer
+  if (typeof s === 'string' || Buffer.isBuffer(s)) {
+    return s.length;
+  }
+
+  // property of `fs.ReadStream`
+  const filePath = s.path;
+  if (filePath && typeof filePath === 'string') {
+    const stat = await _async.fsp.lstat(filePath);
+    return stat.size;
+  }
+
+  // property of `fs.ReadStream`
+  const fd = s.fd;
+  if (fd && typeof fd === 'number') {
+    const stat = await (0, _async.fstat)(fd);
+    return stat.size;
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcnlwdG8iLCJfaW50ZXJvcFJlcXVpcmVXaWxkY2FyZCIsInJlcXVpcmUiLCJzdHJlYW0iLCJfZmFzdFhtbFBhcnNlciIsIl9pcGFkZHIiLCJfbG9kYXNoIiwibWltZSIsIl9hc3luYyIsIl90eXBlIiwiX2dldFJlcXVpcmVXaWxkY2FyZENhY2hlIiwibm9kZUludGVyb3AiLCJXZWFrTWFwIiwiY2FjaGVCYWJlbEludGVyb3AiLCJjYWNoZU5vZGVJbnRlcm9wIiwib2JqIiwiX19lc01vZHVsZSIsImRlZmF1bHQiLCJjYWNoZSIsImhhcyIsImdldCIsIm5ld09iaiIsImhhc1Byb3BlcnR5RGVzY3JpcHRvciIsIk9iamVjdCIsImRlZmluZVByb3BlcnR5IiwiZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yIiwia2V5IiwicHJvdG90eXBlIiwiaGFzT3duUHJvcGVydHkiLCJjYWxsIiwiZGVzYyIsInNldCIsIk1ldGFEYXRhSGVhZGVyUHJlZml4IiwiaGFzaEJpbmFyeSIsImJ1ZiIsImVuYWJsZVNIQTI1NiIsInNoYTI1NnN1bSIsImNyZWF0ZUhhc2giLCJ1cGRhdGUiLCJkaWdlc3QiLCJtZDVzdW0iLCJlbmNvZGVBc0hleCIsImMiLCJjaGFyQ29kZUF0IiwidG9TdHJpbmciLCJ0b1VwcGVyQ2FzZSIsInVyaUVzY2FwZSIsInVyaVN0ciIsImVuY29kZVVSSUNvbXBvbmVudCIsInJlcGxhY2UiLCJ1cmlSZXNvdXJjZUVzY2FwZSIsInN0cmluZyIsImdldFNjb3BlIiwicmVnaW9uIiwiZGF0ZSIsInNlcnZpY2VOYW1lIiwibWFrZURhdGVTaG9ydCIsImlzQW1hem9uRW5kcG9pbnQiLCJlbmRwb2ludCIsImlzVmlydHVhbEhvc3RTdHlsZSIsInByb3RvY29sIiwiYnVja2V0IiwicGF0aFN0eWxlIiwiaW5jbHVkZXMiLCJpc1ZhbGlkSVAiLCJpcCIsImlwYWRkciIsImlzVmFsaWQiLCJpc1ZhbGlkRW5kcG9pbnQiLCJpc1ZhbGlkRG9tYWluIiwiaG9zdCIsImlzU3RyaW5nIiwibGVuZ3RoIiwic2xpY2UiLCJub25BbHBoYU51bWVyaWNzIiwiY2hhciIsInByb2JlQ29udGVudFR5cGUiLCJwYXRoIiwiY29udGVudFR5cGUiLCJsb29rdXAiLCJpc1ZhbGlkUG9ydCIsInBvcnQiLCJwb3J0TnVtIiwicGFyc2VJbnQiLCJpc051bWJlciIsImlzTmFOIiwiaXNWYWxpZEJ1Y2tldE5hbWUiLCJ0ZXN0IiwiaXNWYWxpZE9iamVjdE5hbWUiLCJvYmplY3ROYW1lIiwiaXNWYWxpZFByZWZpeCIsInByZWZpeCIsImFyZyIsImlzRnVuY3Rpb24iLCJpc09iamVjdCIsImlzUmVhZGFibGVTdHJlYW0iLCJfcmVhZCIsImlzQm9vbGVhbiIsImlzRW1wdHkiLCJvIiwiXyIsImlzRW1wdHlPYmplY3QiLCJ2YWx1ZXMiLCJmaWx0ZXIiLCJ4IiwidW5kZWZpbmVkIiwiaXNEZWZpbmVkIiwiaXNWYWxpZERhdGUiLCJEYXRlIiwibWFrZURhdGVMb25nIiwicyIsInRvSVNPU3RyaW5nIiwicGlwZXNldHVwIiwic3RyZWFtcyIsInJlZHVjZSIsInNyYyIsImRzdCIsIm9uIiwiZXJyIiwiZW1pdCIsInBpcGUiLCJyZWFkYWJsZVN0cmVhbSIsImRhdGEiLCJSZWFkYWJsZSIsInB1c2giLCJpbnNlcnRDb250ZW50VHlwZSIsIm1ldGFEYXRhIiwiZmlsZVBhdGgiLCJ0b0xvd2VyQ2FzZSIsInByZXBlbmRYQU1aTWV0YSIsIm1hcEtleXMiLCJ2YWx1ZSIsImlzQW16SGVhZGVyIiwiaXNTdXBwb3J0ZWRIZWFkZXIiLCJpc1N0b3JhZ2VDbGFzc0hlYWRlciIsInRlbXAiLCJzdGFydHNXaXRoIiwic3VwcG9ydGVkX2hlYWRlcnMiLCJleHRyYWN0TWV0YWRhdGEiLCJoZWFkZXJzIiwicGlja0J5IiwibG93ZXIiLCJnZXRWZXJzaW9uSWQiLCJnZXRTb3VyY2VWZXJzaW9uSWQiLCJzYW5pdGl6ZUVUYWciLCJldGFnIiwicmVwbGFjZUNoYXJzIiwibSIsInRvTWQ1IiwicGF5bG9hZCIsIkJ1ZmZlciIsImZyb20iLCJ0b1NoYTI1NiIsInRvQXJyYXkiLCJwYXJhbSIsIkFycmF5IiwiaXNBcnJheSIsInNhbml0aXplT2JqZWN0S2V5IiwiYXNTdHJOYW1lIiwiZGVjb2RlVVJJQ29tcG9uZW50Iiwic2FuaXRpemVTaXplIiwic2l6ZSIsIk51bWJlciIsIlBBUlRfQ09OU1RSQUlOVFMiLCJBQlNfTUlOX1BBUlRfU0laRSIsIk1JTl9QQVJUX1NJWkUiLCJNQVhfUEFSVFNfQ09VTlQiLCJNQVhfUEFSVF9TSVpFIiwiTUFYX1NJTkdMRV9QVVRfT0JKRUNUX1NJWkUiLCJNQVhfTVVMVElQQVJUX1BVVF9PQkpFQ1RfU0laRSIsImV4cG9ydHMiLCJHRU5FUklDX1NTRV9IRUFERVIiLCJFTkNSWVBUSU9OX0hFQURFUlMiLCJzc2VHZW5lcmljSGVhZGVyIiwic3NlS21zS2V5SUQiLCJnZXRFbmNyeXB0aW9uSGVhZGVycyIsImVuY0NvbmZpZyIsImVuY1R5cGUiLCJ0eXBlIiwiRU5DUllQVElPTl9UWVBFUyIsIlNTRUMiLCJLTVMiLCJTU0VBbGdvcml0aG0iLCJLTVNNYXN0ZXJLZXlJRCIsInBhcnRzUmVxdWlyZWQiLCJtYXhQYXJ0U2l6ZSIsInJlcXVpcmVkUGFydFNpemUiLCJNYXRoIiwidHJ1bmMiLCJjYWxjdWxhdGVFdmVuU3BsaXRzIiwib2JqSW5mbyIsInJlcVBhcnRzIiwic3RhcnRJbmRleFBhcnRzIiwiZW5kSW5kZXhQYXJ0cyIsInN0YXJ0IiwiU3RhcnQiLCJkaXZpc29yVmFsdWUiLCJyZW1pbmRlclZhbHVlIiwibmV4dFN0YXJ0IiwiaSIsImN1clBhcnRTaXplIiwiY3VycmVudFN0YXJ0IiwiY3VycmVudEVuZCIsInN0YXJ0SW5kZXgiLCJlbmRJbmRleCIsImZ4cCIsIlhNTFBhcnNlciIsIm51bWJlclBhcnNlT3B0aW9ucyIsImVOb3RhdGlvbiIsImhleCIsImxlYWRpbmdaZXJvcyIsInBhcnNlWG1sIiwieG1sIiwicmVzdWx0IiwicGFyc2UiLCJFcnJvciIsImdldENvbnRlbnRMZW5ndGgiLCJpc0J1ZmZlciIsInN0YXQiLCJmc3AiLCJsc3RhdCIsImZkIiwiZnN0YXQiXSwic291cmNlcyI6WyJoZWxwZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIE1pbklPIEphdmFzY3JpcHQgTGlicmFyeSBmb3IgQW1hem9uIFMzIENvbXBhdGlibGUgQ2xvdWQgU3RvcmFnZSwgKEMpIDIwMTUgTWluSU8sIEluYy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0ICogYXMgY3J5cHRvIGZyb20gJ25vZGU6Y3J5cHRvJ1xuaW1wb3J0ICogYXMgc3RyZWFtIGZyb20gJ25vZGU6c3RyZWFtJ1xuXG5pbXBvcnQgeyBYTUxQYXJzZXIgfSBmcm9tICdmYXN0LXhtbC1wYXJzZXInXG5pbXBvcnQgaXBhZGRyIGZyb20gJ2lwYWRkci5qcydcbmltcG9ydCBfIGZyb20gJ2xvZGFzaCdcbmltcG9ydCAqIGFzIG1pbWUgZnJvbSAnbWltZS10eXBlcydcblxuaW1wb3J0IHsgZnNwLCBmc3RhdCB9IGZyb20gJy4vYXN5bmM
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/join-host-port.d.ts

@@ -0,0 +1,11 @@
+/**
+ * joinHostPort combines host and port into a network address of the
+ * form "host:port". If host contains a colon, as found in literal
+ * IPv6 addresses, then JoinHostPort returns "[host]:port".
+ *
+ * @param host
+ * @param port
+ * @returns Cleaned up host
+ * @internal
+ */
+export declare function joinHostPort(host: string, port?: number): string;

SerpentRace_Backend/node_modules/minio/dist/main/internal/join-host-port.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinHostPort = joinHostPort;
+/**
+ * joinHostPort combines host and port into a network address of the
+ * form "host:port". If host contains a colon, as found in literal
+ * IPv6 addresses, then JoinHostPort returns "[host]:port".
+ *
+ * @param host
+ * @param port
+ * @returns Cleaned up host
+ * @internal
+ */
+function joinHostPort(host, port) {
+  if (port === undefined) {
+    return host;
+  }
+
+  // We assume that host is a literal IPv6 address if host has
+  // colons.
+  if (host.includes(':')) {
+    return `[${host}]:${port.toString()}`;
+  }
+  return `${host}:${port.toString()}`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJqb2luSG9zdFBvcnQiLCJob3N0IiwicG9ydCIsInVuZGVmaW5lZCIsImluY2x1ZGVzIiwidG9TdHJpbmciXSwic291cmNlcyI6WyJqb2luLWhvc3QtcG9ydC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGpvaW5Ib3N0UG9ydCBjb21iaW5lcyBob3N0IGFuZCBwb3J0IGludG8gYSBuZXR3b3JrIGFkZHJlc3Mgb2YgdGhlXG4gKiBmb3JtIFwiaG9zdDpwb3J0XCIuIElmIGhvc3QgY29udGFpbnMgYSBjb2xvbiwgYXMgZm91bmQgaW4gbGl0ZXJhbFxuICogSVB2NiBhZGRyZXNzZXMsIHRoZW4gSm9pbkhvc3RQb3J0IHJldHVybnMgXCJbaG9zdF06cG9ydFwiLlxuICpcbiAqIEBwYXJhbSBob3N0XG4gKiBAcGFyYW0gcG9ydFxuICogQHJldHVybnMgQ2xlYW5lZCB1cCBob3N0XG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGpvaW5Ib3N0UG9ydChob3N0OiBzdHJpbmcsIHBvcnQ/OiBudW1iZXIpOiBzdHJpbmcge1xuICBpZiAocG9ydCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuIGhvc3RcbiAgfVxuXG4gIC8vIFdlIGFzc3VtZSB0aGF0IGhvc3QgaXMgYSBsaXRlcmFsIElQdjYgYWRkcmVzcyBpZiBob3N0IGhhc1xuICAvLyBjb2xvbnMuXG4gIGlmIChob3N0LmluY2x1ZGVzKCc6JykpIHtcbiAgICByZXR1cm4gYFske2hvc3R9XToke3BvcnQudG9TdHJpbmcoKX1gXG4gIH1cblxuICByZXR1cm4gYCR7aG9zdH06JHtwb3J0LnRvU3RyaW5nKCl9YFxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNPLFNBQVNBLFlBQVlBLENBQUNDLElBQVksRUFBRUMsSUFBYSxFQUFVO0VBQ2hFLElBQUlBLElBQUksS0FBS0MsU0FBUyxFQUFFO0lBQ3RCLE9BQU9GLElBQUk7RUFDYjs7RUFFQTtFQUNBO0VBQ0EsSUFBSUEsSUFBSSxDQUFDRyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7SUFDdEIsT0FBUSxJQUFHSCxJQUFLLEtBQUlDLElBQUksQ0FBQ0csUUFBUSxDQUFDLENBQUUsRUFBQztFQUN2QztFQUVBLE9BQVEsR0FBRUosSUFBSyxJQUFHQyxJQUFJLENBQUNHLFFBQVEsQ0FBQyxDQUFFLEVBQUM7QUFDckMifQ==

SerpentRace_Backend/node_modules/minio/dist/main/internal/post-policy.d.ts

@@ -0,0 +1,17 @@
+import type { ObjectMetaData } from "./type.js";
+export declare class PostPolicy {
+  policy: {
+    conditions: (string | number)[][];
+    expiration?: string;
+  };
+  formData: Record<string, string>;
+  setExpires(date: Date): void;
+  setKey(objectName: string): void;
+  setKeyStartsWith(prefix: string): void;
+  setBucket(bucketName: string): void;
+  setContentType(type: string): void;
+  setContentTypeStartsWith(prefix: string): void;
+  setContentDisposition(value: string): void;
+  setContentLengthRange(min: number, max: number): void;
+  setUserMetaData(metaData: ObjectMetaData): void;
+}

SerpentRace_Backend/node_modules/minio/dist/main/internal/post-policy.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var errors = _interopRequireWildcard(require("../errors.js"), true);
+var _helper = require("./helper.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; }
+// Build PostPolicy object that can be signed by presignedPostPolicy
+
+class PostPolicy {
+  policy = {
+    conditions: []
+  };
+  formData = {};
+
+  // set expiration date
+  setExpires(date) {
+    if (!date) {
+      throw new errors.InvalidDateError('Invalid date: cannot be null');
+    }
+    this.policy.expiration = date.toISOString();
+  }
+
+  // set object name
+  setKey(objectName) {
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name : ${objectName}`);
+    }
+    this.policy.conditions.push(['eq', '$key', objectName]);
+    this.formData.key = objectName;
+  }
+
+  // set object name prefix, i.e policy allows any keys with this prefix
+  setKeyStartsWith(prefix) {
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    this.policy.conditions.push(['starts-with', '$key', prefix]);
+    this.formData.key = prefix;
+  }
+
+  // set bucket name
+  setBucket(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`);
+    }
+    this.policy.conditions.push(['eq', '$bucket', bucketName]);
+    this.formData.bucket = bucketName;
+  }
+
+  // set Content-Type
+  setContentType(type) {
+    if (!type) {
+      throw new Error('content-type cannot be null');
+    }
+    this.policy.conditions.push(['eq', '$Content-Type', type]);
+    this.formData['Content-Type'] = type;
+  }
+
+  // set Content-Type prefix, i.e image/ allows any image
+  setContentTypeStartsWith(prefix) {
+    if (!prefix) {
+      throw new Error('content-type cannot be null');
+    }
+    this.policy.conditions.push(['starts-with', '$Content-Type', prefix]);
+    this.formData['Content-Type'] = prefix;
+  }
+
+  // set Content-Disposition
+  setContentDisposition(value) {
+    if (!value) {
+      throw new Error('content-disposition cannot be null');
+    }
+    this.policy.conditions.push(['eq', '$Content-Disposition', value]);
+    this.formData['Content-Disposition'] = value;
+  }
+
+  // set minimum/maximum length of what Content-Length can be.
+  setContentLengthRange(min, max) {
+    if (min > max) {
+      throw new Error('min cannot be more than max');
+    }
+    if (min < 0) {
+      throw new Error('min should be > 0');
+    }
+    if (max < 0) {
+      throw new Error('max should be > 0');
+    }
+    this.policy.conditions.push(['content-length-range', min, max]);
+  }
+
+  // set user defined metadata
+  setUserMetaData(metaData) {
+    if (!(0, _helper.isObject)(metaData)) {
+      throw new TypeError('metadata should be of type "object"');
+    }
+    Object.entries(metaData).forEach(([key, value]) => {
+      const amzMetaDataKey = `x-amz-meta-${key}`;
+      this.policy.conditions.push(['eq', `$${amzMetaDataKey}`, value]);
+      this.formData[amzMetaDataKey] = value.toString();
+    });
+  }
+}
+exports.PostPolicy = PostPolicy;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlcnJvcnMiLCJfaW50ZXJvcFJlcXVpcmVXaWxkY2FyZCIsInJlcXVpcmUiLCJfaGVscGVyIiwiX2dldFJlcXVpcmVXaWxkY2FyZENhY2hlIiwibm9kZUludGVyb3AiLCJXZWFrTWFwIiwiY2FjaGVCYWJlbEludGVyb3AiLCJjYWNoZU5vZGVJbnRlcm9wIiwib2JqIiwiX19lc01vZHVsZSIsImRlZmF1bHQiLCJjYWNoZSIsImhhcyIsImdldCIsIm5ld09iaiIsImhhc1Byb3BlcnR5RGVzY3JpcHRvciIsIk9iamVjdCIsImRlZmluZVByb3BlcnR5IiwiZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yIiwia2V5IiwicHJvdG90eXBlIiwiaGFzT3duUHJvcGVydHkiLCJjYWxsIiwiZGVzYyIsInNldCIsIlBvc3RQb2xpY3kiLCJwb2xpY3kiLCJjb25kaXRpb25zIiwiZm9ybURhdGEiLCJzZXRFeHBpcmVzIiwiZGF0ZSIsIkludmFsaWREYXRlRXJyb3IiLCJleHBpcmF0aW9uIiwidG9JU09TdHJpbmciLCJzZXRLZXkiLCJvYmplY3ROYW1lIiwiaXNWYWxpZE9iamVjdE5hbWUiLCJJbnZhbGlkT2JqZWN0TmFtZUVycm9yIiwicHVzaCIsInNldEtleVN0YXJ0c1dpdGgiLCJwcmVmaXgiLCJpc1ZhbGlkUHJlZml4IiwiSW52YWxpZFByZWZpeEVycm9yIiwic2V0QnVja2V0IiwiYnVja2V0TmFtZSIsImlzVmFsaWRCdWNrZXROYW1lIiwiSW52YWxpZEJ1Y2tldE5hbWVFcnJvciIsImJ1Y2tldCIsInNldENvbnRlbnRUeXBlIiwidHlwZSIsIkVycm9yIiwic2V0Q29udGVudFR5cGVTdGFydHNXaXRoIiwic2V0Q29udGVudERpc3Bvc2l0aW9uIiwidmFsdWUiLCJzZXRDb250ZW50TGVuZ3RoUmFuZ2UiLCJtaW4iLCJtYXgiLCJzZXRVc2VyTWV0YURhdGEiLCJtZXRhRGF0YSIsImlzT2JqZWN0IiwiVHlwZUVycm9yIiwiZW50cmllcyIsImZvckVhY2giLCJhbXpNZXRhRGF0YUtleSIsInRvU3RyaW5nIiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbInBvc3QtcG9saWN5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIEJ1aWxkIFBvc3RQb2xpY3kgb2JqZWN0IHRoYXQgY2FuIGJlIHNpZ25lZCBieSBwcmVzaWduZWRQb3N0UG9saWN5XG5pbXBvcnQgKiBhcyBlcnJvcnMgZnJvbSAnLi4vZXJyb3JzLnRzJ1xuaW1wb3J0IHsgaXNPYmplY3QsIGlzVmFsaWRCdWNrZXROYW1lLCBpc1ZhbGlkT2JqZWN0TmFtZSwgaXNWYWxpZFByZWZpeCB9IGZyb20gJy4vaGVscGVyLnRzJ1xuaW1wb3J0IHR5cGUgeyBPYmplY3RNZXRhRGF0YSB9IGZyb20gJy4vdHlwZS50cydcblxuZXhwb3J0IGNsYXNzIFBvc3RQb2xpY3kge1xuICBwdWJsaWMgcG9saWN5OiB7IGNvbmRpdGlvbnM6IChzdHJpbmcgfCBudW1iZXIpW11bXTsgZXhwaXJhdGlvbj86IHN0cmluZyB9ID0ge1xuICAgIGNvbmRpdGlvbnM6IFtdLFxuICB9XG4gIHB1YmxpYyBmb3JtRGF0YTogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHt9XG5cbiAgLy8gc2V0IGV4cGlyYXRpb24gZGF0ZVxuICBzZXRFeHBpcmVzKGRhdGU6IERhdGUpIHtcbiAgICBpZiAoIWRhdGUpIHtcbiAgICAgIHRocm93IG5ldyBlcnJvcnMuSW52YWxpZERhdGVFcnJvcignSW52YWxpZCBkYXRlOiBjYW5ub3QgYmUgbnVsbCcpXG4gICAgfVxuICAgIHRoaXMucG9saWN5LmV4cGlyYXRpb24gPSBkYXRlLnRvSVNPU3RyaW5nKClcbiAgfVxuXG4gIC8vIHNldCBvYmplY3QgbmFtZVxuICBzZXRLZXkob2JqZWN0TmFtZTogc3RyaW5nKSB7XG4gICAgaWYgKCFpc1ZhbGlkT2JqZWN0TmFtZShvYmplY3ROYW1lKSkge1xuICAgICAgdGhyb3cgbmV3IGVycm9ycy5JbnZhbGlkT2JqZWN0TmFtZUVycm9yKGBJbnZhbGlkIG9iamVjdCBuYW1lIDogJHtvYmplY3ROYW1lfWApXG4gICAgfVxuICAgIHRoaXMucG9saWN5LmNvbmRpdGlvbnMucHVzaChbJ2VxJywgJyRrZXknLCBvYmplY3ROYW1lXSlcbiAgICB0aGlzLmZvcm1EYXRhLmtleSA9IG9iamVjdE5hbWVcbiAgfVxuXG4gIC8vIHNldCBvYmplY3QgbmFtZSBwcmVmaXgsIGkuZSBwb2xpY3kgYWxsb3dzIGFueSBrZXlzIHdpdGggdGhpcyBwcmVmaXhcbiAgc2V0S2V5U3RhcnRzV2l0aChwcmVmaXg6IHN0cmluZykge1xuICAgIGlmICghaXNWYWxpZFByZWZpeChwcmVmaXgpKSB7XG4gICAgICB0aHJvdyBuZXcgZXJyb3JzLkludmFsaWRQcmVmaXhFcnJvcihgSW52YWxpZCBwcmVmaXggOiAke3ByZWZpeH1gKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydzdGFydHMtd2l0aCcsICcka2V5JywgcHJlZml4XSlcbiAgICB0aGlzLmZvcm1EYXRhLmtleSA9IHByZWZpeFxuICB9XG5cbiAgLy8gc2V0IGJ1Y2tldCBuYW1lXG4gIHNldEJ1Y2tldChidWNrZXROYW1lOiBzdHJpbmcpIHtcbiAgICBpZiAoIWlzVmFsaWRCdWNrZXROYW1lKGJ1Y2tldE5hbWUpKSB7XG4gICAgICB0aHJvdyBuZXcgZXJyb3JzLkludmFsaWRCdWNrZXROYW1lRXJyb3IoYEludmFsaWQgYnVja2V0IG5hbWUgOiAke2J1Y2tldE5hbWV9YClcbiAgICB9XG4gICAgdGhpcy5wb2xpY3kuY29uZGl0aW9ucy5wdXNoKFsnZXEnLCAnJGJ1Y2tldCcsIGJ1Y2tldE5hbWVdKVxuICAgIHRoaXMuZm9ybURhdGEuYnVja2V0ID0gYnVja2V0TmFtZVxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtVHlwZVxuICBzZXRDb250ZW50VHlwZSh0eXBlOiBzdHJpbmcpIHtcbiAgICBpZiAoIXR5cGUpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignY29udGVudC10eXBlIGNhbm5vdCBiZSBudWxsJylcbiAgICB9XG4gICAgdGhpcy5wb2xpY3kuY29uZGl0aW9ucy5wdXNoKFsnZXEnLCAnJENvbnRlbnQtVHlwZScsIHR5cGVdKVxuICAgIHRoaXMuZm9ybURhdGFbJ0NvbnRlbnQtVHlwZSddID0gdHlwZVxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtVHlwZSBwcmVmaXgsIGkuZSBpbWFnZS8gYWxsb3dzIGFueSBpbWFnZVxuICBzZXRDb250ZW50VHlwZVN0YXJ0c1dpdGgocHJlZml4OiBzdHJpbmcpIHtcbiAgICBpZiAoIXByZWZpeCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdjb250ZW50LXR5cGUgY2Fubm90IGJlIG51bGwnKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydzdGFydHMtd2l0aCcsICckQ29udGVudC1UeXBlJywgcHJlZml4XSlcbiAgICB0aGlzLmZvcm1EYXRhWydDb250ZW50LVR5cGUnXSA9IHByZWZpeFxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtRGlzcG9zaXRpb25cbiAgc2V0Q29udGVudERpc3Bvc2l0aW9uKHZhbHVlOiBzdHJpbmcpIHtcbiAgICBpZiAoIXZhbHVlKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ2NvbnRlbnQtZGlzcG9zaXRpb24gY2Fubm90IGJlIG51bGwnKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydlcScsICckQ29udGVudC1EaXNwb3NpdGlvbicsIHZhbHVlXSlcbiAgICB0aGlzLmZvcm1EYXRhWydDb250ZW50LURpc3Bvc2l0aW9uJ10gPSB2YWx1ZVxuICB9XG5cbiAgLy8gc2V0IG1pbmltdW0vbWF4aW11bSBsZW5ndGggb2Ygd2hhdCBDb250ZW50LUxlbmd0aCBjYW4gYmUuXG4gIHNldENvbnRlbnRMZW5ndGhSYW5nZShtaW46IG51bWJlciwgbWF4OiBudW1iZXIpIHtcbiAgICBpZiAobWluID4gbWF4KSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ21pbiBjYW5ub3QgYmUgbW9yZSB0aGFuIG1heCcpXG4gICAgfVxuICAgIGlmIChtaW4gPCAwKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ21pbiBzaG91bGQgYmUgPiAwJylcbiAgICB9XG4gICAgaWYgKG1heCA8IDApIHtcbiAgICAgIHRocm93IG5
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/request.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as http from 'node:http';
+import type * as https from 'node:https';
+import type * as stream from 'node:stream';
+import type { Transport } from "./type.js";
+export declare function request(transport: Transport, opt: https.RequestOptions, body?: Buffer | string | stream.Readable | null): Promise<http.IncomingMessage>;
+export declare const retryHttpCodes: Record<string, boolean>;
+export declare function requestWithRetry(transport: Transport, opt: https.RequestOptions, body?: Buffer | string | stream.Readable | null, maxRetries?: number): Promise<http.IncomingMessage>;

SerpentRace_Backend/node_modules/minio/dist/main/internal/request.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.request = request;
+exports.requestWithRetry = requestWithRetry;
+var _stream = require("stream");
+var _util = require("util");
+const pipelineAsync = (0, _util.promisify)(_stream.pipeline);
+async function request(transport, opt, body = null) {
+  return new Promise((resolve, reject) => {
+    const requestObj = transport.request(opt, response => {
+      resolve(response);
+    });
+    requestObj.on('error', reject);
+    if (!body || Buffer.isBuffer(body) || typeof body === 'string') {
+      requestObj.end(body);
+    } else {
+      pipelineAsync(body, requestObj).catch(reject);
+    }
+  });
+}
+const MAX_RETRIES = 10;
+const EXP_BACK_OFF_BASE_DELAY = 1000; // Base delay for exponential backoff
+const ADDITIONAL_DELAY_FACTOR = 1.0; // to avoid synchronized retries
+
+// Retryable error codes for HTTP ( ref: minio-go)
+const retryHttpCodes = {
+  408: true,
+  429: true,
+  499: true,
+  500: true,
+  502: true,
+  503: true,
+  504: true,
+  520: true
+};
+exports.retryHttpCodes = retryHttpCodes;
+const isHttpRetryable = httpResCode => {
+  return retryHttpCodes[httpResCode] !== undefined;
+};
+const sleep = ms => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+const getExpBackOffDelay = retryCount => {
+  const backOffBy = EXP_BACK_OFF_BASE_DELAY * 2 ** retryCount;
+  const additionalDelay = Math.random() * backOffBy * ADDITIONAL_DELAY_FACTOR;
+  return backOffBy + additionalDelay;
+};
+async function requestWithRetry(transport, opt, body = null, maxRetries = MAX_RETRIES) {
+  let attempt = 0;
+  let isRetryable = false;
+  while (attempt <= maxRetries) {
+    try {
+      const response = await request(transport, opt, body);
+      // Check if the HTTP status code is retryable
+      if (isHttpRetryable(response.statusCode)) {
+        isRetryable = true;
+        throw new Error(`Retryable HTTP status: ${response.statusCode}`); // trigger retry attempt with calculated delay
+      }
+
+      return response; // Success, return the raw response
+    } catch (err) {
+      if (isRetryable) {
+        attempt++;
+        isRetryable = false;
+        if (attempt > maxRetries) {
+          throw new Error(`Request failed after ${maxRetries} retries: ${err}`);
+        }
+        const delay = getExpBackOffDelay(attempt);
+        // eslint-disable-next-line no-console
+        console.warn(`${new Date().toLocaleString()} Retrying request (attempt ${attempt}/${maxRetries}) after ${delay}ms due to: ${err}`);
+        await sleep(delay);
+      } else {
+        throw err; // re-throw if any request, syntax errors
+      }
+    }
+  }
+
+  throw new Error(`${MAX_RETRIES} Retries exhausted, request failed.`);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/response.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type http from 'node:http';
+import type stream from 'node:stream';
+export declare function readAsBuffer(res: stream.Readable): Promise<Buffer>;
+export declare function readAsString(res: http.IncomingMessage): Promise<string>;
+export declare function drainResponse(res: stream.Readable): Promise<void>;

SerpentRace_Backend/node_modules/minio/dist/main/internal/response.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.drainResponse = drainResponse;
+exports.readAsBuffer = readAsBuffer;
+exports.readAsString = readAsString;
+async function readAsBuffer(res) {
+  return new Promise((resolve, reject) => {
+    const body = [];
+    res.on('data', chunk => body.push(chunk)).on('error', e => reject(e)).on('end', () => resolve(Buffer.concat(body)));
+  });
+}
+async function readAsString(res) {
+  const body = await readAsBuffer(res);
+  return body.toString();
+}
+async function drainResponse(res) {
+  return new Promise((resolve, reject) => {
+    res.on('data', () => {}).on('error', e => reject(e)).on('end', () => resolve());
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/main/internal/s3-endpoints.d.ts

@@ -0,0 +1,38 @@
+declare const awsS3Endpoint: {
+  'af-south-1': string;
+  'ap-east-1': string;
+  'ap-south-1': string;
+  'ap-south-2': string;
+  'ap-southeast-1': string;
+  'ap-southeast-2': string;
+  'ap-southeast-3': string;
+  'ap-southeast-4': string;
+  'ap-southeast-5': string;
+  'ap-northeast-1': string;
+  'ap-northeast-2': string;
+  'ap-northeast-3': string;
+  'ca-central-1': string;
+  'ca-west-1': string;
+  'cn-north-1': string;
+  'eu-central-1': string;
+  'eu-central-2': string;
+  'eu-north-1': string;
+  'eu-south-1': string;
+  'eu-south-2': string;
+  'eu-west-1': string;
+  'eu-west-2': string;
+  'eu-west-3': string;
+  'il-central-1': string;
+  'me-central-1': string;
+  'me-south-1': string;
+  'sa-east-1': string;
+  'us-east-1': string;
+  'us-east-2': string;
+  'us-west-1': string;
+  'us-west-2': string;
+  'us-gov-east-1': string;
+  'us-gov-west-1': string;
+};
+export type Region = keyof typeof awsS3Endpoint | string;
+export declare function getS3Endpoint(region: Region): string;
+export {};

SerpentRace_Backend/node_modules/minio/dist/main/internal/s3-endpoints.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getS3Endpoint = getS3Endpoint;
+var _helper = require("./helper.js");
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, 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.
+ */
+
+// List of currently supported endpoints.
+const awsS3Endpoint = {
+  'af-south-1': 's3.af-south-1.amazonaws.com',
+  'ap-east-1': 's3.ap-east-1.amazonaws.com',
+  'ap-south-1': 's3.ap-south-1.amazonaws.com',
+  'ap-south-2': 's3.ap-south-2.amazonaws.com',
+  'ap-southeast-1': 's3.ap-southeast-1.amazonaws.com',
+  'ap-southeast-2': 's3.ap-southeast-2.amazonaws.com',
+  'ap-southeast-3': 's3.ap-southeast-3.amazonaws.com',
+  'ap-southeast-4': 's3.ap-southeast-4.amazonaws.com',
+  'ap-southeast-5': 's3.ap-southeast-5.amazonaws.com',
+  'ap-northeast-1': 's3.ap-northeast-1.amazonaws.com',
+  'ap-northeast-2': 's3.ap-northeast-2.amazonaws.com',
+  'ap-northeast-3': 's3.ap-northeast-3.amazonaws.com',
+  'ca-central-1': 's3.ca-central-1.amazonaws.com',
+  'ca-west-1': 's3.ca-west-1.amazonaws.com',
+  'cn-north-1': 's3.cn-north-1.amazonaws.com.cn',
+  'eu-central-1': 's3.eu-central-1.amazonaws.com',
+  'eu-central-2': 's3.eu-central-2.amazonaws.com',
+  'eu-north-1': 's3.eu-north-1.amazonaws.com',
+  'eu-south-1': 's3.eu-south-1.amazonaws.com',
+  'eu-south-2': 's3.eu-south-2.amazonaws.com',
+  'eu-west-1': 's3.eu-west-1.amazonaws.com',
+  'eu-west-2': 's3.eu-west-2.amazonaws.com',
+  'eu-west-3': 's3.eu-west-3.amazonaws.com',
+  'il-central-1': 's3.il-central-1.amazonaws.com',
+  'me-central-1': 's3.me-central-1.amazonaws.com',
+  'me-south-1': 's3.me-south-1.amazonaws.com',
+  'sa-east-1': 's3.sa-east-1.amazonaws.com',
+  'us-east-1': 's3.us-east-1.amazonaws.com',
+  'us-east-2': 's3.us-east-2.amazonaws.com',
+  'us-west-1': 's3.us-west-1.amazonaws.com',
+  'us-west-2': 's3.us-west-2.amazonaws.com',
+  'us-gov-east-1': 's3.us-gov-east-1.amazonaws.com',
+  'us-gov-west-1': 's3.us-gov-west-1.amazonaws.com'
+  // Add new endpoints here.
+};
+
+// getS3Endpoint get relevant endpoint for the region.
+function getS3Endpoint(region) {
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError(`Invalid region: ${region}`);
+  }
+  const endpoint = awsS3Endpoint[region];
+  if (endpoint) {
+    return endpoint;
+  }
+  return 's3.amazonaws.com';
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/type.d.ts

@@ -0,0 +1,447 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as http from 'node:http';
+import type { Readable as ReadableStream } from 'node:stream';
+import type { CopyDestinationOptions, CopySourceOptions } from "../helpers.js";
+import type { CopyConditions } from "./copy-conditions.js";
+export type VersionIdentificator = {
+  versionId?: string;
+};
+export type GetObjectOpts = VersionIdentificator & {
+  SSECustomerAlgorithm?: string;
+  SSECustomerKey?: string;
+  SSECustomerKeyMD5?: string;
+};
+export type Binary = string | Buffer;
+export type ResponseHeader = Record<string, string>;
+export type ObjectMetaData = Record<string, string | number>;
+export type RequestHeaders = Record<string, string | boolean | number | undefined>;
+export type Encryption = {
+  type: ENCRYPTION_TYPES.SSEC;
+} | {
+  type: ENCRYPTION_TYPES.KMS;
+  SSEAlgorithm?: string;
+  KMSMasterKeyID?: string;
+};
+export type EnabledOrDisabledStatus = 'Enabled' | 'Disabled';
+export declare enum ENCRYPTION_TYPES {
+  /**
+   * SSEC represents server-side-encryption with customer provided keys
+   */
+  SSEC = "SSE-C",
+  /**
+   * KMS represents server-side-encryption with managed keys
+   */
+  KMS = "KMS",
+}
+export declare enum RETENTION_MODES {
+  GOVERNANCE = "GOVERNANCE",
+  COMPLIANCE = "COMPLIANCE",
+}
+export declare enum RETENTION_VALIDITY_UNITS {
+  DAYS = "Days",
+  YEARS = "Years",
+}
+export declare enum LEGAL_HOLD_STATUS {
+  ENABLED = "ON",
+  DISABLED = "OFF",
+}
+export type Transport = Pick<typeof http, 'request'>;
+export interface IRequest {
+  protocol: string;
+  port?: number | string;
+  method: string;
+  path: string;
+  headers: RequestHeaders;
+}
+export type ICanonicalRequest = string;
+export interface IncompleteUploadedBucketItem {
+  key: string;
+  uploadId: string;
+  size: number;
+}
+export interface MetadataItem {
+  Key: string;
+  Value: string;
+}
+export interface ItemBucketMetadataList {
+  Items: MetadataItem[];
+}
+export interface ItemBucketMetadata {
+  [key: string]: any;
+}
+export interface ItemBucketTags {
+  [key: string]: any;
+}
+export interface BucketItemFromList {
+  name: string;
+  creationDate: Date;
+}
+export interface BucketItemCopy {
+  etag: string;
+  lastModified: Date;
+}
+export type BucketItem = {
+  name: string;
+  size: number;
+  etag: string;
+  prefix?: never;
+  lastModified: Date;
+} | {
+  name?: never;
+  etag?: never;
+  lastModified?: never;
+  prefix: string;
+  size: 0;
+};
+export type BucketItemWithMetadata = BucketItem & {
+  metadata?: ItemBucketMetadata | ItemBucketMetadataList;
+  tags?: ItemBucketTags;
+};
+export interface BucketStream<T> extends ReadableStream {
+  on(event: 'data', listener: (item: T) => void): this;
+  on(event: 'end' | 'pause' | 'readable' | 'resume' | 'close', listener: () => void): this;
+  on(event: 'error', listener: (err: Error) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+export interface BucketItemStat {
+  size: number;
+  etag: string;
+  lastModified: Date;
+  metaData: ItemBucketMetadata;
+  versionId?: string | null;
+}
+export type StatObjectOpts = {
+  versionId?: string;
+};
+export type ReplicationRuleStatus = {
+  Status: EnabledOrDisabledStatus;
+};
+export type Tag = {
+  Key: string;
+  Value: string;
+};
+export type Tags = Record<string, string>;
+export type ReplicationRuleDestination = {
+  Bucket: string;
+  StorageClass: string;
+};
+export type ReplicationRuleAnd = {
+  Prefix: string;
+  Tags: Tag[];
+};
+export type ReplicationRuleFilter = {
+  Prefix: string;
+  And: ReplicationRuleAnd;
+  Tag: Tag;
+};
+export type ReplicaModifications = {
+  Status: ReplicationRuleStatus;
+};
+export type SourceSelectionCriteria = {
+  ReplicaModifications: ReplicaModifications;
+};
+export type ExistingObjectReplication = {
+  Status: ReplicationRuleStatus;
+};
+export type ReplicationRule = {
+  ID: string;
+  Status: ReplicationRuleStatus;
+  Priority: number;
+  DeleteMarkerReplication: ReplicationRuleStatus;
+  DeleteReplication: ReplicationRuleStatus;
+  Destination: ReplicationRuleDestination;
+  Filter: ReplicationRuleFilter;
+  SourceSelectionCriteria: SourceSelectionCriteria;
+  ExistingObjectReplication: ExistingObjectReplication;
+};
+export type ReplicationConfigOpts = {
+  role: string;
+  rules: ReplicationRule[];
+};
+export type ReplicationConfig = {
+  ReplicationConfiguration: ReplicationConfigOpts;
+};
+export type ResultCallback<T> = (error: Error | null, result: T) => void;
+export type GetObjectLegalHoldOptions = {
+  versionId: string;
+};
+/**
+ * @deprecated keep for backward compatible, use `LEGAL_HOLD_STATUS` instead
+ */
+export type LegalHoldStatus = LEGAL_HOLD_STATUS;
+export type PutObjectLegalHoldOptions = {
+  versionId?: string;
+  status: LEGAL_HOLD_STATUS;
+};
+export interface UploadedObjectInfo {
+  etag: string;
+  versionId: string | null;
+}
+export interface RetentionOptions {
+  versionId: string;
+  mode?: RETENTION_MODES;
+  retainUntilDate?: IsoDate;
+  governanceBypass?: boolean;
+}
+export type Retention = RetentionOptions | EmptyObject;
+export type IsoDate = string;
+export type EmptyObject = Record<string, never>;
+export type ObjectLockInfo = {
+  objectLockEnabled: EnabledOrDisabledStatus;
+  mode: RETENTION_MODES;
+  unit: RETENTION_VALIDITY_UNITS;
+  validity: number;
+} | EmptyObject;
+export type ObjectLockConfigParam = {
+  ObjectLockEnabled?: 'Enabled' | undefined;
+  Rule?: {
+    DefaultRetention: {
+      Mode: RETENTION_MODES;
+      Days: number;
+      Years: number;
+    } | EmptyObject;
+  } | EmptyObject;
+};
+export type VersioningEnabled = 'Enabled';
+export type VersioningSuspended = 'Suspended';
+export type TaggingOpts = {
+  versionId: string;
+};
+export type PutTaggingParams = {
+  bucketName: string;
+  objectName?: string;
+  tags: Tags;
+  putOpts?: TaggingOpts;
+};
+export type RemoveTaggingParams = {
+  bucketName: string;
+  objectName?: string;
+  removeOpts?: TaggingOpts;
+};
+export type InputSerialization = {
+  CompressionType?: 'NONE' | 'GZIP' | 'BZIP2';
+  CSV?: {
+    AllowQuotedRecordDelimiter?: boolean;
+    Comments?: string;
+    FieldDelimiter?: string;
+    FileHeaderInfo?: 'NONE' | 'IGNORE' | 'USE';
+    QuoteCharacter?: string;
+    QuoteEscapeCharacter?: string;
+    RecordDelimiter?: string;
+  };
+  JSON?: {
+    Type: 'DOCUMENT' | 'LINES';
+  };
+  Parquet?: EmptyObject;
+};
+export type OutputSerialization = {
+  CSV?: {
+    FieldDelimiter?: string;
+    QuoteCharacter?: string;
+    QuoteEscapeCharacter?: string;
+    QuoteFields?: string;
+    RecordDelimiter?: string;
+  };
+  JSON?: {
+    RecordDelimiter?: string;
+  };
+};
+export type SelectProgress = {
+  Enabled: boolean;
+};
+export type ScanRange = {
+  Start: number;
+  End: number;
+};
+export type SelectOptions = {
+  expression: string;
+  expressionType?: string;
+  inputSerialization: InputSerialization;
+  outputSerialization: OutputSerialization;
+  requestProgress?: SelectProgress;
+  scanRange?: ScanRange;
+};
+export type Expiration = {
+  Date?: string;
+  Days: number;
+  DeleteMarker?: boolean;
+  DeleteAll?: boolean;
+};
+export type RuleFilterAnd = {
+  Prefix: string;
+  Tags: Tag[];
+};
+export type RuleFilter = {
+  And?: RuleFilterAnd;
+  Prefix: string;
+  Tag?: Tag[];
+};
+export type NoncurrentVersionExpiration = {
+  NoncurrentDays: number;
+  NewerNoncurrentVersions?: number;
+};
+export type NoncurrentVersionTransition = {
+  StorageClass: string;
+  NoncurrentDays?: number;
+  NewerNoncurrentVersions?: number;
+};
+export type Transition = {
+  Date?: string;
+  StorageClass: string;
+  Days: number;
+};
+export type AbortIncompleteMultipartUpload = {
+  DaysAfterInitiation: number;
+};
+export type LifecycleRule = {
+  AbortIncompleteMultipartUpload?: AbortIncompleteMultipartUpload;
+  ID: string;
+  Prefix?: string;
+  Status?: string;
+  Expiration?: Expiration;
+  Filter?: RuleFilter;
+  NoncurrentVersionExpiration?: NoncurrentVersionExpiration;
+  NoncurrentVersionTransition?: NoncurrentVersionTransition;
+  Transition?: Transition;
+};
+export type LifecycleConfig = {
+  Rule: LifecycleRule[];
+};
+export type LifeCycleConfigParam = LifecycleConfig | null | undefined | '';
+export type ApplySSEByDefault = {
+  KmsMasterKeyID?: string;
+  SSEAlgorithm: string;
+};
+export type EncryptionRule = {
+  ApplyServerSideEncryptionByDefault?: ApplySSEByDefault;
+};
+export type EncryptionConfig = {
+  Rule: EncryptionRule[];
+};
+export type GetObjectRetentionOpts = {
+  versionId: string;
+};
+export type ObjectRetentionInfo = {
+  mode: RETENTION_MODES;
+  retainUntilDate: string;
+};
+export type RemoveObjectsEntry = {
+  name: string;
+  versionId?: string;
+};
+export type ObjectName = string;
+export type RemoveObjectsParam = ObjectName[] | RemoveObjectsEntry[];
+export type RemoveObjectsRequestEntry = {
+  Key: string;
+  VersionId?: string;
+};
+export type RemoveObjectsResponse = null | undefined | {
+  Error?: {
+    Code?: string;
+    Message?: string;
+    Key?: string;
+    VersionId?: string;
+  };
+};
+export type CopyObjectResultV1 = {
+  etag: string;
+  lastModified: string | Date;
+};
+export type CopyObjectResultV2 = {
+  Bucket?: string;
+  Key?: string;
+  LastModified: string | Date;
+  MetaData?: ResponseHeader;
+  VersionId?: string | null;
+  SourceVersionId?: string | null;
+  Etag?: string;
+  Size?: number;
+};
+export type CopyObjectResult = CopyObjectResultV1 | CopyObjectResultV2;
+export type CopyObjectParams = [CopySourceOptions, CopyDestinationOptions] | [string, string, string, CopyConditions?];
+export type ExcludedPrefix = {
+  Prefix: string;
+};
+export type BucketVersioningConfiguration = {
+  Status: VersioningEnabled | VersioningSuspended;
+  MFADelete?: string;
+  ExcludedPrefixes?: ExcludedPrefix[];
+  ExcludeFolders?: boolean;
+};
+export type UploadPartConfig = {
+  bucketName: string;
+  objectName: string;
+  uploadID: string;
+  partNumber: number;
+  headers: RequestHeaders;
+  sourceObj: string;
+};
+export type PreSignRequestParams = {
+  [key: string]: string;
+};
+/** List object api types **/
+export type CommonPrefix = {
+  Prefix: string;
+};
+export type Owner = {
+  ID: string;
+  DisplayName: string;
+};
+export type Metadata = {
+  Items: MetadataItem[];
+};
+export type ObjectInfo = {
+  key?: string;
+  name?: string;
+  lastModified?: Date;
+  etag?: string;
+  owner?: Owner;
+  storageClass?: string;
+  userMetadata?: Metadata;
+  userTags?: string;
+  prefix?: string;
+  size?: number;
+};
+export type ListObjectQueryRes = {
+  isTruncated?: boolean;
+  nextMarker?: string;
+  versionIdMarker?: string;
+  objects?: ObjectInfo[];
+};
+export type ListObjectQueryOpts = {
+  Delimiter?: string;
+  MaxKeys?: number;
+  IncludeVersion?: boolean;
+};
+/** List object api types **/
+export type ObjectVersionEntry = {
+  IsLatest?: string;
+  VersionId?: string;
+};
+export type ObjectRowEntry = ObjectVersionEntry & {
+  Key: string;
+  LastModified?: Date | undefined;
+  ETag?: string;
+  Size?: string;
+  Owner?: Owner;
+  StorageClass?: string;
+};
+export interface ListBucketResultV1 {
+  Name?: string;
+  Prefix?: string;
+  ContinuationToken?: string;
+  KeyCount?: string;
+  Marker?: string;
+  MaxKeys?: string;
+  Delimiter?: string;
+  IsTruncated?: boolean;
+  Contents?: ObjectRowEntry[];
+  NextKeyMarker?: string;
+  CommonPrefixes?: CommonPrefix[];
+  Version?: ObjectRowEntry[];
+  DeleteMarker?: ObjectRowEntry[];
+  VersionIdMarker?: string;
+  NextVersionIdMarker?: string;
+}

SerpentRace_Backend/node_modules/minio/dist/main/internal/type.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// nodejs IncomingHttpHeaders is Record<string, string | string[]>, but it's actually this:
+let ENCRYPTION_TYPES = /*#__PURE__*/function (ENCRYPTION_TYPES) {
+  ENCRYPTION_TYPES["SSEC"] = "SSE-C";
+  ENCRYPTION_TYPES["KMS"] = "KMS";
+  return ENCRYPTION_TYPES;
+}({});
+exports.ENCRYPTION_TYPES = ENCRYPTION_TYPES;
+let RETENTION_MODES = /*#__PURE__*/function (RETENTION_MODES) {
+  RETENTION_MODES["GOVERNANCE"] = "GOVERNANCE";
+  RETENTION_MODES["COMPLIANCE"] = "COMPLIANCE";
+  return RETENTION_MODES;
+}({});
+exports.RETENTION_MODES = RETENTION_MODES;
+let RETENTION_VALIDITY_UNITS = /*#__PURE__*/function (RETENTION_VALIDITY_UNITS) {
+  RETENTION_VALIDITY_UNITS["DAYS"] = "Days";
+  RETENTION_VALIDITY_UNITS["YEARS"] = "Years";
+  return RETENTION_VALIDITY_UNITS;
+}({});
+exports.RETENTION_VALIDITY_UNITS = RETENTION_VALIDITY_UNITS;
+let LEGAL_HOLD_STATUS = /*#__PURE__*/function (LEGAL_HOLD_STATUS) {
+  LEGAL_HOLD_STATUS["ENABLED"] = "ON";
+  LEGAL_HOLD_STATUS["DISABLED"] = "OFF";
+  return LEGAL_HOLD_STATUS;
+}({});
+/* Replication Config types */
+/* Replication Config types */
+/**
+ * @deprecated keep for backward compatible, use `LEGAL_HOLD_STATUS` instead
+ */
+/** List object api types **/
+// Common types
+/** List object api types **/
+exports.LEGAL_HOLD_STATUS = LEGAL_HOLD_STATUS;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/internal/xml-parser.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as http from 'node:http';
+import { SelectResults } from "../helpers.js";
+import type { BucketItemFromList, BucketItemWithMetadata, CopyObjectResultV1, ObjectInfo, ObjectLockInfo, ReplicationConfig } from "./type.js";
+export declare function parseBucketRegion(xml: string): string;
+export declare function parseError(xml: string, headerInfo: Record<string, unknown>): Record<string, unknown>;
+export declare function parseResponseError(response: http.IncomingMessage): Promise<Record<string, string>>;
+/**
+ * parse XML response for list objects v2 with metadata in a bucket
+ */
+export declare function parseListObjectsV2WithMetadata(xml: string): {
+  objects: Array<BucketItemWithMetadata>;
+  isTruncated: boolean;
+  nextContinuationToken: string;
+};
+export type UploadedPart = {
+  part: number;
+  lastModified?: Date;
+  etag: string;
+  size: number;
+};
+export declare function parseListParts(xml: string): {
+  isTruncated: boolean;
+  marker: number;
+  parts: UploadedPart[];
+};
+export declare function parseListBucket(xml: string): BucketItemFromList[];
+export declare function parseInitiateMultipart(xml: string): string;
+export declare function parseReplicationConfig(xml: string): ReplicationConfig;
+export declare function parseObjectLegalHoldConfig(xml: string): any;
+export declare function parseTagging(xml: string): any;
+export declare function parseCompleteMultipart(xml: string): {
+  location: any;
+  bucket: any;
+  key: any;
+  etag: any;
+  errCode?: undefined;
+  errMessage?: undefined;
+} | {
+  errCode: any;
+  errMessage: any;
+  location?: undefined;
+  bucket?: undefined;
+  key?: undefined;
+  etag?: undefined;
+} | undefined;
+type UploadID = string;
+export type ListMultipartResult = {
+  uploads: {
+    key: string;
+    uploadId: UploadID;
+    initiator?: {
+      id: string;
+      displayName: string;
+    };
+    owner?: {
+      id: string;
+      displayName: string;
+    };
+    storageClass: unknown;
+    initiated: Date;
+  }[];
+  prefixes: {
+    prefix: string;
+  }[];
+  isTruncated: boolean;
+  nextKeyMarker: string;
+  nextUploadIdMarker: string;
+};
+export declare function parseListMultipart(xml: string): ListMultipartResult;
+export declare function parseObjectLockConfig(xml: string): ObjectLockInfo;
+export declare function parseBucketVersioningConfig(xml: string): any;
+export declare function parseSelectObjectContentResponse(res: Buffer): SelectResults | undefined;
+export declare function parseLifecycleConfig(xml: string): any;
+export declare function parseBucketEncryptionConfig(xml: string): any;
+export declare function parseObjectRetentionConfig(xml: string): {
+  mode: any;
+  retainUntilDate: any;
+};
+export declare function removeObjectsParser(xml: string): any[];
+export declare function parseCopyObject(xml: string): CopyObjectResultV1;
+export declare function parseListObjects(xml: string): {
+  objects: ObjectInfo[];
+  isTruncated?: boolean | undefined;
+  nextMarker?: string | undefined;
+  versionIdMarker?: string | undefined;
+};
+export declare function uploadPartParser(xml: string): any;
+export {};

SerpentRace_Backend/node_modules/minio/dist/main/internal/xml-parser.js

@@ -0,0 +1,719 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseBucketEncryptionConfig = parseBucketEncryptionConfig;
+exports.parseBucketRegion = parseBucketRegion;
+exports.parseBucketVersioningConfig = parseBucketVersioningConfig;
+exports.parseCompleteMultipart = parseCompleteMultipart;
+exports.parseCopyObject = parseCopyObject;
+exports.parseError = parseError;
+exports.parseInitiateMultipart = parseInitiateMultipart;
+exports.parseLifecycleConfig = parseLifecycleConfig;
+exports.parseListBucket = parseListBucket;
+exports.parseListMultipart = parseListMultipart;
+exports.parseListObjects = parseListObjects;
+exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata;
+exports.parseListParts = parseListParts;
+exports.parseObjectLegalHoldConfig = parseObjectLegalHoldConfig;
+exports.parseObjectLockConfig = parseObjectLockConfig;
+exports.parseObjectRetentionConfig = parseObjectRetentionConfig;
+exports.parseReplicationConfig = parseReplicationConfig;
+exports.parseResponseError = parseResponseError;
+exports.parseSelectObjectContentResponse = parseSelectObjectContentResponse;
+exports.parseTagging = parseTagging;
+exports.removeObjectsParser = removeObjectsParser;
+exports.uploadPartParser = uploadPartParser;
+var _bufferCrc = require("buffer-crc32");
+var _fastXmlParser = require("fast-xml-parser");
+var errors = _interopRequireWildcard(require("../errors.js"), true);
+var _helpers = require("../helpers.js");
+var _helper = require("./helper.js");
+var _response = require("./response.js");
+var _type = require("./type.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; }
+// parse XML response for bucket region
+function parseBucketRegion(xml) {
+  // return region information
+  return (0, _helper.parseXml)(xml).LocationConstraint;
+}
+const fxp = new _fastXmlParser.XMLParser();
+const fxpWithoutNumParser = new _fastXmlParser.XMLParser({
+  // @ts-ignore
+  numberParseOptions: {
+    skipLike: /./
+  }
+});
+
+// Parse XML and return information as Javascript types
+// parse error XML response
+function parseError(xml, headerInfo) {
+  let xmlErr = {};
+  const xmlObj = fxp.parse(xml);
+  if (xmlObj.Error) {
+    xmlErr = xmlObj.Error;
+  }
+  const e = new errors.S3Error();
+  Object.entries(xmlErr).forEach(([key, value]) => {
+    e[key.toLowerCase()] = value;
+  });
+  Object.entries(headerInfo).forEach(([key, value]) => {
+    e[key] = value;
+  });
+  return e;
+}
+
+// Generates an Error object depending on http statusCode and XML body
+async function parseResponseError(response) {
+  const statusCode = response.statusCode;
+  let code = '',
+    message = '';
+  if (statusCode === 301) {
+    code = 'MovedPermanently';
+    message = 'Moved Permanently';
+  } else if (statusCode === 307) {
+    code = 'TemporaryRedirect';
+    message = 'Are you using the correct endpoint URL?';
+  } else if (statusCode === 403) {
+    code = 'AccessDenied';
+    message = 'Valid and authorized credentials required';
+  } else if (statusCode === 404) {
+    code = 'NotFound';
+    message = 'Not Found';
+  } else if (statusCode === 405) {
+    code = 'MethodNotAllowed';
+    message = 'Method Not Allowed';
+  } else if (statusCode === 501) {
+    code = 'MethodNotAllowed';
+    message = 'Method Not Allowed';
+  } else if (statusCode === 503) {
+    code = 'SlowDown';
+    message = 'Please reduce your request rate.';
+  } else {
+    const hErrCode = response.headers['x-minio-error-code'];
+    const hErrDesc = response.headers['x-minio-error-desc'];
+    if (hErrCode && hErrDesc) {
+      code = hErrCode;
+      message = hErrDesc;
+    }
+  }
+  const headerInfo = {};
+  // A value created by S3 compatible server that uniquely identifies the request.
+  headerInfo.amzRequestid = response.headers['x-amz-request-id'];
+  // A special token that helps troubleshoot API replies and issues.
+  headerInfo.amzId2 = response.headers['x-amz-id-2'];
+
+  // Region where the bucket is located. This header is returned only
+  // in HEAD bucket and ListObjects response.
+  headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region'];
+  const xmlString = await (0, _response.readAsString)(response);
+  if (xmlString) {
+    throw parseError(xmlString, headerInfo);
+  }
+
+  // Message should be instantiated for each S3Errors.
+  const e = new errors.S3Error(message, {
+    cause: headerInfo
+  });
+  // S3 Error code.
+  e.code = code;
+  Object.entries(headerInfo).forEach(([key, value]) => {
+    // @ts-expect-error force set error properties
+    e[key] = value;
+  });
+  throw e;
+}
+
+/**
+ * parse XML response for list objects v2 with metadata in a bucket
+ */
+function parseListObjectsV2WithMetadata(xml) {
+  const result = {
+    objects: [],
+    isTruncated: false,
+    nextContinuationToken: ''
+  };
+  let xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.ListBucketResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"');
+  }
+  xmlobj = xmlobj.ListBucketResult;
+  if (xmlobj.IsTruncated) {
+    result.isTruncated = xmlobj.IsTruncated;
+  }
+  if (xmlobj.NextContinuationToken) {
+    result.nextContinuationToken = xmlobj.NextContinuationToken;
+  }
+  if (xmlobj.Contents) {
+    (0, _helper.toArray)(xmlobj.Contents).forEach(content => {
+      const name = (0, _helper.sanitizeObjectKey)(content.Key);
+      const lastModified = new Date(content.LastModified);
+      const etag = (0, _helper.sanitizeETag)(content.ETag);
+      const size = content.Size;
+      let tags = {};
+      if (content.UserTags != null) {
+        (0, _helper.toArray)(content.UserTags.split('&')).forEach(tag => {
+          const [key, value] = tag.split('=');
+          tags[key] = value;
+        });
+      } else {
+        tags = {};
+      }
+      let metadata;
+      if (content.UserMetadata != null) {
+        metadata = (0, _helper.toArray)(content.UserMetadata)[0];
+      } else {
+        metadata = null;
+      }
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size,
+        metadata,
+        tags
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+// parse XML response for list parts of an in progress multipart upload
+function parseListParts(xml) {
+  let xmlobj = (0, _helper.parseXml)(xml);
+  const result = {
+    isTruncated: false,
+    parts: [],
+    marker: 0
+  };
+  if (!xmlobj.ListPartsResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"');
+  }
+  xmlobj = xmlobj.ListPartsResult;
+  if (xmlobj.IsTruncated) {
+    result.isTruncated = xmlobj.IsTruncated;
+  }
+  if (xmlobj.NextPartNumberMarker) {
+    result.marker = (0, _helper.toArray)(xmlobj.NextPartNumberMarker)[0] || '';
+  }
+  if (xmlobj.Part) {
+    (0, _helper.toArray)(xmlobj.Part).forEach(p => {
+      const part = parseInt((0, _helper.toArray)(p.PartNumber)[0], 10);
+      const lastModified = new Date(p.LastModified);
+      const etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
+      result.parts.push({
+        part,
+        lastModified,
+        etag,
+        size: parseInt(p.Size, 10)
+      });
+    });
+  }
+  return result;
+}
+function parseListBucket(xml) {
+  let result = [];
+  const listBucketResultParser = new _fastXmlParser.XMLParser({
+    parseTagValue: true,
+    // Enable parsing of values
+    numberParseOptions: {
+      leadingZeros: false,
+      // Disable number parsing for values with leading zeros
+      hex: false,
+      // Disable hex number parsing - Invalid bucket name
+      skipLike: /^[0-9]+$/ // Skip number parsing if the value consists entirely of digits
+    },
+
+    tagValueProcessor: (tagName, tagValue = '') => {
+      // Ensure that the Name tag is always treated as a string
+      if (tagName === 'Name') {
+        return tagValue.toString();
+      }
+      return tagValue;
+    },
+    ignoreAttributes: false // Ensure that all attributes are parsed
+  });
+
+  const parsedXmlRes = listBucketResultParser.parse(xml);
+  if (!parsedXmlRes.ListAllMyBucketsResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"');
+  }
+  const {
+    ListAllMyBucketsResult: {
+      Buckets = {}
+    } = {}
+  } = parsedXmlRes;
+  if (Buckets.Bucket) {
+    result = (0, _helper.toArray)(Buckets.Bucket).map((bucket = {}) => {
+      const {
+        Name: bucketName,
+        CreationDate
+      } = bucket;
+      const creationDate = new Date(CreationDate);
+      return {
+        name: bucketName,
+        creationDate
+      };
+    });
+  }
+  return result;
+}
+function parseInitiateMultipart(xml) {
+  let xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.InitiateMultipartUploadResult) {
+    throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"');
+  }
+  xmlobj = xmlobj.InitiateMultipartUploadResult;
+  if (xmlobj.UploadId) {
+    return xmlobj.UploadId;
+  }
+  throw new errors.InvalidXMLError('Missing tag: "UploadId"');
+}
+function parseReplicationConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  const {
+    Role,
+    Rule
+  } = xmlObj.ReplicationConfiguration;
+  return {
+    ReplicationConfiguration: {
+      role: Role,
+      rules: (0, _helper.toArray)(Rule)
+    }
+  };
+}
+function parseObjectLegalHoldConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  return xmlObj.LegalHold;
+}
+function parseTagging(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  let result = [];
+  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {
+    const tagResult = xmlObj.Tagging.TagSet.Tag;
+    // if it is a single tag convert into an array so that the return value is always an array.
+    if ((0, _helper.isObject)(tagResult)) {
+      result.push(tagResult);
+    } else {
+      result = tagResult;
+    }
+  }
+  return result;
+}
+
+// parse XML response when a multipart upload is completed
+function parseCompleteMultipart(xml) {
+  const xmlobj = (0, _helper.parseXml)(xml).CompleteMultipartUploadResult;
+  if (xmlobj.Location) {
+    const location = (0, _helper.toArray)(xmlobj.Location)[0];
+    const bucket = (0, _helper.toArray)(xmlobj.Bucket)[0];
+    const key = xmlobj.Key;
+    const etag = xmlobj.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
+    return {
+      location,
+      bucket,
+      key,
+      etag
+    };
+  }
+  // Complete Multipart can return XML Error after a 200 OK response
+  if (xmlobj.Code && xmlobj.Message) {
+    const errCode = (0, _helper.toArray)(xmlobj.Code)[0];
+    const errMessage = (0, _helper.toArray)(xmlobj.Message)[0];
+    return {
+      errCode,
+      errMessage
+    };
+  }
+}
+// parse XML response for listing in-progress multipart uploads
+function parseListMultipart(xml) {
+  const result = {
+    prefixes: [],
+    uploads: [],
+    isTruncated: false,
+    nextKeyMarker: '',
+    nextUploadIdMarker: ''
+  };
+  let xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.ListMultipartUploadsResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListMultipartUploadsResult"');
+  }
+  xmlobj = xmlobj.ListMultipartUploadsResult;
+  if (xmlobj.IsTruncated) {
+    result.isTruncated = xmlobj.IsTruncated;
+  }
+  if (xmlobj.NextKeyMarker) {
+    result.nextKeyMarker = xmlobj.NextKeyMarker;
+  }
+  if (xmlobj.NextUploadIdMarker) {
+    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || '';
+  }
+  if (xmlobj.CommonPrefixes) {
+    (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(prefix => {
+      // @ts-expect-error index check
+      result.prefixes.push({
+        prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(prefix.Prefix)[0])
+      });
+    });
+  }
+  if (xmlobj.Upload) {
+    (0, _helper.toArray)(xmlobj.Upload).forEach(upload => {
+      const uploadItem = {
+        key: upload.Key,
+        uploadId: upload.UploadId,
+        storageClass: upload.StorageClass,
+        initiated: new Date(upload.Initiated)
+      };
+      if (upload.Initiator) {
+        uploadItem.initiator = {
+          id: upload.Initiator.ID,
+          displayName: upload.Initiator.DisplayName
+        };
+      }
+      if (upload.Owner) {
+        uploadItem.owner = {
+          id: upload.Owner.ID,
+          displayName: upload.Owner.DisplayName
+        };
+      }
+      result.uploads.push(uploadItem);
+    });
+  }
+  return result;
+}
+function parseObjectLockConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  let lockConfigResult = {};
+  if (xmlObj.ObjectLockConfiguration) {
+    lockConfigResult = {
+      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled
+    };
+    let retentionResp;
+    if (xmlObj.ObjectLockConfiguration && xmlObj.ObjectLockConfiguration.Rule && xmlObj.ObjectLockConfiguration.Rule.DefaultRetention) {
+      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {};
+      lockConfigResult.mode = retentionResp.Mode;
+    }
+    if (retentionResp) {
+      const isUnitYears = retentionResp.Years;
+      if (isUnitYears) {
+        lockConfigResult.validity = isUnitYears;
+        lockConfigResult.unit = _type.RETENTION_VALIDITY_UNITS.YEARS;
+      } else {
+        lockConfigResult.validity = retentionResp.Days;
+        lockConfigResult.unit = _type.RETENTION_VALIDITY_UNITS.DAYS;
+      }
+    }
+  }
+  return lockConfigResult;
+}
+function parseBucketVersioningConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  return xmlObj.VersioningConfiguration;
+}
+
+// Used only in selectObjectContent API.
+// extractHeaderType extracts the first half of the header message, the header type.
+function extractHeaderType(stream) {
+  const headerNameLen = Buffer.from(stream.read(1)).readUInt8();
+  const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString();
+  const splitBySeparator = (headerNameWithSeparator || '').split(':');
+  return splitBySeparator.length >= 1 ? splitBySeparator[1] : '';
+}
+function extractHeaderValue(stream) {
+  const bodyLen = Buffer.from(stream.read(2)).readUInt16BE();
+  return Buffer.from(stream.read(bodyLen)).toString();
+}
+function parseSelectObjectContentResponse(res) {
+  const selectResults = new _helpers.SelectResults({}); // will be returned
+
+  const responseStream = (0, _helper.readableStream)(res); // convert byte array to a readable responseStream
+  // @ts-ignore
+  while (responseStream._readableState.length) {
+    // Top level responseStream read tracker.
+    let msgCrcAccumulator; // accumulate from start of the message till the message crc start.
+
+    const totalByteLengthBuffer = Buffer.from(responseStream.read(4));
+    msgCrcAccumulator = _bufferCrc(totalByteLengthBuffer);
+    const headerBytesBuffer = Buffer.from(responseStream.read(4));
+    msgCrcAccumulator = _bufferCrc(headerBytesBuffer, msgCrcAccumulator);
+    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE(); // use it to check if any CRC mismatch in header itself.
+
+    const preludeCrcBuffer = Buffer.from(responseStream.read(4)); // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)
+    msgCrcAccumulator = _bufferCrc(preludeCrcBuffer, msgCrcAccumulator);
+    const totalMsgLength = totalByteLengthBuffer.readInt32BE();
+    const headerLength = headerBytesBuffer.readInt32BE();
+    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE();
+    if (preludeCrcByteValue !== calculatedPreludeCrc) {
+      // Handle Header CRC mismatch Error
+      throw new Error(`Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`);
+    }
+    const headers = {};
+    if (headerLength > 0) {
+      const headerBytes = Buffer.from(responseStream.read(headerLength));
+      msgCrcAccumulator = _bufferCrc(headerBytes, msgCrcAccumulator);
+      const headerReaderStream = (0, _helper.readableStream)(headerBytes);
+      // @ts-ignore
+      while (headerReaderStream._readableState.length) {
+        const headerTypeName = extractHeaderType(headerReaderStream);
+        headerReaderStream.read(1); // just read and ignore it.
+        if (headerTypeName) {
+          headers[headerTypeName] = extractHeaderValue(headerReaderStream);
+        }
+      }
+    }
+    let payloadStream;
+    const payLoadLength = totalMsgLength - headerLength - 16;
+    if (payLoadLength > 0) {
+      const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength));
+      msgCrcAccumulator = _bufferCrc(payLoadBuffer, msgCrcAccumulator);
+      // read the checksum early and detect any mismatch so we can avoid unnecessary further processing.
+      const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE();
+      const calculatedCrc = msgCrcAccumulator.readInt32BE();
+      // Handle message CRC Error
+      if (messageCrcByteValue !== calculatedCrc) {
+        throw new Error(`Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`);
+      }
+      payloadStream = (0, _helper.readableStream)(payLoadBuffer);
+    }
+    const messageType = headers['message-type'];
+    switch (messageType) {
+      case 'error':
+        {
+          const errorMessage = headers['error-code'] + ':"' + headers['error-message'] + '"';
+          throw new Error(errorMessage);
+        }
+      case 'event':
+        {
+          const contentType = headers['content-type'];
+          const eventType = headers['event-type'];
+          switch (eventType) {
+            case 'End':
+              {
+                selectResults.setResponse(res);
+                return selectResults;
+              }
+            case 'Records':
+              {
+                var _payloadStream;
+                const readData = (_payloadStream = payloadStream) === null || _payloadStream === void 0 ? void 0 : _payloadStream.read(payLoadLength);
+                selectResults.setRecords(readData);
+                break;
+              }
+            case 'Progress':
+              {
+                switch (contentType) {
+                  case 'text/xml':
+                    {
+                      var _payloadStream2;
+                      const progressData = (_payloadStream2 = payloadStream) === null || _payloadStream2 === void 0 ? void 0 : _payloadStream2.read(payLoadLength);
+                      selectResults.setProgress(progressData.toString());
+                      break;
+                    }
+                  default:
+                    {
+                      const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`;
+                      throw new Error(errorMessage);
+                    }
+                }
+              }
+              break;
+            case 'Stats':
+              {
+                switch (contentType) {
+                  case 'text/xml':
+                    {
+                      var _payloadStream3;
+                      const statsData = (_payloadStream3 = payloadStream) === null || _payloadStream3 === void 0 ? void 0 : _payloadStream3.read(payLoadLength);
+                      selectResults.setStats(statsData.toString());
+                      break;
+                    }
+                  default:
+                    {
+                      const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`;
+                      throw new Error(errorMessage);
+                    }
+                }
+              }
+              break;
+            default:
+              {
+                // Continuation message: Not sure if it is supported. did not find a reference or any message in response.
+                // It does not have a payload.
+                const warningMessage = `Un implemented event detected  ${messageType}.`;
+                // eslint-disable-next-line no-console
+                console.warn(warningMessage);
+              }
+          }
+        }
+    }
+  }
+}
+function parseLifecycleConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  return xmlObj.LifecycleConfiguration;
+}
+function parseBucketEncryptionConfig(xml) {
+  return (0, _helper.parseXml)(xml);
+}
+function parseObjectRetentionConfig(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  const retentionConfig = xmlObj.Retention;
+  return {
+    mode: retentionConfig.Mode,
+    retainUntilDate: retentionConfig.RetainUntilDate
+  };
+}
+function removeObjectsParser(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {
+    // return errors as array always. as the response is object in case of single object passed in removeObjects
+    return (0, _helper.toArray)(xmlObj.DeleteResult.Error);
+  }
+  return [];
+}
+
+// parse XML response for copy object
+function parseCopyObject(xml) {
+  const result = {
+    etag: '',
+    lastModified: ''
+  };
+  let xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.CopyObjectResult) {
+    throw new errors.InvalidXMLError('Missing tag: "CopyObjectResult"');
+  }
+  xmlobj = xmlobj.CopyObjectResult;
+  if (xmlobj.ETag) {
+    result.etag = xmlobj.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
+  }
+  if (xmlobj.LastModified) {
+    result.lastModified = new Date(xmlobj.LastModified);
+  }
+  return result;
+}
+const formatObjInfo = (content, opts = {}) => {
+  const {
+    Key,
+    LastModified,
+    ETag,
+    Size,
+    VersionId,
+    IsLatest
+  } = content;
+  if (!(0, _helper.isObject)(opts)) {
+    opts = {};
+  }
+  const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(Key)[0] || '');
+  const lastModified = LastModified ? new Date((0, _helper.toArray)(LastModified)[0] || '') : undefined;
+  const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(ETag)[0] || '');
+  const size = (0, _helper.sanitizeSize)(Size || '');
+  return {
+    name,
+    lastModified,
+    etag,
+    size,
+    versionId: VersionId,
+    isLatest: IsLatest,
+    isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false
+  };
+};
+
+// parse XML response for list objects in a bucket
+function parseListObjects(xml) {
+  const result = {
+    objects: [],
+    isTruncated: false,
+    nextMarker: undefined,
+    versionIdMarker: undefined
+  };
+  let isTruncated = false;
+  let nextMarker, nextVersionKeyMarker;
+  const xmlobj = fxpWithoutNumParser.parse(xml);
+  const parseCommonPrefixesEntity = commonPrefixEntry => {
+    if (commonPrefixEntry) {
+      (0, _helper.toArray)(commonPrefixEntry).forEach(commonPrefix => {
+        result.objects.push({
+          prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0] || ''),
+          size: 0
+        });
+      });
+    }
+  };
+  const listBucketResult = xmlobj.ListBucketResult;
+  const listVersionsResult = xmlobj.ListVersionsResult;
+  if (listBucketResult) {
+    if (listBucketResult.IsTruncated) {
+      isTruncated = listBucketResult.IsTruncated;
+    }
+    if (listBucketResult.Contents) {
+      (0, _helper.toArray)(listBucketResult.Contents).forEach(content => {
+        const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(content.Key)[0] || '');
+        const lastModified = new Date((0, _helper.toArray)(content.LastModified)[0] || '');
+        const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(content.ETag)[0] || '');
+        const size = (0, _helper.sanitizeSize)(content.Size || '');
+        result.objects.push({
+          name,
+          lastModified,
+          etag,
+          size
+        });
+      });
+    }
+    if (listBucketResult.Marker) {
+      nextMarker = listBucketResult.Marker;
+    } else if (isTruncated && result.objects.length > 0) {
+      var _result$objects;
+      nextMarker = (_result$objects = result.objects[result.objects.length - 1]) === null || _result$objects === void 0 ? void 0 : _result$objects.name;
+    }
+    if (listBucketResult.CommonPrefixes) {
+      parseCommonPrefixesEntity(listBucketResult.CommonPrefixes);
+    }
+  }
+  if (listVersionsResult) {
+    if (listVersionsResult.IsTruncated) {
+      isTruncated = listVersionsResult.IsTruncated;
+    }
+    if (listVersionsResult.Version) {
+      (0, _helper.toArray)(listVersionsResult.Version).forEach(content => {
+        result.objects.push(formatObjInfo(content));
+      });
+    }
+    if (listVersionsResult.DeleteMarker) {
+      (0, _helper.toArray)(listVersionsResult.DeleteMarker).forEach(content => {
+        result.objects.push(formatObjInfo(content, {
+          IsDeleteMarker: true
+        }));
+      });
+    }
+    if (listVersionsResult.NextKeyMarker) {
+      nextVersionKeyMarker = listVersionsResult.NextKeyMarker;
+    }
+    if (listVersionsResult.NextVersionIdMarker) {
+      result.versionIdMarker = listVersionsResult.NextVersionIdMarker;
+    }
+    if (listVersionsResult.CommonPrefixes) {
+      parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes);
+    }
+  }
+  result.isTruncated = isTruncated;
+  if (isTruncated) {
+    result.nextMarker = nextVersionKeyMarker || nextMarker;
+  }
+  return result;
+}
+function uploadPartParser(xml) {
+  const xmlObj = (0, _helper.parseXml)(xml);
+  const respEl = xmlObj.CopyPartResult;
+  return respEl;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfYnVmZmVyQ3JjIiwicmVxdWlyZSIsIl9mYXN0WG1sUGFyc2VyIiwiZXJyb3JzIiwiX2ludGVyb3BSZXF1aXJlV2lsZGNhcmQiLCJfaGVscGVycyIsIl9oZWxwZXIiLCJfcmVzcG9uc2UiLCJfdHlwZSIsIl9nZXRSZXF1aXJlV2lsZGNhcmRDYWNoZSIsIm5vZGVJbnRlcm9wIiwiV2Vha01hcCIsImNhY2hlQmFiZWxJbnRlcm9wIiwiY2FjaGVOb2RlSW50ZXJvcCIsIm9iaiIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwiY2FjaGUiLCJoYXMiLCJnZXQiLCJuZXdPYmoiLCJoYXNQcm9wZXJ0eURlc2NyaXB0b3IiLCJPYmplY3QiLCJkZWZpbmVQcm9wZXJ0eSIsImdldE93blByb3BlcnR5RGVzY3JpcHRvciIsImtleSIsInByb3RvdHlwZSIsImhhc093blByb3BlcnR5IiwiY2FsbCIsImRlc2MiLCJzZXQiLCJwYXJzZUJ1Y2tldFJlZ2lvbiIsInhtbCIsInBhcnNlWG1sIiwiTG9jYXRpb25Db25zdHJhaW50IiwiZnhwIiwiWE1MUGFyc2VyIiwiZnhwV2l0aG91dE51bVBhcnNlciIsIm51bWJlclBhcnNlT3B0aW9ucyIsInNraXBMaWtlIiwicGFyc2VFcnJvciIsImhlYWRlckluZm8iLCJ4bWxFcnIiLCJ4bWxPYmoiLCJwYXJzZSIsIkVycm9yIiwiZSIsIlMzRXJyb3IiLCJlbnRyaWVzIiwiZm9yRWFjaCIsInZhbHVlIiwidG9Mb3dlckNhc2UiLCJwYXJzZVJlc3BvbnNlRXJyb3IiLCJyZXNwb25zZSIsInN0YXR1c0NvZGUiLCJjb2RlIiwibWVzc2FnZSIsImhFcnJDb2RlIiwiaGVhZGVycyIsImhFcnJEZXNjIiwiYW16UmVxdWVzdGlkIiwiYW16SWQyIiwiYW16QnVja2V0UmVnaW9uIiwieG1sU3RyaW5nIiwicmVhZEFzU3RyaW5nIiwiY2F1c2UiLCJwYXJzZUxpc3RPYmplY3RzVjJXaXRoTWV0YWRhdGEiLCJyZXN1bHQiLCJvYmplY3RzIiwiaXNUcnVuY2F0ZWQiLCJuZXh0Q29udGludWF0aW9uVG9rZW4iLCJ4bWxvYmoiLCJMaXN0QnVja2V0UmVzdWx0IiwiSW52YWxpZFhNTEVycm9yIiwiSXNUcnVuY2F0ZWQiLCJOZXh0Q29udGludWF0aW9uVG9rZW4iLCJDb250ZW50cyIsInRvQXJyYXkiLCJjb250ZW50IiwibmFtZSIsInNhbml0aXplT2JqZWN0S2V5IiwiS2V5IiwibGFzdE1vZGlmaWVkIiwiRGF0ZSIsIkxhc3RNb2RpZmllZCIsImV0YWciLCJzYW5pdGl6ZUVUYWciLCJFVGFnIiwic2l6ZSIsIlNpemUiLCJ0YWdzIiwiVXNlclRhZ3MiLCJzcGxpdCIsInRhZyIsIm1ldGFkYXRhIiwiVXNlck1ldGFkYXRhIiwicHVzaCIsIkNvbW1vblByZWZpeGVzIiwiY29tbW9uUHJlZml4IiwicHJlZml4IiwiUHJlZml4IiwicGFyc2VMaXN0UGFydHMiLCJwYXJ0cyIsIm1hcmtlciIsIkxpc3RQYXJ0c1Jlc3VsdCIsIk5leHRQYXJ0TnVtYmVyTWFya2VyIiwiUGFydCIsInAiLCJwYXJ0IiwicGFyc2VJbnQiLCJQYXJ0TnVtYmVyIiwicmVwbGFjZSIsInBhcnNlTGlzdEJ1Y2tldCIsImxpc3RCdWNrZXRSZXN1bHRQYXJzZXIiLCJwYXJzZVRhZ1ZhbHVlIiwibGVhZGluZ1plcm9zIiwiaGV4IiwidGFnVmFsdWVQcm9jZXNzb3IiLCJ0YWdOYW1lIiwidGFnVmFsdWUiLCJ0b1N0cmluZyIsImlnbm9yZUF0dHJpYnV0ZXMiLCJwYXJzZWRYbWxSZXMiLCJMaXN0QWxsTXlCdWNrZXRzUmVzdWx0IiwiQnVja2V0cyIsIkJ1Y2tldCIsIm1hcCIsImJ1Y2tldCIsIk5hbWUiLCJidWNrZXROYW1lIiwiQ3JlYXRpb25EYXRlIiwiY3JlYXRpb25EYXRlIiwicGFyc2VJbml0aWF0ZU11bHRpcGFydCIsIkluaXRpYXRlTXVsdGlwYXJ0VXBsb2FkUmVzdWx0IiwiVXBsb2FkSWQiLCJwYXJzZVJlcGxpY2F0aW9uQ29uZmlnIiwiUm9sZSIsIlJ1bGUiLCJSZXBsaWNhdGlvbkNvbmZpZ3VyYXRpb24iLCJyb2xlIiwicnVsZXMiLCJwYXJzZU9iamVjdExlZ2FsSG9sZENvbmZpZyIsIkxlZ2FsSG9sZCIsInBhcnNlVGFnZ2luZyIsIlRhZ2dpbmciLCJUYWdTZXQiLCJUYWciLCJ0YWdSZXN1bHQiLCJpc09iamVjdCIsInBhcnNlQ29tcGxldGVNdWx0aXBhcnQiLCJDb21wbGV0ZU11bHRpcGFydFVwbG9hZFJlc3VsdCIsIkxvY2F0aW9uIiwibG9jYXRpb24iLCJDb2RlIiwiTWVzc2FnZSIsImVyckNvZGUiLCJlcnJNZXNzYWdlIiwicGFyc2VMaXN0TXVsdGlwYXJ0IiwicHJlZml4ZXMiLCJ1cGxvYWRzIiwibmV4dEtleU1hcmtlciIsIm5leHRVcGxvYWRJZE1hcmtlciIsIkxpc3RNdWx0aXBhcnRVcGxvYWRzUmVzdWx0IiwiTmV4dEtleU1hcmtlciIsIk5leHRVcGxvYWRJZE1hcmtlciIsIlVwbG9hZCIsInVwbG9hZCIsInVwbG9hZEl0ZW0iLCJ1cGxvYWRJZCIsInN0b3JhZ2VDbGFzcyIsIlN0b3JhZ2VDbGFzcyIsImluaXRpYXRlZCIsIkluaXRpYXRlZCIsIkluaXRpYXRvciIsImluaXRpYXRvciIsImlkIiwiSUQiLCJkaXNwbGF5TmFtZSIsIkRpc3BsYXlOYW1lIiwiT3duZXIiLCJvd25lciIsInBhcnNlT2JqZWN0TG9ja0NvbmZpZyIsImxvY2tDb25maWdSZXN1bHQiLCJPYmplY3RMb2NrQ29uZmlndXJhdGlvbiIsIm9iamVjdExvY2tFbmFibGVkIiwiT2JqZWN0TG9ja0VuYWJsZWQiLCJyZXRlbnRpb25SZXNwIiwiRGVmYXVsdFJldGVudGlvbiIsIm1vZGUiLCJNb2RlIiwiaXNVbml0WWVhcnMiLCJZZWFycyIsInZhbGlkaXR5IiwidW5pdCIsIlJFVEVOVElPTl9WQUxJRElUWV9VTklUUyIsIllFQVJTIiwiRGF5cyIsIkRBWVMiLCJwYXJzZUJ1Y2tldFZlcnNpb25pbmdDb25maWciLCJWZXJzaW9uaW5nQ29uZmlndXJhdGlvbiIsImV4dHJhY3RIZWFkZXJUeXBlIiwic3RyZWFtIiwiaGVhZGVyTmFtZUxlbiIsIkJ1ZmZlciIsImZyb20iLCJyZWFkIiwicmVhZFVJbnQ4IiwiaGVhZGVyTmFtZVdpdGhTZXBhcmF0b3IiLCJzcGxpdEJ5U2VwYXJhdG9yIiwibGVuZ3RoIiwiZXh0cmFjdEhlYWRlclZhbHVlIiwiYm9keUxlbiIsInJlYWRVSW50MTZCRSIsInBhcnNlU2VsZWN0T2JqZWN0Q29udGVudFJlc3BvbnNlIiwicmVzIiwic2VsZWN0UmVzdWx0cyIsIlNlbGVjdFJlc3VsdHMiLCJyZXNwb25zZVN0cmVhbSIsInJlYWRhYmxlU3RyZWFtIiwiX3JlYWRhYmxlU3RhdGUiLCJtc2dDcmNBY2N1bXVsYXRvciIsInRvdGFsQnl0ZUxlbmd0aEJ1ZmZlciIsImNyYzMyIiwiaGVhZGVyQnl0ZXNCdWZmZXIiLCJjYWxjdWxhdGVkUHJlbHVkZUNyYyIsInJlYWRJbnQzMkJFIiwicHJlbHVkZUNyY0J1ZmZlciIsInRvdGFsTXNnTGVuZ3RoIiwiaGVhZGVyTGVuZ3RoIiwicHJlbHVkZUNyY0J5dGVWYWx1ZSIsImhlYWRlckJ5dGVzIiwiaGVhZGVyUmVhZGVyU3RyZWFtIiwiaGVhZGVyVHlwZU5hbWUiLCJwYXlsb2FkU3RyZWFtIiwicGF5TG9hZExlbmd0aCIsInBheUxvYWRCdWZmZXIiLCJtZXNzYWdlQ3JjQnl0ZVZhbHVlIiwiY2FsY3VsYXRlZENyYyIsIm1lc3NhZ2VUeXBlIiwiZXJyb3JNZXNzYWdlIiwiY29udGVudFR5cGUiLCJldmVudFR5cGUiLCJzZXRSZXNwb25zZSIsIl9wYXlsb2FkU3RyZWFtIiwicmVhZERhdGEiLCJzZXRSZWNvcmRzIiwiX3BheWxvYWRTdHJlYW0yIiwicHJvZ3Jlc3NEYXRhIiwic2V0UHJvZ3Jlc3MiLCJfcGF5bG9hZFN0cmVhbTMiLCJzdGF0c0RhdGEiLCJzZXRTdGF0cyIsIndhcm5pbmdNZXNzYWdlIiwiY29uc29sZSIsIndhcm4iLCJwYXJzZUxpZmVjeWNsZUNvbmZpZyIsIkxpZmVjeWNsZUNvbmZpZ3VyYXRpb24iLCJwYXJzZUJ1Y2tldEVuY3J5cHRpb25Db25maWciLCJwYXJzZU9iamVjdFJldGVudGlvbkNvbmZpZyIsInJldGVudGlvbkNvbmZpZyIsIlJldGVudGlvbiIsInJldGFpblVudGlsRGF0ZSIsIlJldGFpblVudGlsRGF0ZSIsInJlbW92ZU9
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/minio.d.ts

@@ -0,0 +1,66 @@
+// imported from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/93cfb0ec069731dcdfc31464788613f7cddb8192/types/minio/index.d.ts
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./helpers.js";
+import type { ClientOptions, NoResultCallback, RemoveOptions } from "./internal/client.js";
+import { TypedClient } from "./internal/client.js";
+import { CopyConditions } from "./internal/copy-conditions.js";
+import { PostPolicy } from "./internal/post-policy.js";
+import type { BucketItem, BucketItemCopy, BucketItemFromList, BucketItemStat, BucketItemWithMetadata, BucketStream, EmptyObject, ExistingObjectReplication, GetObjectLegalHoldOptions, IncompleteUploadedBucketItem, InputSerialization, IsoDate, ItemBucketMetadata, ItemBucketMetadataList, LegalHoldStatus, LifecycleConfig, LifecycleRule, MetadataItem, ObjectLockInfo, OutputSerialization, PutObjectLegalHoldOptions, ReplicaModifications, ReplicationConfig, ReplicationConfigOpts, ReplicationRule, ReplicationRuleAnd, ReplicationRuleDestination, ReplicationRuleFilter, ReplicationRuleStatus, ResultCallback, Retention, RetentionOptions, ScanRange, SelectOptions, SelectProgress, SourceSelectionCriteria, Tag } from "./internal/type.js";
+import type { NotificationConfig, NotificationEvent, NotificationPoller } from "./notification.js";
+export * from "./errors.js";
+export * from "./helpers.js";
+export type { Region } from "./internal/s3-endpoints.js";
+export type * from "./notification.js";
+export * from "./notification.js";
+export { CopyConditions, PostPolicy };
+export type { MakeBucketOpt } from "./internal/client.js";
+export type { BucketItem, BucketItemCopy, BucketItemFromList, BucketItemStat, BucketItemWithMetadata, BucketStream, ClientOptions, EmptyObject, ExistingObjectReplication, GetObjectLegalHoldOptions, IncompleteUploadedBucketItem, InputSerialization, IsoDate, ItemBucketMetadata, ItemBucketMetadataList, LegalHoldStatus, LifecycleConfig, LifecycleRule, MetadataItem, NoResultCallback, ObjectLockInfo, OutputSerialization, PutObjectLegalHoldOptions, RemoveOptions, ReplicaModifications, ReplicationConfig, ReplicationConfigOpts, ReplicationRule, ReplicationRuleAnd, ReplicationRuleDestination, ReplicationRuleFilter, ReplicationRuleStatus, Retention, RetentionOptions, ScanRange, SelectOptions, SelectProgress, SourceSelectionCriteria, Tag };
+
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+export type Mode = RETENTION_MODES;
+
+/**
+ * @deprecated keep for backward compatible
+ */
+export type LockUnit = RETENTION_VALIDITY_UNITS;
+export type VersioningConfig = Record<string | number | symbol, unknown>;
+export type TagList = Record<string, string>;
+export interface PostPolicyResult {
+  postURL: string;
+  formData: {
+    [key: string]: any;
+  };
+}
+export interface LockConfig {
+  mode: RETENTION_MODES;
+  unit: RETENTION_VALIDITY_UNITS;
+  validity: number;
+}
+export interface LegalHoldOptions {
+  versionId: string;
+  status: LEGAL_HOLD_STATUS;
+}
+export interface SourceObjectStats {
+  size: number;
+  metaData: string;
+  lastModicied: Date;
+  versionId: string;
+  etag: string;
+}
+
+// Exports from library
+export class Client extends TypedClient {
+  listObjectsV2(bucketName: string, prefix?: string, recursive?: boolean, startAfter?: string): BucketStream<BucketItem>;
+
+  // Bucket Policy & Notification operations
+  getBucketNotification(bucketName: string, callback: ResultCallback<NotificationConfig>): void;
+  getBucketNotification(bucketName: string): Promise<NotificationConfig>;
+  setBucketNotification(bucketName: string, bucketNotificationConfig: NotificationConfig, callback: NoResultCallback): void;
+  setBucketNotification(bucketName: string, bucketNotificationConfig: NotificationConfig): Promise<void>;
+  removeAllBucketNotification(bucketName: string, callback: NoResultCallback): void;
+  removeAllBucketNotification(bucketName: string): Promise<void>;
+  listenBucketNotification(bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]): NotificationPoller;
+}

SerpentRace_Backend/node_modules/minio/dist/main/minio.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Client: true,
+  CopyConditions: true,
+  PostPolicy: true
+};
+var Stream = _interopRequireWildcard(require("stream"), true);
+var _xml2js = require("xml2js");
+var errors = _interopRequireWildcard(require("./errors.js"), true);
+Object.keys(errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === errors[key]) return;
+  exports[key] = errors[key];
+});
+var _callbackify = require("./internal/callbackify.js");
+var _client = require("./internal/client.js");
+var _copyConditions = require("./internal/copy-conditions.js");
+exports.CopyConditions = _copyConditions.CopyConditions;
+var _helper = require("./internal/helper.js");
+var _postPolicy = require("./internal/post-policy.js");
+exports.PostPolicy = _postPolicy.PostPolicy;
+var _notification = require("./notification.js");
+Object.keys(_notification).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _notification[key]) return;
+  exports[key] = _notification[key];
+});
+var _promisify = require("./promisify.js");
+var transformers = _interopRequireWildcard(require("./transformers.js"), true);
+var _helpers = require("./helpers.js");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  exports[key] = _helpers[key];
+});
+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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, 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.
+ */
+
+class Client extends _client.TypedClient {
+  //
+  // __Arguments__
+  // * `appName` _string_ - Application name.
+  // * `appVersion` _string_ - Application version.
+
+  // listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.
+  //
+  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.
+  // request parameters :-
+  // * `bucketName` _string_: name of the bucket
+  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.
+  // * `continuation-token` _string_: Used to continue iterating over a set of objects.
+  // * `delimiter` _string_: A delimiter is a character you use to group keys.
+  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.
+  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.
+  listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isString)(continuationToken)) {
+      throw new TypeError('continuationToken should be of type "string"');
+    }
+    if (!(0, _helper.isString)(delimiter)) {
+      throw new TypeError('delimiter should be of type "string"');
+    }
+    if (!(0, _helper.isNumber)(maxKeys)) {
+      throw new TypeError('maxKeys should be of type "number"');
+    }
+    if (!(0, _helper.isString)(startAfter)) {
+      throw new TypeError('startAfter should be of type "string"');
+    }
+    var queries = [];
+
+    // Call for listing objects v2 API
+    queries.push(`list-type=2`);
+    queries.push(`encoding-type=url`);
+
+    // escape every value in query string, except maxKeys
+    queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`);
+    queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`);
+    if (continuationToken) {
+      continuationToken = (0, _helper.uriEscape)(continuationToken);
+      queries.push(`continuation-token=${continuationToken}`);
+    }
+    // Set start-after
+    if (startAfter) {
+      startAfter = (0, _helper.uriEscape)(startAfter);
+      queries.push(`start-after=${startAfter}`);
+    }
+    // no need to escape maxKeys
+    if (maxKeys) {
+      if (maxKeys >= 1000) {
+        maxKeys = 1000;
+      }
+      queries.push(`max-keys=${maxKeys}`);
+    }
+    queries.sort();
+    var query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    var method = 'GET';
+    var transformer = transformers.getListObjectsV2Transformer();
+    this.makeRequest({
+      method,
+      bucketName,
+      query
+    }, '', [200], '', true, (e, response) => {
+      if (e) {
+        return transformer.emit('error', e);
+      }
+      (0, _helper.pipesetup)(response, transformer);
+    });
+    return transformer;
+  }
+
+  // List the objects in the bucket using S3 ListObjects V2
+  //
+  // __Arguments__
+  // * `bucketName` _string_: name of the bucket
+  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)
+  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)
+  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)
+  //
+  // __Return Value__
+  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:
+  //   * `obj.name` _string_: name of the object
+  //   * `obj.prefix` _string_: name of the object prefix
+  //   * `obj.size` _number_: size of the object
+  //   * `obj.etag` _string_: etag of the object
+  //   * `obj.lastModified` _Date_: modified time stamp
+  listObjectsV2(bucketName, prefix, recursive, startAfter) {
+    if (prefix === undefined) {
+      prefix = '';
+    }
+    if (recursive === undefined) {
+      recursive = false;
+    }
+    if (startAfter === undefined) {
+      startAfter = '';
+    }
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isBoolean)(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (!(0, _helper.isString)(startAfter)) {
+      throw new TypeError('startAfter should be of type "string"');
+    }
+    // if recursive is false set delimiter to '/'
+    var delimiter = recursive ? '' : '/';
+    var continuationToken = '';
+    var objects = [];
+    var ended = false;
+    var readStream = Stream.Readable({
+      objectMode: true
+    });
+    readStream._read = () => {
+      // push one object per _read()
+      if (objects.length) {
+        readStream.push(objects.shift());
+        return;
+      }
+      if (ended) {
+        return readStream.push(null);
+      }
+      // if there are no objects to push do query for the next batch of objects
+      this.listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, 1000, startAfter).on('error', e => readStream.emit('error', e)).on('data', result => {
+        if (result.isTruncated) {
+          continuationToken = result.nextContinuationToken;
+        } else {
+          ended = true;
+        }
+        objects = result.objects;
+        readStream._read();
+      });
+    };
+    return readStream;
+  }
+
+  // Remove all the notification configurations in the S3 provider
+  setBucketNotification(bucketName, config, cb) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isObject)(config)) {
+      throw new TypeError('notification config should be of type "Object"');
+    }
+    if (!(0, _helper.isFunction)(cb)) {
+      throw new TypeError('callback should be of type "function"');
+    }
+    var method = 'PUT';
+    var query = 'notification';
+    var builder = new _xml2js.Builder({
+      rootName: 'NotificationConfiguration',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    var payload = builder.buildObject(config);
+    this.makeRequest({
+      method,
+      bucketName,
+      query
+    }, payload, [200], '', false, cb);
+  }
+  removeAllBucketNotification(bucketName, cb) {
+    this.setBucketNotification(bucketName, new _notification.NotificationConfig(), cb);
+  }
+
+  // Return the list of notification configurations stored
+  // in the S3 provider
+  getBucketNotification(bucketName, cb) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isFunction)(cb)) {
+      throw new TypeError('callback should be of type "function"');
+    }
+    var method = 'GET';
+    var query = 'notification';
+    this.makeRequest({
+      method,
+      bucketName,
+      query
+    }, '', [200], '', true, (e, response) => {
+      if (e) {
+        return cb(e);
+      }
+      var transformer = transformers.getBucketNotificationTransformer();
+      var bucketNotification;
+      (0, _helper.pipesetup)(response, transformer).on('data', result => bucketNotification = result).on('error', e => cb(e)).on('end', () => cb(null, bucketNotification));
+    });
+  }
+
+  // Listens for bucket notifications. Returns an EventEmitter.
+  listenBucketNotification(bucketName, prefix, suffix, events) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix must be of type string');
+    }
+    if (!(0, _helper.isString)(suffix)) {
+      throw new TypeError('suffix must be of type string');
+    }
+    if (!Array.isArray(events)) {
+      throw new TypeError('events must be of type Array');
+    }
+    let listener = new _notification.NotificationPoller(this, bucketName, prefix, suffix, events);
+    listener.start();
+    return listener;
+  }
+}
+exports.Client = Client;
+Client.prototype.getBucketNotification = (0, _promisify.promisify)(Client.prototype.getBucketNotification);
+Client.prototype.setBucketNotification = (0, _promisify.promisify)(Client.prototype.setBucketNotification);
+Client.prototype.removeAllBucketNotification = (0, _promisify.promisify)(Client.prototype.removeAllBucketNotification);
+
+// refactored API use promise internally
+Client.prototype.makeBucket = (0, _callbackify.callbackify)(Client.prototype.makeBucket);
+Client.prototype.bucketExists = (0, _callbackify.callbackify)(Client.prototype.bucketExists);
+Client.prototype.removeBucket = (0, _callbackify.callbackify)(Client.prototype.removeBucket);
+Client.prototype.listBuckets = (0, _callbackify.callbackify)(Client.prototype.listBuckets);
+Client.prototype.getObject = (0, _callbackify.callbackify)(Client.prototype.getObject);
+Client.prototype.fGetObject = (0, _callbackify.callbackify)(Client.prototype.fGetObject);
+Client.prototype.getPartialObject = (0, _callbackify.callbackify)(Client.prototype.getPartialObject);
+Client.prototype.statObject = (0, _callbackify.callbackify)(Client.prototype.statObject);
+Client.prototype.putObjectRetention = (0, _callbackify.callbackify)(Client.prototype.putObjectRetention);
+Client.prototype.putObject = (0, _callbackify.callbackify)(Client.prototype.putObject);
+Client.prototype.fPutObject = (0, _callbackify.callbackify)(Client.prototype.fPutObject);
+Client.prototype.removeObject = (0, _callbackify.callbackify)(Client.prototype.removeObject);
+Client.prototype.removeBucketReplication = (0, _callbackify.callbackify)(Client.prototype.removeBucketReplication);
+Client.prototype.setBucketReplication = (0, _callbackify.callbackify)(Client.prototype.setBucketReplication);
+Client.prototype.getBucketReplication = (0, _callbackify.callbackify)(Client.prototype.getBucketReplication);
+Client.prototype.getObjectLegalHold = (0, _callbackify.callbackify)(Client.prototype.getObjectLegalHold);
+Client.prototype.setObjectLegalHold = (0, _callbackify.callbackify)(Client.prototype.setObjectLegalHold);
+Client.prototype.setObjectLockConfig = (0, _callbackify.callbackify)(Client.prototype.setObjectLockConfig);
+Client.prototype.getObjectLockConfig = (0, _callbackify.callbackify)(Client.prototype.getObjectLockConfig);
+Client.prototype.getBucketPolicy = (0, _callbackify.callbackify)(Client.prototype.getBucketPolicy);
+Client.prototype.setBucketPolicy = (0, _callbackify.callbackify)(Client.prototype.setBucketPolicy);
+Client.prototype.getBucketTagging = (0, _callbackify.callbackify)(Client.prototype.getBucketTagging);
+Client.prototype.getObjectTagging = (0, _callbackify.callbackify)(Client.prototype.getObjectTagging);
+Client.prototype.setBucketTagging = (0, _callbackify.callbackify)(Client.prototype.setBucketTagging);
+Client.prototype.removeBucketTagging = (0, _callbackify.callbackify)(Client.prototype.removeBucketTagging);
+Client.prototype.setObjectTagging = (0, _callbackify.callbackify)(Client.prototype.setObjectTagging);
+Client.prototype.removeObjectTagging = (0, _callbackify.callbackify)(Client.prototype.removeObjectTagging);
+Client.prototype.getBucketVersioning = (0, _callbackify.callbackify)(Client.prototype.getBucketVersioning);
+Client.prototype.setBucketVersioning = (0, _callbackify.callbackify)(Client.prototype.setBucketVersioning);
+Client.prototype.selectObjectContent = (0, _callbackify.callbackify)(Client.prototype.selectObjectContent);
+Client.prototype.setBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.setBucketLifecycle);
+Client.prototype.getBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.getBucketLifecycle);
+Client.prototype.removeBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.removeBucketLifecycle);
+Client.prototype.setBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.setBucketEncryption);
+Client.prototype.getBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.getBucketEncryption);
+Client.prototype.removeBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.removeBucketEncryption);
+Client.prototype.getObjectRetention = (0, _callbackify.callbackify)(Client.prototype.getObjectRetention);
+Client.prototype.removeObjects = (0, _callbackify.callbackify)(Client.prototype.removeObjects);
+Client.prototype.removeIncompleteUpload = (0, _callbackify.callbackify)(Client.prototype.removeIncompleteUpload);
+Client.prototype.copyObject = (0, _callbackify.callbackify)(Client.prototype.copyObject);
+Client.prototype.composeObject = (0, _callbackify.callbackify)(Client.prototype.composeObject);
+Client.prototype.presignedUrl = (0, _callbackify.callbackify)(Client.prototype.presignedUrl);
+Client.prototype.presignedGetObject = (0, _callbackify.callbackify)(Client.prototype.presignedGetObject);
+Client.prototype.presignedPutObject = (0, _callbackify.callbackify)(Client.prototype.presignedPutObject);
+Client.prototype.presignedPostPolicy = (0, _callbackify.callbackify)(Client.prototype.presignedPostPolicy);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/notification.d.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'eventemitter3';
+import type { TypedClient } from "./internal/client.js";
+type Event = unknown;
+export declare class TargetConfig {
+  private Filter?;
+  private Event?;
+  private Id;
+  setId(id: unknown): void;
+  addEvent(newevent: Event): void;
+  addFilterSuffix(suffix: string): void;
+  addFilterPrefix(prefix: string): void;
+}
+export declare class TopicConfig extends TargetConfig {
+  private Topic;
+  constructor(arn: string);
+}
+export declare class QueueConfig extends TargetConfig {
+  private Queue;
+  constructor(arn: string);
+}
+export declare class CloudFunctionConfig extends TargetConfig {
+  private CloudFunction;
+  constructor(arn: string);
+}
+export declare class NotificationConfig {
+  private TopicConfiguration?;
+  private CloudFunctionConfiguration?;
+  private QueueConfiguration?;
+  add(target: TargetConfig): void;
+}
+export declare const buildARN: (partition: string, service: string, region: string, accountId: string, resource: string) => string;
+export declare const ObjectCreatedAll = "s3:ObjectCreated:*";
+export declare const ObjectCreatedPut = "s3:ObjectCreated:Put";
+export declare const ObjectCreatedPost = "s3:ObjectCreated:Post";
+export declare const ObjectCreatedCopy = "s3:ObjectCreated:Copy";
+export declare const ObjectCreatedCompleteMultipartUpload = "s3:ObjectCreated:CompleteMultipartUpload";
+export declare const ObjectRemovedAll = "s3:ObjectRemoved:*";
+export declare const ObjectRemovedDelete = "s3:ObjectRemoved:Delete";
+export declare const ObjectRemovedDeleteMarkerCreated = "s3:ObjectRemoved:DeleteMarkerCreated";
+export declare const ObjectReducedRedundancyLostObject = "s3:ReducedRedundancyLostObject";
+export type NotificationEvent = 's3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated' | 's3:ReducedRedundancyLostObject' | 's3:TestEvent' | 's3:ObjectRestore:Post' | 's3:ObjectRestore:Completed' | 's3:Replication:OperationFailedReplication' | 's3:Replication:OperationMissedThreshold' | 's3:Replication:OperationReplicatedAfterThreshold' | 's3:Replication:OperationNotTracked' | string;
+export type NotificationRecord = unknown;
+export declare class NotificationPoller extends EventEmitter<{
+  notification: (event: NotificationRecord) => void;
+  error: (error: unknown) => void;
+}> {
+  private client;
+  private bucketName;
+  private prefix;
+  private suffix;
+  private events;
+  private ending;
+  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]);
+  start(): void;
+  stop(): void;
+  checkForChanges(): void;
+}
+export {};

SerpentRace_Backend/node_modules/minio/dist/main/notification.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _eventemitter = require("eventemitter3");
+var _Parser = require("stream-json/jsonl/Parser.js");
+var _helpers = require("./helpers.js");
+var _helper = require("./internal/helper.js");
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, 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.
+ */
+
+// TODO: type this
+
+// Base class for three supported configs.
+class TargetConfig {
+  setId(id) {
+    this.Id = id;
+  }
+  addEvent(newevent) {
+    if (!this.Event) {
+      this.Event = [];
+    }
+    this.Event.push(newevent);
+  }
+  addFilterSuffix(suffix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'suffix',
+      Value: suffix
+    });
+  }
+  addFilterPrefix(prefix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'prefix',
+      Value: prefix
+    });
+  }
+}
+
+// 1. Topic (simple notification service)
+exports.TargetConfig = TargetConfig;
+class TopicConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Topic = arn;
+  }
+}
+
+// 2. Queue (simple queue service)
+exports.TopicConfig = TopicConfig;
+class QueueConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Queue = arn;
+  }
+}
+
+// 3. CloudFront (lambda function)
+exports.QueueConfig = QueueConfig;
+class CloudFunctionConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.CloudFunction = arn;
+  }
+}
+
+// Notification config - array of target configs.
+// Target configs can be
+// 1. Topic (simple notification service)
+// 2. Queue (simple queue service)
+// 3. CloudFront (lambda function)
+exports.CloudFunctionConfig = CloudFunctionConfig;
+class NotificationConfig {
+  add(target) {
+    let instance;
+    if (target instanceof TopicConfig) {
+      instance = this.TopicConfiguration ?? (this.TopicConfiguration = []);
+    }
+    if (target instanceof QueueConfig) {
+      instance = this.QueueConfiguration ?? (this.QueueConfiguration = []);
+    }
+    if (target instanceof CloudFunctionConfig) {
+      instance = this.CloudFunctionConfiguration ?? (this.CloudFunctionConfiguration = []);
+    }
+    if (instance) {
+      instance.push(target);
+    }
+  }
+}
+exports.NotificationConfig = NotificationConfig;
+const buildARN = (partition, service, region, accountId, resource) => {
+  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource;
+};
+exports.buildARN = buildARN;
+const ObjectCreatedAll = 's3:ObjectCreated:*';
+exports.ObjectCreatedAll = ObjectCreatedAll;
+const ObjectCreatedPut = 's3:ObjectCreated:Put';
+exports.ObjectCreatedPut = ObjectCreatedPut;
+const ObjectCreatedPost = 's3:ObjectCreated:Post';
+exports.ObjectCreatedPost = ObjectCreatedPost;
+const ObjectCreatedCopy = 's3:ObjectCreated:Copy';
+exports.ObjectCreatedCopy = ObjectCreatedCopy;
+const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload';
+exports.ObjectCreatedCompleteMultipartUpload = ObjectCreatedCompleteMultipartUpload;
+const ObjectRemovedAll = 's3:ObjectRemoved:*';
+exports.ObjectRemovedAll = ObjectRemovedAll;
+const ObjectRemovedDelete = 's3:ObjectRemoved:Delete';
+exports.ObjectRemovedDelete = ObjectRemovedDelete;
+const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated';
+exports.ObjectRemovedDeleteMarkerCreated = ObjectRemovedDeleteMarkerCreated;
+const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject';
+
+// put string at least so auto-complete could work
+
+// TODO: type this
+exports.ObjectReducedRedundancyLostObject = ObjectReducedRedundancyLostObject;
+// Poll for notifications, used in #listenBucketNotification.
+// Listening constitutes repeatedly requesting s3 whether or not any
+// changes have occurred.
+class NotificationPoller extends _eventemitter.EventEmitter {
+  constructor(client, bucketName, prefix, suffix, events) {
+    super();
+    this.client = client;
+    this.bucketName = bucketName;
+    this.prefix = prefix;
+    this.suffix = suffix;
+    this.events = events;
+    this.ending = false;
+  }
+
+  // Starts the polling.
+  start() {
+    this.ending = false;
+    process.nextTick(() => {
+      this.checkForChanges();
+    });
+  }
+
+  // Stops the polling.
+  stop() {
+    this.ending = true;
+  }
+  checkForChanges() {
+    // Don't continue if we're looping again but are cancelled.
+    if (this.ending) {
+      return;
+    }
+    const method = 'GET';
+    const queries = [];
+    if (this.prefix) {
+      const prefix = (0, _helper.uriEscape)(this.prefix);
+      queries.push(`prefix=${prefix}`);
+    }
+    if (this.suffix) {
+      const suffix = (0, _helper.uriEscape)(this.suffix);
+      queries.push(`suffix=${suffix}`);
+    }
+    if (this.events) {
+      this.events.forEach(s3event => queries.push('events=' + (0, _helper.uriEscape)(s3event)));
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const region = this.client.region || _helpers.DEFAULT_REGION;
+    this.client.makeRequestAsync({
+      method,
+      bucketName: this.bucketName,
+      query
+    }, '', [200], region).then(response => {
+      const asm = _Parser.make();
+      (0, _helper.pipesetup)(response, asm).on('data', data => {
+        // Data is flushed periodically (every 5 seconds), so we should
+        // handle it after flushing from the JSON parser.
+        let records = data.value.Records;
+        // If null (= no records), change to an empty array.
+        if (!records) {
+          records = [];
+        }
+
+        // Iterate over the notifications and emit them individually.
+        records.forEach(record => {
+          this.emit('notification', record);
+        });
+
+        // If we're done, stop.
+        if (this.ending) {
+          response === null || response === void 0 ? void 0 : response.destroy();
+        }
+      }).on('error', e => this.emit('error', e)).on('end', () => {
+        // Do it again, if we haven't cancelled yet.
+        process.nextTick(() => {
+          this.checkForChanges();
+        });
+      });
+    }, e => {
+      return this.emit('error', e);
+    });
+  }
+}
+exports.NotificationPoller = NotificationPoller;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/promisify.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.promisify = promisify;
+// Returns a wrapper function that will promisify a given callback function.
+// It will preserve 'this'.
+function promisify(fn) {
+  return function () {
+    // If the last argument is a function, assume its the callback.
+    let callback = arguments[arguments.length - 1];
+
+    // If the callback is given, don't promisify, just pass straight in.
+    if (typeof callback === 'function') {
+      return fn.apply(this, arguments);
+    }
+
+    // Otherwise, create a new set of arguments, and wrap
+    // it in a promise.
+    let args = [...arguments];
+    return new Promise((resolve, reject) => {
+      // Add the callback function.
+      args.push((err, value) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(value);
+      });
+
+      // Call the function with our special adaptor callback added.
+      fn.apply(this, args);
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/main/signing.d.ts

@@ -0,0 +1,5 @@
+import type { IRequest } from "./internal/type.js";
+export declare function postPresignSignatureV4(region: string, date: Date, secretKey: string, policyBase64: string): string;
+export declare function signV4(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, sha256sum: string, serviceName?: string): string;
+export declare function signV4ByServiceName(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, contentSha256: string, serviceName?: string): string;
+export declare function presignSignatureV4(request: IRequest, accessKey: string, secretKey: string, sessionToken: string | undefined, region: string, requestDate: Date, expires: number | undefined): string;

SerpentRace_Backend/node_modules/minio/dist/main/signing.js

@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.postPresignSignatureV4 = postPresignSignatureV4;
+exports.presignSignatureV4 = presignSignatureV4;
+exports.signV4 = signV4;
+exports.signV4ByServiceName = signV4ByServiceName;
+var crypto = _interopRequireWildcard(require("crypto"), true);
+var errors = _interopRequireWildcard(require("./errors.js"), true);
+var _helpers = require("./helpers.js");
+var _helper = require("./internal/helper.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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, 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.
+ */
+
+const signV4Algorithm = 'AWS4-HMAC-SHA256';
+
+// getCanonicalRequest generate a canonical request of style.
+//
+// canonicalRequest =
+//  <HTTPMethod>\n
+//  <CanonicalURI>\n
+//  <CanonicalQueryString>\n
+//  <CanonicalHeaders>\n
+//  <SignedHeaders>\n
+//  <HashedPayload>
+//
+function getCanonicalRequest(method, path, headers, signedHeaders, hashedPayload) {
+  if (!(0, _helper.isString)(method)) {
+    throw new TypeError('method should be of type "string"');
+  }
+  if (!(0, _helper.isString)(path)) {
+    throw new TypeError('path should be of type "string"');
+  }
+  if (!(0, _helper.isObject)(headers)) {
+    throw new TypeError('headers should be of type "object"');
+  }
+  if (!Array.isArray(signedHeaders)) {
+    throw new TypeError('signedHeaders should be of type "array"');
+  }
+  if (!(0, _helper.isString)(hashedPayload)) {
+    throw new TypeError('hashedPayload should be of type "string"');
+  }
+  const headersArray = signedHeaders.reduce((acc, i) => {
+    // Trim spaces from the value (required by V4 spec)
+    const val = `${headers[i]}`.replace(/ +/g, ' ');
+    acc.push(`${i.toLowerCase()}:${val}`);
+    return acc;
+  }, []);
+  const requestResource = path.split('?')[0];
+  let requestQuery = path.split('?')[1];
+  if (!requestQuery) {
+    requestQuery = '';
+  }
+  if (requestQuery) {
+    requestQuery = requestQuery.split('&').sort().map(element => !element.includes('=') ? element + '=' : element).join('&');
+  }
+  return [method.toUpperCase(), requestResource, requestQuery, headersArray.join('\n') + '\n', signedHeaders.join(';').toLowerCase(), hashedPayload].join('\n');
+}
+
+// generate a credential string
+function getCredential(accessKey, region, requestDate, serviceName = 's3') {
+  if (!(0, _helper.isString)(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!(0, _helper.isObject)(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  return `${accessKey}/${(0, _helper.getScope)(region, requestDate, serviceName)}`;
+}
+
+// Returns signed headers array - alphabetically sorted
+function getSignedHeaders(headers) {
+  if (!(0, _helper.isObject)(headers)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  // Excerpts from @lsegal - https://github.com/aws/aws-sdk-js/issues/659#issuecomment-120477258
+  //
+  //  User-Agent:
+  //
+  //      This is ignored from signing because signing this causes problems with generating pre-signed URLs
+  //      (that are executed by other agents) or when customers pass requests through proxies, which may
+  //      modify the user-agent.
+  //
+  //  Content-Length:
+  //
+  //      This is ignored from signing because generating a pre-signed URL should not provide a content-length
+  //      constraint, specifically when vending a S3 pre-signed PUT URL. The corollary to this is that when
+  //      sending regular requests (non-pre-signed), the signature contains a checksum of the body, which
+  //      implicitly validates the payload length (since changing the number of bytes would change the checksum)
+  //      and therefore this header is not valuable in the signature.
+  //
+  //  Content-Type:
+  //
+  //      Signing this header causes quite a number of problems in browser environments, where browsers
+  //      like to modify and normalize the content-type header in different ways. There is more information
+  //      on this in https://github.com/aws/aws-sdk-js/issues/244. Avoiding this field simplifies logic
+  //      and reduces the possibility of future bugs
+  //
+  //  Authorization:
+  //
+  //      Is skipped for obvious reasons
+
+  const ignoredHeaders = ['authorization', 'content-length', 'content-type', 'user-agent'];
+  return Object.keys(headers).filter(header => !ignoredHeaders.includes(header)).sort();
+}
+
+// returns the key used for calculating signature
+function getSigningKey(date, region, secretKey, serviceName = 's3') {
+  if (!(0, _helper.isObject)(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!(0, _helper.isString)(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  const dateLine = (0, _helper.makeDateShort)(date);
+  const hmac1 = crypto.createHmac('sha256', 'AWS4' + secretKey).update(dateLine).digest(),
+    hmac2 = crypto.createHmac('sha256', hmac1).update(region).digest(),
+    hmac3 = crypto.createHmac('sha256', hmac2).update(serviceName).digest();
+  return crypto.createHmac('sha256', hmac3).update('aws4_request').digest();
+}
+
+// returns the string that needs to be signed
+function getStringToSign(canonicalRequest, requestDate, region, serviceName = 's3') {
+  if (!(0, _helper.isString)(canonicalRequest)) {
+    throw new TypeError('canonicalRequest should be of type "string"');
+  }
+  if (!(0, _helper.isObject)(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex');
+  const scope = (0, _helper.getScope)(region, requestDate, serviceName);
+  const stringToSign = [signV4Algorithm, (0, _helper.makeDateLong)(requestDate), scope, hash];
+  return stringToSign.join('\n');
+}
+
+// calculate the signature of the POST policy
+function postPresignSignatureV4(region, date, secretKey, policyBase64) {
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!(0, _helper.isObject)(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!(0, _helper.isString)(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(policyBase64)) {
+    throw new TypeError('policyBase64 should be of type "string"');
+  }
+  const signingKey = getSigningKey(date, region, secretKey);
+  return crypto.createHmac('sha256', signingKey).update(policyBase64).digest('hex').toLowerCase();
+}
+
+// Returns the authorization header
+function signV4(request, accessKey, secretKey, region, requestDate, sha256sum, serviceName = 's3') {
+  if (!(0, _helper.isObject)(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!(0, _helper.isString)(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!accessKey) {
+    throw new errors.AccessKeyRequiredError('accessKey is required for signing');
+  }
+  if (!secretKey) {
+    throw new errors.SecretKeyRequiredError('secretKey is required for signing');
+  }
+  const signedHeaders = getSignedHeaders(request.headers);
+  const canonicalRequest = getCanonicalRequest(request.method, request.path, request.headers, signedHeaders, sha256sum);
+  const serviceIdentifier = serviceName || 's3';
+  const stringToSign = getStringToSign(canonicalRequest, requestDate, region, serviceIdentifier);
+  const signingKey = getSigningKey(requestDate, region, secretKey, serviceIdentifier);
+  const credential = getCredential(accessKey, region, requestDate, serviceIdentifier);
+  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase();
+  return `${signV4Algorithm} Credential=${credential}, SignedHeaders=${signedHeaders.join(';').toLowerCase()}, Signature=${signature}`;
+}
+function signV4ByServiceName(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName = 's3') {
+  return signV4(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName);
+}
+
+// returns a presigned URL string
+function presignSignatureV4(request, accessKey, secretKey, sessionToken, region, requestDate, expires) {
+  if (!(0, _helper.isObject)(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!(0, _helper.isString)(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!(0, _helper.isString)(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!accessKey) {
+    throw new errors.AccessKeyRequiredError('accessKey is required for presigning');
+  }
+  if (!secretKey) {
+    throw new errors.SecretKeyRequiredError('secretKey is required for presigning');
+  }
+  if (expires && !(0, _helper.isNumber)(expires)) {
+    throw new TypeError('expires should be of type "number"');
+  }
+  if (expires && expires < 1) {
+    throw new errors.ExpiresParamError('expires param cannot be less than 1 seconds');
+  }
+  if (expires && expires > _helpers.PRESIGN_EXPIRY_DAYS_MAX) {
+    throw new errors.ExpiresParamError('expires param cannot be greater than 7 days');
+  }
+  const iso8601Date = (0, _helper.makeDateLong)(requestDate);
+  const signedHeaders = getSignedHeaders(request.headers);
+  const credential = getCredential(accessKey, region, requestDate);
+  const hashedPayload = 'UNSIGNED-PAYLOAD';
+  const requestQuery = [];
+  requestQuery.push(`X-Amz-Algorithm=${signV4Algorithm}`);
+  requestQuery.push(`X-Amz-Credential=${(0, _helper.uriEscape)(credential)}`);
+  requestQuery.push(`X-Amz-Date=${iso8601Date}`);
+  requestQuery.push(`X-Amz-Expires=${expires}`);
+  requestQuery.push(`X-Amz-SignedHeaders=${(0, _helper.uriEscape)(signedHeaders.join(';').toLowerCase())}`);
+  if (sessionToken) {
+    requestQuery.push(`X-Amz-Security-Token=${(0, _helper.uriEscape)(sessionToken)}`);
+  }
+  const resource = request.path.split('?')[0];
+  let query = request.path.split('?')[1];
+  if (query) {
+    query = query + '&' + requestQuery.join('&');
+  } else {
+    query = requestQuery.join('&');
+  }
+  const path = resource + '?' + query;
+  const canonicalRequest = getCanonicalRequest(request.method, path, request.headers, signedHeaders, hashedPayload);
+  const stringToSign = getStringToSign(canonicalRequest, requestDate, region);
+  const signingKey = getSigningKey(requestDate, region, secretKey);
+  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase();
+  return request.protocol + '//' + request.headers.host + path + `&X-Amz-Signature=${signature}`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/transformers.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBucketNotificationTransformer = getBucketNotificationTransformer;
+exports.getConcater = getConcater;
+exports.getHashSummer = getHashSummer;
+exports.getListObjectsV2Transformer = getListObjectsV2Transformer;
+exports.getListObjectsV2WithMetadataTransformer = getListObjectsV2WithMetadataTransformer;
+var Crypto = _interopRequireWildcard(require("crypto"), true);
+var _through = require("through2");
+var _helper = require("./internal/helper.js");
+var xmlParsers = _interopRequireWildcard(require("./xml-parsers.js"), true);
+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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, 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.
+ */
+
+// getConcater returns a stream that concatenates the input and emits
+// the concatenated output when 'end' has reached. If an optional
+// parser function is passed upon reaching the 'end' of the stream,
+// `parser(concatenated_data)` will be emitted.
+function getConcater(parser, emitError) {
+  var objectMode = false;
+  var bufs = [];
+  if (parser && !(0, _helper.isFunction)(parser)) {
+    throw new TypeError('parser should be of type "function"');
+  }
+  if (parser) {
+    objectMode = true;
+  }
+  return _through({
+    objectMode
+  }, function (chunk, enc, cb) {
+    bufs.push(chunk);
+    cb();
+  }, function (cb) {
+    if (emitError) {
+      cb(parser(Buffer.concat(bufs).toString()));
+      // cb(e) would mean we have to emit 'end' by explicitly calling this.push(null)
+      this.push(null);
+      return;
+    }
+    if (bufs.length) {
+      if (parser) {
+        this.push(parser(Buffer.concat(bufs).toString()));
+      } else {
+        this.push(Buffer.concat(bufs));
+      }
+    }
+    cb();
+  });
+}
+
+// A through stream that calculates md5sum and sha256sum
+function getHashSummer(enableSHA256) {
+  var md5 = Crypto.createHash('md5');
+  var sha256 = Crypto.createHash('sha256');
+  return _through.obj(function (chunk, enc, cb) {
+    if (enableSHA256) {
+      sha256.update(chunk);
+    } else {
+      md5.update(chunk);
+    }
+    cb();
+  }, function (cb) {
+    var md5sum = '';
+    var sha256sum = '';
+    if (enableSHA256) {
+      sha256sum = sha256.digest('hex');
+    } else {
+      md5sum = md5.digest('base64');
+    }
+    var hashData = {
+      md5sum,
+      sha256sum
+    };
+    this.push(hashData);
+    this.push(null);
+    cb();
+  });
+}
+
+// Following functions return a stream object that parses XML
+// and emits suitable Javascript objects.
+
+// Parses listObjects response.
+function getListObjectsV2Transformer() {
+  return getConcater(xmlParsers.parseListObjectsV2);
+}
+
+// Parses listObjects with metadata response.
+function getListObjectsV2WithMetadataTransformer() {
+  return getConcater(xmlParsers.parseListObjectsV2WithMetadata);
+}
+
+// Parses GET/SET BucketNotification response
+function getBucketNotificationTransformer() {
+  return getConcater(xmlParsers.parseBucketNotification);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/main/xml-parsers.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseBucketNotification = parseBucketNotification;
+exports.parseListObjectsV2 = parseListObjectsV2;
+exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata;
+var errors = _interopRequireWildcard(require("./errors.js"), true);
+var _helper = require("./internal/helper.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; }
+/*
+ * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, 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.
+ */
+
+// parse XML response for bucket notification
+function parseBucketNotification(xml) {
+  var result = {
+    TopicConfiguration: [],
+    QueueConfiguration: [],
+    CloudFunctionConfiguration: []
+  };
+  // Parse the events list
+  var genEvents = function (events) {
+    var result = [];
+    if (events) {
+      (0, _helper.toArray)(events).forEach(s3event => {
+        result.push(s3event);
+      });
+    }
+    return result;
+  };
+  // Parse all filter rules
+  var genFilterRules = function (filters) {
+    var result = [];
+    if (filters) {
+      filters = (0, _helper.toArray)(filters);
+      if (filters[0].S3Key) {
+        filters[0].S3Key = (0, _helper.toArray)(filters[0].S3Key);
+        if (filters[0].S3Key[0].FilterRule) {
+          (0, _helper.toArray)(filters[0].S3Key[0].FilterRule).forEach(rule => {
+            var Name = (0, _helper.toArray)(rule.Name)[0];
+            var Value = (0, _helper.toArray)(rule.Value)[0];
+            result.push({
+              Name,
+              Value
+            });
+          });
+        }
+      }
+    }
+    return result;
+  };
+  var xmlobj = (0, _helper.parseXml)(xml);
+  xmlobj = xmlobj.NotificationConfiguration;
+
+  // Parse all topic configurations in the xml
+  if (xmlobj.TopicConfiguration) {
+    (0, _helper.toArray)(xmlobj.TopicConfiguration).forEach(config => {
+      var Id = (0, _helper.toArray)(config.Id)[0];
+      var Topic = (0, _helper.toArray)(config.Topic)[0];
+      var Event = genEvents(config.Event);
+      var Filter = genFilterRules(config.Filter);
+      result.TopicConfiguration.push({
+        Id,
+        Topic,
+        Event,
+        Filter
+      });
+    });
+  }
+  // Parse all topic configurations in the xml
+  if (xmlobj.QueueConfiguration) {
+    (0, _helper.toArray)(xmlobj.QueueConfiguration).forEach(config => {
+      var Id = (0, _helper.toArray)(config.Id)[0];
+      var Queue = (0, _helper.toArray)(config.Queue)[0];
+      var Event = genEvents(config.Event);
+      var Filter = genFilterRules(config.Filter);
+      result.QueueConfiguration.push({
+        Id,
+        Queue,
+        Event,
+        Filter
+      });
+    });
+  }
+  // Parse all QueueConfiguration arrays
+  if (xmlobj.CloudFunctionConfiguration) {
+    (0, _helper.toArray)(xmlobj.CloudFunctionConfiguration).forEach(config => {
+      var Id = (0, _helper.toArray)(config.Id)[0];
+      var CloudFunction = (0, _helper.toArray)(config.CloudFunction)[0];
+      var Event = genEvents(config.Event);
+      var Filter = genFilterRules(config.Filter);
+      result.CloudFunctionConfiguration.push({
+        Id,
+        CloudFunction,
+        Event,
+        Filter
+      });
+    });
+  }
+  return result;
+}
+
+// parse XML response for list objects v2 in a bucket
+function parseListObjectsV2(xml) {
+  var result = {
+    objects: [],
+    isTruncated: false
+  };
+  var xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.ListBucketResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"');
+  }
+  xmlobj = xmlobj.ListBucketResult;
+  if (xmlobj.IsTruncated) {
+    result.isTruncated = xmlobj.IsTruncated;
+  }
+  if (xmlobj.NextContinuationToken) {
+    result.nextContinuationToken = xmlobj.NextContinuationToken;
+  }
+  if (xmlobj.Contents) {
+    (0, _helper.toArray)(xmlobj.Contents).forEach(content => {
+      var name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(content.Key)[0]);
+      var lastModified = new Date(content.LastModified);
+      var etag = (0, _helper.sanitizeETag)(content.ETag);
+      var size = content.Size;
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+
+// parse XML response for list objects v2 with metadata in a bucket
+function parseListObjectsV2WithMetadata(xml) {
+  var result = {
+    objects: [],
+    isTruncated: false
+  };
+  var xmlobj = (0, _helper.parseXml)(xml);
+  if (!xmlobj.ListBucketResult) {
+    throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"');
+  }
+  xmlobj = xmlobj.ListBucketResult;
+  if (xmlobj.IsTruncated) {
+    result.isTruncated = xmlobj.IsTruncated;
+  }
+  if (xmlobj.NextContinuationToken) {
+    result.nextContinuationToken = xmlobj.NextContinuationToken;
+  }
+  if (xmlobj.Contents) {
+    (0, _helper.toArray)(xmlobj.Contents).forEach(content => {
+      var name = (0, _helper.sanitizeObjectKey)(content.Key);
+      var lastModified = new Date(content.LastModified);
+      var etag = (0, _helper.sanitizeETag)(content.ETag);
+      var size = content.Size;
+      var metadata;
+      if (content.UserMetadata != null) {
+        metadata = (0, _helper.toArray)(content.UserMetadata)[0];
+      } else {
+        metadata = null;
+      }
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size,
+        metadata
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated