[#94] Backend

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

SerpentRace_Backend/node_modules/minio/dist/esm/AssumeRoleProvider.d.mts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { CredentialProvider } from "./CredentialProvider.mjs";
+import { Credentials } from "./Credentials.mjs";
+/**
+ * @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/esm/AssumeRoleProvider.mjs

@@ -0,0 +1,183 @@
+import * as http from "http";
+import * as https from "https";
+import { URL, URLSearchParams } from "url";
+import { CredentialProvider } from "./CredentialProvider.mjs";
+import { Credentials } from "./Credentials.mjs";
+import { makeDateLong, parseXml, toSha256 } from "./internal/helper.mjs";
+import { request } from "./internal/request.mjs";
+import { readAsString } from "./internal/response.mjs";
+import { signV4ByServiceName } from "./signing.mjs";
+
+/**
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+ */
+
+const defaultExpirySeconds = 900;
+export class AssumeRoleProvider extends 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(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 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 = 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': makeDateLong(date),
+        'x-amz-content-sha256': contentSha256
+      },
+      agent: this.transportAgent
+    };
+    requestOptions.headers.authorization = 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 request(this.transport, requestOptions, requestData);
+    const body = await readAsString(res);
+    return 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({
+      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
+export default AssumeRoleProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/CredentialProvider.d.mts

@@ -0,0 +1,22 @@
+import { Credentials } from "./Credentials.mjs";
+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/esm/CredentialProvider.mjs

@@ -0,0 +1,48 @@
+import { Credentials } from "./Credentials.mjs";
+export class CredentialProvider {
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }) {
+    this.credentials = new Credentials({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+  }
+  async getCredentials() {
+    return this.credentials.get();
+  }
+  setCredentials(credentials) {
+    if (credentials instanceof 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
+export default CredentialProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/esm/Credentials.d.mts

@@ -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/esm/Credentials.mjs

@@ -0,0 +1,38 @@
+export 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
+export default Credentials;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/esm/IamAwsProvider.d.mts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { CredentialProvider } from "./CredentialProvider.mjs";
+import { Credentials } from "./Credentials.mjs";
+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/esm/IamAwsProvider.mjs

@@ -0,0 +1,189 @@
+import * as fs from "fs/promises";
+import * as http from "http";
+import * as https from "https";
+import { URL, URLSearchParams } from "url";
+import { CredentialProvider } from "./CredentialProvider.mjs";
+import { Credentials } from "./Credentials.mjs";
+import { parseXml } from "./internal/helper.mjs";
+import { request } from "./internal/request.mjs";
+import { readAsString } from "./internal/response.mjs";
+export class IamAwsProvider extends 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(relativeUri, 'http://169.254.170.2');
+      } else if (fullUri) {
+        url = new 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(region ? `https://sts.${region}.amazonaws.com` : 'https://sts.amazonaws.com');
+    const hostValue = stsEndpoint.hostname;
+    const portValue = stsEndpoint.port;
+    const qryParams = new 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 request(transport, requestOptions, null);
+    const body = await readAsString(res);
+    const assumeRoleResponse = parseXml(body);
+    const creds = assumeRoleResponse.AssumeRoleWithWebIdentityResponse.AssumeRoleWithWebIdentityResult.Credentials;
+    this.accessExpiresAt = creds.Expiration;
+    return new 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('/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 request(transport, requestOptions, null);
+    return await readAsString(res);
+  }
+  async getIamRoleNamedUrl(token) {
+    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254';
+    const url = new URL('latest/meta-data/iam/security-credentials/', endpoint);
+    const roleName = await this.getIamRoleName(url, token);
+    return new 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 request(transport, requestOptions, null);
+    const body = await 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 request(transport, requestOptions, null);
+    const body = await 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({
+      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
+export default IamAwsProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/errors.d.mts

@@ -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/esm/errors.mjs

@@ -0,0 +1,117 @@
+/*
+ * 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.
+ */
+export class AnonymousRequestError extends ExtendableError {}
+
+/**
+ * InvalidArgumentError is generated for all invalid arguments.
+ */
+export class InvalidArgumentError extends ExtendableError {}
+
+/**
+ * InvalidPortError is generated when a non integer value is provided
+ * for ports.
+ */
+export class InvalidPortError extends ExtendableError {}
+
+/**
+ * InvalidEndpointError is generated when an invalid end point value is
+ * provided which does not follow domain standards.
+ */
+export 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 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 class InvalidObjectNameError extends ExtendableError {}
+
+/**
+ * AccessKeyRequiredError generated by signature methods when access
+ * key is not found.
+ */
+export class AccessKeyRequiredError extends ExtendableError {}
+
+/**
+ * SecretKeyRequiredError generated by signature methods when secret
+ * key is not found.
+ */
+export class SecretKeyRequiredError extends ExtendableError {}
+
+/**
+ * ExpiresParamError generated when expires parameter value is not
+ * well within stipulated limits.
+ */
+export class ExpiresParamError extends ExtendableError {}
+
+/**
+ * InvalidDateError generated when invalid date is found.
+ */
+export class InvalidDateError extends ExtendableError {}
+
+/**
+ * InvalidPrefixError generated when object prefix provided is invalid
+ * or does not conform to AWS S3 object key restrictions.
+ */
+export class InvalidPrefixError extends ExtendableError {}
+
+/**
+ * InvalidBucketPolicyError generated when the given bucket policy is invalid.
+ */
+export class InvalidBucketPolicyError extends ExtendableError {}
+
+/**
+ * IncorrectSizeError generated when total data read mismatches with
+ * the input size.
+ */
+export class IncorrectSizeError extends ExtendableError {}
+
+/**
+ * InvalidXMLError generated when an unknown XML is found.
+ */
+export class InvalidXMLError extends ExtendableError {}
+
+/**
+ * S3Error is generated for errors returned from S3 server.
+ * see getErrorTransformer for details
+ */
+export class S3Error extends ExtendableError {}
+export class IsValidBucketNameError extends ExtendableError {}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/helpers.d.mts

@@ -0,0 +1,156 @@
+import type { Encryption, ObjectMetaData, RequestHeaders } from "./internal/type.mjs";
+import { RETENTION_MODES } from "./internal/type.mjs";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.mjs";
+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/esm/helpers.mjs

@@ -0,0 +1,218 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as querystring from 'query-string';
+import * as errors from "./errors.mjs";
+import { getEncryptionHeaders, isEmpty, isEmptyObject, isNumber, isObject, isString, isValidBucketName, isValidObjectName } from "./internal/helper.mjs";
+import { RETENTION_MODES } from "./internal/type.mjs";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.mjs";
+export const DEFAULT_REGION = 'us-east-1';
+export const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7; // 7 days in seconds
+
+export 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 (!isValidBucketName(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket);
+    }
+    if (!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 && !isNumber(this.Start) || !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 (!isEmpty(this.VersionID)) {
+      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`;
+    }
+    if (!isEmpty(this.MatchETag)) {
+      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag;
+    }
+    if (!isEmpty(this.NoMatchETag)) {
+      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag;
+    }
+    if (!isEmpty(this.MatchModifiedSince)) {
+      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince;
+    }
+    if (!isEmpty(this.MatchUnmodifiedSince)) {
+      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince;
+    }
+    return headerOptions;
+  }
+}
+
+/**
+ * @deprecated use nodejs fs module
+ */
+export 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
+    });
+  });
+}
+export 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 (!isEmpty(userTags)) {
+      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective;
+      headerOptions['X-Amz-Tagging'] = isObject(userTags) ? querystring.stringify(userTags) : 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 = 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 (!isValidBucketName(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket);
+    }
+    if (!isValidObjectName(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`);
+    }
+    if (!isEmpty(this.UserMetadata) && !isObject(this.UserMetadata)) {
+      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`);
+    }
+    if (!isEmpty(this.Mode) && ![RETENTION_MODES.GOVERNANCE, 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 && 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
+ */
+export 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;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/internal/async.d.mts

@@ -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/esm/internal/async.mjs

@@ -0,0 +1,14 @@
+// promise helper for stdlib
+
+import * as fs from "fs";
+import * as stream from "stream";
+import { promisify } from "util";
+
+// TODO: use "node:fs/promise" directly after we stop testing on nodejs 12
+export { promises as fsp } from 'node:fs';
+export const streamPromise = {
+  // node:stream/promises Added in: v15.0.0
+  pipeline: promisify(stream.pipeline)
+};
+export const fstat = promisify(fs.fstat);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsInN0cmVhbSIsInByb21pc2lmeSIsInByb21pc2VzIiwiZnNwIiwic3RyZWFtUHJvbWlzZSIsInBpcGVsaW5lIiwiZnN0YXQiXSwic291cmNlcyI6WyJhc3luYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBwcm9taXNlIGhlbHBlciBmb3Igc3RkbGliXG5cbmltcG9ydCAqIGFzIGZzIGZyb20gJ25vZGU6ZnMnXG5pbXBvcnQgKiBhcyBzdHJlYW0gZnJvbSAnbm9kZTpzdHJlYW0nXG5pbXBvcnQgeyBwcm9taXNpZnkgfSBmcm9tICdub2RlOnV0aWwnXG5cbi8vIFRPRE86IHVzZSBcIm5vZGU6ZnMvcHJvbWlzZVwiIGRpcmVjdGx5IGFmdGVyIHdlIHN0b3AgdGVzdGluZyBvbiBub2RlanMgMTJcbmV4cG9ydCB7IHByb21pc2VzIGFzIGZzcCB9IGZyb20gJ25vZGU6ZnMnXG5leHBvcnQgY29uc3Qgc3RyZWFtUHJvbWlzZSA9IHtcbiAgLy8gbm9kZTpzdHJlYW0vcHJvbWlzZXMgQWRkZWQgaW46IHYxNS4wLjBcbiAgcGlwZWxpbmU6IHByb21pc2lmeShzdHJlYW0ucGlwZWxpbmUpLFxufVxuXG5leHBvcnQgY29uc3QgZnN0YXQgPSBwcm9taXNpZnkoZnMuZnN0YXQpXG4iXSwibWFwcGluZ3MiOiJBQUFBOztBQUVBLE9BQU8sS0FBS0EsRUFBRTtBQUNkLE9BQU8sS0FBS0MsTUFBTTtBQUNsQixTQUFTQyxTQUFTOztBQUVsQjtBQUNBLFNBQVNDLFFBQVEsSUFBSUMsR0FBRyxRQUFRLFNBQVM7QUFDekMsT0FBTyxNQUFNQyxhQUFhLEdBQUc7RUFDM0I7RUFDQUMsUUFBUSxFQUFFSixTQUFTLENBQUNELE1BQU0sQ0FBQ0ssUUFBUTtBQUNyQyxDQUFDO0FBRUQsT0FBTyxNQUFNQyxLQUFLLEdBQUdMLFNBQVMsQ0FBQ0YsRUFBRSxDQUFDTyxLQUFLLENBQUMifQ==

SerpentRace_Backend/node_modules/minio/dist/esm/internal/callbackify.mjs

@@ -0,0 +1,15 @@
+// wrapper an async function that support callback style API.
+// It will preserve 'this'.
+export 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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImFyZ3VtZW50cyIsImNhbGxiYWNrIiwicG9wIiwiYXBwbHkiLCJ0aGVuIiwicmVzdWx0IiwiZXJyIl0sInNvdXJjZXMiOlsiY2FsbGJhY2tpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gd3JhcHBlciBhbiBhc3luYyBmdW5jdGlvbiB0aGF0IHN1cHBvcnQgY2FsbGJhY2sgc3R5bGUgQVBJLlxuLy8gSXQgd2lsbCBwcmVzZXJ2ZSAndGhpcycuXG5leHBvcnQgZnVuY3Rpb24gY2FsbGJhY2tpZnkoZm4pIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICgpIHtcbiAgICBjb25zdCBhcmdzID0gWy4uLmFyZ3VtZW50c11cbiAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcblxuICAgIC8vIElmIHRoZSBsYXN0IGFyZ3VtZW50IGlzIGEgZnVuY3Rpb24sIGFzc3VtZSBpdCdzIHRoZSBjYWxsYmFjay5cbiAgICBpZiAodHlwZW9mIGNhbGxiYWNrID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncykudGhlbihcbiAgICAgICAgKHJlc3VsdCkgPT4gY2FsbGJhY2sobnVsbCwgcmVzdWx0KSxcbiAgICAgICAgKGVycikgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJndW1lbnRzKVxuICB9XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7QUFDQSxPQUFPLFNBQVNBLFdBQVdBLENBQUNDLEVBQUUsRUFBRTtFQUM5QixPQUFPLFlBQVk7SUFDakIsTUFBTUMsSUFBSSxHQUFHLENBQUMsR0FBR0MsU0FBUyxDQUFDO0lBQzNCLE1BQU1DLFFBQVEsR0FBR0YsSUFBSSxDQUFDRyxHQUFHLENBQUMsQ0FBQzs7SUFFM0I7SUFDQSxJQUFJLE9BQU9ELFFBQVEsS0FBSyxVQUFVLEVBQUU7TUFDbEMsT0FBT0gsRUFBRSxDQUFDSyxLQUFLLENBQUMsSUFBSSxFQUFFSixJQUFJLENBQUMsQ0FBQ0ssSUFBSSxDQUM3QkMsTUFBTSxJQUFLSixRQUFRLENBQUMsSUFBSSxFQUFFSSxNQUFNLENBQUMsRUFDakNDLEdBQUcsSUFBS0wsUUFBUSxDQUFDSyxHQUFHLENBQ3ZCLENBQUM7SUFDSDtJQUVBLE9BQU9SLEVBQUUsQ0FBQ0ssS0FBSyxDQUFDLElBQUksRUFBRUgsU0FBUyxDQUFDO0VBQ2xDLENBQUM7QUFDSCJ9

SerpentRace_Backend/node_modules/minio/dist/esm/internal/client.d.mts

@@ -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.mjs";
+import type { SelectResults } from "../helpers.mjs";
+import { CopyDestinationOptions, CopySourceOptions, LEGAL_HOLD_STATUS } from "../helpers.mjs";
+import type { PostPolicyResult } from "../minio.mjs";
+import { CopyConditions } from "./copy-conditions.mjs";
+import { Extensions } from "./extensions.mjs";
+import { PostPolicy } from "./post-policy.mjs";
+import type { Region } from "./s3-endpoints.mjs";
+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.mjs";
+import type { ListMultipartResult, UploadedPart } from "./xml-parser.mjs";
+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/esm/internal/copy-conditions.d.mts

@@ -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/esm/internal/copy-conditions.mjs

@@ -0,0 +1,25 @@
+export 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;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

SerpentRace_Backend/node_modules/minio/dist/esm/internal/extensions.d.mts

@@ -0,0 +1,18 @@
+import type { TypedClient } from "./client.mjs";
+import type { BucketItemWithMetadata, BucketStream } from "./type.mjs";
+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/esm/internal/extensions.mjs

@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+import * as stream from "stream";
+import * as errors from "../errors.mjs";
+import { isBoolean, isString, isValidBucketName, isValidPrefix, uriEscape } from "./helper.mjs";
+import { readAsString } from "./response.mjs";
+import { parseListObjectsV2WithMetadata } from "./xml-parser.mjs";
+export 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 (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!isValidPrefix(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!isString(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!isBoolean(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (!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=${uriEscape(prefix)}`);
+    queries.push(`delimiter=${uriEscape(delimiter)}`);
+    queries.push(`metadata=true`);
+    if (continuationToken) {
+      continuationToken = uriEscape(continuationToken);
+      queries.push(`continuation-token=${continuationToken}`);
+    }
+    // Set start-after
+    if (startAfter) {
+      startAfter = 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 parseListObjectsV2WithMetadata(await readAsString(res));
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/internal/helper.d.mts

@@ -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.mjs";
+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/esm/internal/helper.mjs

@@ -0,0 +1,547 @@
+/*
+ * 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.
+ */
+
+import * as crypto from "crypto";
+import * as stream from "stream";
+import { XMLParser } from 'fast-xml-parser';
+import ipaddr from 'ipaddr.js';
+import _ from 'lodash';
+import * as mime from 'mime-types';
+import { fsp, fstat } from "./async.mjs";
+import { ENCRYPTION_TYPES } from "./type.mjs";
+const MetaDataHeaderPrefix = 'x-amz-meta-';
+export 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()}`;
+export function uriEscape(uriStr) {
+  return encodeURIComponent(uriStr).replace(/[!'()*]/g, encodeAsHex);
+}
+export function uriResourceEscape(string) {
+  return uriEscape(string).replace(/%2F/g, '/');
+}
+export 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'
+ */
+export 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.
+ */
+export function isVirtualHostStyle(endpoint, protocol, bucket, pathStyle) {
+  if (protocol === 'https:' && bucket.includes('.')) {
+    return false;
+  }
+  return isAmazonEndpoint(endpoint) || !pathStyle;
+}
+export function isValidIP(ip) {
+  return ipaddr.isValid(ip);
+}
+
+/**
+ * @returns if endpoint is valid domain.
+ */
+export function isValidEndpoint(endpoint) {
+  return isValidDomain(endpoint) || isValidIP(endpoint);
+}
+
+/**
+ * @returns if input host is a valid domain.
+ */
+export 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')
+ * ```
+ */
+export function probeContentType(path) {
+  let contentType = mime.lookup(path);
+  if (!contentType) {
+    contentType = 'application/octet-stream';
+  }
+  return contentType;
+}
+
+/**
+ * is input port valid.
+ */
+export 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;
+}
+export 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
+ */
+export function isValidObjectName(objectName) {
+  if (!isValidPrefix(objectName)) {
+    return false;
+  }
+  return objectName.length !== 0;
+}
+
+/**
+ * check if prefix is valid
+ */
+export function isValidPrefix(prefix) {
+  if (!isString(prefix)) {
+    return false;
+  }
+  if (prefix.length > 1024) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * check if typeof arg number
+ */
+export function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * check if typeof arg function
+ */
+export function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+/**
+ * check if typeof arg string
+ */
+export function isString(arg) {
+  return typeof arg === 'string';
+}
+
+/**
+ * check if typeof arg object
+ */
+export function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+/**
+ * check if object is readable stream
+ */
+export function isReadableStream(arg) {
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  return isObject(arg) && isFunction(arg._read);
+}
+
+/**
+ * check if arg is boolean
+ */
+export function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+export function isEmpty(o) {
+  return _.isEmpty(o);
+}
+export function isEmptyObject(o) {
+  return Object.values(o).filter(x => x !== undefined).length !== 0;
+}
+export function isDefined(o) {
+  return o !== null && o !== undefined;
+}
+
+/**
+ * check if arg is a valid date
+ */
+export function isValidDate(arg) {
+  // @ts-expect-error checknew Date(Math.NaN)
+  return arg instanceof Date && !isNaN(arg);
+}
+
+/**
+ * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z
+ */
+export 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'
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export function prependXAMZMeta(metaData) {
+  if (!metaData) {
+    return {};
+  }
+  return _.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
+ */
+export 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
+ */
+export 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
+ */
+export function isStorageClassHeader(key) {
+  return key.toLowerCase() === 'x-amz-storage-class';
+}
+export function extractMetadata(headers) {
+  return _.mapKeys(_.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;
+  });
+}
+export function getVersionId(headers = {}) {
+  return headers['x-amz-version-id'] || null;
+}
+export function getSourceVersionId(headers = {}) {
+  return headers['x-amz-copy-source-version-id'] || null;
+}
+export function sanitizeETag(etag = '') {
+  const replaceChars = {
+    '"': '',
+    '&quot;': '',
+    '&#34;': '',
+    '&QUOT;': '',
+    '&#x00022': ''
+  };
+  return etag.replace(/^("|&quot;|&#34;)|("|&quot;|&#34;)$/g, m => replaceChars[m]);
+}
+export 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');
+}
+export 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
+ */
+export function toArray(param) {
+  if (!Array.isArray(param)) {
+    return [param];
+  }
+  return param;
+}
+export 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);
+}
+export function sanitizeSize(size) {
+  return size ? Number.parseInt(size) : undefined;
+}
+export 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
+};
+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.
+ */
+export function getEncryptionHeaders(encConfig) {
+  const encType = encConfig.type;
+  if (!isEmpty(encType)) {
+    if (encType === ENCRYPTION_TYPES.SSEC) {
+      return {
+        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256'
+      };
+    } else if (encType === ENCRYPTION_TYPES.KMS) {
+      return {
+        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,
+        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID
+      };
+    }
+  }
+  return {};
+}
+export 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.
+ */
+export 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 XMLParser({
+  numberParseOptions: {
+    eNotation: false,
+    hex: true,
+    leadingZeros: true
+  }
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function parseXml(xml) {
+  const result = fxp.parse(xml);
+  if (result.Error) {
+    throw result.Error;
+  }
+  return result;
+}
+
+/**
+ * get content size of object content to upload
+ */
+export 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 fsp.lstat(filePath);
+    return stat.size;
+  }
+
+  // property of `fs.ReadStream`
+  const fd = s.fd;
+  if (fd && typeof fd === 'number') {
+    const stat = await fstat(fd);
+    return stat.size;
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/internal/join-host-port.d.mts

@@ -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/esm/internal/join-host-port.mjs

@@ -0,0 +1,23 @@
+/**
+ * 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 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/OiBudW1iZXIpOiBzdHJpbmcge1xuICBpZiAocG9ydCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuIGhvc3RcbiAgfVxuXG4gIC8vIFdlIGFzc3VtZSB0aGF0IGhvc3QgaXMgYSBsaXRlcmFsIElQdjYgYWRkcmVzcyBpZiBob3N0IGhhc1xuICAvLyBjb2xvbnMuXG4gIGlmIChob3N0LmluY2x1ZGVzKCc6JykpIHtcbiAgICByZXR1cm4gYFske2hvc3R9XToke3BvcnQudG9TdHJpbmcoKX1gXG4gIH1cblxuICByZXR1cm4gYCR7aG9zdH06JHtwb3J0LnRvU3RyaW5nKCl9YFxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sU0FBU0EsWUFBWUEsQ0FBQ0MsSUFBWSxFQUFFQyxJQUFhLEVBQVU7RUFDaEUsSUFBSUEsSUFBSSxLQUFLQyxTQUFTLEVBQUU7SUFDdEIsT0FBT0YsSUFBSTtFQUNiOztFQUVBO0VBQ0E7RUFDQSxJQUFJQSxJQUFJLENBQUNHLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRTtJQUN0QixPQUFRLElBQUdILElBQUssS0FBSUMsSUFBSSxDQUFDRyxRQUFRLENBQUMsQ0FBRSxFQUFDO0VBQ3ZDO0VBRUEsT0FBUSxHQUFFSixJQUFLLElBQUdDLElBQUksQ0FBQ0csUUFBUSxDQUFDLENBQUUsRUFBQztBQUNyQyJ9

SerpentRace_Backend/node_modules/minio/dist/esm/internal/post-policy.d.mts

@@ -0,0 +1,17 @@
+import type { ObjectMetaData } from "./type.mjs";
+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/esm/internal/post-policy.mjs

@@ -0,0 +1,98 @@
+// Build PostPolicy object that can be signed by presignedPostPolicy
+import * as errors from "../errors.mjs";
+import { isObject, isValidBucketName, isValidObjectName, isValidPrefix } from "./helper.mjs";
+export 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 (!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 (!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 (!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 (!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();
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlcnJvcnMiLCJpc09iamVjdCIsImlzVmFsaWRCdWNrZXROYW1lIiwiaXNWYWxpZE9iamVjdE5hbWUiLCJpc1ZhbGlkUHJlZml4IiwiUG9zdFBvbGljeSIsInBvbGljeSIsImNvbmRpdGlvbnMiLCJmb3JtRGF0YSIsInNldEV4cGlyZXMiLCJkYXRlIiwiSW52YWxpZERhdGVFcnJvciIsImV4cGlyYXRpb24iLCJ0b0lTT1N0cmluZyIsInNldEtleSIsIm9iamVjdE5hbWUiLCJJbnZhbGlkT2JqZWN0TmFtZUVycm9yIiwicHVzaCIsImtleSIsInNldEtleVN0YXJ0c1dpdGgiLCJwcmVmaXgiLCJJbnZhbGlkUHJlZml4RXJyb3IiLCJzZXRCdWNrZXQiLCJidWNrZXROYW1lIiwiSW52YWxpZEJ1Y2tldE5hbWVFcnJvciIsImJ1Y2tldCIsInNldENvbnRlbnRUeXBlIiwidHlwZSIsIkVycm9yIiwic2V0Q29udGVudFR5cGVTdGFydHNXaXRoIiwic2V0Q29udGVudERpc3Bvc2l0aW9uIiwidmFsdWUiLCJzZXRDb250ZW50TGVuZ3RoUmFuZ2UiLCJtaW4iLCJtYXgiLCJzZXRVc2VyTWV0YURhdGEiLCJtZXRhRGF0YSIsIlR5cGVFcnJvciIsIk9iamVjdCIsImVudHJpZXMiLCJmb3JFYWNoIiwiYW16TWV0YURhdGFLZXkiLCJ0b1N0cmluZyJdLCJzb3VyY2VzIjpbInBvc3QtcG9saWN5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIEJ1aWxkIFBvc3RQb2xpY3kgb2JqZWN0IHRoYXQgY2FuIGJlIHNpZ25lZCBieSBwcmVzaWduZWRQb3N0UG9saWN5XG5pbXBvcnQgKiBhcyBlcnJvcnMgZnJvbSAnLi4vZXJyb3JzLnRzJ1xuaW1wb3J0IHsgaXNPYmplY3QsIGlzVmFsaWRCdWNrZXROYW1lLCBpc1ZhbGlkT2JqZWN0TmFtZSwgaXNWYWxpZFByZWZpeCB9IGZyb20gJy4vaGVscGVyLnRzJ1xuaW1wb3J0IHR5cGUgeyBPYmplY3RNZXRhRGF0YSB9IGZyb20gJy4vdHlwZS50cydcblxuZXhwb3J0IGNsYXNzIFBvc3RQb2xpY3kge1xuICBwdWJsaWMgcG9saWN5OiB7IGNvbmRpdGlvbnM6IChzdHJpbmcgfCBudW1iZXIpW11bXTsgZXhwaXJhdGlvbj86IHN0cmluZyB9ID0ge1xuICAgIGNvbmRpdGlvbnM6IFtdLFxuICB9XG4gIHB1YmxpYyBmb3JtRGF0YTogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHt9XG5cbiAgLy8gc2V0IGV4cGlyYXRpb24gZGF0ZVxuICBzZXRFeHBpcmVzKGRhdGU6IERhdGUpIHtcbiAgICBpZiAoIWRhdGUpIHtcbiAgICAgIHRocm93IG5ldyBlcnJvcnMuSW52YWxpZERhdGVFcnJvcignSW52YWxpZCBkYXRlOiBjYW5ub3QgYmUgbnVsbCcpXG4gICAgfVxuICAgIHRoaXMucG9saWN5LmV4cGlyYXRpb24gPSBkYXRlLnRvSVNPU3RyaW5nKClcbiAgfVxuXG4gIC8vIHNldCBvYmplY3QgbmFtZVxuICBzZXRLZXkob2JqZWN0TmFtZTogc3RyaW5nKSB7XG4gICAgaWYgKCFpc1ZhbGlkT2JqZWN0TmFtZShvYmplY3ROYW1lKSkge1xuICAgICAgdGhyb3cgbmV3IGVycm9ycy5JbnZhbGlkT2JqZWN0TmFtZUVycm9yKGBJbnZhbGlkIG9iamVjdCBuYW1lIDogJHtvYmplY3ROYW1lfWApXG4gICAgfVxuICAgIHRoaXMucG9saWN5LmNvbmRpdGlvbnMucHVzaChbJ2VxJywgJyRrZXknLCBvYmplY3ROYW1lXSlcbiAgICB0aGlzLmZvcm1EYXRhLmtleSA9IG9iamVjdE5hbWVcbiAgfVxuXG4gIC8vIHNldCBvYmplY3QgbmFtZSBwcmVmaXgsIGkuZSBwb2xpY3kgYWxsb3dzIGFueSBrZXlzIHdpdGggdGhpcyBwcmVmaXhcbiAgc2V0S2V5U3RhcnRzV2l0aChwcmVmaXg6IHN0cmluZykge1xuICAgIGlmICghaXNWYWxpZFByZWZpeChwcmVmaXgpKSB7XG4gICAgICB0aHJvdyBuZXcgZXJyb3JzLkludmFsaWRQcmVmaXhFcnJvcihgSW52YWxpZCBwcmVmaXggOiAke3ByZWZpeH1gKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydzdGFydHMtd2l0aCcsICcka2V5JywgcHJlZml4XSlcbiAgICB0aGlzLmZvcm1EYXRhLmtleSA9IHByZWZpeFxuICB9XG5cbiAgLy8gc2V0IGJ1Y2tldCBuYW1lXG4gIHNldEJ1Y2tldChidWNrZXROYW1lOiBzdHJpbmcpIHtcbiAgICBpZiAoIWlzVmFsaWRCdWNrZXROYW1lKGJ1Y2tldE5hbWUpKSB7XG4gICAgICB0aHJvdyBuZXcgZXJyb3JzLkludmFsaWRCdWNrZXROYW1lRXJyb3IoYEludmFsaWQgYnVja2V0IG5hbWUgOiAke2J1Y2tldE5hbWV9YClcbiAgICB9XG4gICAgdGhpcy5wb2xpY3kuY29uZGl0aW9ucy5wdXNoKFsnZXEnLCAnJGJ1Y2tldCcsIGJ1Y2tldE5hbWVdKVxuICAgIHRoaXMuZm9ybURhdGEuYnVja2V0ID0gYnVja2V0TmFtZVxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtVHlwZVxuICBzZXRDb250ZW50VHlwZSh0eXBlOiBzdHJpbmcpIHtcbiAgICBpZiAoIXR5cGUpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignY29udGVudC10eXBlIGNhbm5vdCBiZSBudWxsJylcbiAgICB9XG4gICAgdGhpcy5wb2xpY3kuY29uZGl0aW9ucy5wdXNoKFsnZXEnLCAnJENvbnRlbnQtVHlwZScsIHR5cGVdKVxuICAgIHRoaXMuZm9ybURhdGFbJ0NvbnRlbnQtVHlwZSddID0gdHlwZVxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtVHlwZSBwcmVmaXgsIGkuZSBpbWFnZS8gYWxsb3dzIGFueSBpbWFnZVxuICBzZXRDb250ZW50VHlwZVN0YXJ0c1dpdGgocHJlZml4OiBzdHJpbmcpIHtcbiAgICBpZiAoIXByZWZpeCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdjb250ZW50LXR5cGUgY2Fubm90IGJlIG51bGwnKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydzdGFydHMtd2l0aCcsICckQ29udGVudC1UeXBlJywgcHJlZml4XSlcbiAgICB0aGlzLmZvcm1EYXRhWydDb250ZW50LVR5cGUnXSA9IHByZWZpeFxuICB9XG5cbiAgLy8gc2V0IENvbnRlbnQtRGlzcG9zaXRpb25cbiAgc2V0Q29udGVudERpc3Bvc2l0aW9uKHZhbHVlOiBzdHJpbmcpIHtcbiAgICBpZiAoIXZhbHVlKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ2NvbnRlbnQtZGlzcG9zaXRpb24gY2Fubm90IGJlIG51bGwnKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydlcScsICckQ29udGVudC1EaXNwb3NpdGlvbicsIHZhbHVlXSlcbiAgICB0aGlzLmZvcm1EYXRhWydDb250ZW50LURpc3Bvc2l0aW9uJ10gPSB2YWx1ZVxuICB9XG5cbiAgLy8gc2V0IG1pbmltdW0vbWF4aW11bSBsZW5ndGggb2Ygd2hhdCBDb250ZW50LUxlbmd0aCBjYW4gYmUuXG4gIHNldENvbnRlbnRMZW5ndGhSYW5nZShtaW46IG51bWJlciwgbWF4OiBudW1iZXIpIHtcbiAgICBpZiAobWluID4gbWF4KSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ21pbiBjYW5ub3QgYmUgbW9yZSB0aGFuIG1heCcpXG4gICAgfVxuICAgIGlmIChtaW4gPCAwKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ21pbiBzaG91bGQgYmUgPiAwJylcbiAgICB9XG4gICAgaWYgKG1heCA8IDApIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignbWF4IHNob3VsZCBiZSA+IDAnKVxuICAgIH1cbiAgICB0aGlzLnBvbGljeS5jb25kaXRpb25zLnB1c2goWydjb250ZW50LWxlbmd0aC1yYW5nZScsIG1pbiwgbWF4XSlcbiAgfVxuXG4gIC8vIHNldCB1c2VyIGRlZmluZWQgbWV0YWRhdGFcbiAgc2V0VXNlck1ldGFEYXRhKG1ldGFEYXRhOiBPYmplY3RNZXRhRGF0YSkge1xuICAgIGlmICghaXNPYmplY3QobWV0YURhdGEpKSB7XG4gICAgICB0aHJvdyBuZXcgVHlwZUVycm9yKCdtZXRhZGF0YSBzaG91bGQgYmUgb2YgdHlwZSBcIm9iamVjdFwiJylcbiAgICB9XG4gICAgT2JqZWN0LmVudHJpZXMobWV
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/internal/request.d.mts

@@ -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.mjs";
+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/esm/internal/request.mjs

@@ -0,0 +1,75 @@
+import { pipeline } from "stream";
+import { promisify } from "util";
+const pipelineAsync = promisify(pipeline);
+export 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)
+export const retryHttpCodes = {
+  408: true,
+  429: true,
+  499: true,
+  500: true,
+  502: true,
+  503: true,
+  504: true,
+  520: true
+};
+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;
+};
+export 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/esm/internal/response.d.mts

@@ -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/esm/internal/response.mjs

@@ -0,0 +1,16 @@
+export 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)));
+  });
+}
+export async function readAsString(res) {
+  const body = await readAsBuffer(res);
+  return body.toString();
+}
+export 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/esm/internal/s3-endpoints.d.mts

@@ -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/esm/internal/s3-endpoints.mjs

@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+import { isString } from "./helper.mjs";
+
+// 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.
+export function getS3Endpoint(region) {
+  if (!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/esm/internal/type.d.mts

@@ -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.mjs";
+import type { CopyConditions } from "./copy-conditions.mjs";
+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/esm/internal/type.mjs

@@ -0,0 +1,34 @@
+// nodejs IncomingHttpHeaders is Record<string, string | string[]>, but it's actually this:
+
+export let ENCRYPTION_TYPES = /*#__PURE__*/function (ENCRYPTION_TYPES) {
+  ENCRYPTION_TYPES["SSEC"] = "SSE-C";
+  ENCRYPTION_TYPES["KMS"] = "KMS";
+  return ENCRYPTION_TYPES;
+}({});
+export let RETENTION_MODES = /*#__PURE__*/function (RETENTION_MODES) {
+  RETENTION_MODES["GOVERNANCE"] = "GOVERNANCE";
+  RETENTION_MODES["COMPLIANCE"] = "COMPLIANCE";
+  return RETENTION_MODES;
+}({});
+export let RETENTION_VALIDITY_UNITS = /*#__PURE__*/function (RETENTION_VALIDITY_UNITS) {
+  RETENTION_VALIDITY_UNITS["DAYS"] = "Days";
+  RETENTION_VALIDITY_UNITS["YEARS"] = "Years";
+  return RETENTION_VALIDITY_UNITS;
+}({});
+export 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 **/
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/internal/xml-parser.d.mts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as http from 'node:http';
+import { SelectResults } from "../helpers.mjs";
+import type { BucketItemFromList, BucketItemWithMetadata, CopyObjectResultV1, ObjectInfo, ObjectLockInfo, ReplicationConfig } from "./type.mjs";
+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/esm/internal/xml-parser.mjs

@@ -0,0 +1,691 @@
+import crc32 from 'buffer-crc32';
+import { XMLParser } from 'fast-xml-parser';
+import * as errors from "../errors.mjs";
+import { SelectResults } from "../helpers.mjs";
+import { isObject, parseXml, readableStream, sanitizeETag, sanitizeObjectKey, sanitizeSize, toArray } from "./helper.mjs";
+import { readAsString } from "./response.mjs";
+import { RETENTION_VALIDITY_UNITS } from "./type.mjs";
+
+// parse XML response for bucket region
+export function parseBucketRegion(xml) {
+  // return region information
+  return parseXml(xml).LocationConstraint;
+}
+const fxp = new XMLParser();
+const fxpWithoutNumParser = new XMLParser({
+  // @ts-ignore
+  numberParseOptions: {
+    skipLike: /./
+  }
+});
+
+// Parse XML and return information as Javascript types
+// parse error XML response
+export 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
+export 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 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
+ */
+export function parseListObjectsV2WithMetadata(xml) {
+  const result = {
+    objects: [],
+    isTruncated: false,
+    nextContinuationToken: ''
+  };
+  let xmlobj = 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) {
+    toArray(xmlobj.Contents).forEach(content => {
+      const name = sanitizeObjectKey(content.Key);
+      const lastModified = new Date(content.LastModified);
+      const etag = sanitizeETag(content.ETag);
+      const size = content.Size;
+      let tags = {};
+      if (content.UserTags != null) {
+        toArray(content.UserTags.split('&')).forEach(tag => {
+          const [key, value] = tag.split('=');
+          tags[key] = value;
+        });
+      } else {
+        tags = {};
+      }
+      let metadata;
+      if (content.UserMetadata != null) {
+        metadata = toArray(content.UserMetadata)[0];
+      } else {
+        metadata = null;
+      }
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size,
+        metadata,
+        tags
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    toArray(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+// parse XML response for list parts of an in progress multipart upload
+export function parseListParts(xml) {
+  let xmlobj = 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 = toArray(xmlobj.NextPartNumberMarker)[0] || '';
+  }
+  if (xmlobj.Part) {
+    toArray(xmlobj.Part).forEach(p => {
+      const part = parseInt(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;
+}
+export function parseListBucket(xml) {
+  let result = [];
+  const listBucketResultParser = new 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 = toArray(Buckets.Bucket).map((bucket = {}) => {
+      const {
+        Name: bucketName,
+        CreationDate
+      } = bucket;
+      const creationDate = new Date(CreationDate);
+      return {
+        name: bucketName,
+        creationDate
+      };
+    });
+  }
+  return result;
+}
+export function parseInitiateMultipart(xml) {
+  let xmlobj = 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"');
+}
+export function parseReplicationConfig(xml) {
+  const xmlObj = parseXml(xml);
+  const {
+    Role,
+    Rule
+  } = xmlObj.ReplicationConfiguration;
+  return {
+    ReplicationConfiguration: {
+      role: Role,
+      rules: toArray(Rule)
+    }
+  };
+}
+export function parseObjectLegalHoldConfig(xml) {
+  const xmlObj = parseXml(xml);
+  return xmlObj.LegalHold;
+}
+export function parseTagging(xml) {
+  const xmlObj = 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 (isObject(tagResult)) {
+      result.push(tagResult);
+    } else {
+      result = tagResult;
+    }
+  }
+  return result;
+}
+
+// parse XML response when a multipart upload is completed
+export function parseCompleteMultipart(xml) {
+  const xmlobj = parseXml(xml).CompleteMultipartUploadResult;
+  if (xmlobj.Location) {
+    const location = toArray(xmlobj.Location)[0];
+    const bucket = 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 = toArray(xmlobj.Code)[0];
+    const errMessage = toArray(xmlobj.Message)[0];
+    return {
+      errCode,
+      errMessage
+    };
+  }
+}
+// parse XML response for listing in-progress multipart uploads
+export function parseListMultipart(xml) {
+  const result = {
+    prefixes: [],
+    uploads: [],
+    isTruncated: false,
+    nextKeyMarker: '',
+    nextUploadIdMarker: ''
+  };
+  let xmlobj = 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) {
+    toArray(xmlobj.CommonPrefixes).forEach(prefix => {
+      // @ts-expect-error index check
+      result.prefixes.push({
+        prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0])
+      });
+    });
+  }
+  if (xmlobj.Upload) {
+    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;
+}
+export function parseObjectLockConfig(xml) {
+  const xmlObj = 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 = RETENTION_VALIDITY_UNITS.YEARS;
+      } else {
+        lockConfigResult.validity = retentionResp.Days;
+        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS;
+      }
+    }
+  }
+  return lockConfigResult;
+}
+export function parseBucketVersioningConfig(xml) {
+  const xmlObj = 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();
+}
+export function parseSelectObjectContentResponse(res) {
+  const selectResults = new SelectResults({}); // will be returned
+
+  const responseStream = 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 = crc32(totalByteLengthBuffer);
+    const headerBytesBuffer = Buffer.from(responseStream.read(4));
+    msgCrcAccumulator = crc32(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 = crc32(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 = crc32(headerBytes, msgCrcAccumulator);
+      const headerReaderStream = 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 = crc32(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 = 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);
+              }
+          }
+        }
+    }
+  }
+}
+export function parseLifecycleConfig(xml) {
+  const xmlObj = parseXml(xml);
+  return xmlObj.LifecycleConfiguration;
+}
+export function parseBucketEncryptionConfig(xml) {
+  return parseXml(xml);
+}
+export function parseObjectRetentionConfig(xml) {
+  const xmlObj = parseXml(xml);
+  const retentionConfig = xmlObj.Retention;
+  return {
+    mode: retentionConfig.Mode,
+    retainUntilDate: retentionConfig.RetainUntilDate
+  };
+}
+export function removeObjectsParser(xml) {
+  const xmlObj = 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 toArray(xmlObj.DeleteResult.Error);
+  }
+  return [];
+}
+
+// parse XML response for copy object
+export function parseCopyObject(xml) {
+  const result = {
+    etag: '',
+    lastModified: ''
+  };
+  let xmlobj = 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 (!isObject(opts)) {
+    opts = {};
+  }
+  const name = sanitizeObjectKey(toArray(Key)[0] || '');
+  const lastModified = LastModified ? new Date(toArray(LastModified)[0] || '') : undefined;
+  const etag = sanitizeETag(toArray(ETag)[0] || '');
+  const size = 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
+export 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) {
+      toArray(commonPrefixEntry).forEach(commonPrefix => {
+        result.objects.push({
+          prefix: sanitizeObjectKey(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) {
+      toArray(listBucketResult.Contents).forEach(content => {
+        const name = sanitizeObjectKey(toArray(content.Key)[0] || '');
+        const lastModified = new Date(toArray(content.LastModified)[0] || '');
+        const etag = sanitizeETag(toArray(content.ETag)[0] || '');
+        const size = 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) {
+      toArray(listVersionsResult.Version).forEach(content => {
+        result.objects.push(formatObjInfo(content));
+      });
+    }
+    if (listVersionsResult.DeleteMarker) {
+      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;
+}
+export function uploadPartParser(xml) {
+  const xmlObj = parseXml(xml);
+  const respEl = xmlObj.CopyPartResult;
+  return respEl;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/minio.d.mts

@@ -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.mjs";
+import type { ClientOptions, NoResultCallback, RemoveOptions } from "./internal/client.mjs";
+import { TypedClient } from "./internal/client.mjs";
+import { CopyConditions } from "./internal/copy-conditions.mjs";
+import { PostPolicy } from "./internal/post-policy.mjs";
+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.mjs";
+import type { NotificationConfig, NotificationEvent, NotificationPoller } from "./notification.mjs";
+export * from "./errors.mjs";
+export * from "./helpers.mjs";
+export type { Region } from "./internal/s3-endpoints.mjs";
+export type * from "./notification.mjs";
+export * from "./notification.mjs";
+export { CopyConditions, PostPolicy };
+export type { MakeBucketOpt } from "./internal/client.mjs";
+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/esm/minio.mjs

@@ -0,0 +1,308 @@
+/*
+ * 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.
+ */
+
+import * as Stream from "stream";
+import xml2js from 'xml2js';
+import * as errors from "./errors.mjs";
+import { callbackify } from "./internal/callbackify.mjs";
+import { TypedClient } from "./internal/client.mjs";
+import { CopyConditions } from "./internal/copy-conditions.mjs";
+import { isBoolean, isFunction, isNumber, isObject, isString, isValidBucketName, isValidPrefix, pipesetup, uriEscape } from "./internal/helper.mjs";
+import { PostPolicy } from "./internal/post-policy.mjs";
+import { NotificationConfig, NotificationPoller } from "./notification.mjs";
+import { promisify } from "./promisify.mjs";
+import * as transformers from "./transformers.mjs";
+export * from "./errors.mjs";
+export * from "./helpers.mjs";
+export * from "./notification.mjs";
+export { CopyConditions, PostPolicy };
+export class Client extends 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 (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!isString(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!isString(continuationToken)) {
+      throw new TypeError('continuationToken should be of type "string"');
+    }
+    if (!isString(delimiter)) {
+      throw new TypeError('delimiter should be of type "string"');
+    }
+    if (!isNumber(maxKeys)) {
+      throw new TypeError('maxKeys should be of type "number"');
+    }
+    if (!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=${uriEscape(prefix)}`);
+    queries.push(`delimiter=${uriEscape(delimiter)}`);
+    if (continuationToken) {
+      continuationToken = uriEscape(continuationToken);
+      queries.push(`continuation-token=${continuationToken}`);
+    }
+    // Set start-after
+    if (startAfter) {
+      startAfter = 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);
+      }
+      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 (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!isValidPrefix(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!isString(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!isBoolean(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (!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 (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!isObject(config)) {
+      throw new TypeError('notification config should be of type "Object"');
+    }
+    if (!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 NotificationConfig(), cb);
+  }
+
+  // Return the list of notification configurations stored
+  // in the S3 provider
+  getBucketNotification(bucketName, cb) {
+    if (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!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;
+      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 (!isValidBucketName(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!isString(prefix)) {
+      throw new TypeError('prefix must be of type string');
+    }
+    if (!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 NotificationPoller(this, bucketName, prefix, suffix, events);
+    listener.start();
+    return listener;
+  }
+}
+Client.prototype.getBucketNotification = promisify(Client.prototype.getBucketNotification);
+Client.prototype.setBucketNotification = promisify(Client.prototype.setBucketNotification);
+Client.prototype.removeAllBucketNotification = promisify(Client.prototype.removeAllBucketNotification);
+
+// refactored API use promise internally
+Client.prototype.makeBucket = callbackify(Client.prototype.makeBucket);
+Client.prototype.bucketExists = callbackify(Client.prototype.bucketExists);
+Client.prototype.removeBucket = callbackify(Client.prototype.removeBucket);
+Client.prototype.listBuckets = callbackify(Client.prototype.listBuckets);
+Client.prototype.getObject = callbackify(Client.prototype.getObject);
+Client.prototype.fGetObject = callbackify(Client.prototype.fGetObject);
+Client.prototype.getPartialObject = callbackify(Client.prototype.getPartialObject);
+Client.prototype.statObject = callbackify(Client.prototype.statObject);
+Client.prototype.putObjectRetention = callbackify(Client.prototype.putObjectRetention);
+Client.prototype.putObject = callbackify(Client.prototype.putObject);
+Client.prototype.fPutObject = callbackify(Client.prototype.fPutObject);
+Client.prototype.removeObject = callbackify(Client.prototype.removeObject);
+Client.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication);
+Client.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication);
+Client.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication);
+Client.prototype.getObjectLegalHold = callbackify(Client.prototype.getObjectLegalHold);
+Client.prototype.setObjectLegalHold = callbackify(Client.prototype.setObjectLegalHold);
+Client.prototype.setObjectLockConfig = callbackify(Client.prototype.setObjectLockConfig);
+Client.prototype.getObjectLockConfig = callbackify(Client.prototype.getObjectLockConfig);
+Client.prototype.getBucketPolicy = callbackify(Client.prototype.getBucketPolicy);
+Client.prototype.setBucketPolicy = callbackify(Client.prototype.setBucketPolicy);
+Client.prototype.getBucketTagging = callbackify(Client.prototype.getBucketTagging);
+Client.prototype.getObjectTagging = callbackify(Client.prototype.getObjectTagging);
+Client.prototype.setBucketTagging = callbackify(Client.prototype.setBucketTagging);
+Client.prototype.removeBucketTagging = callbackify(Client.prototype.removeBucketTagging);
+Client.prototype.setObjectTagging = callbackify(Client.prototype.setObjectTagging);
+Client.prototype.removeObjectTagging = callbackify(Client.prototype.removeObjectTagging);
+Client.prototype.getBucketVersioning = callbackify(Client.prototype.getBucketVersioning);
+Client.prototype.setBucketVersioning = callbackify(Client.prototype.setBucketVersioning);
+Client.prototype.selectObjectContent = callbackify(Client.prototype.selectObjectContent);
+Client.prototype.setBucketLifecycle = callbackify(Client.prototype.setBucketLifecycle);
+Client.prototype.getBucketLifecycle = callbackify(Client.prototype.getBucketLifecycle);
+Client.prototype.removeBucketLifecycle = callbackify(Client.prototype.removeBucketLifecycle);
+Client.prototype.setBucketEncryption = callbackify(Client.prototype.setBucketEncryption);
+Client.prototype.getBucketEncryption = callbackify(Client.prototype.getBucketEncryption);
+Client.prototype.removeBucketEncryption = callbackify(Client.prototype.removeBucketEncryption);
+Client.prototype.getObjectRetention = callbackify(Client.prototype.getObjectRetention);
+Client.prototype.removeObjects = callbackify(Client.prototype.removeObjects);
+Client.prototype.removeIncompleteUpload = callbackify(Client.prototype.removeIncompleteUpload);
+Client.prototype.copyObject = callbackify(Client.prototype.copyObject);
+Client.prototype.composeObject = callbackify(Client.prototype.composeObject);
+Client.prototype.presignedUrl = callbackify(Client.prototype.presignedUrl);
+Client.prototype.presignedGetObject = callbackify(Client.prototype.presignedGetObject);
+Client.prototype.presignedPutObject = callbackify(Client.prototype.presignedPutObject);
+Client.prototype.presignedPostPolicy = callbackify(Client.prototype.presignedPostPolicy);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/notification.d.mts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'eventemitter3';
+import type { TypedClient } from "./internal/client.mjs";
+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/esm/notification.mjs

@@ -0,0 +1,209 @@
+/*
+ * 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.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import jsonLineParser from 'stream-json/jsonl/Parser.js';
+import { DEFAULT_REGION } from "./helpers.mjs";
+import { pipesetup, uriEscape } from "./internal/helper.mjs";
+
+// TODO: type this
+
+// Base class for three supported configs.
+export 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)
+export class TopicConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Topic = arn;
+  }
+}
+
+// 2. Queue (simple queue service)
+export class QueueConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Queue = arn;
+  }
+}
+
+// 3. CloudFront (lambda function)
+export 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)
+export 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);
+    }
+  }
+}
+export const buildARN = (partition, service, region, accountId, resource) => {
+  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource;
+};
+export const ObjectCreatedAll = 's3:ObjectCreated:*';
+export const ObjectCreatedPut = 's3:ObjectCreated:Put';
+export const ObjectCreatedPost = 's3:ObjectCreated:Post';
+export const ObjectCreatedCopy = 's3:ObjectCreated:Copy';
+export const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload';
+export const ObjectRemovedAll = 's3:ObjectRemoved:*';
+export const ObjectRemovedDelete = 's3:ObjectRemoved:Delete';
+export const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated';
+export const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject';
+
+// put string at least so auto-complete could work
+// TODO: type this
+// Poll for notifications, used in #listenBucketNotification.
+// Listening constitutes repeatedly requesting s3 whether or not any
+// changes have occurred.
+export class NotificationPoller extends 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 = uriEscape(this.prefix);
+      queries.push(`prefix=${prefix}`);
+    }
+    if (this.suffix) {
+      const suffix = uriEscape(this.suffix);
+      queries.push(`suffix=${suffix}`);
+    }
+    if (this.events) {
+      this.events.forEach(s3event => queries.push('events=' + uriEscape(s3event)));
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const region = this.client.region || DEFAULT_REGION;
+    this.client.makeRequestAsync({
+      method,
+      bucketName: this.bucketName,
+      query
+    }, '', [200], region).then(response => {
+      const asm = jsonLineParser.make();
+      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);
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated

SerpentRace_Backend/node_modules/minio/dist/esm/promisify.mjs

@@ -0,0 +1,30 @@
+// Returns a wrapper function that will promisify a given callback function.
+// It will preserve 'this'.
+export 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/esm/signing.d.mts

@@ -0,0 +1,5 @@
+import type { IRequest } from "./internal/type.mjs";
+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/esm/signing.mjs

@@ -0,0 +1,258 @@
+/*
+ * 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.
+ */
+
+import * as crypto from "crypto";
+import * as errors from "./errors.mjs";
+import { PRESIGN_EXPIRY_DAYS_MAX } from "./helpers.mjs";
+import { getScope, isNumber, isObject, isString, makeDateLong, makeDateShort, uriEscape } from "./internal/helper.mjs";
+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 (!isString(method)) {
+    throw new TypeError('method should be of type "string"');
+  }
+  if (!isString(path)) {
+    throw new TypeError('path should be of type "string"');
+  }
+  if (!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 (!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 (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isObject(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  return `${accessKey}/${getScope(region, requestDate, serviceName)}`;
+}
+
+// Returns signed headers array - alphabetically sorted
+function getSignedHeaders(headers) {
+  if (!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 (!isObject(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  const dateLine = 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 (!isString(canonicalRequest)) {
+    throw new TypeError('canonicalRequest should be of type "string"');
+  }
+  if (!isObject(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex');
+  const scope = getScope(region, requestDate, serviceName);
+  const stringToSign = [signV4Algorithm, makeDateLong(requestDate), scope, hash];
+  return stringToSign.join('\n');
+}
+
+// calculate the signature of the POST policy
+export function postPresignSignatureV4(region, date, secretKey, policyBase64) {
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isObject(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!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
+export function signV4(request, accessKey, secretKey, region, requestDate, sha256sum, serviceName = 's3') {
+  if (!isObject(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!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}`;
+}
+export function signV4ByServiceName(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName = 's3') {
+  return signV4(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName);
+}
+
+// returns a presigned URL string
+export function presignSignatureV4(request, accessKey, secretKey, sessionToken, region, requestDate, expires) {
+  if (!isObject(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!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 && !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 > PRESIGN_EXPIRY_DAYS_MAX) {
+    throw new errors.ExpiresParamError('expires param cannot be greater than 7 days');
+  }
+  const iso8601Date = 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=${uriEscape(credential)}`);
+  requestQuery.push(`X-Amz-Date=${iso8601Date}`);
+  requestQuery.push(`X-Amz-Expires=${expires}`);
+  requestQuery.push(`X-Amz-SignedHeaders=${uriEscape(signedHeaders.join(';').toLowerCase())}`);
+  if (sessionToken) {
+    requestQuery.push(`X-Amz-Security-Token=${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/esm/transformers.mjs

@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+
+import * as Crypto from "crypto";
+import Through2 from 'through2';
+import { isFunction } from "./internal/helper.mjs";
+import * as xmlParsers from "./xml-parsers.mjs";
+
+// 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.
+export function getConcater(parser, emitError) {
+  var objectMode = false;
+  var bufs = [];
+  if (parser && !isFunction(parser)) {
+    throw new TypeError('parser should be of type "function"');
+  }
+  if (parser) {
+    objectMode = true;
+  }
+  return Through2({
+    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
+export function getHashSummer(enableSHA256) {
+  var md5 = Crypto.createHash('md5');
+  var sha256 = Crypto.createHash('sha256');
+  return Through2.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.
+export function getListObjectsV2Transformer() {
+  return getConcater(xmlParsers.parseListObjectsV2);
+}
+
+// Parses listObjects with metadata response.
+export function getListObjectsV2WithMetadataTransformer() {
+  return getConcater(xmlParsers.parseListObjectsV2WithMetadata);
+}
+
+// Parses GET/SET BucketNotification response
+export 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/esm/xml-parsers.mjs

@@ -0,0 +1,199 @@
+/*
+ * 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.
+ */
+
+import * as errors from "./errors.mjs";
+import { parseXml, sanitizeETag, sanitizeObjectKey, toArray } from "./internal/helper.mjs";
+
+// parse XML response for bucket notification
+export function parseBucketNotification(xml) {
+  var result = {
+    TopicConfiguration: [],
+    QueueConfiguration: [],
+    CloudFunctionConfiguration: []
+  };
+  // Parse the events list
+  var genEvents = function (events) {
+    var result = [];
+    if (events) {
+      toArray(events).forEach(s3event => {
+        result.push(s3event);
+      });
+    }
+    return result;
+  };
+  // Parse all filter rules
+  var genFilterRules = function (filters) {
+    var result = [];
+    if (filters) {
+      filters = toArray(filters);
+      if (filters[0].S3Key) {
+        filters[0].S3Key = toArray(filters[0].S3Key);
+        if (filters[0].S3Key[0].FilterRule) {
+          toArray(filters[0].S3Key[0].FilterRule).forEach(rule => {
+            var Name = toArray(rule.Name)[0];
+            var Value = toArray(rule.Value)[0];
+            result.push({
+              Name,
+              Value
+            });
+          });
+        }
+      }
+    }
+    return result;
+  };
+  var xmlobj = parseXml(xml);
+  xmlobj = xmlobj.NotificationConfiguration;
+
+  // Parse all topic configurations in the xml
+  if (xmlobj.TopicConfiguration) {
+    toArray(xmlobj.TopicConfiguration).forEach(config => {
+      var Id = toArray(config.Id)[0];
+      var Topic = 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) {
+    toArray(xmlobj.QueueConfiguration).forEach(config => {
+      var Id = toArray(config.Id)[0];
+      var Queue = 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) {
+    toArray(xmlobj.CloudFunctionConfiguration).forEach(config => {
+      var Id = toArray(config.Id)[0];
+      var CloudFunction = 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
+export function parseListObjectsV2(xml) {
+  var result = {
+    objects: [],
+    isTruncated: false
+  };
+  var xmlobj = 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) {
+    toArray(xmlobj.Contents).forEach(content => {
+      var name = sanitizeObjectKey(toArray(content.Key)[0]);
+      var lastModified = new Date(content.LastModified);
+      var etag = sanitizeETag(content.ETag);
+      var size = content.Size;
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    toArray(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+
+// parse XML response for list objects v2 with metadata in a bucket
+export function parseListObjectsV2WithMetadata(xml) {
+  var result = {
+    objects: [],
+    isTruncated: false
+  };
+  var xmlobj = 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) {
+    toArray(xmlobj.Contents).forEach(content => {
+      var name = sanitizeObjectKey(content.Key);
+      var lastModified = new Date(content.LastModified);
+      var etag = sanitizeETag(content.ETag);
+      var size = content.Size;
+      var metadata;
+      if (content.UserMetadata != null) {
+        metadata = toArray(content.UserMetadata)[0];
+      } else {
+        metadata = null;
+      }
+      result.objects.push({
+        name,
+        lastModified,
+        etag,
+        size,
+        metadata
+      });
+    });
+  }
+  if (xmlobj.CommonPrefixes) {
+    toArray(xmlobj.CommonPrefixes).forEach(commonPrefix => {
+      result.objects.push({
+        prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]),
+        size: 0
+      });
+    });
+  }
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
Line truncated