svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/fdir/dist/builder/index.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builder = void 0;
+const path_1 = require("path");
+const api_builder_1 = require("./api-builder");
+var pm = null;
+/* c8 ignore next 6 */
+try {
+    require.resolve("picomatch");
+    pm = require("picomatch");
+}
+catch (_e) {
+    // do nothing
+}
+class Builder {
+    globCache = {};
+    options = {
+        maxDepth: Infinity,
+        suppressErrors: true,
+        pathSeparator: path_1.sep,
+        filters: [],
+    };
+    globFunction;
+    constructor(options) {
+        this.options = { ...this.options, ...options };
+        this.globFunction = this.options.globFunction;
+    }
+    group() {
+        this.options.group = true;
+        return this;
+    }
+    withPathSeparator(separator) {
+        this.options.pathSeparator = separator;
+        return this;
+    }
+    withBasePath() {
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withRelativePaths() {
+        this.options.relativePaths = true;
+        return this;
+    }
+    withDirs() {
+        this.options.includeDirs = true;
+        return this;
+    }
+    withMaxDepth(depth) {
+        this.options.maxDepth = depth;
+        return this;
+    }
+    withMaxFiles(limit) {
+        this.options.maxFiles = limit;
+        return this;
+    }
+    withFullPaths() {
+        this.options.resolvePaths = true;
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withErrors() {
+        this.options.suppressErrors = false;
+        return this;
+    }
+    withSymlinks({ resolvePaths = true } = {}) {
+        this.options.resolveSymlinks = true;
+        this.options.useRealPaths = resolvePaths;
+        return this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        this.options.signal = signal;
+        return this;
+    }
+    normalize() {
+        this.options.normalizePath = true;
+        return this;
+    }
+    filter(predicate) {
+        this.options.filters.push(predicate);
+        return this;
+    }
+    onlyDirs() {
+        this.options.excludeFiles = true;
+        this.options.includeDirs = true;
+        return this;
+    }
+    exclude(predicate) {
+        this.options.exclude = predicate;
+        return this;
+    }
+    onlyCounts() {
+        this.options.onlyCounts = true;
+        return this;
+    }
+    crawl(root) {
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        // cast this since we don't have the new type params yet
+        this.globFunction = fn;
+        return this;
+    }
+    /**
+     * @deprecated Pass options using the constructor instead:
+     * ```ts
+     * new fdir(options).crawl("/path/to/root");
+     * ```
+     * This method will be removed in v7.0
+     */
+    /* c8 ignore next 4 */
+    crawlWithOptions(root, options) {
+        this.options = { ...this.options, ...options };
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        if (this.globFunction) {
+            return this.globWithOptions(patterns);
+        }
+        return this.globWithOptions(patterns, ...[{ dot: true }]);
+    }
+    globWithOptions(patterns, ...options) {
+        const globFn = (this.globFunction || pm);
+        /* c8 ignore next 5 */
+        if (!globFn) {
+            throw new Error('Please specify a glob function to use glob matching.');
+        }
+        var isMatch = this.globCache[patterns.join("\0")];
+        if (!isMatch) {
+            isMatch = globFn(patterns, ...options);
+            this.globCache[patterns.join("\0")] = isMatch;
+        }
+        this.options.filters.push((path) => isMatch(path));
+        return this;
+    }
+}
+exports.Builder = Builder;

data/lib/mount_svelte/node_modules/fdir/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Builder } from "./builder";
+export { Builder as fdir };
+export type Fdir = typeof Builder;
+export * from "./types";

data/lib/mount_svelte/node_modules/fdir/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fdir = void 0;
+const builder_1 = require("./builder");
+Object.defineProperty(exports, "fdir", { enumerable: true, get: function () { return builder_1.Builder; } });
+__exportStar(require("./types"), exports);

data/lib/mount_svelte/node_modules/fdir/dist/optimizer.d.ts

@@ -0,0 +1,3 @@
+export declare function findCommonRoots(patterns: string[]): string[];
+export declare function findDirectoryPatterns(patterns: string[]): string[];
+export declare function findMaxDepth(patterns: string[]): number | false;

data/lib/mount_svelte/node_modules/fdir/dist/optimizer.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMaxDepth = exports.findDirectoryPatterns = exports.findCommonRoots = void 0;
+// Glob Optimizations:
+// 1. Find common roots and only iterate on them
+//    For example:
+//      1. "node_modules/**/*.ts" only requires us to search in node_modules
+//          folder.
+//      2. Similarly, multiple glob patterns can have common deterministic roots
+//         The optimizer's job is to find these roots and only crawl them.
+//      3. If any of the glob patterns have a globstar i.e. **/ in them, we
+//         should bail out.
+// 2. Find out if glob is requesting only directories
+// 3. Find maximum depth requested
+// 4. If glob contains a root that doesn't exist, bail out
+const braces_1 = require("braces");
+const glob_parent_1 = __importDefault(require("glob-parent"));
+function findCommonRoots(patterns) {
+    const allRoots = new Set();
+    patterns = patterns.map((p) => (p.includes("{") ? (0, braces_1.expand)(p) : p)).flat();
+    for (const pattern of patterns) {
+        const parent = (0, glob_parent_1.default)(pattern);
+        if (parent === ".")
+            return [];
+        allRoots.add(parent);
+    }
+    return Array.from(allRoots.values()).filter((root) => {
+        for (const r of allRoots) {
+            if (r === root)
+                continue;
+            if (root.startsWith(r))
+                return false;
+        }
+        return true;
+    });
+}
+exports.findCommonRoots = findCommonRoots;
+function findDirectoryPatterns(patterns) {
+    return patterns.filter((p) => p.endsWith("/"));
+}
+exports.findDirectoryPatterns = findDirectoryPatterns;
+function findMaxDepth(patterns) {
+    const isGlobstar = patterns.some((p) => p.includes("**/") || p.includes("/**") || p === "**");
+    if (isGlobstar)
+        return false;
+    const maxDepth = patterns.reduce((depth, p) => {
+        return Math.max(depth, p.split("/").filter(Boolean).length);
+    }, 0);
+    return maxDepth;
+}
+exports.findMaxDepth = findMaxDepth;

data/lib/mount_svelte/node_modules/fdir/dist/types.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Queue } from "./api/queue";
+export type Counts = {
+    files: number;
+    directories: number;
+    /**
+     * @deprecated use `directories` instead. Will be removed in v7.0.
+     */
+    dirs: number;
+};
+export type Group = {
+    directory: string;
+    files: string[];
+    /**
+     * @deprecated use `directory` instead. Will be removed in v7.0.
+     */
+    dir: string;
+};
+export type GroupOutput = Group[];
+export type OnlyCountsOutput = Counts;
+export type PathsOutput = string[];
+export type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+export type WalkerState = {
+    root: string;
+    paths: string[];
+    groups: Group[];
+    counts: Counts;
+    options: Options;
+    queue: Queue;
+    symlinks: Map<string, string>;
+    visited: string[];
+};
+export type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+export type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+export type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+export type PathSeparator = "/" | "\\";
+export type Options<TGlobFunction = unknown> = {
+    includeBasePath?: boolean;
+    includeDirs?: boolean;
+    normalizePath?: boolean;
+    maxDepth: number;
+    maxFiles?: number;
+    resolvePaths?: boolean;
+    suppressErrors: boolean;
+    group?: boolean;
+    onlyCounts?: boolean;
+    filters: FilterPredicate[];
+    resolveSymlinks?: boolean;
+    useRealPaths?: boolean;
+    excludeFiles?: boolean;
+    excludeSymlinks?: boolean;
+    exclude?: ExcludePredicate;
+    relativePaths?: boolean;
+    pathSeparator: PathSeparator;
+    signal?: AbortSignal;
+    globFunction?: TGlobFunction;
+};
+export type GlobMatcher = (test: string) => boolean;
+export type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+export type GlobParams<T> = T extends (globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher ? TParams : [];

data/lib/mount_svelte/node_modules/fdir/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/lib/mount_svelte/node_modules/fdir/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import { PathSeparator } from "./types";
+export declare function cleanPath(path: string): string;
+export declare function convertSlashes(path: string, separator: PathSeparator): string;
+export declare function normalizePath(path: string, options: {
+    resolvePaths?: boolean;
+    normalizePath?: boolean;
+    pathSeparator: PathSeparator;
+}): string;

data/lib/mount_svelte/node_modules/fdir/dist/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = exports.convertSlashes = exports.cleanPath = void 0;
+const path_1 = require("path");
+function cleanPath(path) {
+    let normalized = (0, path_1.normalize)(path);
+    // we have to remove the last path separator
+    // to account for / root path
+    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep)
+        normalized = normalized.substring(0, normalized.length - 1);
+    return normalized;
+}
+exports.cleanPath = cleanPath;
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+exports.convertSlashes = convertSlashes;
+function normalizePath(path, options) {
+    const { resolvePaths, normalizePath, pathSeparator } = options;
+    const pathNeedsCleaning = (process.platform === "win32" && path.includes("/")) ||
+        path.startsWith(".");
+    if (resolvePaths)
+        path = (0, path_1.resolve)(path);
+    if (normalizePath || pathNeedsCleaning)
+        path = cleanPath(path);
+    if (path === ".")
+        return "";
+    const needsSeperator = path[path.length - 1] !== pathSeparator;
+    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+exports.normalizePath = normalizePath;

data/lib/mount_svelte/node_modules/fdir/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "fdir",
+  "version": "6.4.3",
+  "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublishOnly": "npm run test && npm run build",
+    "build": "tsc",
+    "test": "vitest run __tests__/",
+    "test:coverage": "vitest run --coverage __tests__/",
+    "test:watch": "vitest __tests__/",
+    "bench": "ts-node benchmarks/benchmark.js",
+    "bench:glob": "ts-node benchmarks/glob-benchmark.ts",
+    "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts",
+    "release": "./scripts/release.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thecodrr/fdir.git"
+  },
+  "keywords": [
+    "util",
+    "os",
+    "sys",
+    "fs",
+    "walk",
+    "crawler",
+    "directory",
+    "files",
+    "io",
+    "tiny-glob",
+    "glob",
+    "fast-glob",
+    "speed",
+    "javascript",
+    "nodejs"
+  ],
+  "author": "thecodrr <thecodrr@protonmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thecodrr/fdir/issues"
+  },
+  "homepage": "https://github.com/thecodrr/fdir#readme",
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/mock-fs": "^4.13.4",
+    "@types/node": "^20.9.4",
+    "@types/picomatch": "^3.0.0",
+    "@types/tap": "^15.0.11",
+    "@vitest/coverage-v8": "^0.34.6",
+    "all-files-in-tree": "^1.1.2",
+    "benny": "^3.7.1",
+    "csv-to-markdown-table": "^1.3.1",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.3.2",
+    "fdir1": "npm:fdir@1.2.0",
+    "fdir2": "npm:fdir@2.1.0",
+    "fdir3": "npm:fdir@3.4.2",
+    "fdir4": "npm:fdir@4.1.0",
+    "fdir5": "npm:fdir@5.0.0",
+    "fs-readdir-recursive": "^1.1.0",
+    "get-all-files": "^4.1.0",
+    "glob": "^10.3.10",
+    "klaw-sync": "^6.0.0",
+    "mock-fs": "^5.2.0",
+    "picomatch": "^4.0.2",
+    "recur-readdir": "0.0.1",
+    "recursive-files": "^1.0.2",
+    "recursive-fs": "^2.1.0",
+    "recursive-readdir": "^2.2.3",
+    "rrdir": "^12.1.0",
+    "systeminformation": "^5.21.17",
+    "tiny-glob": "^0.2.9",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2",
+    "vitest": "^0.34.6",
+    "walk-sync": "^3.0.0"
+  },
+  "peerDependencies": {
+    "picomatch": "^3 || ^4"
+  },
+  "peerDependenciesMeta": {
+    "picomatch": {
+      "optional": true
+    }
+  }
+}

