@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/watcher/dist/watcher_handler.js

@@ -0,0 +1,248 @@
+/* IMPORT */
+import path from 'node:path';
+import { DEBOUNCE, DEPTH, LIMIT, HAS_NATIVE_RECURSION, IS_WINDOWS } from './constants.js';
+import { FSTargetEvent, FSWatcherEvent, TargetEvent } from './enums.js';
+import Utils from './utils.js';
+/* MAIN */
+class WatcherHandler {
+    /* CONSTRUCTOR */
+    constructor(watcher, config, base) {
+        this.base = base;
+        this.watcher = watcher;
+        this.handler = config.handler;
+        this.fswatcher = config.watcher;
+        this.options = config.options;
+        this.folderPath = config.folderPath;
+        this.filePath = config.filePath;
+        this.handlerBatched = this.base ? this.base.onWatcherEvent.bind(this.base) : this._makeHandlerBatched(this.options.debounce); //UGLY
+    }
+    /* HELPERS */
+    _isSubRoot(targetPath) {
+        if (this.filePath) {
+            return targetPath === this.filePath;
+        }
+        else {
+            return targetPath === this.folderPath || Utils.fs.isSubPath(this.folderPath, targetPath);
+        }
+    }
+    _makeHandlerBatched(delay = DEBOUNCE) {
+        return (() => {
+            let lock = this.watcher._readyWait; // ~Ensuring no two flushes are active in parallel, or before the watcher is ready
+            let initials = [];
+            let regulars = new Set();
+            const flush = async (initials, regulars) => {
+                const initialEvents = this.options.ignoreInitial ? [] : initials;
+                const regularEvents = await this.eventsPopulate([...regulars]);
+                const events = this.eventsDeduplicate([...initialEvents, ...regularEvents]);
+                this.onTargetEvents(events);
+            };
+            const flushDebounced = Utils.lang.debounce(() => {
+                if (this.watcher.isClosed())
+                    return;
+                lock = flush(initials, regulars);
+                initials = [];
+                regulars = new Set();
+            }, delay);
+            return async (event, targetPath = '', isInitial = false) => {
+                if (isInitial) { // Poll immediately
+                    await this.eventsPopulate([targetPath], initials, true);
+                }
+                else { // Poll later
+                    regulars.add(targetPath);
+                }
+                lock.then(flushDebounced);
+            };
+        })();
+    }
+    /* EVENT HELPERS */
+    eventsDeduplicate(events) {
+        if (events.length < 2)
+            return events;
+        const targetsEventPrev = {};
+        return events.reduce((acc, event) => {
+            const [targetEvent, targetPath] = event;
+            const targetEventPrev = targetsEventPrev[targetPath];
+            if (targetEvent === targetEventPrev)
+                return acc; // Same event, ignoring
+            if (targetEvent === TargetEvent.CHANGE && targetEventPrev === TargetEvent.ADD)
+                return acc; // "change" after "add", ignoring
+            targetsEventPrev[targetPath] = targetEvent;
+            acc.push(event);
+            return acc;
+        }, []);
+    }
+    async eventsPopulate(targetPaths, events = [], isInitial = false) {
+        await Promise.all(targetPaths.map(async (targetPath) => {
+            const targetEvents = await this.watcher._poller.update(targetPath, this.options.pollingTimeout);
+            await Promise.all(targetEvents.map(async (event) => {
+                events.push([event, targetPath]);
+                if (event === TargetEvent.ADD_DIR) {
+                    await this.eventsPopulateAddDir(targetPaths, targetPath, events, isInitial);
+                }
+                else if (event === TargetEvent.UNLINK_DIR) {
+                    await this.eventsPopulateUnlinkDir(targetPaths, targetPath, events, isInitial);
+                }
+            }));
+        }));
+        return events;
+    }
+    ;
+    async eventsPopulateAddDir(targetPaths, targetPath, events = [], isInitial = false) {
+        if (isInitial)
+            return events;
+        const depth = this.options.recursive ? this.options.depth ?? DEPTH : Math.min(1, this.options.depth ?? DEPTH);
+        const limit = this.options.limit ?? LIMIT;
+        const [directories, files] = await Utils.fs.readdir(targetPath, this.options.ignore, depth, limit, this.watcher._closeSignal);
+        const targetSubPaths = [...directories, ...files];
+        await Promise.all(targetSubPaths.map(targetSubPath => {
+            if (this.watcher.isIgnored(targetSubPath, this.options.ignore))
+                return;
+            if (targetPaths.includes(targetSubPath))
+                return;
+            return this.eventsPopulate([targetSubPath], events, true);
+        }));
+        return events;
+    }
+    async eventsPopulateUnlinkDir(targetPaths, targetPath, events = [], isInitial = false) {
+        if (isInitial)
+            return events;
+        for (const folderPathOther of this.watcher._poller.stats.keys()) {
+            if (!Utils.fs.isSubPath(targetPath, folderPathOther))
+                continue;
+            if (targetPaths.includes(folderPathOther))
+                continue;
+            await this.eventsPopulate([folderPathOther], events, true);
+        }
+        return events;
+    }
+    /* EVENT HANDLERS */
+    onTargetAdd(targetPath) {
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetAdd(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.ADD, targetPath);
+            }
+        }
+    }
+    onTargetAddDir(targetPath) {
+        if (targetPath !== this.folderPath && this.options.recursive && (!HAS_NATIVE_RECURSION && this.options.native !== false)) {
+            this.watcher.watchDirectory(targetPath, this.options, this.handler, undefined, this.base || this);
+        }
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetAddDir(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.ADD_DIR, targetPath);
+            }
+        }
+    }
+    onTargetChange(targetPath) {
+        if (this._isSubRoot(targetPath)) {
+            this.watcher.event(TargetEvent.CHANGE, targetPath);
+        }
+    }
+    onTargetUnlink(targetPath) {
+        this.watcher.watchersClose(path.dirname(targetPath), targetPath, false);
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetUnlink(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.UNLINK, targetPath);
+            }
+        }
+    }
+    onTargetUnlinkDir(targetPath) {
+        this.watcher.watchersClose(path.dirname(targetPath), targetPath, false);
+        this.watcher.watchersClose(targetPath);
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetUnlinkDir(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.UNLINK_DIR, targetPath);
+            }
+        }
+    }
+    onTargetEvent(event) {
+        const [targetEvent, targetPath] = event;
+        if (targetEvent === TargetEvent.ADD) {
+            this.onTargetAdd(targetPath);
+        }
+        else if (targetEvent === TargetEvent.ADD_DIR) {
+            this.onTargetAddDir(targetPath);
+        }
+        else if (targetEvent === TargetEvent.CHANGE) {
+            this.onTargetChange(targetPath);
+        }
+        else if (targetEvent === TargetEvent.UNLINK) {
+            this.onTargetUnlink(targetPath);
+        }
+        else if (targetEvent === TargetEvent.UNLINK_DIR) {
+            this.onTargetUnlinkDir(targetPath);
+        }
+    }
+    onTargetEvents(events) {
+        for (const event of events) {
+            this.onTargetEvent(event);
+        }
+    }
+    onWatcherEvent(event, targetPath, isInitial = false) {
+        return this.handlerBatched(event, targetPath, isInitial);
+    }
+    onWatcherChange(event = FSTargetEvent.CHANGE, targetName) {
+        if (this.watcher.isClosed())
+            return;
+        const targetPath = path.resolve(this.folderPath, targetName || '');
+        if (this.filePath && targetPath !== this.folderPath && targetPath !== this.filePath)
+            return;
+        if (this.watcher.isIgnored(targetPath, this.options.ignore))
+            return;
+        this.onWatcherEvent(event, targetPath);
+    }
+    onWatcherError(error) {
+        if (IS_WINDOWS && error.code === 'EPERM') { // This may happen when a folder is deleted
+            this.onWatcherChange(FSTargetEvent.CHANGE, '');
+        }
+        else {
+            this.watcher.error(error);
+        }
+    }
+    /* API */
+    async init() {
+        await this.initWatcherEvents();
+        await this.initInitialEvents();
+    }
+    async initWatcherEvents() {
+        const onChange = this.onWatcherChange.bind(this);
+        this.fswatcher.on(FSWatcherEvent.CHANGE, onChange);
+        const onError = this.onWatcherError.bind(this);
+        this.fswatcher.on(FSWatcherEvent.ERROR, onError);
+    }
+    async initInitialEvents() {
+        const isInitial = !this.watcher.isReady(); // "isInitial" => is ignorable via the "ignoreInitial" option
+        if (this.filePath) { // Single initial path
+            if (this.watcher._poller.stats.has(this.filePath))
+                return; // Already polled
+            await this.onWatcherEvent(FSTargetEvent.CHANGE, this.filePath, isInitial);
+        }
+        else { // Multiple initial paths
+            const depth = this.options.recursive && (HAS_NATIVE_RECURSION && this.options.native !== false) ? this.options.depth ?? DEPTH : Math.min(1, this.options.depth ?? DEPTH);
+            const limit = this.options.limit ?? LIMIT;
+            const [directories, files] = await Utils.fs.readdir(this.folderPath, this.options.ignore, depth, limit, this.watcher._closeSignal, this.options.readdirMap);
+            const targetPaths = [this.folderPath, ...directories, ...files];
+            await Promise.all(targetPaths.map(targetPath => {
+                if (this.watcher._poller.stats.has(targetPath))
+                    return; // Already polled
+                if (this.watcher.isIgnored(targetPath, this.options.ignore))
+                    return;
+                return this.onWatcherEvent(FSTargetEvent.CHANGE, targetPath, isInitial);
+            }));
+        }
+    }
+}
+/* EXPORT */
+export default WatcherHandler;

