node-opcua-address-space 2.183.0 → 2.184.0

package/dist/impl/base_node_private.js

@@ -1,53 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToStringBuilder = void 0;
-exports.BaseNode_initPrivate = BaseNode_initPrivate;
-exports.BaseNode_removePrivate = BaseNode_removePrivate;
-exports.BaseNode_resetChildIndex = BaseNode_resetChildIndex;
-exports.BaseNode_getPrivate = BaseNode_getPrivate;
-exports.BaseNode_getCache = BaseNode_getCache;
-exports.BaseNode_clearCache = BaseNode_clearCache;
-exports.BaseNode_toString = BaseNode_toString;
-exports.BaseNode_References_toString = BaseNode_References_toString;
-exports.UAVariableType_toString = UAVariableType_toString;
-exports.UAVariable_toString = UAVariable_toString;
-exports.UAObject_toString = UAObject_toString;
-exports.UAObjectType_toString = UAObjectType_toString;
-exports.valueRankToString = valueRankToString;
-exports.VariableOrVariableType_toString = VariableOrVariableType_toString;
-exports._clone_hierarchical_references = _clone_hierarchical_references;
-exports._clone_non_hierarchical_references = _clone_non_hierarchical_references;
-exports._clone = _clone;
-exports._handle_HierarchicalReference = _handle_HierarchicalReference;
-exports._get_HierarchicalReference = _get_HierarchicalReference;
-exports._remove_HierarchicalReference = _remove_HierarchicalReference;
-exports._constructReferenceDescription = _constructReferenceDescription;
-exports.BaseNode_remove_backward_reference = BaseNode_remove_backward_reference;
-exports.noteReferenceTypeChange = noteReferenceTypeChange;
-exports.BaseNode_add_backward_reference = BaseNode_add_backward_reference;
 /**
  * @module node-opcua-address-space.Private
  */
-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_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_types_1 = require("node-opcua-types");
-const base_node_impl_js_1 = require("./base_node_impl.js");
-const namespace_private_js_1 = require("./namespace_private.js");
-const reference_impl_js_1 = require("./reference_impl.js");
-const reference_type_version_js_1 = require("./reference_type_version.js");
-const tool_isSubtypeOf_js_1 = require("./tool_isSubtypeOf.js");
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("address-space:BaseNode");
-const doTrace = (0, node_opcua_debug_1.checkDebugFlag)("INSTANTIATE");
+import chalk from "chalk";
+import { CloneHelper, fullPath2 } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { ObjectTypeIds, VariableTypeIds } from "node-opcua-constants";
+import { AccessLevelFlag, BrowseDirection, coerceLocalizedText, coerceQualifiedName, NodeClass, ResultMask } from "node-opcua-data-model";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { ReferenceDescription } from "node-opcua-types";
+import { BaseNodeImpl, getReferenceType } from "./base_node_impl.js";
+import { UANamespace_process_modelling_rule } from "./namespace_private.js";
+import { ReferenceImpl } from "./reference_impl.js";
+import { referenceTypeVersion, typeHierarchyVersion } from "./reference_type_version.js";
+import { wipeMemorizedStuff } from "./tool_isSubtypeOf.js";
+const errorLog = make_errorLog("address-space:BaseNode");
+const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("address-space:BaseNode");
+const warningLog = make_warningLog("address-space:BaseNode");
 /**
  * the private record hangs on the node itself under a symbol: as hidden from consumers as the
  * WeakMap it replaces, but a property read rather than a hash lookup, on every access to every
@@ -59,7 +29,7 @@ const PRIVATE = Symbol("BaseNodePrivate");
  * back reference replaces it with a map of the node's own (BaseNode_add_backward_reference)
  */
 const EMPTY_REFERENCE_INDEX = new Map();
