@gjsify/fs 0.4.0 → 0.4.3

package/src/read-stream.ts

@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Adapted from Deno (refs/deno/ext/node/polyfills/_fs/_fs_streams.ts)
-// Copyright (c) 2018-2026 the Deno authors. MIT license.
-// Modifications: Rewritten to use Gio.File / Gio.FileInputStream for GJS
-import Gio from '@girs/gio-2.0';
-import GLib from '@girs/glib-2.0';
-import { Buffer } from "node:buffer";
-import { Readable } from "node:stream";
-import { normalizePath } from './utils.js';
-
-import type { CreateReadStreamOptions } from 'node:fs/promises';
-import type { PathLike, ReadStream as IReadStream } from 'node:fs';
-
-export class ReadStream extends Readable implements IReadStream {
-  bytesRead = 0;
-  path: string | Buffer;
-  pending = true;
-  fd: number | null = null;
-
-  private _gioFile: Gio.File;
-  private _inputStream: Gio.FileInputStream | null = null;
-  private _cancellable = new Gio.Cancellable();
-  private _start: number;
-  private _end: number;
-  private _pos: number;
-
-  close(callback?: (err?: NodeJS.ErrnoException | null) => void): void {
-    this._cancellable.cancel();
-    if (this._inputStream) {
-      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
-      this._inputStream = null;
-    }
-    this.destroy();
-    if (callback) callback(null);
-  }
-
-  constructor(path: PathLike, opts?: CreateReadStreamOptions) {
-    const pathStr = normalizePath(path);
-
-    super({
-      highWaterMark: opts?.highWaterMark ?? 64 * 1024,
-      encoding: opts?.encoding as BufferEncoding | undefined,
-      objectMode: false,
-    });
-
-    this.path = pathStr;
-    this._gioFile = Gio.File.new_for_path(pathStr);
-    this._start = (opts?.start as number) ?? 0;
-    this._end = (opts?.end as number) ?? Infinity;
-    this._pos = this._start;
-  }
-
-  // Use _construct() for async file opening so the stream machinery defers
-  // _read() until the file is open. This avoids the fragile _pendingReadSize
-  // pattern and correctly handles backpressure via the constructed flag.
-  override _construct(callback: (err?: Error | null) => void): void {
-    this._gioFile.read_async(GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
-      if (this.destroyed) { callback(); return; }
-      try {
-        this._inputStream = this._gioFile.read_finish(asyncResult);
-        this.pending = false;
-        this.emit('open', 0);
-        this.emit('ready');
-        if (this._start > 0 && this._inputStream!.can_seek()) {
-          this._inputStream!.seek(this._start, GLib.SeekType.SET, null);
-        }
-        callback();
-      } catch (err) {
-        if (!this._cancellable.is_cancelled()) {
-          callback(err as Error);
-        }
-      }
-    });
-  }
-
-  override _read(size: number): void {
-    this._doRead(size);
-  }
-
-  private _doRead(size: number): void {
-    let toRead = size;
-    if (this._end !== Infinity) {
-      const remaining = this._end - this._pos + 1;
-      if (remaining <= 0) {
-        this.push(null);
-        return;
-      }
-      toRead = Math.min(size, remaining);
-    }
-
-    const stream = this._inputStream!;
-    stream.read_bytes_async(toRead, GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
-      try {
-        const gbytes = stream.read_bytes_finish(asyncResult);
-        const data = gbytes.get_data();
-
-        if (!data || data.length === 0) {
-          this.push(null);
-          return;
-        }
-
-        this.bytesRead += data.length;
-        this._pos += data.length;
-        this.push(Buffer.from(data));
-      } catch (err) {
-        if (!this._cancellable.is_cancelled()) {
-          this.destroy(err as Error);
-        }
-      }
-    });
-  }
-
-  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
-    this._cancellable.cancel();
-    if (this._inputStream) {
-      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
-      this._inputStream = null;
-    }
-    callback(error);
-  }
-}
-
-export function createReadStream(
-  path: string | URL,
-  options?: CreateReadStreamOptions,
-): ReadStream {
-  return new ReadStream(path, options);
-}

