API

Type

• @.as.meaningful()
• @.as.possible()
• @.as()
• @.get()
• @.inherits()
• @.is.nil()
• @.is.obj.pure()
• @.is.obj()
• @.is()
• @.keys()
• @.objectize()
• @.owns()
• @.parse.reg()
• @.parse()
• @.primitify()
• @.prop.getter()
• @.prop.readonly()
• @.prop.sealed()
• @.prop()
• @.type()

Async

• @.async.all()
• @.async.domain()
• @.async.ensure()
• @.async.env()
• @.async.isAsync()
• @.async.reject()
• @.async.resolve()
• @.async.result()
• @.async.state()
• @.async.time()
• @.async.unfinisheds()
• @.async()
• Async.prototype.all()
• Async.prototype.async()
• Async.prototype.catch()
• Async.prototype.domain()
• Async.prototype.finally()
• Async.prototype.finished()
• Async.prototype.frame
• Async.prototype.pipe()
• Async.prototype.promise()
• Async.prototype.rejected()
• Async.prototype.resolve()
• Async.prototype.then()
• Async()
• Step.prototype.delay()
• Step.prototype.next()
• Step.prototype.reject.once()
• Step.prototype.reject()
• Step.prototype.retry()
• Step.prototype.test.attatch()
• Step.prototype.test()
• Step.prototype.untrack()

Buffer

• @.buf.expected()
• @.buf.match()
• @.buf.rejoin()

Cache

• @.cache()
• Cache.prototype.record()
• Cache.prototype.update()

Chan

• @.chan.gen()
• @.chan.mount.union()
• @.chan.mount()
• ChanInfo.prototype.id
• ChanInfo.prototype.meta
• ChanInfo()

Comparator

• @.cmp.cstr()
• @.cmp.date()
• @.cmp.natural.insensitive()
• @.cmp.natural()
• @.cmp.num()
• @.cmp.path()
• @.cmp.str()
• @.cmp()

Config

• @.conf.reg()
• @.conf()

Timer

• @.delay()
• @.plan()
• @.schedule()
• @.timer()
• Job.prototype.act()
• Job.prototype.cancel()
• Job.prototype.resume()
• Job.prototype.schedule()
• Job.prototype.suspend()
• Job()

Serial

• @.deserialize()
• @.serialize.hndl()
• @.serialize()

Error

• @.error.code()
• @.error.desc()
• @.error.exec()
• @.error.reg()
• @.error.stack()
• @.error()

Format

• @.format.closure()
• @.format.compile()
• @.format.date()
• @.format.functors
• @.format.parsers
• @.format.tmpl.closure()
• @.format.tmpl.compile()
• @.format.tmpl.deps.changed()
• @.format.tmpl.deps()
• @.format.tmpl.jit()
• @.format.tmpl()
• @.format.zero()
• @.format()

File

• @.fs.appendBasename()
• @.fs.basename()
• @.fs.changeExtname()
• @.fs.changeRootPath()
• @.fs.copyFile.sync()
• @.fs.copyFile()
• @.fs.deleteFile.sync()
• @.fs.deleteFile()
• @.fs.dirname()
• @.fs.exists.dir()
• @.fs.exists.file()
• @.fs.exists()
• @.fs.extname()
• @.fs.fileLStats()
• @.fs.filename()
• @.fs.fileStats()
• @.fs.hash.md5.sync()
• @.fs.hash.md5()
• @.fs.hash.sha1.sync()
• @.fs.hash.sha1()
• @.fs.hash.sha256.sync()
• @.fs.hash.sha256()
• @.fs.hash.sha512.sync()
• @.fs.hash.sha512()
• @.fs.hash()
• @.fs.homePath()
• @.fs.isAbspath()
• @.fs.isExecutable()
• @.fs.isUnderDir()
• @.fs.linkFile()
• @.fs.listFiles()
• @.fs.makeDirs()
• @.fs.mime()
• @.fs.moveFile.sync()
• @.fs.moveFile()
• @.fs.openFile()
• @.fs.openReadonlyFile()
• @.fs.pathScore()
• @.fs.posixOSPath()
• @.fs.readFile.stream()
• @.fs.readFile.sync()
• @.fs.readFile()
• @.fs.readLink()
• @.fs.realOSPath()
• @.fs.realpath()
• @.fs.relativePath()
• @.fs.resolvePath()
• @.fs.rootBasedPath()
• @.fs.scanFiles.sync()
• @.fs.scanFiles()
• @.fs.setFileLMode()
• @.fs.setFileMode()
• @.fs.setFileModifyTime()
• @.fs.setFileOwner()
• @.fs.standardizePath()
• @.fs.tempFile()
• @.fs.tempPath()
• @.fs.touchFile()
• @.fs.truncateFile()
• @.fs.watchFile()
• @.fs.winOSPath()
• @.fs.writeFile.stream()
• @.fs.writeFile.sync()
• @.fs.writeFile()
• @.fs()
• @path()
• @realpath()
• File.prototype.changeMode()
• File.prototype.changeModifyTime()
• File.prototype.changeOwner()
• File.prototype.close()
• File.prototype.delete()
• File.prototype.flush()
• File.prototype.getStats()
• File.prototype.read()
• File.prototype.readSync()
• File.prototype.truncate()
• File.prototype.write()
• File.prototype.writeSync()
• File()
• FileWatcher.prototype.close()
• FileWatcher()

