@gjsify/fs 0.0.4 → 0.1.1

package/src/file-handle.spec.ts

@@ -1,34 +1,115 @@
+// Ported from refs/node-test/parallel/test-fs-promises-file-handle-*.js
+// Original: MIT license, Node.js contributors
 import { describe, it, expect } from '@gjsify/unit';
-import { promises } from 'fs';
-import { Buffer } from 'buffer';
+import { promises, mkdtempSync, rmdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { Buffer } from 'node:buffer';
 
 export default async () => {
-	await describe('FileHandle', async () => {
-		await it(`should open a file for writing`, async () => {
-			const path = './test/openP.txt';
-			const fileHandle = await promises.open(path, 'w+', 0o666);
+  await describe('FileHandle', async () => {
+    await it('should open a file for writing and return correct bytesWritten', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-'));
+      const path = join(dir, 'write.txt');
+      const fh = await promises.open(path, 'w+', 0o666);
+      const buf = Buffer.from('Hello World', 'utf8');
+      const res = await fh.write(buf, 0, buf.length, 0);
+      expect(res.bytesWritten).toBe(buf.length);
+      expect(res.buffer).toBe(buf);
+      await fh.close();
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-			console.log('FileHandle: file open');
+    await it('should read back written content via read()', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-read-'));
+      const path = join(dir, 'rw.txt');
+      const fh = await promises.open(path, 'w+');
+      const written = Buffer.from('Read back test');
+      await fh.write(written, 0, written.length, 0);
 
-			let buffWrite = Buffer.from('Hello World', 'utf8'),
-			buffStart = 0,
-			buffLength = buffWrite.length,
-			filePos = 0;
-			const res = await fileHandle.write(buffWrite, buffStart, buffLength, filePos);
-			console.log('FileHandle: file written');
+      const readBuf = Buffer.alloc(written.length);
+      const { bytesRead } = await fh.read(readBuf, 0, written.length, 0);
+      expect(bytesRead).toBe(written.length);
+      expect(readBuf.toString()).toBe('Read back test');
 
-			// console.log('written', res.bytesWritten);
+      await fh.close();
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-			expect(res.bytesWritten).toBe(buffWrite.length);
+    await it('should read entire file via readFile()', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-rf-'));
+      const path = join(dir, 'rf.txt');
+      await promises.writeFile(path, 'FileHandle readFile content');
+      const fh = await promises.open(path, 'r');
+      const content = await fh.readFile({ encoding: 'utf8' });
+      expect(content).toBe('FileHandle readFile content');
+      await fh.close();
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-			expect(res.buffer).toBe(buffWrite);
+    await it('should stat the opened file', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-stat-'));
+      const path = join(dir, 'stat.txt');
+      await promises.writeFile(path, 'stat content');
+      const fh = await promises.open(path, 'r');
+      const s = await fh.stat();
+      expect(s.isFile()).toBe(true);
+      expect(s.size).toBeGreaterThan(0);
+      await fh.close();
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-			await fileHandle.close();
-			console.log('FileHandle: file closed');
+    await it('should truncate the file via truncate()', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-trunc-'));
+      const path = join(dir, 'trunc.txt');
+      await promises.writeFile(path, 'Hello World Truncate');
+      const fh = await promises.open(path, 'r+');
+      await fh.truncate(5);
+      await fh.close();
+      const content = await promises.readFile(path, { encoding: 'utf8' });
+      expect(content).toBe('Hello');
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-			await promises.rm(path);
-			console.log('FileHandle: file removed');	
+    await it('should append content via appendFile()', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-app-'));
+      const path = join(dir, 'append.txt');
+      await promises.writeFile(path, 'start');
+      const fh = await promises.open(path, 'a');
+      await fh.appendFile(' appended');
+      await fh.close();
+      const content = await promises.readFile(path, { encoding: 'utf8' });
+      expect(content).toBe('start appended');
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
 
-		});
-	});
-}
+    await it('should throw when opening a non-existent file for reading', async () => {
+      let threw = false;
+      try {
+        await promises.open('/nonexistent/path/abc123.txt', 'r');
+      } catch (e: unknown) {
+        threw = true;
+        expect((e as NodeJS.ErrnoException).code).toBe('ENOENT');
+      }
+      expect(threw).toBe(true);
+    });
+
+    await it('should writeFile via FileHandle', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-wf-'));
+      const path = join(dir, 'wf.txt');
+      const fh = await promises.open(path, 'w');
+      await fh.writeFile('written via FileHandle.writeFile');
+      await fh.close();
+      const content = await promises.readFile(path, { encoding: 'utf8' });
+      expect(content).toBe('written via FileHandle.writeFile');
+      await promises.rm(path);
+      rmdirSync(dir);
+    });
+  });
+};

package/src/file-handle.ts

@@ -1,20 +1,24 @@
+// Reference: Node.js lib/internal/fs/promises.js (FileHandle)
+// Reimplemented for GJS using Gio.File
+
 import { warnNotImplemented, notImplemented } from '@gjsify/utils';
 import { ReadStream } from "./read-stream.js";
 import { WriteStream } from "./write-stream.js";
 import { Stats } from "./stats.js";
 import { getEncodingFromOptions, encodeUint8Array } from './encoding.js';
 import GLib from '@girs/glib-2.0';
-import { ReadableStream } from "stream/web";
-import { Buffer } from "buffer";
+import Gio from '@girs/gio-2.0';
+import { ReadableStream } from "node:stream/web";
+import { Buffer } from "node:buffer";
 
-import type { Abortable } from 'events';
+import type { Abortable } from 'node:events';
 import type {
     FlagAndOpenMode,
     FileReadResult,
     FileReadOptions,
     OpenFlags,
 } from './types/index.js';
-import type { FileHandle as IFileHandle, CreateReadStreamOptions, CreateWriteStreamOptions } from 'fs/promises';
+import type { FileHandle as IFileHandle, CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
 import type {
     ObjectEncodingOptions,
     Mode,
@@ -25,9 +29,49 @@ import type {
     WriteVResult,
     ReadVResult,
     ReadPosition,
-} from 'fs';
+} from 'node:fs';
 import type { Interface as ReadlineInterface } from 'node:readline';
 
+/**
+ * GLib.FileError enum numeric values → Node.js error code strings.
+ * GLib.IOChannel.new_file() throws GLib.FileError (different from Gio.IOErrorEnum).
+ */
+const GLIB_FILE_ERROR_TO_NODE: Record<number, string> = {
+    0:  'EEXIST',
+    1:  'EISDIR',
+    2:  'EACCES',
+    3:  'ENAMETOOLONG',
+    4:  'ENOENT',
+    5:  'ENOTDIR',
+    6:  'ENXIO',
+    7:  'ENODEV',
+    8:  'EROFS',
+    11: 'ELOOP',
+    12: 'ENOSPC',
+    13: 'ENOMEM',
+    14: 'EMFILE',
+    15: 'ENFILE',
+    16: 'EBADF',
+    17: 'EINVAL',
+    18: 'EPIPE',
+    21: 'EIO',
+    22: 'EPERM',
+    24: 'EIO',
+};
+
+function mapOpenError(err: unknown, path: string): NodeJS.ErrnoException {
+    const gErr = err as { code?: number; message?: string } | null | undefined;
+    const msg = gErr?.message ?? '';
+    // GLib.IOChannel.new_file() always throws GLib.FileError (not Gio.IOErrorEnum).
+    // GLIB_FILE_ERROR_TO_NODE maps GLib.FileError numeric values to Node.js codes.
+    const code = GLIB_FILE_ERROR_TO_NODE[gErr?.code ?? -1] ?? 'EIO';
+    const error = new Error(`${code}: ${msg || 'unknown error'}, open '${path}'`) as NodeJS.ErrnoException;
+    error.code = code;
+    error.syscall = 'open';
+    error.path = path;
+    return error;
+}
+
 export class FileHandle implements IFileHandle {
 
     /** Not part of the default implementation, used internal by gjsify */
@@ -43,7 +87,13 @@ export class FileHandle implements IFileHandle {
     }) {
         this.options.flags ||= "r";
         this.options.mode ||= 0o666;
-        this._file = GLib.IOChannel.new_file(options.path.toString(), this.options.flags);
+        try {
+            this._file = GLib.IOChannel.new_file(options.path.toString(), this.options.flags);
+        } catch (err: unknown) {
+            throw mapOpenError(err, options.path.toString());
+        }
+        // Binary mode: prevent GLib from doing any character set conversion.
+        this._file.set_encoding(null as unknown as string);
         this.fd = this._file.unix_get_fd();
 
         FileHandle.instances[this.fd] = this;
@@ -128,7 +178,7 @@ export class FileHandle implements IFileHandle {
      * destroyed.  Set the `emitClose` option to `false` to change this behavior.
      *
      * ```js
-     * import { open } from 'fs/promises';
+     * import { open } from 'node:fs/promises';
      *
      * const fd = await open('/dev/input/event0');
      * // Create a stream from some character device.
@@ -154,7 +204,7 @@ export class FileHandle implements IFileHandle {
      * An example to read the last 10 bytes of a file which is 100 bytes long:
      *
      * ```js
-     * import { open } from 'fs/promises';
+     * import { open } from 'node:fs/promises';
      *
      * const fd = await open('sample.txt');
      * fd.createReadStream({ start: 90, end: 99 });
@@ -220,13 +270,13 @@ export class FileHandle implements IFileHandle {
     async read<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number | null, length?: number | null, position?: ReadPosition | null): Promise<FileReadResult<T>>
     async read<T extends NodeJS.ArrayBufferView = Buffer>(options?: FileReadOptions<T>): Promise<FileReadResult<T>>
 
-    async read<T extends NodeJS.ArrayBufferView = Buffer>(args: any[]): Promise<FileReadResult<T>> {
+    async read<T extends NodeJS.ArrayBufferView = Buffer>(...args: any[]): Promise<FileReadResult<T>> {
         let buffer: T | undefined;
         let offset: number | null | undefined;
         let length: number | null | undefined;
-        let position:  number | null | undefined;
+        let position: number | null | undefined;
 
-        if (typeof args[0] === 'object') {
+        if (typeof args[0] === 'object' && !(args[0] instanceof Uint8Array) && !(args[0] instanceof Buffer)) {
             const options: FileReadOptions<T> = args[0];
             buffer = options.buffer;
             offset = options.offset;
@@ -239,31 +289,27 @@ export class FileHandle implements IFileHandle {
             position = args[3];
         }
 
-        if(offset) {
-            const status = this._file.seek_position(offset, GLib.SeekType.CUR);
-            if(status === GLib.IOStatus.ERROR) {
-                throw new Error("Error on set offset!")
-            }
-        }
-        if(length) this._file.set_buffer_size(length);
-        if(position) {
-            const status = this._file.seek_position(position, GLib.SeekType.SET);
-            if(status === GLib.IOStatus.ERROR) {
-                throw new Error("Error on set position!")
-            }
-        }
-
-        const [status, buf, bytesRead] = this._file.read_chars();
-        if(status === GLib.IOStatus.ERROR) {
-            throw new Error("Error on read!")
+        const bufView = buffer as unknown as Uint8Array;
+        const bufOffset = offset ?? 0;
+        const readLength = length ?? bufView?.byteLength ?? 65536;
+
+        // Use Gio.File.load_contents for reliable position-based reads.
+        // GLib.IOChannel.read_chars() is not introspectable in GJS (caller-allocated buffer),
+        // and read_to_end() has stdio-buffer visibility issues after mixed write/read.
+        const gFile = Gio.File.new_for_path(this.options.path.toString());
+        const [, fileContents] = gFile.load_contents(null);
+        const fileData = fileContents as Uint8Array;
+        const startPos = (position as number | null) ?? 0;
+        const readData = fileData.slice(startPos, startPos + readLength);
+        const bytesRead = readData.length;
+        if (bufView && bytesRead > 0) {
+            bufView.set(readData, bufOffset);
         }
 
-        buffer = buf as T;
-
         return {
             bytesRead,
-            buffer,
-        }
+            buffer: buffer as T,
+        };
     }
     /**
      * Returns a `ReadableStream` that may be used to read the files data.
@@ -272,7 +318,7 @@ export class FileHandle implements IFileHandle {
      * or closing.
      *
      * ```js
-     * import { open } from 'fs/promises';
+     * import { open } from 'node:fs/promises';
      *
      * const file = await open('./some/file/to/read');
      *
@@ -309,7 +355,7 @@ export class FileHandle implements IFileHandle {
             encoding?: null | undefined;
             flag?: OpenMode | undefined;
         } | null
-    ): Promise<Buffer>
+    ): Promise<Buffer<ArrayBuffer>>
     /**
      * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for reading.
@@ -337,7 +383,7 @@ export class FileHandle implements IFileHandle {
               })
             | BufferEncoding
             | null
-    ): Promise<string | Buffer> {
+    ): Promise<string | Buffer<ArrayBuffer>> {
         const encoding = getEncodingFromOptions(options, 'buffer');
         if (encoding) this._file.set_encoding(encoding);
 
@@ -397,7 +443,7 @@ export class FileHandle implements IFileHandle {
      * The following example retains only the first four bytes of the file:
      *
      * ```js
-     * import { open } from 'fs/promises';
+     * import { open } from 'node:fs/promises';
      *
      * let filehandle = null;
      * try {
@@ -416,8 +462,14 @@ export class FileHandle implements IFileHandle {
      * @param [len=0]
      * @return Fulfills with `undefined` upon success.
      */
-    async truncate(len?: number): Promise<void> {
-        warnNotImplemented('fs.FileHandle.truncate');
+    async truncate(len: number = 0): Promise<void> {
+        const effectiveLen = Math.max(0, len);
+        this._file.flush();
+        const gFile = Gio.File.new_for_path(this.options.path.toString());
+        const [, currentContent] = gFile.load_contents(null);
+        const newContent = new Uint8Array(effectiveLen);
+        newContent.set(currentContent.slice(0, Math.min(effectiveLen, currentContent.length)));
+        gFile.replace_contents(newContent, null, false, Gio.FileCreateFlags.NONE, null);
     }
     /**
      * Change the file system timestamps of the object referenced by the `FileHandle` then resolves the promise with no arguments upon success.
@@ -445,7 +497,19 @@ export class FileHandle implements IFileHandle {
      * @since v10.0.0
      */
     async writeFile(data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode & Abortable) | BufferEncoding | null): Promise<void> {
-        warnNotImplemented('fs.FileHandle.writeFile');
+        const encoding = getEncodingFromOptions(options);
+        let buf: Uint8Array;
+        if (typeof data === 'string') {
+            buf = Buffer.from(data, (encoding as BufferEncoding) || 'utf8');
+        } else {
+            buf = data;
+        }
+        this._file.seek_position(0, GLib.SeekType.SET);
+        const [status] = this._file.write_chars(buf, buf.length);
+        if (status === GLib.IOStatus.ERROR) {
+            throw new Error("Error writing to file!");
+        }
+        this._file.flush();
     }
     /**
      * Write `buffer` to the file.
@@ -474,6 +538,13 @@ export class FileHandle implements IFileHandle {
         bytesWritten: number;
         buffer: TBuffer;
     }>;
+    async write<TBuffer extends Uint8Array>(
+        buffer: TBuffer,
+        options?: { offset?: number; length?: number; position?: number },
+    ): Promise<{
+        bytesWritten: number;
+        buffer: TBuffer;
+    }>;
     async write(
         data: string,
         position?: number | null,
@@ -504,45 +575,38 @@ export class FileHandle implements IFileHandle {
         }
 
         encoding = getEncodingFromOptions(encoding, typeof data === 'string' ? 'utf8' : null);
-        if (encoding) {
-            console.log("set_encoding", encoding, this._file.get_encoding(), typeof data);
-            
-            this._file.set_encoding(encoding === 'buffer' ? null : encoding);
-        }
 
-        if(offset) {
-            const status = this._file.seek_position(offset, GLib.SeekType.CUR);
-            if(status === GLib.IOStatus.ERROR) {
-                throw new Error("Error on set offset!")
-            }
+        // Convert data to Uint8Array bytes
+        let writeBuf: Uint8Array;
+        if (typeof data === 'string') {
+            writeBuf = new TextEncoder().encode(data);
+        } else {
+            writeBuf = data as unknown as Uint8Array;
         }
-        if(length) this._file.set_buffer_size(length);
-
-        if(position) {
-            const status = this._file.seek_position(position, GLib.SeekType.SET);
-            if(status === GLib.IOStatus.ERROR) {
-                throw new Error("Error on set position!")
-            }
+        const bufOffset = offset ?? 0;
+        const writeLength = length ?? (writeBuf.byteLength - bufOffset);
+        const writeSlice = writeBuf.slice(bufOffset, bufOffset + writeLength);
+        const writePos = position ?? 0;
+
+        // Use Gio.File for reliable position-based writes.
+        // GLib.IOChannel write_chars + flush does not guarantee data is visible to
+        // subsequent Gio.File or g_file_get_contents readers (stdio-buffer flushing issue).
+        const gFile = Gio.File.new_for_path(this.options.path.toString());
+        let existingData: Uint8Array;
+        try {
+            const [, existing] = gFile.load_contents(null);
+            existingData = existing as Uint8Array;
+        } catch {
+            existingData = new Uint8Array(0);
         }
+        const newSize = Math.max(existingData.length, writePos + writeSlice.length);
+        const newContent = new Uint8Array(newSize);
+        newContent.set(existingData);
+        newContent.set(writeSlice, writePos);
+        gFile.replace_contents(newContent, null, false, Gio.FileCreateFlags.NONE, null);
 
-        let bytesWritten = 0;
-        let status: GLib.IOStatus;
-
-        if(typeof data === 'string') {
-            status = this._file.write_unichar(data);
-            bytesWritten = data.length;
-        } else {
-            const [_status, _bytesWritten] = this._file.write_chars(data as Uint8Array, length);
-            bytesWritten = _bytesWritten;
-            status = _status;
-        }        
-
-        if(status === GLib.IOStatus.ERROR) {
-            throw new Error("Error on write to file!")
-        }
-        
         return {
-            bytesWritten,
+            bytesWritten: writeSlice.length,
             buffer: data
         }
     }
@@ -563,11 +627,11 @@ export class FileHandle implements IFileHandle {
      * @param position The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current
      * position.
      */
-    async writev(buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<WriteVResult> {
+    async writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<WriteVResult<TBuffers>> {
         warnNotImplemented('fs.FileHandle.writev');
         return {
             bytesWritten: 0,
-            buffers: [],
+            buffers: buffers as unknown as TBuffers,
         }
     }
     /**
@@ -576,11 +640,11 @@ export class FileHandle implements IFileHandle {
      * @param position The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position.
      * @return Fulfills upon success an object containing two properties:
      */
-    async readv(buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<ReadVResult> {
+    async readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<ReadVResult<TBuffers>> {
         warnNotImplemented('fs.FileHandle.readv');
         return {
             bytesRead: 0,
-            buffers: [],
+            buffers: buffers as unknown as TBuffers,
         }
     }
     /**
@@ -588,7 +652,7 @@ export class FileHandle implements IFileHandle {
      * complete.
      *
      * ```js
-     * import { open } from 'fs/promises';
+     * import { open } from 'node:fs/promises';
      *
      * let filehandle;
      * try {
@@ -601,6 +665,10 @@ export class FileHandle implements IFileHandle {
      * @return Fulfills with `undefined` upon success.
      */
     async close(): Promise<void> {
-        this._file.close();
+        this._file.shutdown(true);
+    }
+
+    async [Symbol.asyncDispose](): Promise<void> {
+        await this.close();
     }
 }

package/src/fs-watcher.ts

@@ -1,8 +1,12 @@
+// Reference: Node.js lib/internal/fs/watchers.js
+// Reimplemented for GJS using Gio.FileMonitor
+
+import GLib from '@girs/glib-2.0';
 import Gio from '@girs/gio-2.0';
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 const privates = new WeakMap;
 
-import type { FSWatcher as IFSWatcher } from 'fs';
+import type { FSWatcher as IFSWatcher } from 'node:fs';
 
 export class FSWatcher extends EventEmitter implements IFSWatcher {
 
@@ -11,29 +15,72 @@ export class FSWatcher extends EventEmitter implements IFSWatcher {
     if (!options || typeof options !== 'object')
       options = {persistent: true};
 
+    const persistent = options.persistent !== false;
     const cancellable = Gio.Cancellable.new();
     const file = Gio.File.new_for_path(filename);
     const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
     watcher.connect('changed', changed.bind(this));
 
+    // When persistent is true, acquire a reference on the default GLib main context
+    // so the main loop stays alive while this watcher is active.
+    // This mirrors Node.js behavior where persistent watchers keep the event loop alive.
+    let sourceId: number | null = null;
+    if (persistent) {
+      // Add a never-firing timeout source to keep the mainloop alive.
+      // This is a lightweight way to hold a ref on the main context.
+      sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+    }
+
     privates.set(this, {
-      persistent: options.persistent,
+      persistent,
       cancellable,
+      sourceId,
       // even if never used later on, the monitor needs to be
       // attached to this instance or GJS reference counter
       // will ignore it and no watch will ever happen
       watcher
     });
     if (listener) this.on('change', listener);
-    // TODO: if (options.persistent) mainloop.wait();
   }
 
   close() {
-    const {cancellable, persistent} = privates.get(this);
-    if (!cancellable.is_cancelled()) {
-      cancellable.cancel();
-      // TODO: if (persistent) mainloop.go();
+    const priv = privates.get(this);
+    if (!priv.cancellable.is_cancelled()) {
+      priv.cancellable.cancel();
+      if (priv.sourceId !== null) {
+        GLib.source_remove(priv.sourceId);
+        priv.sourceId = null;
+      }
+    }
+  }
+
+  /**
+   * When called, requests that the Node.js event loop not exit so long as the
+   * FSWatcher is active. Calling ref() multiple times has no effect.
+   */
+  ref(): this {
+    const priv = privates.get(this);
+    if (!priv.persistent && !priv.cancellable.is_cancelled()) {
+      priv.persistent = true;
+      priv.sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+    }
+    return this;
+  }
+
+  /**
+   * When called, the active FSWatcher will not require the Node.js event loop
+   * to remain active. Calling unref() multiple times has no effect.
+   */
+  unref(): this {
+    const priv = privates.get(this);
+    if (priv.persistent) {
+      priv.persistent = false;
+      if (priv.sourceId !== null) {
+        GLib.source_remove(priv.sourceId);
+        priv.sourceId = null;
+      }
     }
+    return this;
   }
 
 };