package/src/stat-watcher.ts

@@ -1,116 +0,0 @@
-// Reference: Node.js lib/internal/fs/watchers.js (StatWatcher)
-// Reimplemented for GJS using setInterval polling
-
-import { EventEmitter } from 'node:events';
-import { statSync } from './sync.js';
-
-import type { PathLike, Stats } from 'node:fs';
-
-function zeroedStat(): Stats {
-  return {
-    dev: 0, ino: 0, mode: 0, nlink: 0, uid: 0, gid: 0, rdev: 0,
-    size: 0, blksize: 0, blocks: 0,
-    atimeMs: 0, mtimeMs: 0, ctimeMs: 0, birthtimeMs: 0,
-    atime: new Date(0), mtime: new Date(0), ctime: new Date(0), birthtime: new Date(0),
-    isFile: () => false, isDirectory: () => false, isBlockDevice: () => false,
-    isCharacterDevice: () => false, isSymbolicLink: () => false, isFIFO: () => false,
-    isSocket: () => false,
-  } as unknown as Stats;
-}
-
-export class StatWatcher extends EventEmitter {
-  private _path: string;
-  private _interval: number;
-  private _timerId: ReturnType<typeof setInterval> | null = null;
-  private _prev: Stats;
-  private _changeCount = 0;
-
-  constructor(path: string, interval: number) {
-    super();
-    this._path = path;
-    this._interval = interval;
-    this._prev = zeroedStat();
-  }
-
-  start(): void {
-    try { this._prev = statSync(this._path) as unknown as Stats; } catch {}
-    this._timerId = setInterval(() => {
-      let curr: Stats;
-      try { curr = statSync(this._path) as unknown as Stats; } catch { curr = zeroedStat(); }
-      const prev = this._prev;
-      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size || curr.ino !== prev.ino) {
-        this._prev = curr;
-        this.emit('change', curr, prev);
-      }
-    }, this._interval);
-  }
-
-  stop(): void {
-    if (this._timerId !== null) {
-      clearInterval(this._timerId);
-      this._timerId = null;
-    }
-    this.emit('stop');
-  }
-
-  addChangeListener(listener: (curr: Stats, prev: Stats) => void): void {
-    this._changeCount++;
-    this.on('change', listener);
-  }
-
-  removeChangeListener(listener: (curr: Stats, prev: Stats) => void): void {
-    this._changeCount--;
-    this.removeListener('change', listener);
-  }
-
-  removeAllChangeListeners(): void {
-    this._changeCount = 0;
-    this.removeAllListeners('change');
-  }
-
-  get changeListenerCount(): number {
-    return this._changeCount;
-  }
-}
-
-const statWatchers = new Map<string, StatWatcher>();
-
-export function watchFile(
-  filename: PathLike,
-  options: { persistent?: boolean; interval?: number } | ((curr: Stats, prev: Stats) => void),
-  listener?: (curr: Stats, prev: Stats) => void,
-): StatWatcher {
-  if (typeof options === 'function') {
-    listener = options;
-    options = {};
-  }
-  const interval = (options as { interval?: number }).interval ?? 5007;
-  const resolved = filename.toString();
-
-  let watcher = statWatchers.get(resolved);
-  if (!watcher) {
-    watcher = new StatWatcher(resolved, interval);
-    watcher.start();
-    statWatchers.set(resolved, watcher);
-  }
-  if (listener) watcher.addChangeListener(listener);
-  return watcher;
-}
-
-export function unwatchFile(
-  filename: PathLike,
-  listener?: (curr: Stats, prev: Stats) => void,
-): void {
-  const resolved = filename.toString();
-  const watcher = statWatchers.get(resolved);
-  if (!watcher) return;
-  if (listener) {
-    watcher.removeChangeListener(listener);
-  } else {
-    watcher.removeAllChangeListeners();
-  }
-  if (watcher.changeListenerCount === 0) {
-    watcher.stop();
-    statWatchers.delete(resolved);
-  }
-}

