@azure/storage-blob-changefeed 12.0.0-preview.3 → 12.0.0-preview.5

package/dist/index.js

@@ -1,1644 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var storageBlob = require('@azure/storage-blob');
-var coreHttp = require('@azure/core-http');
-var coreTracing = require('@azure/core-tracing');
-var abortController = require('@azure/abort-controller');
-require('@azure/core-paging');
-var stream = require('stream');
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-const SDK_VERSION = "12.0.0-preview.3";
-const CHANGE_FEED_CONTAINER_NAME = "$blobchangefeed";
-const CHANGE_FEED_META_SEGMENT_PATH = "meta/segments.json";
-const CHANGE_FEED_SEGMENT_PREFIX = "idx/segments/";
-const CHANGE_FEED_INITIALIZATION_SEGMENT = "1601";
-const CHANGE_FEED_MAX_PAGE_SIZE = 5000; // align with rest API list operations
-const CHANGE_FEED_CHUNK_BLOCK_DOWNLOAD_SIZE = 16 * 1024 * 1024;
-
-// Copyright (c) Microsoft Corporation.
-/**
- * Creates a span using the global tracer.
- * @internal
- */
-const createSpan = coreTracing.createSpanFunction({
-    packagePrefix: "Azure.Storage.Blob.Changefeed",
-    namespace: "Microsoft.Storage",
-});
-
-// Copyright (c) Microsoft Corporation.
-const millisecondsInAnHour = 60 * 60 * 1000;
-function ceilToNearestHour(date) {
-    if (date === undefined) {
-        return undefined;
-    }
-    return new Date(Math.ceil(date.getTime() / millisecondsInAnHour) * millisecondsInAnHour);
-}
-function floorToNearestHour(date) {
-    if (date === undefined) {
-        return undefined;
-    }
-    return new Date(Math.floor(date.getTime() / millisecondsInAnHour) * millisecondsInAnHour);
-}
-/**
- * Get host from an URL string.
- *
- * @param url - Source URL string
- */
-function getHost(url) {
-    const urlParsed = coreHttp.URLBuilder.parse(url);
-    return urlParsed.getHost();
-}
-async function getYearsPaths(containerClient, options = {}) {
-    var e_1, _a;
-    const { span, updatedOptions } = createSpan("getYearsPaths", options);
-    try {
-        const years = [];
-        try {
-            for (var _b = tslib.__asyncValues(containerClient.listBlobsByHierarchy("/", {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-                prefix: CHANGE_FEED_SEGMENT_PREFIX,
-            })), _c; _c = await _b.next(), !_c.done;) {
-                const item = _c.value;
-                if (item.kind === "prefix" && !item.name.includes(CHANGE_FEED_INITIALIZATION_SEGMENT)) {
-                    const yearStr = item.name.slice(CHANGE_FEED_SEGMENT_PREFIX.length, -1);
-                    years.push(parseInt(yearStr));
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return years.sort((a, b) => a - b);
-    }
-    catch (e) {
-        span.setStatus({
-            code: coreTracing.SpanStatusCode.ERROR,
-            message: e.message,
-        });
-        throw e;
-    }
-    finally {
-        span.end();
-    }
-}
-async function getSegmentsInYear(containerClient, year, startTime, endTime, options = {}) {
-    var e_2, _a;
-    const { span, updatedOptions } = createSpan("getSegmentsInYear", options);
-    try {
-        const segments = [];
-        const yearBeginTime = new Date(Date.UTC(year, 0));
-        if (endTime && yearBeginTime >= endTime) {
-            return segments;
-        }
-        const prefix = `${CHANGE_FEED_SEGMENT_PREFIX}${year}/`;
-        try {
-            for (var _b = tslib.__asyncValues(containerClient.listBlobsFlat({
-                prefix,
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            })), _c; _c = await _b.next(), !_c.done;) {
-                const item = _c.value;
-                const segmentTime = parseDateFromSegmentPath(item.name);
-                if ((startTime && segmentTime < startTime) || (endTime && segmentTime >= endTime)) {
-                    continue;
-                }
-                segments.push(item.name);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return segments;
-    }
-    catch (e) {
-        span.setStatus({
-            code: coreTracing.SpanStatusCode.ERROR,
-            message: e.message,
-        });
-        throw e;
-    }
-    finally {
-        span.end();
-    }
-}
-function parseDateFromSegmentPath(segmentPath) {
-    const splitPath = segmentPath.split("/");
-    if (splitPath.length < 3) {
-        throw new Error(`${segmentPath} is not a valid segment path.`);
-    }
-    const segmentTime = new Date(0);
-    segmentTime.setUTCFullYear(parseInt(splitPath[2]));
-    if (splitPath.length >= 4) {
-        segmentTime.setUTCMonth(parseInt(splitPath[3]) - 1);
-    }
-    if (splitPath.length >= 5) {
-        segmentTime.setUTCDate(parseInt(splitPath[4]));
-    }
-    if (splitPath.length >= 6) {
-        segmentTime.setUTCHours(parseInt(splitPath[5]) / 100);
-    }
-    return segmentTime;
-}
-function minDate(dateA, dateB) {
-    if (dateB && dateB < dateA) {
-        return dateB;
-    }
-    return dateA;
-}
-function rawEventToBlobChangeFeedEvent(rawEvent) {
-    if (rawEvent.eventTime) {
-        rawEvent.eventTime = new Date(rawEvent.eventTime);
-    }
-    if (rawEvent.eTag) {
-        rawEvent.etag = rawEvent.eTag;
-        delete rawEvent.eTag;
-    }
-    if (rawEvent.data) {
-        if (rawEvent.data.recursive !== undefined) {
-            rawEvent.data.isRecursive = rawEvent.data.recursive;
-            delete rawEvent.data.recursive;
-        }
-        if (rawEvent.data.previousInfo) {
-            const previousInfo = rawEvent.data.previousInfo;
-            if (previousInfo.SoftDeleteSnapshot) {
-                previousInfo.softDeleteSnapshot = previousInfo.SoftDeleteSnapshot;
-                delete previousInfo.SoftDeleteSnapshot;
-            }
-            if (previousInfo.WasBlobSoftDeleted) {
-                previousInfo.isBlobSoftDeleted = previousInfo.WasBlobSoftDeleted === "true";
-                delete previousInfo.WasBlobSoftDeleted;
-            }
-            if (previousInfo.BlobVersion) {
-                previousInfo.newBlobVersion = previousInfo.BlobVersion;
-                delete previousInfo.BlobVersion;
-            }
-            if (previousInfo.LastVersion) {
-                previousInfo.oldBlobVersion = previousInfo.LastVersion;
-                delete previousInfo.LastVersion;
-            }
-            if (previousInfo.PreviousTier) {
-                previousInfo.previousTier = previousInfo.PreviousTier;
-                delete previousInfo.PreviousTier;
-            }
-            rawEvent.data.previousInfo = previousInfo;
-        }
-        if (rawEvent.data.blobPropertiesUpdated) {
-            const updatedBlobProperties = {};
-            Object.entries(rawEvent.data.blobPropertiesUpdated).map((item) => {
-                const blobPropertyChange = {
-                    propertyName: item[0],
-                    oldValue: item[1].previous,
-                    newValue: item[1].current,
-                };
-                updatedBlobProperties[item[0]] = blobPropertyChange;
-            });
-            rawEvent.data.updatedBlobProperties = updatedBlobProperties;
-            delete rawEvent.data.blobPropertiesUpdated;
-        }
-        if (rawEvent.data.asyncOperationInfo) {
-            const longRunningOperationInfo = rawEvent.data.asyncOperationInfo;
-            if (longRunningOperationInfo.DestinationTier) {
-                longRunningOperationInfo.destinationAccessTier = longRunningOperationInfo.DestinationTier;
-                delete longRunningOperationInfo.DestinationTier;
-            }
-            if ("WasAsyncOperation" in longRunningOperationInfo) {
-                longRunningOperationInfo.isAsync = longRunningOperationInfo.WasAsyncOperation === "true";
-                delete longRunningOperationInfo.WasAsyncOperation;
-            }
-            if (longRunningOperationInfo.CopyId) {
-                longRunningOperationInfo.copyId = longRunningOperationInfo.CopyId;
-                delete longRunningOperationInfo.CopyId;
-            }
-            rawEvent.data.longRunningOperationInfo = longRunningOperationInfo;
-            delete rawEvent.data.asyncOperationInfo;
-        }
-        if (rawEvent.data.blobTagsUpdated) {
-            rawEvent.data.updatedBlobTags = {
-                newTags: rawEvent.data.blobTagsUpdated.current,
-                oldTags: rawEvent.data.blobTagsUpdated.previous,
-            };
-            delete rawEvent.data.blobTagsUpdated;
-        }
-        if (rawEvent.data.blobTier) {
-            rawEvent.data.blobAccessTier = rawEvent.data.blobTier;
-            delete rawEvent.data.blobTier;
-        }
-    }
-    return rawEvent;
-}
-
-// Copyright (c) Microsoft Corporation.
-class ChangeFeed {
-    constructor(containerClient, segmentFactory, years, segments, currentSegment, lastConsumable, startTime, endTime) {
-        this.containerClient = containerClient;
-        this.segmentFactory = segmentFactory;
-        this.years = years || [];
-        this.segments = segments || [];
-        this.currentSegment = currentSegment;
-        this.lastConsumable = lastConsumable;
-        this.startTime = startTime;
-        this.endTime = endTime;
-        if (this.lastConsumable) {
-            this.end = minDate(this.lastConsumable, this.endTime);
-        }
-    }
-    async advanceSegmentIfNecessary(options = {}) {
-        const { span, updatedOptions } = createSpan("ChangeFeed-advanceSegmentIfNecessary", options);
-        try {
-            if (!this.currentSegment) {
-                throw new Error("Empty Change Feed shouldn't call this function.");
-            }
-            // If the current segment has more Events, we don't need to do anything.
-            if (this.currentSegment.hasNext()) {
-                return;
-            }
-            // If the current segment is completed, remove it
-            if (this.segments.length > 0) {
-                this.currentSegment = await this.segmentFactory.create(this.containerClient, this.segments.shift(), undefined, {
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-            }
-            // If segments is empty, refill it
-            else if (this.segments.length === 0 && this.years.length > 0) {
-                const year = this.years.shift();
-                this.segments = await getSegmentsInYear(this.containerClient, year, this.startTime, this.end, {
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-                if (this.segments.length > 0) {
-                    this.currentSegment = await this.segmentFactory.create(this.containerClient, this.segments.shift(), undefined, {
-                        abortSignal: options.abortSignal,
-                        tracingOptions: updatedOptions.tracingOptions,
-                    });
-                }
-                else {
-                    this.currentSegment = undefined;
-                }
-            }
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-    hasNext() {
-        // Empty ChangeFeed, using currentSegment as the indicator.
-        if (!this.currentSegment) {
-            return false;
-        }
-        if (this.segments.length === 0 && this.years.length === 0 && !this.currentSegment.hasNext()) {
-            return false;
-        }
-        return this.currentSegment.dateTime < this.end;
-    }
-    async getChange(options = {}) {
-        const { span, updatedOptions } = createSpan("ChangeFeed-getChange", options);
-        try {
-            let event = undefined;
-            while (event === undefined && this.hasNext()) {
-                event = await this.currentSegment.getChange({
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-                await this.advanceSegmentIfNecessary({
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-            }
-            return event;
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-    getCursor() {
-        var _a;
-        if (!this.currentSegment) {
-            throw new Error("Empty Change Feed shouldn't call this function.");
-        }
-        return {
-            CursorVersion: 1,
-            UrlHost: getHost(this.containerClient.url),
-            EndTime: (_a = this.endTime) === null || _a === void 0 ? void 0 : _a.toJSON(),
-            CurrentSegmentCursor: this.currentSegment.getCursor(),
-        };
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-const AVRO_SYNC_MARKER_SIZE = 16;
-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 {
-    /**
-     * Reads a fixed number of bytes from the stream.
-     *
-     * @param stream -
-     * @param length -
-     * @param options -
-     */
-    static async readFixedBytes(stream, length, options = {}) {
-        const bytes = await stream.read(length, { abortSignal: options.abortSignal });
-        if (bytes.length != length) {
-            throw new Error("Hit stream end.");
-        }
-        return bytes;
-    }
-    /**
-     * Reads a single byte from the stream.
-     *
-     * @param stream -
-     * @param options -
-     */
-    static async readByte(stream, options = {}) {
-        const buf = await AvroParser.readFixedBytes(stream, 1, options);
-        return buf[0];
-    }
-    // int and long are stored in variable-length zig-zag coding.
-    // variable-length: https://lucene.apache.org/core/3_5_0/fileformats.html#VInt
-    // zig-zag: https://developers.google.com/protocol-buffers/docs/encoding?csw=1#types
-    static async readZigZagLong(stream, options = {}) {
-        let zigZagEncoded = 0;
-        let significanceInBit = 0;
-        let byte, haveMoreByte, significanceInFloat;
-        do {
-            byte = await AvroParser.readByte(stream, options);
-            haveMoreByte = byte & 0x80;
-            zigZagEncoded |= (byte & 0x7f) << significanceInBit;
-            significanceInBit += 7;
-        } while (haveMoreByte && significanceInBit < 28); // bitwise operation only works for 32-bit integers
-        if (haveMoreByte) {
-            // Switch to float arithmetic
-            zigZagEncoded = zigZagEncoded;
-            significanceInFloat = 268435456; // 2 ** 28.
-            do {
-                byte = await AvroParser.readByte(stream, options);
-                zigZagEncoded += (byte & 0x7f) * significanceInFloat;
-                significanceInFloat *= 128; // 2 ** 7
-            } while (byte & 0x80);
-            const res = (zigZagEncoded % 2 ? -(zigZagEncoded + 1) : zigZagEncoded) / 2;
-            if (res < Number.MIN_SAFE_INTEGER || res > Number.MAX_SAFE_INTEGER) {
-                throw new Error("Integer overflow.");
-            }
-            return res;
-        }
-        return (zigZagEncoded >> 1) ^ -(zigZagEncoded & 1);
-    }
-    static async readLong(stream, options = {}) {
-        return AvroParser.readZigZagLong(stream, options);
-    }
-    static async readInt(stream, options = {}) {
-        return AvroParser.readZigZagLong(stream, options);
-    }
-    static async readNull() {
-        return null;
-    }
-    static async readBoolean(stream, options = {}) {
-        const b = await AvroParser.readByte(stream, options);
-        if (b == 1) {
-            return true;
-        }
-        else if (b == 0) {
-            return false;
-        }
-        else {
-            throw new Error("Byte was not a boolean.");
-        }
-    }
-    static async readFloat(stream, options = {}) {
-        const u8arr = await AvroParser.readFixedBytes(stream, 4, options);
-        const view = new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength);
-        return view.getFloat32(0, true); // littleEndian = true
-    }
-    static async readDouble(stream, options = {}) {
-        const u8arr = await AvroParser.readFixedBytes(stream, 8, options);
-        const view = new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength);
-        return view.getFloat64(0, true); // littleEndian = true
-    }
-    static async readBytes(stream, options = {}) {
-        const size = await AvroParser.readLong(stream, options);
-        if (size < 0) {
-            throw new Error("Bytes size was negative.");
-        }
-        return await 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);
-    }
-    static async readMapPair(stream, readItemMethod, options = {}) {
-        const key = await AvroParser.readString(stream, options);
-        // FUTURE: this won't work with readFixed (currently not supported) which needs a length as the parameter.
-        const value = await readItemMethod(stream, options);
-        return { key, value };
-    }
-    static async readMap(stream, readItemMethod, options = {}) {
-        const readPairMethod = async (stream, options = {}) => {
-            return await AvroParser.readMapPair(stream, readItemMethod, options);
-        };
-        const pairs = await AvroParser.readArray(stream, readPairMethod, options);
-        const dict = {};
-        for (const pair of pairs) {
-            dict[pair.key] = pair.value;
-        }
-        return dict;
-    }
-    static async readArray(stream, readItemMethod, options = {}) {
-        const items = [];
-        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);
-                count = -count;
-            }
-            while (count--) {
-                const item = await readItemMethod(stream, options);
-                items.push(item);
-            }
-        }
-        return items;
-    }
-}
-var AvroComplex;
-(function (AvroComplex) {
-    AvroComplex["RECORD"] = "record";
-    AvroComplex["ENUM"] = "enum";
-    AvroComplex["ARRAY"] = "array";
-    AvroComplex["MAP"] = "map";
-    AvroComplex["UNION"] = "union";
-    AvroComplex["FIXED"] = "fixed";
-})(AvroComplex || (AvroComplex = {}));
-class AvroType {
-    /**
-     * Determines the AvroType from the Avro Schema.
-     */
-    static fromSchema(schema) {
-        if (typeof schema === "string") {
-            return AvroType.fromStringSchema(schema);
-        }
-        else if (Array.isArray(schema)) {
-            return AvroType.fromArraySchema(schema);
-        }
-        else {
-            return AvroType.fromObjectSchema(schema);
-        }
-    }
-    static fromStringSchema(schema) {
-        switch (schema) {
-            case AvroPrimitive.NULL:
-            case AvroPrimitive.BOOLEAN:
-            case AvroPrimitive.INT:
-            case AvroPrimitive.LONG:
-            case AvroPrimitive.FLOAT:
-            case AvroPrimitive.DOUBLE:
-            case AvroPrimitive.BYTES:
-            case AvroPrimitive.STRING:
-                return new AvroPrimitiveType(schema);
-            default:
-                throw new Error(`Unexpected Avro type ${schema}`);
-        }
-    }
-    static fromArraySchema(schema) {
-        return new AvroUnionType(schema.map(AvroType.fromSchema));
-    }
-    static fromObjectSchema(schema) {
-        const type = schema.type;
-        // Primitives can be defined as strings or objects
-        try {
-            return AvroType.fromStringSchema(type);
-        }
-        catch (err) { }
-        switch (type) {
-            case AvroComplex.RECORD:
-                if (schema.aliases) {
-                    throw new Error(`aliases currently is not supported, schema: ${schema}`);
-                }
-                if (!schema.name) {
-                    throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
-                }
-                const fields = {};
-                if (!schema.fields) {
-                    throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
-                }
-                for (const field of schema.fields) {
-                    fields[field.name] = AvroType.fromSchema(field.type);
-                }
-                return new AvroRecordType(fields, schema.name);
-            case AvroComplex.ENUM:
-                if (schema.aliases) {
-                    throw new Error(`aliases currently is not supported, schema: ${schema}`);
-                }
-                if (!schema.symbols) {
-                    throw new Error(`Required attribute 'symbols' doesn't exist on schema: ${schema}`);
-                }
-                return new AvroEnumType(schema.symbols);
-            case AvroComplex.MAP:
-                if (!schema.values) {
-                    throw new Error(`Required attribute 'values' doesn't exist on schema: ${schema}`);
-                }
-                return new AvroMapType(AvroType.fromSchema(schema.values));
-            case AvroComplex.ARRAY: // Unused today
-            case AvroComplex.FIXED: // Unused today
-            default:
-                throw new Error(`Unexpected Avro type ${type} in ${schema}`);
-        }
-    }
-}
-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 = {}) {
-        switch (this._primitive) {
-            case AvroPrimitive.NULL:
-                return await AvroParser.readNull();
-            case AvroPrimitive.BOOLEAN:
-                return await AvroParser.readBoolean(stream, options);
-            case AvroPrimitive.INT:
-                return await AvroParser.readInt(stream, options);
-            case AvroPrimitive.LONG:
-                return await AvroParser.readLong(stream, options);
-            case AvroPrimitive.FLOAT:
-                return await AvroParser.readFloat(stream, options);
-            case AvroPrimitive.DOUBLE:
-                return await AvroParser.readDouble(stream, options);
-            case AvroPrimitive.BYTES:
-                return await AvroParser.readBytes(stream, options);
-            case AvroPrimitive.STRING:
-                return await AvroParser.readString(stream, options);
-            default:
-                throw new Error("Unknown Avro Primitive");
-        }
-    }
-}
-class AvroEnumType extends AvroType {
-    constructor(symbols) {
-        super();
-        this._symbols = symbols;
-    }
-    async read(stream, options = {}) {
-        const value = await AvroParser.readInt(stream, options);
-        return this._symbols[value];
-    }
-}
-class AvroUnionType extends AvroType {
-    constructor(types) {
-        super();
-        this._types = types;
-    }
-    async read(stream, options = {}) {
-        const typeIndex = await AvroParser.readInt(stream, options);
-        return await this._types[typeIndex].read(stream, options);
-    }
-}
-class AvroMapType extends AvroType {
-    constructor(itemType) {
-        super();
-        this._itemType = itemType;
-    }
-    async read(stream, options = {}) {
-        const readItemMethod = async (s, options) => {
-            return await this._itemType.read(s, options);
-        };
-        return await AvroParser.readMap(stream, readItemMethod, options);
-    }
-}
-class AvroRecordType extends AvroType {
-    constructor(fields, name) {
-        super();
-        this._fields = fields;
-        this._name = name;
-    }
-    async read(stream, options = {}) {
-        const record = {};
-        record["$schema"] = this._name;
-        for (const key in this._fields) {
-            if (this._fields.hasOwnProperty(key)) {
-                record[key] = await this._fields[key].read(stream, options);
-            }
-        }
-        return record;
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class AvroReader {
-    constructor(dataStream, headerStream, currentBlockOffset, indexWithinCurrentBlock) {
-        this._dataStream = dataStream;
-        this._headerStream = headerStream || dataStream;
-        this._initialized = false;
-        this._blockOffset = currentBlockOffset || 0;
-        this._objectIndex = indexWithinCurrentBlock || 0;
-        this._initialBlockOffset = currentBlockOffset || 0;
-    }
-    get blockOffset() {
-        return this._blockOffset;
-    }
-    get objectIndex() {
-        return this._objectIndex;
-    }
-    async initialize(options = {}) {
-        const header = await AvroParser.readFixedBytes(this._headerStream, AVRO_INIT_BYTES.length, {
-            abortSignal: options.abortSignal,
-        });
-        if (!arraysEqual(header, AVRO_INIT_BYTES)) {
-            throw new Error("Stream is not an Avro file.");
-        }
-        // File metadata is written as if defined by the following map schema:
-        // { "type": "map", "values": "bytes"}
-        this._metadata = await AvroParser.readMap(this._headerStream, AvroParser.readString, {
-            abortSignal: options.abortSignal,
-        });
-        // Validate codec
-        const codec = this._metadata[AVRO_CODEC_KEY];
-        if (!(codec == undefined || codec == "null")) {
-            throw new Error("Codecs are not supported");
-        }
-        // The 16-byte, randomly-generated sync marker for this file.
-        this._syncMarker = await AvroParser.readFixedBytes(this._headerStream, AVRO_SYNC_MARKER_SIZE, {
-            abortSignal: options.abortSignal,
-        });
-        // Parse the schema
-        const schema = JSON.parse(this._metadata[AVRO_SCHEMA_KEY]);
-        this._itemType = AvroType.fromSchema(schema);
-        if (this._blockOffset == 0) {
-            this._blockOffset = this._initialBlockOffset + this._dataStream.position;
-        }
-        this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, {
-            abortSignal: options.abortSignal,
-        });
-        // skip block length
-        await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
-        this._initialized = true;
-        if (this._objectIndex && this._objectIndex > 0) {
-            for (let i = 0; i < this._objectIndex; i++) {
-                await this._itemType.read(this._dataStream, { abortSignal: options.abortSignal });
-                this._itemsRemainingInBlock--;
-            }
-        }
-    }
-    hasNext() {
-        return !this._initialized || this._itemsRemainingInBlock > 0;
-    }
-    parseObjects(options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* parseObjects_1() {
-            if (!this._initialized) {
-                yield tslib.__await(this.initialize(options));
-            }
-            while (this.hasNext()) {
-                const result = yield tslib.__await(this._itemType.read(this._dataStream, {
-                    abortSignal: options.abortSignal,
-                }));
-                this._itemsRemainingInBlock--;
-                this._objectIndex++;
-                if (this._itemsRemainingInBlock == 0) {
-                    const marker = yield tslib.__await(AvroParser.readFixedBytes(this._dataStream, AVRO_SYNC_MARKER_SIZE, {
-                        abortSignal: options.abortSignal,
-                    }));
-                    this._blockOffset = this._initialBlockOffset + this._dataStream.position;
-                    this._objectIndex = 0;
-                    if (!arraysEqual(this._syncMarker, marker)) {
-                        throw new Error("Stream is not a valid Avro file.");
-                    }
-                    try {
-                        this._itemsRemainingInBlock = yield tslib.__await(AvroParser.readLong(this._dataStream, {
-                            abortSignal: options.abortSignal,
-                        }));
-                    }
-                    catch (err) {
-                        // We hit the end of the stream.
-                        this._itemsRemainingInBlock = 0;
-                    }
-                    if (this._itemsRemainingInBlock > 0) {
-                        // Ignore block size
-                        yield tslib.__await(AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal }));
-                    }
-                }
-                yield yield tslib.__await(result);
-            }
-        });
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-class AvroReadable {
-}
-
-// Copyright (c) Microsoft Corporation.
-const ABORT_ERROR = new abortController.AbortError("Reading from the avro stream was aborted.");
-class AvroReadableFromStream extends AvroReadable {
-    constructor(readable) {
-        super();
-        this._readable = readable;
-        this._position = 0;
-    }
-    toUint8Array(data) {
-        if (typeof data === "string") {
-            return Buffer.from(data);
-        }
-        return data;
-    }
-    get position() {
-        return this._position;
-    }
-    async read(size, options = {}) {
-        var _a;
-        if ((_a = options.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
-            throw ABORT_ERROR;
-        }
-        if (size < 0) {
-            throw new Error(`size parameter should be positive: ${size}`);
-        }
-        if (size === 0) {
-            return new Uint8Array();
-        }
-        if (!this._readable.readable) {
-            throw new Error("Stream no longer readable.");
-        }
-        // See if there is already enough data.
-        const chunk = this._readable.read(size);
-        if (chunk) {
-            this._position += chunk.length;
-            // chunk.length maybe less than desired size if the stream ends.
-            return this.toUint8Array(chunk);
-        }
-        else {
-            // register callback to wait for enough data to read
-            return new Promise((resolve, reject) => {
-                const cleanUp = () => {
-                    this._readable.removeListener("readable", readableCallback);
-                    this._readable.removeListener("error", rejectCallback);
-                    this._readable.removeListener("end", rejectCallback);
-                    this._readable.removeListener("close", rejectCallback);
-                    if (options.abortSignal) {
-                        options.abortSignal.removeEventListener("abort", abortHandler);
-                    }
-                };
-                const readableCallback = () => {
-                    const chunk = this._readable.read(size);
-                    if (chunk) {
-                        this._position += chunk.length;
-                        cleanUp();
-                        // chunk.length maybe less than desired size if the stream ends.
-                        resolve(this.toUint8Array(chunk));
-                    }
-                };
-                const rejectCallback = () => {
-                    cleanUp();
-                    reject();
-                };
-                const abortHandler = () => {
-                    cleanUp();
-                    reject(ABORT_ERROR);
-                };
-                this._readable.on("readable", readableCallback);
-                this._readable.once("error", rejectCallback);
-                this._readable.once("end", rejectCallback);
-                this._readable.once("close", rejectCallback);
-                if (options.abortSignal) {
-                    options.abortSignal.addEventListener("abort", abortHandler);
-                }
-            });
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * Read body from downloading operation methods to string.
- * Works in both Node.js and browsers.
- *
- * @param response - Convenience layer methods response with downloaded body
- * @param length - Length of Readable stream, needed for Node.js environment
- */
-async function bodyToString(response, length) {
-    return new Promise((resolve, reject) => {
-        response.readableStreamBody.on("readable", () => {
-            const chunk = response.readableStreamBody.read(length);
-            if (chunk) {
-                resolve(chunk.toString());
-            }
-        });
-        response.readableStreamBody.on("error", reject);
-        response.readableStreamBody.on("end", () => {
-            resolve("");
-        });
-    });
-}
-function streamToAvroReadable(readableStream) {
-    return new AvroReadableFromStream(readableStream);
-}
-
-// Copyright (c) Microsoft Corporation.
-class Segment {
-    constructor(shards, shardIndex, dateTime, manifestPath) {
-        this.manifestPath = manifestPath;
-        this.shards = shards;
-        this.shardIndex = shardIndex;
-        this._dateTime = dateTime;
-        this.shardDone = Array(shards.length).fill(false);
-        this.shardDoneCount = 0;
-    }
-    get dateTime() {
-        return this._dateTime;
-    }
-    hasNext() {
-        return this.shards.length > this.shardDoneCount;
-    }
-    async getChange(options = {}) {
-        const { span, updatedOptions } = createSpan("Segment-getChange", options);
-        try {
-            if (this.shardIndex >= this.shards.length || this.shardIndex < 0) {
-                throw new Error("shardIndex invalid.");
-            }
-            let event = undefined;
-            while (event === undefined && this.hasNext()) {
-                if (this.shardDone[this.shardIndex]) {
-                    this.shardIndex = (this.shardIndex + 1) % this.shards.length; // find next available shard
-                    continue;
-                }
-                const currentShard = this.shards[this.shardIndex];
-                event = await currentShard.getChange({
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-                if (!currentShard.hasNext()) {
-                    this.shardDone[this.shardIndex] = true;
-                    this.shardDoneCount++;
-                }
-                // Round robin with shards
-                this.shardIndex = (this.shardIndex + 1) % this.shards.length;
-            }
-            return event;
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-    getCursor() {
-        const shardCursors = [];
-        for (const shard of this.shards) {
-            const shardCursor = shard.getCursor();
-            if (shardCursor) {
-                shardCursors.push(shardCursor);
-            }
-        }
-        return {
-            SegmentPath: this.manifestPath,
-            ShardCursors: shardCursors,
-            CurrentShardPath: this.shards[this.shardIndex].shardPath,
-        };
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class SegmentFactory {
-    constructor(shardFactory) {
-        this.shardFactory = shardFactory;
-    }
-    async create(containerClient, manifestPath, cursor, options = {}) {
-        const { span, updatedOptions } = createSpan("SegmentFactory-create", options);
-        try {
-            const shards = [];
-            const dateTime = parseDateFromSegmentPath(manifestPath);
-            const blobClient = containerClient.getBlobClient(manifestPath);
-            const blobDownloadRes = await blobClient.download(undefined, undefined, {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            const blobContent = await bodyToString(blobDownloadRes);
-            const segmentManifest = JSON.parse(blobContent);
-            const containerPrefixLength = CHANGE_FEED_CONTAINER_NAME.length + 1; // "$blobchangefeed/"
-            for (const shardPath of segmentManifest.chunkFilePaths) {
-                const shardPathSubStr = shardPath.substring(containerPrefixLength);
-                const shardCursor = cursor === null || cursor === void 0 ? void 0 : cursor.ShardCursors.find((x) => x.CurrentChunkPath.startsWith(shardPathSubStr));
-                const shard = await this.shardFactory.create(containerClient, shardPathSubStr, shardCursor, {
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-                if (shard.hasNext()) {
-                    shards.push(shard);
-                }
-            }
-            let shardIndex = 0;
-            if (cursor === null || cursor === void 0 ? void 0 : cursor.CurrentShardPath) {
-                shardIndex = shards.findIndex((s) => s.shardPath === (cursor === null || cursor === void 0 ? void 0 : cursor.CurrentShardPath));
-                if (shardIndex === -1) {
-                    shardIndex = 0;
-                }
-            }
-            return new Segment(shards, shardIndex, dateTime, manifestPath);
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class Shard {
-    constructor(containerClient, chunkFactory, chunks, currentChunk, shardPath) {
-        this.shardPath = shardPath;
-        this.containerClient = containerClient;
-        this.chunkFactory = chunkFactory;
-        this.chunks = chunks;
-        this.currentChunk = currentChunk;
-    }
-    hasNext() {
-        return (this.chunks.length > 0 || (this.currentChunk !== undefined && this.currentChunk.hasNext()));
-    }
-    async getChange(options = {}) {
-        const { span, updatedOptions } = createSpan("Shard-getChange", options);
-        try {
-            let event = undefined;
-            while (event === undefined && this.hasNext()) {
-                event = await this.currentChunk.getChange();
-                // Remove currentChunk if it doesn't have more events.
-                if (!this.currentChunk.hasNext() && this.chunks.length > 0) {
-                    this.currentChunk = await this.chunkFactory.create(this.containerClient, this.chunks.shift(), undefined, undefined, {
-                        abortSignal: options.abortSignal,
-                        tracingOptions: updatedOptions.tracingOptions,
-                    });
-                }
-            }
-            return event;
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-    getCursor() {
-        return this.currentChunk === undefined
-            ? undefined
-            : {
-                CurrentChunkPath: this.currentChunk.chunkPath,
-                BlockOffset: this.currentChunk.blockOffset,
-                EventIndex: this.currentChunk.eventIndex,
-            };
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class ShardFactory {
-    constructor(chunkFactory) {
-        this.chunkFactory = chunkFactory;
-    }
-    async create(containerClient, shardPath, shardCursor, options = {}) {
-        var e_1, _a;
-        const { span, updatedOptions } = createSpan("ShardFactory-create", options);
-        try {
-            const chunks = [];
-            const blockOffset = (shardCursor === null || shardCursor === void 0 ? void 0 : shardCursor.BlockOffset) || 0;
-            const eventIndex = (shardCursor === null || shardCursor === void 0 ? void 0 : shardCursor.EventIndex) || 0;
-            try {
-                for (var _b = tslib.__asyncValues(containerClient.listBlobsFlat({
-                    prefix: shardPath,
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                })), _c; _c = await _b.next(), !_c.done;) {
-                    const blobItem = _c.value;
-                    chunks.push(blobItem.name);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            const currentChunkPath = shardCursor === null || shardCursor === void 0 ? void 0 : shardCursor.CurrentChunkPath;
-            let chunkIndex = -1;
-            let currentChunk = undefined;
-            // Chunks can be empty right after hour flips.
-            if (chunks.length !== 0) {
-                // Fast forward to current Chunk
-                if (currentChunkPath) {
-                    for (let i = 0; i < chunks.length; i++) {
-                        if (chunks[i] === currentChunkPath) {
-                            chunkIndex = i;
-                            break;
-                        }
-                    }
-                    if (chunkIndex === -1) {
-                        throw new Error(`Chunk ${currentChunkPath} not found.`);
-                    }
-                }
-                else {
-                    chunkIndex = 0;
-                }
-                // Fast forward to current Chunk.
-                if (chunkIndex > 0) {
-                    chunks.splice(0, chunkIndex);
-                }
-                currentChunk = await this.chunkFactory.create(containerClient, chunks.shift(), blockOffset, eventIndex, {
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-            }
-            return new Shard(containerClient, this.chunkFactory, chunks, currentChunk, shardPath);
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class Chunk {
-    constructor(avroReader, blockOffset, eventIndex, chunkPath, avroOptions = {}) {
-        this.chunkPath = chunkPath;
-        this.avroReader = avroReader;
-        this._blockOffset = blockOffset;
-        this._eventIndex = eventIndex;
-        this.iter = this.avroReader.parseObjects(avroOptions);
-    }
-    get blockOffset() {
-        return this._blockOffset;
-    }
-    get eventIndex() {
-        return this._eventIndex;
-    }
-    hasNext() {
-        return this.avroReader.hasNext();
-    }
-    async getChange() {
-        if (!this.hasNext()) {
-            return undefined;
-        }
-        const next = await this.iter.next();
-        this._eventIndex = this.avroReader.objectIndex;
-        this._blockOffset = this.avroReader.blockOffset;
-        if (next.done) {
-            return undefined;
-        }
-        else {
-            const eventRaw = next.value;
-            if (eventRaw === null) {
-                return undefined;
-            }
-            return rawEventToBlobChangeFeedEvent(eventRaw);
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class ChunkFactory {
-    constructor(avroReaderFactory, lazyLoadingBlobStreamFactory) {
-        this.avroReaderFactory = avroReaderFactory;
-        this.lazyLoadingBlobStreamFactory = lazyLoadingBlobStreamFactory;
-    }
-    async create(containerClient, chunkPath, blockOffset, eventIndex, options = {}) {
-        const blobClient = containerClient.getBlobClient(chunkPath);
-        blockOffset = blockOffset || 0;
-        eventIndex = eventIndex || 0;
-        const dataStream = streamToAvroReadable(this.lazyLoadingBlobStreamFactory.create(blobClient, blockOffset, CHANGE_FEED_CHUNK_BLOCK_DOWNLOAD_SIZE, options));
-        let avroReader;
-        if (blockOffset !== 0) {
-            const headerStream = streamToAvroReadable(this.lazyLoadingBlobStreamFactory.create(blobClient, 0, CHANGE_FEED_CHUNK_BLOCK_DOWNLOAD_SIZE, options));
-            avroReader = this.avroReaderFactory.create(dataStream, headerStream, blockOffset, eventIndex);
-        }
-        else {
-            avroReader = this.avroReaderFactory.create(dataStream);
-        }
-        return new Chunk(avroReader, blockOffset, eventIndex, chunkPath, {
-            abortSignal: options.abortSignal,
-        });
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * Creates AvroReaders.  Allows us to inject mock AvroReaders in the Chunk unit tests.
- */
-class AvroReaderFactory {
-    create(dataStream, headerStream, blockOffset, eventIndex) {
-        if (headerStream) {
-            return new AvroReader(dataStream, headerStream, blockOffset, eventIndex);
-        }
-        else {
-            return new AvroReader(dataStream);
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * This class generates a readable stream from a blobClient's data.
- */
-class LazyLoadingBlobStream extends stream.Readable {
-    /**
-     * Creates an instance of LazyLoadingBlobStream.
-     *
-     * @param byteLength - The total length of data contained in the buffers
-     */
-    constructor(blobClient, offset, blockSize, options) {
-        super(options);
-        this.blobClient = blobClient;
-        this.offset = offset;
-        this.blockSize = blockSize;
-        this.lastDownloadBytes = -1;
-        this.blobLength = -1;
-        this.options = options;
-    }
-    async downloadBlock(options = {}) {
-        const { span, updatedOptions } = createSpan("LazyLoadingBlobStream-downloadBlock", options);
-        try {
-            const properties = await this.blobClient.getProperties({
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            this.blobLength = properties.contentLength;
-            this.lastDownloadBytes = Math.min(this.blockSize, this.blobLength - this.offset);
-            if (this.lastDownloadBytes === 0) {
-                this.lastDownloadData = undefined;
-                return;
-            }
-            this.lastDownloadData = await this.blobClient.downloadToBuffer(this.offset, this.lastDownloadBytes, {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            this.offset += this.lastDownloadBytes;
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-    /**
-     * Internal _read() that will be called when the stream wants to pull more data in.
-     *
-     * @param size - Optional. The size of data to be read
-     */
-    async _read(size) {
-        var _a, _b, _c, _d;
-        const { span, updatedOptions } = createSpan("LazyLoadingBlobStream-read", this.options);
-        try {
-            if (!size) {
-                size = this.readableHighWaterMark;
-            }
-            let count = 0;
-            let chunkSize = 0;
-            const chunksToPush = [];
-            do {
-                if (this.lastDownloadData === undefined || ((_a = this.lastDownloadData) === null || _a === void 0 ? void 0 : _a.byteLength) === 0) {
-                    await this.downloadBlock({
-                        abortSignal: (_b = this.options) === null || _b === void 0 ? void 0 : _b.abortSignal,
-                        tracingOptions: updatedOptions === null || updatedOptions === void 0 ? void 0 : updatedOptions.tracingOptions,
-                    });
-                }
-                if ((_c = this.lastDownloadData) === null || _c === void 0 ? void 0 : _c.byteLength) {
-                    chunkSize = Math.min(size - count, (_d = this.lastDownloadData) === null || _d === void 0 ? void 0 : _d.byteLength);
-                    chunksToPush.push(this.lastDownloadData.slice(0, chunkSize));
-                    this.lastDownloadData = this.lastDownloadData.slice(chunkSize);
-                    count += chunkSize;
-                }
-                else {
-                    chunkSize = 0;
-                }
-            } while (chunkSize > 0 && count < size);
-            this.push(Buffer.concat(chunksToPush));
-            if (count < size) {
-                this.push(null);
-            }
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            this.emit("error", e);
-        }
-        finally {
-            span.end();
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class LazyLoadingBlobStreamFactory {
-    create(blobClient, offset, blockSize, options) {
-        return new LazyLoadingBlobStream(blobClient, offset, blockSize, options);
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-class ChangeFeedFactory {
-    constructor(segmentFactory) {
-        if (segmentFactory) {
-            this.segmentFactory = segmentFactory;
-        }
-        else {
-            this.segmentFactory = new SegmentFactory(new ShardFactory(new ChunkFactory(new AvroReaderFactory(), new LazyLoadingBlobStreamFactory())));
-        }
-    }
-    static validateCursor(containerClient, cursor) {
-        if (getHost(containerClient.url) !== cursor.UrlHost) {
-            throw new Error("Cursor URL host does not match container URL host.");
-        }
-        if (cursor.CursorVersion !== 1) {
-            throw new Error("Unsupported cursor version.");
-        }
-    }
-    async create(blobServiceClient, continuationToken, options = {}) {
-        const { span, updatedOptions } = createSpan("ChangeFeedFactory-create", options);
-        try {
-            const containerClient = blobServiceClient.getContainerClient(CHANGE_FEED_CONTAINER_NAME);
-            let cursor = undefined;
-            // Create cursor.
-            if (continuationToken) {
-                cursor = JSON.parse(continuationToken);
-                ChangeFeedFactory.validateCursor(containerClient, cursor);
-                options.start = parseDateFromSegmentPath(cursor.CurrentSegmentCursor.SegmentPath);
-                options.end = new Date(cursor.EndTime);
-            }
-            // Round start and end time if we are not using the cursor.
-            else {
-                options.start = floorToNearestHour(options.start);
-                options.end = ceilToNearestHour(options.end);
-            }
-            // Check if Change Feed has been enabled for this account.
-            const changeFeedContainerExists = await containerClient.exists({
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            if (!changeFeedContainerExists) {
-                throw new Error("Change Feed hasn't been enabled on this account, or is currently being enabled.");
-            }
-            if (options.start && options.end && options.start >= options.end) {
-                return new ChangeFeed();
-            }
-            // Get last consumable.
-            const blobClient = containerClient.getBlobClient(CHANGE_FEED_META_SEGMENT_PATH);
-            const blobDownloadRes = await blobClient.download(undefined, undefined, {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            const lastConsumable = new Date(JSON.parse(await bodyToString(blobDownloadRes)).lastConsumable);
-            // Get year paths
-            const years = await getYearsPaths(containerClient, {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            // Dequeue any years that occur before start time.
-            if (options.start) {
-                const startYear = options.start.getUTCFullYear();
-                while (years.length > 0 && years[0] < startYear) {
-                    years.shift();
-                }
-            }
-            if (years.length === 0) {
-                return new ChangeFeed();
-            }
-            let segments = [];
-            while (segments.length === 0 && years.length !== 0) {
-                segments = await getSegmentsInYear(containerClient, years.shift(), options.start, minDate(lastConsumable, options.end), {
-                    abortSignal: options.abortSignal,
-                    tracingOptions: updatedOptions.tracingOptions,
-                });
-            }
-            if (segments.length === 0) {
-                return new ChangeFeed();
-            }
-            const currentSegment = await this.segmentFactory.create(containerClient, segments.shift(), cursor === null || cursor === void 0 ? void 0 : cursor.CurrentSegmentCursor, {
-                abortSignal: options.abortSignal,
-                tracingOptions: updatedOptions.tracingOptions,
-            });
-            return new ChangeFeed(containerClient, this.segmentFactory, years, segments, currentSegment, lastConsumable, options.start, options.end);
-        }
-        catch (e) {
-            span.setStatus({
-                code: coreTracing.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * Contains paged response data for the {@link BlobChangeFeedClient.listChanges} operation.
- */
-class BlobChangeFeedEventPage {
-    constructor() {
-        this.events = [];
-        this.continuationToken = "";
-    }
-}
-/**
- * Creates a new Pipeline object with Credential provided.
- *
- * @param credential -  Such as AnonymousCredential, StorageSharedKeyCredential or any credential from the `@azure/identity` package to authenticate requests to the service. You can also provide an object that implements the TokenCredential interface. If not specified, AnonymousCredential is used.
- * @param pipelineOptions - Optional. Options.
- * @returns A new Pipeline object.
- */
-function newPipeline(credential, pipelineOptions = {}) {
-    return newPipeline(credential, appendUserAgentPrefix(pipelineOptions));
-}
-function appendUserAgentPrefix(options) {
-    if (!options) {
-        options = {};
-    }
-    if (options.userAgentOptions === undefined) {
-        options.userAgentOptions = {};
-    }
-    if (options.userAgentOptions.userAgentPrefix === undefined) {
-        options.userAgentOptions.userAgentPrefix = "";
-    }
-    else if (options.userAgentOptions.userAgentPrefix !== "") {
-        options.userAgentOptions.userAgentPrefix += " ";
-    }
-    options.userAgentOptions.userAgentPrefix += `changefeed-js/${SDK_VERSION}`;
-    return options;
-}
-/**
- * BlobChangeFeedClient.
- * @see https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blob-change-feed?tabs=azure-portal
- */
-class BlobChangeFeedClient {
-    constructor(urlOrClient, credentialOrPipeline, 
-    // Legacy, no way to fix the eslint error without breaking. Disable the rule for this line.
-    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options */
-    options) {
-        this.changeFeedFactory = new ChangeFeedFactory();
-        if (credentialOrPipeline instanceof storageBlob.Pipeline) {
-            this.blobServiceClient = new storageBlob.BlobServiceClient(urlOrClient, credentialOrPipeline);
-        }
-        else {
-            this.blobServiceClient = new storageBlob.BlobServiceClient(urlOrClient, credentialOrPipeline, appendUserAgentPrefix(options));
-        }
-    }
-    /**
-     *
-     * Creates an instance of BlobChangeFeedClient from connection string.
-     *
-     * @param connectionString - Account connection string or a SAS connection string of an Azure storage account.
-     *                                  [ Note - Account connection string can only be used in NODE.JS runtime. ]
-     *                                  Account connection string example -
-     *                                  `DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=accountKey;EndpointSuffix=core.windows.net`
-     *                                  SAS connection string example -
-     *                                  `BlobEndpoint=https://myaccount.blob.core.windows.net/;QueueEndpoint=https://myaccount.queue.core.windows.net/;FileEndpoint=https://myaccount.file.core.windows.net/;TableEndpoint=https://myaccount.table.core.windows.net/;SharedAccessSignature=sasString`
-     * @param options - Optional. Options to configure the HTTP pipeline.
-     */
-    static fromConnectionString(connectionString, 
-    // Legacy, no way to fix the eslint error without breaking. Disable the rule for this line.
-    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options */
-    options) {
-        const blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(connectionString, options);
-        return new BlobChangeFeedClient(blobServiceClient.url, blobServiceClient.credential, appendUserAgentPrefix(options));
-    }
-    getChange(options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* getChange_1() {
-            const changeFeed = yield tslib.__await(this.changeFeedFactory.create(this.blobServiceClient, undefined, options));
-            while (changeFeed.hasNext()) {
-                const event = yield tslib.__await(changeFeed.getChange({
-                    abortSignal: options.abortSignal,
-                    tracingOptions: options.tracingOptions,
-                }));
-                if (event) {
-                    yield yield tslib.__await(event);
-                }
-                else {
-                    return yield tslib.__await(void 0);
-                }
-            }
-        });
-    }
-    // start in ChangeFeedListChangesOptions will be ignored when continuationToken is specified.
-    getPage(continuationToken, maxPageSize, options = {}) {
-        return tslib.__asyncGenerator(this, arguments, function* getPage_1() {
-            const changeFeed = yield tslib.__await(this.changeFeedFactory.create(this.blobServiceClient, continuationToken, options));
-            if (!maxPageSize || maxPageSize > CHANGE_FEED_MAX_PAGE_SIZE) {
-                maxPageSize = CHANGE_FEED_MAX_PAGE_SIZE;
-            }
-            while (changeFeed.hasNext()) {
-                const eventPage = new BlobChangeFeedEventPage();
-                while (changeFeed.hasNext() && eventPage.events.length < maxPageSize) {
-                    const event = yield tslib.__await(changeFeed.getChange({
-                        abortSignal: options.abortSignal,
-                        tracingOptions: options.tracingOptions,
-                    }));
-                    if (event) {
-                        eventPage.events.push(event);
-                    }
-                }
-                if (changeFeed.hasNext()) {
-                    eventPage.continuationToken = JSON.stringify(changeFeed.getCursor());
-                }
-                if (eventPage.events.length > 0) {
-                    yield yield tslib.__await(eventPage);
-                }
-                else {
-                    return yield tslib.__await(void 0);
-                }
-            }
-        });
-    }
-    /**
-     * Returns an async iterable iterator to list all the change feed events
-     * in the specified account.
-     *
-     * .byPage() returns an async iterable iterator to list the change feed events in pages.
-     *
-     * Example using `for await` syntax:
-     *
-     * ```js
-     * let i = 1;
-     * for await (const event of blobChangeFeedClient.listChanges()) {
-     *   console.log(`Event ${i++}, type: ${event.eventType}`);
-     * }
-     * ```
-     *
-     * Example using `iter.next()`:
-     *
-     * ```js
-     * let i = 1;
-     * const iter = blobChangeFeedClient.listChanges();
-     * let eventItem = await iter.next();
-     * while (!eventItem.done) {
-     *   console.log(`Event ${i++}, type: ${eventItem.eventType}`);
-     *   eventItem = await iter.next();
-     * }
-     * ```
-     *
-     * Example using `byPage()`:
-     *
-     * ```js
-     * // passing optional maxPageSize in the page settings
-     * let i = 1;
-     * for await (const eventPage of blobChangeFeedClient.listChanges().byPage({ maxPageSize: 20 })) {
-     *   if (eventPage.events) {
-     *     for (const event of eventPage.events) {
-     *       console.log(`Event ${i++}, type: ${event.eventType}`);
-     *     }
-     *   }
-     * }
-     * ```
-     *
-     * Example using paging with a marker:
-     *
-     * ```js
-     * let i = 1;
-     * let iterator = blobChangeFeedClient.listChanges().byPage({ maxPageSize: 2 });
-     * let eventPage = (await iterator.next()).value;
-     *
-     * if (eventPage.events) {
-     *   for (const container of eventPage.events) {
-     *     console.log(`Event ${i++}, type: ${event.eventType}`);
-     *   }
-     * }
-     *
-     * // Gets next marker
-     * let marker = eventPage.continuationToken;
-     * // Passing next marker as continuationToken
-     * iterator = blobChangeFeedClient
-     *   .listChanges()
-     *   .byPage({ continuationToken: marker, maxPageSize: 10 });
-     * eventPage = (await iterator.next()).value;
-     *
-     * if (eventPage.events) {
-     *   for (const container of eventPage.events) {
-     *      console.log(`Event ${i++}, type: ${event.eventType}`);
-     *   }
-     * }
-     * ```
-     *
-     * @param options - Options to list change feed events.
-     * @returns An asyncIterableIterator that supports paging.
-     */
-    listChanges(options = {}) {
-        const iter = this.getChange(options);
-        return {
-            /**
-             * The next method, part of the iteration protocol
-             */
-            async next() {
-                return iter.next();
-            },
-            /**
-             * The connection to the async iterator, part of the iteration protocol
-             */
-            [Symbol.asyncIterator]() {
-                return this;
-            },
-            /**
-             * Return an AsyncIterableIterator that works a page at a time
-             */
-            byPage: (settings = {}) => {
-                return this.getPage(settings.continuationToken, settings.maxPageSize, options);
-            },
-        };
-    }
-}
-
-exports.BlobChangeFeedClient = BlobChangeFeedClient;
-exports.BlobChangeFeedEventPage = BlobChangeFeedEventPage;
-exports.newPipeline = newPipeline;
-//# sourceMappingURL=index.js.map