@zenfs/core 2.4.1 → 2.4.2

package/COPYING.md

@@ -0,0 +1,18 @@
+_This document is supplemental to the license._
+
+**This is a very easy requirement, please respect it.**
+Feel free to reach out if you have any concerns regarding licensing.
+
+If you convey copies of ZenFS (including in bundles), you must meet section 4 and 5 of the license. This includes at a minimum:
+
+- disclosure that ZenFS is in use
+- linking to the GitHub or npm pages
+- referencing the license and copyright.
+
+For example, in a list of libraries you could have:
+
+> - [ZenFS](https://github.com/zen-fs/core), LGPL-3.0-or-later, Copyright © James Prevett and other ZenFS contributors
+
+<br />
+
+Before v2.4.0, ZenFS was licensed under the MIT. This still means you need to include the copyright notice and license.

package/{readme.md → README.md}

@@ -19,7 +19,12 @@ ZenFS supports a number of other backends.
 Many are provided as separate packages under `@zenfs`.
 More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
-You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs).
+You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs). Below is a list of the backends included with some of them:
+
+- @zenfs/archives: `Zip`, `Iso`
+- @zenfs/cloud: `Dropbox`, `GoogleDrive`, `S3Bucket`
+- @zenfs/dom: `WebAccess` (Web [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API)/OPFS), `IndexedDB`, `WebStorage` (`localStorage`/`sessionStorage`), `XML` (DOM elements)
+- @zenfs/emscripten: `Emscripten` and a plugin for Emscripten's file system API
 
 As an added bonus, all ZenFS backends support synchronous operations.
 Additionally, all of the backends included with the core are cross-platform.
@@ -34,7 +39,7 @@ npm install @zenfs/core
 
 If you're using ZenFS, especially for big projects, please consider supporting the project.
 Thousands of hours have been dedicated to its development.
-Your acknowledgment or financial support would go a long way toward improving ZenFS and its community.
+Your financial support would go a long way toward improving ZenFS and its community.
 
 ## Usage
 