package/.output/server/node_modules/watcher/dist/watcher_locker.js

@@ -0,0 +1,139 @@
+/* IMPORT */
+import { RENAME_TIMEOUT } from './constants.js';
+import { FileType, TargetEvent } from './enums.js';
+import Utils from './utils.js';
+import WatcherLocksResolver from './watcher_locks_resolver.js';
+/* MAIN */
+//TODO: Use a better name for this thing, maybe "RenameDetector"
+class WatcherLocker {
+    /* CONSTRUCTOR */
+    constructor(watcher) {
+        this._watcher = watcher;
+        this.reset();
+    }
+    /* API */
+    getLockAdd(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            const otherPath = this._watcher._poller.paths.find(ino || -1, path => path !== targetPath); // Maybe this is actually a rename in a case-insensitive filesystem
+            if (otherPath && otherPath !== targetPath) {
+                if (Utils.fs.getRealPath(targetPath, true) === otherPath)
+                    return; //TODO: This seems a little too special-casey
+                this._watcher.event(events.rename, otherPath, targetPath);
+            }
+            else {
+                this._watcher.event(events.add, targetPath);
+            }
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.add.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const resolve = () => {
+            const unlink = locks.unlink.get(ino);
+            if (!unlink)
+                return; // No matching "unlink" lock found, skipping
+            cleanup();
+            const targetPathPrev = unlink();
+            if (targetPath === targetPathPrev) {
+                if (events.change) {
+                    if (this._watcher._poller.stats.has(targetPath)) {
+                        this._watcher.event(events.change, targetPath);
+                    }
+                }
+            }
+            else {
+                this._watcher.event(events.rename, targetPathPrev, targetPath);
+            }
+        };
+        locks.add.set(ino, resolve);
+        resolve();
+    }
+    getLockUnlink(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            this._watcher.event(events.unlink, targetPath);
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.unlink.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const overridden = () => {
+            cleanup();
+            return targetPath;
+        };
+        locks.unlink.set(ino, overridden);
+        locks.add.get(ino)?.();
+    }
+    getLockTargetAdd(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD, FileType.FILE);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetAddDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD_DIR, FileType.DIR);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    getLockTargetUnlink(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK, FileType.FILE);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetUnlinkDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK_DIR, FileType.DIR);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    reset() {
+        this._locksAdd = new Map();
+        this._locksAddDir = new Map();
+        this._locksUnlink = new Map();
+        this._locksUnlinkDir = new Map();
+        this._locksDir = { add: this._locksAddDir, unlink: this._locksUnlinkDir };
+        this._locksFile = { add: this._locksAdd, unlink: this._locksUnlink };
+    }
+}
+WatcherLocker.DIR_EVENTS = {
+    add: TargetEvent.ADD_DIR,
+    rename: TargetEvent.RENAME_DIR,
+    unlink: TargetEvent.UNLINK_DIR
+};
+WatcherLocker.FILE_EVENTS = {
+    add: TargetEvent.ADD,
+    change: TargetEvent.CHANGE,
+    rename: TargetEvent.RENAME,
+    unlink: TargetEvent.UNLINK
+};
+/* EXPORT */
+export default WatcherLocker;

