react-native-update-cli 2.8.0 → 2.8.2

package/lib/diff.js

@@ -0,0 +1,387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    diffCommands: function() {
+        return diffCommands;
+    },
+    enumZipEntries: function() {
+        return _zipentries.enumZipEntries;
+    },
+    readEntry: function() {
+        return _zipentries.readEntry;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _globaldirectory = /*#__PURE__*/ _interop_require_default(require("global-directory"));
+const _yazl = require("yazl");
+const _utils = require("./utils");
+const _constants = require("./utils/constants");
+const _i18n = require("./utils/i18n");
+const _zipentries = require("./utils/zip-entries");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _loadDiffModule;
+const { npm, yarn } = _globaldirectory.default;
+const loadDiffModule = (pkgName)=>{
+    const resolvePaths = [
+        process.cwd(),
+        npm.packages,
+        yarn.packages
+    ];
+    try {
+        const resolved = require.resolve(pkgName, {
+            paths: resolvePaths
+        });
+        const mod = require(resolved);
+        if (mod == null ? void 0 : mod.diff) {
+            return mod.diff;
+        }
+    } catch (e) {}
+    return undefined;
+};
+let hdiff;
+hdiff = (_loadDiffModule = loadDiffModule('node-hdiffpatch')) == null ? void 0 : _loadDiffModule.diff;
+let bsdiff;
+let diff;
+bsdiff = loadDiffModule('node-bsdiff');
+function basename(fn) {
+    const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
+    return m == null ? void 0 : m[1];
+}
+async function diffFromPPK(origin, next, output) {
+    _fsextra.ensureDirSync(_path.default.dirname(output));
+    const originEntries = {};
+    const originMap = {};
+    let originSource;
+    await (0, _zipentries.enumZipEntries)(origin, (entry, zipFile)=>{
+        originEntries[entry.fileName] = entry;
+        if (!/\/$/.test(entry.fileName)) {
+            // isFile
+            originMap[entry.crc32] = entry.fileName;
+            if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
+                // This is source.
+                return (0, _zipentries.readEntry)(entry, zipFile).then((v)=>originSource = v);
+            }
+        }
+    });
+    if (!originSource) {
+        throw new Error((0, _i18n.t)('bundleFileNotFound'));
+    }
+    const copies = {};
+    const zipfile = new _yazl.ZipFile();
+    const writePromise = new Promise((resolve, reject)=>{
+        zipfile.outputStream.on('error', (err)=>{
+            throw err;
+        });
+        zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
+            resolve(void 0);
+        });
+    });
+    const addedEntry = {};
+    function addEntry(fn) {
+        //console.log(fn);
+        if (!fn || addedEntry[fn]) {
+            return;
+        }
+        const base = basename(fn);
+        if (base) {
+            addEntry(base);
+        }
+        zipfile.addEmptyDirectory(fn);
+    }
+    const newEntries = {};
+    await (0, _zipentries.enumZipEntries)(next, (entry, nextZipfile)=>{
+        newEntries[entry.fileName] = entry;
+        if (/\/$/.test(entry.fileName)) {
+            // Directory
+            if (!originEntries[entry.fileName]) {
+                addEntry(entry.fileName);
+            }
+        } else if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
+            //console.log('Found bundle');
+            return (0, _zipentries.readEntry)(entry, nextZipfile).then((newSource)=>{
+                //console.log('Begin diff');
+                zipfile.addBuffer(diff(originSource, newSource), `${entry.fileName}.patch`);
+            //console.log('End diff');
+            });
+        } else {
+            // If same file.
+            const originEntry = originEntries[entry.fileName];
+            if (originEntry && originEntry.crc32 === entry.crc32) {
+                // ignore
+                return;
+            }
+            // If moved from other place
+            if (originMap[entry.crc32]) {
+                const base = basename(entry.fileName);
+                if (!originEntries[base]) {
+                    addEntry(base);
+                }
+                copies[entry.fileName] = originMap[entry.crc32];
+                return;
+            }
+            // New file.
+            addEntry(basename(entry.fileName));
+            return new Promise((resolve, reject)=>{
+                nextZipfile.openReadStream(entry, (err, readStream)=>{
+                    if (err) {
+                        return reject(err);
+                    }
+                    zipfile.addReadStream(readStream, entry.fileName);
+                    readStream.on('end', ()=>{
+                        //console.log('add finished');
+                        resolve(void 0);
+                    });
+                });
+            });
+        }
+    });
+    const deletes = {};
+    for(const k in originEntries){
+        if (!newEntries[k]) {
+            console.log((0, _i18n.t)('deleteFile', {
+                file: k
+            }));
+            deletes[k] = 1;
+        }
+    }
+    //console.log({copies, deletes});
+    zipfile.addBuffer(Buffer.from(JSON.stringify({
+        copies,
+        deletes
+    })), '__diff.json');
+    zipfile.end();
+    await writePromise;
+}
+async function diffFromPackage(origin, next, output, originBundleName, transformPackagePath = (v)=>v) {
+    _fsextra.ensureDirSync(_path.default.dirname(output));
+    const originEntries = {};
+    const originMap = {};
+    let originSource;
+    await (0, _zipentries.enumZipEntries)(origin, (entry, zipFile)=>{
+        if (!/\/$/.test(entry.fileName)) {
+            const fn = transformPackagePath(entry.fileName);
+            if (!fn) {
+                return;
+            }
+            //console.log(fn);
+            // isFile
+            originEntries[fn] = entry.crc32;
+            originMap[entry.crc32] = fn;
+            if (fn === originBundleName) {
+                // This is source.
+                return (0, _zipentries.readEntry)(entry, zipFile).then((v)=>originSource = v);
+            }
+        }
+    });
+    if (!originSource) {
+        throw new Error((0, _i18n.t)('bundleFileNotFound'));
+    }
+    const copies = {};
+    const zipfile = new _yazl.ZipFile();
+    const writePromise = new Promise((resolve, reject)=>{
+        zipfile.outputStream.on('error', (err)=>{
+            throw err;
+        });
+        zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
+            resolve(void 0);
+        });
+    });
+    await (0, _zipentries.enumZipEntries)(next, (entry, nextZipfile)=>{
+        if (/\/$/.test(entry.fileName)) {
+            // Directory
+            zipfile.addEmptyDirectory(entry.fileName);
+        } else if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
+            //console.log('Found bundle');
+            return (0, _zipentries.readEntry)(entry, nextZipfile).then((newSource)=>{
+                //console.log('Begin diff');
+                zipfile.addBuffer(diff(originSource, newSource), `${entry.fileName}.patch`);
+            //console.log('End diff');
+            });
+        } else {
+            // If same file.
+            if (originEntries[entry.fileName] === entry.crc32) {
+                copies[entry.fileName] = '';
+                return;
+            }
+            // If moved from other place
+            if (originMap[entry.crc32]) {
+                copies[entry.fileName] = originMap[entry.crc32];
+                return;
+            }
+            return new Promise((resolve, reject)=>{
+                nextZipfile.openReadStream(entry, (err, readStream)=>{
+                    if (err) {
+                        return reject(err);
+                    }
+                    zipfile.addReadStream(readStream, entry.fileName);
+                    readStream.on('end', ()=>{
+                        //console.log('add finished');
+                        resolve(void 0);
+                    });
+                });
+            });
+        }
+    });
+    zipfile.addBuffer(Buffer.from(JSON.stringify({
+        copies
+    })), '__diff.json');
+    zipfile.end();
+    await writePromise;
+}
+function diffArgsCheck(args, options, diffFn) {
+    const [origin, next] = args;
+    if (!origin || !next) {
+        console.error((0, _i18n.t)('usageDiff', {
+            command: diffFn
+        }));
+        process.exit(1);
+    }
+    if (options == null ? void 0 : options.customDiff) {
+        diff = options.customDiff;
+    } else {
+        if (diffFn.startsWith('hdiff')) {
+            if (!hdiff) {
+                console.error((0, _i18n.t)('nodeHdiffpatchRequired', {
+                    scriptName: _constants.scriptName
+                }));
+                process.exit(1);
+            }
+            diff = hdiff;
+        } else {
+            if (!bsdiff) {
+                console.error((0, _i18n.t)('nodeBsdiffRequired', {
+                    scriptName: _constants.scriptName
+                }));
+                process.exit(1);
+            }
+            diff = bsdiff;
+        }
+    }
+    const { output } = (0, _utils.translateOptions)({
+        ...options,
+        tempDir: _constants.tempDir
+    });
+    return {
+        origin,
+        next,
+        realOutput: output.replace(/\$\{time\}/g, `${Date.now()}`)
+    };
+}
+const diffCommands = {
+    async diff ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diff');
+        await diffFromPPK(origin, next, realOutput);
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async hdiff ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiff');
+        await diffFromPPK(origin, next, realOutput);
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async diffFromApk ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApk');
+        await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async hdiffFromApk ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApk');
+        await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async diffFromApp ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApp');
+        await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async hdiffFromApp ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApp');
+        await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async diffFromIpa ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromIpa');
+        await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v)=>{
+            const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+            return m == null ? void 0 : m[1];
+        });
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    },
+    async hdiffFromIpa ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromIpa');
+        await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v)=>{
+            const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+            return m == null ? void 0 : m[1];
+        });
+        console.log((0, _i18n.t)('diffPackageGenerated', {
+            output: realOutput
+        }));
+    }
+};