@@ -69,8 +74,8 @@ await configure({
 		'/mnt/zip': { backend: Zip, data: await res.arrayBuffer() },
 		'/tmp': InMemory,
 		'/home': IndexedDB,
-	}
-};
+	},
+});
 ```
 
 Note that while you aren't required to use absolute paths for the keys of `mounts`, it is a good practice to do so.
@@ -140,7 +145,7 @@ await configure({
 	},
 });
 
-fs.mkdirSync('/mnt');
+fs.mkdirSync('/mnt/zip', { recursive: true });
 
 const res = await fetch('mydata.zip');
 const zipfs = await resolveMountConfig({ backend: Zip, data: await res.arrayBuffer() });
@@ -156,82 +161,19 @@ fs.umount('/mnt/zip'); // finished using the zip
 
 ### Devices and device files
 
-ZenFS includes support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. You can automatically add some normal devices with the `addDevices` configuration option:
-
-```ts
-await configure({
-	mounts: {
-		/* ... */
-	},
-	addDevices: true,
-});
-
-fs.writeFileSync('/dev/null', 'Some data to be discarded');
-
-const randomData = new Uint8Array(100);
-
-const random = fs.openSync('/dev/random', 'r');
-fs.readSync(random, randomData);
-fs.closeSync(random);
-```
-
-You can create your own devices by implementing a `DeviceDriver`. For example, the null device looks similar to this:
-
-```ts
-const customNullDevice = {
-	name: 'custom_null',
-	// only 1 can exist per DeviceFS
-	singleton: true,
-	// optional if false
-	isBuffered: false,
-	read() {
-		return 0;
-	},
-	write() {
-		return 0;
-	},
-};
-```
-
-Note the actual implementation's write is slightly more complicated since it adds to the file position. You can find more information on the docs.
-
-Finally, if you'd like to use your custom device with the file system:
+ZenFS includes support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. Check out the [Devices and Device Drivers](https://zenfs.dev/core/documents/Devices_and_Device_Drivers) documentation for more information.
 
-```ts
-import { addDevice, fs } from '@zenfs/core';
-
-addDevice(customNullDevice);
-
-fs.writeFileSync('/dev/custom', 'This gets discarded.');
-```
+## Bundling
 
-## Using with bundlers
+ZenFS exports a drop-in for Node's `fs` module, so you can use it for your bundler of preference using the default export.
 
-ZenFS exports a drop-in for Node's `fs` module (up to the version of `@types/node` in package.json), so you can use it for your bundler of preference using the default export.
+> [!IMPORTANT]
+> See [COPYING.md](./COPYING.md)
 
 ## Sponsors
 
-A huge thank you to [![Deco.cx logo](https://avatars.githubusercontent.com/deco-cx?size=20) Deco.cx](https://github.com/deco-cx) for sponsoring ZenFS and helping to make this possible.
-
-## Building
-
-- Make sure you have Node and NPM installed. You must have Node v22 or newer.
-- Install dependencies with `npm install`
-- Build using `npx tsc` or `npm run build`
-- You can find the built code in `dist`.
+A huge thank you to [deco.cx](https://github.com/deco-cx) for sponsoring ZenFS and helping to make this possible.
 
 ## Contact and Support
 
 You can reach out [on Discord](https://zenfs.dev/discord) or by emailing jp@zenfs.dev
-
-### Testing
-
-Run unit tests with:
-
-- `npm test` to run all tests using the default configuration
-- `npx zenfs-test -abc` to run the common tests and run the full FS suite against all included backends
-    - You can also run this command to test your own backends, the `--auto` (`-a`) flag will automatically detect any setup scripts matching `tests/setup/*` or `tests/setup-*.ts`. If you do, you'll need to include the `c8` dependency for coverage.
-
-### BrowserFS Fork
-
-ZenFS is a fork of [BrowserFS](https://github.com/jvilk/BrowserFS). If you are using ZenFS in a research paper, you may want to [cite BrowserFS](https://github.com/jvilk/BrowserFS#citing).

package/dist/backends/fetch.js

@@ -6,7 +6,7 @@ import * as requests from 'utilium/requests.js';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
 import { normalizePath } from '../utils.js';
-import { S_IFREG } from '../vfs/constants.js';
+import { S_IFREG } from '../constants.js';
 /** Parse and throw */
 function parseError(error) {
     if (!('tag' in error))

package/dist/backends/memory.js

@@ -1,4 +1,4 @@
-import { size_max } from '../vfs/constants.js';
+import { size_max } from '../constants.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
 /**

package/dist/backends/passthrough.d.ts

@@ -1,8 +1,7 @@
-import type * as fs from 'node:fs';
 import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { type InodeLike } from '../internal/inode.js';
-export type NodeFS = typeof fs;
+import type { NodeFS } from '../node/types.js';
 /**
  * Passthrough backend options
  * @category Backends and Configuration

package/dist/backends/single_buffer.js

@@ -87,7 +87,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { alert, crit, err, warn } from 'kerium/log';
-import { array, offsetof, packed, sizeof } from 'memium';
+import { array, offsetof, sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
 import { crc32c } from 'utilium/checksum.js';

package/dist/backends/store/fs.js

@@ -58,10 +58,10 @@ import { _throw, canary, encodeUTF8 } from 'utilium';
 import { extendBuffer } from 'utilium/buffer.js';
 import { Index } from '../../internal/file_index.js';
 import { FileSystem } from '../../internal/filesystem.js';
-import { Inode, isDirectory, rootIno } from '../../internal/inode.js';
+import { Inode, isDirectory, isFile, rootIno } from '../../internal/inode.js';
 import { basename, dirname, join, parse, relative } from '../../path.js';
 import { decodeDirListing, encodeDirListing } from '../../utils.js';
-import { S_IFDIR, S_IFREG, size_max } from '../../vfs/constants.js';
+import { S_IFDIR, S_IFREG, size_max } from '../../constants.js';
 import { WrappedTransaction } from './store.js';
 /**
  * A file system which uses a `Store`
@@ -304,7 +304,7 @@ export class StoreFS extends FileSystem {
                 : decodeDirListing((await tx.get(newDirNode.data)) ?? _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
                 const existing = new Inode((await tx.get(newDirList[_new.base])) ?? _throw(withErrno('ENOENT')));
-                if (!existing.toStats().isFile())
+                if (!isFile(existing))
                     throw withErrno('EISDIR');
                 await tx.remove(existing.data);
                 await tx.remove(newDirList[_new.base]);
@@ -353,7 +353,7 @@ export class StoreFS extends FileSystem {
             const newDirList = sameParent ? oldDirList : decodeDirListing(tx.getSync(newDirNode.data) ?? _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
                 const existing = new Inode(tx.getSync(newDirList[_new.base]) ?? _throw(withErrno('ENOENT')));
-                if (!existing.toStats().isFile())
+                if (!isFile(existing))
                     throw withErrno('EISDIR');
                 tx.removeSync(existing.data);
                 tx.removeSync(newDirList[_new.base]);

package/dist/config.js

@@ -4,9 +4,9 @@ import { defaultContext } from './internal/contexts.js';
 import { createCredentials } from './internal/credentials.js';
 import { DeviceFS } from './internal/devices.js';
 import { FileSystem } from './internal/filesystem.js';
+import { exists, mkdir, stat } from './node/promises.js';
 import { _setAccessChecks } from './vfs/config.js';
-import * as fs from './vfs/index.js';
-import { mounts } from './vfs/shared.js';
+import { mount, mounts, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
  * @category Backends and Configuration
@@ -69,8 +69,8 @@ export async function configureSingle(configuration) {
         throw new TypeError('Invalid single mount point configuration');
     }
     const resolved = await resolveMountConfig(configuration);
-    fs.umount('/');
-    fs.mount('/', resolved);
+    umount('/');
+    mount('/', resolved);
 }
 /**
  * Like `fs.mount`, but it also creates missing directories.
@@ -78,19 +78,19 @@ export async function configureSingle(configuration) {
  * This is implemented as a separate function to avoid a circular dependency between vfs/shared.ts and other vfs layer files.
  * @internal
  */
-async function mount(path, mount) {
+async function mountWithMkdir(path, fs) {
     if (path == '/') {
-        fs.mount(path, mount);
+        mount(path, fs);
         return;
     }
-    const stats = await fs.promises.stat(path).catch(() => null);
+    const stats = await stat(path).catch(() => null);
     if (!stats) {
-        await fs.promises.mkdir(path, { recursive: true });
+        await mkdir(path, { recursive: true });
     }
     else if (!stats.isDirectory()) {
         throw withErrno('ENOTDIR', 'Missing directory at mount point: ' + path);
     }
-    fs.mount(path, mount);
+    mount(path, fs);
 }
 /**
  * @category Backends and Configuration
@@ -124,8 +124,8 @@ export async function configure(configuration) {
                 mountConfig.caseFold ??= configuration.caseFold;
             }
             if (point == '/')
-                fs.umount('/');
-            await mount(point, await resolveMountConfig(mountConfig));
+                umount('/');
+            await mountWithMkdir(point, await resolveMountConfig(mountConfig));
         }
     }
     for (const fs of mounts.values()) {
@@ -135,17 +135,17 @@ export async function configure(configuration) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();
-        await mount('/dev', devfs);
+        await mountWithMkdir('/dev', devfs);
     }
     if (configuration.defaultDirectories) {
         for (const dir of _defaultDirectories) {
-            if (await fs.promises.exists(dir)) {
-                const stats = await fs.promises.stat(dir);
+            if (await exists(dir)) {
+                const stats = await stat(dir);
                 if (!stats.isDirectory())
                     log.warn('Default directory exists but is not a directory: ' + dir);
             }
             else
-                await fs.promises.mkdir(dir);
+                await mkdir(dir);
         }
     }
 }

package/dist/context.js

@@ -3,7 +3,8 @@ import { bindFunctions } from 'utilium';
 import { defaultContext } from './internal/contexts.js';
 import { createCredentials } from './internal/credentials.js';
 import * as path from './path.js';
-import * as fs from './vfs/index.js';
+import * as fs from './node/index.js';
+import * as xattr from './vfs/xattr.js';
 // 0 is reserved for the global/default context
 let _nextId = 1;
 /**
@@ -33,7 +34,7 @@ export function bindContext({ root = this?.root || '/', pwd = this?.pwd || '/',
         fs: {
             ...bindFunctions(fs, ctx),
             promises: bindFunctions(fs.promises, ctx),
-            xattr: bindFunctions(fs.xattr, ctx),
+            xattr: bindFunctions(xattr, ctx),
         },
         path: bindFunctions(path, ctx),
         bind: (init) => {

package/dist/index.d.ts

@@ -1,12 +1,18 @@
+/*!
+ * @zenfs/core — https://npmjs.com/package/@zenfs/core
+ * Copyright © James Prevett and other ZenFS contributors.
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './vfs/stats.js';
 export * from './utils.js';
 export { mounts } from './vfs/shared.js';
-export * from './vfs/index.js';
+import * as fs from './node/compat.js';
+/** @primaryExport */
 export { fs };
-import * as fs from './vfs/index.js';
 export default fs;
+export * from './node/compat.js';
+export * as vfs from './vfs/index.js';

package/dist/index.js

@@ -1,15 +1,20 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
+/*!
+ * @zenfs/core — https://npmjs.com/package/@zenfs/core
+ * Copyright © James Prevett and other ZenFS contributors.
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './vfs/stats.js';
 export * from './utils.js';
 export { mounts } from './vfs/shared.js';
-export * from './vfs/index.js';
+import * as fs from './node/compat.js';
+/** @primaryExport */
 export { fs };
-import * as fs from './vfs/index.js';
 export default fs;
+export * from './node/compat.js';
+export * as vfs from './vfs/index.js';
 import $pkg from '../package.json' with { type: 'json' };
 globalThis.__zenfs__ = Object.assign(Object.create(fs), { _version: $pkg.version });

package/dist/internal/contexts.d.ts

@@ -1,7 +1,8 @@
 import type { Bound } from 'utilium';
+import type * as fs from '../node/index.js';
 import type * as path from '../path.js';
-import type { SyncHandle } from '../vfs/file.js';
-import type * as fs from '../vfs/index.js';
+import type { Handle } from '../vfs/file.js';
+import type * as xattr from '../vfs/xattr.js';
 import type { Credentials, CredentialsInit } from './credentials.js';
 /**
  * A context used for FS operations
@@ -21,7 +22,7 @@ export interface FSContext {
     /** The credentials of the context, used for access checks */
     readonly credentials: Credentials;
     /** A map of open file descriptors to their handles */
-    descriptors: Map<number, SyncHandle>;
+    descriptors: Map<number, Handle>;
     /** The parent context, if any. */
     parent: V_Context;
     /** The child contexts */
@@ -38,7 +39,7 @@ export type V_Context = void | null | (Partial<FSContext> & object);
 export interface BoundContext extends FSContext {
     fs: Bound<typeof fs, FSContext> & {
         promises: Bound<typeof fs.promises, FSContext>;
-        xattr: Bound<typeof fs.xattr, FSContext>;
+        xattr: Bound<typeof xattr, FSContext>;
     };
     /** Path functions, bound to the context */
     path: Bound<typeof path, FSContext>;

package/dist/internal/devices.js

@@ -8,7 +8,7 @@ import { decodeUTF8, omit } from 'utilium';
 import { InMemoryStore } from '../backends/memory.js';
 import { StoreFS } from '../backends/store/fs.js';
 import { basename, dirname } from '../path.js';
-import { S_IFCHR } from '../vfs/constants.js';
+import { S_IFCHR } from '../constants.js';
 import { Inode } from './inode.js';
 /**
  * A temporary file system that manages and interfaces with devices

package/dist/internal/error.d.ts

@@ -1,4 +1,5 @@
-import { Exception, type ExceptionJSON } from 'kerium';
+import { Exception, type ExceptionExtra, type ExceptionJSON } from 'kerium';
+import type { FileSystem } from './filesystem.js';
 /**
  * @deprecated Use {@link ExceptionJSON} instead
  * @category Internals
@@ -15,4 +16,12 @@ export declare const ErrnoError: typeof Exception;
  */
 export type ErrnoError = Exception;
 export declare function withPath<E extends Exception>(e: E, path: string): E;
-export declare function wrap<const FS, const Prop extends keyof FS & string>(fs: FS, prop: Prop, path: string, dest?: string): FS[Prop];
+/**
+ * @internal @hidden
+ */
+export declare function wrap<const FS, const Prop extends keyof FS & string>(fs: FS, prop: Prop, path: string | ExceptionExtra, dest?: string): FS[Prop];
+/**
+ * @internal
+ * Wraps an `fs` so that thrown errors aren't empty
+ */
+export declare function withExceptionContext<const FS extends FileSystem>(fs: FS, context: ExceptionExtra): FS;

package/dist/internal/error.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { Exception, setUVMessage } from 'kerium';
+import { Errno, Exception, setUVMessage, UV } from 'kerium';
 /**
  * @deprecated Use {@link Exception} instead
  * @category Internals
@@ -9,7 +9,11 @@ export function withPath(e, path) {
     e.path = path;
     return e;
 }
+/**
+ * @internal @hidden
+ */
 export function wrap(fs, prop, path, dest) {
+    const extra = typeof path === 'string' ? { path, dest, syscall: prop.endsWith('Sync') ? prop.slice(0, -4) : prop } : path;
     const fn = fs[prop];
     if (typeof fn !== 'function')
         throw new TypeError(`${prop} is not a function`);
@@ -18,7 +22,39 @@ export function wrap(fs, prop, path, dest) {
             return fn.call(fs, ...args);
         }
         catch (e) {
-            throw setUVMessage(Object.assign(e, { path, dest, syscall: prop.endsWith('Sync') ? prop.slice(0, -4) : prop }));
+            throw setUVMessage(Object.assign(e, extra));
         }
     };
 }
+/**
+ * @internal
+ * Wraps an `fs` so that thrown errors aren't empty
+ */
+export function withExceptionContext(fs, context) {
+    return new Proxy(fs, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop);
+            if (typeof value != 'function')
+                return value;
+            return function __withContext(...args) {
+                try {
+                    const result = value.apply(target, args);
+                    if (!(result instanceof Promise))
+                        return result;
+                    return result.catch((e) => {
+                        if ('code' in e)
+                            throw setUVMessage(Object.assign(e, context));
+                        if (e in Errno) {
+                            const ex = UV(e, context);
+                            Error.captureStackTrace(ex, __withContext);
+                        }
+                        throw e;
+                    });
+                }
+                catch (e) {
+                    throw setUVMessage(Object.assign(e, context));
+                }
+            };
+        },
+    });
+}

