@azure/storage-blob 12.10.0-beta.1 → 12.10.1-alpha.20220517.1

package/dist/index.js

@@ -13325,7 +13325,7 @@ const logger = logger$1.createClientLogger("storage-blob");
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-const SDK_VERSION = "12.10.0-beta.1";
+const SDK_VERSION = "12.10.1";
 const SERVICE_VERSION = "2021-06-08";
 const BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES = 256 * 1024 * 1024; // 256MB
 const BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES = 4000 * 1024 * 1024; // 4000MB
@@ -14183,82 +14183,207 @@ function ParseBlobName(blobNameInXML) {
         };
     }
 }
+function ParseBlobProperties(blobPropertiesInXML) {
+    const blobProperties = blobPropertiesInXML;
+    if (blobPropertiesInXML["Creation-Time"]) {
+        blobProperties.createdOn = new Date(blobPropertiesInXML["Creation-Time"]);
+        delete blobProperties["Creation-Time"];
+    }
+    if (blobPropertiesInXML["Last-Modified"]) {
+        blobProperties.lastModified = new Date(blobPropertiesInXML["Last-Modified"]);
+        delete blobProperties["Last-Modified"];
+    }
+    if (blobPropertiesInXML["Etag"]) {
+        blobProperties.etag = blobPropertiesInXML["Etag"];
+        delete blobProperties["Etag"];
+    }
+    if (blobPropertiesInXML["Content-Length"]) {
+        blobProperties.contentLength = parseFloat(blobPropertiesInXML["Content-Length"]);
+        delete blobProperties["Content-Length"];
+    }
+    if (blobPropertiesInXML["Content-Type"]) {
+        blobProperties.contentType = blobPropertiesInXML["Content-Type"];
+        delete blobProperties["Content-Type"];
+    }
+    if (blobPropertiesInXML["Content-Encoding"]) {
+        blobProperties.contentEncoding = blobPropertiesInXML["Content-Encoding"];
+        delete blobProperties["Content-Encoding"];
+    }
+    if (blobPropertiesInXML["Content-Language"]) {
+        blobProperties.contentLanguage = blobPropertiesInXML["Content-Language"];
+        delete blobProperties["Content-Language"];
+    }
+    if (blobPropertiesInXML["Content-MD5"]) {
+        blobProperties.contentMD5 = decodeBase64String(blobPropertiesInXML["Content-MD5"]);
+        delete blobProperties["Content-MD5"];
+    }
+    if (blobPropertiesInXML["Content-Disposition"]) {
+        blobProperties.contentDisposition = blobPropertiesInXML["Content-Disposition"];
+        delete blobProperties["Content-Disposition"];
+    }
+    if (blobPropertiesInXML["Cache-Control"]) {
+        blobProperties.cacheControl = blobPropertiesInXML["Cache-Control"];
+        delete blobProperties["Cache-Control"];
+    }
+    if (blobPropertiesInXML["x-ms-blob-sequence-number"]) {
+        blobProperties.blobSequenceNumber = parseFloat(blobPropertiesInXML["x-ms-blob-sequence-number"]);
+        delete blobProperties["x-ms-blob-sequence-number"];
+    }
+    if (blobPropertiesInXML["BlobType"]) {
+        blobProperties.blobType = blobPropertiesInXML["BlobType"];
+        delete blobProperties["BlobType"];
+    }
+    if (blobPropertiesInXML["LeaseStatus"]) {
+        blobProperties.leaseStatus = blobPropertiesInXML["LeaseStatus"];
+        delete blobProperties["LeaseStatus"];
+    }
+    if (blobPropertiesInXML["LeaseState"]) {
+        blobProperties.leaseState = blobPropertiesInXML["LeaseState"];
+        delete blobProperties["LeaseState"];
+    }
+    if (blobPropertiesInXML["LeaseDuration"]) {
+        blobProperties.leaseDuration = blobPropertiesInXML["LeaseDuration"];
+        delete blobProperties["LeaseDuration"];
+    }
+    if (blobPropertiesInXML["CopyId"]) {
+        blobProperties.copyId = blobPropertiesInXML["CopyId"];
+        delete blobProperties["CopyId"];
+    }
+    if (blobPropertiesInXML["CopyStatus"]) {
+        blobProperties.copyStatus = blobPropertiesInXML["CopyStatus"];
+        delete blobProperties["CopyStatus"];
+    }
+    if (blobPropertiesInXML["CopySource"]) {
+        blobProperties.copySource = blobPropertiesInXML["CopySource"];
+        delete blobProperties["CopySource"];
+    }
+    if (blobPropertiesInXML["CopyProgress"]) {
+        blobProperties.copyProgress = blobPropertiesInXML["CopyProgress"];
+        delete blobProperties["CopyProgress"];
+    }
+    if (blobPropertiesInXML["CopyCompletionTime"]) {
+        blobProperties.copyCompletedOn = new Date(blobPropertiesInXML["CopyCompletionTime"]);
+        delete blobProperties["CopyCompletionTime"];
+    }
+    if (blobPropertiesInXML["CopyStatusDescription"]) {
+        blobProperties.copyStatusDescription = blobPropertiesInXML["CopyStatusDescription"];
+        delete blobProperties["CopyStatusDescription"];
+    }
+    if (blobPropertiesInXML["ServerEncrypted"]) {
+        blobProperties.serverEncrypted = ParseBoolean(blobPropertiesInXML["ServerEncrypted"]);
+        delete blobProperties["ServerEncrypted"];
+    }
+    if (blobPropertiesInXML["IncrementalCopy"]) {
+        blobProperties.incrementalCopy = ParseBoolean(blobPropertiesInXML["IncrementalCopy"]);
+        delete blobProperties["IncrementalCopy"];
+    }
+    if (blobPropertiesInXML["DestinationSnapshot"]) {
+        blobProperties.destinationSnapshot = blobPropertiesInXML["DestinationSnapshot"];
+        delete blobProperties["DestinationSnapshot"];
+    }
+    if (blobPropertiesInXML["DeletedTime"]) {
+        blobProperties.deletedOn = new Date(blobPropertiesInXML["DeletedTime"]);
+        delete blobProperties["DeletedTime"];
+    }
+    if (blobPropertiesInXML["RemainingRetentionDays"]) {
+        blobProperties.remainingRetentionDays = parseFloat(blobPropertiesInXML["RemainingRetentionDays"]);
+        delete blobProperties["RemainingRetentionDays"];
+    }
+    if (blobPropertiesInXML["AccessTier"]) {
+        blobProperties.accessTier = blobPropertiesInXML["AccessTier"];
+        delete blobProperties["AccessTier"];
+    }
+    if (blobPropertiesInXML["AccessTierInferred"]) {
+        blobProperties.accessTierInferred = ParseBoolean(blobPropertiesInXML["AccessTierInferred"]);
+        delete blobProperties["AccessTierInferred"];
+    }
+    if (blobPropertiesInXML["ArchiveStatus"]) {
+        blobProperties.archiveStatus = blobPropertiesInXML["ArchiveStatus"];
+        delete blobProperties["ArchiveStatus"];
+    }
+    if (blobPropertiesInXML["CustomerProvidedKeySha256"]) {
+        blobProperties.customerProvidedKeySha256 = blobPropertiesInXML["CustomerProvidedKeySha256"];
+        delete blobProperties["CustomerProvidedKeySha256"];
+    }
+    if (blobPropertiesInXML["EncryptionScope"]) {
+        blobProperties.encryptionScope = blobPropertiesInXML["EncryptionScope"];
+        delete blobProperties["EncryptionScope"];
+    }
+    if (blobPropertiesInXML["AccessTierChangeTime"]) {
+        blobProperties.accessTierChangedOn = new Date(blobPropertiesInXML["AccessTierChangeTime"]);
+        delete blobProperties["AccessTierChangeTime"];
+    }
+    if (blobPropertiesInXML["TagCount"]) {
+        blobProperties.tagCount = parseFloat(blobPropertiesInXML["TagCount"]);
+        delete blobProperties["TagCount"];
+    }
+    if (blobPropertiesInXML["Expiry-Time"]) {
+        blobProperties.expiresOn = new Date(blobPropertiesInXML["Expiry-Time"]);
+        delete blobProperties["Expiry-Time"];
+    }
+    if (blobPropertiesInXML["Sealed"]) {
+        blobProperties.isSealed = ParseBoolean(blobPropertiesInXML["Sealed"]);
+        delete blobProperties["Sealed"];
+    }
+    if (blobPropertiesInXML["RehydratePriority"]) {
+        blobProperties.rehydratePriority = blobPropertiesInXML["RehydratePriority"];
+        delete blobProperties["RehydratePriority"];
+    }
+    if (blobPropertiesInXML["LastAccessTime"]) {
+        blobProperties.lastAccessedOn = new Date(blobPropertiesInXML["LastAccessTime"]);
+        delete blobProperties["LastAccessTime"];
+    }
+    if (blobPropertiesInXML["ImmutabilityPolicyUntilDate"]) {
+        blobProperties.immutabilityPolicyExpiresOn = new Date(blobPropertiesInXML["ImmutabilityPolicyUntilDate"]);
+        delete blobProperties["ImmutabilityPolicyUntilDate"];
+    }
+    if (blobPropertiesInXML["ImmutabilityPolicyMode"]) {
+        blobProperties.immutabilityPolicyMode = blobPropertiesInXML["ImmutabilityPolicyMode"];
+        delete blobProperties["ImmutabilityPolicyMode"];
+    }
+    if (blobPropertiesInXML["LegalHold"]) {
+        blobProperties.legalHold = ParseBoolean(blobPropertiesInXML["LegalHold"]);
+        delete blobProperties["LegalHold"];
+    }
+    return blobProperties;
+}
 function ParseBlobItem(blobInXML) {
-    const blobPropertiesInXML = blobInXML["Properties"];
-    const blobProperties = {
-        createdOn: new Date(blobPropertiesInXML["Creation-Time"]),
-        lastModified: new Date(blobPropertiesInXML["Last-Modified"]),
-        etag: blobPropertiesInXML["Etag"],
-        contentLength: blobPropertiesInXML["Content-Length"] === undefined
-            ? undefined
-            : parseFloat(blobPropertiesInXML["Content-Length"]),
-        contentType: blobPropertiesInXML["Content-Type"],
-        contentEncoding: blobPropertiesInXML["Content-Encoding"],
-        contentLanguage: blobPropertiesInXML["Content-Language"],
-        contentMD5: decodeBase64String(blobPropertiesInXML["Content-MD5"]),
-        contentDisposition: blobPropertiesInXML["Content-Disposition"],
-        cacheControl: blobPropertiesInXML["Cache-Control"],
-        blobSequenceNumber: blobPropertiesInXML["x-ms-blob-sequence-number"] === undefined
-            ? undefined
-            : parseFloat(blobPropertiesInXML["x-ms-blob-sequence-number"]),
-        blobType: blobPropertiesInXML["BlobType"],
-        leaseStatus: blobPropertiesInXML["LeaseStatus"],
-        leaseState: blobPropertiesInXML["LeaseState"],
-        leaseDuration: blobPropertiesInXML["LeaseDuration"],
-        copyId: blobPropertiesInXML["CopyId"],
-        copyStatus: blobPropertiesInXML["CopyStatus"],
-        copySource: blobPropertiesInXML["CopySource"],
-        copyProgress: blobPropertiesInXML["CopyProgress"],
-        copyCompletedOn: blobPropertiesInXML["CopyCompletionTime"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["CopyCompletionTime"]),
-        copyStatusDescription: blobPropertiesInXML["CopyStatusDescription"],
-        serverEncrypted: ParseBoolean(blobPropertiesInXML["ServerEncrypted"]),
-        incrementalCopy: ParseBoolean(blobPropertiesInXML["IncrementalCopy"]),
-        destinationSnapshot: blobPropertiesInXML["DestinationSnapshot"],
-        deletedOn: blobPropertiesInXML["DeletedTime"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["DeletedTime"]),
-        remainingRetentionDays: blobPropertiesInXML["RemainingRetentionDays"] === undefined
-            ? undefined
-            : parseFloat(blobPropertiesInXML["RemainingRetentionDays"]),
-        accessTier: blobPropertiesInXML["AccessTier"],
-        accessTierInferred: ParseBoolean(blobPropertiesInXML["AccessTierInferred"]),
-        archiveStatus: blobPropertiesInXML["ArchiveStatus"],
-        customerProvidedKeySha256: blobPropertiesInXML["CustomerProvidedKeySha256"],
-        encryptionScope: blobPropertiesInXML["EncryptionScope"],
-        accessTierChangedOn: blobPropertiesInXML["AccessTierChangeTime"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["AccessTierChangeTime"]),
-        tagCount: blobPropertiesInXML["TagCount"] === undefined
-            ? undefined
-            : parseFloat(blobPropertiesInXML["TagCount"]),
-        expiresOn: blobPropertiesInXML["Expiry-Time"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["Expiry-Time"]),
-        isSealed: ParseBoolean(blobPropertiesInXML["Sealed"]),
-        rehydratePriority: blobPropertiesInXML["RehydratePriority"],
-        lastAccessedOn: blobPropertiesInXML["LastAccessTime"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["LastAccessTime"]),
-        immutabilityPolicyExpiresOn: blobPropertiesInXML["ImmutabilityPolicyUntilDate"] === undefined
-            ? undefined
-            : new Date(blobPropertiesInXML["ImmutabilityPolicyUntilDate"]),
-        immutabilityPolicyMode: blobPropertiesInXML["ImmutabilityPolicyMode"],
-        legalHold: ParseBoolean(blobPropertiesInXML["LegalHold"]),
-    };
-    return {
-        name: ParseBlobName(blobInXML["Name"]),
-        deleted: ParseBoolean(blobInXML["Deleted"]),
-        snapshot: blobInXML["Snapshot"],
-        versionId: blobInXML["VersionId"],
-        isCurrentVersion: ParseBoolean(blobInXML["IsCurrentVersion"]),
-        properties: blobProperties,
-        metadata: blobInXML["Metadata"],
-        blobTags: ParseBlobTags(blobInXML["Tags"]),
-        objectReplicationMetadata: blobInXML["OrMetadata"],
-        hasVersionsOnly: ParseBoolean(blobInXML["HasVersionsOnly"]),
-    };
+    const blobItem = blobInXML;
+    blobItem.properties = ParseBlobProperties(blobInXML["Properties"]);
+    delete blobItem["Properties"];
+    blobItem.name = ParseBlobName(blobInXML["Name"]);
+    delete blobItem["Name"];
+    blobItem.deleted = ParseBoolean(blobInXML["Deleted"]);
+    delete blobItem["Deleted"];
+    if (blobInXML["Snapshot"]) {
+        blobItem.snapshot = blobInXML["Snapshot"];
+        delete blobItem["Snapshot"];
+    }
+    if (blobInXML["VersionId"]) {
+        blobItem.versionId = blobInXML["VersionId"];
+        delete blobItem["VersionId"];
+    }
+    if (blobInXML["IsCurrentVersion"]) {
+        blobItem.isCurrentVersion = ParseBoolean(blobInXML["IsCurrentVersion"]);
+        delete blobItem["IsCurrentVersion"];
+    }
+    if (blobInXML["Metadata"]) {
+        blobItem.metadata = blobInXML["Metadata"];
+        delete blobItem["Metadata"];
+    }
+    if (blobInXML["Tags"]) {
+        blobItem.blobTags = ParseBlobTags(blobInXML["Tags"]);
+        delete blobItem["Tags"];
+    }
+    if (blobInXML["OrMetadata"]) {
+        blobItem.objectReplicationMetadata = blobInXML["OrMetadata"];
+        delete blobItem["OrMetadata"];
+    }
+    if (blobInXML["HasVersionsOnly"]) {
+        blobItem.hasVersionsOnly = ParseBoolean(blobInXML["HasVersionsOnly"]);
+        delete blobItem["HasVersionsOnly"];
+    }
+    return blobItem;
 }
 function ParseBlobPrefix(blobPrefixInXML) {
     return {
@@ -14771,7 +14896,10 @@ class TelemetryPolicyFactory {
                 userAgentInfo.push(libInfo);
             }
             // e.g. (NODE-VERSION 4.9.1; Windows_NT 10.0.16299)
-            const runtimeInfo = `(NODE-VERSION ${process.version}; ${os__namespace.type()} ${os__namespace.release()})`;
+            let runtimeInfo = `(NODE-VERSION ${process.version})`;
+            if (os__namespace) {
+                runtimeInfo = `(NODE-VERSION ${process.version}; ${os__namespace.type()} ${os__namespace.release()})`;
+            }
             if (userAgentInfo.indexOf(runtimeInfo) === -1) {
                 userAgentInfo.push(runtimeInfo);
             }
@@ -15309,7 +15437,7 @@ class StorageSharedKeyCredential extends Credential {
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
 const packageName = "azure-storage-blob";
-const packageVersion = "12.10.0-beta.1";
+const packageVersion = "12.10.1";
 class StorageClientContext extends coreHttp__namespace.ServiceClient {
     /**
      * Initializes a new instance of the StorageClientContext class.
@@ -17417,22 +17545,6 @@ const AVRO_INIT_BYTES = new Uint8Array([79, 98, 106, 1]);
 const AVRO_CODEC_KEY = "avro.codec";
 const AVRO_SCHEMA_KEY = "avro.schema";
 
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-function arraysEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (a.length != b.length)
-        return false;
-    for (let i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 class AvroParser {
@@ -17445,7 +17557,7 @@ class AvroParser {
      */
     static async readFixedBytes(stream, length, options = {}) {
         const bytes = await stream.read(length, { abortSignal: options.abortSignal });
-        if (bytes.length != length) {
+        if (bytes.length !== length) {
             throw new Error("Hit stream end.");
         }
         return bytes;
@@ -17475,6 +17587,7 @@ class AvroParser {
         } while (haveMoreByte && significanceInBit < 28); // bitwise operation only works for 32-bit integers
         if (haveMoreByte) {
             // Switch to float arithmetic
+            // eslint-disable-next-line no-self-assign
             zigZagEncoded = zigZagEncoded;
             significanceInFloat = 268435456; // 2 ** 28.
             do {
@@ -17501,10 +17614,10 @@ class AvroParser {
     }
     static async readBoolean(stream, options = {}) {
         const b = await AvroParser.readByte(stream, options);
-        if (b == 1) {
+        if (b === 1) {
             return true;
         }
-        else if (b == 0) {
+        else if (b === 0) {
             return false;
         }
         else {
@@ -17526,16 +17639,10 @@ class AvroParser {
         if (size < 0) {
             throw new Error("Bytes size was negative.");
         }
-        return await stream.read(size, { abortSignal: options.abortSignal });
+        return stream.read(size, { abortSignal: options.abortSignal });
     }
     static async readString(stream, options = {}) {
         const u8arr = await AvroParser.readBytes(stream, options);
-        // polyfill TextDecoder to be backward compatible with older
-        // nodejs that doesn't expose TextDecoder as a global variable
-        if (typeof TextDecoder === "undefined" && typeof require !== "undefined") {
-            global.TextDecoder = require("util").TextDecoder;
-        }
-        // FUTURE: need TextDecoder polyfill for IE
         const utf8decoder = new TextDecoder();
         return utf8decoder.decode(u8arr);
     }
@@ -17546,8 +17653,8 @@ class AvroParser {
         return { key, value };
     }
     static async readMap(stream, readItemMethod, options = {}) {
-        const readPairMethod = async (stream, options = {}) => {
-            return await AvroParser.readMapPair(stream, readItemMethod, options);
+        const readPairMethod = (s, opts = {}) => {
+            return AvroParser.readMapPair(s, readItemMethod, opts);
         };
         const pairs = await AvroParser.readArray(stream, readPairMethod, options);
         const dict = {};
@@ -17558,7 +17665,7 @@ class AvroParser {
     }
     static async readArray(stream, readItemMethod, options = {}) {
         const items = [];
-        for (let count = await AvroParser.readLong(stream, options); count != 0; count = await AvroParser.readLong(stream, options)) {
+        for (let count = await AvroParser.readLong(stream, options); count !== 0; count = await AvroParser.readLong(stream, options)) {
             if (count < 0) {
                 // Ignore block sizes
                 await AvroParser.readLong(stream, options);
@@ -17581,6 +17688,17 @@ var AvroComplex;
     AvroComplex["UNION"] = "union";
     AvroComplex["FIXED"] = "fixed";
 })(AvroComplex || (AvroComplex = {}));
+var AvroPrimitive;
+(function (AvroPrimitive) {
+    AvroPrimitive["NULL"] = "null";
+    AvroPrimitive["BOOLEAN"] = "boolean";
+    AvroPrimitive["INT"] = "int";
+    AvroPrimitive["LONG"] = "long";
+    AvroPrimitive["FLOAT"] = "float";
+    AvroPrimitive["DOUBLE"] = "double";
+    AvroPrimitive["BYTES"] = "bytes";
+    AvroPrimitive["STRING"] = "string";
+})(AvroPrimitive || (AvroPrimitive = {}));
 class AvroType {
     /**
      * Determines the AvroType from the Avro Schema.
@@ -17620,7 +17738,9 @@ class AvroType {
         try {
             return AvroType.fromStringSchema(type);
         }
-        catch (err) { }
+        catch (err) {
+            // eslint-disable-line no-empty
+        }
         switch (type) {
             case AvroComplex.RECORD:
                 if (schema.aliases) {
@@ -17629,6 +17749,7 @@ class AvroType {
                 if (!schema.name) {
                     throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
                 }
+                // eslint-disable-next-line no-case-declarations
                 const fields = {};
                 if (!schema.fields) {
                     throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
@@ -17657,40 +17778,29 @@ class AvroType {
         }
     }
 }
-var AvroPrimitive;
-(function (AvroPrimitive) {
-    AvroPrimitive["NULL"] = "null";
-    AvroPrimitive["BOOLEAN"] = "boolean";
-    AvroPrimitive["INT"] = "int";
-    AvroPrimitive["LONG"] = "long";
-    AvroPrimitive["FLOAT"] = "float";
-    AvroPrimitive["DOUBLE"] = "double";
-    AvroPrimitive["BYTES"] = "bytes";
-    AvroPrimitive["STRING"] = "string";
-})(AvroPrimitive || (AvroPrimitive = {}));
 class AvroPrimitiveType extends AvroType {
     constructor(primitive) {
         super();
         this._primitive = primitive;
     }
-    async read(stream, options = {}) {
+    read(stream, options = {}) {
         switch (this._primitive) {
             case AvroPrimitive.NULL:
-                return await AvroParser.readNull();
+                return AvroParser.readNull();
             case AvroPrimitive.BOOLEAN:
-                return await AvroParser.readBoolean(stream, options);
+                return AvroParser.readBoolean(stream, options);
             case AvroPrimitive.INT:
-                return await AvroParser.readInt(stream, options);
+                return AvroParser.readInt(stream, options);
             case AvroPrimitive.LONG:
-                return await AvroParser.readLong(stream, options);
+                return AvroParser.readLong(stream, options);
             case AvroPrimitive.FLOAT:
-                return await AvroParser.readFloat(stream, options);
+                return AvroParser.readFloat(stream, options);
             case AvroPrimitive.DOUBLE:
-                return await AvroParser.readDouble(stream, options);
+                return AvroParser.readDouble(stream, options);
             case AvroPrimitive.BYTES:
-                return await AvroParser.readBytes(stream, options);
+                return AvroParser.readBytes(stream, options);
             case AvroPrimitive.STRING:
-                return await AvroParser.readString(stream, options);
+                return AvroParser.readString(stream, options);
             default:
                 throw new Error("Unknown Avro Primitive");
         }
@@ -17713,7 +17823,7 @@ class AvroUnionType extends AvroType {
     }
     async read(stream, options = {}) {
         const typeIndex = await AvroParser.readInt(stream, options);
-        return await this._types[typeIndex].read(stream, options);
+        return this._types[typeIndex].read(stream, options);
     }
 }
 class AvroMapType extends AvroType {
@@ -17721,11 +17831,11 @@ class AvroMapType extends AvroType {
         super();
         this._itemType = itemType;
     }
-    async read(stream, options = {}) {
-        const readItemMethod = async (s, options) => {
-            return await this._itemType.read(s, options);
+    read(stream, options = {}) {
+        const readItemMethod = (s, opts) => {
+            return this._itemType.read(s, opts);
         };
-        return await AvroParser.readMap(stream, readItemMethod, options);
+        return AvroParser.readMap(stream, readItemMethod, options);
     }
 }
 class AvroRecordType extends AvroType {
@@ -17738,7 +17848,7 @@ class AvroRecordType extends AvroType {
         const record = {};
         record["$schema"] = this._name;
         for (const key in this._fields) {
-            if (this._fields.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(this._fields, key)) {
                 record[key] = await this._fields[key].read(stream, options);
             }
         }
@@ -17746,6 +17856,23 @@ class AvroRecordType extends AvroType {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    // eslint-disable-next-line eqeqeq
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+
 // Copyright (c) Microsoft Corporation.
 class AvroReader {
     constructor(dataStream, headerStream, currentBlockOffset, indexWithinCurrentBlock) {
@@ -17776,7 +17903,7 @@ class AvroReader {
         });
         // Validate codec
         const codec = this._metadata[AVRO_CODEC_KEY];
-        if (!(codec == undefined || codec == "null")) {
+        if (!(codec === undefined || codec === null || codec === "null")) {
             throw new Error("Codecs are not supported");
         }
         // The 16-byte, randomly-generated sync marker for this file.
@@ -17786,7 +17913,7 @@ class AvroReader {
         // Parse the schema
         const schema = JSON.parse(this._metadata[AVRO_SCHEMA_KEY]);
         this._itemType = AvroType.fromSchema(schema);
-        if (this._blockOffset == 0) {
+        if (this._blockOffset === 0) {
             this._blockOffset = this._initialBlockOffset + this._dataStream.position;
         }
         this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, {
@@ -17816,7 +17943,7 @@ class AvroReader {
                 }));
                 this._itemsRemainingInBlock--;
                 this._objectIndex++;
-                if (this._itemsRemainingInBlock == 0) {
+                if (this._itemsRemainingInBlock === 0) {
                     const marker = yield tslib.__await(AvroParser.readFixedBytes(this._dataStream, AVRO_SYNC_MARKER_SIZE, {
                         abortSignal: options.abortSignal,
                     }));
@@ -17891,6 +18018,7 @@ class AvroReadableFromStream extends AvroReadable {
         else {
             // register callback to wait for enough data to read
             return new Promise((resolve, reject) => {
+                /* eslint-disable @typescript-eslint/no-use-before-define */
                 const cleanUp = () => {
                     this._readable.removeListener("readable", readableCallback);
                     this._readable.removeListener("error", rejectCallback);
@@ -17901,12 +18029,12 @@ class AvroReadableFromStream extends AvroReadable {
                     }
                 };
                 const readableCallback = () => {
-                    const chunk = this._readable.read(size);
-                    if (chunk) {
-                        this._position += chunk.length;
+                    const callbackChunk = this._readable.read(size);
+                    if (callbackChunk) {
+                        this._position += callbackChunk.length;
                         cleanUp();
-                        // chunk.length maybe less than desired size if the stream ends.
-                        resolve(this.toUint8Array(chunk));
+                        // callbackChunk.length maybe less than desired size if the stream ends.
+                        resolve(this.toUint8Array(callbackChunk));
                     }
                 };
                 const rejectCallback = () => {
@@ -17924,6 +18052,7 @@ class AvroReadableFromStream extends AvroReadable {
                 if (options.abortSignal) {
                     options.abortSignal.addEventListener("abort", abortHandler);
                 }
+                /* eslint-enable @typescript-eslint/no-use-before-define */
             });
         }
     }