@bitpoolos/edge-bacnet 1.1.8 → 1.2.1

package/resources/node-bacstack-ts/dist/lib/npdu.js

@@ -0,0 +1,112 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = exports.decodeFunction = void 0;
+const baEnum = require("./enum");
+const BACNET_PROTOCOL_VERSION = 1;
+const BacnetAddressTypes = {
+    NONE: 0,
+    IP: 1
+};
+const decodeTarget = (buffer, offset) => {
+    let len = 0;
+    const target = { type: BacnetAddressTypes.NONE, net: (buffer[offset + len++] << 8) | (buffer[offset + len++] << 0) };
+    const adrLen = buffer[offset + len++];
+    if (adrLen > 0) {
+        target.adr = [];
+        for (let i = 0; i < adrLen; i++) {
+            target.adr.push(buffer[offset + len++]);
+        }
+    }
+    return {
+        target: target,
+        len: len
+    };
+};
+const encodeTarget = (buffer, target) => {
+    buffer.buffer[buffer.offset++] = (target.net & 0xFF00) >> 8;
+    buffer.buffer[buffer.offset++] = (target.net & 0x00FF) >> 0;
+    if (target.net === 0xFFFF || !target.adr) {
+        buffer.buffer[buffer.offset++] = 0;
+    }
+    else {
+        buffer.buffer[buffer.offset++] = target.adr.length;
+        if (target.adr.length > 0) {
+            for (let i = 0; i < target.adr.length; i++) {
+                buffer.buffer[buffer.offset++] = target.adr[i];
+            }
+        }
+    }
+};
+const decodeFunction = (buffer, offset) => {
+    if (buffer[offset + 0] !== BACNET_PROTOCOL_VERSION)
+        return;
+    return buffer[offset + 1];
+};
+exports.decodeFunction = decodeFunction;
+const decode = (buffer, offset) => {
+    const orgOffset = offset;
+    offset++;
+    const funct = buffer[offset++];
+    let destination;
+    if (funct & baEnum.NpduControlBits.DESTINATION_SPECIFIED) {
+        const tmpDestination = decodeTarget(buffer, offset);
+        offset += tmpDestination.len;
+        destination = tmpDestination.target;
+    }
+    let source;
+    if (funct & baEnum.NpduControlBits.SOURCE_SPECIFIED) {
+        const tmpSource = decodeTarget(buffer, offset);
+        offset += tmpSource.len;
+        source = tmpSource.target;
+    }
+    let hopCount = 0;
+    if (funct & baEnum.NpduControlBits.DESTINATION_SPECIFIED) {
+        hopCount = buffer[offset++];
+    }
+    let networkMsgType = baEnum.NetworkLayerMessageType.WHO_IS_ROUTER_TO_NETWORK;
+    let vendorId = 0;
+    if (funct & baEnum.NpduControlBits.NETWORK_LAYER_MESSAGE) {
+        networkMsgType = buffer[offset++];
+        if (networkMsgType >= 0x80) {
+            vendorId = (buffer[offset++] << 8) | (buffer[offset++] << 0);
+        }
+        else if (networkMsgType === baEnum.NetworkLayerMessageType.WHO_IS_ROUTER_TO_NETWORK) {
+            offset += 2;
+        }
+    }
+    if (buffer[orgOffset + 0] !== BACNET_PROTOCOL_VERSION)
+        return;
+    return {
+        len: offset - orgOffset,
+        funct: funct,
+        destination: destination,
+        source: source,
+        hopCount: hopCount,
+        networkMsgType: networkMsgType,
+        vendorId: vendorId
+    };
+};
+exports.decode = decode;
+const encode = (buffer, funct, destination, source, hopCount, networkMsgType, vendorId) => {
+    const hasDestination = destination && destination.net > 0;
+    const hasSource = source && source.net > 0 && source.net !== 0xFFFF;
+    buffer.buffer[buffer.offset++] = BACNET_PROTOCOL_VERSION;
+    buffer.buffer[buffer.offset++] = funct | (hasDestination ? baEnum.NpduControlBits.DESTINATION_SPECIFIED : 0) | (hasSource ? baEnum.NpduControlBits.SOURCE_SPECIFIED : 0);
+    if (hasDestination) {
+        encodeTarget(buffer, destination);
+    }
+    if (hasSource) {
+        encodeTarget(buffer, source);
+    }
+    if (hasDestination) {
+        buffer.buffer[buffer.offset++] = hopCount;
+    }
+    if ((funct & baEnum.NpduControlBits.NETWORK_LAYER_MESSAGE) > 0) {
+        buffer.buffer[buffer.offset++] = networkMsgType;
+        if (networkMsgType >= 0x80) {
+            buffer.buffer[buffer.offset++] = (vendorId & 0xFF00) >> 8;
+            buffer.buffer[buffer.offset++] = (vendorId & 0x00FF) >> 0;
+        }
+    }
+};
+exports.encode = encode;