data/lib/mount_svelte/node_modules/fsevents/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+-----------
+
+Copyright (C) 2010-2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/mount_svelte/node_modules/fsevents/README.md

@@ -0,0 +1,89 @@
+# fsevents
+
+Native access to MacOS FSEvents in [Node.js](https://nodejs.org/)
+
+The FSEvents API in MacOS allows applications to register for notifications of
+changes to a given directory tree. It is a very fast and lightweight alternative
+to kqueue.
+
+This is a low-level library. For a cross-platform file watching module that
+uses fsevents, check out [Chokidar](https://github.com/paulmillr/chokidar).
+
+## Usage
+
+```sh
+npm install fsevents
+```
+
+Supports only **Node.js v8.16 and higher**.
+
+```js
+const fsevents = require('fsevents');
+
+// To start observation
+const stop = fsevents.watch(__dirname, (path, flags, id) => {
+  const info = fsevents.getInfo(path, flags);
+});
+
+// To end observation
+stop();
+```
+
+> **Important note:** The API behaviour is slightly different from typical JS APIs. The `stop` function **must** be
+> retrieved and stored somewhere, even if you don't plan to stop the watcher. If you forget it, the garbage collector
+> will eventually kick in, the watcher will be unregistered, and your callbacks won't be called anymore.
+
+The callback passed as the second parameter to `.watch` get's called whenever the operating system detects a
+a change in the file system. It takes three arguments:
+
+###### `fsevents.watch(dirname: string, (path: string, flags: number, id: string) => void): () => Promise<undefined>`
+
+ * `path: string` - the item in the filesystem that have been changed
+ * `flags: number` - a numeric value describing what the change was
+ * `id: string` - an unique-id identifying this specific event
+
+ Returns closer callback which when called returns a Promise resolving when the watcher process has been shut down.
+
+###### `fsevents.getInfo(path: string, flags: number, id: string): FsEventInfo`
+
+The `getInfo` function takes the `path`, `flags` and `id` arguments and converts those parameters into a structure
+that is easier to digest to determine what the change was.
+
+The `FsEventsInfo` has the following shape:
+
+```js
+/**
+ * @typedef {'created'|'modified'|'deleted'|'moved'|'root-changed'|'cloned'|'unknown'} FsEventsEvent
+ * @typedef {'file'|'directory'|'symlink'} FsEventsType
+ */
+{
+  "event": "created", // {FsEventsEvent}
+  "path": "file.txt",
+  "type": "file",    // {FsEventsType}
+  "changes": {
+    "inode": true,   // Had iNode Meta-Information changed
+    "finder": false, // Had Finder Meta-Data changed
+    "access": false, // Had access permissions changed
+    "xattrs": false  // Had xAttributes changed
+  },
+  "flags": 0x100000000
+}
+```
+
+## Changelog
+
+- v2.3 supports Apple Silicon ARM CPUs
+- v2 supports node 8.16+ and reduces package size massively
+- v1.2.8 supports node 6+
+- v1.2.7 supports node 4+
+
+## Troubleshooting
+
+- I'm getting `EBADPLATFORM` `Unsupported platform for fsevents` error.
+- It's fine, nothing is broken. fsevents is macos-only. Other platforms are skipped. If you want to hide this warning, report a bug to NPM bugtracker asking them to hide ebadplatform warnings by default.
+
+## License
+
+The MIT License Copyright (C) 2010-2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller — see LICENSE file.
+
+Visit our [GitHub page](https://github.com/fsevents/fsevents) and [NPM Page](https://npmjs.org/package/fsevents)

data/lib/mount_svelte/node_modules/fsevents/fsevents.d.ts

@@ -0,0 +1,46 @@
+declare type Event = "created" | "cloned" | "modified" | "deleted" | "moved" | "root-changed" | "unknown";
+declare type Type = "file" | "directory" | "symlink";
+declare type FileChanges = {
+  inode: boolean;
+  finder: boolean;
+  access: boolean;
+  xattrs: boolean;
+};
+declare type Info = {
+  event: Event;
+  path: string;
+  type: Type;
+  changes: FileChanges;
+  flags: number;
+};
+declare type WatchHandler = (path: string, flags: number, id: string) => void;
+export declare function watch(path: string, handler: WatchHandler): () => Promise<void>;
+export declare function watch(path: string, since: number, handler: WatchHandler): () => Promise<void>;
+export declare function getInfo(path: string, flags: number): Info;
+export declare const constants: {
+  None: 0x00000000;
+  MustScanSubDirs: 0x00000001;
+  UserDropped: 0x00000002;
+  KernelDropped: 0x00000004;
+  EventIdsWrapped: 0x00000008;
+  HistoryDone: 0x00000010;
+  RootChanged: 0x00000020;
+  Mount: 0x00000040;
+  Unmount: 0x00000080;
+  ItemCreated: 0x00000100;
+  ItemRemoved: 0x00000200;
+  ItemInodeMetaMod: 0x00000400;
+  ItemRenamed: 0x00000800;
+  ItemModified: 0x00001000;
+  ItemFinderInfoMod: 0x00002000;
+  ItemChangeOwner: 0x00004000;
+  ItemXattrMod: 0x00008000;
+  ItemIsFile: 0x00010000;
+  ItemIsDir: 0x00020000;
+  ItemIsSymlink: 0x00040000;
+  ItemIsHardlink: 0x00100000;
+  ItemIsLastHardlink: 0x00200000;
+  OwnEvent: 0x00080000;
+  ItemCloned: 0x00400000;
+};
+export {};

data/lib/mount_svelte/node_modules/fsevents/fsevents.js

@@ -0,0 +1,83 @@
+/*
+ ** © 2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller
+ ** Licensed under MIT License.
+ */
+
+/* jshint node:true */
+"use strict";
+
+if (process.platform !== "darwin") {
+  throw new Error(`Module 'fsevents' is not compatible with platform '${process.platform}'`);
+}
+
+const Native = require("./fsevents.node");
+const events = Native.constants;
+
+function watch(path, since, handler) {
+  if (typeof path !== "string") {
+    throw new TypeError(`fsevents argument 1 must be a string and not a ${typeof path}`);
+  }
+  if ("function" === typeof since && "undefined" === typeof handler) {
+    handler = since;
+    since = Native.flags.SinceNow;
+  }
+  if (typeof since !== "number") {
+    throw new TypeError(`fsevents argument 2 must be a number and not a ${typeof since}`);
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError(`fsevents argument 3 must be a function and not a ${typeof handler}`);
+  }
+
+  let instance = Native.start(Native.global, path, since, handler);
+  if (!instance) throw new Error(`could not watch: ${path}`);
+  return () => {
+    const result = instance ? Promise.resolve(instance).then(Native.stop) : Promise.resolve(undefined);
+    instance = undefined;
+    return result;
+  };
+}
+
+function getInfo(path, flags) {
+  return {
+    path,
+    flags,
+    event: getEventType(flags),
+    type: getFileType(flags),
+    changes: getFileChanges(flags),
+  };
+}
+
+function getFileType(flags) {
+  if (events.ItemIsFile & flags) return "file";
+  if (events.ItemIsDir & flags) return "directory";
+  if (events.MustScanSubDirs & flags) return "directory"; 
+  if (events.ItemIsSymlink & flags) return "symlink";
+}
+function anyIsTrue(obj) {
+  for (let key in obj) {
+    if (obj[key]) return true;
+  }
+  return false;
+}
+function getEventType(flags) {
+  if (events.ItemRemoved & flags) return "deleted";
+  if (events.ItemRenamed & flags) return "moved";
+  if (events.ItemCreated & flags) return "created";
+  if (events.ItemModified & flags) return "modified";
+  if (events.RootChanged & flags) return "root-changed";
+  if (events.ItemCloned & flags) return "cloned";
+  if (anyIsTrue(flags)) return "modified";
+  return "unknown";
+}
+function getFileChanges(flags) {
+  return {
+    inode: !!(events.ItemInodeMetaMod & flags),
+    finder: !!(events.ItemFinderInfoMod & flags),
+    access: !!(events.ItemChangeOwner & flags),
+    xattrs: !!(events.ItemXattrMod & flags),
+  };
+}
+
+exports.watch = watch;
+exports.getInfo = getInfo;
+exports.constants = events;