package/dist/internal/file_index.js

@@ -4,7 +4,7 @@ import { withErrno } from 'kerium';
 import { sizeof } from 'memium';
 import { isJSON, randomInt } from 'utilium';
 import { basename, dirname } from '../path.js';
-import { S_IFDIR, S_IFMT, size_max } from '../vfs/constants.js';
+import { S_IFDIR, S_IFMT, size_max } from '../constants.js';
 import { Inode } from './inode.js';
 export const version = 1;
 /**

package/dist/internal/index.d.ts

@@ -1,4 +1,5 @@
 export { log } from 'kerium';
+export * from './contexts.js';
 export * from './credentials.js';
 export * from './devices.js';
 export * from './error.js';

package/dist/internal/index.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-export { log } from 'kerium'; // DO NOT USE
+export { log } from 'kerium'; // DO NOT USE @todo [BREAKING] Remove this
+export * from './contexts.js';
 export * from './credentials.js';
 export * from './devices.js';
 export * from './error.js';

package/dist/internal/index_fs.js

@@ -3,7 +3,7 @@
 import { withErrno } from 'kerium';
 import { _throw } from 'utilium';
 import { dirname, join, relative } from '../path.js';
-import { S_IFDIR, S_IFMT, S_IFREG, S_ISGID, S_ISUID } from '../vfs/constants.js';
+import { S_IFDIR, S_IFMT, S_IFREG, S_ISGID, S_ISUID } from '../constants.js';
 import { Index } from './file_index.js';
 import { FileSystem } from './filesystem.js';
 import { Inode } from './inode.js';

package/dist/internal/inode.d.ts

@@ -1,5 +1,5 @@
 import { BufferView } from 'utilium/buffer.js';
-import { Stats, type StatsLike } from '../vfs/stats.js';
+import { Stats } from '../node/stats.js';
 import { type V_Context } from './contexts.js';
 /**
  * Root inode
@@ -36,7 +36,51 @@ export interface InodeFields {
  * @category Internals
  * @internal
  */
