iobroker.javascript 9.0.0 → 9.0.2

package/admin/i18n/uk.json

@@ -0,0 +1,61 @@
+{
+  "Activate syntax help for these npm modules": "Активуйте синтаксичну довідку для цих модулів npm",
+  "Add module": "Додайте модуль NPM",
+  "Additional npm modules": "Додаткові модулі npm",
+  "Allow self-signed certificates for URL requests": "Дозволити самопідписані сертифікати для URL-запитів",
+  "And not later": "І не пізніше",
+  "Astro settings": "Налаштування Astro",
+  "But not earlier": "Але не раніше",
+  "Create states for all astro times": "Створіть стани для всіх астрономічних часів",
+  "Day time settings": "Налаштування денного часу",
+  "Do not subscribe all states on start": "Не підписуйтеся на всі стани на початку",
+  "Enable command \"exec\"": "Увімкнути команду \"exec\"",
+  "Enable command \"sendToHost\"": "Увімкнути команду \"sendToHost\"",
+  "Enable command \"setObject\"": "Увімкнути команду \"setObject\"",
+  "Help": "Використовуйте форму з 49.1245, а <b>не</b> 49°34'0\". Інакше його буде автоматично перетворено.",
+  "Instance, that do mirroring": "Наприклад, які виконують дзеркальне відображення",
+  "Invalid format. Use A°B'C\"D": "Недійсний формат. Використовуйте A°B'C\"D",
+  "Javascript scripts adapter settings": "Параметри адаптера сценаріїв Javascript",
+  "Latitude °": "Широта °",
+  "Longitude °": "Довгота °",
+  "Maximum setState requests per Minute per Script": "Максимальна кількість запитів setState за хвилину на сценарій",
+  "Maximum triggers per Script (until warning)": "Максимальна кількість тригерів на сценарій (до попередження)",
+  "Mirror scripts to file path": "Дзеркало сценаріїв до шляху до файлу",
+  "Module names": "Назви модулів NPM",
+  "Next sunrise": "Наступний схід сонця:",
+  "Next sunset": "Наступний захід сонця:",
+  "Offset": "Зсув",
+  "Security relevant": "Релевантність безпеки",
+  "Settings": "Налаштування",
+  "This path is not allowed for mirroring. Please change it.": "Цей шлях не можна віддзеркалювати. Будь ласка, змініть це.",
+  "Use system settings:": "Використовуйте налаштування системи",
+  "Used as end of the daytime": "Використовується як кінець дня",
+  "Used as start of the daytime": "Використовується як початок дня",
+  "Your home": "Твій дім",
+  "in minutes": "за хвилини",
+  "info_enableExec": "Актуальна безпека системи",
+  "info_enableSendToHost": "Релевантність безпеки",
+  "info_enableSetObject": "Релевантність безпеки",
+  "info_libraries": "Розділяється комою",
+  "sch_astro_dawn": "Світанок",
+  "sch_astro_dusk": "Сутінки",
+  "sch_astro_goldenHour": "Золота година",
+  "sch_astro_goldenHourEnd": "Кінець золотої години",
+  "sch_astro_nadir": "Надір",
+  "sch_astro_nauticalDawn": "Морський світанок",
+  "sch_astro_nauticalDusk": "Морські сутінки",
+  "sch_astro_night": "ніч",
+  "sch_astro_nightEnd": "Кінець ночі",
+  "sch_astro_solarNoon": "Сонячний полудень",
+  "sch_astro_sunrise": "Схід сонця",
+  "sch_astro_sunriseEnd": "Кінець сходу сонця",
+  "sch_astro_sunset": "Захід сонця",
+  "sch_astro_sunsetStart": "Початок заходу сонця",
+  "tooltip_enableExec": "Дозволити виклик exec у сценаріях",
+  "tooltip_enableSendToHost": "Дозволити надсилати повідомлення хостам у сценаріях",
+  "tooltip_enableSetObject": "Дозволити зміни системних об'єктів у сценаріях",
+  "tooltip_latitude": "Широта як 5,345 для використання астрофункцій",
+  "tooltip_libraries": "Додаткові бібліотеки NPM, розділені комою. Ви можете отримати до них доступ за допомогою require('name') у скриптах.",
+  "tooltip_longitude": "Довгота як 5,345 для використання астрофункцій",
+  "tooltip_useSystemGPS": "Використовуйте координати з налаштувань системи"
+}

package/admin/i18n/zh-cn.json