package/src/stat.spec.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect } from '@gjsify/unit';
-import { statSync, mkdtempSync, writeFileSync, rmSync, rmdirSync } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-export default async () => {
-	await describe('fs.statSync', async () => {
-
-		await it('Should return the file stat', async () => {
-			const dir = mkdtempSync(join(tmpdir(), 'fs-stat-'));
-			const filePath = join(dir, 'test.txt');
-			writeFileSync(filePath, 'stat test data');
-
-            const s = statSync(filePath);
-
-            expect(s.atime instanceof Date).toBeTruthy();
-            expect(s.atimeMs).toBeGreaterThan(0);
-            expect(s.birthtime instanceof Date).toBeTruthy();
-            expect(s.birthtimeMs).toBeGreaterThan(0);
-            expect(s.blksize).toBeGreaterThan(0);
-            expect(s.blocks).toBeGreaterThan(0);
-            expect(s.ctime instanceof Date).toBeTruthy();
-            expect(s.ctimeMs).toBeGreaterThan(0);
-            expect(s.dev).toBeGreaterThan(0);
-            expect(s.gid).toBeGreaterThan(-1);
-            expect(s.ino).toBeGreaterThan(0);
-            expect(s.mode).toBeGreaterThan(0);
-            expect(s.mtime instanceof Date).toBeTruthy();
-            expect(s.mtimeMs).toBeGreaterThan(0);
-            expect(s.nlink).toBeGreaterThan(0);
-            expect(s.rdev).toBeGreaterThan(-1);
-            expect(s.size).toBeGreaterThan(0);
-            expect(s.uid).toBeGreaterThan(-1);
-            expect(s.isBlockDevice()).toBeFalsy();
-            expect(s.isCharacterDevice()).toBeFalsy();
-            expect(s.isDirectory()).toBeFalsy();
-            expect(s.isFIFO()).toBeFalsy();
-            expect(s.isFile()).toBeTruthy();
-            expect(s.isSocket()).toBeFalsy();
-            expect(s.isSymbolicLink()).toBeFalsy();
-
-			rmSync(filePath);
-			rmdirSync(dir);
-		});
-	});
-
-	await describe('fs.stat (promise)', async () => {
-
-		await it('Should return the file stat', async () => {
-			const dir = mkdtempSync(join(tmpdir(), 'fs-pstat-'));
-			const filePath = join(dir, 'test.txt');
-			writeFileSync(filePath, 'stat test data');
-
-            const s = await stat(filePath);
-
-            expect(s.atime instanceof Date).toBeTruthy();
-            expect(s.atimeMs).toBeGreaterThan(0);
-            expect(s.birthtime instanceof Date).toBeTruthy();
-            expect(s.birthtimeMs).toBeGreaterThan(0);
-            expect(s.blksize).toBeGreaterThan(0);
-            expect(s.blocks).toBeGreaterThan(0);
-            expect(s.ctime instanceof Date).toBeTruthy();
-            expect(s.ctimeMs).toBeGreaterThan(0);
-            expect(s.dev).toBeGreaterThan(0);
-            expect(s.gid).toBeGreaterThan(-1);
-            expect(s.ino).toBeGreaterThan(0);
-            expect(s.mode).toBeGreaterThan(0);
-            expect(s.mtime instanceof Date).toBeTruthy();
-            expect(s.mtimeMs).toBeGreaterThan(0);
-            expect(s.nlink).toBeGreaterThan(0);
-            expect(s.rdev).toBeGreaterThan(-1);
-            expect(s.size).toBeGreaterThan(0);
-            expect(s.uid).toBeGreaterThan(-1);
-            expect(s.isBlockDevice()).toBeFalsy();
-            expect(s.isCharacterDevice()).toBeFalsy();
-            expect(s.isDirectory()).toBeFalsy();
-            expect(s.isFIFO()).toBeFalsy();
-            expect(s.isFile()).toBeTruthy();
-            expect(s.isSocket()).toBeFalsy();
-            expect(s.isSymbolicLink()).toBeFalsy();
-
-			rmSync(filePath);
-			rmdirSync(dir);
-		});
-	});
-}