package/resources/node-bacstack-ts/dist/lib/services/add-list-element.js

@@ -0,0 +1,58 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, objectId, propertyId, arrayIndex, values) => {
+    baAsn1.encodeContextObjectId(buffer, 0, objectId.type, objectId.instance);
+    baAsn1.encodeContextEnumerated(buffer, 1, propertyId);
+    if (arrayIndex !== baEnum.ASN1_ARRAY_ALL) {
+        baAsn1.encodeContextUnsigned(buffer, 2, arrayIndex);
+    }
+    baAsn1.encodeOpeningTag(buffer, 3);
+    values.forEach((value) => baAsn1.bacappEncodeApplicationData(buffer, value));
+    baAsn1.encodeClosingTag(buffer, 3);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    const value = {};
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    value.objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    value.property = { id: decodedValue.value, index: baEnum.ASN1_ARRAY_ALL };
+    if (len < apduLen && baAsn1.decodeIsContextTag(buffer, offset + len, 2)) {
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.property.index = decodedValue.value;
+    }
+    const values = [];
+    if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 3))
+        return;
+    len++;
+    while ((apduLen - len) > 1) {
+        result = baAsn1.bacappDecodeApplicationData(buffer, offset + len, apduLen + offset, value.objectId.type, value.property.id);
+        if (!result)
+            return;
+        len += result.len;
+        delete result.len;
+        values.push(result);
+    }
+    value.values = values;
+    if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 3))
+        return;
+    len++;
+    value.len = len;
+    return value;
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/alarm-acknowledge.js

