@hanzo/s3 0.6.4 → 8.0.7

package/dist/esm/internal/xml-parser.mjs

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