package/src/statfs.spec.ts

@@ -1,67 +0,0 @@
-// Ported from refs/node-test/parallel/test-fs-statfs.js (behavior)
-// Original: MIT, Node.js contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import { statfsSync, statfs, promises } from 'node:fs';
-import { tmpdir } from 'node:os';
-
-const TMP = tmpdir();
-
-export default async () => {
-  await describe('fs.statfs / fs.promises.statfs', async () => {
-    await it('statfsSync returns object with expected shape', async () => {
-      const result = statfsSync(TMP);
-      expect(typeof result.type).toBe('number');
-      expect(typeof result.bsize).toBe('number');
-      expect(typeof result.blocks).toBe('number');
-      expect(typeof result.bfree).toBe('number');
-      expect(typeof result.bavail).toBe('number');
-      expect(typeof result.files).toBe('number');
-      expect(typeof result.ffree).toBe('number');
-    });
-
-    await it('statfsSync returns plausible values', async () => {
-      const result = statfsSync(TMP);
-      expect(result.bsize).toBe(4096);
-      expect(result.blocks).toBeGreaterThan(0);
-      expect(result.bfree).toBeGreaterThanOrEqual(0);
-      expect(result.bavail).toBeGreaterThanOrEqual(0);
-    });
-
-    await it('statfs callback form returns same shape', async () => {
-      const result = await new Promise<any>((resolve, reject) => {
-        statfs(TMP, (err, stats) => {
-          if (err) reject(err);
-          else resolve(stats);
-        });
-      });
-      expect(typeof result.type).toBe('number');
-      expect(typeof result.bsize).toBe('number');
-      expect(result.bsize).toBe(4096);
-      expect(result.blocks).toBeGreaterThan(0);
-    });
-
-    await it('promises.statfs returns same shape', async () => {
-      const result = await promises.statfs(TMP);
-      expect(typeof result.type).toBe('number');
-      expect(typeof result.bsize).toBe('number');
-      expect(result.bsize).toBe(4096);
-      expect(result.blocks).toBeGreaterThan(0);
-    });
-
-    await it('statfsSync with bigint:true returns bigint fields', async () => {
-      const result = statfsSync(TMP, { bigint: true });
-      expect(typeof result.type).toBe('bigint');
-      expect(typeof result.bsize).toBe('bigint');
-      expect(typeof result.blocks).toBe('bigint');
-      expect(typeof result.bfree).toBe('bigint');
-      expect(result.bsize).toBe(4096n);
-      expect(result.blocks > 0n).toBe(true);
-    });
-
-    await it('statfsSync throws on non-existent path', async () => {
-      expect(() => statfsSync('/nonexistent-gjsify-test-path-xyz')).toThrow();
-    });
-  });
-};

package/src/statfs.ts

