node-opcua-address-space 2.170.1 → 2.172.0

package/source/loader/generateAddressSpaceRaw.ts

@@ -1,11 +1,11 @@
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { CallbackT } from "node-opcua-status-code";
-import { IAddressSpace, RequiredModel } from "node-opcua-address-space-base";
-import { ReaderStateParser, ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import type { IAddressSpace, RequiredModel } from "node-opcua-address-space-base";
 import { getMinOPCUADate } from "node-opcua-date-time";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import type { CallbackT } from "node-opcua-status-code";
+import { type ReaderStateParser, type ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import type { NamespacePrivate } from "../../src/namespace_private";
 import { adjustNamespaceArray } from "../../src/nodeset_tools/adjust_namespace_array";
-import { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
-import { NamespacePrivate } from "../../src/namespace_private";
+import type { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
 import { NodeSetLoader } from "./load_nodeset2";
 
 const doDebug = checkDebugFlag(__filename);
@@ -24,7 +24,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
     const namespaceUris: string[] = [];
 
     const models: Model[] = [];
-    let currentModel: Model | undefined = undefined;
+    let currentModel: Model | undefined;
     const state0: ReaderStateParser = {
         parser: {
             UANodeSet: {
@@ -32,7 +32,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                     NamespaceUris: {
                         parser: {
                             Uri: <ReaderStateParserLike & { text: string }>{
-                                finish(this: ReaderStateParserLike & {text: string}) {
+                                finish(this: ReaderStateParserLike & { text: string }) {
                                     namespaceUris.push(this.text);
                                 }
                             }
@@ -41,7 +41,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                     Models: {
                         parser: {
                             Model: {
-                                init(elementName: string, attrs: any) {
+                                init(_elementName: string, attrs: any) {
                                     const modelUri = attrs.ModelUri;
                                     const version = attrs.Version;
                                     const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -56,7 +56,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                                 },
                                 parser: {
                                     RequiredModel: {
-                                        init(elementName: string, attrs: any) {
+                                        init(_elementName: string, attrs: any) {
                                             const modelUri = attrs.ModelUri;
                                             const version = attrs.Version;
                                             const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -146,7 +146,7 @@ export function findOrder(nodesetDescs: NodesetDesc[]): number[] {
         for (const requiredModel of model.requiredModel) {
             const requiredModelIndex = findNodesetIndex(requiredModel.modelUri);
             if (requiredModelIndex === -1) {
-                throw new Error("Cannot find namespace for " + requiredModel.modelUri);
+                throw new Error(`Cannot find namespace for ${requiredModel.modelUri}`);
             }
             const nd = nodesetDescs[requiredModelIndex];
             for (const n of nd.namespaceModel.models) {
@@ -154,7 +154,7 @@ export function findOrder(nodesetDescs: NodesetDesc[]): number[] {
             }
         }
         const nodesetIndex = findNodesetIndex(model.modelUri);
-        const alreadyIn = order.findIndex((x) => x === nodesetIndex) !== -1;
+        const alreadyIn = order.indexOf(nodesetIndex) !== -1;
         if (!alreadyIn) order.push(nodesetIndex);
     };
     const visit2 = (nodesetDesc: NodesetDesc) => {
@@ -197,7 +197,6 @@ export async function generateAddressSpaceRaw(
         }
     }
 
-
     for (let index = 0; index < order.length; index++) {
         const nodesetIndex = order[index];
         const nodeset = nodesetDesc[nodesetIndex];

package/source/loader/load_nodeset2.ts

@@ -221,8 +221,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         if (!namespace) {
             throw new Error(
                 "cannot find namespace for " +
-                namespaceUri +
-                "\nplease make sure to initialize your address space with the corresponding nodeset files"
+                    namespaceUri +
+                    "\nplease make sure to initialize your address space with the corresponding nodeset files"
             );
         }
         foundNamespaceMap.set(namespaceUri, namespace);
@@ -1038,7 +1038,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         doDebug &&
             debugLog(
                 chalk.bgGreenBright("Performing post loading tasks -------------------------------------------") +
-                chalk.green("DONE")
+                    chalk.green("DONE")
             );
 
         async function performPostLoadingTasks(tasks: Task[]): Promise<void> {

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,11 +1,29 @@
-import { IAddressSpace } from "node-opcua-address-space-base";
-import { Byte, coerceInt64, coerceUInt64, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32, UInt64 } from "node-opcua-basic-types";
+import type { IAddressSpace } from "node-opcua-address-space-base";
+import {
+    type Byte,
+    coerceInt64,
+    coerceUInt64,
+    type Int16,
+    type Int32,
+    type Int64,
+    type SByte,
+    type UInt16,
+    type UInt32,
+    type UInt64
+} from "node-opcua-basic-types";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, INodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
+import { coerceNodeId, type INodeId, type NodeId, NodeIdType } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, VariantOptions, Variant } from "node-opcua-variant";
-import { ReaderState, ReaderStateParserLike, ParserLike, XmlAttributes, IReaderState, Xml2Json, ReaderStateParser } from "node-opcua-xml2json";
+import { DataType, Variant, type VariantOptions } from "node-opcua-variant";
+import {
+    type IReaderState,
+    ReaderState,
+    type ReaderStateParser,
+    type ReaderStateParserLike,
+    type Xml2Json,
+    type XmlAttributes
+} from "node-opcua-xml2json";
 import { localizedText_parser } from "./parsers/localized_text_parser";
 import { makeQualifiedNameParser } from "./parsers/qualified_name_parser";
 import { makeVariantReader } from "./parsers/variant_parser";
@@ -50,12 +68,12 @@ const partials = {
 
     Boolean: <Parser<boolean>>{
         finish(this: Parser<boolean>) {
-            this.value = this.text.toLowerCase() === "true" ? true : false;
+            this.value = this.text.toLowerCase() === "true";
         }
     },
 
     ByteString: <Parser<Buffer>>{
-        init(this: Parser<Buffer>, name: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
+        init(this: Parser<Buffer>, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
             this.value = null;
         },
         finish(this: Parser<Buffer>) {
@@ -65,56 +83,56 @@ const partials = {
         }
     },
 
-    Float: <Parser<number>> {
+    Float: <Parser<number>>{
         finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
 
-    Double: <Parser<number>> {
+    Double: <Parser<number>>{
         finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
-    Byte: <Parser<Byte>>  {
+    Byte: <Parser<Byte>>{
         finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
-    SByte: <Parser<SByte>> {
+    SByte: <Parser<SByte>>{
         finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
-    Int8: <Parser<SByte>>  {
+    Int8: <Parser<SByte>>{
         finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
 
-    Int16: <Parser<Int16>> {
+    Int16: <Parser<Int16>>{
         finish(this: Parser<Int16>) {
             this.value = clamp(parseInt(this.text, 10), -32768, 32767);
         }
     },
-    Int32: <Parser<Int32>>  {
+    Int32: <Parser<Int32>>{
         finish(this: Parser<Int32>) {
             this.value = clamp(parseInt(this.text, 10), -2147483648, 2147483647);
         }
     },
-    Int64: <Parser<Int64>>  {
+    Int64: <Parser<Int64>>{
         finish(this: Parser<Int64>) {
             this.value = coerceInt64(parseInt(this.text, 10));
         }
     },
 
-    UInt8: <Parser<Byte>>  {
+    UInt8: <Parser<Byte>>{
         finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
 
-    UInt16: <Parser<UInt16>>   {
+    UInt16: <Parser<UInt16>>{
         finish(this: Parser<UInt16>) {
             this.value = clamp(parseInt(this.text, 10), 0, 65535);
         }
@@ -146,7 +164,7 @@ const partials = {
         }
     },
 
-    NodeId: <Parser<NodeId>> {
+    NodeId: <Parser<NodeId>>{
         finish(this: Parser<NodeId>) {
             // to do check Local or GMT
             this.value = coerceNodeId(this.text);
@@ -176,13 +194,13 @@ function _clone(a: any): any {
     if (typeof a === "string" || typeof a === "number" || typeof a === "boolean") {
         return a;
     }
-    if (a instanceof Buffer) {
+    if (Buffer.isBuffer(a)) {
         return Buffer.from(a);
     }
     if (a instanceof Date) {
         return new Date(a);
     }
-    if (a instanceof Array) {
+    if (Array.isArray(a)) {
         return a.map((x) => _clone(x));
     }
     return { ...a };
@@ -197,14 +215,10 @@ function _makeTypeReader(
     const n = dataTypeNodeId1 as INodeId;
     if (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0 && n.value === 0) {
         // a generic Extension Object
-        return { name: "Variant", reader: partials["Variant"] };
+        return { name: "Variant", reader: partials.Variant };
     }
 
-    if (
-        n.namespace === 0 &&
-        n.identifierType === NodeIdType.NUMERIC &&
-        n.value < DataType.ExtensionObject
-    ) {
+    if (n.namespace === 0 && n.identifierType === NodeIdType.NUMERIC && n.value < DataType.ExtensionObject) {
         const name = DataType[n.value as number] as string;
         const reader = partials[name as keyof typeof partials] as ReaderStateParser;
         return { name, reader };
@@ -236,14 +250,14 @@ function _makeTypeReader(
             const fieldTypename = typeReader.name;
             // c8 ignore next
             if (!fieldParser) {
-                throw new Error(" Cannot find reader for dataType " + field.dataType + " fieldTypename=" + fieldTypename);
+                throw new Error(` Cannot find reader for dataType ${field.dataType} fieldTypename=${fieldTypename}`);
             }
 
             if (field.valueRank === undefined || field.valueRank === -1) {
                 // scalar
                 const parser = fieldParser;
                 if (!parser) {
-                    throw new Error("??? " + field.dataType + "  " + field.name);
+                    throw new Error(`??? ${field.dataType}  ${field.name}`);
                 }
 
                 reader.parser![field.name!] = {
@@ -254,7 +268,7 @@ function _makeTypeReader(
                         if (fieldParser.finish) {
                             fieldParser.finish.call(this);
                         } else {
-                            debugLog("xxx check " + fieldTypename);
+                            debugLog(`xxx check ${fieldTypename}`);
                         }
                         this.parent.value = this.parent.value || Object.create(null);
                         this.parent.value[elName] = _clone(this.value);
@@ -265,14 +279,16 @@ function _makeTypeReader(
                     init(this: any) {
                         this.value = [];
                     },
-                    parser: { /** empty */},
+                    parser: {
+                        /** empty */
+                    },
                     finish(this: any) {
                         const elName = lowerFirstLetter(this.name);
                         this.parent.value = this.parent.value || Object.create(null);
                         this.parent.value[elName] = this.value;
                         this.value = undefined;
                     },
-                    startElement(name: string, attrs: XmlAttributes) {
+                    startElement(_name: string, _attrs: XmlAttributes) {
                         // empty
                     },
                     endElement(element: string) {
@@ -285,7 +301,7 @@ function _makeTypeReader(
                 throw new Error("Unsupported ValueRank !");
             }
         }
-        readerMap.set(dataTypeName,reader);
+        readerMap.set(dataTypeName, reader);
         return { name, reader };
     } else if (definition instanceof EnumDefinition) {
         const turnToInt = (value: any) => {
@@ -300,26 +316,26 @@ function _makeTypeReader(
                 }
             }
         };
-    } else if (definition?.dataType == DataType.Variant) {
+    } else if (definition?.dataType === DataType.Variant) {
         // <Value><String>Foo</String></Value>
         type Task = (addressSpace: any) => Promise<void>;
 
         let variantOptions: VariantOptions = Object.create(null);
 
         const variantReader = makeVariantReader(
-            (self, data: VariantOptions) => variantOptions = data,
-            /*setDeferredValue: */(self,data, deferedTask) => {
+            (_self, data: VariantOptions) => (variantOptions = data),
+            /*setDeferredValue: */ (_self, _data, _deferedTask) => {
                 // to do
             },
-            /* postExtensionObjectDecoding:*/(task: (addressSpace: IAddressSpace) => Promise<void>) => {
+            /* postExtensionObjectDecoding:*/ (_task: (addressSpace: IAddressSpace) => Promise<void>) => {
                 // to do
             },
-            translateNodeId,
+            translateNodeId
         );
         return {
             name,
             reader: {
-                init(this: any , name: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
+                init(this: any, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
                     this.obj = {};
                 },
                 ...variantReader,
@@ -334,7 +350,7 @@ function _makeTypeReader(
         const reader = partials[typeName as keyof typeof partials] as ReaderStateParser;
         // c8 ignore next
         if (!reader) {
-            throw new Error("missing parse for " + typeName);
+            throw new Error(`missing parse for ${typeName}`);
         }
         return { name, reader };
     }

package/source/loader/namespace_post_step.ts

@@ -1,8 +1,7 @@
+import type { IAddressSpace, INamespace, UAObject, UAVariable } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
-import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
-
-import { UAObject, UAVariable, IAddressSpace, INamespace, UAVariableType } from "node-opcua-address-space-base";
-import { NamespacePrivate } from "../../src/namespace_private";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import type { NamespacePrivate } from "../../src/namespace_private";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);

package/source/loader/parsers/extension_object_parser.ts

@@ -1,20 +1,19 @@
-import assert from "assert";
-import { IAddressSpace } from "node-opcua-address-space-base";
+import assert from "node:assert";
+import type { IAddressSpace } from "node-opcua-address-space-base";
+import { coerceInt64 } from "node-opcua-basic-types";
+import { Range } from "node-opcua-data-access";
+import { coerceLocalizedText, LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
+import { make_debugLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { InternalFragmentClonerReaderState, ParserLike, ReaderStateParser, ReaderStateParserLike } from "node-opcua-xml2json";
+import { Argument, EnumValueType, EUInformation, type EUInformationOptions } from "node-opcua-types";
+import { InternalFragmentClonerReaderState, type ParserLike, type ReaderStateParserLike } from "node-opcua-xml2json";
 import { decodeXmlExtensionObject } from "../decode_xml_extension_object";
-import { coerceLocalizedText, LocalizedText, LocalizedTextOptions } from "node-opcua-data-model";
-import { Argument, EnumValueType, EUInformation, EUInformationOptions } from "node-opcua-types";
 import { localizedText_parser } from "./localized_text_parser";
-import { coerceInt64 } from "node-opcua-basic-types";
-import { make_debugLog } from "node-opcua-debug";
-import { Range } from "node-opcua-data-access";
-
 
 const debugLog = make_debugLog("ExtensionObjectParser");
 const errorLog = make_debugLog("ExtensionObjectParser");
-const doDebug = false;
+const _doDebug = false;
 export type Task = (addressSpace: IAddressSpace) => Promise<void>;
 
 interface PostExtensionObjectData {
@@ -75,7 +74,7 @@ const makeArgumentParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
 
 // #region Range parser
 type RangeParser = ParserLike & { range: Range };
-type RangeParserL2 = ParserLike & { parent: RangeParser, text: string };
+type RangeParserL2 = ParserLike & { parent: RangeParser; text: string };
 
 const Range_parser = {
     Range: {
@@ -103,14 +102,14 @@ const Range_parser = {
 
 type EUInformationParser = ReaderStateParserLike & {
     euInformation: EUInformationOptions;
-    parser: any
+    parser: any;
 };
 type EUInformationParserLevel2 = { parent: EUInformationParser } & { text: string };
 type EUInformationParserLevel2L = { parent: EUInformationParser } & { localizedText: LocalizedTextOptions };
 
 const EUInformation_parser: ParserLike = {
     EUInformation: <EUInformationParser>{
-        init(this: EUInformationParser, name, attrs, parent, engine) {
+        init(this: EUInformationParser, _name, _attrs, _parent, _engine) {
             this.euInformation = new EUInformation({});
         },
         parser: {
@@ -150,17 +149,17 @@ const EUInformation_parser: ParserLike = {
 type EnumValueParser = ReaderStateParserLike & {
     enumValueType: EnumValueType;
     parser: {
-        Value: ReaderStateParserLike,
-        DisplayName: ReaderStateParserLike,
-        Description: ReaderStateParserLike
-    }
+        Value: ReaderStateParserLike;
+        DisplayName: ReaderStateParserLike;
+        Description: ReaderStateParserLike;
+    };
 };
 type EnumValueParserL2 = ReaderStateParserLike & { parent: EnumValueParser } & { text: string };
 type EnumValueParserL2L = { parent: EnumValueParser } & { localizedText: LocalizedTextOptions };
 
 const enumValueType_parser = {
     EnumValueType: {
-        init(this: EnumValueParser) {  
+        init(this: EnumValueParser) {
             this.enumValueType = new EnumValueType({
                 description: undefined,
                 displayName: undefined,
@@ -179,14 +178,14 @@ const enumValueType_parser = {
             DisplayName: {
                 ...localizedText_parser.LocalizedText,
                 finish(this: EnumValueParserL2L) {
-                    this.parent.enumValueType.displayName = new LocalizedText({...this.localizedText});
+                    this.parent.enumValueType.displayName = new LocalizedText({ ...this.localizedText });
                 }
             },
 
             Description: {
                 ...localizedText_parser.LocalizedText,
                 finish(this: EnumValueParserL2L) {
-                    this.parent.enumValueType.description = new LocalizedText({...this.localizedText});
+                    this.parent.enumValueType.description = new LocalizedText({ ...this.localizedText });
                 }
             }
         },
@@ -197,8 +196,6 @@ const enumValueType_parser = {
 };
 // #endregion
 
-
-
 export interface ExtensionObjectTypeIdParser {
     parent: ExtensionObjectParser;
 }
@@ -213,31 +210,30 @@ export interface ExtensionObjectParserInner {
 }
 type ExtensionObjectParser = ExtensionObjectParserInner & any;
 export interface ExtensionObjectBodyParser {
-
     parent: ExtensionObjectParser;
     _cloneFragment: InternalFragmentClonerReaderState;
     engine: any;
     parser: {
-        Argument: ArgumentParser,
-        EUInformation: EUInformationParser,
-        EnumValueType: EnumValueParser,
-        Range: RangeParser
+        Argument: ArgumentParser;
+        EUInformation: EUInformationParser;
+        EnumValueType: EnumValueParser;
+        Range: RangeParser;
     };
 }
 
 export function makeExtensionObjectInnerParser<T>(
     translateNodeId: (nodeId: string) => NodeId,
     setExtensionObject: (extensionObject: ExtensionObject) => void,
-    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void,
+    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void
 ): ReaderStateParserLike {
     const a = makeExtensionObjectParser(translateNodeId, setExtensionObject, setExtensionObjectPojo);
     return a.ExtensionObject;
-};
+}
 
 export function makeExtensionObjectParser<T>(
     translateNodeId: (nodeId: string) => NodeId,
     setExtensionObject: (extensionObject: ExtensionObject, data: T) => void,
-    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void,
+    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void
 ): ParserLike {
     return {
         ExtensionObject: <ExtensionObjectParser>{
@@ -266,47 +262,53 @@ export function makeExtensionObjectParser<T>(
                         Range: Range_parser.Range
                     },
                     startElement(this: ExtensionObjectBodyParser, elementName: string, attrs: any) {
-                        if (!Object.prototype.hasOwnProperty.call(this.parser, elementName)) {
+                        if (!Object.hasOwn(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 InternalFragmentClonerReaderState();
-                            this.engine!._promote(this._cloneFragment, this.engine!.currentLevel, elementName, attrs);
+                            this.engine?._promote(this._cloneFragment, this.engine?.currentLevel, elementName, attrs);
                         }
                     },
                     finish(this: ExtensionObjectBodyParser) {
-
                         const data = this.parent.parent as T;
                         const typeDefinitionId = this.parent.typeDefinitionId;
                         // typeDefinitionId is also the "Default XML" encoding nodeId !
                         switch (typeDefinitionId.toString()) {
                             case "i=7616": // EnumValueType
-                            case "ns=0;i=7616":
+                            case "ns=0;i=7616": {
                                 const extensionObject = this.parser.EnumValueType.enumValueType;
                                 assert(extensionObject !== null && typeof extensionObject === "object");
                                 assert(extensionObject instanceof ExtensionObject);
                                 setExtensionObject(extensionObject, data);
                                 break;
+                            }
                             case "i=297": // Arguments
-                            case "ns=0;i=297": {
-                                const extensionObject = this.parser.Argument.argument;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
-                            case "i=888":// EUInformation
-                            case "ns=0;i=888": {
-                                const extensionObject = this.parser.EUInformation.euInformation;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
+                            case "ns=0;i=297":
+                                {
+                                    const extensionObject = this.parser.Argument.argument;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
+                            case "i=888": // EUInformation
+                            case "ns=0;i=888":
+                                {
+                                    const extensionObject = this.parser.EUInformation.euInformation;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
                             case "i=885": // Range
-                            case "ns=0;i=885": {
-                                const extensionObject = this.parser.Range.range;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
+                            case "ns=0;i=885":
+                                {
+                                    const extensionObject = this.parser.Range.range;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
                             default: {
                                 // c8 ignore next
                                 if (!this._cloneFragment) {
@@ -319,13 +321,13 @@ export function makeExtensionObjectParser<T>(
                                     );
                                     break;
                                 }
-                                const bodyXML = this._cloneFragment!.value;
+                                const bodyXML = this._cloneFragment?.value;
                                 this._cloneFragment!.value = null;
 
                                 // the "Default Xml" encoding  nodeId
                                 const xmlEncodingNodeId = typeDefinitionId;
                                 if (typeDefinitionId.isEmpty()) {
-                                    debugLog("xmlEncodingNodeId is empty for " + typeDefinitionId.toString());
+                                    debugLog(`xmlEncodingNodeId is empty for ${typeDefinitionId.toString()}`);
                                     break;
                                 }
                                 setExtensionObjectPojo(xmlEncodingNodeId, bodyXML, data);
@@ -339,16 +341,15 @@ export function makeExtensionObjectParser<T>(
                 /* empty */
             }
         }
-    }
-};
-
+    };
+}
 
 export function createXMLExtensionObjectDecodingTask(
-    translateNodeId: (nodeId:string) => NodeId,
-    xmlEncodingNodeId: NodeId, bodyXML: string,
-    withDecoded: (extensionObject: ExtensionObject) => void,
+    translateNodeId: (nodeId: string) => NodeId,
+    xmlEncodingNodeId: NodeId,
+    bodyXML: string,
+    withDecoded: (extensionObject: ExtensionObject) => void
 ) {
-
     const capturedXmlBody = bodyXML;
 
     const task = async (addressSpace2: IAddressSpace) => {

package/source/loader/parsers/localized_text_parser.ts

@@ -1,5 +1,5 @@
-import { coerceLocalizedText, LocalizedTextOptions, LocalizedText } from "node-opcua-data-model";
-import { ReaderStateParserLike } from "node-opcua-xml2json";
+import { coerceLocalizedText, type LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
+import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
 type LocalizedTextParserLikeL1 = ReaderStateParserLike & {
     localizedText: LocalizedTextOptions;
@@ -16,7 +16,7 @@ export const localizedText_parser = {
         parser: {
             Locale: {
                 finish(this: LocalizedTextParserLikeL2) {
-                    this.parent.localizedText = this.parent.localizedText || { text: undefined};
+                    this.parent.localizedText = this.parent.localizedText || { text: undefined };
                     this.parent.localizedText.locale = this.text.trim();
                 }
             },

package/source/loader/parsers/nodeid_parser.ts

@@ -1,5 +1,4 @@
-import { resolveNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
-
+import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
 
 export const makeNodeIdParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
     NodeId: {
@@ -14,4 +13,4 @@ export const makeNodeIdParser = (_translateNodeId: (nodeId: string) => NodeId) =
             }
         }
     }
-});
+});