npm - node-opcua-address-space - Versions diffs - 2.183.1 → 2.184.0 - Mend

node-opcua-address-space 2.183.1 → 2.184.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (741) hide show

package/dist/impl/ua_variable_impl.js CHANGED Viewed

@@ -1,72 +1,65 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAVariableImplT = exports.UAVariableImpl = void 0;
-exports.adjust_accessLevel = adjust_accessLevel;
-exports.adjust_userAccessLevel = adjust_userAccessLevel;
 /**
  * @module node-opcua-address-space
  */
-const node_util_1 = require("node:util");
-const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_address_space_base_1 = require("node-opcua-address-space-base");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_data_value_1 = require("node-opcua-data-value");
-const node_opcua_date_time_1 = require("node-opcua-date-time");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_extension_object_1 = require("node-opcua-extension-object");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const node_opcua_numeric_range_1 = require("node-opcua-numeric-range");
-const node_opcua_service_write_1 = require("node-opcua-service-write");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const multiform_func_js_1 = require("../api/helpers/multiform_func.js");
-const session_context_js_1 = require("../api/session_context.js");
-const apply_condition_refresh_js_1 = require("./apply_condition_refresh.js");
-const base_node_impl_js_1 = require("./base_node_impl.js");
-const base_node_private_js_1 = require("./base_node_private.js");
-const adjust_datavalue_status_code_js_1 = require("./data_access/adjust_datavalue_status_code.js");
-const semantics_changed_js_1 = require("./data_access/semantics_changed.js");
-const get_basic_datatype_js_1 = require("./get_basic_datatype.js");
-const ua_data_type_impl_js_1 = require("./ua_data_type_impl.js");
-const ua_variable_impl_ext_obj_js_1 = require("./ua_variable_impl_ext_obj.js");
-const validate_data_type_correctness_js_1 = require("./validate_data_type_correctness.js");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)("ua_variable_impl");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("ua_variable_impl");
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)("ua_variable_impl");
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("ua_variable_impl");
+import { types } from "node:util";
+import chalk from "chalk";
+import { defaultCloneFilter, makeDefaultCloneExtraInfo } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { AccessLevelFlag, AttributeIds, convertAccessLevelFlagToByte, isDataEncoding, isValidDataEncoding, makeAccessLevelFlag, NodeClass } from "node-opcua-data-model";
+import { DataValue, extractRange, makeNowDataValue, sameDataValue } from "node-opcua-data-value";
+import { coerceClock, getCurrentClock } from "node-opcua-date-time";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { ExtensionObject, OpaqueStructure } from "node-opcua-extension-object";
+import { NodeId } from "node-opcua-nodeid";
+import { NumericRange } from "node-opcua-numeric-range";
+import { WriteValue } from "node-opcua-service-write";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { HistoryReadResult, PermissionType } from "node-opcua-types";
+import { adjustVariant, DataType, sameVariant, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
+import { convertToCallbackFunction1 } from "../api/helpers/multiform_func.js";
+import { SessionContext } from "../api/session_context.js";
+import { apply_condition_refresh } from "./apply_condition_refresh.js";
+import { BaseNodeImpl } from "./base_node_impl.js";
+import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private.js";
+import { loadClock } from "./bulk_load_clock.js";
+import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code.js";
+import { notifySemanticsChangedIfNeeded, raiseSemanticChangeEvent } from "./data_access/semantics_changed.js";
+import { _getBasicDataType } from "./get_basic_datatype.js";
+import { UADataTypeImpl } from "./ua_data_type_impl.js";
+import { _bindExtensionObject, _bindExtensionObjectArrayOrMatrix, _installExtensionObjectBindingOnProperties, extractPartialData, incrementElement, propagateTouchValueDownward, propagateTouchValueDownwardArray, propagateTouchValueUpward, setExtensionObjectPartialValue } from "./ua_variable_impl_ext_obj.js";
+import { validateDataTypeCorrectness } from "./validate_data_type_correctness.js";
+const debugLog = make_debugLog("ua_variable_impl");
+const warningLog = make_warningLog("ua_variable_impl");
+const doDebug = checkDebugFlag("ua_variable_impl");
+const errorLog = make_errorLog("ua_variable_impl");
 // a colourless chalk; see ua_object_impl.ts for why it is not a Proxy over `chalk`
-const plainChalk = new chalk_1.default.Instance({ level: 0 });
-function adjust_accessLevel(accessLevel) {
-    const flag = (0, node_opcua_data_model_1.makeAccessLevelFlag)(accessLevel ?? "CurrentRead | CurrentWrite");
-    (0, node_opcua_assert_1.assert)(Number.isFinite(flag));
+const plainChalk = new chalk.Instance({ level: 0 });
+export function adjust_accessLevel(accessLevel) {
+    const flag = makeAccessLevelFlag(accessLevel ?? "CurrentRead | CurrentWrite");
+    assert(Number.isFinite(flag));
     return flag;
 }
-function adjust_userAccessLevel(userAccessLevel, accessLevel) {
+export function adjust_userAccessLevel(userAccessLevel, accessLevel) {
     if (userAccessLevel === undefined) {
         return undefined;
     }
     userAccessLevel = adjust_accessLevel(userAccessLevel);
     accessLevel = adjust_accessLevel(accessLevel);
-    return (0, node_opcua_data_model_1.makeAccessLevelFlag)(accessLevel & userAccessLevel);
+    return makeAccessLevelFlag(accessLevel & userAccessLevel);
 }
 function adjust_samplingInterval(minimumSamplingInterval) {
-    (0, node_opcua_assert_1.assert)(Number.isFinite(minimumSamplingInterval));
+    assert(Number.isFinite(minimumSamplingInterval));
     if (minimumSamplingInterval < 0) {
         return -1; // only -1 is a valid negative value for samplingInterval and means "unspecified"
     }
     return minimumSamplingInterval;
 }
 function is_Variant(v) {
-    return v instanceof node_opcua_variant_1.Variant;
+    return v instanceof Variant;
 }
 function is_StatusCode(v) {
     return !!(v?.constructor &&
-        (v instanceof node_opcua_status_code_1.StatusCode ||
+        (v instanceof StatusCode ||
             v.constructor.name === "ConstantStatusCode" ||
             v.constructor.name === "StatusCode" ||
             v.constructor.name === "ModifiableStatusCode"));
@@ -106,7 +99,7 @@ function default_func(dataValue1, callback1) {
  *  indicates if the history of the Variable is available via the OPC UA server.
  *
  */
-class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
+export class UAVariableImpl extends BaseNodeImpl {
     // -------------- UAvaraibleImplExArray
     $$variableType;
     $$dataType = undefined;
@@ -114,7 +107,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     $$extensionObjectArray;
     $$indexPropertyName;
     // --------------
-    nodeClass = node_opcua_data_model_1.NodeClass.Variable;
+    nodeClass = NodeClass.Variable;
     dataType;
     _basicDataType;
     // narrowing this to ExtensionObject breaks declaration-merging in ua_two_state_variable.ts and elsewhere
@@ -143,8 +136,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     refreshFunc;
     __waiting_callbacks;
     get typeDefinitionObj() {
-        // c8 ignore next
-        if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
+        /* c8 ignore next */
+        if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== NodeClass.VariableType) {
             // this could happen in faulty external nodeset and has been seen once
             // in an nano server
             warningLog(super.typeDefinitionObj.toString());
@@ -160,7 +153,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     }
     constructor(options) {
         super(options);
-        (0, node_opcua_variant_1.verifyRankAndDimensions)(options);
+        verifyRankAndDimensions(options);
         this.valueRank = options.valueRank ?? -1;
         this.arrayDimensions = options.arrayDimensions ?? null;
         this.dataType = this.resolveNodeId(options.dataType); // DataType (NodeId)
@@ -171,11 +164,13 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         // a Variant built from null takes the constructor's short path; the options form costs twice as much.
         // Stamped with the clock of the construction: a variable nobody gives a value to (a nodeset
         // Variable of an abstract data type has no default to make up) is read as it is, and the
-        // requested timestamps are expected on that Uncertain result too (FEAT-34)
-        const now = (0, node_opcua_date_time_1.getCurrentClock)();
-        this.$dataValue = new node_opcua_data_value_1.DataValue({
-            statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue,
-            value: new node_opcua_variant_1.Variant(null),
+        // requested timestamps are expected on that Uncertain result too (FEAT-34).
+        // One reading for a whole load — see impl/bulk_load_clock.ts; outside a load of THIS
+        // address space this is getCurrentClock(), unchanged.
+        const now = loadClock(this.addressSpace);
+        this.$dataValue = new DataValue({
+            statusCode: StatusCodes.UncertainInitialValue,
+            value: new Variant(null),
             sourceTimestamp: now.timestamp,
             sourcePicoseconds: now.picoseconds,
             serverTimestamp: now.timestamp,
@@ -196,7 +191,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     checkPermissionPrivate(context, permission) {
         if (!context)
             return true;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         if (context.checkPermission) {
             if (!(context.checkPermission instanceof Function)) {
                 errorLog("context checkPermission is not a function");
@@ -215,43 +210,43 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         return this.checkAccessLevelPrivate(context, accessLevel);
     }
     isReadable(_context) {
-        return (this.accessLevel & node_opcua_data_model_1.AccessLevelFlag.CurrentRead) === node_opcua_data_model_1.AccessLevelFlag.CurrentRead;
+        return (this.accessLevel & AccessLevelFlag.CurrentRead) === AccessLevelFlag.CurrentRead;
     }
     isUserReadable(context) {
         if (!this.isReadable(context)) {
             return false;
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
             return false;
         }
-        return this.checkAccessLevelPrivate(context, node_opcua_data_model_1.AccessLevelFlag.CurrentRead);
+        return this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead);
     }
     isWritable(_context) {
-        return (this.accessLevel & node_opcua_data_model_1.AccessLevelFlag.CurrentWrite) === node_opcua_data_model_1.AccessLevelFlag.CurrentWrite;
+        return (this.accessLevel & AccessLevelFlag.CurrentWrite) === AccessLevelFlag.CurrentWrite;
     }
     isUserWritable(context) {
         if (!this.isWritable(context)) {
             return false;
         }
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.CurrentWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.Write, AccessLevelFlag.CurrentWrite);
     }
     canUserReadHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.ReadHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryRead);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.ReadHistory, AccessLevelFlag.HistoryRead);
     }
     canUserWriteHistorizingAttribute(context) {
-        if (context && !context.checkPermission(this, node_opcua_types_1.PermissionType.WriteHistorizing)) {
+        if (context && !context.checkPermission(this, PermissionType.WriteHistorizing)) {
             return false;
         }
         return true;
     }
     canUserInsertHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.InsertHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.InsertHistory, AccessLevelFlag.HistoryWrite);
     }
     canUserModifyHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.ModifyHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.ModifyHistory, AccessLevelFlag.HistoryWrite);
     }
     canUserDeleteHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.DeleteHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.DeleteHistory, AccessLevelFlag.HistoryWrite);
     }
     /**
      *
@@ -282,7 +277,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      */
     readValue(context, indexRange, dataEncoding) {
         if (!context) {
-            context = session_context_js_1.SessionContext.defaultContext;
+            context = SessionContext.defaultContext;
         }
         // A Bad result the variable makes up here carries the requested timestamps: a
         // DataValue may carry them whatever its status, and the CTT expects them on every
@@ -291,20 +286,20 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         // nodeset reserves to a role nobody holds, FEAT-34). The clock of the denial is
         // the honest source timestamp: the value behind it stays undisclosed.
         if (context.isAccessRestricted(this)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadSecurityModeInsufficient });
+            return makeNowDataValue({ statusCode: StatusCodes.BadSecurityModeInsufficient });
         }
         if (!this.isReadable(context)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadUserAccessDenied });
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            return makeNowDataValue({ statusCode: StatusCodes.BadUserAccessDenied });
         }
         if (!this.isUserReadable(context)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
-        if (!(0, node_opcua_data_model_1.isValidDataEncoding)(dataEncoding)) {
+        if (!isValidDataEncoding(dataEncoding)) {
             // Table 51: no encoding can be applied to a non-Structure value
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadDataEncodingInvalid });
+            return makeNowDataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
         if (this._timestamped_get_func) {
             if (this._timestamped_get_func.length === 0) {
@@ -312,7 +307,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 if (!Object.hasOwn(dataValueOrPromise.constructor.prototype, "then")) {
                     if (dataValueOrPromise !== this.$dataValue) {
                         // we may have a problem here if we use a getter that returns a dataValue that is a ExtensionObject
-                        if (dataValueOrPromise.value?.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+                        if (dataValueOrPromise.value?.dataType === DataType.ExtensionObject) {
                             if (this.$extensionObject || this.$$extensionObjectArray) {
                                 // we have an extension object already bound to this node
                                 // the client is asking us to replace the object entirely by a new one
@@ -336,17 +331,17 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         let dataValue = this.$dataValue;
         if (dataValue.statusCode.isGoodish()) {
             // note : extractRange will clone the dataValue
-            dataValue = (0, node_opcua_data_value_1.extractRange)(dataValue, indexRange);
+            dataValue = extractRange(dataValue, indexRange);
         }
         /* c8 ignore next */
-        if (dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadWaitingForInitialData) ||
-            dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.UncertainInitialValue)) {
-            // c8 ignore next
+        if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData) ||
+            dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
+            /* c8 ignore next */
             doDebug &&
-                debugLog(chalk_1.default.red(" Warning:  UAVariable#readValue ") +
-                    chalk_1.default.cyan(this.browseName.toString()) +
+                debugLog(chalk.red(" Warning:  UAVariable#readValue ") +
+                    chalk.cyan(this.browseName.toString()) +
                     " (" +
-                    chalk_1.default.yellow(this.nodeId.toString()) +
+                    chalk.yellow(this.nodeId.toString()) +
                     ") exists but dataValue has not been defined");
         }
         return dataValue;
@@ -374,7 +369,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     }
     _getEnumerationInfo() {
         // DataType must be one of Enumeration
-        (0, node_opcua_assert_1.assert)(this.isEnumeration(), "Variable is not an enumeration");
+        assert(this.isEnumeration(), "Variable is not an enumeration");
         const dataTypeNode = this.addressSpace.findDataType(this.dataType);
         return dataTypeNode._getEnumerationInfo();
     }
@@ -395,7 +390,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             const dataValue = this.readValue();
             dataValue.serverTimestamp = oldestDate.timestamp;
             dataValue.serverPicoseconds = oldestDate.picoseconds;
-            const serverClock = (0, node_opcua_date_time_1.coerceClock)(dataValue.serverTimestamp, dataValue.serverPicoseconds);
+            const serverClock = coerceClock(dataValue.serverTimestamp, dataValue.serverPicoseconds);
             if (lessOrEqual(oldestDate, serverClock)) {
                 cb(null, dataValue);
                 return;
@@ -407,7 +402,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             }
         }
         const c1 = this.$dataValue.serverTimestamp
-            ? (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.serverTimestamp, this.$dataValue.serverPicoseconds)
+            ? coerceClock(this.$dataValue.serverTimestamp, this.$dataValue.serverPicoseconds)
             : null;
         if (c1 && lessOrEqual(oldestDate, c1)) {
             const dataValue = this.readValue().clone();
@@ -421,7 +416,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 // c8 ignore next
                 if (err || !dataValue) {
                     errorLog("-------------- refresh call failed", this.browseName.toString(), this.nodeId.toString(), err?.message);
-                    dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
+                    dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
                 }
                 if (dataValue && dataValue !== this.$dataValue) {
                     this._internal_set_dataValue(coerceDataValue(dataValue), null);
@@ -432,7 +427,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         catch (err) {
             errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
             errorLog(err);
-            const dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadInternalError });
+            const dataValue = new DataValue({ statusCode: StatusCodes.BadInternalError });
             this._internal_set_dataValue(dataValue, null);
             cb(err, this.$dataValue);
         }
@@ -460,7 +455,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 throw new Error(`UAVariable#writeEnumValue : value out of range ${value} in [${possibleValues}]`);
             }
             this.setValueFromSource({
-                dataType: node_opcua_variant_1.DataType.Int32,
+                dataType: DataType.Int32,
                 value
             });
         }
@@ -469,47 +464,47 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     readAttribute(context, attributeId, indexRange, dataEncoding) {
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
         const options = {};
-        if (attributeId !== node_opcua_data_model_1.AttributeIds.Value) {
+        if (attributeId !== AttributeIds.Value) {
             if (indexRange?.isDefined()) {
-                options.statusCode = node_opcua_status_code_1.StatusCodes.BadIndexRangeNoData;
-                return new node_opcua_data_value_1.DataValue(options);
+                options.statusCode = StatusCodes.BadIndexRangeNoData;
+                return new DataValue(options);
             }
-            if ((0, node_opcua_data_model_1.isDataEncoding)(dataEncoding)) {
-                options.statusCode = node_opcua_status_code_1.StatusCodes.BadDataEncodingInvalid;
-                return new node_opcua_data_value_1.DataValue(options);
+            if (isDataEncoding(dataEncoding)) {
+                options.statusCode = StatusCodes.BadDataEncodingInvalid;
+                return new DataValue(options);
             }
         }
         switch (attributeId) {
-            case node_opcua_data_model_1.AttributeIds.Value:
+            case AttributeIds.Value:
                 return this.readValue(context, indexRange, dataEncoding);
-            case node_opcua_data_model_1.AttributeIds.DataType:
+            case AttributeIds.DataType:
                 return this._readDataType();
-            case node_opcua_data_model_1.AttributeIds.ValueRank:
+            case AttributeIds.ValueRank:
                 return this._readValueRank();
-            case node_opcua_data_model_1.AttributeIds.ArrayDimensions:
+            case AttributeIds.ArrayDimensions:
                 return this._readArrayDimensions();
-            case node_opcua_data_model_1.AttributeIds.AccessLevel:
+            case AttributeIds.AccessLevel:
                 return this._readAccessLevel(context);
-            case node_opcua_data_model_1.AttributeIds.UserAccessLevel:
+            case AttributeIds.UserAccessLevel:
                 return this._readUserAccessLevel(context);
-            case node_opcua_data_model_1.AttributeIds.MinimumSamplingInterval:
+            case AttributeIds.MinimumSamplingInterval:
                 return this._readMinimumSamplingInterval();
-            case node_opcua_data_model_1.AttributeIds.Historizing:
+            case AttributeIds.Historizing:
                 return this._readHistorizing();
-            case node_opcua_data_model_1.AttributeIds.AccessLevelEx:
+            case AttributeIds.AccessLevelEx:
                 return this._readAccessLevelEx(context);
             default:
-                return base_node_impl_js_1.BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
+                return BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
         }
     }
     getBasicDataType() {
-        return (0, get_basic_datatype_js_1._getBasicDataType)(this);
+        return _getBasicDataType(this);
     }
     adjustVariant(variant) {
-        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, this.getBasicDataType());
+        return adjustVariant(variant, this.valueRank, this.getBasicDataType());
     }
     verifyVariantCompatibility(variant) {
         try {
@@ -521,17 +516,17 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         " this.dataType= " +
                         this.dataType.toString());
                 }
-                if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
-                    (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
+                if (variant.dataType === DataType.Boolean &&
+                    (this.dataType.namespace !== 0 || this.dataType.value !== DataType.Boolean)) {
                     throw new Error("Variant must provide a valid Boolean : variant = " +
                         variant.toString() +
                         " this.dataType= " +
                         this.dataType.toString());
                 }
                 if (this.dataType.namespace === 0 &&
-                    this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
-                    variant.dataType !== node_opcua_variant_1.DataType.LocalizedText &&
-                    variant.dataType !== node_opcua_variant_1.DataType.Null) {
+                    this.dataType.value === DataType.LocalizedText &&
+                    variant.dataType !== DataType.LocalizedText &&
+                    variant.dataType !== DataType.Null) {
                     throw new Error("Variant must provide a valid LocalizedText : variant = " +
                         variant.toString() +
                         " this.dataType= " +
@@ -539,15 +534,15 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 }
             }
             const basicType = this.getBasicDataType();
-            if (basicType === node_opcua_variant_1.DataType.String && variant.dataType === node_opcua_variant_1.DataType.ByteString) {
+            if (basicType === DataType.String && variant.dataType === DataType.ByteString) {
                 return; // this is allowed
             }
-            if (basicType === node_opcua_variant_1.DataType.ByteString && variant.dataType === node_opcua_variant_1.DataType.String) {
+            if (basicType === DataType.ByteString && variant.dataType === DataType.String) {
                 return; // this is allowed
             }
-            if (basicType !== node_opcua_variant_1.DataType.Null &&
-                basicType !== node_opcua_variant_1.DataType.Variant &&
-                variant.dataType !== node_opcua_variant_1.DataType.Null &&
+            if (basicType !== DataType.Null &&
+                basicType !== DataType.Variant &&
+                variant.dataType !== DataType.Null &&
                 variant.dataType !== basicType) {
                 const message = "UAVariable.setValueFromSource " +
                     this.browseName.toString() +
@@ -558,10 +553,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                     ":\n" +
                     "the provided variant must have the expected dataType!\n" +
                     "   - the expected dataType is " +
-                    chalk_1.default.cyan(node_opcua_variant_1.DataType[basicType]) +
+                    chalk.cyan(DataType[basicType]) +
                     "\n" +
                     "   - the actual dataType   is " +
-                    chalk_1.default.magenta(node_opcua_variant_1.DataType[variant.dataType]) +
+                    chalk.magenta(DataType[variant.dataType]) +
                     "\n" +
                     "   - " +
                     variant.toString();
@@ -588,18 +583,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     */
     setValueFromSource(variant, statusCode, sourceTimestamp) {
         try {
-            statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
-            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            statusCode = statusCode || StatusCodes.Good;
+            const variant1 = Variant.coerce(variant);
             this.verifyVariantCompatibility(variant1);
-            const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
-            const dataValue = new node_opcua_data_value_1.DataValue(null);
+            const now = coerceClock(sourceTimestamp, 0);
+            const dataValue = new DataValue(null);
             dataValue.serverPicoseconds = now.picoseconds;
             dataValue.serverTimestamp = now.timestamp;
             dataValue.sourcePicoseconds = now.picoseconds;
             dataValue.sourceTimestamp = now.timestamp;
             dataValue.statusCode = statusCode;
             dataValue.value = variant1;
-            if (dataValue.value.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+            if (dataValue.value.dataType === DataType.ExtensionObject) {
                 // early, detailed diagnostics on a malformed extension object (the actual throw
                 // happens below in _internal_set_dataValue).
                 const valueIsCorrect = this.checkExtensionObjectIsCorrect(dataValue.value.value);
@@ -636,7 +631,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      *
      * @internal
      */
-    _setInitialDataValue(variant, statusCode = node_opcua_status_code_1.StatusCodes.Good) {
+    _setInitialDataValue(variant, statusCode = StatusCodes.Good) {
         // the loader creates every variable with an empty value object, which the constructor
         // binds, so a bound setter is the norm here and not a reason to take the long path:
         // setValueFromSource never consults it either. A bound extension object is.
@@ -645,13 +640,14 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             return;
         }
         try {
-            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            const variant1 = Variant.coerce(variant);
             this.verifyVariantCompatibility(variant1);
-            if (variant1.dataType === node_opcua_variant_1.DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
+            if (variant1.dataType === DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
                 throw new Error("invalid extension object");
             }
-            const now = (0, node_opcua_date_time_1.getCurrentClock)();
-            this.$dataValue = new node_opcua_data_value_1.DataValue({
+            // the load's reading while this address space is being loaded, a fresh one otherwise
+            const now = loadClock(this.addressSpace);
+            this.$dataValue = new DataValue({
                 value: variant1,
                 statusCode,
                 sourceTimestamp: now.timestamp,
@@ -665,12 +661,12 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     adjustDataValueStatusCode(dataValue) {
-        const statusCode = (0, adjust_datavalue_status_code_js_1.adjustDataValueStatusCode)(this, dataValue, this.acceptValueOutOfRange || false);
+        const statusCode = adjustDataValueStatusCode(this, dataValue, this.acceptValueOutOfRange || false);
         return statusCode;
     }
     writeValue(context, dataValue, ...args) {
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
         if (!dataValue.sourceTimestamp) {
             // source timestamp was not specified by the caller
             // we will set the timestamp ourself with the current clock
@@ -679,7 +675,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 dataValue.sourcePicoseconds = context.currentTime.picoseconds;
             }
             else {
-                const { timestamp, picoseconds } = (0, node_opcua_date_time_1.getCurrentClock)();
+                const { timestamp, picoseconds } = getCurrentClock();
                 dataValue.sourceTimestamp = timestamp;
                 dataValue.sourcePicoseconds = picoseconds;
             }
@@ -692,7 +688,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         let indexRange = null;
         let callback;
         if (args.length === 1) {
-            indexRange = new node_opcua_numeric_range_1.NumericRange();
+            indexRange = new NumericRange();
             callback = args[0];
         }
         else if (args.length === 2) {
@@ -702,30 +698,30 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         else {
             throw new Error("Invalid Number of args");
         }
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
-        (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
+        assert(typeof callback === "function");
+        assert(dataValue instanceof DataValue);
         // index range could be string
-        indexRange = node_opcua_numeric_range_1.NumericRange.coerce(indexRange);
+        indexRange = NumericRange.coerce(indexRange);
         // test write permission
         if (!this.isWritable(context)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+            callback?.(null, StatusCodes.BadNotWritable);
             return;
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Write)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+        if (!this.checkPermissionPrivate(context, PermissionType.Write)) {
+            callback?.(null, StatusCodes.BadUserAccessDenied);
             return;
         }
         // isWritable() and the role permission above already passed, so a false result
         // here can only come from the UserAccessLevel attribute withholding CurrentWrite
         // for this user (Part 3 5.6.3): that is an access decision, not an unsupported call.
         if (!this.isUserWritable(context)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+            callback?.(null, StatusCodes.BadUserAccessDenied);
             return;
         }
         // adjust special case
         const variant = adjustVariant2.call(this, dataValue.value);
         const statusCode = this.checkVariantCompatibility(variant);
-        if (statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+        if (statusCode.isNot(StatusCodes.Good)) {
             callback?.(null, statusCode);
             return;
         }
@@ -739,29 +735,29 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         if (!write_func) {
             warningLog(` warning ${this.nodeId.toString()} ${this.browseName.toString()} has no setter. \n`);
             warningLog("Please make sure to bind the variable or to pass a valid value: new Variant({}) during construction time");
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+            callback?.(null, StatusCodes.BadNotWritable);
             return;
         }
-        (0, node_opcua_assert_1.assert)(write_func);
+        assert(write_func);
         write_func.call(this, dataValue, (err, statusCode1) => {
             if (!err) {
                 dataValue && this.verifyVariantCompatibility(dataValue.value);
                 if (indexRange && !indexRange.isEmpty()) {
                     if (!indexRange.isValid()) {
-                        callback?.(null, node_opcua_status_code_1.StatusCodes.BadIndexRangeInvalid);
+                        callback?.(null, StatusCodes.BadIndexRangeInvalid);
                         return;
                     }
                     const newArrayOrMatrix = dataValue.value.value;
-                    if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
-                            callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                    if (dataValue.value.arrayType === VariantArrayType.Array) {
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Array) {
+                            callback(null, StatusCodes.BadTypeMismatch);
                             return;
                         }
                         // check that destination data is also an array
-                        (0, node_opcua_assert_1.assert)(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
+                        assert(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
                         const destArr = this.$dataValue.value.value;
                         const result = indexRange.set_values(destArr, newArrayOrMatrix);
-                        if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
                             callback?.(null, result.statusCode);
                             return;
                         }
@@ -769,11 +765,11 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         // scrap original array so we detect range
                         this.$dataValue.value.value = null;
                     }
-                    else if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+                    else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
                         const dimensions = this.$dataValue.value.dimensions;
-                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
                             // not a matrix !
-                            callback?.(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                            callback?.(null, StatusCodes.BadTypeMismatch);
                             return;
                         }
                         const matrix = this.$dataValue.value.value;
@@ -781,7 +777,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                             matrix,
                             dimensions
                         }, newArrayOrMatrix);
-                        if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
                             callback?.(null, result.statusCode);
                             return;
                         }
@@ -791,7 +787,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         this.$dataValue.value.value = null;
                     }
                     else {
-                        callback?.(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                        callback?.(null, StatusCodes.BadTypeMismatch);
                         return;
                     }
                 }
@@ -799,10 +795,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                     this._internal_set_dataValue(dataValue, indexRange);
                 }
                 catch (err) {
-                    if (node_util_1.types.isNativeError(err)) {
+                    if (types.isNativeError(err)) {
                         warningLog(err.message);
                     }
-                    callback?.(null, node_opcua_status_code_1.StatusCodes.BadInternalError);
+                    callback?.(null, StatusCodes.BadInternalError);
                     return;
                 }
             }
@@ -816,48 +812,48 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             throw new Error("Internal error");
         }
         if (!this.canUserWriteAttribute(context, writeValueOptions.attributeId)) {
-            callback(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+            callback(null, StatusCodes.BadUserAccessDenied);
             return;
         }
-        const writeValue = writeValueOptions instanceof node_opcua_service_write_1.WriteValue ? writeValueOptions : new node_opcua_service_write_1.WriteValue(writeValueOptions);
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
-        (0, node_opcua_assert_1.assert)(writeValue instanceof node_opcua_service_write_1.WriteValue);
-        (0, node_opcua_assert_1.assert)(writeValue.value instanceof node_opcua_data_value_1.DataValue);
-        (0, node_opcua_assert_1.assert)(writeValue.value?.value instanceof node_opcua_variant_1.Variant);
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
+        const writeValue = writeValueOptions instanceof WriteValue ? writeValueOptions : new WriteValue(writeValueOptions);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
+        assert(writeValue instanceof WriteValue);
+        assert(writeValue.value instanceof DataValue);
+        assert(writeValue.value?.value instanceof Variant);
+        assert(typeof callback === "function");
         // Spec 1.0.2 Part 4 page 58
         // If the SourceTimestamp or the ServerTimestamp is specified, the Server shall
         // use these values.
         // xx _apply_default_timestamps(writeValue.value);
         switch (writeValue.attributeId) {
-            case node_opcua_data_model_1.AttributeIds.Value:
+            case AttributeIds.Value:
                 this.writeValue(context, writeValue.value, writeValue.indexRange, callback);
                 break;
-            case node_opcua_data_model_1.AttributeIds.Historizing:
-                if (writeValue.value?.value.dataType !== node_opcua_variant_1.DataType.Boolean) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+            case AttributeIds.Historizing:
+                if (writeValue.value?.value.dataType !== DataType.Boolean) {
+                    callback(null, StatusCodes.BadTypeMismatch);
                     break;
                 }
-                if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.WriteHistorizing)) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+                if (!this.checkPermissionPrivate(context, PermissionType.WriteHistorizing)) {
+                    callback(null, StatusCodes.BadUserAccessDenied);
                     break;
                 }
                 if (!this.canUserWriteHistorizingAttribute(context)) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported);
+                    callback(null, StatusCodes.BadHistoryOperationUnsupported);
                     break;
                 }
                 // Historizing is a real, writable attribute of a Variable (Part 3 5.6.2); a node
                 // without an HA Configuration simply cannot honour it right now, which is
                 // BadNotWritable, not BadNotSupported (that would mean the attribute never applies).
                 if (!this.getChildByName("HA Configuration")) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+                    callback(null, StatusCodes.BadNotWritable);
                     break;
                 }
                 // check if user is allowed to do that !
                 // TODO
                 this.historizing = !!writeValue.value?.value.value; // yes ! indeed !
-                callback(null, node_opcua_status_code_1.StatusCodes.Good);
+                callback(null, StatusCodes.Good);
                 break;
             default:
                 super.writeAttribute(context, writeValue, callback);
@@ -874,23 +870,23 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     checkVariantCompatibility(value) {
         // test dataType
         if (!this._validate_DataType(value.dataType)) {
-            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+            return StatusCodes.BadTypeMismatch;
         }
         try {
             this.verifyVariantCompatibility(value);
         }
         catch (_err) {
-            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+            return StatusCodes.BadTypeMismatch;
         }
-        return node_opcua_status_code_1.StatusCodes.Good;
+        return StatusCodes.Good;
     }
     /**
      * touch the source timestamp of a Variable and cascade up the change
      * to the parent variable if any.
      */
     touchValue(optionalNow) {
-        const now = optionalNow || (0, node_opcua_date_time_1.getCurrentClock)();
-        (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueUpward)(this, now);
+        const now = optionalNow || getCurrentClock();
+        propagateTouchValueUpward(this, now);
     }
     /**
      * bind a variable with a get and set functions.
@@ -1023,24 +1019,24 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             this._historyRead = UAVariableImpl.prototype._historyRead;
         }
         options = options || {};
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_set_func !== "function", "UAVariable already bound");
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_get_func !== "function", "UAVariable already bound");
+        assert(typeof this._timestamped_set_func !== "function", "UAVariable already bound");
+        assert(typeof this._timestamped_get_func !== "function", "UAVariable already bound");
         bind_getter.call(this, options);
         bind_setter.call(this, options);
         const _historyRead = options.historyRead;
         if (_historyRead) {
-            (0, node_opcua_assert_1.assert)(typeof this._historyRead !== "function" || this._historyRead === UAVariableImpl.prototype._historyRead);
-            (0, node_opcua_assert_1.assert)(typeof _historyRead === "function");
+            assert(typeof this._historyRead !== "function" || this._historyRead === UAVariableImpl.prototype._historyRead);
+            assert(typeof _historyRead === "function");
             this._historyRead = _historyRead;
-            (0, node_opcua_assert_1.assert)(this._historyRead.length === 6);
+            assert(this._historyRead.length === 6);
         }
         // post conditions
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_set_func === "function");
-        (0, node_opcua_assert_1.assert)(this._timestamped_set_func?.length === 2, "expecting 2 parameters");
+        assert(typeof this._timestamped_set_func === "function");
+        assert(this._timestamped_set_func?.length === 2, "expecting 2 parameters");
     }
     readValueAsync(context, callback) {
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
-        context = context || session_context_js_1.SessionContext.defaultContext;
+        assert(typeof callback === "function");
+        context = context || SessionContext.defaultContext;
         this.__waiting_callbacks = this.__waiting_callbacks || [];
         this.__waiting_callbacks.push(callback);
         const _readValueAsync_in_progress = this.__waiting_callbacks.length >= 2;
@@ -1048,18 +1044,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             return;
         }
         if (this.isDisposed()) {
-            callback?.(null, new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadNodeIdUnknown }));
+            callback?.(null, new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown }));
             return;
         }
         const readImmediate = (innerCallback) => {
-            (0, node_opcua_assert_1.assert)(this.$dataValue instanceof node_opcua_data_value_1.DataValue);
+            assert(this.$dataValue instanceof DataValue);
             const dataValue = this.readValue(context);
             innerCallback(null, dataValue);
         };
         let func;
         // stamped like the same gates of readValue(): the requested timestamps are expected
         // on a Bad result too (FEAT-34)
-        const answerStatusOnly = (statusCode) => (innerCallback) => innerCallback(null, (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode }));
+        const answerStatusOnly = (statusCode) => (innerCallback) => innerCallback(null, makeNowDataValue({ statusCode }));
         if (context.isAccessRestricted(this)) {
             // same gate as readValue(): a variable bound with a simple get()
             // also gets a refreshFunc, sending every read down the asyncRefresh
@@ -1067,19 +1063,19 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // through readValue(). Without this check here, a node hardened
             // with AccessRestrictions(EncryptionRequired) answered its value
             // over an unencrypted channel.
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadSecurityModeInsufficient);
+            func = answerStatusOnly(StatusCodes.BadSecurityModeInsufficient);
         }
         else if (!this.isReadable(context)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadNotReadable);
+            func = answerStatusOnly(StatusCodes.BadNotReadable);
         }
-        else if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+        else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            func = answerStatusOnly(StatusCodes.BadUserAccessDenied);
         }
         else if (!this.isUserReadable(context)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadNotReadable);
+            func = answerStatusOnly(StatusCodes.BadNotReadable);
         }
         else {
-            const clock = (0, node_opcua_date_time_1.getCurrentClock)();
+            const clock = getCurrentClock();
             func = typeof this.refreshFunc === "function" ? this.asyncRefresh.bind(this, clock) : readImmediate;
         }
         const satisfy_callbacks = (err, dataValue) => {
@@ -1097,8 +1093,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         catch (err) {
             // c8 ignore next
             if (doDebug) {
-                debugLog(chalk_1.default.red("func readValueAsync has failed "));
-                if (node_util_1.types.isNativeError(err)) {
+                debugLog(chalk.red("func readValueAsync has failed "));
+                if (types.isNativeError(err)) {
                     debugLog(" stack", err.stack);
                 }
             }
@@ -1125,14 +1121,14 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             userAccessLevel: this.userAccessLevel,
             valueRank: this.valueRank
         };
-        const newVariable = (0, base_node_private_js_1._clone)(this, (UAVariableImpl), options, optionalFilter || node_opcua_address_space_base_1.defaultCloneFilter, extraInfo || (0, node_opcua_address_space_base_1.makeDefaultCloneExtraInfo)(this));
+        const newVariable = _clone(this, UAVariableImpl, options, optionalFilter || defaultCloneFilter, extraInfo || makeDefaultCloneExtraInfo(this));
         newVariable.bindVariable();
-        (0, node_opcua_assert_1.assert)(typeof newVariable._timestamped_set_func === "function");
-        (0, node_opcua_assert_1.assert)(newVariable.dataType === this.dataType);
+        assert(typeof newVariable._timestamped_set_func === "function");
+        assert(newVariable.dataType === this.dataType);
         newVariable.$dataValue = this.$dataValue.clone();
         // also bind extension object
         const v = newVariable.$dataValue.value;
-        if (v.dataType === node_opcua_variant_1.DataType.ExtensionObject && v.value && v.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+        if (v.dataType === DataType.ExtensionObject && v.value && v.arrayType === VariantArrayType.Scalar) {
             try {
                 newVariable.bindExtensionObject(newVariable.$dataValue.value.value);
             }
@@ -1152,7 +1148,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     getDataTypeNode() {
         const addressSpace = this.addressSpace;
         if (this.dataType.isEmpty()) {
-            this.dataType = this.resolveNodeId(node_opcua_variant_1.DataType.Variant);
+            this.dataType = this.resolveNodeId(DataType.Variant);
         }
         const dt = addressSpace.findNode(this.dataType);
         // c8 ignore next
@@ -1178,7 +1174,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // has not yet been loaded !
             return true;
         }
-        if (dataType.nodeId.namespace === 0 && dataType.nodeId.value === node_opcua_variant_1.DataType.ExtensionObject) {
+        if (dataType.nodeId.namespace === 0 && dataType.nodeId.value === DataType.ExtensionObject) {
             return true;
         }
         const Constructor = addressSpace.getExtensionObjectConstructor(this.dataType);
@@ -1221,7 +1217,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             if (extObj.constructor.name === Constructor.name) {
                 return true;
             }
-            if (extObj instanceof node_opcua_extension_object_1.OpaqueStructure) {
+            if (extObj instanceof OpaqueStructure) {
                 throw new Error("An opaque structure is not expected here");
             }
             // let's verify that the constructor is a sub-class of Constructor
@@ -1271,67 +1267,67 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      * precondition:
      */
     installExtensionObjectVariables() {
-        (0, ua_variable_impl_ext_obj_js_1._installExtensionObjectBindingOnProperties)(this, { createMissingProp: true });
+        _installExtensionObjectBindingOnProperties(this, { createMissingProp: true });
     }
     /**
      * @return {ExtensionObject}
      */
     bindExtensionObjectScalar(optionalExtensionObject, options) {
-        (0, node_opcua_assert_1.assert)(this.valueRank === -1, "expecting an Scalar variable here");
-        return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, optionalExtensionObject, options);
+        assert(this.valueRank === -1, "expecting an Scalar variable here");
+        return _bindExtensionObject(this, optionalExtensionObject, options);
     }
     bindExtensionObjectArray(optionalExtensionObject, options) {
-        (0, node_opcua_assert_1.assert)(this.valueRank >= 1, "expecting an Array or a Matrix variable here");
-        return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, optionalExtensionObject, options);
+        assert(this.valueRank >= 1, "expecting an Array or a Matrix variable here");
+        return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
     }
     bindExtensionObject(optionalExtensionObject, options) {
         // coerce to ExtensionObject[] when this.valueRank === 1
         if (optionalExtensionObject &&
             this.valueRank === 1 &&
             !Array.isArray(optionalExtensionObject) &&
-            optionalExtensionObject instanceof node_opcua_extension_object_1.ExtensionObject) {
+            optionalExtensionObject instanceof ExtensionObject) {
             warningLog("bindExtensionObject: coerce to ExtensionObject[] when valueRank === 1 and value is a scalar extension object");
             optionalExtensionObject = [optionalExtensionObject];
         }
         if (optionalExtensionObject) {
             if (Array.isArray(optionalExtensionObject)) {
-                (0, node_opcua_assert_1.assert)(this.valueRank >= 1, "bindExtensionObject: expecting an Array of Matrix variable here");
-                return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, optionalExtensionObject, options);
+                assert(this.valueRank >= 1, "bindExtensionObject: expecting an Array of Matrix variable here");
+                return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
             }
             else {
                 if (this.valueRank !== -1 && this.valueRank !== 0) {
                     throw new Error(`bindExtensionObject: expecting an Scalar variable here but got value rank ${this.valueRank}`);
                 }
-                return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, optionalExtensionObject, options);
+                return _bindExtensionObject(this, optionalExtensionObject, options);
             }
         }
-        (0, node_opcua_assert_1.assert)(optionalExtensionObject === undefined || optionalExtensionObject === null);
+        assert(optionalExtensionObject === undefined || optionalExtensionObject === null);
         if (this.valueRank === -1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, undefined, options);
+            return _bindExtensionObject(this, undefined, options);
         }
         else if (this.valueRank === 1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, undefined, options);
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
         }
         else if (this.valueRank > 1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, undefined, options);
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
         }
         //  unsupported case ...
         return null;
     }
     updateExtensionObjectPartial(partialExtensionObject) {
-        (0, ua_variable_impl_ext_obj_js_1.setExtensionObjectPartialValue)(this, partialExtensionObject);
+        setExtensionObjectPartialValue(this, partialExtensionObject);
         return this.$extensionObject;
     }
     incrementExtensionObjectPartial(path) {
         const extensionObject = this.readValue().value.value;
-        const partialData = (0, ua_variable_impl_ext_obj_js_1.extractPartialData)(path, extensionObject);
-        (0, ua_variable_impl_ext_obj_js_1.incrementElement)(path, partialData);
-        (0, ua_variable_impl_ext_obj_js_1.setExtensionObjectPartialValue)(this, partialData);
+        const partialData = extractPartialData(path, extensionObject);
+        incrementElement(path, partialData);
+        setExtensionObjectPartialValue(this, partialData);
     }
     toString() {
-        const options = new base_node_private_js_1.ToStringBuilder();
-        base_node_private_js_1.UAVariable_toString.call(this, options);
+        const options = new ToStringBuilder();
+        UAVariable_toString.call(this, options);
         return options.toString();
     }
     toJSON() {
@@ -1341,7 +1337,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             const dv = this.$dataValue;
             if (dv) {
                 statusCode = dv.statusCode?.toString();
-                if (dv.value && !(dv.value.value instanceof node_opcua_extension_object_1.OpaqueStructure)) {
+                if (dv.value && !(dv.value.value instanceof OpaqueStructure)) {
                     value = dv.value.value;
                 }
             }
@@ -1355,13 +1351,13 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             dataType: this.dataType?.toString(),
             valueRank: this.valueRank,
             arrayDimensions: this.arrayDimensions,
-            accessLevel: node_opcua_data_model_1.AccessLevelFlag[this.accessLevel],
+            accessLevel: AccessLevelFlag[this.accessLevel],
             statusCode,
             value
         };
     }
     [Symbol.for("nodejs.util.inspect.custom")](depth, inspectOptions) {
-        const c = inspectOptions?.colors === false ? plainChalk : chalk_1.default;
+        const c = inspectOptions?.colors === false ? plainChalk : chalk;
         const typeName = this.typeDefinitionObj?.browseName.toString() ?? "?";
         const displayName = this.displayName.length ? this.displayName.map((d) => d.text).join(" | ") : "";
         if (depth !== null && depth <= 0) {
@@ -1378,7 +1374,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 if (dv.value &&
                     dv.value.value !== undefined &&
                     dv.value.value !== null &&
-                    !(dv.value.value instanceof node_opcua_extension_object_1.OpaqueStructure)) {
+                    !(dv.value.value instanceof OpaqueStructure)) {
                     const v = dv.value.value;
                     valueStr = typeof v === "object" ? Object.prototype.toString.call(v) : String(v);
                     if (valueStr.length > 80)
@@ -1394,8 +1390,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             c.yellow("  typeDefinition : ") + typeName,
             c.yellow("  displayName    : ") + displayName,
             c.yellow("  dataType       : ") + dt,
-            c.yellow("  valueRank      : ") + (0, base_node_private_js_1.valueRankToString)(this.valueRank),
-            c.yellow("  accessLevel    : ") + node_opcua_data_model_1.AccessLevelFlag[this.accessLevel]
+            c.yellow("  valueRank      : ") + valueRankToString(this.valueRank),
+            c.yellow("  accessLevel    : ") + AccessLevelFlag[this.accessLevel]
         ];
         if (this.arrayDimensions?.length) {
             lines.push(c.yellow("  arrayDimensions: ") + JSON.stringify(this.arrayDimensions));
@@ -1412,10 +1408,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         return lines.join("\n");
     }
     historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
+        assert(context instanceof SessionContext);
+        assert(typeof callback === "function");
         if (typeof this._historyRead !== "function") {
-            callback?.(null, new node_opcua_types_1.HistoryReadResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable }));
+            callback?.(null, new HistoryReadResult({ statusCode: StatusCodes.BadNotReadable }));
             return;
         }
         this._historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback);
@@ -1428,20 +1424,20 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         throw new Error("");
     }
     _historyRead(context, _historyReadDetails, _indexRange, _dataEncoding, _continuationData, callback) {
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.ReadHistory)) {
-            const result = new node_opcua_types_1.HistoryReadResult({
-                statusCode: node_opcua_status_code_1.StatusCodes.BadUserAccessDenied
+        if (!this.checkPermissionPrivate(context, PermissionType.ReadHistory)) {
+            const result = new HistoryReadResult({
+                statusCode: StatusCodes.BadUserAccessDenied
             });
             callback(null, result);
         }
         if (!this.canUserReadHistory(context)) {
-            const result = new node_opcua_types_1.HistoryReadResult({
-                statusCode: node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported
+            const result = new HistoryReadResult({
+                statusCode: StatusCodes.BadHistoryOperationUnsupported
             });
             callback(null, result);
         }
-        const result = new node_opcua_types_1.HistoryReadResult({
-            statusCode: node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported
+        const result = new HistoryReadResult({
+            statusCode: StatusCodes.BadHistoryOperationUnsupported
         });
         callback(null, result);
     }
@@ -1462,26 +1458,26 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         throw new Error("");
     }
     _validate_DataType(variantDataType) {
-        return (0, validate_data_type_correctness_js_1.validateDataTypeCorrectness)(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
+        return validateDataTypeCorrectness(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
     }
     _internal_set_value(value) {
-        if (value.dataType !== node_opcua_variant_1.DataType.Null) {
+        if (value.dataType !== DataType.Null) {
             this.verifyVariantCompatibility(value);
         }
         this.$dataValue.value = value;
     }
     _internal_set_dataValue(dataValue, indexRange) {
-        (0, node_opcua_assert_1.assert)(dataValue, "expecting a dataValue");
-        (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue, "expecting dataValue to be a DataValue");
-        (0, node_opcua_assert_1.assert)(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
+        assert(dataValue, "expecting a dataValue");
+        assert(dataValue instanceof DataValue, "expecting dataValue to be a DataValue");
+        assert(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
         const addressSpace = this.addressSpace;
-        // c8 ignore next
+        /* c8 ignore next */
         if (!addressSpace) {
             warningLog("UAVariable#_internal_set_dataValue : no addressSpace ! may be node has already been deleted ?");
             return;
         }
-        // c8 ignore next
-        if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+        /* c8 ignore next */
+        if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
             }
@@ -1491,7 +1487,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             }
         }
         // c8 ignore next
-        if (dataValue.value.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+        if (dataValue.value.dataType === DataType.ExtensionObject) {
             // c8 ignore next
             if (!this.checkExtensionObjectIsCorrect(dataValue.value.value)) {
                 warningLog(dataValue.toString());
@@ -1505,34 +1501,34 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      * @private
      */
     _inner_replace_dataValue(dataValue, indexRange) {
-        (0, node_opcua_assert_1.assert)(this.$dataValue.value instanceof node_opcua_variant_1.Variant);
+        assert(this.$dataValue.value instanceof Variant);
         const old_dataValue = this.$dataValue.clone();
-        if (this.$$extensionObjectArray && dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Scalar) {
+        if (this.$$extensionObjectArray && dataValue.value.arrayType !== VariantArrayType.Scalar) {
             // we have a bounded array or matrix
-            (0, node_opcua_assert_1.assert)(Array.isArray(dataValue.value.value));
+            assert(Array.isArray(dataValue.value.value));
             if (this.$$extensionObjectArray !== this.$dataValue.value.value) {
                 throw new Error("internal error");
             }
             this.$$extensionObjectArray = dataValue.value.value;
             this.$dataValue.value.value = dataValue.value.value;
-            this.$dataValue.statusCode = dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            this.$dataValue.statusCode = dataValue.statusCode || StatusCodes.Good;
             this.$dataValue.serverTimestamp = dataValue.serverTimestamp;
             this.$dataValue.serverPicoseconds = dataValue.serverPicoseconds;
             this.$dataValue.sourceTimestamp = dataValue.sourceTimestamp;
             this.$dataValue.sourcePicoseconds = dataValue.sourcePicoseconds;
         }
-        else if (this._basicDataType === node_opcua_variant_1.DataType.ExtensionObject &&
+        else if (this._basicDataType === DataType.ExtensionObject &&
             this.valueRank === -1 &&
             this.$set_ExtensionObject &&
-            dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+            dataValue.value.arrayType === VariantArrayType.Scalar) {
             // the entire extension object is changed.
-            this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
-            const preciseClock = (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
+            const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
             this.$set_ExtensionObject(dataValue.value.value, preciseClock, new Set());
         }
         else {
             this.$dataValue = dataValue;
-            this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
         }
         // repair missing timestamps
         const now = new Date();
@@ -1544,7 +1540,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp || now;
             this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds || 0;
         }
-        if (!(0, node_opcua_data_value_1.sameDataValue)(old_dataValue, dataValue)) {
+        if (!sameDataValue(old_dataValue, dataValue)) {
             // a Property that carries the semantics of a DataItem (EURange, TrueState, ...) has to make
             // the DataItem's next notification carry the SemanticsChanged bit. Done from the Property
             // rather than with a listener installed when the DataItem is built, because a hand-built
@@ -1552,18 +1548,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // ... but a Property receiving its first value is a Variable being built, not a
             // semantics change: until then its StatusCode is UncertainInitialValue.
             if (old_dataValue.statusCode.isGood()) {
-                (0, semantics_changed_js_1.notifySemanticsChangedIfNeeded)(this);
+                notifySemanticsChangedIfNeeded(this);
             }
-            if (this.getBasicDataType() === node_opcua_variant_1.DataType.ExtensionObject) {
-                const preciseClock = (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+            if (this.getBasicDataType() === DataType.ExtensionObject) {
+                const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
                 const cache = new Set();
                 if (this.$$extensionObjectArray) {
                     this.touchValue(preciseClock);
-                    (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueDownwardArray)(this, preciseClock, cache);
+                    propagateTouchValueDownwardArray(this, preciseClock, cache);
                 }
                 else {
                     this.touchValue(preciseClock);
-                    (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueDownward)(this, preciseClock, cache);
+                    propagateTouchValueDownward(this, preciseClock, cache);
                 }
             }
             else {
@@ -1572,117 +1568,119 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     _conditionRefresh(_cache) {
-        apply_condition_refresh_js_1.apply_condition_refresh.call(this, _cache);
+        apply_condition_refresh.call(this, _cache);
     }
     handle_semantic_changed(_dataValue) {
         this.semantic_version = this.semantic_version + 1;
         this.emit("semantic_changed");
+        // the bit tells whoever monitors this DataItem; the event tells whoever monitors the
+        // Server object (OPC 10000-5 6.4.31). Both have to come from this one place.
+        raiseSemanticChangeEvent(this);
     }
     _readDataType() {
-        (0, node_opcua_assert_1.assert)(this.dataType instanceof node_opcua_nodeid_1.NodeId);
+        assert(this.dataType instanceof NodeId);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+            statusCode: StatusCodes.Good,
             value: {
-                dataType: node_opcua_variant_1.DataType.NodeId,
+                dataType: DataType.NodeId,
                 value: this.dataType
             }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readValueRank() {
-        (0, node_opcua_assert_1.assert)(typeof this.valueRank === "number");
+        assert(typeof this.valueRank === "number");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Int32, value: this.valueRank }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Int32, value: this.valueRank }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readArrayDimensions() {
-        (0, node_opcua_assert_1.assert)(Array.isArray(this.arrayDimensions) || this.arrayDimensions === null);
-        (0, node_opcua_assert_1.assert)(!this.arrayDimensions || this.valueRank > 0, "arrayDimension must be null if valueRank <0");
+        assert(Array.isArray(this.arrayDimensions) || this.arrayDimensions === null);
+        assert(!this.arrayDimensions || this.valueRank > 0, "arrayDimension must be null if valueRank <0");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.UInt32, arrayType: node_opcua_variant_1.VariantArrayType.Array, value: this.arrayDimensions }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: this.arrayDimensions }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readAccessLevel(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Byte, value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(this.accessLevel) }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Byte, value: convertAccessLevelFlagToByte(this.accessLevel) }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readAccessLevelEx(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+            statusCode: StatusCodes.Good,
             // Extra flags are not supported yet. to do:
-            value: { dataType: node_opcua_variant_1.DataType.UInt32, value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(this.accessLevel) }
+            value: { dataType: DataType.UInt32, value: convertAccessLevelFlagToByte(this.accessLevel) }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readUserAccessLevel(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const effectiveUserAccessLevel = _calculateEffectiveUserAccessLevelFromPermission(this, context, this.userAccessLevel);
         const options = {
             value: {
-                dataType: node_opcua_variant_1.DataType.Byte,
-                statusCode: node_opcua_status_code_1.StatusCodes.Good,
-                value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(effectiveUserAccessLevel)
+                dataType: DataType.Byte,
+                statusCode: StatusCodes.Good,
+                value: convertAccessLevelFlagToByte(effectiveUserAccessLevel)
             }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readMinimumSamplingInterval() {
         // expect a Duration => Double
         const options = {};
         if (this.minimumSamplingInterval === undefined) {
-            options.statusCode = node_opcua_status_code_1.StatusCodes.BadAttributeIdInvalid;
+            options.statusCode = StatusCodes.BadAttributeIdInvalid;
         }
         else {
-            options.value = { dataType: node_opcua_variant_1.DataType.Double, value: this.minimumSamplingInterval };
-            options.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+            options.value = { dataType: DataType.Double, value: this.minimumSamplingInterval };
+            options.statusCode = StatusCodes.Good;
         }
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readHistorizing() {
-        (0, node_opcua_assert_1.assert)(typeof this.historizing === "boolean");
+        assert(typeof this.historizing === "boolean");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Boolean, value: !!this.historizing }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Boolean, value: !!this.historizing }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
 }
-exports.UAVariableImpl = UAVariableImpl;
-const thenify_ex_1 = require("thenify-ex");
-UAVariableImpl.prototype.asyncRefresh = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.asyncRefresh);
-UAVariableImpl.prototype.writeValue = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.writeValue);
-UAVariableImpl.prototype.writeAttribute = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.writeAttribute);
-UAVariableImpl.prototype.historyRead = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.historyRead);
-UAVariableImpl.prototype.readValueAsync = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.readValueAsync);
+import { withCallback } from "thenify-ex";
+UAVariableImpl.prototype.asyncRefresh = withCallback(UAVariableImpl.prototype.asyncRefresh);
+UAVariableImpl.prototype.writeValue = withCallback(UAVariableImpl.prototype.writeValue);
+UAVariableImpl.prototype.writeAttribute = withCallback(UAVariableImpl.prototype.writeAttribute);
+UAVariableImpl.prototype.historyRead = withCallback(UAVariableImpl.prototype.historyRead);
+UAVariableImpl.prototype.readValueAsync = withCallback(UAVariableImpl.prototype.readValueAsync);
 function check_valid_array(dataType, array) {
     if (Array.isArray(array)) {
         return true;
     }
     switch (dataType) {
-        case node_opcua_variant_1.DataType.Double:
+        case DataType.Double:
             return array instanceof Float64Array;
-        case node_opcua_variant_1.DataType.Float:
+        case DataType.Float:
             return array instanceof Float32Array;
-        case node_opcua_variant_1.DataType.Int32:
+        case DataType.Int32:
             return array instanceof Int32Array;
-        case node_opcua_variant_1.DataType.Int16:
+        case DataType.Int16:
             return array instanceof Int16Array;
-        case node_opcua_variant_1.DataType.SByte:
+        case DataType.SByte:
             return array instanceof Int8Array;
-        case node_opcua_variant_1.DataType.UInt32:
+        case DataType.UInt32:
             return array instanceof Uint32Array;
-        case node_opcua_variant_1.DataType.UInt16:
+        case DataType.UInt16:
             return array instanceof Uint16Array;
-        case node_opcua_variant_1.DataType.Byte:
+        case DataType.Byte:
             return array instanceof Uint8Array || array instanceof Buffer;
     }
     return false;
@@ -1719,13 +1717,13 @@ function _calculateEffectiveUserAccessLevelFromPermission(node, context, userAcc
     }
     userAccessLevel = node.userAccessLevel === undefined ? node.accessLevel : node.userAccessLevel & node.accessLevel;
     if (context.checkPermission) {
-        (0, node_opcua_assert_1.assert)(context.checkPermission instanceof Function);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Read, node_opcua_data_model_1.AccessLevelFlag.CurrentRead, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.CurrentWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.StatusWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.TimestampWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.ReadHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryRead, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.DeleteHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite, userAccessLevel);
+        assert(context.checkPermission instanceof Function);
+        userAccessLevel = __adjustFlag(PermissionType.Read, AccessLevelFlag.CurrentRead, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.CurrentWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.StatusWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.TimestampWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.ReadHistory, AccessLevelFlag.HistoryRead, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.DeleteHistory, AccessLevelFlag.HistoryWrite, userAccessLevel);
         return userAccessLevel;
     }
     else {
@@ -1736,16 +1734,16 @@ function adjustVariant2(variant) {
     // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
     const _addressSpace = this.addressSpace;
     const basicType = this.getBasicDataType();
-    variant = (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, basicType);
+    variant = adjustVariant(variant, this.valueRank, basicType);
     return variant;
 }
 function _not_writable_timestamped_set_func(dataValue, callback) {
-    (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
-    callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable, null);
+    assert(dataValue instanceof DataValue);
+    callback(null, StatusCodes.BadNotWritable, null);
 }
 function _default_writable_timestamped_set_func(dataValue, callback) {
-    (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
-    callback(null, node_opcua_status_code_1.StatusCodes.Good, dataValue);
+    assert(dataValue instanceof DataValue);
+    callback(null, StatusCodes.Good, dataValue);
 }
 function turn_sync_to_async(f, numberOfArgs) {
     if (f.length <= numberOfArgs) {
@@ -1775,24 +1773,24 @@ function turn_sync_to_async(f, numberOfArgs) {
         };
     }
     else {
-        (0, node_opcua_assert_1.assert)(f.length === numberOfArgs + 1);
+        assert(f.length === numberOfArgs + 1);
         return f;
     }
 }
 const _default_minimumSamplingInterval = 1000;
 function coerceDataValue(dataValue) {
-    if (dataValue instanceof node_opcua_data_value_1.DataValue) {
+    if (dataValue instanceof DataValue) {
         return dataValue;
     }
-    return new node_opcua_data_value_1.DataValue(dataValue);
+    return new DataValue(dataValue);
 }
 // variation #3 :
 function _Variable_bind_with_async_refresh(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.refreshFunc === "function");
-    (0, node_opcua_assert_1.assert)(!options.get, "a getter shall not be specified when refreshFunc is set");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_get, "a getter shall not be specified when refreshFunc is set");
-    (0, node_opcua_assert_1.assert)(!this.refreshFunc);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.refreshFunc === "function");
+    assert(!options.get, "a getter shall not be specified when refreshFunc is set");
+    assert(!options.timestamped_get, "a getter shall not be specified when refreshFunc is set");
+    assert(!this.refreshFunc);
     this.refreshFunc = options.refreshFunc;
     /*
     // TO DO : REVISIT THIS ASSUMPTION
@@ -1808,10 +1806,10 @@ function _Variable_bind_with_async_refresh(options) {
 // variation 2
 function _Variable_bind_with_timestamped_get(options) {
     /* jshint validthis: true */
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.timestamped_get === "function");
-    (0, node_opcua_assert_1.assert)(!options.get, "should not specify 'get' when 'timestamped_get' exists ");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_get_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.timestamped_get === "function");
+    assert(!options.get, "should not specify 'get' when 'timestamped_get' exists ");
+    assert(!this._timestamped_get_func);
     const async_refresh_func = (callback) => {
         Promise.resolve(this._timestamped_get_func.call(this))
             .then((dataValue) => callback(null, dataValue))
@@ -1828,8 +1826,8 @@ function _Variable_bind_with_timestamped_get(options) {
         const dataValue_verify = timestamped_get.call(pThis);
         // dataValue_verify should be a DataValue or a Promise
         /* c8 ignore next */
-        if (!(dataValue_verify instanceof node_opcua_data_value_1.DataValue) && typeof dataValue_verify.then !== "function") {
-            errorLog(chalk_1.default.red(" Bind variable error: "), " the timestamped_get function must return a DataValue or a Promise<DataValue>" +
+        if (!(dataValue_verify instanceof DataValue) && typeof dataValue_verify.then !== "function") {
+            errorLog(chalk.red(" Bind variable error: "), " the timestamped_get function must return a DataValue or a Promise<DataValue>" +
                 "\n value_check.constructor.name ", dataValue_verify ? dataValue_verify.constructor.name : "null");
             throw new Error(" Bind variable error: " + " the timestamped_get function must return a DataValue");
         }
@@ -1845,31 +1843,31 @@ function _Variable_bind_with_timestamped_get(options) {
 }
 // variation 1
 function _Variable_bind_with_simple_get(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.get === "function", "should specify get function");
-    (0, node_opcua_assert_1.assert)(options.get?.length === 0, "get function should not have arguments");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_get, "should not specify a timestamped_get function when get is specified");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_get_func);
-    (0, node_opcua_assert_1.assert)(!this._get_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.get === "function", "should specify get function");
+    assert(options.get?.length === 0, "get function should not have arguments");
+    assert(!options.timestamped_get, "should not specify a timestamped_get function when get is specified");
+    assert(!this._timestamped_get_func);
+    assert(!this._get_func);
     this._get_func = options.get;
     const timestamped_get_func_from__Variable_bind_with_simple_get = () => {
         const value = this._get_func();
         /* c8 ignore next */
         if (!is_Variant_or_StatusCode(value)) {
-            errorLog(chalk_1.default.red(" Bind variable error: "), " : the getter must return a Variant or a StatusCode" + "\nvalue_check.constructor.name ", value ? value.constructor.name : "null");
+            errorLog(chalk.red(" Bind variable error: "), " : the getter must return a Variant or a StatusCode" + "\nvalue_check.constructor.name ", value ? value.constructor.name : "null");
             throw new Error(" bindVariable : the value getter function returns a invalid result ( expecting a Variant or a StatusCode !!!");
         }
         if (is_StatusCode(value)) {
-            return new node_opcua_data_value_1.DataValue({ statusCode: value });
+            return new DataValue({ statusCode: value });
         }
         else {
-            if (!this.$dataValue?.statusCode.isGoodish() || !(0, node_opcua_variant_1.sameVariant)(this.$dataValue.value, value)) {
+            if (!this.$dataValue?.statusCode.isGoodish() || !sameVariant(this.$dataValue.value, value)) {
                 // rebuilding artificially timestamps with current clock as they are not provided
                 // by the underlying getter function
-                const { timestamp: sourceTimestamp, picoseconds: sourcePicoseconds } = (0, node_opcua_date_time_1.getCurrentClock)();
+                const { timestamp: sourceTimestamp, picoseconds: sourcePicoseconds } = getCurrentClock();
                 const serverTimestamp = sourceTimestamp;
                 const serverPicoseconds = sourcePicoseconds;
-                this._inner_replace_dataValue(new node_opcua_data_value_1.DataValue({ value, sourceTimestamp, sourcePicoseconds, serverTimestamp, serverPicoseconds }));
+                this._inner_replace_dataValue(new DataValue({ value, sourceTimestamp, sourcePicoseconds, serverTimestamp, serverPicoseconds }));
             }
             return this.$dataValue;
         }
@@ -1880,36 +1878,36 @@ function _Variable_bind_with_simple_get(options) {
     });
 }
 function _Variable_bind_with_simple_set(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.set === "function", "should specify set function");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_set, "should not specify a timestamped_set function");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_set_func);
-    (0, node_opcua_assert_1.assert)(!this._set_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.set === "function", "should specify set function");
+    assert(!options.timestamped_set, "should not specify a timestamped_set function");
+    assert(!this._timestamped_set_func);
+    assert(!this._set_func);
     //
     const set_func = turn_sync_to_async(options.set, 1);
     this._set_func = set_func;
-    (0, node_opcua_assert_1.assert)(set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
+    assert(set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
     this._timestamped_set_func = (timestamped_value, callback) => {
-        (0, node_opcua_assert_1.assert)(timestamped_value instanceof node_opcua_data_value_1.DataValue);
+        assert(timestamped_value instanceof DataValue);
         set_func.call(this, timestamped_value.value, (err, statusCode) => {
             // c8 ignore next
             if (!err && !statusCode) {
-                errorLog(chalk_1.default.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
-                errorLog(chalk_1.default.yellow("StatusCode.Good is assumed"));
-                return callback(err, node_opcua_status_code_1.StatusCodes.Good, timestamped_value);
+                errorLog(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
+                errorLog(chalk.yellow("StatusCode.Good is assumed"));
+                return callback(err, StatusCodes.Good, timestamped_value);
             }
             if (statusCode?.isNotGood()) {
                 // record the value but still record the statusCode !
                 timestamped_value.statusCode = statusCode;
             }
-            callback(err, statusCode ?? node_opcua_status_code_1.StatusCodes.BadInternalError, timestamped_value);
+            callback(err, statusCode ?? StatusCodes.BadInternalError, timestamped_value);
         });
     };
 }
 function _Variable_bind_with_timestamped_set(options) {
-    (0, node_opcua_assert_1.assert)(options.timestamped_set.length === 2 || options.timestamped_set.length === 1, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
-    (0, node_opcua_assert_1.assert)(!options.set, "should not specify set when timestamped_set_func exists ");
-    this._timestamped_set_func = (0, multiform_func_js_1.convertToCallbackFunction1)(options.timestamped_set);
+    assert(options.timestamped_set.length === 2 || options.timestamped_set.length === 1, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
+    assert(!options.set, "should not specify set when timestamped_set_func exists ");
+    this._timestamped_set_func = convertToCallbackFunction1(options.timestamped_set);
 }
 function bind_setter(options) {
     if (options.set && typeof options.set === "function") {
@@ -1923,7 +1921,7 @@ function bind_setter(options) {
     }
     else if (typeof options.timestamped_set === "function") {
         // variation 2
-        (0, node_opcua_assert_1.assert)(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
+        assert(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
         _Variable_bind_with_timestamped_set.call(this, {
             set: undefined,
             timestamped_set: options.timestamped_set
@@ -1964,7 +1962,7 @@ function bind_getter(options) {
         _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.refreshFunc });
     }
     else {
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "set"), "getter is missing : a getter must be provided if a setter is provided");
+        assert(!Object.hasOwn(options, "set"), "getter is missing : a getter must be provided if a setter is provided");
         // xx bind_variant.call(this,options);
         if (options.dataType !== undefined) {
             // if (options.dataType !== DataType.ExtensionObject) {
@@ -1973,7 +1971,7 @@ function bind_getter(options) {
         }
     }
 }
-class UAVariableImplT extends UAVariableImpl {
+export class UAVariableImplT extends UAVariableImpl {
     readValue(context, indexRange, dataEncoding) {
         return super.readValue(context, indexRange, dataEncoding);
     }
@@ -1997,18 +1995,17 @@ class UAVariableImplT extends UAVariableImpl {
         return super.writeValue(context, dataValue, indexRangeOrCallback, callback);
     }
 }
-exports.UAVariableImplT = UAVariableImplT;
 function changeUAVariableDataType(uaVariable, newDataType, valueLike) {
-    let value = valueLike ? (valueLike instanceof node_opcua_variant_1.Variant ? valueLike : new node_opcua_variant_1.Variant(valueLike)) : null;
+    let value = valueLike ? (valueLike instanceof Variant ? valueLike : new Variant(valueLike)) : null;
     const addressSpace = uaVariable.addressSpace;
     const newDataTypeNode = addressSpace.findNode(newDataType);
     // c8 ignore next
-    if (!newDataTypeNode || !(newDataTypeNode instanceof ua_data_type_impl_js_1.UADataTypeImpl)) {
+    if (!newDataTypeNode || !(newDataTypeNode instanceof UADataTypeImpl)) {
         throw new Error(`Cannot find newDataTypeNode ${newDataType.toString()}`);
     }
     const newBaseDataType = newDataTypeNode.basicDataType;
     // c8 ignore next
-    if (newBaseDataType === node_opcua_variant_1.DataType.Null) {
+    if (newBaseDataType === DataType.Null) {
         throw new Error("newDataTypeNode must be a DataType");
     }
     if (!value) {