node-opcua-address-space 2.183.0 → 2.184.0

package/dist/impl/address_space.js

@@ -1,44 +1,38 @@
-"use strict";
 /**
  * @module node-opcua-address-space
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddressSpaceImpl = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_constants_1 = require("node-opcua-constants");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const node_opcua_object_registry_1 = require("node-opcua-object-registry");
-const node_opcua_service_browse_1 = require("node-opcua-service-browse");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_utils_1 = require("node-opcua-utils");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const adjust_browse_direction_js_1 = require("../api/helpers/adjust_browse_direction.js");
-const index_js_1 = require("./alarms_and_conditions/index.js");
-const base_node_impl_js_1 = require("./base_node_impl.js");
-const event_data_js_1 = require("./event_data.js");
-const event_layout_js_1 = require("./event_layout.js");
-const address_space_historical_data_node_js_1 = require("./historical_access/address_space_historical_data_node.js");
-const historizer_factory_js_1 = require("./historizer_factory.js");
-const namespace_impl_js_1 = require("./namespace_impl.js");
-const reference_impl_js_1 = require("./reference_impl.js");
-const ua_data_type_impl_js_1 = require("./ua_data_type_impl.js");
-const ua_object_impl_js_1 = require("./ua_object_impl.js");
-const ua_object_type_impl_js_1 = require("./ua_object_type_impl.js");
-const ua_reference_type_impl_js_1 = require("./ua_reference_type_impl.js");
+import chalk from "chalk";
+import { assert } from "node-opcua-assert";
+import { DataTypeIds, VariableTypeIds } from "node-opcua-constants";
+import { BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { coerceExpandedNodeId, coerceNodeId, makeNodeId, NodeId, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { ObjectRegistry } from "node-opcua-object-registry";
+import { BrowseResult } from "node-opcua-service-browse";
+import { StatusCodes } from "node-opcua-status-code";
+import { BrowsePath, BrowsePathResult } from "node-opcua-types";
+import { isNullOrUndefined, randomBytes } from "node-opcua-utils";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { adjustBrowseDirection } from "../api/helpers/adjust_browse_direction.js";
+import { UAAcknowledgeableConditionImplBase, UAConditionImplBase } from "./alarms_and_conditions/index.js";
+import { BaseNodeImpl, defineSharedChildAccessors } from "./base_node_impl.js";
+import { EventData } from "./event_data.js";
+import { getEventLayout } from "./event_layout.js";
+import { AddressSpace_installHistoricalDataNode } from "./historical_access/address_space_historical_data_node.js";
+import { historizerFactoryHolder } from "./historizer_factory.js";
+import { isNonEmptyQualifiedName, NamespaceImpl } from "./namespace_impl.js";
+import { nodeIdKey, ReferenceImpl } from "./reference_impl.js";
+import { UADataTypeImpl } from "./ua_data_type_impl.js";
+import { UAObjectImpl } from "./ua_object_impl.js";
+import { UAObjectTypeImpl } from "./ua_object_type_impl.js";
+import { UAReferenceTypeImpl } from "./ua_reference_type_impl.js";
 const doDebug = false;
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("address_space");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)("address_space");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("address_space");
-const dequeue_1 = __importDefault(require("dequeue"));
+const errorLog = make_errorLog("address_space");
+const debugLog = make_debugLog("address_space");
+const warningLog = make_warningLog("address_space");
+import Dequeue from "dequeue";
 const regexNumberColumnString = /^([0-9]+):(.*)/;
-const enumerationTypeNodeId = (0, node_opcua_nodeid_1.coerceNodeId)(node_opcua_constants_1.DataTypeIds.Enumeration);
+const enumerationTypeNodeId = coerceNodeId(DataTypeIds.Enumeration);
 /**
  * Extracts the namespace and browse name as a string from the given input.
  *
@@ -48,10 +42,10 @@ const enumerationTypeNodeId = (0, node_opcua_nodeid_1.coerceNodeId)(node_opcua_c
  * @returns A tuple containing the NamespacePrivate and the browse name as a string.
  */
 function _extract_namespace_and_browse_name_as_string(addressSpace, browseNameOrNodeId, namespaceIndex) {
-    (0, node_opcua_assert_1.assert)(!namespaceIndex || namespaceIndex >= 0);
+    assert(!namespaceIndex || namespaceIndex >= 0);
     let result;
     if (namespaceIndex !== undefined && namespaceIndex > 0) {
-        (0, node_opcua_assert_1.assert)(typeof browseNameOrNodeId === "string", "expecting a string when namespaceIndex is specified");
+        assert(typeof browseNameOrNodeId === "string", "expecting a string when namespaceIndex is specified");
         result = [addressSpace.getNamespace(namespaceIndex), browseNameOrNodeId.toString()];
     }
     else if (typeof browseNameOrNodeId === "string") {
@@ -67,14 +61,14 @@ function _extract_namespace_and_browse_name_as_string(addressSpace, browseNameOr
         }
         result = [addressSpace.getNamespace(namespaceIndex || 0), browseNameOrNodeId];
     }
-    else if (browseNameOrNodeId instanceof node_opcua_data_model_1.QualifiedName) {
+    else if (browseNameOrNodeId instanceof QualifiedName) {
         namespaceIndex = browseNameOrNodeId.namespaceIndex;
         result = [addressSpace.getNamespace(namespaceIndex), browseNameOrNodeId.name || ""];
     }
     else if (typeof browseNameOrNodeId === "number") {
-        result = [addressSpace.getDefaultNamespace(), node_opcua_variant_1.DataType[browseNameOrNodeId]];
+        result = [addressSpace.getDefaultNamespace(), DataType[browseNameOrNodeId]];
     }
-    else if (browseNameOrNodeId instanceof node_opcua_nodeid_1.NodeId) {
+    else if (browseNameOrNodeId instanceof NodeId) {
         // we have a nodeId
         const nodeId = browseNameOrNodeId;
         namespaceIndex = nodeId.namespace;
@@ -105,7 +99,7 @@ function isNodeIdString(str) {
  *
  * @internal
  */
-class AddressSpaceImpl {
+export class AddressSpaceImpl {
     get rootFolder() {
         const rootFolder = this.findNode(this.resolveNodeId("RootFolder"));
         if (!rootFolder) {
@@ -114,36 +108,49 @@ class AddressSpaceImpl {
         }
         return rootFolder;
     }
-    static isNonEmptyQualifiedName = namespace_impl_js_1.isNonEmptyQualifiedName;
+    static isNonEmptyQualifiedName = isNonEmptyQualifiedName;
     /**
      * Reads and writes reach the module that the historical-access code also reads, so
      * assigning here actually takes effect. It used to be a plain static, while the code that
      * consumed it read the static of a different AddressSpace class altogether.
      */
     static get historizerFactory() {
-        return historizer_factory_js_1.historizerFactoryHolder.factory;
+        return historizerFactoryHolder.factory;
     }
     static set historizerFactory(factory) {
-        historizer_factory_js_1.historizerFactoryHolder.factory = factory;
+        historizerFactoryHolder.factory = factory;
     }
     static create() {
         return new AddressSpaceImpl();
     }
-    static registry = new node_opcua_object_registry_1.ObjectRegistry();
+    static registry = new ObjectRegistry();
     /***
      * @internal
      * @private
      */
     suspendBackReference = false;
     isFrugal = false;
+    /**
+     * Stop collecting GeneralModelChangeEventType material.
+     *
+     * Every node added, deleted or re-referenced pays a probe - an inverse reference scan and a
+     * `getNodeVersion` per hierarchical parent - before the bookkeeping can conclude that no node
+     * involved carries a NodeVersion and there is nothing to report. A loader, a compiler or a
+     * test fixture has no subscriber for those events, so the probe is pure cost.
+     *
+     * Defaults to `false`, which is the behaviour every existing caller has. While it is `true`
+     * no ModelChangeStructure is collected and no NodeVersion is bumped, so set it only when
+     * nothing is listening - typically around a bulk load or a bulk delete.
+     */
+    suspendModelChangeEvents = false;
     registerChildAccessorNames(browseNames) {
-        (0, base_node_impl_js_1.defineSharedChildAccessors)(browseNames);
+        defineSharedChildAccessors(browseNames);
     }
     // reference keys pack a reference type as a small ordinal (see reference_impl.ts); one is
     // handed out per distinct reference type NodeId, whether or not the type exists yet
     _referenceTypeOrdinals = new Map();
     referenceTypeOrdinal(referenceType) {
-        const key = (0, reference_impl_js_1.nodeIdKey)(referenceType);
+        const key = nodeIdKey(referenceType);
         let ordinal = this._referenceTypeOrdinals.get(key);
         if (ordinal === undefined) {
             ordinal = this._referenceTypeOrdinals.size;
@@ -156,6 +163,8 @@ class AddressSpaceImpl {
     isNodeIdString = isNodeIdString;
     _private_namespaceIndex;
     _namespaceArray;
+    /** uri -> index into `_namespaceArray`; registering and resolving a uri were linear scans */
+    _namespaceIndexByUri = new Map();
     _shutdownTask;
     _eventIdCounter;
     $$extraDataTypeManager;
@@ -190,7 +199,7 @@ class AddressSpaceImpl {
         return this.$$extraDataTypeManager;
     }
     getNamespaceUri(namespaceIndex) {
-        (0, node_opcua_assert_1.assert)(namespaceIndex >= 0 && namespaceIndex < this._namespaceArray.length);
+        assert(namespaceIndex >= 0 && namespaceIndex < this._namespaceArray.length);
         return this._namespaceArray[namespaceIndex].namespaceUri;
     }
     /***
@@ -198,12 +207,12 @@ class AddressSpaceImpl {
     getNamespace(namespaceIndexOrName) {
         if (typeof namespaceIndexOrName === "number") {
             const namespaceIndex = namespaceIndexOrName;
-            (0, node_opcua_assert_1.assert)(namespaceIndex >= 0 && namespaceIndex < this._namespaceArray.length, "invalid namespace index ( out of bound)");
+            assert(namespaceIndex >= 0 && namespaceIndex < this._namespaceArray.length, "invalid namespace index ( out of bound)");
             return this._namespaceArray[namespaceIndex];
         }
         else {
             const namespaceUri = namespaceIndexOrName;
-            (0, node_opcua_assert_1.assert)(typeof namespaceUri === "string");
+            assert(typeof namespaceUri === "string");
             const index = this.getNamespaceIndex(namespaceUri);
             return this._namespaceArray[index];
         }
@@ -232,8 +241,9 @@ class AddressSpaceImpl {
      *
      */
     getNamespaceIndex(namespaceUri) {
-        (0, node_opcua_assert_1.assert)(typeof namespaceUri === "string");
-        return this._namespaceArray.findIndex((ns) => ns.namespaceUri === namespaceUri);
+        assert(typeof namespaceUri === "string");
+        const index = this._namespaceIndexByUri.get(namespaceUri);
+        return index === undefined ? -1 : index;
     }
     /**
      *
@@ -245,21 +255,69 @@ class AddressSpaceImpl {
      * @returns {Namespace}
      */
     registerNamespace(namespaceUri) {
-        let index = this._namespaceArray.findIndex((ns) => ns.namespaceUri === namespaceUri);
-        if (index !== -1) {
-            (0, node_opcua_assert_1.assert)(this._namespaceArray[index].addressSpace === this);
-            return this._namespaceArray[index];
+        const existing = this._namespaceIndexByUri.get(namespaceUri);
+        if (existing !== undefined) {
+            assert(this._namespaceArray[existing].addressSpace === this);
+            return this._namespaceArray[existing];
         }
-        index = this._namespaceArray.length;
-        this._namespaceArray.push(new namespace_impl_js_1.NamespaceImpl({
+        const index = this._namespaceArray.length;
+        this._namespaceArray.push(new NamespaceImpl({
             addressSpace: this,
             index,
             namespaceUri,
             publicationDate: new Date(),
             version: "undefined"
         }));
+        this._namespaceIndexByUri.set(namespaceUri, index);
         return this._namespaceArray[index];
     }
+    /**
+     * Empty a namespace, leaving the rest of the address space as it was before that namespace
+     * was ever populated, and the namespace itself registered under the same index and uri and
+     * ready to be populated again.
+     *
+     * This is the recycle that lets a compiler keep its loaded base nodesets across an edit:
+     * rebuilding the model's own namespace costs a fraction of rebuilding the whole address
+     * space. Everything goes in one model-change transaction, and only the references that cross
+     * the namespace boundary are severed - the ones inside it die with their nodes.
+     *
+     * It lives here rather than on Namespace because most of what it touches is not the
+     * namespace's: references held by nodes of other namespaces, the DataType factory this
+     * namespace registered with the address space's DataType manager, the address space's set of
+     * historizing nodes.
+     *
+     * Namespace 0 cannot be deleted: it is the standard namespace every other node resolves
+     * against.
+     *
+     * A structure DataType of the namespace also registered an ExtensionObject constructor with
+     * the address space's DataType manager; the factory holding those is dropped here, so that
+     * a later `ensureDatatypeExtracted` builds a fresh one for the repopulated namespace rather
+     * than colliding with the leftovers of the previous one.
+     */
+    deleteNamespace(namespaceIndexOrUri) {
+        const namespace = this.getNamespace(namespaceIndexOrUri);
+        /* c8 ignore next */
+        if (!namespace) {
+            throw new Error(`deleteNamespace: no namespace ${namespaceIndexOrUri.toString()} in this address space`);
+        }
+        const index = namespace.index;
+        if (index === 0) {
+            throw new Error("deleteNamespace: the standard namespace (index 0) cannot be deleted");
+        }
+        this.modelChangeTransaction(() => {
+            namespace._deleteAllNodes();
+        });
+        // a historized variable of the namespace is gone; the address space must stop listing it
+        if (this.historizingNodes.size) {
+            for (const node of [...this.historizingNodes]) {
+                if (node.nodeId.namespace === index) {
+                    this.historizingNodes.delete(node);
+                }
+            }
+        }
+        // the structures and enumerations this namespace registered go with their factory
+        this.$$extraDataTypeManager?.unregisterDataTypeFactory(index);
+    }
     /***
      * @return {Namespace[]} the namespace array
      */
@@ -273,8 +331,8 @@ class AddressSpaceImpl {
      * @internal
      */
     addAlias(alias, nodeId) {
-        (0, node_opcua_assert_1.assert)(typeof alias === "string");
-        (0, node_opcua_assert_1.assert)(nodeId instanceof node_opcua_nodeid_1.NodeId);
+        assert(typeof alias === "string");
+        assert(nodeId instanceof NodeId);
         this.getNamespace(nodeId.namespace).addAlias(alias, nodeId);
     }
     /**
@@ -283,7 +341,7 @@ class AddressSpaceImpl {
      * @return {BaseNode|null}
      */
     findNode(nodeId) {
-        if (!(nodeId instanceof node_opcua_nodeid_1.NodeId)) {
+        if (!(nodeId instanceof NodeId)) {
             nodeId = this.resolveNodeId(nodeId);
         }
         if (nodeId.namespace < 0 || nodeId.namespace >= this._namespaceArray.length) {
@@ -295,7 +353,7 @@ class AddressSpaceImpl {
     }
     findMethod(nodeId) {
         const node = this.findNode(nodeId);
-        if (!node || node.nodeClass !== node_opcua_data_model_1.NodeClass.Method) {
+        if (!node || node.nodeClass !== NodeClass.Method) {
             return null;
         }
         return node;
@@ -318,7 +376,7 @@ class AddressSpaceImpl {
             }
         }
         const namespaceArray = this.getNamespaceArray().map((a) => a.namespaceUri);
-        return (0, node_opcua_nodeid_1.resolveNodeId)(nodeId, { namespaceArray });
+        return resolveNodeId(nodeId, { namespaceArray });
     }
     /**
      *
@@ -348,7 +406,7 @@ class AddressSpaceImpl {
      * ```
      */
     findObjectType(objectType, namespaceIndex) {
-        if (objectType instanceof node_opcua_nodeid_1.NodeId) {
+        if (objectType instanceof NodeId) {
             return _find_by_node_id(this, objectType, namespaceIndex);
         }
         const [namespace, browseName] = _extract_namespace_and_browse_name_as_string(this, objectType, namespaceIndex);
@@ -373,7 +431,7 @@ class AddressSpaceImpl {
      * ```
      */
     findVariableType(variableType, namespaceIndex) {
-        if (variableType instanceof node_opcua_nodeid_1.NodeId) {
+        if (variableType instanceof NodeId) {
             return _find_by_node_id(this, variableType, namespaceIndex);
         }
         const [namespace, browseName] = _extract_namespace_and_browse_name_as_string(this, variableType, namespaceIndex);
@@ -404,18 +462,18 @@ class AddressSpaceImpl {
         // +-> Structure
         //       +-> Node
         //            +-> ObjectNode
-        if (dataType instanceof ua_data_type_impl_js_1.UADataTypeImpl) {
+        if (dataType instanceof UADataTypeImpl) {
             return this.findDataType(dataType.nodeId);
         }
-        else if (dataType instanceof node_opcua_nodeid_1.NodeId) {
+        else if (dataType instanceof NodeId) {
             return _find_by_node_id(this, dataType, namespaceIndex);
         }
         if (typeof dataType === "number") {
-            if (node_opcua_variant_1.DataType[dataType] !== undefined) {
-                return this.findDataType((0, node_opcua_nodeid_1.makeNodeId)(dataType, 0));
+            if (DataType[dataType] !== undefined) {
+                return this.findDataType(makeNodeId(dataType, 0));
             }
             else {
-                return this.findDataType((0, node_opcua_nodeid_1.resolveNodeId)(dataType));
+                return this.findDataType(resolveNodeId(dataType));
             }
         }
         const res = _extract_namespace_and_browse_name_as_string(this, dataType, namespaceIndex);
@@ -444,7 +502,7 @@ class AddressSpaceImpl {
             }
             dataTypeNode = resolvedDataType;
         }
-        if (dataTypeNode instanceof node_opcua_nodeid_1.NodeId) {
+        if (dataTypeNode instanceof NodeId) {
             const foundDataTypeNode = this.findDataType(dataTypeNode);
             /* c8 ignore next */
             if (!foundDataTypeNode) {
@@ -453,24 +511,24 @@ class AddressSpaceImpl {
             dataTypeNode = foundDataTypeNode;
         }
         /* c8 ignore next */
-        if (!(dataTypeNode instanceof ua_data_type_impl_js_1.UADataTypeImpl)) {
+        if (!(dataTypeNode instanceof UADataTypeImpl)) {
             throw new Error("we are expecting an UADataType here :  " +
                 _orig_dataTypeNode.toString() +
                 " should not refer to a  " +
                 dataTypeNode.browseName.name);
         }
-        if ((0, node_opcua_nodeid_1.sameNodeId)(enumerationTypeNodeId, dataTypeNode?.nodeId)) {
-            return node_opcua_variant_1.DataType.Int32;
+        if (sameNodeId(enumerationTypeNodeId, dataTypeNode?.nodeId)) {
+            return DataType.Int32;
         }
         const n = dataTypeNode.nodeId;
         if (n.namespace === 0 && n.value === 29) {
             // Number
-            return node_opcua_variant_1.DataType.Null; //which one ?
+            return DataType.Null; //which one ?
         }
         if (n.namespace === 0 && n.value === 0) {
-            return node_opcua_variant_1.DataType.Null;
+            return DataType.Null;
         }
-        if (n.identifierType === node_opcua_nodeid_1.NodeIdType.NUMERIC && n.namespace === 0 && n.value <= 25) {
+        if (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0 && n.value <= 25) {
             return n.value;
         }
         const result = this.findCorrespondingBasicDataType(dataTypeNode.subtypeOfObj);
@@ -510,19 +568,19 @@ class AddressSpaceImpl {
         //                  +->(hasSubtype) Organizes/OrganizedBy
         //                  +->(hasSubtype) HasEventSource/EventSourceOf
         let node;
-        if ((!(refType instanceof node_opcua_nodeid_1.NodeId) && isNodeIdString(refType)) || typeof refType === "number") {
-            refType = (0, node_opcua_nodeid_1.resolveNodeId)(refType);
+        if ((!(refType instanceof NodeId) && isNodeIdString(refType)) || typeof refType === "number") {
+            refType = resolveNodeId(refType);
         }
-        if (refType instanceof node_opcua_nodeid_1.NodeId) {
+        if (refType instanceof NodeId) {
             node = this.findNode(refType);
             /* c8 ignore next */
-            if (!(node && node.nodeClass === node_opcua_data_model_1.NodeClass.ReferenceType)) {
+            if (!(node && node.nodeClass === NodeClass.ReferenceType)) {
                 // throw new Error("cannot resolve referenceId "+ refType.toString());
                 return null;
             }
         }
         else {
-            (0, node_opcua_assert_1.assert)(typeof refType === "string");
+            assert(typeof refType === "string");
             node = this._findReferenceType(refType, namespaceIndex);
         }
         return node;
@@ -542,7 +600,7 @@ class AddressSpaceImpl {
      *
      */
     inverseReferenceType(referenceType) {
-        (0, node_opcua_assert_1.assert)(typeof referenceType === "string");
+        assert(typeof referenceType === "string");
         const n1 = this.findReferenceType(referenceType);
         if (n1) {
             return n1.inverseName?.text;
@@ -569,7 +627,7 @@ class AddressSpaceImpl {
      */
     findEventType(eventTypeId, namespaceIndex) {
         let eventType;
-        if (eventTypeId instanceof base_node_impl_js_1.BaseNodeImpl) {
+        if (eventTypeId instanceof BaseNodeImpl) {
             eventType = eventTypeId;
         }
         else {
@@ -583,7 +641,7 @@ class AddressSpaceImpl {
         if (!baseEventType) {
             throw new Error("expecting BaseEventType - please check you nodeset xml file!");
         }
-        if ((0, node_opcua_nodeid_1.sameNodeId)(eventType.nodeId, baseEventType.nodeId)) {
+        if (sameNodeId(eventType.nodeId, baseEventType.nodeId)) {
             return eventType;
         }
         /* eventTypeNode should be a sub type of "BaseEventType" */
@@ -609,12 +667,12 @@ class AddressSpaceImpl {
          */
         const offset = 16;
         if (!this._eventIdCounter) {
-            this._eventIdCounter = (0, node_opcua_utils_1.randomBytes)(20);
+            this._eventIdCounter = randomBytes(20);
             this._eventIdCounter.writeInt32BE(0, offset);
         }
         this._eventIdCounter.writeInt32BE(this._eventIdCounter.readInt32BE(offset) + 1, offset);
-        return new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.ByteString,
+        return new Variant({
+            dataType: DataType.ByteString,
             value: Buffer.from(this._eventIdCounter)
         });
     }
@@ -631,45 +689,45 @@ class AddressSpaceImpl {
         // construct the reference dataStructure to store event Data
         let eventTypeNode = eventTypeId;
         // make sure that eventType is really a object that derived from EventType
-        if (eventTypeId instanceof ua_object_type_impl_js_1.UAObjectTypeImpl) {
+        if (eventTypeId instanceof UAObjectTypeImpl) {
             eventTypeNode = this.findEventType(eventTypeId);
         }
         /* c8 ignore next */
         if (!eventTypeNode)
             throw new Error(` cannot find EventType for ${eventTypeId}`);
-        (0, node_opcua_assert_1.assert)(eventTypeNode instanceof ua_object_type_impl_js_1.UAObjectTypeImpl, "eventTypeId must represent a UAObjectType");
+        assert(eventTypeNode instanceof UAObjectTypeImpl, "eventTypeId must represent a UAObjectType");
         // eventId
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(data, "eventId"), "eventId constructEventData : options object should not have eventId property");
+        assert(!Object.hasOwn(data, "eventId"), "eventId constructEventData : options object should not have eventId property");
         data.eventId = data.eventId || this.generateEventId();
         // eventType
-        data.eventType = { dataType: node_opcua_variant_1.DataType.NodeId, value: eventTypeNode.nodeId };
+        data.eventType = { dataType: DataType.NodeId, value: eventTypeNode.nodeId };
         // sourceNode
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(data, "sourceNode"), "expecting a source node to be defined");
-        data.sourceNode = new node_opcua_variant_1.Variant(data.sourceNode);
-        (0, node_opcua_assert_1.assert)(data.sourceNode.dataType === node_opcua_variant_1.DataType.NodeId);
+        assert(Object.hasOwn(data, "sourceNode"), "expecting a source node to be defined");
+        data.sourceNode = new Variant(data.sourceNode);
+        assert(data.sourceNode.dataType === DataType.NodeId);
         // sourceName
         const sourceNode = this.findNode(data.sourceNode.value);
         if (!sourceNode) {
             warningLog(`constructEventData: cannot find sourceNode ${data.sourceNode.value?.toString()} for event ${eventTypeNode.browseName.toString()}`);
         }
         data.sourceName = data.sourceName || {
-            dataType: node_opcua_variant_1.DataType.String,
+            dataType: DataType.String,
             value: sourceNode?.getDisplayName("en") || ""
         };
         const nowUTC = new Date();
         // time (UtcTime)
         // TODO
-        data.time = data.time || { dataType: node_opcua_variant_1.DataType.DateTime, value: nowUTC };
+        data.time = data.time || { dataType: DataType.DateTime, value: nowUTC };
         // receivedTime  (UtcTime)
         // TODO
-        data.receiveTime = data.receiveTime || { dataType: node_opcua_variant_1.DataType.DateTime, value: nowUTC };
+        data.receiveTime = data.receiveTime || { dataType: DataType.DateTime, value: nowUTC };
         // localTime  (UtcTime)
         // TODO
-        data.localTime = data.localTime || { dataType: node_opcua_variant_1.DataType.DateTime, value: nowUTC };
+        data.localTime = data.localTime || { dataType: DataType.DateTime, value: nowUTC };
         // message  (LocalizedText)
-        data.message = data.message || { dataType: node_opcua_variant_1.DataType.LocalizedText, value: { text: "" } };
+        data.message = data.message || { dataType: DataType.LocalizedText, value: { text: "" } };
         // severity  (UInt16)
-        data.severity = data.severity || { dataType: node_opcua_variant_1.DataType.UInt16, value: 0 };
+        data.severity = data.severity || { dataType: DataType.UInt16, value: 0 };
         // xx // reminder : event type cannot be instantiated directly !
         // xx assert(eventTypeNode.isAbstract);
         const baseObjectType = this.findObjectType("BaseObjectType"); // i=58
@@ -677,23 +735,23 @@ class AddressSpaceImpl {
         if (!baseObjectType) {
             throw new Error("BaseObjectType must be defined in the address space");
         }
-        const layout = (0, event_layout_js_1.getEventLayout)(this, eventTypeNode, baseObjectType);
-        const eventData = new event_data_js_1.EventData(eventTypeNode, layout.pathToNodeId);
+        const layout = getEventLayout(this, eventTypeNode, baseObjectType);
+        const eventData = new EventData(eventTypeNode, layout.pathToNodeId);
         for (const field of layout.fields) {
             if (Object.hasOwn(data, field.lowerName)) {
                 eventData._setField(field, data[field.lowerName]);
                 continue;
             }
             // add a property , but with a null variant
-            eventData._setField(field, { dataType: node_opcua_variant_1.DataType.Null });
+            eventData._setField(field, { dataType: DataType.Null });
             // c8 ignore next
             if (doDebug) {
                 errorLog((field.mandatory
-                    ? chalk_1.default.red("ERROR : AddressSpace#constructEventData(eventType,options) cannot find property ")
-                    : chalk_1.default.yellow("Warning : AddressSpace#constructEventData(eventType,options) cannot find property ")) +
+                    ? chalk.red("ERROR : AddressSpace#constructEventData(eventType,options) cannot find property ")
+                    : chalk.yellow("Warning : AddressSpace#constructEventData(eventType,options) cannot find property ")) +
                     eventTypeNode.browseName.toString() +
                     " => " +
-                    chalk_1.default.cyan(field.lowerName));
+                    chalk.cyan(field.lowerName));
             }
         }
         // verify that all elements of data are valid
@@ -732,14 +790,14 @@ class AddressSpaceImpl {
      *
      */
     browsePath(browsePath) {
-        (0, node_opcua_assert_1.assert)(browsePath instanceof node_opcua_types_1.BrowsePath);
+        assert(browsePath instanceof BrowsePath);
         const startingNode = this.findNode(browsePath.startingNode);
         if (!startingNode) {
-            return new node_opcua_types_1.BrowsePathResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNodeIdUnknown });
+            return new BrowsePathResult({ statusCode: StatusCodes.BadNodeIdUnknown });
         }
         if (!browsePath.relativePath.elements || browsePath.relativePath.elements.length === 0) {
-            return new node_opcua_types_1.BrowsePathResult({
-                statusCode: node_opcua_status_code_1.StatusCodes.BadNothingToDo,
+            return new BrowsePathResult({
+                statusCode: StatusCodes.BadNothingToDo,
                 targets: []
             });
         }
@@ -761,14 +819,14 @@ class AddressSpaceImpl {
             return prev + (isBad ? 1 : 0);
         }, 0);
         if (empty_targetName_not_in_lastPos) {
-            return new node_opcua_types_1.BrowsePathResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadBrowseNameInvalid });
+            return new BrowsePathResult({ statusCode: StatusCodes.BadBrowseNameInvalid });
         }
         // from OPCUA 1.03 - PArt 3 - 5.8.4 TranslateBrowsePathToNodeIds
         // TranslateBrowsePathToNodeIds further restrict RelativePath targetName rules:
         // The last element in the relativePath shall always have a targetName specified.
         const last_el = browsePath.relativePath.elements[elements_length - 1];
         if (!last_el.targetName?.name || last_el.targetName.name.length === 0) {
-            return new node_opcua_types_1.BrowsePathResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadBrowseNameInvalid });
+            return new BrowsePathResult({ statusCode: StatusCodes.BadBrowseNameInvalid });
         }
         const res = [];
         const explore_element = (curNodeObject, elements, index) => {
@@ -795,24 +853,24 @@ class AddressSpaceImpl {
                 for (const target of targets) {
                     res.push({
                         remainingPathIndex: 0xffffffff,
-                        targetId: (0, node_opcua_nodeid_1.coerceExpandedNodeId)(target.targetId)
+                        targetId: coerceExpandedNodeId(target.targetId)
                     });
                 }
             }
         };
         explore_element(startingNode, browsePath.relativePath.elements, 0);
         if (res.length === 0) {
-            return new node_opcua_types_1.BrowsePathResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNoMatch });
+            return new BrowsePathResult({ statusCode: StatusCodes.BadNoMatch });
         }
-        return new node_opcua_types_1.BrowsePathResult({
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+        return new BrowsePathResult({
+            statusCode: StatusCodes.Good,
             targets: res
         });
     }
     // - Extension Object ----------------------------------------------------------------------------------------------
     getExtensionObjectConstructor(dataType) {
-        (0, node_opcua_assert_1.assert)(dataType, "expecting a dataType");
-        if (dataType instanceof node_opcua_nodeid_1.NodeId) {
+        assert(dataType, "expecting a dataType");
+        if (dataType instanceof NodeId) {
             const tmp = this.findNode(dataType);
             /* c8 ignore next */
             if (!tmp) {
@@ -821,7 +879,7 @@ class AddressSpaceImpl {
             dataType = tmp;
         }
         /* c8 ignore next */
-        if (!(dataType instanceof ua_data_type_impl_js_1.UADataTypeImpl)) {
+        if (!(dataType instanceof UADataTypeImpl)) {
             // may be dataType was the NodeId of the "Binary Encoding" node
             throw new Error(`getExtensionObjectConstructor: dataType has unexpected type${dataType}`);
         }
@@ -837,7 +895,7 @@ class AddressSpaceImpl {
             // c8 ignore next
             doDebug && debugLog(_dataType.toString());
         }
-        (0, node_opcua_assert_1.assert)(_dataType.isSubtypeOf(structureDataType));
+        assert(_dataType.isSubtypeOf(structureDataType));
         if (!_dataType._extensionObjectConstructor) {
             if (!this.$$extraDataTypeManager) {
                 throw new Error(`getExtensionObjectConstructor: cannot build a constructor for ${_dataType.browseName.toString()} (${_dataType.nodeId.toString()}): ` +
@@ -847,7 +905,7 @@ class AddressSpaceImpl {
             const dataTypeManager = this.$$extraDataTypeManager;
             _dataType._extensionObjectConstructor = dataTypeManager.getExtensionObjectConstructorFromDataType(_dataType.nodeId);
         }
-        (0, node_opcua_assert_1.assert)(_dataType._extensionObjectConstructor, "dataType must have a constructor");
+        assert(_dataType._extensionObjectConstructor, "dataType must have a constructor");
         const Constructor = _dataType._extensionObjectConstructor;
         return Constructor;
     }
@@ -888,7 +946,7 @@ class AddressSpaceImpl {
      */
     registerShutdownTask(task) {
         this._shutdownTask = this._shutdownTask || [];
-        (0, node_opcua_assert_1.assert)(typeof task === "function");
+        assert(typeof task === "function");
         this._shutdownTask.push(task);
     }
     /**
@@ -898,7 +956,7 @@ class AddressSpaceImpl {
      * is rejected and subsequent interceptors are skipped.
      */
     addMethodCallInterceptor(interceptor) {
-        (0, node_opcua_assert_1.assert)(typeof interceptor === "function");
+        assert(typeof interceptor === "function");
         this._methodCallInterceptors.push(interceptor);
     }
     /**
@@ -927,13 +985,13 @@ class AddressSpaceImpl {
         const browseResult = {
             continuationPoint: undefined,
             references: null,
-            statusCode: node_opcua_status_code_1.StatusCodes.Good
+            statusCode: StatusCodes.Good
         };
-        if (!browseDescription || browseDescription.browseDirection === node_opcua_data_model_1.BrowseDirection.Invalid) {
-            browseResult.statusCode = node_opcua_status_code_1.StatusCodes.BadBrowseDirectionInvalid;
-            return new node_opcua_service_browse_1.BrowseResult(browseResult);
+        if (!browseDescription || browseDescription.browseDirection === BrowseDirection.Invalid) {
+            browseResult.statusCode = StatusCodes.BadBrowseDirectionInvalid;
+            return new BrowseResult(browseResult);
         }
-        browseDescription.browseDirection = (0, adjust_browse_direction_js_1.adjustBrowseDirection)(browseDescription.browseDirection, node_opcua_data_model_1.BrowseDirection.Forward);
+        browseDescription.browseDirection = adjustBrowseDirection(browseDescription.browseDirection, BrowseDirection.Forward);
         /* c8 ignore next */
         if (typeof nodeId === "number") {
             throw new Error("Not Implemented");
@@ -945,28 +1003,28 @@ class AddressSpaceImpl {
             }
         }
         // check if referenceTypeId is correct
-        if (browseDescription.referenceTypeId instanceof node_opcua_nodeid_1.NodeId) {
+        if (browseDescription.referenceTypeId instanceof NodeId) {
             if (browseDescription.referenceTypeId.value === 0) {
                 browseDescription.referenceTypeId = null;
             }
             else {
                 const rf = this.findNode(browseDescription.referenceTypeId);
-                if (!rf || !(rf instanceof ua_reference_type_impl_js_1.UAReferenceTypeImpl)) {
-                    browseResult.statusCode = node_opcua_status_code_1.StatusCodes.BadReferenceTypeIdInvalid;
-                    return new node_opcua_service_browse_1.BrowseResult(browseResult);
+                if (!rf || !(rf instanceof UAReferenceTypeImpl)) {
+                    browseResult.statusCode = StatusCodes.BadReferenceTypeIdInvalid;
+                    return new BrowseResult(browseResult);
                 }
             }
         }
         const obj = this.findNode(nodeId);
         if (!obj) {
             // Object Not Found
-            browseResult.statusCode = node_opcua_status_code_1.StatusCodes.BadNodeIdUnknown;
+            browseResult.statusCode = StatusCodes.BadNodeIdUnknown;
         }
         else {
-            browseResult.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+            browseResult.statusCode = StatusCodes.Good;
             browseResult.references = obj.browseNode(browseDescription, context);
         }
-        return new node_opcua_service_browse_1.BrowseResult(browseResult);
+        return new BrowseResult(browseResult);
     }
     /**
      * @param folder
@@ -1003,22 +1061,22 @@ class AddressSpaceImpl {
      * @private
      */
     extractRootViews(node) {
-        (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Object || node.nodeClass === node_opcua_data_model_1.NodeClass.Variable);
+        assert(node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable);
         const visitedMap = {};
-        const q = new dequeue_1.default();
+        const q = new Dequeue();
         q.push(node);
         const objectsFolder = this.rootFolder.objects;
-        (0, node_opcua_assert_1.assert)(objectsFolder instanceof ua_object_impl_js_1.UAObjectImpl);
+        assert(objectsFolder instanceof UAObjectImpl);
         const results = [];
         while (q.length) {
             node = q.shift();
-            const references = node.findReferencesEx("HierarchicalReferences", node_opcua_data_model_1.BrowseDirection.Inverse);
-            const parentNodes = references.map((r) => reference_impl_js_1.ReferenceImpl.resolveReferenceNode(this, r));
+            const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
+            const parentNodes = references.map((r) => ReferenceImpl.resolveReferenceNode(this, r));
             for (const parent of parentNodes) {
-                if ((0, node_opcua_nodeid_1.sameNodeId)(parent.nodeId, objectsFolder.nodeId)) {
+                if (sameNodeId(parent.nodeId, objectsFolder.nodeId)) {
                     continue; // nothing to do
                 }
-                if (parent.nodeClass === node_opcua_data_model_1.NodeClass.View) {
+                if (parent.nodeClass === NodeClass.View) {
                     results.push(parent);
                 }
                 else {
@@ -1042,7 +1100,7 @@ class AddressSpaceImpl {
         this._modelChangeTransactionCounter = this._modelChangeTransactionCounter || 0;
         function beginModelChange() {
             this._modelChanges = this._modelChanges || [];
-            (0, node_opcua_assert_1.assert)(this._modelChangeTransactionCounter >= 0);
+            assert(this._modelChangeTransactionCounter >= 0);
             this._modelChangeTransactionCounter += 1;
         }
         function endModelChange() {
@@ -1064,8 +1122,8 @@ class AddressSpaceImpl {
                         this.rootFolder.objects.server.raiseEvent(eventTypeNode, {
                             // Part 5 - 6.4.32 GeneralModelChangeEventType
                             changes: {
-                                dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                                arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                                dataType: DataType.ExtensionObject,
+                                arrayType: VariantArrayType.Array,
                                 value: this._modelChanges
                             }
                         });
@@ -1094,19 +1152,19 @@ class AddressSpaceImpl {
      * @return {Object} a new reference object  with the normalized name { referenceType: <value>, isForward: <flag>}
      */
     normalizeReferenceType(params) {
-        if (params instanceof reference_impl_js_1.ReferenceImpl) {
+        if (params instanceof ReferenceImpl) {
             // a reference has already been normalized
             return params;
         }
         // ----------------------------------------------- handle is forward
-        (0, node_opcua_assert_1.assert)(params.isForward === undefined || typeof params.isForward === "boolean");
-        params.isForward = (0, node_opcua_utils_1.isNullOrUndefined)(params.isForward) ? true : !!params.isForward;
+        assert(params.isForward === undefined || typeof params.isForward === "boolean");
+        params.isForward = isNullOrUndefined(params.isForward) ? true : !!params.isForward;
         // referenceType = Organizes   , isForward = true =>   referenceType = Organizes , isForward = true
         // referenceType = Organizes   , isForward = false =>  referenceType = Organizes , isForward = false
         // referenceType = OrganizedBy , isForward = true =>   referenceType = Organizes , isForward = **false**
         // referenceType = OrganizedBy , isForward = false =>  referenceType = Organizes , isForward =  **true**
         // ----------------------------------------------- handle referenceType
-        if (params.referenceType instanceof ua_reference_type_impl_js_1.UAReferenceTypeImpl) {
+        if (params.referenceType instanceof UAReferenceTypeImpl) {
             params.referenceType = params.referenceType;
             params.referenceType = params.referenceType.nodeId;
         }
@@ -1125,31 +1183,31 @@ class AddressSpaceImpl {
                 params.isForward = !params.isForward;
             }
             else {
-                params.referenceType = (0, node_opcua_nodeid_1.resolveNodeId)(params.referenceType);
+                params.referenceType = resolveNodeId(params.referenceType);
                 const refType = this.findReferenceType(params.referenceType);
                 if (refType) {
                     params._referenceType = refType;
                 }
             }
         }
-        (0, node_opcua_assert_1.assert)(params.referenceType instanceof node_opcua_nodeid_1.NodeId);
+        assert(params.referenceType instanceof NodeId);
         // ----------- now resolve target NodeId;
-        if (params.nodeId instanceof base_node_impl_js_1.BaseNodeImpl) {
-            (0, node_opcua_assert_1.assert)(!Object.hasOwn(params, "node"));
+        if (params.nodeId instanceof BaseNodeImpl) {
+            assert(!Object.hasOwn(params, "node"));
             params.node = params.nodeId;
             params.nodeId = params.node.nodeId;
         }
         else {
             let _nodeId = params.nodeId;
-            (0, node_opcua_assert_1.assert)(!!_nodeId, "missing 'nodeId' in reference");
+            assert(!!_nodeId, "missing 'nodeId' in reference");
             const _nodeIdWithNodeId = _nodeId;
             if (_nodeId && _nodeIdWithNodeId.nodeId) {
                 _nodeId = _nodeIdWithNodeId.nodeId;
             }
-            _nodeId = (0, node_opcua_nodeid_1.resolveNodeId)(_nodeId);
+            _nodeId = resolveNodeId(_nodeId);
             params.nodeId = _nodeId;
         }
-        return new reference_impl_js_1.ReferenceImpl(params);
+        return new ReferenceImpl(params);
     }
     normalizeReferenceTypes(references) {
         if (!references || references.length === 0) {
@@ -1164,25 +1222,25 @@ class AddressSpaceImpl {
      * @param options
      */
     installHistoricalDataNode(node, options) {
-        address_space_historical_data_node_js_1.AddressSpace_installHistoricalDataNode.call(this, node, options);
+        AddressSpace_installHistoricalDataNode.call(this, node, options);
     }
     // -- Alarms & Conditions  -----------------------------------------------------------------------------------------
     /**
      *
      */
     installAlarmsAndConditionsService() {
-        index_js_1.UAConditionImplBase.install_condition_refresh_handle(this);
-        index_js_1.UAAcknowledgeableConditionImplBase.install_method_handle_on_type(this);
+        UAConditionImplBase.install_condition_refresh_handle(this);
+        UAAcknowledgeableConditionImplBase.install_method_handle_on_type(this);
     }
     // -- internal stuff -----------------------------------------------------------------------------------------------
     _coerceNode(node) {
         // coerce to BaseNode object
-        if (node instanceof base_node_impl_js_1.BaseNodeImpl) {
+        if (node instanceof BaseNodeImpl) {
             return node;
         }
         // it's a node id like
         // coerce parent folder to an object
-        const returnValue = this.findNode((0, node_opcua_nodeid_1.resolveNodeId)(node));
+        const returnValue = this.findNode(resolveNodeId(node));
         /*
          if (!hasTypeDefinition(node as BaseNode)) {
              node = this.findNode(node.nodeId) || node;
@@ -1194,14 +1252,14 @@ class AddressSpaceImpl {
         return returnValue;
     }
     _coerce_DataType(dataType) {
-        if (dataType instanceof node_opcua_nodeid_1.NodeId) {
+        if (dataType instanceof NodeId) {
             // xx assert(self.findDataType(dataType));
             return dataType;
         }
         if (dataType === 0) {
-            return node_opcua_nodeid_1.NodeId.nullNodeId;
+            return NodeId.nullNodeId;
         }
-        return this._coerce_Type(dataType, node_opcua_constants_1.DataTypeIds, "DataTypeIds", AddressSpaceImpl.prototype.findDataType);
+        return this._coerce_Type(dataType, DataTypeIds, "DataTypeIds", AddressSpaceImpl.prototype.findDataType);
     }
     _coerceTypeDefinition(typeDefinition) {
         if (typeof typeDefinition === "string") {
@@ -1213,24 +1271,24 @@ class AddressSpaceImpl {
             }
             typeDefinition = typeDefinitionNode.nodeId;
         }
-        (0, node_opcua_assert_1.assert)(typeDefinition instanceof node_opcua_nodeid_1.NodeId);
+        assert(typeDefinition instanceof NodeId);
         return typeDefinition;
     }
     _coerceType(baseType, topMostBaseType, nodeClass) {
-        (0, node_opcua_assert_1.assert)(typeof topMostBaseType === "string");
+        assert(typeof topMostBaseType === "string");
         const topMostBaseTypeNode = this.findNode(topMostBaseType);
         /* c8 ignore next */
         if (!topMostBaseTypeNode) {
             throw new Error(`Cannot find topMostBaseTypeNode ${topMostBaseType.toString()}`);
         }
-        (0, node_opcua_assert_1.assert)(topMostBaseTypeNode instanceof base_node_impl_js_1.BaseNodeImpl);
-        (0, node_opcua_assert_1.assert)(topMostBaseTypeNode.nodeClass === nodeClass);
+        assert(topMostBaseTypeNode instanceof BaseNodeImpl);
+        assert(topMostBaseTypeNode.nodeClass === nodeClass);
         if (!baseType) {
             return topMostBaseTypeNode;
         }
-        (0, node_opcua_assert_1.assert)(typeof baseType === "string" || baseType instanceof base_node_impl_js_1.BaseNodeImpl || baseType instanceof node_opcua_nodeid_1.NodeId);
+        assert(typeof baseType === "string" || baseType instanceof BaseNodeImpl || baseType instanceof NodeId);
         let baseTypeNode;
-        if (baseType instanceof base_node_impl_js_1.BaseNodeImpl) {
+        if (baseType instanceof BaseNodeImpl) {
             baseTypeNode = baseType;
         }
         else {
@@ -1252,10 +1310,10 @@ class AddressSpaceImpl {
         return baseTypeNode;
     }
     _coerce_VariableTypeIds(dataType) {
-        return this._coerce_Type(dataType, node_opcua_constants_1.VariableTypeIds, "VariableTypeIds", AddressSpaceImpl.prototype.findVariableType);
+        return this._coerce_Type(dataType, VariableTypeIds, "VariableTypeIds", AddressSpaceImpl.prototype.findVariableType);
     }
     _register(node) {
-        (0, node_opcua_assert_1.assert)(node.nodeId instanceof node_opcua_nodeid_1.NodeId);
+        assert(node.nodeId instanceof NodeId);
         const namespace = this.getNamespace(node.nodeId.namespace);
         namespace._register(node);
     }
@@ -1276,19 +1334,19 @@ class AddressSpaceImpl {
     }
     _coerce_Type(dataType, typeMap, typeMapName, finderMethod) {
         if (typeof dataType === "number") {
-            return this._coerce_Type((0, node_opcua_nodeid_1.coerceNodeId)(dataType), typeMap, typeMapName, finderMethod);
+            return this._coerce_Type(coerceNodeId(dataType), typeMap, typeMapName, finderMethod);
         }
-        if (dataType instanceof base_node_impl_js_1.BaseNodeImpl) {
+        if (dataType instanceof BaseNodeImpl) {
             dataType = dataType.nodeId;
         }
-        (0, node_opcua_assert_1.assert)(typeMap !== null && typeof typeMap === "object");
+        assert(typeMap !== null && typeof typeMap === "object");
         let nodeId;
         if (typeof dataType === "string") {
             if (isNodeIdString(dataType)) {
                 const nodeId = this.resolveNodeId(dataType);
                 if (nodeId.isEmpty()) {
                     // this is a valid dataType NodeId, but it has no definition in the address space
-                    return node_opcua_nodeid_1.NodeId.nullNodeId;
+                    return NodeId.nullNodeId;
                 }
                 const node = this.findNode(nodeId);
                 if (node) {
@@ -1306,22 +1364,22 @@ class AddressSpaceImpl {
             if (!nodeId) {
                 // dataType was not found in the aliases database
                 if (typeMap[dataType]) {
-                    nodeId = (0, node_opcua_nodeid_1.makeNodeId)(typeMap[dataType], 0);
+                    nodeId = makeNodeId(typeMap[dataType], 0);
                     return nodeId;
                 }
                 else {
-                    nodeId = (0, node_opcua_nodeid_1.resolveNodeId)(dataType);
+                    nodeId = resolveNodeId(dataType);
                 }
             }
         }
         else if (typeof dataType === "number") {
-            nodeId = (0, node_opcua_nodeid_1.makeNodeId)(dataType, 0);
+            nodeId = makeNodeId(dataType, 0);
         }
         else {
-            nodeId = (0, node_opcua_nodeid_1.resolveNodeId)(dataType);
+            nodeId = resolveNodeId(dataType);
         }
         /* c8 ignore next */
-        if (nodeId == null || !(nodeId instanceof node_opcua_nodeid_1.NodeId)) {
+        if (nodeId == null || !(nodeId instanceof NodeId)) {
             throw new Error("Expecting valid nodeId ");
         }
         const el = finderMethod.call(this, nodeId);
@@ -1336,16 +1394,15 @@ class AddressSpaceImpl {
         return nodeId;
     }
     _findReferenceType(refType, namespaceIndex) {
-        if (refType instanceof node_opcua_nodeid_1.NodeId) {
+        if (refType instanceof NodeId) {
             return _find_by_node_id(this, refType, namespaceIndex);
         }
         const [namespace, browseName] = _extract_namespace_and_browse_name_as_string(this, refType, namespaceIndex);
         return namespace.findReferenceType(browseName);
     }
 }
-exports.AddressSpaceImpl = AddressSpaceImpl;
 function _getNamespace(addressSpace, nodeOrNodId) {
-    const nodeId = nodeOrNodId instanceof base_node_impl_js_1.BaseNodeImpl ? nodeOrNodId.nodeId : nodeOrNodId;
+    const nodeId = nodeOrNodId instanceof BaseNodeImpl ? nodeOrNodId.nodeId : nodeOrNodId;
     return addressSpace.getNamespace(nodeId.namespace);
 }
 function _find_by_node_id(addressSpace, nodeId, _namespaceIndex) {
@@ -1361,8 +1418,8 @@ function _find_by_node_id(addressSpace, nodeId, _namespaceIndex) {
  */
 function _isFolder(addressSpace, folder) {
     const folderType = addressSpace.findObjectType("FolderType");
-    (0, node_opcua_assert_1.assert)(folder instanceof base_node_impl_js_1.BaseNodeImpl);
-    (0, node_opcua_assert_1.assert)(folder.typeDefinitionObj);
+    assert(folder instanceof BaseNodeImpl);
+    assert(folder.typeDefinitionObj);
     return folder.typeDefinitionObj.isSubtypeOf(folderType);
 }
 function _increase_version_number(node) {
@@ -1375,7 +1432,7 @@ function _increase_version_number(node) {
             previousValue = 0;
         }
         uaNodeVersion.setValueFromSource({
-            dataType: node_opcua_variant_1.DataType.String,
+            dataType: DataType.String,
             value: (previousValue + 1).toString()
         });
     }