package/lib/index.js

@@ -20,6 +20,7 @@ _export(exports, {
 const _api = require("./api");
 const _app = require("./app");
 const _bundle = require("./bundle");
+const _diff = require("./diff");
 const _install = require("./install");
 const _modulemanager = require("./module-manager");
 const _modules = require("./modules");
@@ -45,6 +46,7 @@ function printUsage() {
     const legacyCommands = {
         ..._user.userCommands,
         ..._bundle.bundleCommands,
+        ..._diff.diffCommands,
         ..._app.appCommands,
         ..._package.packageCommands,
         ..._versions.versionCommands,
@@ -77,6 +79,7 @@ function printUsage() {
 const legacyCommands = {
     ..._user.userCommands,
     ..._bundle.bundleCommands,
+    ..._diff.diffCommands,
     ..._app.appCommands,
     ..._package.packageCommands,
     ..._versions.versionCommands,

package/lib/utils/app-info-parser/utils.js

@@ -46,7 +46,6 @@ const isPrimitive = (value)=>value === null || [
         'string',
         'undefined'
     ].includes(objectType(value));
-const isBrowser = ()=>typeof process === 'undefined' || Object.prototype.toString.call(process) !== '[object process]';
 /**
  * map file place with resourceMap
  * @param {Object} apkInfo // json info parsed from .apk file

package/lib/utils/app-info-parser/zip.js

@@ -9,8 +9,14 @@ Object.defineProperty(exports, "Zip", {
     }
 });
 const _utils = require("./utils");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _zipentries = require("../zip-entries");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const Unzip = require('isomorphic-unzip');
-let bundleZipUtils;
 class Zip {
     /**
    * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
@@ -44,11 +50,10 @@ class Zip {
     }
     async getEntryFromHarmonyApp(regex) {
         try {
-            const { enumZipEntries, readEntry } = bundleZipUtils != null ? bundleZipUtils : bundleZipUtils = require('../../bundle');
             let originSource;
-            await enumZipEntries(this.file, (entry, zipFile)=>{
+            await (0, _zipentries.enumZipEntries)(this.file, (entry, zipFile)=>{
                 if (regex.test(entry.fileName)) {
-                    return readEntry(entry, zipFile).then((value)=>{
+                    return (0, _zipentries.readEntry)(entry, zipFile).then((value)=>{
                         originSource = value;
                     });
                 }
@@ -59,17 +64,10 @@ class Zip {
         }
     }
     constructor(file){
-        if ((0, _utils.isBrowser)()) {
-            if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
-                throw new Error('Param error: [file] must be an instance of Blob or File in browser.');
-            }
-            this.file = file;
-        } else {
-            if (typeof file !== 'string') {
-                throw new Error('Param error: [file] must be file path in Node.');
-            }
-            this.file = require('path').resolve(file);
+        if (typeof file !== 'string') {
+            throw new Error('Param error: [file] must be file path in Node.');
         }
+        this.file = _path.default.resolve(file);
         this.unzip = new Unzip(this.file);
     }
 }

package/lib/utils/latest-version/index.js

@@ -20,7 +20,7 @@ const _fs = require("fs");
 const _os = require("os");
 const _path = require("path");
 const _url = require("url");
-const _globaldirs = require("global-dirs");
+const _globaldirectory = /*#__PURE__*/ _interop_require_default(require("global-directory"));
 const _registryauthtoken = /*#__PURE__*/ _interop_require_default(require("registry-auth-token"));
 const _registryurl = /*#__PURE__*/ _interop_require_default(require("registry-auth-token/registry-url"));
 const _gt = /*#__PURE__*/ _interop_require_default(require("semver/functions/gt"));
@@ -30,6 +30,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+const { npm, yarn } = _globaldirectory.default;
 const ONE_DAY = 1000 * 60 * 60 * 24; // eslint-disable-line @typescript-eslint/naming-convention
 const isPackageJson = (obj)=>{
     return obj.dependencies !== undefined || obj.devDependencies !== undefined || obj.peerDependencies !== undefined;
@@ -172,15 +173,15 @@ const getInstalledVersion = (pkgName, location = 'local')=>{
     try {
         if (location === 'globalNpm') {
             var _require;
-            return (_require = require((0, _path.join)(_globaldirs.npm.packages, pkgName, 'package.json'))) == null ? void 0 : _require.version;
+            return (_require = require((0, _path.join)(npm.packages, pkgName, 'package.json'))) == null ? void 0 : _require.version;
         } else if (location === 'globalYarn') {
             var _yarnGlobalPkg_dependencies, _require1;
             // Make sure package is globally installed by Yarn
-            const yarnGlobalPkg = require((0, _path.resolve)(_globaldirs.yarn.packages, '..', 'package.json'));
+            const yarnGlobalPkg = require((0, _path.resolve)(yarn.packages, '..', 'package.json'));
             if (!(yarnGlobalPkg == null ? void 0 : (_yarnGlobalPkg_dependencies = yarnGlobalPkg.dependencies) == null ? void 0 : _yarnGlobalPkg_dependencies[pkgName])) {
                 return undefined;
             }
-            return (_require1 = require((0, _path.join)(_globaldirs.yarn.packages, pkgName, 'package.json'))) == null ? void 0 : _require1.version;
+            return (_require1 = require((0, _path.join)(yarn.packages, pkgName, 'package.json'))) == null ? void 0 : _require1.version;
         } else {
             /**
        * Compute the local paths manually as require.resolve() and require.resolve.paths()

package/lib/utils/zip-entries.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    enumZipEntries: function() {
+        return enumZipEntries;
+    },
+    readEntry: function() {
+        return readEntry;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _yauzl = require("yauzl");
+const _i18n = require("./i18n");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function readEntry(entry, zipFile) {
+    const buffers = [];
+    return new Promise((resolve, reject)=>{
+        zipFile.openReadStream(entry, (err, stream)=>{
+            stream.on('data', (chunk)=>{
+                buffers.push(chunk);
+            });
+            stream.on('end', ()=>{
+                resolve(Buffer.concat(buffers));
+            });
+            stream.on('error', (err)=>{
+                reject(err);
+            });
+        });
+    });
+}
+async function enumZipEntries(zipFn, callback, nestedPath = '') {
+    return new Promise((resolve, reject)=>{
+        (0, _yauzl.open)(zipFn, {
+            lazyEntries: true
+        }, async (err, zipfile)=>{
+            if (err) {
+                return reject(err);
+            }
+            zipfile.on('end', resolve);
+            zipfile.on('error', reject);
+            zipfile.on('entry', async (entry)=>{
+                const fullPath = nestedPath + entry.fileName;
+                try {
+                    if (!entry.fileName.endsWith('/') && entry.fileName.toLowerCase().endsWith('.hap')) {
+                        const tempDir = _path.default.join(_os.default.tmpdir(), `nested_zip_${Date.now()}`);
+                        await _fsextra.ensureDir(tempDir);
+                        const tempZipPath = _path.default.join(tempDir, 'temp.zip');
+                        await new Promise((res, rej)=>{
+                            zipfile.openReadStream(entry, async (err, readStream)=>{
+                                if (err) return rej(err);
+                                const writeStream = _fsextra.createWriteStream(tempZipPath);
+                                readStream.pipe(writeStream);
+                                writeStream.on('finish', ()=>res(void 0));
+                                writeStream.on('error', rej);
+                            });
+                        });
+                        await enumZipEntries(tempZipPath, callback, `${fullPath}/`);
+                        await _fsextra.remove(tempDir);
+                    }
+                    const result = callback(entry, zipfile, fullPath);
+                    if (result && typeof result.then === 'function') {
+                        await result;
+                    }
+                } catch (error) {
+                    console.error((0, _i18n.t)('processingError', {
+                        error
+                    }));
+                }
+                zipfile.readEntry();
+            });
+            zipfile.readEntry();
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update-cli",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "command line tool for react-native-update (remote updates for react native)",
   "main": "index.js",
   "bin": {
@@ -47,7 +47,7 @@
     "filesize-parser": "^1.5.1",
     "form-data": "^4.0.2",
     "fs-extra": "8",
-    "global-dirs": "^4.0.0",
+    "global-directory": "^4.0.1",
     "gradle-to-js": "^2.0.1",
     "i18next": "^24.2.3",
     "isomorphic-git": "^1.30.1",
@@ -84,12 +84,8 @@
     "@types/yazl": "^2.4.6",
     "typescript": "^5.8.3"
   },
-  "optionalDependencies": {
-    "node-hdiffpatch": "^1.2.1"
-  },
   "trustedDependencies": [
     "@biomejs/biome",
-    "@swc/core",
-    "node-hdiffpatch"
+    "@swc/core"
   ]
 }