node-opcua-address-space 2.183.0 → 2.184.0

package/dist/impl/nodeset_tools/nodeset_to_xml.js

@@ -1,47 +1,35 @@
-"use strict";
 /**
  * @module node-opcua-address-space
  */
 // produce nodeset xml files
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTypeXsd = exports.initXmlWriterEx = exports.coerceInt64ToInt32 = void 0;
-exports._dumpVariantExtensionObjectValue_Body = _dumpVariantExtensionObjectValue_Body;
-exports._isDefaultValue = _isDefaultValue;
-exports.sortByBrowseName = sortByBrowseName;
-const node_util_1 = require("node:util");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_basic_types_1 = require("node-opcua-basic-types");
-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_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_xml_primitives_js_1 = require("../../api/loader/nodeset_xml_primitives.js");
-const session_context_js_1 = require("../../api/session_context.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_object_type_impl_js_1 = require("../ua_object_type_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_records_js_1 = require("./nodeset_to_records.js");
-var nodeset_xml_primitives_js_2 = require("../../api/loader/nodeset_xml_primitives.js");
-Object.defineProperty(exports, "coerceInt64ToInt32", { enumerable: true, get: function () { return nodeset_xml_primitives_js_2.coerceInt64ToInt32; } });
-Object.defineProperty(exports, "initXmlWriterEx", { enumerable: true, get: function () { return nodeset_xml_primitives_js_2.initXmlWriterEx; } });
-Object.defineProperty(exports, "makeTypeXsd", { enumerable: true, get: function () { return nodeset_xml_primitives_js_2.makeTypeXsd; } });
-const debugLog = (0, node_opcua_debug_1.make_debugLog)("nodeset_to_xml");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("nodeset_to_xml");
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("nodeset_to_xml");
+import { types } from "node:util";
+import { assert } from "node-opcua-assert";
+import { AttributeIds, isMinDate } from "node-opcua-basic-types";
+import { VariableIds } from "node-opcua-constants";
+import { makeAccessLevelFlag, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { NodeId, NodeIdType } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { EnumDefinition, StructureDefinition, StructureType } from "node-opcua-types";
+import { isNullOrUndefined, lowerFirstLetter } 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 { _dumpLocalizedText, _dumpNodeId, _dumpQualifiedName, _dumpXmlElement, b, coerceInt64ToInt32, findXsdNamespaceUri, getPrefix, initXmlWriterEx, int64ToDecimalString, makeTypeXsd, n, restoreDefaultNamespace, startElementEx } from "../../api/loader/nodeset_xml_primitives.js";
+import { SessionContext } from "../../api/session_context.js";
+import { BaseNodeImpl, 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 { UAObjectTypeImpl } from "../ua_object_type_impl.js";
+import { UAVariableImpl } from "../ua_variable_impl.js";
+import { _constructNamespaceTranslationTable, constructNamespaceDependency, constructNamespacePriorityTable } from "./construct_namespace_dependency.js";
+import { namespaceToWalkEvents, nodeToWalkEvents, sortByNodeId } from "./nodeset_to_records.js";
+export { coerceInt64ToInt32, initXmlWriterEx, makeTypeXsd } from "../../api/loader/nodeset_xml_primitives.js";
+const debugLog = make_debugLog("nodeset_to_xml");
+const warningLog = make_warningLog("nodeset_to_xml");
+const errorLog = make_errorLog("nodeset_to_xml");
 const doDebug = false;
 function _hash(node) {
     return node.nodeId.toString();
@@ -66,14 +54,14 @@ function hasHigherPriorityThan(namespaceIndex1, namespaceIndex2, priorityTable)
     return order1 > order2;
 }
 function _hasHigherPriorityThan(xw, namespaceIndex1, namespaceIndex2) {
-    (0, node_opcua_assert_1.assert)(xw.priorityTable, "expecting a priorityTable");
-    (0, node_opcua_assert_1.assert)(namespaceIndex1 < xw.priorityTable.length);
-    (0, node_opcua_assert_1.assert)(namespaceIndex2 < xw.priorityTable.length);
+    assert(xw.priorityTable, "expecting a priorityTable");
+    assert(namespaceIndex1 < xw.priorityTable.length);
+    assert(namespaceIndex2 < xw.priorityTable.length);
     return hasHigherPriorityThan(namespaceIndex1, namespaceIndex2, xw.priorityTable);
 }
 function _mustFindReferenceType(addressSpace, name) {
     const referenceType = addressSpace.findReferenceType(name);
-    // c8 ignore next
+    /* c8 ignore next */
     if (!referenceType) {
         throw new Error(`Cannot find standard reference type ${name}: please check your nodeset file`);
     }
@@ -95,7 +83,7 @@ function _dumpReferences(xw, node) {
     const hierarchicalReferencesType = _mustFindReferenceType(addressSpace, "HierarchicalReferences");
     function referenceToKeep(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;
         }
@@ -160,16 +148,16 @@ function _dumpReferences(xw, node) {
     }
     const allReferences = node.allReferences();
     const references = allReferences.filter(referenceToKeep);
-    for (const reference of references.sort(nodeset_to_records_js_1.sortByNodeId)) {
-        if ((0, base_node_impl_js_1.getReferenceType)(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
+    for (const reference of references.sort(sortByNodeId)) {
+        if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
             continue;
         }
         xw.startElement("Reference");
-        xw.writeAttribute("ReferenceType", (0, nodeset_xml_primitives_js_1.b)(xw, (0, base_node_impl_js_1.getReferenceType)(reference).browseName));
+        xw.writeAttribute("ReferenceType", b(xw, getReferenceType(reference).browseName));
         if (!reference.isForward) {
             xw.writeAttribute("IsForward", reference.isForward ? "true" : "false");
         }
-        xw.text((0, nodeset_xml_primitives_js_1.n)(xw, reference.nodeId));
+        xw.text(n(xw, reference.nodeId));
         xw.endElement();
     }
     xw.endElement();
@@ -195,44 +183,44 @@ function _dumpVariantValue(xw, dataTypeNodeId, dataType, addressSpace, value) {
     if (value === undefined || value === null) {
         return;
     }
-    if (dataType === node_opcua_variant_1.DataType.Null) {
+    if (dataType === DataType.Null) {
         return;
     }
-    const uax = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-    xw.startElement(`${uax}${node_opcua_variant_1.DataType[dataType]}`);
-    const definitionMap = (0, decode_xml_extension_object_js_1.makeDefinitionMap)(addressSpace);
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    xw.startElement(`${uax}${DataType[dataType]}`);
+    const definitionMap = makeDefinitionMap(addressSpace);
     _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, addressSpace, value);
     xw.endElement();
 }
 function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, addressSpace, value) {
-    const namespaceUri = (0, nodeset_xml_primitives_js_1.findXsdNamespaceUri)(xw, definition.defaultEncodingId);
-    const ns = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, namespaceUri);
-    const isUnion = definition.structureType === node_opcua_types_1.StructureType.Union || definition.structureType === node_opcua_types_1.StructureType.UnionWithSubtypedValues;
+    const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
+    const ns = getPrefix(xw, namespaceUri);
+    const isUnion = definition.structureType === StructureType.Union || definition.structureType === StructureType.UnionWithSubtypedValues;
     for (const field of definition.fields || []) {
         const dataTypeNodeId = field.dataType;
         const fieldName = field.name || "";
-        const lowerFieldName = (0, node_opcua_utils_1.lowerFirstLetter)(fieldName);
+        const lowerFieldName = lowerFirstLetter(fieldName);
         const v = value[lowerFieldName];
         if (v !== null && v !== undefined) {
             if (dataTypeNodeId.namespace === 0 &&
                 dataTypeNodeId.value === 0 &&
-                dataTypeNodeId.identifierType === node_opcua_nodeid_1.NodeIdType.NUMERIC) {
+                dataTypeNodeId.identifierType === NodeIdType.NUMERIC) {
                 // to do ?? shall we do a extension Object here ?
                 continue; // ns=0;i=0 is reserved
             }
             const { name, definition } = definitionMap.findDefinition(dataTypeNodeId);
-            (0, nodeset_xml_primitives_js_1.startElementEx)(xw, ns, fieldName, namespaceUri);
+            startElementEx(xw, ns, fieldName, namespaceUri);
             //  xw.startElement(fieldName);
             let fun = (_value) => {
                 /** */
             };
-            if (definition instanceof node_opcua_types_1.StructureDefinition) {
+            if (definition instanceof StructureDefinition) {
                 fun = _dumpVariantInnerExtensionObject.bind(null, xw, definitionMap, definition, addressSpace);
             }
-            else if (definition instanceof node_opcua_types_1.EnumDefinition) {
+            else if (definition instanceof EnumDefinition) {
                 fun = _dumpVariantInnerValueEnum.bind(null, xw, definition);
             }
-            else if (definition?.dataType === node_opcua_variant_1.DataType.Variant) {
+            else if (definition?.dataType === DataType.Variant) {
                 fun = (value) => {
                     const variantValue = value;
                     xw.startElement("Value");
@@ -258,7 +246,7 @@ function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, address
                 }
             }
             catch (err) {
-                if (node_util_1.types.isNativeError(err)) {
+                if (types.isNativeError(err)) {
                     errorLog("Error in _dumpVariantExtensionObjectValue_Body !!!", err.message);
                 }
                 // c8 ignore next
@@ -268,14 +256,14 @@ function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, address
                 }
                 // throw err;
             }
-            (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+            restoreDefaultNamespace(xw);
             xw.endElement();
         }
         else {
             if (!isUnion && !field.isOptional) {
                 // field is mandatory but is null=> provide an empty array
-                (0, nodeset_xml_primitives_js_1.startElementEx)(xw, ns, fieldName, namespaceUri);
-                (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+                startElementEx(xw, ns, fieldName, namespaceUri);
+                restoreDefaultNamespace(xw);
                 xw.endElement();
             }
         }
@@ -289,47 +277,47 @@ function _dumpVariantInnerValueEnum(xw, definition, value) {
     xw.text(`${field?.name}_${field?.value[1]}`);
 }
 function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, addressSpace, value) {
-    const uax = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     switch (dataType) {
         case null:
-        case node_opcua_variant_1.DataType.Null:
+        case DataType.Null:
             break;
-        case node_opcua_variant_1.DataType.LocalizedText:
-            (0, nodeset_xml_primitives_js_1._dumpLocalizedText)(xw, value);
+        case DataType.LocalizedText:
+            _dumpLocalizedText(xw, value);
             break;
-        case node_opcua_variant_1.DataType.QualifiedName:
-            (0, nodeset_xml_primitives_js_1._dumpQualifiedName)(xw, value);
+        case DataType.QualifiedName:
+            _dumpQualifiedName(xw, value);
             break;
-        case node_opcua_variant_1.DataType.NodeId:
-            (0, nodeset_xml_primitives_js_1._dumpNodeId)(xw, value);
+        case DataType.NodeId:
+            _dumpNodeId(xw, value);
             break;
-        case node_opcua_variant_1.DataType.DateTime:
+        case DataType.DateTime:
             xw.text(value.toISOString());
             break;
-        case node_opcua_variant_1.DataType.Int64:
-        case node_opcua_variant_1.DataType.UInt64:
-            xw.text((0, nodeset_xml_primitives_js_1.int64ToDecimalString)(value, dataType === node_opcua_variant_1.DataType.Int64));
+        case DataType.Int64:
+        case DataType.UInt64:
+            xw.text(int64ToDecimalString(value, dataType === DataType.Int64));
             break;
-        case node_opcua_variant_1.DataType.Boolean:
-        case node_opcua_variant_1.DataType.SByte:
-        case node_opcua_variant_1.DataType.Byte:
-        case node_opcua_variant_1.DataType.Float:
-        case node_opcua_variant_1.DataType.Double:
-        case node_opcua_variant_1.DataType.Int16:
-        case node_opcua_variant_1.DataType.Int32:
-        case node_opcua_variant_1.DataType.UInt16:
-        case node_opcua_variant_1.DataType.UInt32:
-        case node_opcua_variant_1.DataType.String:
+        case DataType.Boolean:
+        case DataType.SByte:
+        case DataType.Byte:
+        case DataType.Float:
+        case DataType.Double:
+        case DataType.Int16:
+        case DataType.Int32:
+        case DataType.UInt16:
+        case DataType.UInt32:
+        case DataType.String:
             xw.text(value.toString());
             break;
-        case node_opcua_variant_1.DataType.ByteString:
+        case DataType.ByteString:
             {
                 const base64 = value.toString("base64");
                 const chunks = base64.match(/.{0,80}/g);
                 xw.text(base64.length > 80 && chunks ? chunks.join("\n") : base64);
             }
             break;
-        case node_opcua_variant_1.DataType.Guid:
+        case DataType.Guid:
             /*
              <uax:Guid>
                  <uax:String>947c29a7-490d-4dc9-adda-1109e3e8fcb7</uax:String>
@@ -342,22 +330,22 @@ function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, add
                 xw.endElement();
             }
             break;
-        case node_opcua_variant_1.DataType.ExtensionObject:
+        case DataType.ExtensionObject:
             _dumpVariantExtensionObjectValue(xw, dataTypeNodeId, definitionMap, addressSpace, value);
             break;
-        case node_opcua_variant_1.DataType.XmlElement:
-            (0, nodeset_xml_primitives_js_1._dumpXmlElement)(xw, value);
+        case DataType.XmlElement:
+            _dumpXmlElement(xw, value);
             break;
-        case node_opcua_variant_1.DataType.StatusCode:
+        case DataType.StatusCode:
             xw.text(value.value.toString());
             break;
-        case node_opcua_variant_1.DataType.Variant: {
+        case DataType.Variant: {
             const variantValue = value;
             _dumpVariantInnerValue(xw, variantValue.dataType, dataTypeNodeId, definitionMap, addressSpace, variantValue.value);
             break;
         }
         default:
-            errorLog(`_dumpVariantInnerValue incomplete ${value} DataType=${dataType}=${node_opcua_variant_1.DataType[dataType]}`);
+            errorLog(`_dumpVariantInnerValue incomplete ${value} DataType=${dataType}=${DataType[dataType]}`);
         //  throw new Error("_dumpVariantInnerValue incomplete " + value + " " + "DataType=" + dataType + "=" + DataType[dataType]);
     }
 }
@@ -368,15 +356,15 @@ function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, add
  * @param value
  * @private
  */
-function _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition, addressSpace, value) {
+export function _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition, addressSpace, value) {
     if (value) {
-        const namespaceUri = (0, nodeset_xml_primitives_js_1.findXsdNamespaceUri)(xw, definition.defaultEncodingId);
-        const ns = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, namespaceUri);
-        (0, nodeset_xml_primitives_js_1.startElementEx)(xw, ns, `${name}`, namespaceUri);
+        const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
+        const ns = getPrefix(xw, namespaceUri);
+        startElementEx(xw, ns, `${name}`, namespaceUri);
         if (value) {
             _dumpVariantInnerExtensionObject(xw, definitionMap, definition, addressSpace, value);
         }
-        (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+        restoreDefaultNamespace(xw);
         xw.endElement();
     }
 }
@@ -389,28 +377,28 @@ function _dumpVariantExtensionObjectValue(xw, dataTypeNodeId, definitionMap, add
         // throw new Error("Extension Object doesn't provide a XML ");
         return;
     }
-    const uax = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-    (0, nodeset_xml_primitives_js_1.startElementEx)(xw, uax, `ExtensionObject`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    startElementEx(xw, uax, `ExtensionObject`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     {
-        const uax = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+        const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
         xw.startElement(`${uax}TypeId`);
         // find HasEncoding node
         // xx var encodingDefaultXml = schema.encodingDefaultXml;
         xw.startElement(`${uax}Identifier`);
-        xw.text((0, nodeset_xml_primitives_js_1.n)(xw, encodingDefaultXml));
+        xw.text(n(xw, encodingDefaultXml));
         xw.endElement();
         xw.endElement();
-        (0, nodeset_xml_primitives_js_1.startElementEx)(xw, uax, "Body", "http://opcfoundation.org/UA/2008/02/Types.xsd");
+        startElementEx(xw, uax, "Body", "http://opcfoundation.org/UA/2008/02/Types.xsd");
         _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition, addressSpace, value);
-        (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+        restoreDefaultNamespace(xw);
         xw.endElement();
     }
-    (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+    restoreDefaultNamespace(xw);
     xw.endElement();
 }
 function _dumpVariantExtensionObjectValue2(xw, addressSpace, value) {
     const dataTypeNodeId = value.schema.dataTypeNodeId;
-    const definitionMap = (0, decode_xml_extension_object_js_1.makeDefinitionMap)(addressSpace);
+    const definitionMap = makeDefinitionMap(addressSpace);
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
     if (!dataTypeNode) {
         warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
@@ -418,51 +406,51 @@ function _dumpVariantExtensionObjectValue2(xw, addressSpace, value) {
     }
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, addressSpace, value);
 }
-function _isDefaultValue(value) {
+export function _isDefaultValue(value) {
     // detect default value
-    if (value.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+    if (value.arrayType === VariantArrayType.Scalar) {
         switch (value.dataType) {
-            case node_opcua_variant_1.DataType.ExtensionObject:
+            case DataType.ExtensionObject:
                 if (!value.value) {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.DateTime:
-                if (!value.value || (0, node_opcua_basic_types_1.isMinDate)(value.value)) {
+            case DataType.DateTime:
+                if (!value.value || isMinDate(value.value)) {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.ByteString:
+            case DataType.ByteString:
                 if (!value.value || value.value.length === 0) {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.Boolean:
+            case DataType.Boolean:
                 return false; // we want it all the time !
-            case node_opcua_variant_1.DataType.SByte:
-            case node_opcua_variant_1.DataType.Byte:
-            case node_opcua_variant_1.DataType.UInt16:
-            case node_opcua_variant_1.DataType.UInt32:
-            case node_opcua_variant_1.DataType.Int16:
-            case node_opcua_variant_1.DataType.Int32:
-            case node_opcua_variant_1.DataType.Double:
-            case node_opcua_variant_1.DataType.Float:
+            case DataType.SByte:
+            case DataType.Byte:
+            case DataType.UInt16:
+            case DataType.UInt32:
+            case DataType.Int16:
+            case DataType.Int32:
+            case DataType.Double:
+            case DataType.Float:
                 if (value.value === 0 || value.value === null) {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.String:
+            case DataType.String:
                 if (value.value === null || value.value === "") {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.Int64:
-            case node_opcua_variant_1.DataType.UInt64:
-                if (0 === (0, nodeset_xml_primitives_js_1.coerceInt64ToInt32)(value.value)) {
+            case DataType.Int64:
+            case DataType.UInt64:
+                if (0 === coerceInt64ToInt32(value.value)) {
                     return true;
                 }
                 break;
-            case node_opcua_variant_1.DataType.LocalizedText:
+            case DataType.LocalizedText:
                 if (!value.value) {
                     return true;
                 }
@@ -489,7 +477,7 @@ function _dumpValue(xw, node, variant) {
     if (variant === null || variant === undefined) {
         return;
     }
-    (0, node_opcua_assert_1.assert)(variant instanceof node_opcua_variant_1.Variant);
+    assert(variant instanceof Variant);
     const dataTypeNode = addressSpace.findDataType(node.dataType);
     // c8 ignore next
     if (!dataTypeNode) {
@@ -497,13 +485,13 @@ function _dumpValue(xw, node, variant) {
         doDebug && debugLog("Cannot find dataType:", node.dataType.toString());
         return;
     }
-    const baseDataTypeName = node_opcua_variant_1.DataType[variant.dataType];
+    const baseDataTypeName = DataType[variant.dataType];
     if (baseDataTypeName === "Null") {
         return;
     }
-    (0, node_opcua_assert_1.assert)(typeof baseDataTypeName === "string");
+    assert(typeof baseDataTypeName === "string");
     // determine if dataTypeName is a ExtensionObject
-    const isExtensionObject = variant.dataType === node_opcua_variant_1.DataType.ExtensionObject;
+    const isExtensionObject = variant.dataType === DataType.ExtensionObject;
     // nothing to serialize: a scalar with no value, or an array that is null rather than empty.
     // This is the one thing _isDefaultValue used to catch here that still needs catching -- it is
     // a test for the absence of a value, not for a value that happens to equal a type's default
@@ -511,18 +499,18 @@ function _dumpValue(xw, node, variant) {
         return;
     }
     xw.startElement("Value");
-    const uax = (0, nodeset_xml_primitives_js_1.getPrefix)(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     if (isExtensionObject) {
         const encodeXml = _dumpVariantExtensionObjectValue2.bind(null, xw, node.addressSpace);
         switch (variant.arrayType) {
-            case node_opcua_variant_1.VariantArrayType.Matrix:
-            case node_opcua_variant_1.VariantArrayType.Array:
-                (0, nodeset_xml_primitives_js_1.startElementEx)(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+            case VariantArrayType.Matrix:
+            case VariantArrayType.Array:
+                startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
                 variant.value.forEach(encodeXml);
-                (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+                restoreDefaultNamespace(xw);
                 xw.endElement();
                 break;
-            case node_opcua_variant_1.VariantArrayType.Scalar:
+            case VariantArrayType.Scalar:
                 encodeXml(variant.value);
                 break;
             default:
@@ -533,18 +521,18 @@ function _dumpValue(xw, node, variant) {
     else {
         const encodeXml = _dumpVariantValue.bind(null, xw, node.dataType, variant.dataType, node.addressSpace);
         switch (variant.arrayType) {
-            case node_opcua_variant_1.VariantArrayType.Matrix:
-            case node_opcua_variant_1.VariantArrayType.Array:
+            case VariantArrayType.Matrix:
+            case VariantArrayType.Array:
                 // the built-in type, not the DataType's browse name: the uax schema defines
                 // ListOfInt32 and ListOfString, and nothing named after a nodeset's own DataType.
                 // A `ListOfIdType` is not an element any reader knows, so the reader that meets it
                 // walks straight past into the first child and takes the array for a scalar
-                (0, nodeset_xml_primitives_js_1.startElementEx)(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+                startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
                 variant.value.forEach(encodeXml);
-                (0, nodeset_xml_primitives_js_1.restoreDefaultNamespace)(xw);
+                restoreDefaultNamespace(xw);
                 xw.endElement();
                 break;
-            case node_opcua_variant_1.VariantArrayType.Scalar:
+            case VariantArrayType.Scalar:
                 encodeXml(variant.value);
                 break;
             default:
@@ -568,19 +556,19 @@ function _dumpArrayDimensionsAttribute(xw, node) {
     xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
 }
 function getParent(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;
 }
-const currentReadFlag = (0, node_opcua_data_model_1.makeAccessLevelFlag)("CurrentRead");
+const currentReadFlag = makeAccessLevelFlag("CurrentRead");
 function dumpCommonAttributes(xw, node) {
-    xw.writeAttribute("NodeId", (0, nodeset_xml_primitives_js_1.n)(xw, node.nodeId));
-    xw.writeAttribute("BrowseName", (0, nodeset_xml_primitives_js_1.b)(xw, node.browseName));
+    xw.writeAttribute("NodeId", n(xw, node.nodeId));
+    xw.writeAttribute("BrowseName", b(xw, node.browseName));
     const parentNode = getParent(node);
     if (parentNode) {
         if (parentNode.nodeId.namespace <= node.nodeId.namespace) {
-            xw.writeAttribute("ParentNodeId", (0, nodeset_xml_primitives_js_1.n)(xw, parentNode.nodeId));
+            xw.writeAttribute("ParentNodeId", n(xw, parentNode.nodeId));
         }
     }
     if (Object.hasOwn(node, "symbolicName")) {
@@ -600,7 +588,7 @@ function dumpCommonAttributes(xw, node) {
     // class rather than on the presence of the property: UAVariableTypeImpl happens not to own
     // an accessLevel today, but it does own a `historizing` (see #1550), so a property-presence
     // guard is one refactor away from emitting an attribute the schema rejects.
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+    if (node.nodeClass === NodeClass.Variable) {
         const variable = node;
         // CurrentRead is by default
         if (variable.accessLevel !== currentReadFlag) {
@@ -632,7 +620,7 @@ function dumpCommonAttributes(xw, node) {
     // EventNotifier lives on UAObject, UAObjectType and UAView in the XSD. 0 is the default and is
     // left unwritten; anything else the document declared. It was written nowhere at all until now,
     // so every node that declared one lost it on the way out
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.Object || node.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType || node.nodeClass === node_opcua_data_model_1.NodeClass.View) {
+    if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.ObjectType || node.nodeClass === NodeClass.View) {
         // typeof, not truthiness: a node with a child called "EventNotifier" resolves the name to
         // that child through the shared child accessors, so `node.eventNotifier` is a BaseNode
         // there and not the attribute. PublishedEventsType is one, and stringifying it wrote a
@@ -646,7 +634,7 @@ function dumpCommonAttributes(xw, node) {
     // DataType/ValueRank/ArrayDimensions. UAVariableTypeImpl nevertheless owns a `historizing`
     // property, so the node class must be tested here rather than the presence of the property.
     // false being the default, the attribute is only emitted when it is set.
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable && node.historizing) {
+    if (node.nodeClass === NodeClass.Variable && node.historizing) {
         xw.writeAttribute("Historizing", "true");
     }
 }
@@ -662,7 +650,7 @@ function _dumpRolePermissions(xw, node) {
     for (const rolePermission of rolePermissions) {
         xw.startElement("RolePermission");
         xw.writeAttribute("Permissions", rolePermission.permissions.toString());
-        xw.text((0, nodeset_xml_primitives_js_1.n)(xw, rolePermission.roleId));
+        xw.text(n(xw, rolePermission.roleId));
         xw.endElement();
     }
     xw.endElement();
@@ -678,8 +666,8 @@ function _dumpEnumDefinition(xw, enumDefinition) {
     for (const defItem of enumDefinition.fields) {
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name);
-        if (!(0, node_opcua_utils_1.isNullOrUndefined)(defItem.value)) {
-            xw.writeAttribute("Value", (0, nodeset_xml_primitives_js_1.coerceInt64ToInt32)(defItem.value));
+        if (!isNullOrUndefined(defItem.value)) {
+            xw.writeAttribute("Value", coerceInt64ToInt32(defItem.value));
         }
         _dumpDescription(xw, defItem);
         xw.endElement();
@@ -698,8 +686,8 @@ function _dumpStructureDefinition(xw, structureDefinition, baseStructureDefiniti
     // Part 3 8.51: in a *WithSubtypedValues structure, isOptional is where "subtyping allowed" is
     // held, and the document spells that AllowSubTypes. Written as IsOptional it said the opposite
     // of what it meant, and the AllowSubTypes the document had was simply gone
-    const subtypedValues = structureDefinition.structureType === node_opcua_types_1.StructureType.StructureWithSubtypedValues ||
-        structureDefinition.structureType === node_opcua_types_1.StructureType.UnionWithSubtypedValues;
+    const subtypedValues = structureDefinition.structureType === StructureType.StructureWithSubtypedValues ||
+        structureDefinition.structureType === StructureType.UnionWithSubtypedValues;
     for (let index = nbFieldsInBase; index < fields.length; index++) {
         const defItem = fields[index];
         xw.startElement("Field");
@@ -719,7 +707,7 @@ function _dumpStructureDefinition(xw, structureDefinition, baseStructureDefiniti
         // todo : SymbolicName ( see AutoId )
         if (defItem.dataType) {
             // todo : namespace translation !
-            xw.writeAttribute("DataType", (0, nodeset_xml_primitives_js_1.n)(xw, defItem.dataType));
+            xw.writeAttribute("DataType", n(xw, defItem.dataType));
         }
         _dumpDescription(xw, defItem);
         xw.endElement();
@@ -733,7 +721,7 @@ function _dumpUADataTypeDefinition(xw, uaDataType) {
     const asImpl = uaDataType;
     // what the document called this definition, or -- for a DataType built here, which never had a
     // declaration -- the browse name, which is the only name available
-    const definitionName = asImpl.declaredDefinitionName ?? (0, nodeset_xml_primitives_js_1.b)(xw, uaDataType.browseName);
+    const definitionName = asImpl.declaredDefinitionName ?? b(xw, uaDataType.browseName);
     if (asImpl.isOptionSetDataType && asImpl.declaredDefinitionFields) {
         xw.startElement("Definition");
         xw.writeAttribute("Name", definitionName);
@@ -760,7 +748,7 @@ function _dumpUADataTypeDefinition(xw, uaDataType) {
     if (uaDataType.isStructure()) {
         // in case the namespace is conforming to 1.03 specification the DataTypeDefinition attribute
         // will be not be readable....
-        const dataValue = uaDataType.readAttribute(session_context_js_1.SessionContext.defaultContext, node_opcua_basic_types_1.AttributeIds.DataTypeDefinition);
+        const dataValue = uaDataType.readAttribute(SessionContext.defaultContext, AttributeIds.DataTypeDefinition);
         const t = true;
         if (t || dataValue.statusCode.isGood()) {
             const definition = uaDataType.getStructureDefinition();
@@ -769,7 +757,7 @@ function _dumpUADataTypeDefinition(xw, uaDataType) {
             const baseDefinition = uaDataTypeBase?.isStructure() ? uaDataTypeBase.getStructureDefinition() : null;
             xw.startElement("Definition");
             xw.writeAttribute("Name", definitionName);
-            if (definition.structureType === node_opcua_types_1.StructureType.Union) {
+            if (definition.structureType === StructureType.Union) {
                 xw.writeAttribute("IsUnion", "true");
             }
             _dumpStructureDefinition(xw, definition, baseDefinition);
@@ -781,16 +769,16 @@ function _dumpUADataTypeDefinition(xw, uaDataType) {
 function dumpUAView(xw, node) {
     _markAsVisited(xw, node);
     xw.startElement("UAView");
-    xw.writeAttribute("NodeId", (0, nodeset_xml_primitives_js_1.n)(xw, node.nodeId));
-    xw.writeAttribute("BrowseName", (0, nodeset_xml_primitives_js_1.b)(xw, node.browseName));
+    xw.writeAttribute("NodeId", n(xw, node.nodeId));
+    xw.writeAttribute("BrowseName", b(xw, node.browseName));
     dumpCommonElements(xw, node);
     xw.endElement();
 }
 function dumpUADataType(xw, node) {
     _markAsVisited(xw, node);
     xw.startElement("UADataType");
-    xw.writeAttribute("NodeId", (0, nodeset_xml_primitives_js_1.n)(xw, node.nodeId));
-    xw.writeAttribute("BrowseName", (0, nodeset_xml_primitives_js_1.b)(xw, node.browseName));
+    xw.writeAttribute("NodeId", n(xw, node.nodeId));
+    xw.writeAttribute("BrowseName", b(xw, node.browseName));
     if (node.symbolicName !== node.browseName.name) {
         xw.writeAttribute("SymbolicName", node.symbolicName);
     }
@@ -803,11 +791,11 @@ function dumpUADataType(xw, node) {
 }
 function _markAsVisited(xw, node) {
     xw.visitedNode = xw.visitedNode || new Set();
-    (0, node_opcua_assert_1.assert)(!xw.visitedNode.has(_hash(node)));
+    assert(!xw.visitedNode.has(_hash(node)));
     xw.visitedNode.add(_hash(node));
 }
 function dumpUAVariable(xw, node) {
-    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Variable);
+    assert(node.nodeClass === NodeClass.Variable);
     if (xw.visitedNode.has(_hash(node))) {
         return;
     }
@@ -826,7 +814,7 @@ function dumpUAVariable(xw, node) {
         if (dataTypeNode) {
             // verify that data Type is in alias
             // xx const dataTypeName = dataTypeNode.browseName.toString();
-            const dataTypeName = (0, nodeset_xml_primitives_js_1.b)(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
+            const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
             xw.writeAttribute("DataType", dataTypeName);
         }
     }
@@ -840,16 +828,16 @@ function dumpUAVariable(xw, node) {
         const synthesized = node.valueWasSynthesized;
         const dataValue = node.$dataValue;
         const value = dataValue.value;
-        if (value && !synthesized && !dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadWaitingForInitialData)) {
+        if (value && !synthesized && !dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
             _dumpValue(xw, node, value);
         }
     }
     xw.endElement();
 }
 function dumpUAVariableType(xw, node) {
-    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType);
+    assert(node.nodeClass === NodeClass.VariableType);
     xw.visitedNode = xw.visitedNode || new Set();
-    (0, node_opcua_assert_1.assert)(!xw.visitedNode.has(_hash(node)));
+    assert(!xw.visitedNode.has(_hash(node)));
     xw.visitedNode.add(_hash(node));
     const addressSpace = node.addressSpace;
     xw.startElement("UAVariableType");
@@ -872,7 +860,7 @@ function dumpUAVariableType(xw, node) {
                     node.nodeId.toString());
         }
         else {
-            const dataTypeName = (0, nodeset_xml_primitives_js_1.b)(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
+            const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
             xw.writeAttribute("DataType", dataTypeName);
         }
     }
@@ -888,9 +876,9 @@ function dumpUAVariableType(xw, node) {
     xw.endElement();
 }
 function _dumpUAObject(xw, node) {
-    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Object);
+    assert(node.nodeClass === NodeClass.Object);
     xw.visitedNode = xw.visitedNode || new Set();
-    (0, node_opcua_assert_1.assert)(!xw.visitedNode.has(_hash(node)));
+    assert(!xw.visitedNode.has(_hash(node)));
     xw.visitedNode.add(_hash(node));
     // dump SubTypeOf and HasTypeDefinition
     xw.startElement("UAObject");
@@ -900,8 +888,8 @@ function _dumpUAObject(xw, node) {
     // dump aggregates nodes ( Properties / components )
 }
 function dumpUAObjectType(xw, node) {
-    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType);
-    (0, node_opcua_assert_1.assert)(node instanceof ua_object_type_impl_js_1.UAObjectTypeImpl);
+    assert(node.nodeClass === NodeClass.ObjectType);
+    assert(node instanceof UAObjectTypeImpl);
     _markAsVisited(xw, node);
     // dump SubtypeOf and HasTypeDefinition node if part of the same namespace
     xw.startElement("UAObjectType");
@@ -910,12 +898,12 @@ function dumpUAObjectType(xw, node) {
     xw.endElement();
 }
 function dumpUAMethod(xw, node) {
-    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Method);
+    assert(node.nodeClass === NodeClass.Method);
     _markAsVisited(xw, node);
     xw.startElement("UAMethod");
     dumpCommonAttributes(xw, node);
     if (node.methodDeclarationId) {
-        xw.writeAttribute("MethodDeclarationId", (0, nodeset_xml_primitives_js_1.n)(xw, node.methodDeclarationId));
+        xw.writeAttribute("MethodDeclarationId", n(xw, node.methodDeclarationId));
     }
     dumpCommonElements(xw, node);
     xw.endElement();
@@ -927,13 +915,13 @@ function resolveDataTypeName(addressSpace, dataType) {
         dataTypeNode = addressSpace.findDataType(dataType);
     }
     else {
-        (0, node_opcua_assert_1.assert)(dataType instanceof node_opcua_nodeid_1.NodeId);
+        assert(dataType instanceof NodeId);
         const o = addressSpace.findNode(dataType.toString());
         dataTypeNode = o ? o : null;
     }
     if (!dataTypeNode) {
         errorLog(`resolveDataTypeName: warning 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;
 }
@@ -966,7 +954,7 @@ function dumpReferenceType(xw, referenceType) {
     }
     xw.endElement();
 }
-function sortByBrowseName(x, y) {
+export function sortByBrowseName(x, y) {
     const x_str = x.browseName.toString();
     const y_str = y.browseName.toString();
     if (x_str > y_str) {
@@ -980,28 +968,28 @@ function sortByBrowseName(x, y) {
 /** the element of one node, and nothing else: the walk decides what comes before and after it */
 function dumpElement(xw, node) {
     switch (node.nodeClass) {
-        case node_opcua_data_model_1.NodeClass.Method:
+        case NodeClass.Method:
             dumpUAMethod(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.Object:
+        case NodeClass.Object:
             _dumpUAObject(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.Variable:
+        case NodeClass.Variable:
             dumpUAVariable(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.VariableType:
+        case NodeClass.VariableType:
             dumpUAVariableType(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.ReferenceType:
+        case NodeClass.ReferenceType:
             dumpReferenceType(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.ObjectType:
+        case NodeClass.ObjectType:
             dumpUAObjectType(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.DataType:
+        case NodeClass.DataType:
             dumpUADataType(xw, node);
             break;
-        case node_opcua_data_model_1.NodeClass.View:
+        case NodeClass.View:
             dumpUAView(xw, node);
             break;
         default:
@@ -1027,7 +1015,7 @@ function writeWalkEvents(xw, addressSpace, translationTable, events) {
         if (namespace === undefined) {
             throw new Error(`toNodeset2XML: no namespace for ${event.nodeId.toString()}`);
         }
-        const node = addressSpace.findNode(new node_opcua_nodeid_1.NodeId(event.nodeId.identifierType, event.nodeId.value, namespace));
+        const node = addressSpace.findNode(new NodeId(event.nodeId.identifierType, event.nodeId.value, namespace));
         if (!node) {
             throw new Error(`toNodeset2XML: cannot find ${event.nodeId.toString()} (namespace ${namespace})`);
         }
@@ -1038,23 +1026,23 @@ function writeWalkEvents(xw, addressSpace, translationTable, events) {
  * one node as XML, with what the export brings with it: its type definition and supertype when they
  * belong to the same namespace, its aggregates after it. The same walk toNodeset2XML runs, from this node.
  */
-base_node_impl_js_1.BaseNodeImpl.prototype.dumpXML = function (xw) {
-    const { events, translationTable } = (0, nodeset_to_records_js_1.nodeToWalkEvents)(this);
+BaseNodeImpl.prototype.dumpXML = function (xw) {
+    const { events, translationTable } = nodeToWalkEvents(this);
     xw.translationTable = xw.translationTable || translationTable;
     writeWalkEvents(xw, this.addressSpace, translationTable, events);
 };
-namespace_impl_js_1.NamespaceImpl.prototype.toNodeset2XML = function () {
-    const namespaceArrayNode = this.addressSpace.findNode(node_opcua_constants_1.VariableIds.Server_NamespaceArray);
+NamespaceImpl.prototype.toNodeset2XML = function () {
+    const namespaceArrayNode = this.addressSpace.findNode(VariableIds.Server_NamespaceArray);
     const namespaceArray = namespaceArrayNode
-        ? namespaceArrayNode.readAttribute(null, node_opcua_basic_types_1.AttributeIds.Value).value.value
+        ? namespaceArrayNode.readAttribute(null, AttributeIds.Value).value.value
         : [];
-    const xw = new xml_writer_1.default(true);
-    xw.priorityTable = (0, construct_namespace_dependency_js_1.constructNamespacePriorityTable)(this.addressSpace).priorityTable;
-    const dependency = (0, construct_namespace_dependency_js_1.constructNamespaceDependency)(this, xw.priorityTable);
-    const translationTable = (0, construct_namespace_dependency_js_1._constructNamespaceTranslationTable)(dependency, this);
+    const xw = new XMLWriter(true);
+    xw.priorityTable = constructNamespacePriorityTable(this.addressSpace).priorityTable;
+    const dependency = constructNamespaceDependency(this, xw.priorityTable);
+    const translationTable = _constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
     // the walk: the same records the image writer and the loader consume, plus the comments
-    const events = (0, nodeset_to_records_js_1.namespaceToWalkEvents)(this);
+    const events = namespaceToWalkEvents(this);
     const header = events[0];
     if (header?.kind !== "header") {
         throw new Error("toNodeset2XML: the walk must start with the header record");
@@ -1075,10 +1063,10 @@ namespace_impl_js_1.NamespaceImpl.prototype.toNodeset2XML = function () {
         }
         const translatedIndex = translationTable.get(namespace.index);
         const smallName = `ns${translatedIndex}`;
-        xw.writeAttribute(`xmlns:${smallName}`, (0, nodeset_xml_primitives_js_1.makeTypeXsd)(namespace.namespaceUri));
+        xw.writeAttribute(`xmlns:${smallName}`, makeTypeXsd(namespace.namespaceUri));
         namespacesMap[namespace.namespaceUri] = smallName;
     }
-    (0, nodeset_xml_primitives_js_1.initXmlWriterEx)(xw, namespacesMap, namespaceArray);
+    initXmlWriterEx(xw, namespacesMap, namespaceArray);
     xw.startElement("NamespaceUris");
     for (const namespaceUri of header.namespaceUris) {
         xw.startElement("Uri");