@@ -0,0 +1,93 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, ackProcessId, eventObjectId, eventStateAcknowledged, ackSource, eventTimeStamp, ackTimeStamp) => {
+    baAsn1.encodeContextUnsigned(buffer, 0, ackProcessId);
+    baAsn1.encodeContextObjectId(buffer, 1, eventObjectId.type, eventObjectId.instance);
+    baAsn1.encodeContextEnumerated(buffer, 2, eventStateAcknowledged);
+    baAsn1.bacappEncodeContextTimestamp(buffer, 3, eventTimeStamp);
+    baAsn1.encodeContextCharacterString(buffer, 4, ackSource);
+    baAsn1.bacappEncodeContextTimestamp(buffer, 5, ackTimeStamp);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    const value = {};
+    let result;
+    let decodedValue;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    value.acknowledgedProcessId = decodedValue.value;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    value.eventObjectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    value.eventStateAcknowledged = decodedValue.value;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber === baEnum.TimeStamp.TIME) {
+        decodedValue = baAsn1.decodeBacnetTime(buffer, offset + len);
+        len += decodedValue.len;
+        value.eventTimeStamp = decodedValue.value;
+    }
+    else if (result.tagNumber === baEnum.TimeStamp.SEQUENCE_NUMBER) {
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.eventTimeStamp = decodedValue.value;
+    }
+    else if (result.tagNumber === baEnum.TimeStamp.DATETIME) {
+        const dateRaw = baAsn1.decodeApplicationDate(buffer, offset + len);
+        len += dateRaw.len;
+        const date = dateRaw.value;
+        const timeRaw = baAsn1.decodeApplicationTime(buffer, offset + len);
+        len += timeRaw.len;
+        const time = timeRaw.value;
+        value.eventTimeStamp = new Date(date.getFullYear(), date.getMonth(), date.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+        len++;
+    }
+    len++;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeCharacterString(buffer, offset + len, apduLen - (offset + len), result.value);
+    value.acknowledgeSource = decodedValue.value;
+    len += decodedValue.len;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber === baEnum.TimeStamp.TIME) {
+        decodedValue = baAsn1.decodeBacnetTime(buffer, offset + len);
+        len += decodedValue.len;
+        value.acknowledgeTimeStamp = decodedValue.value;
+    }
+    else if (result.tagNumber === baEnum.TimeStamp.SEQUENCE_NUMBER) {
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.acknowledgeTimeStamp = decodedValue.value;
+    }
+    else if (result.tagNumber === baEnum.TimeStamp.DATETIME) {
+        const dateRaw = baAsn1.decodeApplicationDate(buffer, offset + len);
+        len += dateRaw.len;
+        const date = dateRaw.value;
+        const timeRaw = baAsn1.decodeApplicationTime(buffer, offset + len);
+        len += timeRaw.len;
+        const time = timeRaw.value;
+        value.acknowledgeTimeStamp = new Date(date.getFullYear(), date.getMonth(), date.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+        len++;
+    }
+    len++;
+    value.len = len;
+    return value;
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/alarm-summary.js

@@ -0,0 +1,42 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const encode = (buffer, alarms) => {
+    alarms.forEach((alarm) => {
+        baAsn1.encodeContextObjectId(buffer, 12, alarm.objectId.type, alarm.objectId.instance);
+        baAsn1.encodeContextEnumerated(buffer, 9, alarm.alarmState);
+        baAsn1.encodeContextBitstring(buffer, 8, alarm.acknowledgedTransitions);
+    });
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    const alarms = [];
+    while ((apduLen - 3 - len) > 0) {
+        const value = {};
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+        len += decodedValue.len;
+        value.objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.alarmState = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeBitstring(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.acknowledgedTransitions = decodedValue.value;
+        alarms.push(value);
+    }
+    return {
+        len: len,
+        alarms: alarms
+    };
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/atomic-read-file.js

@@ -0,0 +1,157 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAcknowledge = exports.encodeAcknowledge = exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, isStream, objectId, position, count) => {
+    baAsn1.encodeApplicationObjectId(buffer, objectId.type, objectId.instance);
+    if (isStream) {
+        baAsn1.encodeOpeningTag(buffer, 0);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationUnsigned(buffer, count);
+        baAsn1.encodeClosingTag(buffer, 0);
+    }
+    else {
+        baAsn1.encodeOpeningTag(buffer, 1);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationUnsigned(buffer, count);
+        baAsn1.encodeClosingTag(buffer, 1);
+    }
+};
+exports.encode = encode;
+const decode = (buffer, offset) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    let isStream = true;
+    let objectId = {};
+    let position = -1;
+    let count = 0;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber !== baEnum.ApplicationTags.OBJECTIDENTIFIER)
+        return;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 0)) {
+        isStream = true;
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.SIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        position = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.UNSIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        count = decodedValue.value;
+        if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 0))
+            return;
+        len++;
+    }
+    else if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 1)) {
+        isStream = false;
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.SIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        position = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.UNSIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        count = decodedValue.value;
+        if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 1))
+            return;
+        len++;
+    }
+    else {
+        return;
+    }
+    return {
+        len: len,
+        isStream: isStream,
+        objectId: objectId,
+        position: position,
+        count: count
+    };
+};
+exports.decode = decode;
+const encodeAcknowledge = (buffer, isStream, endOfFile, position, blockCount, blocks, counts) => {
+    baAsn1.encodeApplicationBoolean(buffer, endOfFile);
+    if (isStream) {
+        baAsn1.encodeOpeningTag(buffer, 0);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationOctetString(buffer, blocks[0], 0, counts[0]);
+        baAsn1.encodeClosingTag(buffer, 0);
+    }
+    else {
+        baAsn1.encodeOpeningTag(buffer, 1);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationUnsigned(buffer, blockCount);
+        for (let i = 0; i < blockCount; i++) {
+            baAsn1.encodeApplicationOctetString(buffer, blocks[i], 0, counts[i]);
+        }
+        baAsn1.encodeClosingTag(buffer, 1);
+    }
+};
+exports.encodeAcknowledge = encodeAcknowledge;
+const decodeAcknowledge = (buffer, offset) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    let isStream;
+    let position;
+    let targetBuffer;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber !== baEnum.ApplicationTags.BOOLEAN)
+        return;
+    const endOfFile = result.value > 0;
+    if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 0)) {
+        isStream = true;
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.SIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        position = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.OCTET_STRING)
+            return;
+        targetBuffer = buffer.slice(offset + len, offset + len + result.value);
+        len += result.value;
+        if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 0))
+            return;
+        len++;
+    }
+    else if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 1)) {
+        isStream = false;
+        throw new Error('NotImplemented');
+    }
+    else {
+        return;
+    }
+    return {
+        len: len,
+        endOfFile: endOfFile,
+        isStream: isStream,
+        position: position,
+        buffer: targetBuffer
+    };
+};
+exports.decodeAcknowledge = decodeAcknowledge;