package/.output/server/node_modules/watcher/dist/watcher_locks_resolver.js

@@ -0,0 +1,42 @@
+/* MAIN */
+// Registering a single interval scales much better than registering N timeouts
+// Timeouts are respected within the interval margin
+const WatcherLocksResolver = {
+    /* VARIABLES */
+    interval: 100,
+    intervalId: undefined,
+    fns: new Map(),
+    /* LIFECYCLE API */
+    init: () => {
+        if (WatcherLocksResolver.intervalId)
+            return;
+        WatcherLocksResolver.intervalId = setInterval(WatcherLocksResolver.resolve, WatcherLocksResolver.interval);
+    },
+    reset: () => {
+        if (!WatcherLocksResolver.intervalId)
+            return;
+        clearInterval(WatcherLocksResolver.intervalId);
+        delete WatcherLocksResolver.intervalId;
+    },
+    /* API */
+    add: (fn, timeout) => {
+        WatcherLocksResolver.fns.set(fn, Date.now() + timeout);
+        WatcherLocksResolver.init();
+    },
+    remove: (fn) => {
+        WatcherLocksResolver.fns.delete(fn);
+    },
+    resolve: () => {
+        if (!WatcherLocksResolver.fns.size)
+            return WatcherLocksResolver.reset();
+        const now = Date.now();
+        for (const [fn, timestamp] of WatcherLocksResolver.fns) {
+            if (timestamp >= now)
+                continue; // We should still wait some more for this
+            WatcherLocksResolver.remove(fn);
+            fn();
+        }
+    }
+};
+/* EXPORT */
+export default WatcherLocksResolver;