@@ -0,0 +1,61 @@
+{
+  "Activate syntax help for these npm modules": "激活以下npm模块的语法帮助",
+  "Add module": "添加NPM模块",
+  "Additional npm modules": "添加外部npm模块",
+  "Allow self-signed certificates for URL requests": "允许URL请求的自签名证书",
+  "And not later": "不久之后",
+  "Astro settings": "Astro设置",
+  "But not earlier": "但不是更早",
+  "Create states for all astro times": "为所有天文时间创建状态",
+  "Day time settings": "白天时间设定",
+  "Do not subscribe all states on start": "不要在开始时订阅所有状态",
+  "Enable command \"exec\"": "启用命令\"exec\"",
+  "Enable command \"sendToHost\"": "启用命令\"sendToHost\"",
+  "Enable command \"setObject\"": "启用命令\"setObject\"",
+  "Help": "使用这样的格式49.1245, <b>而不是</b> 49°34'0\"。否则，它会被自动转换。",
+  "Instance, that do mirroring": "实例，做镜像",
+  "Invalid format. Use A°B'C\"D": "格式无效。 使用A°B'C\"D这样的格式",
+  "Javascript scripts adapter settings": "Javascript脚本适配器设置",
+  "Latitude °": "纬度°",
+  "Longitude °": "经度°",
+  "Maximum setState requests per Minute per Script": "Maximum国家请求每分钟",
+  "Maximum triggers per Script (until warning)": "每个脚本的最大触发器数（直到警告）",
+  "Mirror scripts to file path": "将脚本镜像到文件路径：",
+  "Module names": "模块名称",
+  "Next sunrise": "下一个日出：",
+  "Next sunset": "下一日落：",
+  "Offset": "偏移量",
+  "Security relevant": "安全相关",
+  "Settings": "设置",
+  "This path is not allowed for mirroring. Please change it.": "此路径不允许用于镜像。请更改它。",
+  "Use system settings:": "使用系统设置",
+  "Used as end of the daytime": "用作白天结束",
+  "Used as start of the daytime": "用作白天的开始",
+  "Your home": "你家",
+  "in minutes": "在几分钟内",
+  "info_enableExec": "系统安全相关",
+  "info_enableSendToHost": "安全相关",
+  "info_enableSetObject": "安全相关",
+  "info_libraries": "逗号分隔",
+  "sch_astro_dawn": "黎明",
+  "sch_astro_dusk": "黄昏",
+  "sch_astro_goldenHour": "黄金时段",
+  "sch_astro_goldenHourEnd": "黄金时段结束",
+  "sch_astro_nadir": "天底",
+  "sch_astro_nauticalDawn": "航海黎明",
+  "sch_astro_nauticalDusk": "航海黄昏",
+  "sch_astro_night": "夜晚",
+  "sch_astro_nightEnd": "夜晚结束",
+  "sch_astro_solarNoon": "正午",
+  "sch_astro_sunrise": "日出",
+  "sch_astro_sunriseEnd": "日出结束",
+  "sch_astro_sunset": "日落",
+  "sch_astro_sunsetStart": "日落开始",
+  "tooltip_enableExec": "允许在脚本中调用exec",
+  "tooltip_enableSendToHost": "允许以脚本方式向主机发送消息",
+  "tooltip_enableSetObject": "允许更改脚本中的系统对象",
+  "tooltip_latitude": "纬度为5.345以使用astro功能",
+  "tooltip_libraries": "增加外部NPM库, 请使用逗号分隔。您可以在脚本中使用require('name')调用它们。",
+  "tooltip_longitude": "经度为5.345使用astro函数",
+  "tooltip_useSystemGPS": "使用系统设置中的坐标"
+}

package/admin/tab.html

@@ -115,7 +115,7 @@
             type="text/javascript"
             src="google-blockly/own/blocks_object.js"
         ></script>
-      <script type="module" crossorigin src="./assets/index-B0RKH_iG.js"></script>
+      <script type="module" crossorigin src="./assets/index-DCiLLcon.js"></script>
       <link rel="modulepreload" crossorigin href="./assets/iobroker_javascript__mf_v__runtimeInit__mf_v__-CBQgOKij.js">
       <link rel="modulepreload" crossorigin href="./assets/_commonjsHelpers-Cpj98o6Y.js">
       <link rel="modulepreload" crossorigin href="./assets/iobroker_javascript__loadShare__react__loadShare__-BiJPUKBK.js">

package/build-backend/lib/protectFs.js

@@ -198,13 +198,16 @@ class ProtectFs {
             throw new Error('Permission denied');
         }
     }