package/resources/node-bacstack-ts/dist/lib/services/atomic-write-file.js

@@ -0,0 +1,136 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAcknowledge = exports.encodeAcknowledge = exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, isStream, objectId, position, blocks) => {
+    baAsn1.encodeApplicationObjectId(buffer, objectId.type, objectId.instance);
+    if (isStream) {
+        baAsn1.encodeOpeningTag(buffer, 0);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationOctetString(buffer, blocks[0], 0, blocks[0].length);
+        baAsn1.encodeClosingTag(buffer, 0);
+    }
+    else {
+        baAsn1.encodeOpeningTag(buffer, 1);
+        baAsn1.encodeApplicationSigned(buffer, position);
+        baAsn1.encodeApplicationUnsigned(buffer, blocks.length);
+        for (let i = 0; i < blocks.length; i++) {
+            baAsn1.encodeApplicationOctetString(buffer, blocks[i], 0, blocks[i].length);
+        }
+        baAsn1.encodeClosingTag(buffer, 1);
+    }
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    let isStream;
+    let position;
+    const blocks = [];
+    let blockCount;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber !== baEnum.ApplicationTags.OBJECTIDENTIFIER)
+        return;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    const objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 0)) {
+        isStream = true;
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.SIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        position = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.OCTET_STRING)
+            return;
+        decodedValue = baAsn1.decodeOctetString(buffer, offset + len, apduLen, 0, result.value);
+        len += decodedValue.len;
+        blocks.push(decodedValue.value);
+        if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 0))
+            return;
+        len++;
+    }
+    else if (baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 1)) {
+        isStream = false;
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.SIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        position = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== baEnum.ApplicationTags.UNSIGNED_INTEGER)
+            return;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        blockCount = decodedValue.value;
+        for (let i = 0; i < blockCount; i++) {
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            if (result.tagNumber !== baEnum.ApplicationTags.OCTET_STRING)
+                return;
+            decodedValue = baAsn1.decodeOctetString(buffer, offset + len, apduLen, 0, result.value);
+            len += decodedValue.len;
+            blocks.push(decodedValue.value);
+        }
+        if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 1))
+            return;
+        len++;
+    }
+    else {
+        return;
+    }
+    return {
+        len: len,
+        isStream: isStream,
+        objectId: objectId,
+        position: position,
+        blocks: blocks
+    };
+};
+exports.decode = decode;
+const encodeAcknowledge = (buffer, isStream, position) => {
+    if (isStream) {
+        baAsn1.encodeContextSigned(buffer, 0, position);
+    }
+    else {
+        baAsn1.encodeContextSigned(buffer, 1, position);
+    }
+};
+exports.encodeAcknowledge = encodeAcknowledge;
+const decodeAcknowledge = (buffer, offset) => {
+    let len = 0;
+    let isStream = false;
+    let position = 0;
+    const result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if (result.tagNumber === 0) {
+        isStream = true;
+    }
+    else if (result.tagNumber === 1) {
+        isStream = false;
+    }
+    else {
+        return;
+    }
+    const decodedValue = baAsn1.decodeSigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    position = decodedValue.value;
+    return {
+        len: len,
+        isStream: isStream,
+        position: position
+    };
+};
+exports.decodeAcknowledge = decodeAcknowledge;