-export interface InodeLike extends StatsLike<number>, InodeFields {
+export interface InodeLike<T extends number | bigint = number> extends InodeFields {
+    /**
+     * Size of the item in bytes.
+     * For directories/symlinks, this is normally the size of the struct that represents the item.
+     */
+    size: T;
+    /**
+     * Unix-style file mode (e.g. 0o644) that includes the item type
+     */
+    mode: T;
+    /**
+     * Time of last access, since epoch
+     */
+    atimeMs: T;
+    /**
+     * Time of last modification, since epoch
+     */
+    mtimeMs: T;
+    /**
+     * Time of last time file status was changed, since epoch
+     */
+    ctimeMs: T;
+    /**
+     * Time of file creation, since epoch
+     */
+    birthtimeMs: T;
+    /**
+     * The id of the user that owns the file
+     */
+    uid: T;
+    /**
+     * The id of the group that owns the file
+     */
+    gid: T;
+    /**
+     * Inode number
+     */
+    ino: T;
+    /**
+     * Number of hard links
+     */
+    nlink: T;
+    /**
+     * Extended attributes
+     */
     attributes?: Attributes;
 }
 /**
@@ -153,6 +197,7 @@ export declare class Inode extends Inode_base implements InodeLike {
     toJSON(): InodeLike;
     /**
      * Handy function that converts the Inode to a Node Stats object.
+     * @deprecated Use `new Stats(inode)` instead.
      */
     toStats(): Stats;
     /**
@@ -194,4 +239,8 @@ export declare function isFIFO(metadata: {
  * @internal
  */
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
+/**
+ * @hidden @internal
+ */
+export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
 export {};

package/dist/internal/inode.js

@@ -39,8 +39,8 @@ import { sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
 import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer.js';
-import * as c from '../vfs/constants.js';
-import { Stats } from '../vfs/stats.js';
+import { Stats } from '../node/stats.js';
+import * as c from '../constants.js';
 import { defaultContext } from './contexts.js';
 /**
  * Root inode
@@ -549,6 +549,7 @@ let Inode = (() => {
         }
         /**
          * Handy function that converts the Inode to a Node Stats object.
+         * @deprecated Use `new Stats(inode)` instead.
          */
         toStats() {
             return new Stats(this);
@@ -647,3 +648,18 @@ export function hasAccess($, inode, access) {
         perm |= c.X_OK;
     return (perm & access) === access;
 }
+/**
+ * @hidden @internal
+ */
+export function _chown(stats, uid, gid) {
+    let valid = true;
+    if (!isNaN(uid) && uid >= 0 && uid < c.size_max)
+        stats.uid = uid;
+    else
+        valid = false;
+    if (!isNaN(gid) && gid >= 0 && gid < c.size_max)
+        stats.gid = gid;
+    else
+        valid = false;
+    return valid;
+}

package/dist/mixins/shared.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/no-empty-object-type,@typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /*
     Code shared by various mixins
 */