-    access(path, callback) {
+    access(path, mode, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.access(path, callback);
+        if (typeof callback === 'function') {
+            return nodeFS.access(path, mode, callback);
+        }
+        return nodeFS.access(path, mode);
     }
     accessSync(path, mode) {
         this.#checkProtected(path, true);
-        return nodeFS.accessSync(path, mode); // function accessSync(path, mode) {
+        return nodeFS.accessSync(path, mode);
     }
     cp(source, destination, opts, callback) {
         this.#checkProtected(source, false);
@@ -220,27 +223,36 @@ class ProtectFs {
     cpSync(source, destination, opts) {
         this.#checkProtected(source, false);
         this.#checkProtected(destination, false);
-        return nodeFS.cpSync.call(this, source, destination, opts); // function cpSync(src, dest, options) {
+        return nodeFS.cpSync.call(this, source, destination, opts);
     }
-    readFile(path, callback) {
+    readFile(path, options, callback) {
         if (typeof path !== 'number') {
             this.#checkProtected(path, true);
         }
-        return nodeFS.readFile.call(this, path, callback); // function readFile(path, options, callback) {
+        if (typeof callback === 'function') {
+            return nodeFS.readFile.call(this, path, options, 
+            // @ts-expect-error readFile can accept 3 arguments too
+            callback);
+        }
+        return nodeFS.readFile.call(this, path, options);
     }
     readFileSync(path, options) {
         if (typeof path !== 'number') {
             this.#checkProtected(path, true);
         }
-        return nodeFS.readFileSync.call(this, path, options); // function readFileSync(path, options) {
+        return nodeFS.readFileSync.call(this, path, options);
     }
-    readlink(path, callback) {
+    readlink(path, options, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.readlink.call(this, path, callback); // function readlink(path, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.readlink.call(this, path, options, callback); //
+        }
+        return nodeFS.readlink.call(this, path, options);
     }
     readlinkSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.readlinkSync.call(this, path, options); // function readlinkSync(path, options) {
+        return nodeFS.readlinkSync.call(this, path, options);
     }
     symlink(target, path, type, callback) {
         this.#checkProtected(target, true);
@@ -249,228 +261,266 @@ class ProtectFs {
             // @ts-expect-error should work
             return nodeFS.symlink.call(this, target, path, type, callback);
         }
-        return nodeFS.symlink.call(this, target, path, type); // function symlink(target, path, type_, callback_) {
+        return nodeFS.symlink.call(this, target, path, type);
     }
     symlinkSync(target, path, type) {
         this.#checkProtected(target, true);
         this.#checkProtected(path, false);
-        return nodeFS.symlinkSync.call(this, target, path, type); // function symlinkSync(target, path, type) {
+        return nodeFS.symlinkSync.call(this, target, path, type);
     }
     writeFile(file, data, options, callback) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        // @ts-expect-error should work
-        return nodeFS.writeFile.call(this, file, data, options, callback); // function writeFile(path, data, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.writeFile.call(this, file, data, options, callback);
+        }
+        return nodeFS.writeFile.call(this, file, data, options);
     }
     writeFileSync(file, data, options) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.writeFileSync.call(this, file, data, options); // function writeFileSync(path, data, options) {
+        return nodeFS.writeFileSync.call(this, file, data, options);
     }
     unlink(path, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.unlink.call(this, path, callback); // function unlink(path, callback) {
+        return nodeFS.unlink.call(this, path, callback || ((_err) => { }));
     }
     unlinkSync(path) {
         this.#checkProtected(path, false);
-        return nodeFS.unlinkSync.call(this, path); // function unlinkSync(path) {
+        return nodeFS.unlinkSync.call(this, path);
     }
-    appendFile(file, data, callback) {
+    appendFile(file, data, options, callback) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.appendFile.call(this, file, data, callback); // function appendFile(path, data, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.appendFile.call(this, file, data, options, callback);
+        }
+        return nodeFS.appendFile.call(this, file, data, options);
     }