@@ -1,92 +0,0 @@
-// Reference: Node.js lib/fs.js (fs.statfs / fs.promises.statfs)
-// Reimplemented for GJS using Gio.File.query_filesystem_info
-
-import Gio from '@girs/gio-2.0';
-import GLib from '@girs/glib-2.0';
-import { normalizePath } from './utils.js';
-
-import type { PathLike } from 'node:fs';
-
-const FS_INFO_ATTRS = [
-  'filesystem::size',
-  'filesystem::free',
-].join(',');
-
-// Block size used to derive block counts from byte counts.
-// Gio does not expose the real fs block size; 4096 is a safe default.
-const BSIZE = 4096;
-
-export interface StatFsResult {
-  type: number;
-  bsize: number;
-  blocks: number;
-  bfree: number;
-  bavail: number;
-  files: number;
-  ffree: number;
-}
-
-export interface BigIntStatFsResult {
-  type: bigint;
-  bsize: bigint;
-  blocks: bigint;
-  bfree: bigint;
-  bavail: bigint;
-  files: bigint;
-  ffree: bigint;
-}
-
-function buildStatFs(info: Gio.FileInfo): StatFsResult {
-  const totalBytes = Number(info.get_attribute_uint64('filesystem::size') ?? 0);
-  const freeBytes  = Number(info.get_attribute_uint64('filesystem::free') ?? 0);
-  const blocks = Math.floor(totalBytes / BSIZE);
-  const bfree  = Math.floor(freeBytes  / BSIZE);
-  return { type: 0, bsize: BSIZE, blocks, bfree, bavail: bfree, files: 0, ffree: 0 };
-}
-
-function buildBigIntStatFs(info: Gio.FileInfo): BigIntStatFsResult {
-  const totalBytes = BigInt(info.get_attribute_uint64('filesystem::size') ?? 0);
-  const freeBytes  = BigInt(info.get_attribute_uint64('filesystem::free') ?? 0);
-  const bsize = BigInt(BSIZE);
-  const blocks = totalBytes / bsize;
-  const bfree  = freeBytes  / bsize;
-  return { type: 0n, bsize, blocks, bfree, bavail: bfree, files: 0n, ffree: 0n };
-}
-
-export function statfsSync(path: PathLike, options?: { bigint?: false }): StatFsResult;
-export function statfsSync(path: PathLike, options: { bigint: true }): BigIntStatFsResult;
-export function statfsSync(path: PathLike, options?: { bigint?: boolean }): StatFsResult | BigIntStatFsResult {
-  const file = Gio.File.new_for_path(normalizePath(path));
-  const info = file.query_filesystem_info(FS_INFO_ATTRS, null);
-  return options?.bigint === true ? buildBigIntStatFs(info) : buildStatFs(info);
-}
-
-function queryFsInfoAsync(path: PathLike, useBigInt: boolean): Promise<StatFsResult | BigIntStatFsResult> {
-  return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(normalizePath(path));
-    file.query_filesystem_info_async(FS_INFO_ATTRS, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
-      try {
-        const info = file.query_filesystem_info_finish(res);
-        resolve(useBigInt ? buildBigIntStatFs(info) : buildStatFs(info));
-      } catch (err) {
-        reject(err);
-      }
-    });
-  });
-}
-
-export function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
-export function statfs(path: PathLike, options: { bigint?: false }, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
-export function statfs(path: PathLike, options: { bigint: true }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatFsResult) => void): void;
-export function statfs(path: PathLike, optionsOrCb: any, callback?: any): void {
-  if (typeof optionsOrCb === 'function') {
-    callback = optionsOrCb;
-    optionsOrCb = {};
-  }
-  const useBigInt = optionsOrCb?.bigint === true;
-  queryFsInfoAsync(path, useBigInt).then(result => callback(null, result), err => callback(err, null));
-}
-
-export async function statfsAsync(path: PathLike, options?: { bigint?: boolean }): Promise<StatFsResult | BigIntStatFsResult> {
-  return queryFsInfoAsync(path, options?.bigint === true);
-}

package/src/stats.ts