package/.output/server/node_modules/watcher/dist/watcher_poller.js

@@ -0,0 +1,116 @@
+/* IMPORT */
+import { FileType, TargetEvent } from './enums.js';
+import LazyMapSet from './lazy_map_set.js';
+import Utils from './utils.js';
+import WatcherStats from './watcher_stats.js';
+/* MAIN */
+class WatcherPoller {
+    constructor() {
+        /* VARIABLES */
+        this.inos = {};
+        this.paths = new LazyMapSet();
+        this.stats = new Map();
+    }
+    /* API */
+    getIno(targetPath, event, type) {
+        const inos = this.inos[event];
+        if (!inos)
+            return;
+        const ino = inos[targetPath];
+        if (!ino)
+            return;
+        if (type && ino[1] !== type)
+            return;
+        return ino[0];
+    }
+    getStats(targetPath) {
+        return this.stats.get(targetPath);
+    }
+    async poll(targetPath, timeout) {
+        const stats = await Utils.fs.poll(targetPath, timeout);
+        if (!stats)
+            return;
+        const isSupported = stats.isFile() || stats.isDirectory();
+        if (!isSupported)
+            return;
+        return new WatcherStats(stats);
+    }
+    reset() {
+        this.inos = {};
+        this.paths = new LazyMapSet();
+        this.stats = new Map();
+    }
+    async update(targetPath, timeout) {
+        const prev = this.getStats(targetPath);
+        const next = await this.poll(targetPath, timeout);
+        this.updateStats(targetPath, next);
+        if (!prev && next) {
+            if (next.isFile()) {
+                this.updateIno(targetPath, TargetEvent.ADD, next);
+                return [TargetEvent.ADD];
+            }
+            if (next.isDirectory()) {
+                this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                return [TargetEvent.ADD_DIR];
+            }
+        }
+        else if (prev && !next) {
+            if (prev.isFile()) {
+                this.updateIno(targetPath, TargetEvent.UNLINK, prev);
+                return [TargetEvent.UNLINK];
+            }
+            if (prev.isDirectory()) {
+                this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                return [TargetEvent.UNLINK_DIR];
+            }
+        }
+        else if (prev && next) {
+            if (prev.isFile()) {
+                if (next.isFile()) {
+                    if (prev.ino === next.ino && !prev.size && !next.size)
+                        return []; // Same path, same content and same file, nothing actually changed
+                    this.updateIno(targetPath, TargetEvent.CHANGE, next);
+                    return [TargetEvent.CHANGE];
+                }
+                if (next.isDirectory()) {
+                    this.updateIno(targetPath, TargetEvent.UNLINK, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                    return [TargetEvent.UNLINK, TargetEvent.ADD_DIR];
+                }
+            }
+            else if (prev.isDirectory()) {
+                if (next.isFile()) {
+                    this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD, next);
+                    return [TargetEvent.UNLINK_DIR, TargetEvent.ADD];
+                }
+                if (next.isDirectory()) {
+                    if (prev.ino === next.ino)
+                        return []; // Same path and same directory, nothing actually changed
+                    this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                    return [TargetEvent.UNLINK_DIR, TargetEvent.ADD_DIR];
+                }
+            }
+        }
+        return [];
+    }
+    updateIno(targetPath, event, stats) {
+        const inos = this.inos[event] = this.inos[event] || (this.inos[event] = {});
+        const type = stats.isFile() ? FileType.FILE : FileType.DIR;
+        inos[targetPath] = [stats.ino, type];
+    }
+    updateStats(targetPath, stats) {
+        if (stats) {
+            this.paths.set(stats.ino, targetPath);
+            this.stats.set(targetPath, stats);
+        }
+        else {
+            const ino = this.stats.get(targetPath)?.ino || -1;
+            this.paths.delete(ino, targetPath);
+            this.stats.delete(targetPath);
+        }
+    }
+}
+/* EXPORT */
+export default WatcherPoller;

