node-opcua-address-space 2.51.0

package/dist/source/loader/load_nodeset2.js

@@ -0,0 +1,1392 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSetLoader = exports.makeStuff = exports.ensureDatatypeExtractedWithCallback = exports.ensureDatatypeExtracted = void 0;
+/* eslint-disable max-statements */
+/**
+ * @module node-opcua-address-space
+ */
+const chalk = require("chalk");
+const ec = require("node-opcua-basic-types");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_basic_types_1 = require("node-opcua-basic-types");
+const node_opcua_client_dynamic_extension_object_1 = require("node-opcua-client-dynamic-extension-object");
+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_extension_object_1 = require("node-opcua-extension-object");
+const node_opcua_factory_1 = require("node-opcua-factory");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const node_opcua_service_call_1 = require("node-opcua-service-call");
+const node_opcua_types_1 = require("node-opcua-types");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_xml2json_1 = require("node-opcua-xml2json");
+const PrettyError = require("pretty-error");
+const pseudo_session_1 = require("../pseudo_session");
+const namespace_post_step_1 = require("./namespace_post_step");
+const pe = new PrettyError();
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+function ensureDatatypeExtracted(addressSpace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressSpacePriv = addressSpace;
+        if (!addressSpacePriv.$$extraDataTypeManager) {
+            const dataTypeManager = new node_opcua_client_dynamic_extension_object_1.ExtraDataTypeManager();
+            const namespaceArray = addressSpace.getNamespaceArray().map((n) => n.namespaceUri);
+            debugLog("INamespace Array = ", namespaceArray.join("\n                   "));
+            dataTypeManager.setNamespaceArray(namespaceArray);
+            addressSpacePriv.$$extraDataTypeManager = dataTypeManager;
+            for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
+                const dataTypeFactory1 = new node_opcua_factory_1.DataTypeFactory([(0, node_opcua_factory_1.getStandardDataTypeFactory)()]);
+                dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
+            }
+            // inject simple types
+            // now extract structure and enumeration from old form if
+            const session = new pseudo_session_1.PseudoSession(addressSpace);
+            yield (0, node_opcua_client_dynamic_extension_object_1.populateDataTypeManager)(session, dataTypeManager, true);
+        }
+        return addressSpacePriv.$$extraDataTypeManager;
+    });
+}
+exports.ensureDatatypeExtracted = ensureDatatypeExtracted;
+function ensureDatatypeExtractedWithCallback(addressSpace, callback) {
+    ensureDatatypeExtracted(addressSpace)
+        .then((result) => callback(null, result))
+        .catch((err) => callback(err));
+}
+exports.ensureDatatypeExtractedWithCallback = ensureDatatypeExtractedWithCallback;
+function findDataTypeNode(addressSpace, encodingNodeId) {
+    const encodingNode = addressSpace.findNode(encodingNodeId);
+    // istanbul ignore next
+    if (!encodingNode) {
+        throw new Error("findDataTypeNode:  Cannot find " + encodingNodeId.toString());
+    }
+    // xx console.log("encodingNode", encodingNode.toString());
+    const refs = encodingNode.findReferences("HasEncoding", false);
+    const dataTypes = refs.map((ref) => addressSpace.findNode(ref.nodeId)).filter((obj) => obj !== null);
+    // istanbul ignore next
+    if (dataTypes.length !== 1) {
+        throw new Error("Internal Error");
+    }
+    const dataTypeNode = dataTypes[0];
+    // istanbul ignore next
+    if (dataTypeNode.nodeClass !== node_opcua_data_model_1.NodeClass.DataType) {
+        throw new Error("internal error: expecting a UADataType node here");
+    }
+    return dataTypeNode;
+}
+function decodeXmlObject(addressSpace2, xmlEncodingNodeId, xmlBody) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dataTypeManager = yield ensureDatatypeExtracted(addressSpace2);
+        const dataTypeNode = findDataTypeNode(addressSpace2, xmlEncodingNodeId);
+        const dataTypeFactory = dataTypeManager.getDataTypeFactory(xmlEncodingNodeId.namespace);
+        // istanbul ignore next
+        if (!dataTypeNode) {
+            debugLog(" cannot find ", xmlEncodingNodeId.toString());
+            return null;
+        }
+        const dataTypeName = dataTypeNode.browseName.name;
+        const definitionMap = {
+            findDefinition(name) {
+                debugLog(chalk.magentaBright("xxxxxxxxxxxxx !!!! "), name);
+                if (!name) {
+                    return { name: "", fields: [] };
+                }
+                return dataTypeFactory.getStructuredTypeSchema(name);
+            }
+        };
+        const reader = (0, node_opcua_xml2json_1.makeExtensionObjectReader)(dataTypeName, definitionMap, {});
+        const parser2 = new node_opcua_xml2json_1.Xml2Json(reader);
+        const pojo = yield parser2.parseString(xmlBody);
+        // at this time the bsd file containing object definition
+        // must have been found and object can be constructed
+        const userDefinedExtensionObject = addressSpace2.constructExtensionObject(dataTypeNode, pojo);
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("userDefinedExtensionObject", userDefinedExtensionObject.toString());
+        }
+        //
+        return userDefinedExtensionObject;
+    });
+}
+function makeEnumDefinition(definitionFields) {
+    return new node_opcua_types_1.EnumDefinition({
+        fields: definitionFields.map((x) => ({
+            description: {
+                text: x.description
+            },
+            name: x.name,
+            value: x.value
+        }))
+    });
+}
+function makeStructureDefinition(name, definitionFields, isUnion) {
+    // Structure = 0,
+    // StructureWithOptionalFields = 1,
+    // Union = 2,
+    const hasOptionalFields = definitionFields.filter((field) => field.isOptional).length > 0;
+    const structureType = isUnion
+        ? node_opcua_types_1.StructureType.Union
+        : hasOptionalFields
+            ? node_opcua_types_1.StructureType.StructureWithOptionalFields
+            : node_opcua_types_1.StructureType.Structure;
+    const sd = new node_opcua_types_1.StructureDefinition({
+        baseDataType: undefined,
+        defaultEncodingId: undefined,
+        fields: definitionFields,
+        structureType
+    });
+    return sd;
+}
+function __make_back_references(namespace) {
+    const namespaceP = namespace;
+    for (const node of namespaceP.nodeIterator()) {
+        node.propagate_back_references();
+    }
+    for (const node of namespaceP.nodeIterator()) {
+        node.install_extra_properties();
+    }
+}
+function make_back_references(addressSpace) {
+    const addressSpacePrivate = addressSpace;
+    addressSpacePrivate.suspendBackReference = false;
+    addressSpace.getNamespaceArray().map(__make_back_references);
+}
+function stringToUInt32Array(str) {
+    const array = str ? str.split(",").map((value) => parseInt(value, 10)) : null;
+    return array;
+}
+function convertAccessLevel(accessLevel) {
+    const accessLevelN = parseInt(accessLevel || "1", 10); // CurrentRead if not specified
+    return (0, node_opcua_data_model_1.makeAccessLevelFlag)(accessLevelN);
+}
+function makeDefaultVariant2(addressSpace, dataTypeNode, valueRank) {
+    const variant = { dataType: node_opcua_variant_1.DataType.Null };
+    return variant;
+}
+function makeDefaultVariant(addressSpace, dataTypeNode, valueRank) {
+    let variant = { dataType: node_opcua_variant_1.DataType.Null };
+    const nodeDataType = addressSpace.findNode(dataTypeNode);
+    if (nodeDataType) {
+        const dataType = addressSpace.findCorrespondingBasicDataType(dataTypeNode);
+        if (dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+            // console.log("xxxxxxxxxx ", dataTypeNode.toString(addressSpace as any));
+            return { dataType: node_opcua_variant_1.DataType.ExtensionObject, value: null };
+        }
+        const dv = (0, node_opcua_factory_1.findSimpleType)(node_opcua_variant_1.DataType[dataType]).defaultValue;
+        if (dv === undefined || dv === null) {
+            // return
+            return { dataType: node_opcua_variant_1.DataType.Null };
+        }
+        let arrayType;
+        const value = typeof dv === "function" ? dv() : dv;
+        //  if (dataType === DataType.ByteString ) { value = Buffer.alloc(0) }
+        /*
+         *  * n > 1                     : the Value is an array with the specified number of dimensions.
+         *  * OneDimension (1):           The value is an array with one dimension.
+         *  * OneOrMoreDimensions (0):    The value is an array with one or more dimensions.
+         *  * Scalar (-1):                The value is not an array.
+         *  * Any (-2):                   The value can be a scalar or an array with any number of dimensions.
+         *  * ScalarOrOneDimension (-3):  The value can be a scalar or a one dimensional array.
+         */
+        switch (valueRank) {
+            case -3: //  ScalarOrOneDimension (-3):
+            case -2: // any
+            case -1:
+                arrayType = node_opcua_variant_1.VariantArrayType.Scalar;
+                variant = { dataType, value, arrayType };
+                break;
+            case 0: // one or more dimension
+            case 1: // one dimension
+                arrayType = node_opcua_variant_1.VariantArrayType.Array;
+                variant = { dataType, value: [], arrayType };
+                break;
+            default:
+                arrayType = node_opcua_variant_1.VariantArrayType.Matrix;
+                variant = { dataType, value: [], arrayType, dimensions: [] };
+                break;
+        }
+        // console.log(variant, DataType[dataType], valueRank);
+    }
+    return variant;
+}
+function makeStuff(addressSpace) {
+    const addressSpace1 = addressSpace;
+    addressSpace1.suspendBackReference = true;
+    let postTasks = [];
+    let postTaskInitializeVariable = [];
+    let postTasks2 = [];
+    let postTasks3 = [];
+    let alias_map = {};
+    /**
+     * @param aliasName
+     */
+    function addAlias(aliasName, nodeIdInXmlContext) {
+        (0, node_opcua_assert_1.assert)(typeof nodeIdInXmlContext === "string");
+        const nodeId = _translateNodeId(nodeIdInXmlContext);
+        (0, node_opcua_assert_1.assert)(nodeId instanceof node_opcua_nodeid_1.NodeId);
+        alias_map[aliasName] = nodeId;
+        addressSpace1.getNamespace(nodeId.namespace).addAlias(aliasName, nodeId);
+    }
+    let namespace_uri_translation = {};
+    let namespaceCounter = 0;
+    let found_namespace_in_uri = {};
+    function _reset_namespace_translation() {
+        debugLog("_reset_namespace_translation");
+        namespace_uri_translation = {};
+        found_namespace_in_uri = {};
+        namespaceCounter = 0;
+        _register_namespace_uri("http://opcfoundation.org/UA/");
+        alias_map = {};
+    }
+    function _translateNamespaceIndex(innerIndex) {
+        const namespaceIndex = namespace_uri_translation[innerIndex];
+        // istanbul ignore next
+        if (namespaceIndex === undefined) {
+            // tslint:disable-next-line: no-console
+            debugLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
+            throw new Error("_translateNamespaceIndex! Cannot find namespace definition for index " + innerIndex);
+        }
+        return namespaceIndex;
+    }
+    function _internal_addReferenceType(params) {
+        // istanbul ignore next
+        if (!(params.nodeId instanceof node_opcua_nodeid_1.NodeId)) {
+            throw new Error("invalid param");
+        } // already translated
+        const namespace = addressSpace1.getNamespace(params.nodeId.namespace);
+        namespace.addReferenceType(params);
+    }
+    function _internal_createNode(params) {
+        // istanbul ignore next
+        if (!(params.nodeId instanceof node_opcua_nodeid_1.NodeId)) {
+            throw new Error("invalid param expecting a valid nodeId");
+        } // already translated
+        const namespace = addressSpace1.getNamespace(params.nodeId.namespace);
+        return namespace.internalCreateNode(params);
+    }
+    function _register_namespace_uri(namespaceUri) {
+        if (found_namespace_in_uri[namespaceUri]) {
+            return found_namespace_in_uri[namespaceUri];
+        }
+        const namespace = addressSpace1.registerNamespace(namespaceUri);
+        found_namespace_in_uri[namespaceUri] = namespace;
+        const index_in_xml = namespaceCounter;
+        namespaceCounter++;
+        namespace_uri_translation[index_in_xml] = namespace.index;
+        debugLog(" _register_namespace_uri = ", namespaceUri, "index in Xml=", index_in_xml, " index in addressSpace", namespace.index);
+        return namespace;
+    }
+    function _register_namespace_uri_model(model) {
+        const namespace = _register_namespace_uri(model.modelUri);
+        namespace.version = model.version;
+        namespace.publicationDate = model.publicationDate;
+        return namespace;
+    }
+    const reg = /ns=([0-9]+);(.*)/;
+    function _translateNodeId(nodeId) {
+        if (alias_map[nodeId]) {
+            return alias_map[nodeId];
+        }
+        const m = nodeId.match(reg);
+        if (m) {
+            const namespaceIndex = _translateNamespaceIndex(parseInt(m[1], 10));
+            nodeId = "ns=" + namespaceIndex + ";" + m[2];
+        }
+        return (0, node_opcua_nodeid_1.resolveNodeId)(nodeId);
+    }
+    function _translateReferenceType(refType) {
+        return _translateNodeId(refType);
+    }
+    /**
+     * convert a nodeId
+     *
+     * @method convertToNodeId
+     * @param nodeId {String|null}
+     * @return {NodeId}
+     *
+     * @example
+     *    convertToNodeId("String") => resolve alias
+     *    convertToNodeId("i=58")   => resolve to nodeId in namespace 0
+     *    convertToNodeId("ns=1;i=100") => convert namespace from xml namespace
+     *                                      table to corresponding namespace in addressSpace
+     */
+    function convertToNodeId(nodeIdLike) {
+        // treat alias
+        if (!nodeIdLike) {
+            return null;
+        }
+        const nodeId = _translateNodeId(nodeIdLike);
+        return addressSpace1.resolveNodeId(nodeId);
+    }
+    function convertQualifiedName(qualifiedName) {
+        const qn = (0, node_opcua_data_model_1.stringToQualifiedName)(qualifiedName);
+        // Xx if (qn.namespaceIndex > 0) {
+        qn.namespaceIndex = _translateNamespaceIndex(qn.namespaceIndex);
+        // Xx }
+        return qn;
+    }
+    const state_Alias = {
+        finish() {
+            addAlias(this.attrs.Alias, this.text);
+        }
+    };
+    const references_parser = {
+        init() {
+            this.parent.obj.references = [];
+            this.array = this.parent.obj.references;
+        },
+        parser: {
+            Reference: {
+                finish() {
+                    this.parent.array.push({
+                        isForward: this.attrs.IsForward === undefined ? true : this.attrs.IsForward === "false" ? false : true,
+                        nodeId: convertToNodeId(this.text),
+                        referenceType: _translateReferenceType(this.attrs.ReferenceType)
+                    });
+                }
+            }
+        }
+    };
+    const state_UAObject = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.Object;
+            this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.eventNotifier = ec.coerceByte(attrs.EventNotifier) || 0;
+            this.obj.symbolicName = attrs.SymbolicName || null;
+        },
+        finish() {
+            _internal_createNode(this.obj);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            References: references_parser
+        }
+    };
+    const state_UAObjectType = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.ObjectType;
+            this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.eventNotifier = ec.coerceByte(attrs.EventNotifier) || 0;
+        },
+        finish() {
+            _internal_createNode(this.obj);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            References: references_parser
+        }
+    };
+    const state_UAReferenceType = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.ReferenceType;
+            this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+        },
+        finish() {
+            _internal_addReferenceType(this.obj);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            InverseName: {
+                finish() {
+                    this.parent.obj.inverseName = this.text;
+                }
+            },
+            References: references_parser
+        }
+    };
+    const pendingSimpleTypeToRegister = [];
+    const state_UADataType = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.DataType;
+            this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract) || false;
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.displayName = "";
+            this.obj.description = "";
+            this.obj.symbolicName = attrs.SymbolicName;
+            this.isDraft = attrs.ReleaseStatus === "Draft";
+            this.definitionFields = [];
+        },
+        finish() {
+            if (this.isDraft) {
+                // ignore Draft element
+                debugLog("Ignoring Draft dataType =", this.obj.browseName.toString());
+                return;
+            }
+            let definitionFields = this.definitionFields;
+            // replace DataType with nodeId
+            definitionFields = definitionFields.map((x) => {
+                if (x.dataType) {
+                    x.dataType = convertToNodeId(x.dataType);
+                }
+                return x;
+            });
+            const dataTypeNode = _internal_createNode(this.obj);
+            (0, node_opcua_assert_1.assert)(addressSpace1.findNode(this.obj.nodeId));
+            const definitionName = dataTypeNode.browseName.name;
+            let alreadyCalled = false;
+            const processBasicDataType = (addressSpace2) => __awaiter(this, void 0, void 0, function* () {
+                (0, node_opcua_assert_1.assert)(!alreadyCalled);
+                alreadyCalled = true;
+                const enumeration = addressSpace2.findDataType("Enumeration");
+                const structure = addressSpace2.findDataType("Structure");
+                const union = addressSpace2.findDataType("Union");
+                // we have a data type from a companion specification
+                // let's see if this data type need to be registered
+                const isEnumeration = enumeration && dataTypeNode.isSupertypeOf(enumeration);
+                const isStructure = structure && dataTypeNode.isSupertypeOf(structure);
+                const isUnion = !!(structure && union && dataTypeNode.isSupertypeOf(union));
+                if (definitionFields.length) {
+                    // remove <namespace>:
+                    const nameWithoutNamespace = definitionName.split(":").slice(-1)[0];
+                    if (isStructure /*&& dataTypeNode.nodeId.namespace !== 0*/) {
+                        // note: at this stage, structure definition will be incomplete as we do not know
+                        //       what is the subType yet, encodings are also unknown...
+                        //       structureType may also be inaccurate
+                        debugLog("setting structure $definition for ", definitionName, nameWithoutNamespace);
+                        dataTypeNode.$definition = makeStructureDefinition(definitionName, definitionFields, isUnion);
+                    }
+                    else if (isEnumeration /* && dataTypeNode.nodeId.namespace !== 0 */) {
+                        dataTypeNode.$definition = makeEnumDefinition(definitionFields);
+                    }
+                }
+                if (!isEnumeration && !isStructure && this.obj.nodeId.namespace !== 0) {
+                    pendingSimpleTypeToRegister.push({ name: definitionName, dataTypeNodeId: dataTypeNode.nodeId });
+                }
+            });
+            postTasks.push(processBasicDataType);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            References: references_parser,
+            Definition: node_opcua_xml2json_1._definitionParser
+        }
+    };
+    const localizedText_parser = {
+        LocalizedText: {
+            init() {
+                this.localizedText = {};
+            },
+            parser: {
+                Locale: {
+                    finish() {
+                        this.parent.localizedText.locale = this.text.trim();
+                    }
+                },
+                Text: {
+                    finish() {
+                        this.parent.localizedText.text = this.text.trim();
+                    }
+                }
+            }
+        }
+    };
+    const qualifiedName_parser = {
+        QualifiedName: {
+            init() {
+                this.qualifiedName = {
+                    namespaceIndex: 0,
+                    name: null
+                };
+            },
+            parser: {
+                Name: {
+                    finish() {
+                        this.parent.qualifiedName.name = this.text.trim();
+                    }
+                },
+                NamespaceIndex: {
+                    finish() {
+                        const ns = parseInt(this.text, 10);
+                        const t = _translateNodeId((0, node_opcua_nodeid_1.resolveNodeId)(`ns=${ns};i=1`).toString());
+                        this.parent.qualifiedName.namespaceIndex = t.namespace;
+                    }
+                }
+            }
+        }
+    };
+    const nodeId_parser = {
+        NodeId: {
+            init() {
+                this.nodeId = "";
+            },
+            parser: {
+                Identifier: {
+                    finish() {
+                        this.parent.nodeId = _translateNodeId((0, node_opcua_nodeid_1.resolveNodeId)(this.text.trim()).toString());
+                    }
+                }
+            }
+        }
+    };
+    const enumValueType_parser = {
+        EnumValueType: {
+            init() {
+                this.enumValueType = new node_opcua_types_1.EnumValueType({
+                    description: undefined,
+                    displayName: undefined,
+                    value: [0, 0] // Int64
+                });
+            },
+            parser: {
+                Value: {
+                    finish() {
+                        // Low part
+                        this.parent.enumValueType.value[1] = parseInt(this.text, 10);
+                    }
+                },
+                DisplayName: Object.assign(Object.assign({}, localizedText_parser.LocalizedText), { finish() {
+                        this.parent.enumValueType.displayName = Object.assign({}, this.localizedText);
+                    } }),
+                Description: Object.assign(Object.assign({}, localizedText_parser.LocalizedText), { finish() {
+                        this.parent.enumValueType.description = Object.assign({}, this.localizedText);
+                    } })
+            },
+            finish() {
+                this.enumValueType = new node_opcua_types_1.EnumValueType(this.enumValueType);
+            }
+        }
+    };
+    const argument_parser = {
+        Argument: {
+            init() {
+                this.argument = new node_opcua_service_call_1.Argument({});
+            },
+            parser: {
+                Name: {
+                    finish() {
+                        this.parent.argument.name = this.text.trim();
+                    }
+                },
+                DataType: {
+                    parser: {
+                        Identifier: {
+                            finish() {
+                                this.parent.parent.argument.dataType = _translateNodeId((0, node_opcua_nodeid_1.resolveNodeId)(this.text.trim()).toString());
+                            }
+                        }
+                    }
+                },
+                ValueRank: {
+                    finish() {
+                        this.parent.argument.valueRank = parseInt(this.text.trim(), 10);
+                    }
+                },
+                ArrayDimensions: {
+                    finish() {
+                        // xx  this.parent.argument.arrayDimensions =[];
+                    }
+                },
+                Description: {
+                    init() {
+                        this._text = "";
+                        this.locale = null;
+                        this.text = null;
+                    },
+                    parser: {
+                        Locale: {
+                            init() {
+                                this.text = "";
+                            },
+                            finish() {
+                                this.parent.locale = this.text.trim();
+                            }
+                        },
+                        Text: {
+                            finish() {
+                                this.text = this.text || "";
+                                this.parent._text = this.text.trim();
+                            }
+                        }
+                    },
+                    finish() {
+                        this.parent.argument.description = (0, node_opcua_data_model_1.coerceLocalizedText)(this._text);
+                    }
+                }
+            },
+            finish() {
+                // xx this.argument = new Argument(this.argument);
+            }
+        }
+    };
+    const Range_parser = {
+        Range: {
+            init() {
+                this.range = new node_opcua_types_1.Range({});
+            },
+            parser: {
+                Low: {
+                    finish() {
+                        this.parent.range.low = parseFloat(this.text);
+                    }
+                },
+                High: {
+                    finish() {
+                        this.parent.range.high = parseFloat(this.text);
+                    }
+                }
+            }
+        }
+    };
+    const EUInformation_parser = {
+        EUInformation: {
+            init() {
+                this.euInformation = new node_opcua_data_access_1.EUInformation({});
+            },
+            parser: {
+                NamespaceUri: {
+                    finish() {
+                        this.parent.euInformation.namespaceUri = this.text;
+                    }
+                },
+                UnitId: {
+                    finish() {
+                        this.parent.euInformation.unitId = parseInt(this.text, 10);
+                    }
+                },
+                DisplayName: Object.assign(Object.assign({}, localizedText_parser.LocalizedText), { finish() {
+                        this.parent.euInformation.displayName = Object.assign({}, this.localizedText);
+                    } }),
+                Description: Object.assign(Object.assign({}, localizedText_parser.LocalizedText), { finish() {
+                        this.parent.euInformation.description = Object.assign({}, this.localizedText);
+                    } })
+            },
+            finish() {
+                this.euInformation = new node_opcua_data_access_1.EUInformation(this.euInformation);
+            }
+        }
+    };
+    const _extensionObject_inner_parser = {
+        TypeId: {
+            parser: {
+                Identifier: {
+                    finish() {
+                        const typeDefinitionId = this.text.trim();
+                        const self = this.parent.parent; // ExtensionObject
+                        self.typeDefinitionId = (0, node_opcua_nodeid_1.resolveNodeId)(typeDefinitionId);
+                    }
+                }
+            }
+        },
+        Body2: new node_opcua_xml2json_1.FragmentClonerParser(),
+        Body: {
+            parser: {
+                Argument: argument_parser.Argument,
+                EUInformation: EUInformation_parser.EUInformation,
+                EnumValueType: enumValueType_parser.EnumValueType,
+                Range: Range_parser.Range
+            },
+            startElement(elementName, attrs) {
+                const self = this.parent; // ExtensionObject
+                self.extensionObject = null;
+                self.extensionObjectPojo = null;
+                if (!Object.prototype.hasOwnProperty.call(this.parser, elementName)) {
+                    // treat it as a opaque XML bloc for the time being
+                    // until we find the definition of this object, so we know how to interpret the fields
+                    this._cloneFragment = new node_opcua_xml2json_1.InternalFragmentClonerReaderState();
+                    this.engine._promote(this._cloneFragment, this.engine.currentLevel, elementName, attrs);
+                }
+            },
+            finish() {
+                const self = this.parent; // ExtensionObject
+                // typeDefinitionId is also the "Default XML" encoding nodeId !
+                switch (self.typeDefinitionId.toString()) {
+                    case "i=7616": // EnumValueType
+                    case "ns=0;i=7616": // EnumValueType
+                        self.extensionObject = self.parser.Body.parser.EnumValueType.enumValueType;
+                        (0, node_opcua_assert_1.assert)(self.extensionObject !== null && typeof self.extensionObject === "object");
+                        (0, node_opcua_assert_1.assert)(self.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject);
+                        break;
+                    case "i=297": // Arguments
+                    case "ns=0;i=297": // Arguments
+                        self.extensionObject = self.parser.Body.parser.Argument.argument;
+                        (0, node_opcua_assert_1.assert)(self.extensionObject !== null && typeof self.extensionObject === "object");
+                        (0, node_opcua_assert_1.assert)(self.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject);
+                        break;
+                    case "i=888":
+                    case "ns=0;i=888": // EUInformation
+                        self.extensionObject = self.parser.Body.parser.EUInformation.euInformation;
+                        (0, node_opcua_assert_1.assert)(self.extensionObject !== null && typeof self.extensionObject === "object");
+                        (0, node_opcua_assert_1.assert)(self.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject);
+                        break;
+                    case "i=885": // Range
+                    case "ns=0;i=885":
+                        self.extensionObject = self.parser.Body.parser.Range.range;
+                        (0, node_opcua_assert_1.assert)(self.extensionObject !== null && typeof self.extensionObject === "object");
+                        (0, node_opcua_assert_1.assert)(self.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject);
+                        break;
+                    default: {
+                        this.bodyXML = this._cloneFragment.value;
+                        this._cloneFragment.value = null;
+                        // the "Default Xml" encoding  nodeId
+                        const xmlEncodingNodeId = _translateNodeId(self.typeDefinitionId.toString());
+                        const xmlBody = this.bodyXML;
+                        // this is a user defined Extension Object
+                        debugLog("load nodeset2: typeDefinitionId in ExtensionObject Default XML = " + xmlEncodingNodeId.toString());
+                        if (doDebug) {
+                            debugLog("xxxx ", chalk.yellow(xmlBody));
+                        }
+                        const postTaskData = self.postTaskData;
+                        const task = (addressSpace2) => __awaiter(this, void 0, void 0, function* () {
+                            const extensionObject = yield decodeXmlObject(addressSpace2, xmlEncodingNodeId, xmlBody);
+                            if (postTaskData) {
+                                postTaskData.postponedExtensionObject = extensionObject;
+                            }
+                        });
+                        postTasks2.push(task);
+                        self.extensionObjectPojo = null;
+                        (0, node_opcua_assert_1.assert)(!self.extensionObject || self.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject);
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    const extensionObject_parser = {
+        ExtensionObject: {
+            init() {
+                this.typeDefinitionId = "";
+                this.extensionObject = null;
+                this.extensionObjectPojo = null;
+            },
+            parser: _extensionObject_inner_parser,
+            finish() {
+                /* empty */
+            }
+        }
+    };
+    function BasicType_parser(dataType, parseFunc) {
+        const _parser = {};
+        const r = {
+            init(name, attrs) {
+                this.value = 0;
+            },
+            finish() {
+                this.value = parseFunc.call(this, this.text);
+            }
+        };
+        _parser[dataType] = r;
+        return _parser;
+    }
+    function ListOf(dataType, parseFunc) {
+        return {
+            init() {
+                this.listData = [];
+            },
+            parser: BasicType_parser(dataType, parseFunc),
+            finish() {
+                this.parent.parent.obj.value = {
+                    arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                    dataType: node_opcua_variant_1.DataType[dataType],
+                    value: this.listData
+                };
+            },
+            endElement(element) {
+                this.listData.push(this.parser[dataType].value);
+            }
+        };
+    }
+    function parser2(type, p) {
+        return {
+            finish() {
+                this.parent.parent.obj.value = {
+                    dataType: node_opcua_variant_1.DataType[type],
+                    value: p(this.text)
+                };
+            }
+        };
+    }
+    const state_Variant = {
+        init: () => {
+            /* empty */
+        },
+        parser: {
+            QualifiedName: Object.assign(Object.assign({}, qualifiedName_parser.QualifiedName), { finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.QualifiedName,
+                        value: this.qualifiedName
+                    };
+                } }),
+            LocalizedText: Object.assign(Object.assign({}, localizedText_parser.LocalizedText), { finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.LocalizedText,
+                        value: this.localizedText
+                    };
+                } }),
+            XmlElement: {
+                finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.XmlElement,
+                        value: this.text
+                    };
+                }
+            },
+            String: {
+                finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.String,
+                        value: this.text
+                    };
+                }
+            },
+            Guid: {
+                parser: {
+                    String: {
+                        finish() {
+                            const guid = this.text;
+                            if (!(0, node_opcua_basic_types_1.isValidGuid)(guid)) {
+                                /* ?*/
+                            }
+                            this.parent.parent.parent.obj.value = {
+                                dataType: node_opcua_variant_1.DataType.Guid,
+                                arrayType: node_opcua_variant_1.VariantArrayType.Scalar,
+                                value: this.text
+                            };
+                        }
+                    }
+                }
+            },
+            NodeId: {
+                parser: {
+                    Identifier: {
+                        finish() {
+                            const nodeId = this.text;
+                            this.parent.parent.parent.obj.value = {
+                                dataType: node_opcua_variant_1.DataType.NodeId,
+                                arrayType: node_opcua_variant_1.VariantArrayType.Scalar,
+                                value: _translateNodeId((0, node_opcua_nodeid_1.resolveNodeId)(nodeId).toString())
+                            };
+                        }
+                    }
+                }
+            },
+            Boolean: parser2("Boolean", ec.coerceBoolean),
+            Byte: parser2("Byte", parseInt),
+            Int16: parser2("Int16", parseInt),
+            Int32: parser2("Int32", parseInt),
+            Int8: parser2("Int8", parseInt),
+            SByte: parser2("SByte", parseInt),
+            UInt16: parser2("UInt16", parseInt),
+            UInt32: parser2("UInt32", parseInt),
+            UInt8: parser2("UInt8", parseInt),
+            ByteString: {
+                init() {
+                    this.value = null;
+                },
+                finish() {
+                    const base64text = this.text;
+                    const byteString = Buffer.from(base64text, "base64");
+                    this.parent.parent.obj.value = {
+                        arrayType: node_opcua_variant_1.VariantArrayType.Scalar,
+                        dataType: node_opcua_variant_1.DataType.ByteString,
+                        value: byteString
+                    };
+                }
+            },
+            Float: {
+                finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.Float,
+                        value: parseFloat(this.text)
+                    };
+                }
+            },
+            Double: {
+                finish() {
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.Double,
+                        value: parseFloat(this.text)
+                    };
+                }
+            },
+            ListOfExtensionObject: {
+                init() {
+                    this.listData = [];
+                },
+                parser: extensionObject_parser,
+                finish() {
+                    this.parent.parent.obj.value = {
+                        arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                        dataType: node_opcua_variant_1.DataType.ExtensionObject,
+                        value: this.listData
+                    };
+                },
+                startElement(elementName) {
+                    /* empty */
+                },
+                endElement(elementName) {
+                    this.listData.push(this.parser.ExtensionObject.extensionObject);
+                    if (this.parser.ExtensionObject.extensionObject) {
+                        // assert(element === "ExtensionObject");
+                        // istanbul ignore next
+                        if (!(this.parser.ExtensionObject.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject)) {
+                            throw new Error("expecting an extension object");
+                        }
+                    }
+                }
+            },
+            ListOfLocalizedText: {
+                init() {
+                    this.listData = [];
+                },
+                parser: localizedText_parser,
+                finish() {
+                    this.parent.parent.obj.value = {
+                        arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                        dataType: node_opcua_variant_1.DataType.LocalizedText,
+                        value: this.listData
+                    };
+                },
+                endElement() {
+                    this.listData.push(this.parser.LocalizedText.localizedText);
+                }
+            },
+            ListOfQualifiedName: {
+                init() {
+                    this.listData = [];
+                },
+                parser: qualifiedName_parser,
+                finish() {
+                    this.parent.parent.obj.value = {
+                        arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                        dataType: node_opcua_variant_1.DataType.QualifiedName,
+                        value: this.listData
+                    };
+                },
+                endElement() {
+                    this.listData.push(this.parser.QualifiedName.qualifiedName);
+                }
+            },
+            ListOfNodeId: {
+                init() {
+                    this.listData = [];
+                },
+                parser: nodeId_parser,
+                finish() {
+                    this.parent.parent.obj.value = {
+                        arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                        dataType: node_opcua_variant_1.DataType.NodeId,
+                        value: this.listData
+                    };
+                },
+                endElement(elementName) {
+                    this.listData.push(this.parser.NodeId.nodeId);
+                }
+            },
+            ListOfBoolean: ListOf("Boolean", ec.coerceBoolean),
+            ListOfByte: ListOf("Byte", parseInt),
+            ListOfDouble: ListOf("Double", parseFloat),
+            ListOfFloat: ListOf("Float", parseFloat),
+            ListOfInt32: ListOf("Int32", parseInt),
+            ListOfInt16: ListOf("Int16", parseInt),
+            ListOfInt8: ListOf("Int8", parseInt),
+            ListOfUInt32: ListOf("UInt32", parseInt),
+            ListOfUInt16: ListOf("UInt16", parseInt),
+            ListOfUInt8: ListOf("UInt8", parseInt),
+            ListOfString: ListOf("String", (value) => value),
+            ListOfXmlElement: ListOf("XmlElement", (value) => value),
+            ExtensionObject: {
+                init() {
+                    this.typeDefinitionId = {};
+                    this.extensionObject = null;
+                    this.postTaskData = {};
+                },
+                parser: _extensionObject_inner_parser,
+                finish() {
+                    // istanbul ignore next
+                    if (this.extensionObject && !(this.extensionObject instanceof node_opcua_extension_object_1.ExtensionObject)) {
+                        throw new Error("expecting an extension object");
+                    }
+                    this.parent.parent.obj.value = {
+                        dataType: node_opcua_variant_1.DataType.ExtensionObject,
+                        value: this.extensionObject
+                    };
+                    // let's create the mechanism that postpone the creation of the
+                    // extension object
+                    const data = this.postTaskData;
+                    data.variant = this.parent.parent.obj.value;
+                    if (!data.variant) {
+                        data.nodeId = this.parent.parent.obj.nodeId;
+                        this.postTaskData = null;
+                        const task = (addressSpace2) => __awaiter(this, void 0, void 0, function* () {
+                            data.variant.value = data.postponedExtensionObject;
+                            (0, node_opcua_assert_1.assert)(data.nodeId, "expecting a nodeid");
+                            const node = addressSpace2.findNode(data.nodeId);
+                            if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+                                const v = node;
+                                v.setValueFromSource(data.variant);
+                            }
+                            if (node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+                                const v = node;
+                                v /*fix me*/.value.value = data.variant.value;
+                            }
+                        });
+                        postTasks3.push(task);
+                    }
+                }
+            }
+        }
+    };
+    const state_UAVariable = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.Variable;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.parentNodeId = convertToNodeId(attrs.ParentNodeId);
+            this.obj.dataType = convertToNodeId(attrs.DataType);
+            this.obj.valueRank = attrs.ValueRank === undefined ? -1 : ec.coerceInt32(attrs.ValueRank);
+            this.obj.arrayDimensions = this.obj.valueRank <= 0 ? null : stringToUInt32Array(attrs.ArrayDimensions);
+            this.obj.minimumSamplingInterval = attrs.MinimumSamplingInterval ? parseInt(attrs.MinimumSamplingInterval, 10) : 0;
+            this.obj.minimumSamplingInterval = parseInt(this.obj.minimumSamplingInterval, 10);
+            this.obj.historizing = false;
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.accessLevel = convertAccessLevel(attrs.AccessLevel);
+            this.obj.userAccessLevel = this.obj.accessLevel; // convertAccessLevel(attrs.UserAccessLevel || attrs.AccessLevel);
+        },
+        finish() {
+            /*
+            // set default value based on obj data Type
+            if (this.obj.value === undefined) {
+                const dataTypeNode = this.obj.dataType;
+                const valueRank = this.obj.valueRank;
+                this.obj.value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank);
+            }
+            */
+            // eslint-disable-next-line prefer-const
+            let variable;
+            if (this.obj.value) {
+                const capturedValue = this.obj.value;
+                const task = (addressSpace2) => __awaiter(this, void 0, void 0, function* () {
+                    if (false && doDebug) {
+                        debugLog("1 setting value to ", variable.nodeId.toString(), new node_opcua_variant_1.Variant(capturedValue).toString());
+                    }
+                    variable.setValueFromSource(capturedValue);
+                });
+                postTaskInitializeVariable.push(task);
+            }
+            else {
+                const task = (addressSpace2) => __awaiter(this, void 0, void 0, function* () {
+                    const dataTypeNode = variable.dataType;
+                    const valueRank = variable.valueRank;
+                    const value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank);
+                    if (value) {
+                        if (false && doDebug) {
+                            debugLog("2 setting value to ", variable.nodeId.toString(), value);
+                        }
+                        if (value.dataType === node_opcua_variant_1.DataType.Null) {
+                            variable.setValueFromSource(value, node_opcua_basic_types_1.StatusCodes.BadWaitingForInitialData);
+                        }
+                        else {
+                            variable.setValueFromSource(value, node_opcua_basic_types_1.StatusCodes.Good);
+                        }
+                    }
+                });
+                postTaskInitializeVariable.push(task);
+            }
+            this.obj.value = undefined;
+            variable = _internal_createNode(this.obj);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            References: references_parser,
+            Value: state_Variant
+        }
+    };
+    const state_UAVariableType = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.VariableType;
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.parentNodeId = attrs.ParentNodeId || null;
+            this.obj.dataType = convertToNodeId(attrs.DataType) || null;
+            this.obj.valueRank = ec.coerceInt32(attrs.ValueRank) || -1;
+            this.obj.arrayDimensions = this.obj.valueRank <= 0 ? null : stringToUInt32Array(attrs.ArrayDimensions);
+            this.obj.minimumSamplingInterval = attrs.MinimumSamplingInterval ? parseInt(attrs.MinimumSamplingInterval, 10) : 0;
+            this.obj.historizing = false;
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+        },
+        finish() {
+            try {
+                _internal_createNode(this.obj);
+            } /* istanbul ignore next */
+            catch (err) {
+                this.obj.addressSpace = null;
+                // tslint:disable:no-console
+                console.warn(" Cannot create object", JSON.stringify(this.obj, null, " "));
+                throw err;
+            }
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            Description: {
+                finish() {
+                    this.parent.obj.description = this.text;
+                }
+            },
+            References: references_parser,
+            Value: state_Variant
+        }
+    };
+    const state_UAMethod = {
+        init(name, attrs) {
+            this.obj = {};
+            this.obj.nodeClass = node_opcua_data_model_1.NodeClass.Method;
+            // MethodDeclarationId
+            // ParentNodeId
+            this.obj.browseName = convertQualifiedName(attrs.BrowseName);
+            this.obj.parentNodeId = attrs.ParentNodeId || null;
+            this.obj.nodeId = convertToNodeId(attrs.NodeId) || null;
+            this.obj.methodDeclarationId = attrs.MethodDeclarationId ? _translateNodeId(attrs.MethodDeclarationId) : null;
+        },
+        finish() {
+            _internal_createNode(this.obj);
+        },
+        parser: {
+            DisplayName: {
+                finish() {
+                    this.parent.obj.displayName = this.text;
+                }
+            },
+            References: references_parser
+        }
+    };
+    const state_ModelTableEntry = new node_opcua_xml2json_1.ReaderState({
+        // ModelTableEntry
+        init() {
+            this._requiredModels = [];
+        },
+        parser: {
+        // xx  "RequiredModel":  null
+        },
+        finish() {
+            const modelUri = this.attrs.ModelUri; // //"http://opcfoundation.org/UA/"
+            const version = this.attrs.Version; // 1.04
+            const publicationDate = this.attrs.PublicationDate; // "2018-05-15T00:00:00Z" "
+            // optional,
+            const symbolicName = this.attrs.SymbolicName;
+            const accessRestrictions = this.attrs.AccessRestrictions;
+            const namespace = _register_namespace_uri_model({
+                accessRestrictions,
+                modelUri,
+                publicationDate,
+                requiredModels: this._requiredModels,
+                symbolicName,
+                version
+            });
+            this._requiredModels.push(namespace);
+        }
+    });
+    // state_ModelTableEntry.parser["RequiredModel"] = state_ModelTableEntry;
+    const state_0 = {
+        parser: {
+            Aliases: { parser: { Alias: state_Alias } },
+            NamespaceUris: {
+                init() {
+                    //
+                },
+                parser: {
+                    Uri: {
+                        finish() {
+                            _register_namespace_uri(this.text);
+                        }
+                    }
+                }
+            },
+            Models: {
+                // ModelTable
+                init() {
+                    //
+                },
+                parser: {
+                    Model: state_ModelTableEntry
+                },
+                finish() {
+                    //
+                }
+            },
+            UADataType: state_UADataType,
+            UAMethod: state_UAMethod,
+            UAObject: state_UAObject,
+            UAObjectType: state_UAObjectType,
+            UAReferenceType: state_UAReferenceType,
+            UAVariable: state_UAVariable,
+            UAVariableType: state_UAVariableType
+        }
+    };
+    const parser = new node_opcua_xml2json_1.Xml2Json(state_0);
+    function terminate(callback) {
+        var _a, _b, _c;
+        make_back_references(addressSpace1);
+        // setting up Server_NamespaceArray
+        if ((_c = (_b = (_a = addressSpace1.rootFolder) === null || _a === void 0 ? void 0 : _a.objects) === null || _b === void 0 ? void 0 : _b.server) === null || _c === void 0 ? void 0 : _c.namespaceArray) {
+            addressSpace1.rootFolder.objects.server.namespaceArray.setValueFromSource({
+                arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                dataType: node_opcua_variant_1.DataType.String,
+                value: addressSpace1.getNamespaceArray().map((ns) => ns.namespaceUri)
+            });
+            // istanbul ignore next
+            if (doDebug) {
+                debugLog("addressSpace NS = ", addressSpace1.rootFolder.objects.server.namespaceArray.readValue().value.value.join(" "));
+            }
+        }
+        debugLog(chalk.bgGreenBright("Performing post loading tasks -------------------------------------------") + chalk.green("DONE"));
+        function performPostLoadingTasks(tasks) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (const task of tasks) {
+                    try {
+                        yield task(addressSpace1);
+                    }
+                    catch (err) {
+                        // istanbul ignore next
+                        // tslint:disable:no-console
+                        if (err instanceof Error) {
+                            console.log(" performPostLoadingTasks Err  => ", err.message, "\n", err);
+                        }
+                        yield task(addressSpace1);
+                    }
+                }
+            });
+        }
+        function finalSteps() {
+            return __awaiter(this, void 0, void 0, function* () {
+                /// ----------------------------------------------------------------------------------------
+                // perform post task
+                debugLog(chalk.bgGreenBright("Performing post loading tasks -------------------------------------------"));
+                yield performPostLoadingTasks(postTasks);
+                postTasks = [];
+                debugLog(chalk.bgGreenBright("Performing DataType extraction -------------------------------------------"));
+                (0, node_opcua_assert_1.assert)(!addressSpace1.suspendBackReference);
+                yield ensureDatatypeExtracted(addressSpace);
+                /// ----------------------------------------------------------------------------------------
+                debugLog(chalk.bgGreenBright("DataType extraction done ") + chalk.green("DONE"));
+                for (const { name, dataTypeNodeId } of pendingSimpleTypeToRegister) {
+                    if (dataTypeNodeId.namespace === 0) {
+                        continue;
+                    }
+                    const dataTypeManager = addressSpace.getDataTypeManager();
+                    const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
+                }
+                pendingSimpleTypeToRegister.splice(0);
+                debugLog(chalk.bgGreenBright("Performing post loading tasks 2 (parsing XML objects) ---------------------"));
+                yield performPostLoadingTasks(postTasks2);
+                postTasks2 = [];
+                debugLog(chalk.bgGreenBright("Performing post variable initialization ---------------------"));
+                yield performPostLoadingTasks(postTaskInitializeVariable);
+                postTaskInitializeVariable = [];
+                debugLog(chalk.bgGreenBright("Performing post loading tasks 3 (assigning Extension Object to Variables) ---------------------"));
+                yield performPostLoadingTasks(postTasks3);
+                postTasks3 = [];
+                (0, namespace_post_step_1.promoteObjectsAndVariables)(addressSpace);
+            });
+        }
+        finalSteps()
+            .then(() => callback())
+            .catch((err1) => {
+            console.log("Error ", pe.render(err1));
+            callback(err1);
+        });
+    }
+    function addNodeSet(xmlData, callback1) {
+        _reset_namespace_translation();
+        parser.parseString(xmlData, callback1);
+    }
+    return {
+        addNodeSet,
+        terminate
+    };
+}
+exports.makeStuff = makeStuff;
+class NodeSetLoader {
+    constructor(addressSpace) {
+        this._s = makeStuff(addressSpace);
+    }
+    addNodeSet(xmlData, callback) {
+        if (!callback) {
+            throw new Error("Expecting callback function");
+        }
+        return this._s.addNodeSet(xmlData, callback);
+    }
+    addNodeSetAsync(xmlData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new Promise((resolve) => {
+                this.addNodeSet(xmlData, (err) => {
+                    resolve();
+                });
+            });
+        });
+    }
+    terminate(callback) {
+        this._s.terminate(callback);
+    }
+}
+exports.NodeSetLoader = NodeSetLoader;
+//# sourceMappingURL=load_nodeset2.js.map