VFS

• @.fs()
• @vfs.complete()
• @vfs.fdPath()
• @vfs.mount()
• @vfs.realpath()
• @vfs.reg()
• @vfs.testSU()
• @vfs.unmount()

Hash

• @.fs.hash.md5.sync()
• @.fs.hash.md5()
• @.fs.hash.sha1.sync()
• @.fs.hash.sha1()
• @.fs.hash.sha256.sync()
• @.fs.hash.sha256()
• @.fs.hash.sha512.sync()
• @.fs.hash.sha512()
• @.fs.hash()
• @.hash.md5()
• @.hash.sha1()
• @.hash.sha256()
• @.hash.sha512()
• @.hash()

Jsonize

• @.jsonize.hndl()
• @.jsonize()

Lock

• @.lock.pendings()
• @.lock.read()
• @.lock.write()
• @.lock()

Merge

• @.match()
• @.merge.advanced()
• @.merge.simple()
• @.merge()

Memory

• @.mem.cachePool()
• @.mem.dict()
• @.mem.lru()
• @.mem.map()
• @.mem.recall()
• @.mem.redisCachePool()
• @.mem.weakMap()
• @.mem.weakRefMap()

Network

• @.net.availablePort()
• @.net.hostIPs()
• @.net.httpClient()
• @.net.jsonrpcClient()
• @.net.lookupNS()
• @.net.wsClient()
• @.net.wsServer()
• HTTPClient.prototype.download()
• HTTPClient.prototype.getCookies()
• HTTPClient.prototype.multipartRequest()
• HTTPClient.prototype.request()
• HTTPClient.prototype.setCookie()
• HTTPClient()
• JSONRPCClient.prototype.download()
• JSONRPCClient.prototype.getCookies()
• JSONRPCClient.prototype.jsonRPC()
• JSONRPCClient.prototype.multipartRequest()
• JSONRPCClient.prototype.request()
• JSONRPCClient.prototype.setCookie()
• JSONRPCClient()
• WebSocket.prototype.close()
• WebSocket.prototype.off()
• WebSocket.prototype.on()
• WebSocket.prototype.ping()
• WebSocket.prototype.send()
• WebSocket()
• WebSocketServer.prototype.broadcast()
• WebSocketServer.prototype.clients()
• WebSocketServer.prototype.close()
• WebSocketServer()

OS

• @.os.inMSYS()
• @.os.is.android()
• @.os.is.darwin()
• @.os.is.ios()
• @.os.is.linux()
• @.os.is.macos()
• @.os.is.msys()
• @.os.is.windows()
• @.os.is()
• @.os.posixPath()
• @.os()

Ruler

• @.ruler.rule()
• @.ruler()
• Rule.prototype.test()
• Rule()
• Ruler.prototype.addRule()
• Ruler.prototype.merge()
• Ruler.prototype.removeRule()
• Ruler.prototype.reset()
• Ruler.prototype.test()
• Ruler()

Stream

• @.stream.buffer()
• @.stream.expect.toFile()
• @.stream.expect()
• @.stream.json()
• @.stream.monitor()
• @.stream.read()
• @.stream.string()

Task

• @.task.execute.sync()
• @.task.execute()
• @.task.pty()
• @.task.resolve.shebang()
• @.task.resolve()
• PTY.prototype.kill()
• PTY.prototype.size
• PTY.prototype.socket
• PTY()

Terminal

• @.term.leftPad()
• @.term.rightPad()
• @.term.strip()
• @.term.text()

UUID

• @.uuid()

Annotation

• @annot.func()
• @annot.import()
• @annot.marker()
• @forget()
• @import()

Log

• @assert.eq()
• @assert()
• @celebr()
• @debug()
• @dump.all()
• @dump()
• @error()
• @info()
• @logLevel()
• @system()
• @warn()

