{ "source": "doc/api/fs.markdown", "modules": [ { "textRaw": "FS", "name": "fs", "desc": "
Node-style filesystem module for luvit\n\n
\nlocal fs = require('fs')
\n\n
Uses lib uv under the hood. A lot of these fuctions are very similiar to linux system calls and can be understood by reading the man pages of linux command line commnds with the same names.\n\n
\nThe asynchronous form always takes a completion callback as its last argument. The arguments passed to the completion callback depend on the method, but the first argument is always reserved for an exception. If the operation was completed successfully, then the first argument will be null or undefined.\n\n
\nSync versions of functions usually return true if they succeed or an error if they dont and no data is expected.\nOtherwise they return the data on success. \n\n
\n", "methods": [ { "textRaw": "fs.close(fileDescriptor, callback)", "type": "method", "name": "close", "desc": "Close a file. No arguments other than a possible exception are given to the completion callback.\n\n
\n", "signatures": [ { "params": [ { "name": "fileDescriptor" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.closeSync(fd)", "type": "method", "name": "closeSync", "desc": "Synchronous file close\n\n
\n", "signatures": [ { "params": [ { "name": "fd" } ] } ] }, { "textRaw": "fs.open(path[, flags, mode], callback)", "type": "method", "name": "open", "desc": "Asynchronous file open. flags
can be:\n\n
'r'
- Open file for reading.\nAn exception occurs if the file does not exist.
'r+'
- Open file for reading and writing.\nAn exception occurs if the file does not exist.
'rs'
- Open file for reading in synchronous mode. Instructs the operating\nsystem to bypass the local file system cache.
This is primarily useful for opening files on NFS mounts as it allows you to\nskip the potentially stale local cache. It has a very real impact on I/O\nperformance so don't use this flag unless you need it.
\nNote that this doesn't turn fs.open()
into a synchronous blocking call.\nIf that's what you want then you should be using fs.openSync()
'rs+'
- Open file for reading and writing, telling the OS to open it\nsynchronously. See notes for 'rs'
about using this with caution.
'w'
- Open file for writing.\nThe file is created (if it does not exist) or truncated (if it exists).
'wx'
- Like 'w'
but fails if path
exists.
'w+'
- Open file for reading and writing.\nThe file is created (if it does not exist) or truncated (if it exists).
'wx+'
- Like 'w+'
but fails if path
exists.
'a'
- Open file for appending.\nThe file is created if it does not exist.
'ax'
- Like 'a'
but fails if path
exists.
'a+'
- Open file for reading and appending.\nThe file is created if it does not exist.
'ax+'
- Like 'a+'
but fails if path
exists.
mode
sets the file mode (permission and sticky bits), but only if the file was\ncreated. It defaults to 0666
, readable and writeable.\n\n
The callback gets two arguments (err, fd)
.\n\n
The exclusive flag 'x'
(O_EXCL
flag in open(2)) ensures that path
is newly\ncreated. On POSIX systems, path
is considered to exist even if it is a symlink\nto a non-existent file. The exclusive flag may or may not work with network file\nsystems.\n\n
On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "flags" }, { "name": "mode", "optional": true }, { "name": "callback" } ] } ] }, { "textRaw": "fs.openSync(path, flags[, mode])", "type": "method", "name": "openSync", "desc": "Synchronous version of fs.open()
. Returns an integer representing the file\ndescriptor.\n\n
Read data from the file specified by fd
.\n\n
offset
is the offset in the buffer to start reading at.\n\n
size
is an integer specifying the number of bytes to read. Defaults to 4096.\n\n
The callback is given the three arguments, (err, bytesRead, buffer)
.\n\n
Synchronous file read\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "size" }, { "name": "offset", "optional": true } ] } ] }, { "textRaw": "fs.unlink(path, callback)", "type": "method", "name": "unlink", "desc": "Asynchronous delete file. No arguments other than a possible exception are given\nto the completion callback.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.unlinkSync(path)", "type": "method", "name": "unlinkSync", "desc": "Synchronous unlink. Returns undefined
.\n\n
Writes a data in string data
to a file fd
calling a function callback
with \nerr or nil when done. offset
is the offset in the buffer to start writing at.\n\n
Synchronous version of the above write function\n\n
\n", "signatures": [ { "params": [ { "name": "fs" }, { "name": "offset" }, { "name": "] data" } ] } ] }, { "textRaw": "fs.mkdir(path[, mode], callback)", "type": "method", "name": "mkdir", "desc": "Creates a directory with name path
and returns a callback with err or nil.\nMode is the permissions set on the directory, defaults to octal 0777\n\n
Sync version of mkdir. \n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "mode" } ] } ] }, { "textRaw": "fs.mkdtemp(template, callback)", "type": "method", "name": "mkdtemp", "desc": "Makes a directory from a template object\n\n
\n", "signatures": [ { "params": [ { "name": "template" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.mkdtempSync(template)", "type": "method", "name": "mkdtempSync", "desc": "Sync version of mkdtemp\n\n
\n", "signatures": [ { "params": [ { "name": "template" } ] } ] }, { "textRaw": "fs.rmdir(path, callback)", "type": "method", "name": "rmdir", "desc": "It's like rm -rf
but in luvit!\n\n
Sync version of rmdir\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.readdir(path, callback)", "type": "method", "name": "readdir", "desc": "Reads a directory, returning files and folders in it in the callback. First arg of cb is nil or err\nThis function is not recursive. Use the luvit-walk package for a recursive variant\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.readdirSync(path)", "type": "method", "name": "readdirSync", "desc": "Sync version of readdir\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.scandir(path, callback)", "type": "method", "name": "scandir", "desc": "Similiar to readdir but the callback here gets a function instead of a table containing\nthe list of files. Every time this function is invoked it returns the name of the file/dir\nand the type of the file/dir (either file or directory).\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.scandirSync(path)", "type": "method", "name": "scandirSync", "desc": "Simply returns the iterator function retrieved in the async scandirs callback\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.exists(path, callback)", "type": "method", "name": "exists", "desc": "Checks if a file exists. Callback is called with true or false and an error or nil in the\nfirst and second args respectively.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.existsSync(path)", "type": "method", "name": "existsSync", "desc": "Sync version of exists. Returns the args the callback gets in the async version\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.stat(path, callback)", "type": "method", "name": "stat", "desc": "> fs.stat('/', function(err, stat) print(err) statData = stat end)\nuv_fs_t: 0x00ada5c0\n> nil\nstatData\n{ mtime = { nsec = 0, sec = 1440200375 },\n atime = { nsec = 0, sec = 1444233226 }, ino = 2, nlink = 31, uid = 0,\n blksize = 4096, ctime = { nsec = 0, sec = 1440200375 }, rdev = 0,\n size = 1122, mode = 16877, type = 'directory',\n birthtime = { nsec = 0, sec = 1428616447 }, flags = 0, gid = 0, gen = 0,\n dev = 16777220, blocks = 0 }
\n",
"signatures": [
{
"params": [
{
"name": "path"
},
{
"name": "callback"
}
]
}
]
},
{
"textRaw": "fs.statSync(path)",
"type": "method",
"name": "statSync",
"desc": "Sync version of fs.stat. Returns either an error or the stat object\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.fstat(fd, callback)", "type": "method", "name": "fstat", "desc": "Similiar to stat but expects a file descriptor as retrieved from open or read instead of a path\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.fstatSync(fd)", "type": "method", "name": "fstatSync", "desc": "Sync fstat\n\n
\n", "signatures": [ { "params": [ { "name": "fd" } ] } ] }, { "textRaw": "fs.lstat(path, callback)", "type": "method", "name": "lstat", "desc": "lstat() is identical to stat(), except that if path is a symbolic link, then the link itself is stat-ed, not the file that it refers to.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.lstatSync(path)", "type": "method", "name": "lstatSync", "desc": "Sync lstat\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.rename(path, newPath, callback)", "type": "method", "name": "rename", "desc": "Renames a file or directory located at the given path to the new path.\nThe callback is called with either the error or true\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.renameSync(path, newPath)", "type": "method", "name": "renameSync", "desc": "Sync version of rename\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" } ] } ] }, { "textRaw": "fs.fsync(fd, callback)", "type": "method", "name": "fsync", "desc": "Async fsync. No arguments other than a possible exception are given to the completion callback.\n\n
\nfsync() transfers ("flushes") all modified in-core data of (i.e., modified buffer cache pages for) the file referred to by the file descriptor fd to the disk device (or other permanent storage device) so that all changed information can be retrieved even after the system crashed or was rebooted. This includes writing through or flushing a disk cache if present. The call blocks until the device reports that the transfer has completed. It also flushes metadata information associated with the file (see stat(2)).\n\n
\nCalling fsync() does not necessarily ensure that the entry in the directory containing the file has also reached disk. For that an explicit fsync() on a file descriptor for the directory is also needed.\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.fsyncSync(fd)", "type": "method", "name": "fsyncSync", "desc": "Sync version of fsync\n\n
\n", "signatures": [ { "params": [ { "name": "fd" } ] } ] }, { "textRaw": "fs.fdatasync(fd, callback)", "type": "method", "name": "fdatasync", "desc": "fdatasync() is similar to fsync(), but does not flush modified metadata unless that metadata is needed in order to allow a subsequent data retrieval to be correctly handled. For example, changes to st_atime or st_mtime (respectively, time of last access and time of last modification; see stat(2)) do not require flushing because they are not necessary for a subsequent data read to be handled correctly. On the other hand, a change to the file size (st_size, as made by say ftruncate(2)), would require a metadata flush.\n\n
\nThe aim of fdatasync() is to reduce disk activity for applications that do not require all metadata to be synchronized with the disk.\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.fdatasyncSync(fd)", "type": "method", "name": "fdatasyncSync", "desc": "Sync fdatasync\n\n
\n", "signatures": [ { "params": [ { "name": "fd" } ] } ] }, { "textRaw": "fs.ftruncate(fname[, offset], callback)", "type": "method", "name": "ftruncate", "desc": "Shrink or extend the size of each FILE to the specified size\n\n
\nA FILE argument that does not exist is created.\n\n
\nIf a FILE is larger than the specified size, the extra data is lost. If a FILE is shorter, it is extended and the extended part (hole) reads as zero bytes.\n\n
\n", "signatures": [ { "params": [ { "name": "fname" }, { "name": "offset", "optional": true }, { "name": "callback" } ] } ] }, { "textRaw": "fs.ftruncateSync(fname[, offset])", "type": "method", "name": "ftruncateSync", "desc": "Sync truncate\n\n
\n", "signatures": [ { "params": [ { "name": "fname" }, { "name": "offset", "optional": true } ] } ] }, { "textRaw": "fs.sendFile(outFd, inFd, offset, length, callback)", "type": "method", "name": "sendFile", "desc": "sendfile() copies data between one file descriptor and another. Because this copying is done within the kernel, sendfile() is more efficient than the combination of read(2) and write(2), which would require transferring data to and from user space.\n\n
\n", "signatures": [ { "params": [ { "name": "outFd" }, { "name": "inFd" }, { "name": "offset" }, { "name": "length" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.sendfileSync(outFd, inFd, offset, length)", "type": "method", "name": "sendfileSync", "desc": "Sync sendfile\n\n
\n", "signatures": [ { "params": [ { "name": "outFd" }, { "name": "inFd" }, { "name": "offset" }, { "name": "length" } ] } ] }, { "textRaw": "fs.access(path[, flags], callback)", "type": "method", "name": "access", "desc": "Tests a user's permissions for the file specified by path. mode is an optional integer that specifies the accessibility checks to be performed. The following constants define the possible values of mode. It is possible to create a mask consisting of the bitwise OR of two or more values.\n\n
\nAsynchronous fchmod(2). No arguments other than a possible exception are given to the completion callback.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "mode" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.cmodSync(fd, mode)", "type": "method", "name": "cmodSync", "desc": "Sync chmod.\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "mode" } ] } ] }, { "textRaw": "fs.fchmod(fd, mode, callback)", "type": "method", "name": "fchmod", "desc": "Asynchronous fchmod(2). No arguments other than a possible exception are given to the completion callback.\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "mode" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.utime(path, atime, mtime, callback)", "type": "method", "name": "utime", "desc": "Async utime. Chages file last access and modification times\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "atime" }, { "name": "mtime" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.utimeSync(path, atime, mtime)", "type": "method", "name": "utimeSync", "desc": "Sync utime\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "atime" }, { "name": "mtime" } ] } ] }, { "textRaw": "fs.futime(fd, atime, mtime, callback)", "type": "method", "name": "futime", "desc": "Changes file timestamps\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "atime" }, { "name": "mtime" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.futimeSync(fd, atime, mtime, callback)", "type": "method", "name": "futimeSync", "desc": "Sync futime\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "atime" }, { "name": "mtime" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.link(path, newPath, callback)", "type": "method", "name": "link", "desc": "link() creates a new link (also known as a hard link) to an existing file.\nIf newpath exists it will not be overwritten.\n\n
\nThis new name may be used exactly as the old one for any operation; both names refer to the same file (and so have the same permissions and ownership) and it is impossible to tell which name was the "original".\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.linkSync(path, newPath)", "type": "method", "name": "linkSync", "desc": "Sync link\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" } ] } ] }, { "textRaw": "fs.symink(path, newPath[, option], callback)", "type": "method", "name": "symink", "desc": "Creates soft link instead of a hard link as in link\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" }, { "name": "option", "optional": true }, { "name": "callback" } ] } ] }, { "textRaw": "fs.symlinkSync(path, newPath[, options])", "type": "method", "name": "symlinkSync", "desc": "Sync symlink\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "newPath" }, { "name": "options", "optional": true } ] } ] }, { "textRaw": "fs.readlink(path, callback)", "type": "method", "name": "readlink", "desc": "Asynchronous readlink(2). The callback gets two arguments (err, linkString).\nPrints value of a symbolic link or canonical file name\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.readlinkSync(path)", "type": "method", "name": "readlinkSync", "desc": "Sync readlink\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.chown(path, uid, gid, callback)", "type": "method", "name": "chown", "desc": "Async chown. Changes ownership of a file\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "uid" }, { "name": "gid" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.chownSync(path, uid, gid)", "type": "method", "name": "chownSync", "desc": "Sync chown\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "uid" }, { "name": "gid" } ] } ] }, { "textRaw": "fs.fchown(fd, uid, gid, callback)", "type": "method", "name": "fchown", "desc": "Like chown but works with file descriptors\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "uid" }, { "name": "gid" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.fchownSync(fd, uid, gid)", "type": "method", "name": "fchownSync", "desc": "Sync fchown\n\n
\n", "signatures": [ { "params": [ { "name": "fd" }, { "name": "uid" }, { "name": "gid" } ] } ] }, { "textRaw": "fs.readFile(path, callback)", "type": "method", "name": "readFile", "desc": "Reads a file to a string buffer which is returned as the second argument in the callback. Works with virtual filesystems as well\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.readFileSync(path)", "type": "method", "name": "readFileSync", "desc": "Sync readFile\n\n
\n", "signatures": [ { "params": [ { "name": "path" } ] } ] }, { "textRaw": "fs.writeFile(path, data, callback)", "type": "method", "name": "writeFile", "desc": "Writes a file. \n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "data" }, { "name": "callback" } ] } ] }, { "textRaw": "fs.writeFileSync(path, data)", "type": "method", "name": "writeFileSync", "desc": "Sync writeFile\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "data" } ] } ] }, { "textRaw": "fs.appendFile(filename, data[, callback])", "type": "method", "name": "appendFile", "desc": "Appends data to a file\n\n
\n", "signatures": [ { "params": [ { "name": "filename" }, { "name": "data" }, { "name": "callback", "optional": true } ] } ] }, { "textRaw": "fs.appendFileSync(path, data)", "type": "method", "name": "appendFileSync", "desc": "Sync version of append file.\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "data" } ] } ] }, { "textRaw": "fs.createWriteStream(path, options)", "type": "method", "name": "createWriteStream", "desc": "Creates and returns a new write stream, that is an instance of the afore mentioned WriteStream class with the given path and options\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "options" } ] } ] }, { "textRaw": "fs.createReadStream(path, options)", "type": "method", "name": "createReadStream", "desc": "Function which creates and returns a new read stream instance with the set options and path\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "options" } ] } ] } ], "modules": [ { "textRaw": "fs.fchmodSync(fd, mode0", "name": "fs.fchmodsync(fd,_mode0", "desc": "Sync fchmod\n\n
\n", "type": "module", "displayName": "fs.fchmodSync(fd, mode0" } ], "classes": [ { "textRaw": "Class: fs.WriteStream", "type": "class", "name": "fs.WriteStream", "desc": "Creates a writeable stream\nYou can extend the following class methods in your extended instance.\n\n
\ne.g.\n\n
\nlocal path, cb, chunk = 'valid/path', validFunc, 'validString'\nlocal WritableChild = fs.WriteStream:extend()\nfunction WritableChild:_write(data, callback)\n print('Wrote: '..data)\n callback()\nend\nlocal writable = WritableChild:new(path, cb)\nwritable:on('open', function() print('file opened')\nwritable:write(chunk) -- optional callback\nwritable:close()
\n",
"methods": [
{
"textRaw": "WriteStream:initialize(path, options)",
"type": "method",
"name": "WriteStream:initialize",
"desc": "You can set the path to the file and options here. Options is a table with the following key-value pairs\n\n
\nfd - File descriptor
\nflags - 'w' for write. See fs.open for other possible flags
\nmode - file mode to write to. Defaults to 438 which is equivalent to octal 0666
\nstart - Start position
\nCallback to fire when the write stream is opened. This callback gets no arguments\nAn open event is also emitted with the file descriptor when the file is opened\n\n
\n", "signatures": [ { "params": [ { "name": "callback" } ] } ] }, { "textRaw": "WriteStream:_write(data, callback)", "type": "method", "name": "WriteStream:_write", "desc": "Internal write utility. Bind the declared _write
in your inherited class to be called when the file is opened\n\n
Closes or destroys the write stream. Calls self:destroy()\n\n
\n", "signatures": [ { "params": [] } ] }, { "textRaw": "WriteStream:destroy()", "type": "method", "name": "WriteStream:destroy", "desc": "Closes the write stream\n\n
\n", "signatures": [ { "params": [] } ] } ] }, { "textRaw": "Class: fs.WriteStreamSync", "type": "class", "name": "fs.WriteStreamSync", "desc": "A synchronous version of the WriteStream class. Extends WriteStream\n\n
\n" }, { "textRaw": "Class: fs.ReadStream", "type": "class", "name": "fs.ReadStream", "desc": "A parent class for creating readable streams from files\nYou should extend the following class methods in your extended instance\n\n
\n", "methods": [ { "textRaw": "ReadStream:initialize(path, options)", "type": "method", "name": "ReadStream:initialize", "desc": "Initializer for the ReadStream class. \nOptions table key values: \n fd - file descriptor\n mode\n path\n offset\n chunkSize\n length\n\n
\n", "signatures": [ { "params": [ { "name": "path" }, { "name": "options" } ] } ] }, { "textRaw": "ReadStream:open(callback)", "type": "method", "name": "ReadStream:open", "desc": "Callback to fire when the read stream is opened. This callback gets no arguments\nAn open event is also emitted with the file descriptor when the file is opened\n\n
\n", "signatures": [ { "params": [ { "name": "callback" } ] } ] }, { "textRaw": "ReadStream:_read(n)", "type": "method", "name": "ReadStream:_read", "desc": "Reads a file, n chunk bytes at a time. You can set the n in the init options\n\n
\n", "signatures": [ { "params": [ { "name": "n" } ] } ] }, { "textRaw": "ReadStream:close()", "type": "method", "name": "ReadStream:close", "desc": "Closes the readstream. \n\n
\n", "signatures": [ { "params": [] } ] }, { "textRaw": "ReadStream:destroy(err)", "type": "method", "name": "ReadStream:destroy", "desc": "Destroys the readstream. Gets called by close. Emits 'error' with err if theres an error. \n\n
\n", "signatures": [ { "params": [ { "name": "err" } ] } ] } ] } ], "type": "module", "displayName": "FS" } ] }