node-opcua-variant 2.165.0 → 2.167.0

package/dist/DataType_enum.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module node-opcua-variant
- */
-import { Enum } from "node-opcua-enum";
+import type { Enum } from "node-opcua-enum";
 export { DataType } from "node-opcua-basic-types";
 export declare const _enumerationDataType: Enum;

package/dist/DataType_enum.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._enumerationDataType = exports.DataType = void 0;
-const node_opcua_factory_1 = require("node-opcua-factory");
+/**
+ * @module node-opcua-variant
+ */
 const node_opcua_basic_types_1 = require("node-opcua-basic-types");
+const node_opcua_factory_1 = require("node-opcua-factory");
 var node_opcua_basic_types_2 = require("node-opcua-basic-types");
 Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return node_opcua_basic_types_2.DataType; } });
 const schemaDataType = {

package/dist/DataType_enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"DataType_enum.js","sourceRoot":"","sources":["../source/DataType_enum.ts"],"names":[],"mappings":";;;AAIA,2DAAyD;AACzD,mEAAkD;AAClD,iEAAkD;AAAzC,kHAAA,QAAQ,OAAA;AACjB,MAAM,cAAc,GAAG;IACnB,IAAI,EAAE,UAAU;IAEhB,UAAU,EAAE,iCAAQ;CACvB,CAAC;AACW,QAAA,oBAAoB,GAAS,IAAA,wCAAmB,EAAC,cAAc,CAAC,CAAC"}
+{"version":3,"file":"DataType_enum.js","sourceRoot":"","sources":["../source/DataType_enum.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,mEAAkD;AAElD,2DAAyD;AAEzD,iEAAkD;AAAzC,kHAAA,QAAQ,OAAA;AAEjB,MAAM,cAAc,GAAG;IACnB,IAAI,EAAE,UAAU;IAEhB,UAAU,EAAE,iCAAQ;CACvB,CAAC;AACW,QAAA,oBAAoB,GAAS,IAAA,wCAAmB,EAAC,cAAc,CAAC,CAAC"}

package/dist/VariantArrayType_enum.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module node-opcua-variant
  */
-import { Enum } from "node-opcua-enum";
+import type { Enum } from "node-opcua-enum";
 export declare enum VariantArrayType {
     Scalar = 0,
     Array = 1,

package/dist/adjust_variant.d.ts

@@ -1,3 +1,3 @@
-import { Variant } from "./variant";
 import { DataType } from "./DataType_enum";
+import type { Variant } from "./variant";
 export declare function adjustVariant(variant: Variant, valueRank: number, targetDataType: DataType): Variant;

package/dist/adjust_variant.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.adjustVariant = adjustVariant;
-const node_opcua_assert_1 = __importDefault(require("node-opcua-assert"));
+const node_opcua_assert_1 = require("node-opcua-assert");
 const DataType_enum_1 = require("./DataType_enum");
 const VariantArrayType_enum_1 = require("./VariantArrayType_enum");
 function adjustVariant(variant, valueRank, targetDataType) {
@@ -13,8 +10,8 @@ function adjustVariant(variant, valueRank, targetDataType) {
             // Byte
             variant.arrayType = VariantArrayType_enum_1.VariantArrayType.Array;
             variant.dataType = DataType_enum_1.DataType.Byte;
-            (0, node_opcua_assert_1.default)(variant.dataType === DataType_enum_1.DataType.Byte);
-            (0, node_opcua_assert_1.default)(!variant.value || variant.value instanceof Buffer);
+            (0, node_opcua_assert_1.assert)(variant.dataType === DataType_enum_1.DataType.Byte);
+            (0, node_opcua_assert_1.assert)(!variant.value || variant.value instanceof Buffer);
         }
     }
     if (targetDataType === DataType_enum_1.DataType.ByteString && valueRank === -1 /* Scalar*/) {
@@ -22,8 +19,8 @@ function adjustVariant(variant, valueRank, targetDataType) {
             // Byte
             variant.arrayType = VariantArrayType_enum_1.VariantArrayType.Scalar;
             variant.dataType = DataType_enum_1.DataType.ByteString;
-            (0, node_opcua_assert_1.default)(variant.dataType === DataType_enum_1.DataType.ByteString);
-            (0, node_opcua_assert_1.default)(!variant.value || variant.value instanceof Buffer);
+            (0, node_opcua_assert_1.assert)(variant.dataType === DataType_enum_1.DataType.ByteString);
+            (0, node_opcua_assert_1.assert)(!variant.value || variant.value instanceof Buffer);
         }
     }
     return variant;

package/dist/adjust_variant.js.map

@@ -1 +1 @@
-{"version":3,"file":"adjust_variant.js","sourceRoot":"","sources":["../source/adjust_variant.ts"],"names":[],"mappings":";;;;;AAKA,sCAoBC;AAzBD,0EAAuC;AAEvC,mDAA2C;AAC3C,mEAA2D;AAE3D,SAAgB,aAAa,CAAC,OAAgB,EAAE,SAAiB,EAAE,cAAwB;IACvF,IAAI,cAAc,KAAK,wBAAQ,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAClE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,MAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,EAAE,CAAC;YAC5F,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,KAAK,CAAC;YAC3C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,IAAI,CAAC;YACjC,IAAA,2BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAA,2BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;QAC9D,CAAC;IACL,CAAC;IACD,IAAI,cAAc,KAAK,wBAAQ,CAAC,UAAU,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;QACzE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,EAAE,CAAC;YACrF,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,MAAM,CAAC;YAC5C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,UAAU,CAAC;YACvC,IAAA,2BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,CAAC,CAAC;YACjD,IAAA,2BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;QAC9D,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC"}
+{"version":3,"file":"adjust_variant.js","sourceRoot":"","sources":["../source/adjust_variant.ts"],"names":[],"mappings":";;AAKA,sCAoBC;AAzBD,yDAA2C;AAC3C,mDAA2C;AAC3C,mEAA2D;AAG3D,SAAgB,aAAa,CAAC,OAAgB,EAAE,SAAiB,EAAE,cAAwB;IACvF,IAAI,cAAc,KAAK,wBAAQ,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAClE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,MAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,EAAE,CAAC;YAC5F,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,KAAK,CAAC;YAC3C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,IAAI,CAAC;YACjC,IAAA,0BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAA,0BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;QAC9D,CAAC;IACL,CAAC;IACD,IAAI,cAAc,KAAK,wBAAQ,CAAC,UAAU,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;QACzE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,EAAE,CAAC;YACrF,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,MAAM,CAAC;YAC5C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,UAAU,CAAC;YACvC,IAAA,0BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,CAAC,CAAC;YACjD,IAAA,0BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;QAC9D,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/dist/cast_variant.js.map

@@ -1 +1 @@
-{"version":3,"file":"cast_variant.js","sourceRoot":"","sources":["../source/cast_variant.ts"],"names":[],"mappings":";;AAGA,OAAO;AACP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCE"}
+{"version":3,"file":"cast_variant.js","sourceRoot":"","sources":["../source/cast_variant.ts"],"names":[],"mappings":";;AACA,OAAO;AACP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCE"}

package/dist/index.d.ts

@@ -23,9 +23,9 @@
 /**
  * @module node-opcua-variant
  */
+export * from "./adjust_variant";
+export * from "./cast_variant";
 export * from "./DataType_enum";
 export * from "./VariantArrayType_enum";
 export * from "./variant";
-export * from "./adjust_variant";
-export * from "./cast_variant";
 export * from "./verify_rank_and_dimension";

package/dist/index.js

@@ -1,19 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /*!
  * The MIT License (MIT)
  * Copyright (c) 2022-2025  Sterfive SAS - 833264583 RCS ORLEANS - France  (https://www.sterfive.com)
@@ -39,10 +24,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @module node-opcua-variant
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adjust_variant"), exports);
+__exportStar(require("./cast_variant"), exports);
 __exportStar(require("./DataType_enum"), exports);
 __exportStar(require("./VariantArrayType_enum"), exports);
 __exportStar(require("./variant"), exports);
-__exportStar(require("./adjust_variant"), exports);
-__exportStar(require("./cast_variant"), exports);
 __exportStar(require("./verify_rank_and_dimension"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;GAEG;AACH,kDAAgC;AAChC,0DAAwC;AACxC,4CAA0B;AAC1B,mDAAiC;AACjC,iDAA+B;AAC/B,8DAA4C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;GAEG;;;;;;;;;;;;;;;;AAEH,mDAAiC;AACjC,iDAA+B;AAC/B,kDAAgC;AAChC,0DAAwC;AACxC,4CAA0B;AAC1B,8DAA4C"}

package/dist/variant.d.ts

@@ -1,5 +1,5 @@
-import { BaseUAObject, DecodeDebugOptions } from "node-opcua-factory";
-import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import type { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { BaseUAObject, type DecodeDebugOptions } from "node-opcua-factory";
 import { DataType } from "./DataType_enum";
 import { VariantArrayType } from "./VariantArrayType_enum";
 export { VariantArrayType };

package/dist/variant.js

@@ -11,12 +11,12 @@ exports.sameVariant = sameVariant;
  * @module node-opcua-variant
  */
 const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
 const node_opcua_basic_types_1 = require("node-opcua-basic-types");
 const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_debug_1 = require("node-opcua-debug");
 const node_opcua_factory_1 = require("node-opcua-factory");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
 const node_opcua_utils_1 = require("node-opcua-utils");
-const node_opcua_debug_1 = require("node-opcua-debug");
 const DataType_enum_1 = require("./DataType_enum");
 const VariantArrayType_enum_1 = require("./VariantArrayType_enum");
 Object.defineProperty(exports, "VariantArrayType", { enumerable: true, get: function () { return VariantArrayType_enum_1.VariantArrayType; } });
@@ -64,6 +64,7 @@ class Variant extends node_opcua_factory_1.BaseUAObject {
     static computer_default_value = () => new Variant({ dataType: DataType_enum_1.DataType.Null });
     dataType;
     arrayType;
+    // biome-ignore lint/suspicious/noExplicitAny: intentionally using any here
     value;
     dimensions;
     constructor(options) {
@@ -125,34 +126,38 @@ class Variant extends node_opcua_factory_1.BaseUAObject {
 }
 exports.Variant = Variant;
 Variant.prototype.schema = schemaVariant;
-function variantToString(self, options) {
-    function toString(value) {
+function variantToString(self, _options) {
+    function asString(value) {
         switch (self.dataType) {
             case DataType_enum_1.DataType.ByteString:
-                return value ? "0x" + value.toString("hex") : "<null>";
+                return value ? `0x${value.toString("hex")}` : "<null>";
             case DataType_enum_1.DataType.NodeId:
-                return value instanceof node_opcua_nodeid_1.NodeId ? value.displayText() : value ? value.toString(options) : "";
+                return value instanceof node_opcua_nodeid_1.NodeId ? value.displayText() : value ? String(value) : "";
             case DataType_enum_1.DataType.Boolean:
-                return value.toString();
+                return String(value);
             case DataType_enum_1.DataType.DateTime:
-                return value ? (value.toISOString ? value.toISOString() : value.toString()) : "<null>";
+                return value
+                    ? typeof value.toISOString === "function"
+                        ? value.toISOString()
+                        : String(value)
+                    : "<null>";
             default:
-                return value ? value.toString(options) : "0";
+                return value ? String(value) : "0";
         }
     }
     function f(value) {
         if (value === undefined || (value === null && typeof value === "object")) {
             return "<null>";
         }
-        return toString(value);
+        return asString(value);
     }
     let data = VariantArrayType_enum_1.VariantArrayType[self.arrayType];
     if (self.dimensions && self.dimensions.length >= 0) {
-        data += "[ " + self.dimensions.join(",") + " ]";
+        data += `[ ${self.dimensions.join(",")} ]`;
     }
-    data += "<" + DataType_enum_1.DataType[self.dataType] + ">";
+    data += `<${DataType_enum_1.DataType[self.dataType]}>`;
     if (self.arrayType === VariantArrayType_enum_1.VariantArrayType.Scalar) {
-        data += ", value: " + f(self.value);
+        data += `, value: ${f(self.value)}`;
     }
     else if (self.arrayType === VariantArrayType_enum_1.VariantArrayType.Array || self.arrayType === VariantArrayType_enum_1.VariantArrayType.Matrix) {
         if (!self.value) {
@@ -167,10 +172,10 @@ function variantToString(self, options) {
             if (self.value.length > 10) {
                 a.push("...");
             }
-            data += ", l= " + self.value.length + ", value=[" + a.map(f).join(",") + "]";
+            data += `, l= ${self.value.length}, value=[${a.map(f).join(",")}]`;
         }
     }
-    return "Variant(" + data + ")";
+    return `Variant(${data})`;
 }
 /***
  * @private
@@ -216,7 +221,7 @@ function encodeVariant(variant, stream) {
 function _decodeVariantArrayDebug(stream, decode, tracer, dataType) {
     let cursorBefore = stream.length;
     const length = (0, node_opcua_basic_types_1.decodeUInt32)(stream);
-    let i;
+    let i = 0;
     let element;
     tracer.trace("start_array", "Variant", -1, cursorBefore, stream.length);
     if (length === 0xffffffff) {
@@ -257,7 +262,7 @@ function decodeDebugVariant(self, stream, options) {
     const decode = (0, node_opcua_factory_1.findBuiltInType)(DataType_enum_1.DataType[self.dataType]).decode;
     /* c8 ignore next */
     if (!decode) {
-        throw new Error("Variant.decode : cannot find decoder for type " + DataType_enum_1.DataType[self.dataType]);
+        throw new Error(`Variant.decode : cannot find decoder for type ${DataType_enum_1.DataType[self.dataType]}`);
     }
     const cursorBefore = stream.length;
     if (isArray) {
@@ -279,7 +284,7 @@ function decodeDebugVariant(self, stream, options) {
     //   stop and raise a BadDecodingError.
     if (hasDimension) {
         self.dimensions = decodeDimension(stream);
-        const verification = calculate_product(self.dimensions);
+        const _verification = calculate_product(self.dimensions);
     }
 }
 /* c8 ignore stop */
@@ -326,14 +331,14 @@ function constructHook(options) {
         };
         if (opts.dataType === DataType_enum_1.DataType.ExtensionObject) {
             if (opts.arrayType === VariantArrayType_enum_1.VariantArrayType.Scalar) {
-                if (opts.value && opts.value.constructor) {
+                if (opts?.value?.constructor) {
                     opts.value = new opts.value.constructor(opts.value);
                 }
             }
             else {
                 if (opts.value) {
                     opts.value = opts.value.map((e) => {
-                        if (e && e.constructor) {
+                        if (e?.constructor) {
                             return new e.constructor(e);
                         }
                         return null;
@@ -352,7 +357,7 @@ function constructHook(options) {
         const d = (0, node_opcua_factory_1.findBuiltInType)(options.dataType);
         /* c8 ignore start */
         if (!d) {
-            throw new Error("Cannot find Built-In data type or any DataType resolving to " + options.dataType);
+            throw new Error(`Cannot find Built-In data type or any DataType resolving to ${options.dataType}`);
         }
         /* c8 ignore stop */
         options.dataType = DataType_enum_1.DataType[d.name];
@@ -362,7 +367,7 @@ function constructHook(options) {
         const at = VariantArrayType_enum_1.VariantArrayType[options.arrayType];
         /* c8 ignore start */
         if (at === undefined) {
-            throw new Error("ArrayType: invalid " + options.arrayType);
+            throw new Error(`ArrayType: invalid ${options.arrayType}`);
         }
         /* c8 ignore stop */
         options.arrayType = at;
@@ -375,8 +380,8 @@ function constructHook(options) {
             throw new Error("Variant#constructor : when using UInt64 ou Int64" +
                 " arrayType must be specified , as automatic detection cannot be made");
         }
-        /* c8 ignore stop */
         else {
+            /* c8 ignore stop */
             options.arrayType = VariantArrayType_enum_1.VariantArrayType.Array;
             isArrayTypeUnspecified = false;
         }
@@ -388,21 +393,16 @@ function constructHook(options) {
             (0, node_opcua_assert_1.assert)(value1 === null || value1 !== options.value);
             options.value = value1;
         }
-        /* c8 ignore start */
         else {
+            /* c8 ignore start */
             (0, node_opcua_assert_1.assert)(options.arrayType === VariantArrayType_enum_1.VariantArrayType.Matrix);
             options.value = options.value || [];
             options.value = coerceVariantArray(options.dataType, options.value);
             if (!options.dimensions) {
                 throw new Error("Matrix Variant : missing dimensions");
             }
-            if (options.value.length != 0 && options.value.length !== calculate_product(options.dimensions)) {
-                throw new Error("Matrix Variant : invalid value size = options.value.length " +
-                    options.value.length +
-                    "!=" +
-                    calculate_product(options.dimensions) +
-                    " => " +
-                    JSON.stringify(options.dimensions));
+            if (options.value.length !== 0 && options.value.length !== calculate_product(options.dimensions)) {
+                throw new Error(`Matrix Variant : invalid value size = options.value.length ${options.value.length} != ${calculate_product(options.dimensions)} => ${JSON.stringify(options.dimensions)}`);
             }
         }
         /* c8 ignore stop */
@@ -410,20 +410,12 @@ function constructHook(options) {
     else {
         (0, node_opcua_assert_1.assert)(options.arrayType === VariantArrayType_enum_1.VariantArrayType.Scalar || options.arrayType === undefined);
         options.arrayType = VariantArrayType_enum_1.VariantArrayType.Scalar;
-        const tmp = options.value;
+        const _tmp = options.value;
         // scalar
         options.value = coerceVariantType(options.dataType, options.value);
         /* c8 ignore start */
         if (!isValidVariant(options.arrayType, options.dataType, options.value, null)) {
-            throw new Error("Invalid variant arrayType: " +
-                VariantArrayType_enum_1.VariantArrayType[options.arrayType] +
-                "  dataType: " +
-                DataType_enum_1.DataType[options.dataType] +
-                " value:" +
-                options.value +
-                " (javascript type = " +
-                typeof options.value +
-                " )");
+            throw new Error(`Invalid variant arrayType: ${VariantArrayType_enum_1.VariantArrayType[options.arrayType]}  dataType: ${DataType_enum_1.DataType[options.dataType]} value:${options.value} (javascript type = ${typeof options.value} )`);
         }
         /* c8 ignore stop */
     }
@@ -443,13 +435,13 @@ function get_encoder(dataType) {
     const dataTypeAsString = typeof dataType === "string" ? dataType : DataType_enum_1.DataType[dataType];
     /* c8 ignore start */
     if (!dataTypeAsString) {
-        throw new Error("invalid dataType " + dataType);
+        throw new Error(`invalid dataType ${dataType}`);
     }
     /* c8 ignore stop */
     const encode = (0, node_opcua_factory_1.findBuiltInType)(dataTypeAsString).encode;
     /* c8 ignore start */
     if (!encode) {
-        throw new Error("Cannot find encode function for dataType " + dataTypeAsString);
+        throw new Error(`Cannot find encode function for dataType ${dataTypeAsString}`);
     }
     /* c8 ignore stop */
     return encode;
@@ -459,7 +451,7 @@ function get_decoder(dataType) {
     const decode = (0, node_opcua_factory_1.findBuiltInType)(dataTypeAsString).decode;
     /* c8 ignore start */
     if (!decode) {
-        throw new Error("Variant.decode : cannot find decoder for type " + dataTypeAsString);
+        throw new Error(`Variant.decode : cannot find decoder for type ${dataTypeAsString}`);
     }
     /* c8 ignore stop */
     return decode;
@@ -486,9 +478,9 @@ function convertTo(dataType, arrayTypeConstructor, value) {
     }
     // c8 ignore next
     if (arrayTypeConstructor && displayWarning && n > 10) {
-        warningLog("Warning ! an array containing  " + DataType_enum_1.DataType[dataType] + " elements has been provided as a generic array. ");
-        warningLog("          This is inefficient as every array value will " + "have to be coerced and verified against the expected type");
-        warningLog("          It is highly recommended that you use a " + " typed array ", arrayTypeConstructor.constructor.name, " instead");
+        warningLog(`Warning ! an array containing  ${DataType_enum_1.DataType[dataType]} elements has been provided as a generic array. `);
+        warningLog("          This is inefficient as every array value will have to be coerced and verified against the expected type");
+        warningLog("          It is highly recommended that you use a  typed array ", arrayTypeConstructor.constructor.name, " instead");
     }
     return newArr;
 }
@@ -506,10 +498,11 @@ function coerceVariantArray(dataType, value) {
     }
 }
 function encodeTypedArray(arrayTypeConstructor, stream, value) {
-    (0, node_opcua_assert_1.assert)(value instanceof arrayTypeConstructor);
-    (0, node_opcua_assert_1.assert)(value.buffer instanceof ArrayBuffer);
-    (0, node_opcua_basic_types_1.encodeUInt32)(value.length, stream);
-    stream.writeArrayBuffer(value.buffer, value.byteOffset, value.byteLength);
+    const typedValue = value;
+    (0, node_opcua_assert_1.assert)(typedValue instanceof arrayTypeConstructor);
+    (0, node_opcua_assert_1.assert)(typedValue.buffer instanceof ArrayBuffer);
+    (0, node_opcua_basic_types_1.encodeUInt32)(typedValue.length, stream);
+    stream.writeArrayBuffer(typedValue.buffer, typedValue.byteOffset, typedValue.byteLength);
 }
 function encodeGeneralArray(dataType, stream, value) {
     if (!value) {
@@ -594,10 +587,11 @@ function encodeDimension(dimensions, stream) {
 }
 function isEnumerationItem(value) {
     return (value instanceof Object &&
-        Object.prototype.hasOwnProperty.call(value, "value") &&
-        Object.prototype.hasOwnProperty.call(value, "key") &&
+        Object.hasOwn(value, "value") &&
+        Object.hasOwn(value, "key") &&
         value.constructor.name === "EnumValueType");
 }
+// biome-ignore lint/suspicious/noExplicitAny: intentional
 function coerceVariantType(dataType, value) {
     /* eslint max-statements: ["error",1000], complexity: ["error",1000]*/
     if (value === undefined) {
@@ -608,7 +602,7 @@ function coerceVariantType(dataType, value) {
         // OPCUA Specification 1.0.3 5.8.2 encoding rules for various dataType:
         // [...]Enumeration are always encoded as Int32 on the wire [...]
         if (dataType !== DataType_enum_1.DataType.Int32 && dataType !== DataType_enum_1.DataType.ExtensionObject) {
-            throw new Error("expecting DataType.Int32 for enumeration values ;" + " got DataType." + dataType.toString() + " instead");
+            throw new Error(`expecting DataType.Int32 for enumeration values ; got DataType.${dataType.toString()} instead`);
         }
     }
     /* c8 ignore stop */
@@ -633,8 +627,8 @@ function coerceVariantType(dataType, value) {
             (0, node_opcua_assert_1.assert)(value !== undefined);
             value = parseInt(value, 10);
             /* c8 ignore start */
-            if (!isFinite(value)) {
-                throw new Error("expecting a number " + value);
+            if (!Number.isFinite(value)) {
+                throw new Error(`expecting a number ${value}`);
             }
             /* c8 ignore stop */
             break;
@@ -664,17 +658,16 @@ function coerceVariantType(dataType, value) {
         default:
             (0, node_opcua_assert_1.assert)(dataType !== undefined && dataType !== null, "Invalid DataType");
             break;
-        case DataType_enum_1.DataType.NodeId:
-            break;
     }
     return value;
 }
+// biome-ignore lint/suspicious/noExplicitAny: intentionally using an   y here
 function isValidScalarVariant(dataType, value) {
     (0, node_opcua_assert_1.assert)(value === null ||
         DataType_enum_1.DataType.Int64 === dataType ||
         DataType_enum_1.DataType.ByteString === dataType ||
         DataType_enum_1.DataType.UInt64 === dataType ||
-        !(value instanceof Array));
+        !Array.isArray(value));
     (0, node_opcua_assert_1.assert)(value === null || !(value instanceof Int32Array));
     (0, node_opcua_assert_1.assert)(value === null || !(value instanceof Uint32Array));
     switch (dataType) {
@@ -706,6 +699,7 @@ function isValidScalarVariant(dataType, value) {
             return true;
     }
 }
+// biome-ignore lint/suspicious/noExplicitAny: intentional - polymorphic Variant value
 function isValidArrayVariant(dataType, value) {
     if (value === null) {
         return true;
@@ -744,6 +738,7 @@ function isValidArrayVariant(dataType, value) {
     return true;
 }
 /* c8 ignore start */
+// biome-ignore lint/suspicious/noExplicitAny: intentional - polymorphic Variant value
 function isValidMatrixVariant(dataType, value, dimensions) {
     if (!dimensions) {
         return false;
@@ -762,7 +757,7 @@ function isValidVariant(arrayType, dataType, value, dimensions) {
             return isValidArrayVariant(dataType, value);
         default:
             (0, node_opcua_assert_1.assert)(arrayType === VariantArrayType_enum_1.VariantArrayType.Matrix);
-            return isValidMatrixVariant(dataType, value, dimensions);
+            return isValidMatrixVariant(dataType, value, dimensions ?? null);
     }
 }
 function buildVariantArray(dataType, nbElements, defaultValue) {
@@ -804,9 +799,11 @@ function buildVariantArray(dataType, nbElements, defaultValue) {
 }
 // old version of nodejs do not provide a Buffer#equals test
 const oldNodeVersion = typeof process === "object" && process.versions && process.versions.node && process.versions.node.substring(0, 1) === "0";
+// biome-ignore lint/suspicious/noExplicitAny: intentional - deep equality comparison of polymorphic values
 function __type(a) {
     return Object.prototype.toString.call(a);
 }
+// biome-ignore lint/suspicious/noExplicitAny: intentional - deep equality comparison of polymorphic values
 function __check_same_object(o1, o2) {
     if (o1 === o2)
         return true;
@@ -854,11 +851,12 @@ function __check_same_object(o1, o2) {
         case "[object BigInt]":
             return o1 === o2;
         case "[object Date]":
-            return o1.getTime() == o2.getTime();
+            return o1.getTime() === o2.getTime();
         default:
             return o1 === o2;
     }
 }
+// biome-ignore lint/suspicious/noExplicitAny: intentional - deep equality comparison of polymorphic values
 function __check_same_array(arr1, arr2) {
     if (!arr1 || !arr2) {
         return !arr1 && !arr2;