iobroker.zigbee2mqtt 3.0.21 → 3.1.5

package/lib/deviceController.js

@@ -6,17 +6,32 @@ const rgb = require('./rgb.js');
 const ImageController = require('./imageController').ImageController;
 
 /**
+ * Prüft ob eine ieee_address in der kommaseparierten debugDevices-Liste enthalten ist.
+ * String.includes() würde Substring-Matches liefern (z.B. "0x12" trifft "0x1234").
  *
+ * @param {string} debugDevices
+ * @param {string} address
+ * @returns {boolean}
+ */
+function isDebugDevice(debugDevices, address) {
+    if (!debugDevices || !address) { return false; }
+    return String(debugDevices).split(',').map((s) => s.trim()).includes(address);
+}
+
+/**
+ * Verwaltet das Erstellen und Aktualisieren von Geräte- und Gruppenobjekten in ioBroker
+ * basierend auf den Zigbee2MQTT-Exposes.
  */
 class DeviceController {
     /**
+     * Erstellt eine neue DeviceController-Instanz.
      *
-     * @param adapter
-     * @param deviceCache
-     * @param groupCache
-     * @param config
-     * @param logCustomizations
-     * @param createCache
+     * @param {object} adapter           Die ioBroker-Adapter-Instanz
+     * @param {Array}  deviceCache       Gemeinsamer Cache aller bekannten Geräte
+     * @param {Array}  groupCache        Gemeinsamer Cache aller bekannten Gruppen
+     * @param {object} config            Adapter-Konfiguration
+     * @param {object} logCustomizations Debug/Filter-Einstellungen (debugDevices, logfilter)
+     * @param {object} createCache       Cache bereits erstellter ioBroker-Objekte
      */
     constructor(adapter, deviceCache, groupCache, config, logCustomizations, createCache) {
         this.adapter = adapter;
@@ -29,29 +44,41 @@ class DeviceController {
     }
 
     /**
+     * Erstellt Geräte-Definitionen aus dem bridge/devices-Payload von Zigbee2MQTT
+     * und befüllt den deviceCache neu.
      *
-     * @param devicesMessage
+     * @param {Array} devicesMessage Array mit Gerätedaten aus dem bridge/devices-Topic
      */
     async createDeviceDefinitions(devicesMessage) {
+        // Fix 1: devicesMessage kann null/kein Array sein (z.B. leerer bridge/devices payload)
+        if (!Array.isArray(devicesMessage)) {
+            this.adapter.log.warn('createDeviceDefinitions: payload ist kein Array');
+            return;
+        }
         utils.clearArray(this.deviceCache);
         for (const devicesMessag of devicesMessage) {
-            if (this.logCustomizations.debugDevices.includes(devicesMessag.ieee_address)) {
+            if (!devicesMessag || !devicesMessag.ieee_address) {
+                continue;
+            }
+
+            if (isDebugDevice(this.logCustomizations.debugDevices, devicesMessag.ieee_address)) {
                 this.adapter.log.warn(
                     `--->>> fromZ2M -> ${devicesMessag.ieee_address} exposes: ${JSON.stringify(devicesMessag)}`
                 );
             }
 
             if (devicesMessag.definition != null) {
-                // if the device is already present in the cache, remove it
                 this.removeDeviceByIeee(this.deviceCache, devicesMessag.ieee_address);
 
-                if (devicesMessag.definition.exposes) {
+                // Fix 3: exposes muss auch ein Array sein
+                if (Array.isArray(devicesMessag.definition.exposes)) {
                     try {
                         const newDevice = await createDeviceFromExposes(devicesMessag, this.adapter);
                         newDevice.icon = await this.imageController.getDeviceIcon(devicesMessag);
                         this.deviceCache.push(newDevice);
                     } catch (err) {
-                        this.adapter.log.warn(`Cannot ${devicesMessag.friendly_name} create Device from Exposes!`);
+                        // Fix 2: friendly_name im Fehlerlog verwenden
+                        this.adapter.log.warn(`Cannot create Device from Exposes for ${devicesMessag.friendly_name || devicesMessag.ieee_address}!`);
                         this.adapter.log.debug(JSON.stringify(devicesMessag));
                         this.adapter.log.debug(err);
                     }
@@ -61,29 +88,29 @@ class DeviceController {
     }
 
     /**
+     * Erstellt die State-Definition für eine Zigbee2MQTT-Gruppe und legt sie im groupCache ab.
      *
-     * @param groupID
-     * @param ieee_address
-     * @param scenes
+     * @param {string} groupID      Friendly-Name der Gruppe (wird als ioBroker-ID verwendet)
+     * @param {string} ieee_address Interne Gruppen-ID (z.B. "group_1")
+     * @param {Array}  scenes       Liste der Szenen-Objekte ({id, name}) der Gruppe
      */
-    async defineGroupDevice(groupID, ieee_address, scenes) {
-        const brmPropName =
-			this.adapter.config.brightnessMoveOnOff == true ? 'brightness_move_onoff' : 'brightness_move';
-        const brsPropName =
-			this.adapter.config.brightnessStepOnOff == true ? 'brightness_step_onoff' : 'brightness_step';
+    defineGroupDevice(groupID, ieee_address, scenes) {
+        const brmPropName = this.adapter.config.brightnessMoveOnOff === true ? 'brightness_move_onoff' : 'brightness_move';
+        const brsPropName = this.adapter.config.brightnessStepOnOff === true ? 'brightness_step_onoff' : 'brightness_step';
         const newDevice = {
             id: groupID,
             ieee_address: ieee_address,
             icon: undefined, //  await imageController.getDeviceIcon(devicesMessag), device.definition.model
             optionsValues: {},
             states: [
-                statesDefs.available,
-                statesDefs.brightness,
-                statesDefs.colortemp_move,
-                statesDefs.transition,
+                // Fix 1: Klone aller statesDefs-Objekte – sonst werden geteilte Referenzen mutiert
+                Object.assign({}, statesDefs.available),
+                Object.assign({}, statesDefs.brightness),
+                Object.assign({}, statesDefs.colortemp_move),
+                Object.assign({}, statesDefs.transition),
                 {
                     id: 'state',
-                    prob: 'state',
+                    prop: 'state',
                     name: 'Switch state',
                     options: ['transition'],
                     icon: undefined,
@@ -133,29 +160,28 @@ class DeviceController {
                     type: 'string',
                     def: '#ff00ff',
                     setter: (value) => {
-                        let xy = [0, 0];
+                        // Fix 6: redundante [0,0]-Initialisierung entfernt
                         const rgbcolor = colors.ParseColor(value);
-                        xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
+                        const xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
                         return {
                             x: xy[0],
                             y: xy[1],
                         };
                     },
                     getter: (payload) => {
-                        if (payload.color_mode != 'xy' && this.config.colorTempSyncColor == false) {
+                        if (payload.color_mode !== 'xy' && !this.config.colorTempSyncColor) {
                             return undefined;
                         }
-                        if (payload.color && payload.color.x && payload.color.y) {
+                        // Fix 2: x=0 / y=0 sind gültige CIE-Koordinaten → != null statt truthy
+                        if (payload.color && payload.color.x != null && payload.color.y != null) {
                             const colorval = rgb.cie_to_rgb(payload.color.x, payload.color.y);
                             return (
-                                `#${ 
-								utils.decimalToHex(colorval[0]) 
-								}${utils.decimalToHex(colorval[1]) 
-								}${utils.decimalToHex(colorval[2])}`
+                                `#${utils.decimalToHex(colorval[0])
+                                }${utils.decimalToHex(colorval[1])
+                                }${utils.decimalToHex(colorval[2])}`
                             );
-                        } 
-                            return undefined;
-                        
+                        }
+                        return undefined;
                     },
                 },
                 {
@@ -168,22 +194,24 @@ class DeviceController {
                     write: true,
                     read: true,
                     type: 'number',
-                    min: this.config.useKelvin == true ? utils.miredKelvinConversion(550) : 150,
-                    max: this.config.useKelvin == true ? utils.miredKelvinConversion(153) : 500,
-                    def: this.config.useKelvin == true ? utils.miredKelvinConversion(153) : 500,
-                    unit: this.config.useKelvin == true ? 'K' : 'mired',
+                    min: this.config.useKelvin === true ? utils.miredKelvinConversion(550) : 150,
+                    max: this.config.useKelvin === true ? utils.miredKelvinConversion(153) : 500,
+                    def: this.config.useKelvin === true ? utils.miredKelvinConversion(153) : 500,
+                    unit: this.config.useKelvin === true ? 'K' : 'mired',
                     setter: (value) => {
                         return utils.toMired(value);
                     },
                     getter: (payload) => {
-                        if (payload.color_mode != 'color_temp') {
+                        if (payload.color_mode !== 'color_temp') {
                             return undefined;
                         }
-                        if (this.config.useKelvin == true) {
+                        if (payload.color_temp == null) {
+                            return undefined;
+                        }
+                        if (this.config.useKelvin === true) {
                             return utils.miredKelvinConversion(payload.color_temp);
-                        } 
-                            return payload.color_temp;
-                        
+                        }
+                        return payload.color_temp;
                     },
                 },
                 {
@@ -226,7 +254,7 @@ class DeviceController {
             const sceneSate = {
                 id: `scene_${scene.id}`,
                 prop: `scene_recall`,
-                name: scene.name,
+                name: scene.name || `Scene ${scene.id}`,
                 icon: undefined,
                 role: 'button',
                 write: true,
@@ -244,148 +272,172 @@ class DeviceController {
     }
 
     /**
+     * Erstellt Gruppen-Definitionen aus dem bridge/groups-Payload von Zigbee2MQTT
+     * und befüllt den groupCache neu.
      *
-     * @param groupsMessage
+     * @param {Array} groupsMessage Array mit Gruppendaten aus dem bridge/groups-Topic
      */
     async createGroupDefinitions(groupsMessage) {
+        // Fix 4: groupsMessage kann null/kein Array sein
+        if (!Array.isArray(groupsMessage)) {
+            this.adapter.log.warn('createGroupDefinitions: payload ist kein Array');
+            return;
+        }
         utils.clearArray(this.groupCache);
         for (const groupMessage of groupsMessage) {
-            if (this.logCustomizations.debugDevices.includes(groupMessage.id)) {
+            // Fix 5: fehlende Pflichtfelder abfangen
+            if (!groupMessage || groupMessage.id == null || !groupMessage.friendly_name) {
+                continue;
+            }
+            if (isDebugDevice(this.logCustomizations.debugDevices, String(groupMessage.id))) {
                 this.adapter.log.warn(`--->>> fromZ2M -> ${groupMessage.id} exposes: ${JSON.stringify(groupMessage)}`);
             }
-            await this.defineGroupDevice(groupMessage.friendly_name, `group_${groupMessage.id}`, groupMessage.scenes);
+            this.defineGroupDevice(groupMessage.friendly_name, `group_${groupMessage.id}`, groupMessage.scenes || []);
         }
     }
 
     /**
-     *
+     * Legt alle Geräte und Gruppen aus den Caches als ioBroker-Objekte an
+     * bzw. aktualisiert sie falls sich Name oder Beschreibung geändert haben.
      */
     async createOrUpdateDevices() {
-        for (const device of this.groupCache.concat(this.deviceCache)) {
-            let deviceName = await this.getDeviceName(device);
-            let description = await this.getDeviceDescription(device);
+        // Gruppen und Geräte getrennt verarbeiten
+        for (const device of this.groupCache) {
+            await this._createOrUpdateSingleDevice(device, true);
+        }
+        for (const device of this.deviceCache) {
+            await this._createOrUpdateSingleDevice(device, false);
+        }
+    }
 
-            if (deviceName == '' && device.description) {
-                deviceName = device.description;
-                description = '';
-            }
+    /**
+     * Legt ein einzelnes Gerät oder eine Gruppe als ioBroker-Objekt an oder aktualisiert es.
+     *
+     * @param {object}  device   Das Gerät/Gruppen-Objekt aus dem Cache
+     * @param {boolean} isGroup  true = Gruppe, false = echtes Gerät
+     */
+    async _createOrUpdateSingleDevice(device, isGroup) {
+        let deviceName = this.getDeviceName(device);
+        let description = this.getDeviceDescription(device);
 
-            // Manipulate deviceName if the device is disabled, so the update of the device is triggered as well
-            if (device.disabled && device.disabled == true) {
-                if (this.config.useEventInDesc == true) {
-                    description = 'Device is disabled!';
-                } else {
-                    deviceName = `[Disabled] ${deviceName}`;
-                }
+        if (deviceName === '' && device.description) {
+            deviceName = device.description;
+            description = '';
+        }
+
+        // Disabled-Flag nur bei echten Geräten – Gruppen können nicht disabled sein
+        if (!isGroup && device.disabled === true) {
+            if (this.config.useEventInDesc === true) {
+                description = 'Device is disabled!';
+            } else {
+                // Fallback auf ieee_address wenn kein friendly_name vorhanden
+                const label = deviceName || device.ieee_address;
+                deviceName = `[Disabled] ${label}`;
             }
+        }
 
-            if (!this.createCache[device.ieee_address] || this.createCache[device.ieee_address].name != deviceName || this.createCache[device.ieee_address].description != description) {
-                const deviceObj = {
-                    type: 'device',
-                    common: {
-                        icon: device.icon,
-                        name: deviceName,
-                        desc: description,
-                        statusStates: { onlineId: '' },
-                    },
-                    native: {
-                        deviceRemoved: false,
-                        groupDevice: false,
-                    },
-                };
+        if (!this.createCache[device.ieee_address] ||
+            this.createCache[device.ieee_address].name !== deviceName ||
+            this.createCache[device.ieee_address].description !== description) {
 
-                // Group Device
-                if (device.ieee_address.includes('group_')) {
-                    deviceObj.native.groupDevice = true;
-                    deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
-                }
-                // Disabled Device
-                else if (device.disabled || device.disabled == true) {
-                    // Placeholder for possible later logic
-                }
-                // Only the onlineId is set if the device is not disabled
-                else {
-                    deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
-                }               
-                await this.adapter.extendObjectAsync(device.ieee_address, deviceObj);
-                this.createCache[device.ieee_address] = { name: deviceName, description: description };
+            const deviceObj = {
+                type: 'device',
+                common: {
+                    icon: device.icon,
+                    name: deviceName,
+                    desc: description,
+                    statusStates: { onlineId: '' },
+                },
+                native: {
+                    deviceRemoved: false,
+                    groupDevice: isGroup,
+                },
+            };
+
+            if (isGroup || device.disabled !== true) {
+                deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
             }
 
-            // Here it is checked whether the scenes match the current data from z2m.
-            // If necessary, scenes are automatically deleted from ioBroker.
-            const sceneStates = await this.adapter.getStatesAsync(`${device.ieee_address}.scene_*`);
-            const sceneIDs = Object.keys(sceneStates);
-            for (const sceneID of sceneIDs) {
-                const stateID = sceneID.split('.')[3];
-                if (device.states.find((x) => x.id == stateID) == null) {
-                    this.adapter.delObject(sceneID);
-                }
+            await this.adapter.extendObjectAsync(device.ieee_address, deviceObj);
+            // Bestehende State-Einträge im Cache bewahren – nur name/description aktualisieren
+            if (!this.createCache[device.ieee_address]) {
+                this.createCache[device.ieee_address] = {};
             }
+            this.createCache[device.ieee_address].name        = deviceName;
+            this.createCache[device.ieee_address].description = description;
+        }
 
-            if (device != undefined && device.states != undefined) {
-                for (const state of device.states) {
-                    if (state && (!this.createCache[device.ieee_address][state.id] || this.createCache[device.ieee_address][state.id].name != state.name)) {
-                        const iobState = {
-                            type: 'state',
-                            common: await this.copyAndCleanStateObj(state),
-                            native: {},
-                        };
+        if (!Array.isArray(device.states)) {
+            return;
+        }
 
-                        await this.adapter.extendObjectAsync(`${device.ieee_address}.${state.id}`, iobState);
-                        this.createCache[device.ieee_address][state.id] = {name: state.name, created: true};
-                    }
+        // Veraltete scene_*-States bereinigen – getForeignObjectsAsync mit vollem Namespace-Pfad
+        const sceneObjects = await this.adapter.getForeignObjectsAsync(
+            `${this.adapter.namespace}.${device.ieee_address}.scene_*`
+        );
+        if (sceneObjects) {
+            for (const sceneObjId of Object.keys(sceneObjects)) {
+                const parts = sceneObjId.split('.');
+                const stateID = parts[parts.length - 1];
+                if (!device.states.find((x) => x.id === stateID)) {
+                    await this.adapter.delForeignObjectAsync(sceneObjId);
                 }
             }
         }
-    }
 
-    /**
-     *
-     * @param messageObj
-     */
-    async renameDeviceInCache(messageObj) {
-        const renamedDevice = this.groupCache
-            .concat(this.deviceCache)
-            .find((x) => x.id == messageObj.payload.data.from);
-        if (renamedDevice) {
-            renamedDevice.id = messageObj.payload.data.to;
+        for (const state of device.states) {
+            if (state && (!this.createCache[device.ieee_address][state.id] ||
+                this.createCache[device.ieee_address][state.id].name !== state.name)) {
+
+                const iobState = {
+                    type: 'state',
+                    common: this.copyAndCleanStateObj(state),
+                    native: {},
+                };
+
+                await this.adapter.extendObjectAsync(`${device.ieee_address}.${state.id}`, iobState);
+                this.createCache[device.ieee_address][state.id] = { name: state.name, created: true };
+            }
         }
     }
 
     /**
-     *
+     * Prüft alle in ioBroker vorhandenen Geräte-Objekte gegen den deviceCache und markiert
+     * nicht mehr vorhandene Geräte als "[Removed]" bzw. setzt available auf false.
      */
     async checkAndProgressDeviceRemove() {
-        let description = '';
-        let deviceName = '';
         let iobDevices = await this.adapter.getDevicesAsync();
-        // Do not consider devices already marked as "deviceRemoved"
-        iobDevices = iobDevices.filter((x) => x.native.deviceRemoved == false);
-        // Do not consider groups
-        iobDevices = iobDevices.filter((x) => x.native.groupDevice == false);
+        if (!iobDevices) {
+            return;
+        }
+        // Nur nicht-entfernte, echte Geräte (keine Gruppen) in einem Schritt filtern
+        iobDevices = iobDevices.filter((x) =>
+            x.native && x.native.deviceRemoved === false && x.native.groupDevice === false
+        );
 
         for (const iobDevice of iobDevices) {
-            const ieee_address = iobDevice._id.split('.')[2];
-            //Check whether the devices found from the object tree are also available in the DeviceCache
-            if (!this.deviceCache.find((x) => x.ieee_address == ieee_address)) {
-                deviceName = iobDevice.common.name;
+            const idParts = iobDevice._id.split('.');
+            if (idParts.length < 3) {continue;}
+            const ieee_address = idParts[2];
+
+            // Gruppen-Einträge im ioBroker-Baum explizit überspringen
+            if (ieee_address.startsWith('group_')) {continue;}
+
+            if (!this.deviceCache.find((x) => x.ieee_address === ieee_address)) {
+                let deviceName = iobDevice.common && iobDevice.common.name ? iobDevice.common.name : ieee_address;
+                let description = '';
 
-                if (this.config.useEventInDesc == true) {
+                if (this.config.useEventInDesc === true) {
                     description = 'Device was removed!';
                 } else {
                     deviceName = `[Removed] ${deviceName}`;
                 }
 
-                this.adapter.extendObject(`${ieee_address}`, {
-                    common: {
-                        name: deviceName,
-                        desc: description,
-                    },
-                    native: {
-                        deviceRemoved: true,
-                    },
+                await this.adapter.extendObjectAsync(ieee_address, {
+                    common: { name: deviceName, desc: description },
+                    native: { deviceRemoved: true },
                 });
-                this.adapter.setStateChangedAsync(`${ieee_address}.available`, false, true);
+                await this.adapter.setStateChangedAsync(`${ieee_address}.available`, false, true);
 
                 delete this.createCache[ieee_address];
             }
@@ -393,22 +445,46 @@ class DeviceController {
     }
 
     /**
+     * Aktualisiert die Geräte-ID im Cache wenn ein Gerät in Zigbee2MQTT umbenannt wurde.
+     *
+     * @param {{ payload: { data: { from: string, to: string } } }} messageObj Die Rename-Nachricht
+     */
+    async renameDeviceInCache(messageObj) {
+        if (!messageObj.payload || !messageObj.payload.data) {
+            return;
+        }
+        if (!messageObj.payload.data.from || !messageObj.payload.data.to) {
+            return;
+        }
+        const renamedDevice = this.groupCache
+            .concat(this.deviceCache)
+            .find((x) => x.id === messageObj.payload.data.from);
+        if (renamedDevice) {
+            renamedDevice.id = messageObj.payload.data.to;
+        }
+    }
+
+    /**
+     * Entfernt ein Gerät anhand seiner IEEE-Adresse aus dem angegebenen Cache-Array.
      *
-     * @param devices
-     * @param ieee_address
+     * @param {Array}  devices      Das Cache-Array (deviceCache oder groupCache)
+     * @param {string} ieee_address Die IEEE-Adresse des zu entfernenden Geräts
      */
     removeDeviceByIeee(devices, ieee_address) {
-        const idx = devices.findIndex((x) => x.ieee_address == ieee_address);
+        const idx = devices.findIndex((x) => x.ieee_address === ieee_address);
         if (idx > -1) {
             devices.splice(idx, 1);
         }
     }
 
     /**
+     * Erstellt eine bereinigte Kopie eines State-Objekts ohne interne Laufzeit-Felder
+     * (getter, setter, prop, etc.) für die ioBroker-Objektdefinition.
      *
-     * @param state
+     * @param {object} state Das vollständige State-Objekt mit Laufzeit-Feldern
+     * @returns {object}     Das bereinigte State-Objekt für extendObjectAsync
      */
-    async copyAndCleanStateObj(state) {
+    copyAndCleanStateObj(state) {
         const iobState = { ...state };
         const blacklistedKeys = [
             'prop',
@@ -430,33 +506,44 @@ class DeviceController {
     }
 
     /**
+     * Gibt den Anzeigenamen eines Geräts zurück.
+     * Ist friendly_name gleich der IEEE-Adresse, wird ein leerer String zurückgegeben.
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt aus dem Cache
+     * @returns {string}      Der Anzeigename oder ""
      */
     getDeviceName(device) {
-        return device.id == device.ieee_address ? '' : device.id;
+        return device.id === device.ieee_address ? '' : device.id;
     }
 
     /**
+     * Gibt die Beschreibung eines Geräts zurück (oder "" wenn keine vorhanden).
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt aus dem Cache
+     * @returns {string}      Die Beschreibung oder ""
      */
     getDeviceDescription(device) {
         return device.description ? device.description : '';
     }
 
     /**
+     * Verarbeitet die Antwort eines Coordinator-Check-Requests von Zigbee2MQTT
+     * und schreibt fehlende Router in die info-States.
      *
-     * @param payload
+     * @param {{ data: { missing_routers: Array } }} payload Der Antwort-Payload
      */
-    processCoordinatorCheck(payload) {
+    async processCoordinatorCheck(payload) {
         if (payload && payload.data && payload.data.missing_routers) {
             const missingRoutersCount = payload.data.missing_routers.length;
-            this.adapter.setState('info.missing_routers', JSON.stringify(payload.data.missing_routers), true);
-            this.adapter.setState('info.missing_routers_count', missingRoutersCount, true);
+            await this.adapter.setStateAsync('info.missing_routers', JSON.stringify(payload.data.missing_routers), true);
+            await this.adapter.setStateAsync('info.missing_routers_count', missingRoutersCount, true);
 
             if (missingRoutersCount > 0) {
-                this.adapter.log[this.config.coordinatorCheckLogLvl](
+                const logLvl = this.config.coordinatorCheckLogLvl;
+                const logFn = (logLvl && typeof this.adapter.log[logLvl] === 'function')
+                    ? this.adapter.log[logLvl].bind(this.adapter.log)
+                    : this.adapter.log.warn.bind(this.adapter.log);
+                logFn(
                     `Coordinator check: ${missingRoutersCount} missing routers were found, please check the data point 'zigbee2mqtt.x.info.missing_routers'!`
                 );
             } else {