-function BaseNode_initPrivate(self) {
+export function BaseNode_initPrivate(self) {
     const _private = {
         __address_space: null,
         _referenceIdx: new Map(),
@@ -75,7 +45,7 @@ function BaseNode_initPrivate(self) {
     self[PRIVATE] = _private;
     return _private;
 }
-function BaseNode_removePrivate(self) {
+export function BaseNode_removePrivate(self) {
     // there is no need to delete object from weak map
     // the GC will take care of this in due course
     // g_weakMap.delete(self);
@@ -95,7 +65,7 @@ function BaseNode_removePrivate(self) {
  * every node once a load is complete, so an index built before the load (a second nodeset added at
  * runtime to an address space already in use) cannot go stale.
  */
-function BaseNode_resetChildIndex(node) {
+export function BaseNode_resetChildIndex(node) {
     const _private = BaseNode_getPrivate(node);
     if (!_private) {
         return;
@@ -103,28 +73,28 @@ function BaseNode_resetChildIndex(node) {
     _private._childByNameMap = undefined;
     _private._childByNameMapIncomplete = false;
 }
-function BaseNode_getPrivate(self) {
+export function BaseNode_getPrivate(self) {
     return self[PRIVATE];
 }
-function BaseNode_getCache(node) {
+export function BaseNode_getCache(node) {
     const _private = BaseNode_getPrivate(node);
     if (!_private._cache) {
         _private._cache = {};
     }
     return _private._cache;
 }
-function BaseNode_clearCache(node) {
+export function BaseNode_clearCache(node) {
     const _private = BaseNode_getPrivate(node);
     if (_private?._cache) {
         _private._cache = undefined;
     }
-    (0, tool_isSubtypeOf_js_1.wipeMemorizedStuff)(node);
+    wipeMemorizedStuff(node);
 }
-const hasTypeDefinition_ReferenceTypeNodeId = (0, node_opcua_nodeid_1.resolveNodeId)("HasTypeDefinition");
+const hasTypeDefinition_ReferenceTypeNodeId = resolveNodeId("HasTypeDefinition");
 // looked up by NodeId rather than by name: a name lookup throws while namespace 0 is still
 // loading, and the child index must simply answer "nothing yet" at that point
-const hierarchicalReferences_ReferenceTypeNodeId = (0, node_opcua_nodeid_1.resolveNodeId)("HierarchicalReferences");
-class ToStringBuilder {
+const hierarchicalReferences_ReferenceTypeNodeId = resolveNodeId("HierarchicalReferences");
+export class ToStringBuilder {
     level = 0;
     cycleDetector = {};
     padding = "";
@@ -149,37 +119,36 @@ class ToStringBuilder {
             .join("\n");
     }
 }
-exports.ToStringBuilder = ToStringBuilder;
 function set_as_processed(options, nodeId) {
     options.cycleDetector[nodeId.toString()] = nodeId;
 }
 function is_already_processed(options, nodeId) {
     return !!options.cycleDetector[nodeId.toString()];
 }
-function BaseNode_toString(options) {
+export function BaseNode_toString(options) {
     options.level = options.level || 1;
     set_as_processed(options, this.nodeId);
     options.add("");
-    options.add(options.padding + chalk_1.default.yellow("          nodeId              : ") + this.nodeId.toString());
-    options.add(`${options.padding + chalk_1.default.yellow("          nodeClass           : ")}${node_opcua_data_model_1.NodeClass[this.nodeClass]} (${this.nodeClass})`);
-    options.add(options.padding + chalk_1.default.yellow("          browseName          : ") + this.browseName.toString());
+    options.add(options.padding + chalk.yellow("          nodeId              : ") + this.nodeId.toString());
+    options.add(`${options.padding + chalk.yellow("          nodeClass           : ")}${NodeClass[this.nodeClass]} (${this.nodeClass})`);
+    options.add(options.padding + chalk.yellow("          browseName          : ") + this.browseName.toString());
     options.add(options.padding +
-        chalk_1.default.yellow("          displayName         : ") +
+        chalk.yellow("          displayName         : ") +
         this.displayName.map((f) => `${f.locale} ${f.text}`).join(" | "));
-    options.add(options.padding + chalk_1.default.yellow("          description         : ") + (this.description ? this.description.toString() : ""));
+    options.add(options.padding + chalk.yellow("          description         : ") + (this.description ? this.description.toString() : ""));
 }
-function BaseNode_References_toString(options) {
+export function BaseNode_References_toString(options) {
     const _private = BaseNode_getPrivate(this);
     const displayOptions = {
         addressSpace: this.addressSpace
     };
     const addressSpace = this.addressSpace;
-    options.add(`${options.padding + chalk_1.default.yellow("    references                : ")}  length =${_private._referenceIdx.size}`);
+    options.add(`${options.padding + chalk.yellow("    references                : ")}  length =${_private._referenceIdx.size}`);
     function dump_reference(follow, reference) {
         if (!reference) {
             return;
         }
-        const o = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+        const o = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
         if (!o) {
             warningLog("cannot find reference", reference.toString());
             return;
@@ -189,34 +158,34 @@ function BaseNode_References_toString(options) {
         const extra = modellingRule[0] +
             (() => {
                 switch (o.nodeClass) {
-                    case node_opcua_data_model_1.NodeClass.Object:
+                    case NodeClass.Object:
                         return "[O] ";
-                    case node_opcua_data_model_1.NodeClass.Variable:
+                    case NodeClass.Variable:
                         return `[V] ${o.dataType.toString(displayOptions).padEnd(10)}`;
-                    case node_opcua_data_model_1.NodeClass.Method:
+                    case NodeClass.Method:
                         return "[M] ";
-                    case node_opcua_data_model_1.NodeClass.DataType:
+                    case NodeClass.DataType:
                         return "[DT]";
-                    case node_opcua_data_model_1.NodeClass.ReferenceType:
+                    case NodeClass.ReferenceType:
                         return "[RT]";
-                    case node_opcua_data_model_1.NodeClass.ObjectType:
+                    case NodeClass.ObjectType:
                         return "[OT]";
-                    case node_opcua_data_model_1.NodeClass.VariableType:
+                    case NodeClass.VariableType:
                         return "[VT]";
-                    case node_opcua_data_model_1.NodeClass.View:
+                    case NodeClass.View:
                         return "[V] ";
                 }
                 return "";
             })();
         options.add(options.padding +
-            chalk_1.default.yellow("      +-> ") +
+            chalk.yellow("      +-> ") +
             reference.toString(displayOptions) +
             " " +
-            chalk_1.default.cyan(name.padEnd(25, " ")) +
+            chalk.cyan(name.padEnd(25, " ")) +
             " " +
-            chalk_1.default.magentaBright(extra));
+            chalk.magentaBright(extra));
         // ignore HasTypeDefinition as it has been already handled
-        if ((0, node_opcua_nodeid_1.sameNodeId)(reference.referenceType, hasTypeDefinition_ReferenceTypeNodeId) && reference.nodeId.namespace === 0) {
+        if (sameNodeId(reference.referenceType, hasTypeDefinition_ReferenceTypeNodeId) && reference.nodeId.namespace === 0) {
             return;
         }
         if (o) {
@@ -238,10 +207,10 @@ function BaseNode_References_toString(options) {
         dump_reference(false, r);
     }
     options.add(options.padding +
-        chalk_1.default.yellow("    back_references                 : ") +
-        chalk_1.default.cyan("  length =") +
+        chalk.yellow("    back_references                 : ") +
+        chalk.cyan("  length =") +
         _private._back_referenceIdx.size +
-        chalk_1.default.grey(" ( references held by other nodes involving this node)"));
+        chalk.grey(" ( references held by other nodes involving this node)"));
     for (const r of _private._back_referenceIdx.values()) {
         dump_reference(false, r);
     }
@@ -250,7 +219,7 @@ function BaseNode_References_toString(options) {
 function _UAType_toString(options) {
     if (this.subtypeOfObj) {
         options.add(options.padding +
-            chalk_1.default.yellow("          subtypeOf           : ") +
+            chalk.yellow("          subtypeOf           : ") +
             this.subtypeOfObj.browseName.toString() +
             " (" +
             this.subtypeOfObj.nodeId.toString() +
@@ -260,37 +229,37 @@ function _UAType_toString(options) {
 function _UAInstance_toString(options) {
     if (this.typeDefinitionObj) {
         options.add(options.padding +
-            chalk_1.default.yellow("          typeDefinition      : ") +
+            chalk.yellow("          typeDefinition      : ") +
             this.typeDefinitionObj.browseName.toString() +
             " (" +
             this.typeDefinitionObj.nodeId.toString() +
             ")");
     }
 }
-function UAVariableType_toString(options) {
+export function UAVariableType_toString(options) {
     BaseNode_toString.call(this, options);
     _UAType_toString.call(this, options);
     VariableOrVariableType_toString.call(this, options);
     BaseNode_References_toString.call(this, options);
 }
-function UAVariable_toString(options) {
+export function UAVariable_toString(options) {
     BaseNode_toString.call(this, options);
     _UAInstance_toString.call(this, options);
     VariableOrVariableType_toString.call(this, options);
     AccessLevelFlags_toString.call(this, options);
     BaseNode_References_toString.call(this, options);
 }
-function UAObject_toString(options) {
+export function UAObject_toString(options) {
     BaseNode_toString.call(this, options);
     _UAInstance_toString.call(this, options);
     BaseNode_References_toString.call(this, options);
 }
-function UAObjectType_toString(options) {
+export function UAObjectType_toString(options) {
     BaseNode_toString.call(this, options);
     _UAType_toString.call(this, options);
     BaseNode_References_toString.call(this, options);
 }
-function valueRankToString(valueRank) {
+export function valueRankToString(valueRank) {
     switch (valueRank) {
         case 1:
             return "OneDimension (1)";
@@ -313,66 +282,66 @@ function valueRankToString(valueRank) {
 }
 function accessLevelFlagToString(flag) {
     const str = [];
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.CurrentRead) {
+    if (flag & AccessLevelFlag.CurrentRead) {
         str.push("CurrentRead");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.CurrentWrite) {
+    if (flag & AccessLevelFlag.CurrentWrite) {
         str.push("CurrentWrite");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.HistoryRead) {
+    if (flag & AccessLevelFlag.HistoryRead) {
         str.push("HistoryRead");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.HistoryWrite) {
+    if (flag & AccessLevelFlag.HistoryWrite) {
         str.push("HistoryWrite");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.SemanticChange) {
+    if (flag & AccessLevelFlag.SemanticChange) {
         str.push("SemanticChange");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.StatusWrite) {
+    if (flag & AccessLevelFlag.StatusWrite) {
         str.push("StatusWrite");
     }
-    if (flag & node_opcua_data_model_1.AccessLevelFlag.TimestampWrite) {
+    if (flag & AccessLevelFlag.TimestampWrite) {
         str.push("TimestampWrite");
     }
     return str.join(" | ");
 }
 function AccessLevelFlags_toString(options) {
-    (0, node_opcua_assert_1.assert)(options);
-    options.add(`${options.padding + chalk_1.default.yellow("          accessLevel         : ")} ${accessLevelFlagToString(this.accessLevel)}`);
+    assert(options);
+    options.add(`${options.padding + chalk.yellow("          accessLevel         : ")} ${accessLevelFlagToString(this.accessLevel)}`);
     if (this.userAccessLevel !== undefined) {
-        options.add(`${options.padding + chalk_1.default.yellow("          userAccessLevel     : ")} ${accessLevelFlagToString(this.userAccessLevel)}`);
+        options.add(`${options.padding + chalk.yellow("          userAccessLevel     : ")} ${accessLevelFlagToString(this.userAccessLevel)}`);
     }
 }
-function VariableOrVariableType_toString(options) {
-    (0, node_opcua_assert_1.assert)(options);
+export function VariableOrVariableType_toString(options) {
+    assert(options);
     if (this.dataType) {
         const addressSpace = this.addressSpace;
         const d = addressSpace.findNode(this.dataType);
         const n = d ? `(${d.browseName.toString()})` : " (???)";
-        options.add(`${options.padding + chalk_1.default.yellow("          dataType            : ")} ${this.dataType}  ${n}`);
+        options.add(`${options.padding + chalk.yellow("          dataType            : ")} ${this.dataType}  ${n}`);
     }
-    if (this.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+    if (this.nodeClass === NodeClass.Variable) {
         const _dataValue = this.$dataValue;
         if (_dataValue) {
             options.add(options.padding +
-                chalk_1.default.yellow("          value               : ") +
+                chalk.yellow("          value               : ") +
                 "\n" +
                 options.indent(_dataValue.toString(), `${options.padding}                        | `));
         }
     }
     if (Object.hasOwn(this, "valueRank")) {
         if (this.valueRank !== undefined) {
-            options.add(`${options.padding + chalk_1.default.yellow("          valueRank           : ")} ${valueRankToString(this.valueRank)}`);
+            options.add(`${options.padding + chalk.yellow("          valueRank           : ")} ${valueRankToString(this.valueRank)}`);
         }
         else {
-            options.add(`${options.padding + chalk_1.default.yellow("          valueRank           : ")} undefined`);
+            options.add(`${options.padding + chalk.yellow("          valueRank           : ")} undefined`);
         }
     }
     if (this.minimumSamplingInterval !== undefined) {
-        options.add(`${options.padding + chalk_1.default.yellow(" minimumSamplingInterval      : ")} ${this.minimumSamplingInterval.toString()} ms`);
+        options.add(`${options.padding + chalk.yellow(" minimumSamplingInterval      : ")} ${this.minimumSamplingInterval.toString()} ms`);
     }
     if (this.arrayDimensions) {
-        options.add(`${options.padding + chalk_1.default.yellow(" arrayDimension               : ")} [${this.arrayDimensions.join(",").toString()} ]`);
+        options.add(`${options.padding + chalk.yellow(" arrayDimension               : ")} [${this.arrayDimensions.join(",").toString()} ]`);
     }
 }
 /**
@@ -393,7 +362,7 @@ function VariableOrVariableType_toString(options) {
  * `browseName`, nearest supertype first; none when `type` is not a type
  */
 function _base_declarations_of(type, browseName) {
-    if (type.nodeClass !== node_opcua_data_model_1.NodeClass.ObjectType && type.nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
+    if (type.nodeClass !== NodeClass.ObjectType && type.nodeClass !== NodeClass.VariableType) {
         return [];
     }
     const result = [];
@@ -415,7 +384,7 @@ function _base_declarations_of(type, browseName) {
  */
 function _register_existing_children(original, cloned, extraInfo) {
     extraInfo.registerClonedObject({ originalNode: original, clonedNode: cloned });
-    for (const ref of original.findReferencesEx("Aggregates", node_opcua_data_model_1.BrowseDirection.Forward)) {
+    for (const ref of original.findReferencesEx("Aggregates", BrowseDirection.Forward)) {
         const child = ref.node;
         if (!child)
             continue;
@@ -433,7 +402,7 @@ function _register_existing_children(original, cloned, extraInfo) {
  */
 function _merge_base_declaration(baseDeclaration, clonedNode, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     // c8 ignore next
-    doTrace && traceLog(extraInfo.pad(), "merging base declaration ", (0, node_opcua_address_space_base_1.fullPath2)(baseDeclaration), " into ", (0, node_opcua_address_space_base_1.fullPath2)(clonedNode));
+    doTrace && traceLog(extraInfo.pad(), "merging base declaration ", fullPath2(baseDeclaration), " into ", fullPath2(clonedNode));
     _register_existing_children(baseDeclaration, clonedNode, extraInfo);
     _clone_hierarchical_references(baseDeclaration, clonedNode, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
@@ -443,39 +412,39 @@ function _merge_base_declaration(baseDeclaration, clonedNode, copyAlsoModellingR
  */
 function _clone_collection_new(nodeToClone, newParent, collectionRef, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     const namespace = newParent.namespace;
-    extraInfo = extraInfo || new node_opcua_address_space_base_1.CloneHelper();
+    extraInfo = extraInfo || new CloneHelper();
     const addressSpace = newParent.addressSpace;
-    (0, node_opcua_assert_1.assert)(!optionalFilter || (typeof optionalFilter.shouldKeep === "function" && typeof optionalFilter.filterFor === "function"));
+    assert(!optionalFilter || (typeof optionalFilter.shouldKeep === "function" && typeof optionalFilter.filterFor === "function"));
     for (const reference of collectionRef) {
-        const node = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+        const node = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
         // ensure node is of the correct type,
         // it may happen that the xml nodeset2 file was malformed
         // c8 ignore next
         if (typeof node.clone !== "function") {
-            warningLog(chalk_1.default.red("Warning : cannot clone node ") +
-                (0, node_opcua_address_space_base_1.fullPath2)(node) +
+            warningLog(chalk.red("Warning : cannot clone node ") +
+                fullPath2(node) +
                 " of class " +
-                node_opcua_data_model_1.NodeClass[node.nodeClass].toString() +
+                NodeClass[node.nodeClass].toString() +
                 " while cloning " +
-                (0, node_opcua_address_space_base_1.fullPath2)(newParent));
+                fullPath2(newParent));
             continue;
         }
         if (node && !node.modellingRule) {
             // c8 ignore next
-            doTrace && traceLog(extraInfo.pad(), "skipping  with no modelling rule", (0, node_opcua_address_space_base_1.fullPath2)(node));
+            doTrace && traceLog(extraInfo.pad(), "skipping  with no modelling rule", fullPath2(node));
             // those node stays in the Type
             continue; // skip this node
         }
         if (optionalFilter && node && !optionalFilter.shouldKeep(node)) {
             // c8 ignore next
-            doTrace && traceLog(extraInfo.pad(), "skipping optional that doesn't appear in the filter", (0, node_opcua_address_space_base_1.fullPath2)(node));
+            doTrace && traceLog(extraInfo.pad(), "skipping optional that doesn't appear in the filter", fullPath2(node));
             continue; // skip this node
         }
         const key = `${newParent.nodeId.toString()}(${newParent.browseName.toString()})/${node.browseName.toString()}`;
         if (browseNameMap?.has(key)) {
             // a same-named child was cloned already, from a nearer declaration: this one is a
             // base declaration of it, merge what it adds
-            doTrace && traceLog(extraInfo.pad(), "node with same browseName already cloned, merging", (0, node_opcua_address_space_base_1.fullPath2)(node), "key=", key);
+            doTrace && traceLog(extraInfo.pad(), "node with same browseName already cloned, merging", fullPath2(node), "key=", key);
             const existing = newParent.getChildByName(node.browseName);
             if (existing) {
                 _merge_base_declaration(node, existing, copyAlsoModellingRules, optionalFilter.filterFor(existing), extraInfo, new Set());
@@ -487,7 +456,7 @@ function _clone_collection_new(nodeToClone, newParent, collectionRef, copyAlsoMo
         // assert(reference.referenceType instanceof NodeId, "" + reference.referenceType.toString());
         const options = {
             namespace,
-            references: [new reference_impl_js_1.ReferenceImpl({ referenceType: reference.referenceType, isForward: false, nodeId: newParent.nodeId })],
+            references: [new ReferenceImpl({ referenceType: reference.referenceType, isForward: false, nodeId: newParent.nodeId })],
             copyAlsoModellingRules,
             baseDeclarations: _base_declarations_of(nodeToClone, node.browseName)
         };
@@ -495,11 +464,11 @@ function _clone_collection_new(nodeToClone, newParent, collectionRef, copyAlsoMo
         if (alreadyCloned) {
             // c8 ignore next
             doTrace &&
-                traceLog(extraInfo.pad(), "node ", (0, node_opcua_address_space_base_1.fullPath2)(node), "already cloned as", (0, node_opcua_address_space_base_1.fullPath2)(alreadyCloned), "\nnode to clone =", (0, node_opcua_address_space_base_1.fullPath2)(nodeToClone), "\nnew parent   =", (0, node_opcua_address_space_base_1.fullPath2)(newParent));
+                traceLog(extraInfo.pad(), "node ", fullPath2(node), "already cloned as", fullPath2(alreadyCloned), "\nnode to clone =", fullPath2(nodeToClone), "\nnew parent   =", fullPath2(newParent));
             // this parent, not any parent: a shared child may already hang under another one
             const hasReference = alreadyCloned
                 .findReferences(reference.referenceType, false)
-                .some((r) => (0, node_opcua_nodeid_1.sameNodeId)(r.nodeId, newParent.nodeId));
+                .some((r) => sameNodeId(r.nodeId, newParent.nodeId));
             if (!hasReference) {
                 alreadyCloned.addReference({
                     referenceType: reference.referenceType,
@@ -509,19 +478,19 @@ function _clone_collection_new(nodeToClone, newParent, collectionRef, copyAlsoMo
             }
             else {
                 // c8 ignore next
-                doTrace && traceLog(extraInfo.pad(), "reference to node  ", (0, node_opcua_address_space_base_1.fullPath2)(alreadyCloned), " already exists !");
+                doTrace && traceLog(extraInfo.pad(), "reference to node  ", fullPath2(alreadyCloned), " already exists !");
             }
         }
         else {
             // c8 ignore next
             doTrace &&
-                traceLog(extraInfo.pad(), "cloning => ", reference.referenceType.toString({ addressSpace }), "=>", (0, node_opcua_address_space_base_1.fullPath2)(node), chalk_1.default.magentaBright(node.typeDefinitionObj?.browseName.toString()));
+                traceLog(extraInfo.pad(), "cloning => ", reference.referenceType.toString({ addressSpace }), "=>", fullPath2(node), chalk.magentaBright(node.typeDefinitionObj?.browseName.toString()));
             extraInfo.level += 1;
             const clonedNode = node.clone(options, optionalFilter, extraInfo);
             extraInfo.level -= 1;
             // c8 ignore next
             doTrace &&
-                traceLog(extraInfo.pad(), "cloned => ", (0, node_opcua_address_space_base_1.fullPath2)(node), "", extraInfo.pad(), "    original nodeId", node.nodeId.toString(), "", extraInfo.pad(), "    cloned   nodeId", clonedNode.nodeId.toString(), `${(0, node_opcua_address_space_base_1.fullPath2)(clonedNode)}`);
+                traceLog(extraInfo.pad(), "cloned => ", fullPath2(node), "", extraInfo.pad(), "    original nodeId", node.nodeId.toString(), "", extraInfo.pad(), "    cloned   nodeId", clonedNode.nodeId.toString(), `${fullPath2(clonedNode)}`);
             // also clone or instantiate interface members that may be required in the optionals
             extraInfo.level++;
             _cloneInterface(nodeToClone, newParent, node, optionalFilter, extraInfo, browseNameMap);
@@ -534,8 +503,8 @@ function _clone_collection_new(nodeToClone, newParent, collectionRef, copyAlsoMo
 function _extractInterfaces2(typeDefinitionNode, extraInfo) {
     if (!typeDefinitionNode ||
         (typeDefinitionNode.nodeId.namespace === 0 &&
-            (typeDefinitionNode.nodeId.value === node_opcua_constants_1.ObjectTypeIds.BaseObjectType ||
-                typeDefinitionNode.nodeId.value === node_opcua_constants_1.VariableTypeIds.BaseVariableType))) {
+            (typeDefinitionNode.nodeId.value === ObjectTypeIds.BaseObjectType ||
+                typeDefinitionNode.nodeId.value === VariableTypeIds.BaseVariableType))) {
         return [];
     }
     const addressSpace = typeDefinitionNode.addressSpace;
@@ -555,7 +524,7 @@ function _extractInterfaces2(typeDefinitionNode, extraInfo) {
     // IMachineTagNameplateType            -subtypeOf-> ITagNameplateType
     // IMachineVendorNamePlateType         -subtypeOf-> IMachineryItemVendorNamePlateType
     // IMachineryItemVendorNamePlateType   -subtypeOf-> IVendorNameplateType
-    const interfacesRef = typeDefinitionNode.findReferencesEx("HasInterface", node_opcua_data_model_1.BrowseDirection.Forward);
+    const interfacesRef = typeDefinitionNode.findReferencesEx("HasInterface", BrowseDirection.Forward);
     const interfaces = interfacesRef.map((r) => addressSpace.findNode(r.nodeId));
     const baseInterfaces = [];
     for (const iface of interfaces) {
@@ -582,16 +551,16 @@ function _extractInterfaces2(typeDefinitionNode, extraInfo) {
     // c8 ignore next
     doTrace &&
         deduplicatedInterfaces.length &&
-        traceLog(extraInfo.pad(), chalk_1.default.yellow("Interface for ", typeDefinitionNode.browseName.toString()), "=", deduplicatedInterfaces.map((x) => x.browseName.toString()).join(" "));
+        traceLog(extraInfo.pad(), chalk.yellow("Interface for ", typeDefinitionNode.browseName.toString()), "=", deduplicatedInterfaces.map((x) => x.browseName.toString()).join(" "));
     return deduplicatedInterfaces;
 }
 function _cloneInterface(nodeToClone, _newParent, node, optionalFilter, extraInfo, browseNameMap) {
     // c8 ignore next
     doTrace &&
-        traceLog(extraInfo?.pad(), chalk_1.default.green("-------------------- now cloning interfaces of ", node.browseName.toString(), node.nodeId.toString()));
-    extraInfo = extraInfo || new node_opcua_address_space_base_1.CloneHelper();
+        traceLog(extraInfo?.pad(), chalk.green("-------------------- now cloning interfaces of ", node.browseName.toString(), node.nodeId.toString()));
+    extraInfo = extraInfo || new CloneHelper();
     const addressSpace = node.addressSpace;
-    if (node.nodeClass !== node_opcua_data_model_1.NodeClass.Object && node.nodeClass !== node_opcua_data_model_1.NodeClass.Variable) {
+    if (node.nodeClass !== NodeClass.Object && node.nodeClass !== NodeClass.Variable) {
         return;
     }
     const typeDefinitionNode = node.typeDefinitionObj;
@@ -603,70 +572,70 @@ function _cloneInterface(nodeToClone, _newParent, node, optionalFilter, extraInf
         // c8 ignore next
         doTrace &&
             false &&
-            traceLog(extraInfo.pad(), chalk_1.default.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
+            traceLog(extraInfo.pad(), chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
         return;
     }
     // c8 ignore next
-    doTrace && traceLog(extraInfo?.pad(), chalk_1.default.green("-------------------- interfaces are  ", interfaces.length));
+    doTrace && traceLog(extraInfo?.pad(), chalk.green("-------------------- interfaces are  ", interfaces.length));
     const localFilter = optionalFilter.filterFor(node);
     for (const iface of interfaces) {
-        const aggregates = iface.findReferencesEx("Aggregates", node_opcua_data_model_1.BrowseDirection.Forward);
+        const aggregates = iface.findReferencesEx("Aggregates", BrowseDirection.Forward);
         if (aggregates.length === 0)
             continue;
         // c8 ignore next
         doTrace &&
-            traceLog(extraInfo.pad(), chalk_1.default.magentaBright("   interface ", iface.browseName.toString()), `\n${extraInfo?.pad()}`, aggregates.map((r) => r.toString({ addressSpace })).join(`\n${extraInfo?.pad()}`));
+            traceLog(extraInfo.pad(), chalk.magentaBright("   interface ", iface.browseName.toString()), `\n${extraInfo?.pad()}`, aggregates.map((r) => r.toString({ addressSpace })).join(`\n${extraInfo?.pad()}`));
         _clone_collection_new(nodeToClone, node, aggregates, false, localFilter, extraInfo, browseNameMap);
     }
 }
 function __clone_organizes_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     // find all references that derives from the Organizes
-    const organizedRef = nodeToClone.findReferencesEx("Organizes", node_opcua_data_model_1.BrowseDirection.Forward);
+    const organizedRef = nodeToClone.findReferencesEx("Organizes", BrowseDirection.Forward);
     if (organizedRef.length === 0)
         return;
     _clone_collection_new(nodeToClone, newParent, organizedRef, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
 function __clone_children_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     // find all references that derives from the Aggregates
-    const aggregatesRef = nodeToClone.findReferencesEx("Aggregates", node_opcua_data_model_1.BrowseDirection.Forward);
+    const aggregatesRef = nodeToClone.findReferencesEx("Aggregates", BrowseDirection.Forward);
     if (aggregatesRef.length === 0)
         return;
     _clone_collection_new(nodeToClone, newParent, aggregatesRef, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
 function __clone_interfaces_related_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     // find all references that derives from the HasInterface
-    const hasInterfaceRef = nodeToClone.findReferencesEx("HasInterface", node_opcua_data_model_1.BrowseDirection.Forward);
+    const hasInterfaceRef = nodeToClone.findReferencesEx("HasInterface", BrowseDirection.Forward);
     if (hasInterfaceRef.length === 0)
         return;
     for (const ref of hasInterfaceRef) {
-        let typeDefinitionNode = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(nodeToClone.addressSpace, ref);
+        let typeDefinitionNode = ReferenceImpl.resolveReferenceNode(nodeToClone.addressSpace, ref);
         if (!typeDefinitionNode) {
             continue;
         }
         if (doTrace)
-            traceLog(extraInfo?.pad(), chalk_1.default.blueBright(newParent.browseName.toString(), "-----> Exploring interface ", typeDefinitionNode.browseName.toString()));
+            traceLog(extraInfo?.pad(), chalk.blueBright(newParent.browseName.toString(), "-----> Exploring interface ", typeDefinitionNode.browseName.toString()));
         while (typeDefinitionNode) {
             // c8 ignore next
             doTrace &&
-                traceLog(extraInfo?.pad(), chalk_1.default.blueBright(newParent.browseName.toString(), "-----> Exploring ", typeDefinitionNode.browseName.toString()));
+                traceLog(extraInfo?.pad(), chalk.blueBright(newParent.browseName.toString(), "-----> Exploring ", typeDefinitionNode.browseName.toString()));
             __clone_children_references(typeDefinitionNode, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
             typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
         }
     }
 }
-function _clone_hierarchical_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
+export function _clone_hierarchical_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     __clone_children_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
     __clone_organizes_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
     //   __clone_interfaces_related_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
-function _clone_non_hierarchical_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
+export function _clone_non_hierarchical_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap) {
     // clone only some non hierarchical_references that we do want to clone
     // such as:
     //   HasSubStateMachine
     //   (may be other as well later ... to do )
-    (0, node_opcua_assert_1.assert)(newParent instanceof base_node_impl_js_1.BaseNodeImpl);
+    assert(newParent instanceof BaseNodeImpl);
     // find all reference that derives from the HasSubStateMachine
-    const references = nodeToClone.findReferencesEx("HasSubStateMachine", node_opcua_data_model_1.BrowseDirection.Forward);
+    const references = nodeToClone.findReferencesEx("HasSubStateMachine", BrowseDirection.Forward);
     if (references.length === 0)
         return;
     _clone_collection_new(nodeToClone, newParent, references, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
@@ -675,10 +644,10 @@ function _clone_non_hierarchical_references(nodeToClone, newParent, copyAlsoMode
 
  * @private
  */
-function _clone(originalNode, Constructor, options, optionalFilter, extraInfo) {
-    (0, node_opcua_assert_1.assert)(typeof Constructor === "function");
-    (0, node_opcua_assert_1.assert)(options !== null && typeof options === "object");
-    (0, node_opcua_assert_1.assert)(!extraInfo || (extraInfo !== null && typeof extraInfo === "object" && typeof extraInfo.registerClonedObject === "function"));
+export function _clone(originalNode, Constructor, options, optionalFilter, extraInfo) {
+    assert(typeof Constructor === "function");
+    assert(options !== null && typeof options === "object");
+    assert(!extraInfo || (extraInfo !== null && typeof extraInfo === "object" && typeof extraInfo.registerClonedObject === "function"));
     const namespace = options.namespace;
     const constructorOptions = {
         ...options,
@@ -689,32 +658,32 @@ function _clone(originalNode, Constructor, options, optionalFilter, extraInfo) {
         nodeClass: originalNode.nodeClass
     };
     constructorOptions.references = options.references || [];
-    if (originalNode.nodeClass === node_opcua_data_model_1.NodeClass.Variable || originalNode.nodeClass === node_opcua_data_model_1.NodeClass.Object) {
+    if (originalNode.nodeClass === NodeClass.Variable || originalNode.nodeClass === NodeClass.Object) {
         const voThis = originalNode;
         if (voThis.typeDefinition) {
-            constructorOptions.references.push(new reference_impl_js_1.ReferenceImpl({
+            constructorOptions.references.push(new ReferenceImpl({
                 isForward: true,
                 nodeId: voThis.typeDefinition,
-                referenceType: (0, node_opcua_nodeid_1.resolveNodeId)("HasTypeDefinition")
+                referenceType: resolveNodeId("HasTypeDefinition")
             }));
         }
     }
     if (!constructorOptions.modellingRule) {
         if (originalNode.modellingRule && options.copyAlsoModellingRules) {
             const modellingRuleNode = originalNode.findReferencesAsObject("HasModellingRule", true)[0];
-            (0, node_opcua_assert_1.assert)(modellingRuleNode);
-            constructorOptions.references.push(new reference_impl_js_1.ReferenceImpl({
+            assert(modellingRuleNode);
+            constructorOptions.references.push(new ReferenceImpl({
                 isForward: true,
                 nodeId: modellingRuleNode.nodeId,
-                referenceType: (0, node_opcua_nodeid_1.resolveNodeId)("HasModellingRule")
+                referenceType: resolveNodeId("HasModellingRule")
             }));
         }
     }
     else {
-        (0, namespace_private_js_1.UANamespace_process_modelling_rule)(constructorOptions.references, constructorOptions.modellingRule);
+        UANamespace_process_modelling_rule(constructorOptions.references, constructorOptions.modellingRule);
     }
     constructorOptions.nodeId = namespace.constructNodeId(constructorOptions);
-    (0, node_opcua_assert_1.assert)(constructorOptions.nodeId instanceof node_opcua_nodeid_1.NodeId);
+    assert(constructorOptions.nodeId instanceof NodeId);
     const clonedNode = new Constructor(constructorOptions);
     originalNode.addressSpace._register(clonedNode);
     extraInfo.registerClonedObject({
@@ -733,7 +702,7 @@ function _clone(originalNode, Constructor, options, optionalFilter, extraInfo) {
         for (const baseDeclaration of options.baseDeclarations || []) {
             _merge_base_declaration(baseDeclaration, clonedNode, options.copyAlsoModellingRules, newFilter, extraInfo, browseNameMap);
         }
-        if (originalNode.nodeClass === node_opcua_data_model_1.NodeClass.Object || originalNode.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+        if (originalNode.nodeClass === NodeClass.Object || originalNode.nodeClass === NodeClass.Variable) {
             let typeDefinitionNode = originalNode.typeDefinitionObj;
             extraInfo.pushContext({
                 clonedParent: clonedNode,
@@ -742,7 +711,7 @@ function _clone(originalNode, Constructor, options, optionalFilter, extraInfo) {
             while (typeDefinitionNode) {
                 // c8 ignore next
                 doTrace &&
-                    traceLog(extraInfo?.pad(), chalk_1.default.blueBright(originalNode.browseName.toString(), "-----> Exploring ", typeDefinitionNode.browseName.toString()));
+                    traceLog(extraInfo?.pad(), chalk.blueBright(originalNode.browseName.toString(), "-----> Exploring ", typeDefinitionNode.browseName.toString()));
                 _clone_hierarchical_references(typeDefinitionNode, clonedNode, options.copyAlsoModellingRules, newFilter, extraInfo, browseNameMap);
                 typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
             }
@@ -781,9 +750,9 @@ function _add(_childByNameMap, reference) {
 function sameRef(a, b) {
     if (a.isForward !== b.isForward)
         return false;
-    if (!(0, node_opcua_nodeid_1.sameNodeId)(a.nodeId, b.nodeId))
+    if (!sameNodeId(a.nodeId, b.nodeId))
         return false;
-    if (!(0, node_opcua_nodeid_1.sameNodeId)(a.referenceType, b.referenceType))
+    if (!sameNodeId(a.referenceType, b.referenceType))
         return false;
     return true;
 }
@@ -812,12 +781,12 @@ function _remove(_childByNameMap, reference) {
 /**
  * keep an existing child index in step with a forward reference just added to `node`
  */
-function _handle_HierarchicalReference(node, reference) {
+export function _handle_HierarchicalReference(node, reference) {
     const _private = BaseNode_getPrivate(node);
     if (!reference.isForward || !_private._childByNameMap)
         return;
     const addressSpace = node.addressSpace;
-    const referenceType = reference_impl_js_1.ReferenceImpl.resolveReferenceType(addressSpace, reference);
+    const referenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference);
     const hierarchicalReferences = addressSpace.findReferenceType(hierarchicalReferences_ReferenceTypeNodeId);
     if (!referenceType || !hierarchicalReferences) {
         _private._childByNameMapIncomplete = true;
@@ -834,7 +803,7 @@ function _handle_HierarchicalReference(node, reference) {
     }
     if (!isHierarchical)
         return;
-    reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+    ReferenceImpl.resolveReferenceNode(addressSpace, reference);
     if (!_add(_private._childByNameMap, reference)) {
         _private._childByNameMapIncomplete = true;
     }
@@ -847,11 +816,11 @@ function _handle_HierarchicalReference(node, reference) {
  * resolved: a lookup then gets a transient map and the next one rebuilds. Before namespace 0 has
  * loaded `HierarchicalReferences` nothing can be hierarchical yet and the map is empty.
  */
-function _get_HierarchicalReference(node) {
+export function _get_HierarchicalReference(node) {
     const _private = BaseNode_getPrivate(node);
     if (_private._childByNameMap &&
         !_private._childByNameMapIncomplete &&
-        _private._childByNameMapVersion === reference_type_version_js_1.referenceTypeVersion.count) {
+        _private._childByNameMapVersion === referenceTypeVersion.count) {
         return _private._childByNameMap;
     }
     const addressSpace = node.addressSpace;
@@ -861,15 +830,15 @@ function _get_HierarchicalReference(node) {
         return map;
     }
     let complete = true;
-    for (const reference of node.findReferencesEx(hierarchicalReferences, node_opcua_data_model_1.BrowseDirection.Forward)) {
-        reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+    for (const reference of node.findReferencesEx(hierarchicalReferences, BrowseDirection.Forward)) {
+        ReferenceImpl.resolveReferenceNode(addressSpace, reference);
         if (!_add(map, reference)) {
             complete = false;
         }
     }
     if (complete && !addressSpace.suspendBackReference) {
         _private._childByNameMap = map;
-        _private._childByNameMapVersion = reference_type_version_js_1.referenceTypeVersion.count;
+        _private._childByNameMapVersion = referenceTypeVersion.count;
     }
     else {
         _private._childByNameMap = undefined;
@@ -877,15 +846,15 @@ function _get_HierarchicalReference(node) {
     _private._childByNameMapIncomplete = false;
     return map;
 }
-function _remove_HierarchicalReference(node, reference) {
+export function _remove_HierarchicalReference(node, reference) {
     const _private = BaseNode_getPrivate(node);
     if (_private._childByNameMap && reference.isForward) {
         const addressSpace = node.addressSpace;
-        const referenceType = reference_impl_js_1.ReferenceImpl.resolveReferenceType(addressSpace, reference);
+        const referenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference);
         if (referenceType) {
             const HierarchicalReferencesType = addressSpace.findReferenceType(hierarchicalReferences_ReferenceTypeNodeId);
             if (HierarchicalReferencesType && referenceType.isSubtypeOf(HierarchicalReferencesType)) {
-                reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+                ReferenceImpl.resolveReferenceNode(addressSpace, reference);
                 _remove(_private._childByNameMap, reference);
             }
         }
@@ -893,44 +862,44 @@ function _remove_HierarchicalReference(node, reference) {
 }
 function _makeReferenceDescription(addressSpace, reference, resultMask) {
     const isForward = reference.isForward;
-    const referenceTypeId = reference_impl_js_1.ReferenceImpl.resolveReferenceType(addressSpace, reference).nodeId;
-    (0, node_opcua_assert_1.assert)(referenceTypeId instanceof node_opcua_nodeid_1.NodeId);
-    const obj = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, reference);
+    const referenceTypeId = ReferenceImpl.resolveReferenceType(addressSpace, reference).nodeId;
+    assert(referenceTypeId instanceof NodeId);
+    const obj = ReferenceImpl.resolveReferenceNode(addressSpace, reference);
     let data = {};
     if (!obj) {
         // cannot find reference node
         data = {
             isForward,
             nodeId: reference.nodeId,
-            referenceTypeId: resultMask & node_opcua_data_model_1.ResultMask.ReferenceType ? referenceTypeId : null,
+            referenceTypeId: resultMask & ResultMask.ReferenceType ? referenceTypeId : null,
             typeDefinition: undefined
         };
     }
     else {
         const obj2 = obj;
-        const objOrVar = obj2.nodeClass === node_opcua_data_model_1.NodeClass.Object || obj2.nodeClass === node_opcua_data_model_1.NodeClass.Variable ? obj2 : null;
-        (0, node_opcua_assert_1.assert)(reference.nodeId, " obj.nodeId");
+        const objOrVar = obj2.nodeClass === NodeClass.Object || obj2.nodeClass === NodeClass.Variable ? obj2 : null;
+        assert(reference.nodeId, " obj.nodeId");
         data = {
-            browseName: resultMask & node_opcua_data_model_1.ResultMask.BrowseName ? (0, node_opcua_data_model_1.coerceQualifiedName)(obj.browseName) : null,
-            displayName: resultMask & node_opcua_data_model_1.ResultMask.DisplayName ? (0, node_opcua_data_model_1.coerceLocalizedText)(obj.displayName[0]) : null,
-            isForward: resultMask & node_opcua_data_model_1.ResultMask.IsForward ? isForward : false,
-            nodeClass: resultMask & node_opcua_data_model_1.ResultMask.NodeClass ? obj.nodeClass : node_opcua_data_model_1.NodeClass.Unspecified,
+            browseName: resultMask & ResultMask.BrowseName ? coerceQualifiedName(obj.browseName) : null,
+            displayName: resultMask & ResultMask.DisplayName ? coerceLocalizedText(obj.displayName[0]) : null,
+            isForward: resultMask & ResultMask.IsForward ? isForward : false,
+            nodeClass: resultMask & ResultMask.NodeClass ? obj.nodeClass : NodeClass.Unspecified,
             nodeId: obj.nodeId,
-            referenceTypeId: resultMask & node_opcua_data_model_1.ResultMask.ReferenceType ? referenceTypeId : null,
-            typeDefinition: resultMask & node_opcua_data_model_1.ResultMask.TypeDefinition ? objOrVar?.typeDefinition : undefined
+            referenceTypeId: resultMask & ResultMask.ReferenceType ? referenceTypeId : null,
+            typeDefinition: resultMask & ResultMask.TypeDefinition ? objOrVar?.typeDefinition : undefined
         };
     }
     if (data.typeDefinition === null) {
-        data.typeDefinition = node_opcua_nodeid_1.ExpandedNodeId.nullNodeId;
+        data.typeDefinition = ExpandedNodeId.nullNodeId;
     }
-    const referenceDescription = new node_opcua_types_1.ReferenceDescription(data);
+    const referenceDescription = new ReferenceDescription(data);
     return referenceDescription;
 }
-function _constructReferenceDescription(addressSpace, references, resultMask) {
-    (0, node_opcua_assert_1.assert)(Array.isArray(references));
+export function _constructReferenceDescription(addressSpace, references, resultMask) {
+    assert(Array.isArray(references));
     return references.map((reference) => _makeReferenceDescription(addressSpace, reference, resultMask));
 }
-function BaseNode_remove_backward_reference(reference) {
+export function BaseNode_remove_backward_reference(reference) {
     const _private = BaseNode_getPrivate(this);
     _remove_HierarchicalReference(this, reference);
     const h = reference.key(this.addressSpace);
@@ -949,17 +918,17 @@ function BaseNode_remove_backward_reference(reference) {
  * a reference added to or removed from a reference type may move it in the hierarchy (a
  * HasSubtype link made at runtime): every memo built against the hierarchy is then stale
  */
-function noteReferenceTypeChange(node, reference) {
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.ReferenceType) {
-        reference_type_version_js_1.referenceTypeVersion.count += 1;
+export function noteReferenceTypeChange(node, reference) {
+    if (node.nodeClass === NodeClass.ReferenceType) {
+        referenceTypeVersion.count += 1;
     }
-    if (reference && (0, node_opcua_nodeid_1.sameNodeId)(reference.referenceType, hasSubtype_ReferenceTypeNodeId)) {
+    if (reference && sameNodeId(reference.referenceType, hasSubtype_ReferenceTypeNodeId)) {
         // the answer of isSubtypeOf may have changed for every type below this node
-        reference_type_version_js_1.typeHierarchyVersion.count += 1;
+        typeHierarchyVersion.count += 1;
     }
 }
-const hasSubtype_ReferenceTypeNodeId = (0, node_opcua_nodeid_1.resolveNodeId)("HasSubtype");
-function BaseNode_add_backward_reference(reference) {
+const hasSubtype_ReferenceTypeNodeId = resolveNodeId("HasSubtype");
+export function BaseNode_add_backward_reference(reference) {
     const _private = BaseNode_getPrivate(this);
     const h = reference.key(this.addressSpace);
     // c8 ignore next
@@ -983,7 +952,7 @@ function BaseNode_add_backward_reference(reference) {
         }
         return;
     }
-    if (!(0, base_node_impl_js_1.getReferenceType)(reference)) {
+    if (!getReferenceType(reference)) {
         const _stop_here = 1;
     }
     //  assert(reference._referenceType instanceof ReferenceType);