Test

• @benchmark.test()
• @benchmark()
• @test.assert.count()
• @test.assert.eq()
• @test.assert()
• @test.clear()
• @test.start()
• @test()

Engine

• @engine.coreVersionCode()
• @engine.coreVersions()
• @engine.dumpStack()
• @engine.genVersionCode()
• @engine.ignoreStack()
• @engine.printMascot()
• @engine.stackFrame()

GC

• @engine.gc()
• WeakRef

Git

• @git.blame()
• @git.checkout()
• @git.clone()
• @git.fetch()
• @git.reset()
• @git.resolveRefish()
• @git.status()
• @git()
• Git.prototype.blame()
• Git.prototype.checkout()
• Git.prototype.close()
• Git.prototype.fetch()
• Git.prototype.path
• Git.prototype.reset()
• Git.prototype.resolveRefish()
• Git.prototype.status()
• Git()

Database

• @mysql()
• @sql()
• @sqlite()
• ORM.prototype.add()
• ORM.prototype.clear()
• ORM.prototype.find()
• ORM.prototype.get()
• ORM.prototype.load()
• ORM.prototype.remove()
• ORM.prototype.save()
• ORM.prototype.set()
• ORM()
• SQLBuilder.prototype.as()
• SQLBuilder.prototype.asc()
• SQLBuilder.prototype.compile()
• SQLBuilder.prototype.count()
• SQLBuilder.prototype.crossJoin()
• SQLBuilder.prototype.desc()
• SQLBuilder.prototype.execute()
• SQLBuilder.prototype.from()
• SQLBuilder.prototype.groupBy()
• SQLBuilder.prototype.having()
• SQLBuilder.prototype.join()
• SQLBuilder.prototype.leftJoin()
• SQLBuilder.prototype.limit()
• SQLBuilder.prototype.naturalJoin()
• SQLBuilder.prototype.offset()
• SQLBuilder.prototype.on()
• SQLBuilder.prototype.query()
• SQLBuilder.prototype.rightJoin()
• SQLBuilder.prototype.select()
• SQLBuilder.prototype.set()
• SQLBuilder.prototype.toString()
• SQLBuilder.prototype.where()
• SQLBuilder.deleteFrom()
• SQLBuilder.insertInto()
• SQLBuilder.select()
• SQLBuilder.selectDistinct()
• SQLBuilder.update()
• SQLBuilder()
• SQLConnection.prototype.acquire()
• SQLConnection.prototype.close()
• SQLConnection.prototype.connected
• SQLConnection.prototype.open()
• SQLConnection.prototype.orm
• SQLConnection()
• SQLSession.prototype.convertDataFromSQL()
• SQLSession.prototype.convertDataToSQL()
• SQLSession.prototype.deleteFrom()
• SQLSession.prototype.execute()
• SQLSession.prototype.executeSync()
• SQLSession.prototype.getTableDefinition()
• SQLSession.prototype.insertInto()
• SQLSession.prototype.lastRecordID
• SQLSession.prototype.listTables()
• SQLSession.prototype.orm
• SQLSession.prototype.query()
• SQLSession.prototype.querySync()
• SQLSession.prototype.select()
• SQLSession.prototype.selectDistinct()
• SQLSession.prototype.totalChanges
• SQLSession.prototype.transaction()
• SQLSession.prototype.update()
• SQLSession()

Redis

• @redis.connect()
• RedisClient.prototype.close()
• RedisClient.prototype.execute()
• RedisClient.prototype.executeSync()
• RedisClient.prototype.host
• RedisClient.prototype.lock()
• RedisClient.prototype.port
• RedisClient.prototype.ready()
• RedisClient.prototype.username
• RedisClient()

Module

• @require.make()
• @require.path()
• @require.pathAsEntry()
• @require()

Zip

• @zip.build()
• @zip.load()
• ZipArchive.prototype.extractAll()
• ZipArchive.prototype.extractFile()
• ZipArchive.prototype.extractFileSync()
• ZipArchive.prototype.files
• ZipArchive.prototype.getEntry()
• ZipArchive.prototype.getEntryMeta()
• ZipArchive.prototype.listFiles()
• ZipArchive.prototype.readFile()
• ZipArchive.prototype.readFileSync()
• ZipArchive.prototype.readLink()
• ZipArchive()
• ZipBuilder.prototype.addArchive()
• ZipBuilder.prototype.addEntry()
• ZipBuilder.prototype.save()
• ZipBuilder()
• ZipEntry()