-    appendFileSync(file, data) {
+    appendFileSync(file, data, options) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.appendFileSync.call(this, file, data); // function appendFileSync(path, data, options) {
+        return nodeFS.appendFileSync.call(this, file, data, options);
     }
     chmod(path, mode, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.chmod.call(this, path, mode, callback); // function chmod(path, mode, callback) {
+        return nodeFS.chmod.call(this, path, mode, callback || ((_err) => { }));
     }
     chmodSync(path, mode) {
         this.#checkProtected(path, false);
-        return nodeFS.chmodSync.call(this, path, mode); // function chmodSync(path, mode) {
+        return nodeFS.chmodSync.call(this, path, mode);
     }
     chown(path, uid, gid, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.chown.call(this, path, uid, gid, callback); // function chown(path, uid, gid, callback) {
+        return nodeFS.chown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     chownSync(path, uid, gid) {
         this.#checkProtected(path, false);
-        return nodeFS.chownSync.call(this, path, uid, gid); // function chownSync(path, uid, gid) {
+        return nodeFS.chownSync.call(this, path, uid, gid);
     }
     copyFile(src, dest, mode, callback) {
         this.#checkProtected(src, true);
         this.#checkProtected(dest, false);
         // @ts-expect-error should work
-        return nodeFS.copyFile.call(this, src, dest, mode, callback); // function copyFile(src, dest, mode, callback) {
+        return nodeFS.copyFile.call(this, src, dest, mode, callback);
     }
     copyFileSync(src, dest, mode) {
         this.#checkProtected(src, true);
         this.#checkProtected(dest, false);
-        return nodeFS.copyFileSync.call(this, src, dest, mode); // function copyFileSync(src, dest, mode) {
+        return nodeFS.copyFileSync.call(this, src, dest, mode);
     }
     rename(oldPath, newPath, callback) {
         this.#checkProtected(oldPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.rename.call(this, oldPath, newPath, callback); // function rename(oldPath, newPath, callback) {
+        return nodeFS.rename.call(this, oldPath, newPath, callback || ((_err) => { }));
     }
     renameSync(oldPath, newPath) {
         this.#checkProtected(oldPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.renameSync.call(this, oldPath, newPath); // function renameSync(oldPath, newPath) {
+        return nodeFS.renameSync.call(this, oldPath, newPath);
     }
     open(path, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.open.call(this, path, callback); // function open(path, flags, mode, callback) {
+        return nodeFS.open.call(this, path, callback);
     }
     openSync(path, flags, mode) {
         this.#checkProtected(path, true);
-        return nodeFS.openSync.call(this, path, flags, mode); // function openSync(path, flags, mode) {
+        return nodeFS.openSync.call(this, path, flags, mode);
     }
     truncate(path, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.truncate.call(this, path, callback); // function truncate(path, len, callback) {
+        return nodeFS.truncate.call(this, path, callback || ((_err) => { }));
     }
     truncateSync(path) {
         this.#checkProtected(path, false);
-        return nodeFS.truncateSync.call(this, path); // function truncateSync(path, len) {
+        return nodeFS.truncateSync.call(this, path);
     }
     exists(path, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.exists.call(this, path, callback); // function exists(path, callback) {
+        return nodeFS.exists.call(this, path, callback);
     }
     existsSync(path) {
         this.#checkProtected(path, true);
-        return nodeFS.existsSync.call(this, path); // function existsSync(path) {
+        return nodeFS.existsSync.call(this, path);
     }
     stat(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.stat.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.stat.call(this, path, options, callback); // function stat(path, options = { bigint: false }, callback) {
+        return nodeFS.stat.call(this, path, options);
     }
     statSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.statSync.call(this, path, options); // function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+        return nodeFS.statSync.call(this, path, options);
     }
     utimes(path, atime, mtime, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.utimes.call(this, path, atime, mtime, callback); // function utimes(path, atime, mtime, callback) {
+        return nodeFS.utimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     utimesSync(path, atime, mtime) {
         this.#checkProtected(path, false);
-        return nodeFS.utimesSync.call(this, path, atime, mtime); // function utimesSync(path, atime, mtime) {
+        return nodeFS.utimesSync.call(this, path, atime, mtime);
     }
     readdir(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            return nodeFS.readdir.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.readdir.call(this, path, options, callback); // function readdir(path, options, callback) {
+        return nodeFS.readdir.call(this, path, options);
     }
     readdirSync(path, options) {
         this.#checkProtected(path, true);
         // @ts-expect-error should work
-        return nodeFS.readdirSync.call(this, path, options); // function readdirSync(path, options) {
+        return nodeFS.readdirSync.call(this, path, options);
     }
     createReadStream(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.createReadStream.call(this, path, options); // function createReadStream(path, options) {
+        return nodeFS.createReadStream.call(this, path, options);
     }
     createWriteStream(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.createWriteStream.call(this, path, options); // function createWriteStream(path, options) {
+        return nodeFS.createWriteStream.call(this, path, options);
     }
     lchmod(path, mode, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lchmod.call(this, path, mode, callback); // function lchmod(path, mode, callback) {
+        return nodeFS.lchmod.call(this, path, mode, callback || ((_err) => { }));
     }
     lchmodSync(path, mode) {
         this.#checkProtected(path, false);
-        return nodeFS.lchmodSync.call(this, path, mode); // function lchmodSync(path, mode) {
+        return nodeFS.lchmodSync.call(this, path, mode);
     }
     lchown(path, uid, gid, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lchown.call(this, path, uid, gid, callback); // function lchown(path, uid, gid, callback) {
+        return nodeFS.lchown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     lchownSync(path, uid, gid) {
         this.#checkProtected(path, false);
-        return nodeFS.lchownSync.call(this, path, uid, gid); // function lchownSync(path, uid, gid) {
+        return nodeFS.lchownSync.call(this, path, uid, gid);
     }
     link(existingPath, newPath, callback) {
         this.#checkProtected(existingPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.link.call(this, existingPath, newPath, callback); // function link(existingPath, newPath, callback) {
+        return nodeFS.link.call(this, existingPath, newPath, callback || ((_err) => { }));
     }
     linkSync(existingPath, newPath) {
         this.#checkProtected(existingPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.linkSync.call(this, existingPath, newPath); // function linkSync(existingPath, newPath) {
+        return nodeFS.linkSync.call(this, existingPath, newPath);
     }
     lstat(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.lstat.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.lstat.call(this, path, options, callback); // function lstat(path, options = { bigint: false }, callback) {
+        return nodeFS.lstat.call(this, path, options);
     }
     lstatSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.lstatSync.call(this, path, options); // function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+        return nodeFS.lstatSync.call(this, path, options);
     }
     lutimes(path, atime, mtime, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lutimes.call(this, path, atime, mtime, callback); // function lutimes(path, atime, mtime, callback) {
+        return nodeFS.lutimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     lutimesSync(path, atime, mtime) {
         this.#checkProtected(path, false);
-        return nodeFS.lutimesSync.call(this, path, atime, mtime); // function lutimesSync(path, atime, mtime) {
+        return nodeFS.lutimesSync.call(this, path, atime, mtime);
     }
     mkdir(path, options, callback) {
         this.#checkProtected(path, false);
-        // @ts-expect-error should work
-        return nodeFS.mkdir.call(this, path, options, callback); // function mkdir(path, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.mkdir.call(this, path, options, callback);
+        }
+        return nodeFS.mkdir.call(this, path, options);
     }
     mkdirSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.mkdirSync.call(this, path, options); // function mkdirSync(path, options) {
+        return nodeFS.mkdirSync.call(this, path, options);
     }
     mkdtemp(prefix, options, callback) {
         this.#checkProtected(prefix, false);
-        // @ts-expect-error should work
-        return nodeFS.mkdtemp.call(this, prefix, options, callback); // function mkdtemp(prefix, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.mkdtemp.call(this, prefix, options, callback);
+        }
+        return nodeFS.mkdtemp.call(this, prefix, options);
     }
     mkdtempSync(prefix, options) {
         this.#checkProtected(prefix, false);
-        return nodeFS.mkdtempSync.call(this, prefix, options); // function mkdtempSync(prefix, options) {
+        return nodeFS.mkdtempSync.call(this, prefix, options);
     }
     rm(path, options, callback) {
         this.#checkProtected(path, false);
+        if (typeof callback === 'function') {
+            return nodeFS.rm.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.rm.call(this, path, options, callback); // function rm(path, options, callback) {
+        return nodeFS.rm.call(this, path, options);
     }
     rmSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.rmSync.call(this, path, options); // function rmSync(path, options) {
+        return nodeFS.rmSync.call(this, path, options);
     }
     rmdir(path, options, callback) {
         this.#checkProtected(path, false);
+        if (typeof callback === 'function') {
+            return nodeFS.rmdir.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.rmdir.call(this, path, options, callback); // function rmdir(path, options, callback) {
+        return nodeFS.rmdir.call(this, path, options);
     }
     rmdirSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.rmdirSync.call(this, path, options); // function rmdirSync(path, options) {
+        return nodeFS.rmdirSync.call(this, path, options);
     }
-    watch(filename, listener) {
+    watch(filename, options, listener) {
         this.#checkProtected(filename, true);
-        return nodeFS.watch.call(this, filename, listener); // function watch(filename, options, listener) {
+        if (typeof listener === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.watch.call(this, filename, options, listener);
+        }
+        return nodeFS.watch.call(this, filename, options);
     }
     watchFile(filename, listener) {
         this.#checkProtected(filename, true);
-        return nodeFS.watchFile.call(this, filename, listener); // function watchFile(filename, options, listener) {
+        return nodeFS.watchFile.call(this, filename, listener);
+    }
+    unwatchFile(filename, listener) {
+        this.#checkProtected(filename, true);
+        return nodeFS.unwatchFile.call(this, filename, listener);
     }
 }
 exports.default = ProtectFs;