package/.output/server/node_modules/watcher/dist/watcher_stats.js

@@ -0,0 +1,29 @@
+/* IMPORT */
+/* MAIN */
+// An more memory-efficient representation of the useful subset of stats objects
+class WatcherStats {
+    /* CONSTRUCTOR */
+    constructor(stats) {
+        this.ino = (stats.ino <= Number.MAX_SAFE_INTEGER) ? Number(stats.ino) : stats.ino;
+        this.size = Number(stats.size);
+        this.atimeMs = Number(stats.atimeMs);
+        this.mtimeMs = Number(stats.mtimeMs);
+        this.ctimeMs = Number(stats.ctimeMs);
+        this.birthtimeMs = Number(stats.birthtimeMs);
+        this._isFile = stats.isFile();
+        this._isDirectory = stats.isDirectory();
+        this._isSymbolicLink = stats.isSymbolicLink();
+    }
+    /* API */
+    isFile() {
+        return this._isFile;
+    }
+    isDirectory() {
+        return this._isDirectory;
+    }
+    isSymbolicLink() {
+        return this._isSymbolicLink;
+    }
+}
+/* EXPORT */
+export default WatcherStats;

package/.output/server/node_modules/watcher/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "watcher",
+  "repository": "github:fabiospampinato/watcher",
+  "description": "The file system watcher that strives for perfection, with no native dependencies and optional rename detection support.",
+  "version": "2.3.1",
+  "type": "module",
+  "main": "dist/watcher.js",
+  "exports": "./dist/watcher.js",
+  "types": "./dist/watcher.d.ts",
+  "scripts": {
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "tsex prepare"
+  },
+  "keywords": [
+    "fs",
+    "file",
+    "system",
+    "filesystem",
+    "watch",
+    "watcher"
+  ],
+  "dependencies": {
+    "dettle": "^1.0.2",
+    "stubborn-fs": "^1.2.5",
+    "tiny-readdir": "^2.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.4.6",
+    "fava": "^0.2.0",
+    "tsex": "^3.0.0",
+    "typescript": "^5.1.6"
+  }
+}

package/.output/server/node_modules/which/package.json

@@ -0,0 +1,43 @@
+{
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "name": "which",
+  "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
+  "version": "2.0.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-which.git"
+  },
+  "main": "which.js",
+  "bin": {
+    "node-which": "./bin/node-which"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "isexe": "^2.0.0"
+  },
+  "devDependencies": {
+    "mkdirp": "^0.5.0",
+    "rimraf": "^2.6.2",
+    "tap": "^14.6.9"
+  },
+  "scripts": {
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublish": "npm run changelog",
+    "prechangelog": "bash gen-changelog.sh",
+    "changelog": "git add CHANGELOG.md",
+    "postchangelog": "git commit -m 'update changelog - '${npm_package_version}",
+    "postpublish": "git push origin --follow-tags"
+  },
+  "files": [
+    "which.js",
+    "bin/node-which"
+  ],
+  "tap": {
+    "check-coverage": true
+  },
+  "engines": {
+    "node": ">= 8"
+  }
+}