@@ -1,207 +0,0 @@
-// Reference: Node.js lib/internal/fs/utils.js (Stats class)
-// Reimplemented for GJS using Gio.FileInfo attributes
-
-import Gio from '@girs/gio-2.0';
-import { Dirent } from './dirent.js';
-import { basename } from 'node:path';
-
-import type { Stats as NodeStats, BigIntStats as NodeBigIntStats, PathLike } from 'node:fs';
-
-// Query all attributes needed for a full Node.js Stats object
-export const STAT_ATTRIBUTES = 'standard::*,time::*,unix::*';
-
-function populateFromInfo(info: Gio.FileInfo) {
-    const atimeSec = info.get_attribute_uint64('time::access');
-    const atimeUsec = info.get_attribute_uint32('time::access-usec') || 0;
-    const mtimeSec = info.get_attribute_uint64('time::modified');
-    const mtimeUsec = info.get_attribute_uint32('time::modified-usec') || 0;
-    const ctimeSec = info.get_attribute_uint64('time::changed');
-    const ctimeUsec = info.get_attribute_uint32('time::changed-usec') || 0;
-    const createdSec = info.get_attribute_uint64('time::created');
-    const createdUsec = info.get_attribute_uint32('time::created-usec') || 0;
-
-    const atimeMs = atimeSec * 1000 + atimeUsec / 1000;
-    const mtimeMs = mtimeSec * 1000 + mtimeUsec / 1000;
-    const ctimeMs = ctimeSec ? ctimeSec * 1000 + ctimeUsec / 1000 : mtimeMs;
-    const birthtimeMs = createdSec ? createdSec * 1000 + createdUsec / 1000 : ctimeMs;
-
-    return {
-        dev: info.get_attribute_uint32('unix::device') || 0,
-        ino: Number(info.get_attribute_uint64('unix::inode') || 0),
-        mode: info.get_attribute_uint32('unix::mode') || 0,
-        nlink: info.get_attribute_uint32('unix::nlink') || 0,
-        uid: info.get_attribute_uint32('unix::uid') || 0,
-        gid: info.get_attribute_uint32('unix::gid') || 0,
-        rdev: info.get_attribute_uint32('unix::rdev') || 0,
-        size: Number(info.get_size() || 0),
-        blksize: info.get_attribute_uint32('unix::block-size') || 4096,
-        blocks: Number(info.get_attribute_uint64('unix::blocks') || 0),
-        atimeMs,
-        mtimeMs,
-        ctimeMs,
-        birthtimeMs,
-        atime: new Date(atimeMs),
-        mtime: new Date(mtimeMs),
-        ctime: new Date(ctimeMs),
-        birthtime: new Date(birthtimeMs),
-    };
-}
-
-/**
- * A `fs.Stats` object provides information about a file.
- * @since v0.1.21
- */
-export class Stats extends Dirent implements NodeStats {
-    dev: number;
-    ino: number;
-    mode: number;
-    nlink: number;
-    uid: number;
-    gid: number;
-    rdev: number;
-    size: number;
-    blksize: number;
-    blocks: number;
-    atimeMs: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    birthtimeMs: number;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-
-    protected _info: Gio.FileInfo;
-
-    /**
-     * Create Stats from a pre-queried FileInfo, or from a path.
-     * @param infoOrPath - A Gio.FileInfo or a file path
-     * @param pathOrFilename - The file path (when first arg is FileInfo) or filename
-     * @param filename - Optional filename (when first arg is FileInfo)
-     */
-    constructor(info: Gio.FileInfo, path: PathLike, filename?: string);
-    constructor(path: PathLike, filename?: string);
-    constructor(
-        infoOrPath: Gio.FileInfo | PathLike,
-        pathOrFilename?: PathLike | string,
-        filename?: string
-    ) {
-        let info: Gio.FileInfo;
-        let pathStr: string;
-
-        if (infoOrPath instanceof Gio.FileInfo) {
-            info = infoOrPath;
-            pathStr = (pathOrFilename as PathLike).toString();
-            if (!filename) filename = basename(pathStr);
-        } else {
-            pathStr = infoOrPath.toString();
-            if (typeof pathOrFilename === 'string') filename = pathOrFilename;
-            if (!filename) filename = basename(pathStr);
-            const file = Gio.File.new_for_path(pathStr);
-            info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-        }
-
-        super(pathStr, filename, info.get_file_type());
-        this._info = info;
-
-        const data = populateFromInfo(info);
-        this.dev = data.dev;
-        this.ino = data.ino;
-        this.mode = data.mode;
-        this.nlink = data.nlink;
-        this.uid = data.uid;
-        this.gid = data.gid;
-        this.rdev = data.rdev;
-        this.size = data.size;
-        this.blksize = data.blksize;
-        this.blocks = data.blocks;
-        this.atimeMs = data.atimeMs;
-        this.mtimeMs = data.mtimeMs;
-        this.ctimeMs = data.ctimeMs;
-        this.birthtimeMs = data.birthtimeMs;
-        this.atime = data.atime;
-        this.mtime = data.mtime;
-        this.ctime = data.ctime;
-        this.birthtime = data.birthtime;
-    }
-}
-
-/**
- * BigIntStats — same as Stats but with bigint fields and nanosecond precision.
- */
-export class BigIntStats extends Dirent implements NodeBigIntStats {
-    dev: bigint;
-    ino: bigint;
-    mode: bigint;
-    nlink: bigint;
-    uid: bigint;
-    gid: bigint;
-    rdev: bigint;
-    size: bigint;
-    blksize: bigint;
-    blocks: bigint;
-    atimeMs: bigint;
-    mtimeMs: bigint;
-    ctimeMs: bigint;
-    birthtimeMs: bigint;
-    atimeNs: bigint;
-    mtimeNs: bigint;
-    ctimeNs: bigint;
-    birthtimeNs: bigint;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-
-    protected _info: Gio.FileInfo;
-
-    constructor(info: Gio.FileInfo, path: PathLike, filename?: string);
-    constructor(path: PathLike, filename?: string);
-    constructor(
-        infoOrPath: Gio.FileInfo | PathLike,
-        pathOrFilename?: PathLike | string,
-        filename?: string
-    ) {
-        let info: Gio.FileInfo;
-        let pathStr: string;
-
-        if (infoOrPath instanceof Gio.FileInfo) {
-            info = infoOrPath;
-            pathStr = (pathOrFilename as PathLike).toString();
-            if (!filename) filename = basename(pathStr);
-        } else {
-            pathStr = infoOrPath.toString();
-            if (typeof pathOrFilename === 'string') filename = pathOrFilename;
-            if (!filename) filename = basename(pathStr);
-            const file = Gio.File.new_for_path(pathStr);
-            info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-        }
-
-        super(pathStr, filename, info.get_file_type());
-        this._info = info;
-
-        const data = populateFromInfo(info);
-        this.dev = BigInt(data.dev);
-        this.ino = BigInt(data.ino);
-        this.mode = BigInt(data.mode);
-        this.nlink = BigInt(data.nlink);
-        this.uid = BigInt(data.uid);
-        this.gid = BigInt(data.gid);
-        this.rdev = BigInt(data.rdev);
-        this.size = BigInt(data.size);
-        this.blksize = BigInt(data.blksize);
-        this.blocks = BigInt(data.blocks);
-        this.atimeMs = BigInt(Math.trunc(data.atimeMs));
-        this.mtimeMs = BigInt(Math.trunc(data.mtimeMs));
-        this.ctimeMs = BigInt(Math.trunc(data.ctimeMs));
-        this.birthtimeMs = BigInt(Math.trunc(data.birthtimeMs));
-        this.atimeNs = this.atimeMs * 1000000n;
-        this.mtimeNs = this.mtimeMs * 1000000n;
-        this.ctimeNs = this.ctimeMs * 1000000n;
-        this.birthtimeNs = this.birthtimeMs * 1000000n;
-        this.atime = data.atime;
-        this.mtime = data.mtime;
-        this.ctime = data.ctime;
-        this.birthtime = data.birthtime;
-    }
-}