node-opcua-address-space 2.183.1 → 2.184.0

package/dist/impl/nodeset_tools/nodeset_to_records.js

@@ -1,48 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeIdType = exports.makeTypeXsd = exports.DataTypeIds = exports.NodesetExportError = exports.sortByNodeId = void 0;
-exports.namespaceToWalkEvents = namespaceToWalkEvents;
-exports.nodeToWalkEvents = nodeToWalkEvents;
-exports.namespaceToRecords = namespaceToRecords;
-exports.namespaceToImage = namespaceToImage;
-const node_opcua_basic_types_1 = require("node-opcua-basic-types");
-const node_opcua_constants_1 = require("node-opcua-constants");
-Object.defineProperty(exports, "DataTypeIds", { enumerable: true, get: function () { return node_opcua_constants_1.DataTypeIds; } });
-const node_opcua_data_access_1 = require("node-opcua-data-access");
-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");
-Object.defineProperty(exports, "NodeIdType", { enumerable: true, get: function () { return node_opcua_nodeid_1.NodeIdType; } });
-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 xml_writer_1 = __importDefault(require("xml-writer"));
-const decode_xml_extension_object_js_1 = require("../../api/loader/decode_xml_extension_object.js");
-const nodeset_image_js_1 = require("../../api/loader/nodeset_image.js");
-const nodeset_record_js_1 = require("../../api/loader/nodeset_record.js");
-const nodeset_source_js_1 = require("../../api/loader/nodeset_source.js");
-const base_node_impl_js_1 = require("../base_node_impl.js");
-const namespace_impl_js_1 = require("../namespace_impl.js");
-const reference_impl_js_1 = require("../reference_impl.js");
-const ua_method_impl_js_1 = require("../ua_method_impl.js");
-const ua_object_impl_js_1 = require("../ua_object_impl.js");
-const ua_variable_impl_js_1 = require("../ua_variable_impl.js");
-const construct_namespace_dependency_js_1 = require("./construct_namespace_dependency.js");
-const nodeset_to_xml_js_1 = require("./nodeset_to_xml.js");
-Object.defineProperty(exports, "makeTypeXsd", { enumerable: true, get: function () { return nodeset_to_xml_js_1.makeTypeXsd; } });
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("nodeset_to_records");
+import { AttributeIds, coerceInt64 } from "node-opcua-basic-types";
+import { DataTypeIds, ObjectIds, VariableIds } from "node-opcua-constants";
+import { Range } from "node-opcua-data-access";
+import { BrowseDirection, LocalizedText, makeAccessLevelFlag, makeNodeClassMask, makeResultMask, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { make_warningLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { Argument, BrowseDescription, EnumValueType, EUInformation, StructureType } from "node-opcua-types";
+import { isNullOrUndefined } from "node-opcua-utils";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import XMLWriter from "xml-writer";
+import { makeDefinitionMap } from "../../api/loader/decode_xml_extension_object.js";
+import { NodesetImageWriter } from "../../api/loader/nodeset_image.js";
+import { XmlExtensionObjectFragment } from "../../api/loader/nodeset_record.js";
+import { sha256Hex } from "../../api/loader/nodeset_source.js";
+import { getReferenceType } from "../base_node_impl.js";
+import { NamespaceImpl } from "../namespace_impl.js";
+import { ReferenceImpl } from "../reference_impl.js";
+import { UAMethodImpl } from "../ua_method_impl.js";
+import { UAObjectImpl } from "../ua_object_impl.js";
+import { UAVariableImpl } from "../ua_variable_impl.js";
+import { _constructNamespaceTranslationTable, constructNamespaceDependency, constructNamespacePriorityTable } from "./construct_namespace_dependency.js";
+import { _dumpVariantExtensionObjectValue_Body, coerceInt64ToInt32, initXmlWriterEx, makeTypeXsd, sortByBrowseName } from "./nodeset_to_xml.js";
+const warningLog = make_warningLog("nodeset_to_records");
 /** the order the exporters list nodes in: by NodeId string, what the XML writer sorted by all along */
-const sortByNodeId = (a, b) => a.nodeId.toString() < b.nodeId.toString() ? -1 : 1;
-exports.sortByNodeId = sortByNodeId;
-const currentReadFlag = (0, node_opcua_data_model_1.makeAccessLevelFlag)("CurrentRead");
+export const sortByNodeId = (a, b) => a.nodeId.toString() < b.nodeId.toString() ? -1 : 1;
+const currentReadFlag = makeAccessLevelFlag("CurrentRead");
 /** what the exporter cannot turn into a record: named by the node so that the caller can act */
-class NodesetExportError extends Error {
+export class NodesetExportError extends Error {
 }
-exports.NodesetExportError = NodesetExportError;
 class RecordExporter {
     namespace;
     addressSpace;
@@ -62,12 +47,12 @@ class RecordExporter {
         this.namespace = namespace;
         const addressSpace = namespace.addressSpace;
         this.addressSpace = addressSpace;
-        this.priorityTable = (0, construct_namespace_dependency_js_1.constructNamespacePriorityTable)(addressSpace).priorityTable;
-        this.dependency = (0, construct_namespace_dependency_js_1.constructNamespaceDependency)(namespace, this.priorityTable);
-        this.translationTable = (0, construct_namespace_dependency_js_1._constructNamespaceTranslationTable)(this.dependency, namespace);
+        this.priorityTable = constructNamespacePriorityTable(addressSpace).priorityTable;
+        this.dependency = constructNamespaceDependency(namespace, this.priorityTable);
+        this.translationTable = _constructNamespaceTranslationTable(this.dependency, namespace);
         this.sortedDependencies = [...this.dependency].sort((a, b) => (this.translationTable.get(a.index) ?? 0) > (this.translationTable.get(b.index) ?? 0) ? 1 : -1);
-        const namespaceArrayNode = addressSpace.findNode(node_opcua_constants_1.VariableIds.Server_NamespaceArray);
-        this.namespaceArray = namespaceArrayNode ? namespaceArrayNode.readAttribute(null, node_opcua_basic_types_1.AttributeIds.Value).value.value : [];
+        const namespaceArrayNode = addressSpace.findNode(VariableIds.Server_NamespaceArray);
+        this.namespaceArray = namespaceArrayNode ? namespaceArrayNode.readAttribute(null, AttributeIds.Value).value.value : [];
         this.namespacesMap = {
             "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd": "",
             "http://opcfoundation.org/UA/2008/02/Types.xsd": "uax",
@@ -78,7 +63,7 @@ class RecordExporter {
                 continue;
             this.namespacesMap[dependency.namespaceUri] = `ns${this.translationTable.get(dependency.index)}`;
         }
-        this.definitionMap = (0, decode_xml_extension_object_js_1.makeDefinitionMap)(addressSpace);
+        this.definitionMap = makeDefinitionMap(addressSpace);
     }
     // #region ids
     t(nodeId) {
@@ -86,13 +71,13 @@ class RecordExporter {
         if (namespace === undefined) {
             throw new NodesetExportError(`namespace ${nodeId.namespace} of ${nodeId.toString()} is not in the dependency set of ${this.namespace.namespaceUri}`);
         }
-        if (nodeId instanceof node_opcua_nodeid_1.ExpandedNodeId) {
-            return new node_opcua_nodeid_1.ExpandedNodeId(nodeId.identifierType, nodeId.value, namespace, nodeId.namespaceUri, nodeId.serverIndex);
+        if (nodeId instanceof ExpandedNodeId) {
+            return new ExpandedNodeId(nodeId.identifierType, nodeId.value, namespace, nodeId.namespaceUri, nodeId.serverIndex);
         }
-        return new node_opcua_nodeid_1.NodeId(nodeId.identifierType, nodeId.value, namespace);
+        return new NodeId(nodeId.identifierType, nodeId.value, namespace);
     }
     tq(browseName) {
-        return new node_opcua_data_model_1.QualifiedName({ namespaceIndex: this.translationTable.get(browseName.namespaceIndex), name: browseName.name });
+        return new QualifiedName({ namespaceIndex: this.translationTable.get(browseName.namespaceIndex), name: browseName.name });
     }
     /** the browse name as the XML writes it: `ns=0;` dropped */
     b(browseName) {
@@ -118,14 +103,14 @@ class RecordExporter {
         const namespace = this.namespace;
         this.records.push(this.header());
         this.section("ReferenceTypes");
-        const referenceTypes = [...namespace._referenceTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        const referenceTypes = [...namespace._referenceTypeIterator()].sort(sortByBrowseName);
         for (const referenceType of referenceTypes) {
             this.dumpReferenceType(referenceType);
         }
-        const dataTypes = [...namespace._dataTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        const dataTypes = [...namespace._dataTypeIterator()].sort(sortByBrowseName);
         if (dataTypes.length) {
             this.section("DataTypes");
-            for (const dataType of dataTypes.sort(exports.sortByNodeId)) {
+            for (const dataType of dataTypes.sort(sortByNodeId)) {
                 if (!this.visited.has(this.hash(dataType))) {
                     this.dumpNode(dataType);
                 }
@@ -133,22 +118,22 @@ class RecordExporter {
             this.dumpDictionaries();
         }
         this.section("ObjectTypes");
-        const objectTypes = [...namespace._objectTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
-        for (const objectType of objectTypes.sort(exports.sortByNodeId)) {
+        const objectTypes = [...namespace._objectTypeIterator()].sort(sortByBrowseName);
+        for (const objectType of objectTypes.sort(sortByNodeId)) {
             if (!this.visited.has(this.hash(objectType))) {
                 this.dumpNode(objectType);
             }
         }
         this.section("VariableTypes");
-        const variableTypes = [...namespace._variableTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
-        for (const variableType of variableTypes.sort(exports.sortByNodeId)) {
+        const variableTypes = [...namespace._variableTypeIterator()].sort(sortByBrowseName);
+        for (const variableType of variableTypes.sort(sortByNodeId)) {
             if (!this.visited.has(this.hash(variableType))) {
                 this.dumpNode(variableType);
             }
         }
         this.section("Other Nodes");
-        const nodes = [...namespace.nodeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
-        for (const node of nodes.sort(exports.sortByNodeId)) {
+        const nodes = [...namespace.nodeIterator()].sort(sortByBrowseName);
+        for (const node of nodes.sort(sortByNodeId)) {
             if (!this.visited.has(this.hash(node))) {
                 this.dumpNode(node);
             }
@@ -190,7 +175,7 @@ class RecordExporter {
         if (aliasesVisited.has(k))
             return;
         aliasesVisited.add(k);
-        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable || node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+        if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
             const nodeV = node;
             if (nodeV.dataType && nodeV.dataType.value !== 0) {
                 const dataTypeName = this.b(this.resolveDataTypeName(nodeV.dataType));
@@ -200,7 +185,7 @@ class RecordExporter {
             }
         }
         for (const reference of node.allReferences()) {
-            const key = this.b((0, base_node_impl_js_1.getReferenceType)(reference).browseName);
+            const key = this.b(getReferenceType(reference).browseName);
             // the XML export overwrites a reference-type alias each time it meets it; same value every time
             aliases[key] = this.t(reference.referenceType);
         }
@@ -209,7 +194,7 @@ class RecordExporter {
         const dataTypeNode = this.addressSpace.findNode(dataType);
         if (!dataTypeNode) {
             warningLog(`resolveDataTypeName: cannot find DataType ${dataType.toString()}`);
-            return new node_opcua_data_model_1.QualifiedName({ name: "", namespaceIndex: 0 });
+            return new QualifiedName({ name: "", namespaceIndex: 0 });
         }
         return dataTypeNode.browseName;
     }
@@ -232,7 +217,7 @@ class RecordExporter {
         const hasEventSource = must("HasEventSource");
         const keep = (reference) => {
             // resolved here: a reference nobody has looked at since the load carries only the NodeId of its type
-            const referenceType = reference_impl_js_1.ReferenceImpl.resolveReferenceType(addressSpace, reference);
+            const referenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference);
             if (!referenceType)
                 return false;
             if (referenceType.isSubtypeOf(aggregates) &&
@@ -260,7 +245,7 @@ class RecordExporter {
         const references = node.allReferences().filter(keep);
         const out = [];
         for (const reference of references) {
-            if ((0, base_node_impl_js_1.getReferenceType)(reference).browseName.toString() === "HasSubtype" && reference.isForward)
+            if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward)
                 continue;
             out.push({
                 isForward: reference.isForward,
@@ -271,7 +256,7 @@ class RecordExporter {
         return out;
     }
     parentOf(node) {
-        if (node instanceof ua_variable_impl_js_1.UAVariableImpl || node instanceof ua_method_impl_js_1.UAMethodImpl || node instanceof ua_object_impl_js_1.UAObjectImpl) {
+        if (node instanceof UAVariableImpl || node instanceof UAMethodImpl || node instanceof UAObjectImpl) {
             return node.parent;
         }
         return null;
@@ -300,7 +285,7 @@ class RecordExporter {
         if (Object.hasOwn(node, "isAbstract") && node.isAbstract) {
             record.isAbstract = true;
         }
-        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+        if (node.nodeClass === NodeClass.Variable) {
             const variable = node;
             if (variable.accessLevel !== currentReadFlag)
                 record.accessLevel = variable.accessLevel.toString();
@@ -320,7 +305,7 @@ class RecordExporter {
             if (minimumSamplingInterval > 0)
                 record.minimumSamplingInterval = minimumSamplingInterval;
         }
-        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable && node.historizing)
+        if (node.nodeClass === NodeClass.Variable && node.historizing)
             record.historizing = true;
         if (node.displayName?.[0])
             record.displayName = node.displayName[0].text || "";
@@ -341,28 +326,28 @@ class RecordExporter {
     }
     dumpNode(node) {
         switch (node.nodeClass) {
-            case node_opcua_data_model_1.NodeClass.Object:
+            case NodeClass.Object:
                 this.dumpObject(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.Variable:
+            case NodeClass.Variable:
                 this.dumpVariable(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.Method:
+            case NodeClass.Method:
                 this.dumpMethod(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.ObjectType:
+            case NodeClass.ObjectType:
                 this.dumpObjectType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.VariableType:
+            case NodeClass.VariableType:
                 this.dumpVariableType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.DataType:
+            case NodeClass.DataType:
                 this.dumpDataType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.ReferenceType:
+            case NodeClass.ReferenceType:
                 this.dumpReferenceType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.View:
+            case NodeClass.View:
                 this.dumpView(node);
                 break;
             default:
@@ -374,7 +359,7 @@ class RecordExporter {
         const addressSpace = this.addressSpace;
         const typeDefinitions = node.findReferencesEx("HasTypeDefinition");
         if (typeDefinitions?.length) {
-            const typeDefinition = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, typeDefinitions[0]);
+            const typeDefinition = ReferenceImpl.resolveReferenceNode(addressSpace, typeDefinitions[0]);
             if (!typeDefinition) {
                 warningLog(`dumpReferencedNodes: ${node.browseName.toString()} unknown typeDefinition ${typeDefinitions[0].toString()}`);
             }
@@ -382,17 +367,17 @@ class RecordExporter {
                 this.dumpNode(typeDefinition);
             }
         }
-        const supertypes = node.findReferencesEx("HasSubtype", node_opcua_data_model_1.BrowseDirection.Inverse);
+        const supertypes = node.findReferencesEx("HasSubtype", BrowseDirection.Inverse);
         if (supertypes?.length) {
-            const supertype = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, supertypes[0]);
+            const supertype = ReferenceImpl.resolveReferenceNode(addressSpace, supertypes[0]);
             if (supertype && supertype.nodeId.namespace === node.nodeId.namespace && !this.visited.has(this.hash(supertype))) {
                 this.dumpNode(supertype);
             }
         }
     }
     dumpAggregates(node) {
-        const aggregates = node.getAggregates().sort(nodeset_to_xml_js_1.sortByBrowseName);
-        for (const aggregate of aggregates.sort(exports.sortByNodeId)) {
+        const aggregates = node.getAggregates().sort(sortByBrowseName);
+        for (const aggregate of aggregates.sort(sortByNodeId)) {
             if (node.nodeId.namespace !== aggregate.nodeId.namespace)
                 continue;
             if (this.hasHigherPriorityThan(aggregate.nodeId.namespace, node.nodeId.namespace))
@@ -405,7 +390,7 @@ class RecordExporter {
         const elements = node
             .getFolderElements()
             .sort((x, y) => (x?.browseName.name?.toString() || 0) > (y?.browseName.name?.toString() || 0) ? 1 : -1);
-        for (const element of elements.sort(exports.sortByNodeId)) {
+        for (const element of elements.sort(sortByNodeId)) {
             // the XML export stops at the first element of another namespace; kept, so that both agree
             if (node.nodeId.namespace !== element.nodeId.namespace)
                 return;
@@ -442,8 +427,8 @@ class RecordExporter {
         // the encodings, then the aggregates
         // in the order the references were added, as the XML export always walked them; a record
         // stream keeps that order in its references, so a reload reproduces it
-        for (const encoding of node.findReferencesExAsObject("HasEncoding", node_opcua_data_model_1.BrowseDirection.Forward)) {
-            if (encoding.nodeClass !== node_opcua_data_model_1.NodeClass.Object)
+        for (const encoding of node.findReferencesExAsObject("HasEncoding", BrowseDirection.Forward)) {
+            if (encoding.nodeClass !== NodeClass.Object)
                 continue;
             const description = encoding.findReferencesAsObject("HasDescription")[0];
             if (description)
@@ -454,7 +439,7 @@ class RecordExporter {
     }
     /** the fields as the XML loader's definition parser shapes them: an absent rank is -1, an absent type BaseDataType */
     definitionOf(node) {
-        const baseDataType = this.t((0, node_opcua_nodeid_1.resolveNodeId)(node_opcua_constants_1.DataTypeIds.BaseDataType));
+        const baseDataType = this.t(resolveNodeId(DataTypeIds.BaseDataType));
         // an OptionSet is neither an enumeration nor a structure to node-opcua -- it is a plain
         // UInt16 or UInt32 subtype -- so the only account of it is the one the loader kept
         const asImpl = node;
@@ -476,8 +461,8 @@ class RecordExporter {
                 const field = { name: f.name, allowSubTypes: false };
                 if (f.description?.text?.length)
                     field.description = { text: f.description.text };
-                if (!(0, node_opcua_utils_1.isNullOrUndefined)(f.value))
-                    field.value = (0, nodeset_to_xml_js_1.coerceInt64ToInt32)(f.value);
+                if (!isNullOrUndefined(f.value))
+                    field.value = coerceInt64ToInt32(f.value);
                 field.valueRank = -1;
                 field.dataType = baseDataType;
                 return field;
@@ -494,8 +479,8 @@ class RecordExporter {
             // Part 3 8.51: in a *WithSubtypedValues structure, isOptional does not mean optional --
             // it is where "subtyping allowed" is held. The document spells that AllowSubTypes, and
             // says nothing about IsOptional there, so the two must be swapped back on the way out
-            const subtypedValues = definition.structureType === node_opcua_types_1.StructureType.StructureWithSubtypedValues ||
-                definition.structureType === node_opcua_types_1.StructureType.UnionWithSubtypedValues;
+            const subtypedValues = definition.structureType === StructureType.StructureWithSubtypedValues ||
+                definition.structureType === StructureType.UnionWithSubtypedValues;
             const fields = [];
             const all = definition.fields || [];
             for (let index = nbFieldsInBase; index < all.length; index++) {
@@ -517,7 +502,7 @@ class RecordExporter {
                 fields.push(field);
             }
             const record = { name: definitionName, fields };
-            if (definition.structureType === node_opcua_types_1.StructureType.Union)
+            if (definition.structureType === StructureType.Union)
                 record.isUnion = true;
             return record;
         }
@@ -538,7 +523,7 @@ class RecordExporter {
         // a value the loader made up for a variable the document left unvalued is not the document's
         // to write back; see valueWasSynthesized in nodeset_record_applier
         const synthesized = node.valueWasSynthesized;
-        if (dataValue?.value && !synthesized && !dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadWaitingForInitialData)) {
+        if (dataValue?.value && !synthesized && !dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
             const value = this.valueOf(node, dataValue.value);
             if (value)
                 record.value = value;
@@ -632,17 +617,17 @@ class RecordExporter {
     dumpDictionaries() {
         const addressSpace = this.addressSpace;
         const describe = (typeSystem) => {
-            const nodeToBrowse = new node_opcua_types_1.BrowseDescription({
-                browseDirection: node_opcua_data_model_1.BrowseDirection.Forward,
+            const nodeToBrowse = new BrowseDescription({
+                browseDirection: BrowseDirection.Forward,
                 includeSubtypes: false,
-                nodeClassMask: (0, node_opcua_data_model_1.makeNodeClassMask)("Variable"),
+                nodeClassMask: makeNodeClassMask("Variable"),
                 nodeId: typeSystem.nodeId,
-                referenceTypeId: (0, node_opcua_nodeid_1.resolveNodeId)("HasComponent"),
-                resultMask: (0, node_opcua_data_model_1.makeResultMask)("ReferenceType | IsForward | BrowseName | NodeClass | TypeDefinition")
+                referenceTypeId: resolveNodeId("HasComponent"),
+                resultMask: makeResultMask("ReferenceType | IsForward | BrowseName | NodeClass | TypeDefinition")
             });
             return typeSystem.browseNode(nodeToBrowse).filter((r) => r.nodeId.namespace === this.namespace.index);
         };
-        for (const typeSystemId of [node_opcua_constants_1.ObjectIds.OPCBinarySchema_TypeSystem, node_opcua_constants_1.ObjectIds.XmlSchema_TypeSystem]) {
+        for (const typeSystemId of [ObjectIds.OPCBinarySchema_TypeSystem, ObjectIds.XmlSchema_TypeSystem]) {
             const typeSystem = addressSpace.findNode(typeSystemId);
             if (!typeSystem)
                 continue;
@@ -652,7 +637,7 @@ class RecordExporter {
             const dictionary = addressSpace.findNode(result[0].nodeId);
             if (!dictionary)
                 continue;
-            this.section(typeSystemId === node_opcua_constants_1.ObjectIds.OPCBinarySchema_TypeSystem ? "DataSystem - Binary" : "DataSystem - Xml");
+            this.section(typeSystemId === ObjectIds.OPCBinarySchema_TypeSystem ? "DataSystem - Binary" : "DataSystem - Xml");
             for (const component of dictionary.getComponents()) {
                 if (!this.visited.has(this.hash(component)))
                     this.dumpNode(component);
@@ -664,9 +649,9 @@ class RecordExporter {
     // #endregion
     // #region values
     valueOf(node, variant) {
-        if (!(variant instanceof node_opcua_variant_1.Variant))
+        if (!(variant instanceof Variant))
             return undefined;
-        if (variant.dataType === node_opcua_variant_1.DataType.Null)
+        if (variant.dataType === DataType.Null)
             return undefined;
         // a null value is nothing to write down, whatever its declared data type
         if (variant.value === null || variant.value === undefined)
@@ -678,12 +663,12 @@ class RecordExporter {
         // made up. valueWasSynthesized now separates the two, so a declared "" survives the trip
         const element = (v) => this.elementOf(node, variant.dataType, v);
         const out = { dataType: variant.dataType, arrayType: variant.arrayType };
-        if (variant.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+        if (variant.arrayType === VariantArrayType.Scalar) {
             out.value = element(variant.value);
         }
         else {
             out.value = Array.from(variant.value, element);
-            if (variant.arrayType === node_opcua_variant_1.VariantArrayType.Matrix)
+            if (variant.arrayType === VariantArrayType.Matrix)
                 out.dimensions = variant.dimensions;
         }
         return out;
@@ -692,20 +677,20 @@ class RecordExporter {
         if (value === null || value === undefined)
             return null;
         switch (dataType) {
-            case node_opcua_variant_1.DataType.NodeId:
-            case node_opcua_variant_1.DataType.ExpandedNodeId:
-                return value instanceof node_opcua_nodeid_1.NodeId ? this.t(value) : value;
-            case node_opcua_variant_1.DataType.QualifiedName:
-                return value instanceof node_opcua_data_model_1.QualifiedName ? this.tq(value) : value;
-            case node_opcua_variant_1.DataType.LocalizedText: {
+            case DataType.NodeId:
+            case DataType.ExpandedNodeId:
+                return value instanceof NodeId ? this.t(value) : value;
+            case DataType.QualifiedName:
+                return value instanceof QualifiedName ? this.tq(value) : value;
+            case DataType.LocalizedText: {
                 const text = value;
-                return new node_opcua_data_model_1.LocalizedText({ locale: text.locale ?? undefined, text: text.text ?? undefined });
+                return new LocalizedText({ locale: text.locale ?? undefined, text: text.text ?? undefined });
             }
-            case node_opcua_variant_1.DataType.ExtensionObject:
+            case DataType.ExtensionObject:
                 return this.extensionObjectOf(node, value);
-            case node_opcua_variant_1.DataType.Variant: {
+            case DataType.Variant: {
                 const inner = value;
-                return new node_opcua_variant_1.Variant(this.valueOf(node, inner) ?? { dataType: node_opcua_variant_1.DataType.Null });
+                return new Variant(this.valueOf(node, inner) ?? { dataType: DataType.Null });
             }
             default:
                 return value;
@@ -713,48 +698,48 @@ class RecordExporter {
     }
     /** the four types the XML reader decodes itself travel as instances; every other one as the XML body the reader would capture */
     extensionObjectOf(node, value) {
-        if (value instanceof node_opcua_types_1.Argument) {
-            const argument = new node_opcua_types_1.Argument({});
+        if (value instanceof Argument) {
+            const argument = new Argument({});
             argument.name = value.name;
             argument.dataType = this.t(value.dataType);
             argument.valueRank = value.valueRank;
             // an empty list and null say the same thing; a stored value comes back as null
             argument.arrayDimensions =
                 value.arrayDimensions && value.arrayDimensions.length > 0 ? [...value.arrayDimensions] : null;
-            argument.description = new node_opcua_data_model_1.LocalizedText({
+            argument.description = new LocalizedText({
                 locale: value.description?.locale ?? undefined,
                 text: value.description?.text ?? undefined
             });
             return argument;
         }
-        if (value instanceof node_opcua_types_1.EUInformation) {
-            return new node_opcua_types_1.EUInformation({
+        if (value instanceof EUInformation) {
+            return new EUInformation({
                 namespaceUri: value.namespaceUri,
                 unitId: value.unitId,
-                displayName: new node_opcua_data_model_1.LocalizedText({
+                displayName: new LocalizedText({
                     locale: value.displayName?.locale ?? undefined,
                     text: value.displayName?.text ?? undefined
                 }),
-                description: new node_opcua_data_model_1.LocalizedText({
+                description: new LocalizedText({
                     locale: value.description?.locale ?? undefined,
                     text: value.description?.text ?? undefined
                 })
             });
         }
-        if (value instanceof node_opcua_data_access_1.Range) {
-            const range = new node_opcua_data_access_1.Range({});
+        if (value instanceof Range) {
+            const range = new Range({});
             range.low = value.low;
             range.high = value.high;
             return range;
         }
-        if (value instanceof node_opcua_types_1.EnumValueType) {
-            return new node_opcua_types_1.EnumValueType({
-                value: (0, node_opcua_basic_types_1.coerceInt64)(value.value),
-                displayName: new node_opcua_data_model_1.LocalizedText({
+        if (value instanceof EnumValueType) {
+            return new EnumValueType({
+                value: coerceInt64(value.value),
+                displayName: new LocalizedText({
                     locale: value.displayName?.locale ?? undefined,
                     text: value.displayName?.text ?? undefined
                 }),
-                description: new node_opcua_data_model_1.LocalizedText({
+                description: new LocalizedText({
                     locale: value.description?.locale ?? undefined,
                     text: value.description?.text ?? undefined
                 })
@@ -769,18 +754,18 @@ class RecordExporter {
         if (!encodingDefaultXml || encodingDefaultXml.isEmpty()) {
             throw new NodesetExportError(`${node.nodeId.toString()}: ${schema.name} has no XML encoding`);
         }
-        const xw = new xml_writer_1.default(false);
+        const xw = new XMLWriter(false);
         xw.translationTable = this.translationTable;
         xw.priorityTable = this.priorityTable;
         xw.visitedNode = new Set();
-        (0, nodeset_to_xml_js_1.initXmlWriterEx)(xw, { ...this.namespacesMap }, this.namespaceArray);
+        initXmlWriterEx(xw, { ...this.namespacesMap }, this.namespaceArray);
         const { name, definition } = this.definitionMap.findDefinition(dataTypeNode.nodeId);
-        (0, nodeset_to_xml_js_1._dumpVariantExtensionObjectValue_Body)(xw, this.definitionMap, name, definition, this.addressSpace, value);
-        return new nodeset_record_js_1.XmlExtensionObjectFragment(this.t(encodingDefaultXml), xw.toString());
+        _dumpVariantExtensionObjectValue_Body(xw, this.definitionMap, name, definition, this.addressSpace, value);
+        return new XmlExtensionObjectFragment(this.t(encodingDefaultXml), xw.toString());
     }
 }
 /** the records of a namespace with the comment markers the XML export places between them */
-function namespaceToWalkEvents(namespace) {
+export function namespaceToWalkEvents(namespace) {
     return new RecordExporter(namespace).run();
 }
 /**
@@ -788,32 +773,33 @@ function namespaceToWalkEvents(namespace) {
  * same namespace and are not out yet, its aggregates after it; with the namespace table the
  * events' ids are in
  */
-function nodeToWalkEvents(node) {
+export function nodeToWalkEvents(node) {
     const exporter = new RecordExporter(node.namespace);
     return { events: exporter.walkFrom(node), translationTable: exporter.translation };
 }
 /** the records of a namespace; see {@link ToNodesetRecordsOptions} */
-function namespaceToRecords(namespace, _options = {}) {
+export function namespaceToRecords(namespace, _options = {}) {
     return namespaceToWalkEvents(namespace).filter((event) => event.kind !== "section");
 }
 /** the sha256 of the lines the digest covers, hex */
-const sha256 = (text) => (0, nodeset_source_js_1.sha256Hex)(new TextEncoder().encode(text));
+const sha256 = (text) => sha256Hex(new TextEncoder().encode(text));
 /**
  * the precompiled image of a namespace: the records, JSON Lines, gzip; the trailer digest is the
  * SHA-256 of the node lines, so that a re-import keys on the content and not on a file that does
  * not exist
  */
-async function namespaceToImage(namespace, options = {}) {
-    const writer = new nodeset_image_js_1.NodesetImageWriter({ ...options });
+export async function namespaceToImage(namespace, options = {}) {
+    const writer = new NodesetImageWriter({ ...options });
     for (const record of namespaceToRecords(namespace)) {
         writer.apply(record);
     }
     return writer.finish(await sha256(writer.bodyText()));
 }
-namespace_impl_js_1.NamespaceImpl.prototype.toNodesetRecords = function (options) {
+NamespaceImpl.prototype.toNodesetRecords = function (options) {
     return namespaceToRecords(this, options);
 };
-namespace_impl_js_1.NamespaceImpl.prototype.toNodesetImage = function (options) {
+NamespaceImpl.prototype.toNodesetImage = function (options) {
     return namespaceToImage(this, options);
 };
+export { DataTypeIds, makeTypeXsd, NodeIdType };
 //# sourceMappingURL=nodeset_to_records.js.map