Nodejs.sublime-completions

{
    "scope": "source.js - variable.other.js",
    "completions": [
        {
            "trigger": "assert",
            "contents": "assert"
        },
        {
            "trigger": "buffer",
            "contents": "buffer"
        },
        {
            "trigger": "child_process",
            "contents": "child_process"
        },
        {
            "trigger": "cluster",
            "contents": "cluster"
        },
        {
            "trigger": "console",
            "contents": "console"
        },
        {
            "trigger": "crypto",
            "contents": "crypto"
        },
        {
            "trigger": "dns",
            "contents": "dns"
        },
        {
            "trigger": "events",
            "contents": "events"
        },
        {
            "trigger": "fs",
            "contents": "fs"
        },
        {
            "trigger": "http",
            "contents": "http"
        },
        {
            "trigger": "https",
            "contents": "https"
        },
        {
            "trigger": "module",
            "contents": "module"
        },
        {
            "trigger": "net",
            "contents": "net"
        },
        {
            "trigger": "os",
            "contents": "os"
        },
        {
            "trigger": "path",
            "contents": "path"
        },
        {
            "trigger": "punycode",
            "contents": "punycode"
        },
        {
            "trigger": "querystring",
            "contents": "querystring"
        },
        {
            "trigger": "readline",
            "contents": "readline"
        },
        {
            "trigger": "repl",
            "contents": "repl"
        },
        {
            "trigger": "stream",
            "contents": "stream"
        },
        {
            "trigger": "string_decoder",
            "contents": "string_decoder"
        },
        {
            "trigger": "timers",
            "contents": "timers"
        },
        {
            "trigger": "tls",
            "contents": "tls"
        },
        {
            "trigger": "dgram",
            "contents": "dgram"
        },
        {
            "trigger": "url",
            "contents": "url"
        },
        {
            "trigger": "util",
            "contents": "util"
        },
        {
            "trigger": "v8",
            "contents": "v8"
        },
        {
            "trigger": "vm",
            "contents": "vm"
        },
        {
            "trigger": "zlib",
            "contents": "zlib"
        },
        {
            "trigger": "clearInterval",
            "contents": "clearInterval(${1:timer});$0"
        },
        {
            "trigger": "clearTimeout",
            "contents": "clearTimeout(${1:timer});$0"
        },
        {
            "trigger": "setInterval",
            "contents": "setInterval(${1:callback}, ${2:repeat}, ${3:arg1}, ${4:arg2}, ${5:arg3});$0"
        },
        {
            "trigger": "setTimeout",
            "contents": "setTimeout(${1:callback}, ${2:after}, ${3:arg1}, ${4:arg2}, ${5:arg3});$0"
        },
        {
            "trigger": "queueMicrotask",
            "contents": "queueMicrotask(${1:callback});$0"
        },
        {
            "trigger": "clearImmediate",
            "contents": "clearImmediate(${1:immediate});$0"
        },
        {
            "trigger": "setImmediate",
            "contents": "setImmediate(${1:callback}, ${2:arg1}, ${3:arg2}, ${4:arg3});$0"
        },
        {
            "trigger": "process._rawDebug",
            "contents": "process._rawDebug(${1:...args});$0"
        },
        {
            "trigger": "process.binding",
            "contents": "process.binding(${1:module});$0"
        },
        {
            "trigger": "process._linkedBinding",
            "contents": "process._linkedBinding(${1:module});$0"
        },
        {
            "trigger": "process.dlopen",
            "contents": "process.dlopen();$0"
        },
        {
            "trigger": "process.uptime",
            "contents": "process.uptime();$0"
        },
        {
            "trigger": "process._getActiveRequests",
            "contents": "process._getActiveRequests();$0"
        },
        {
            "trigger": "process._getActiveHandles",
            "contents": "process._getActiveHandles();$0"
        },
        {
            "trigger": "process.reallyExit",
            "contents": "process.reallyExit();$0"
        },
        {
            "trigger": "process._kill",
            "contents": "process._kill();$0"
        },
        {
            "trigger": "process.hrtime",
            "contents": "process.hrtime(${1:time});$0"
        },
        {
            "trigger": "process.cpuUsage",
            "contents": "process.cpuUsage(${1:prevValue});$0"
        },
        {
            "trigger": "process.resourceUsage",
            "contents": "process.resourceUsage();$0"
        },
        {
            "trigger": "process.memoryUsage",
            "contents": "process.memoryUsage();$0"
        },
        {
            "trigger": "process.kill",
            "contents": "process.kill(${1:pid}, ${2:sig});$0"
        },
        {
            "trigger": "process.exit",
            "contents": "process.exit(${1:code});$0"
        },
        {
            "trigger": "process.openStdin",
            "contents": "process.openStdin();$0"
        },
        {
            "trigger": "process.getuid",
            "contents": "process.getuid();$0"
        },
        {
            "trigger": "process.geteuid",
            "contents": "process.geteuid();$0"
        },
        {
            "trigger": "process.getgid",
            "contents": "process.getgid();$0"
        },
        {
            "trigger": "process.getegid",
            "contents": "process.getegid();$0"
        },
        {
            "trigger": "process.getgroups",
            "contents": "process.getgroups();$0"
        },
        {
            "trigger": "process.assert",
            "contents": "process.assert(${1:...args});$0"
        },
        {
            "trigger": "process._fatalException",
            "contents": "process._fatalException(${1:er}, ${2:fromPromise});$0"
        },
        {
            "trigger": "process.setUncaughtExceptionCaptureCallback",
            "contents": "process.setUncaughtExceptionCaptureCallback(${1:fn});$0"
        },
        {
            "trigger": "process.hasUncaughtExceptionCaptureCallback",
            "contents": "process.hasUncaughtExceptionCaptureCallback();$0"
        },
        {
            "trigger": "process.emitWarning",
            "contents": "process.emitWarning(${1:warning}, ${2:type}, ${3:code}, ${4:ctor}, ${5:now});$0"
        },
        {
            "trigger": "process.nextTick",
            "contents": "process.nextTick(${1:callback});$0"
        },
        {
            "trigger": "process._tickCallback",
            "contents": "process._tickCallback();$0"
        },
        {
            "trigger": "process._debugProcess",
            "contents": "process._debugProcess();$0"
        },
        {
            "trigger": "process._debugEnd",
            "contents": "process._debugEnd();$0"
        },
        {
            "trigger": "process._startProfilerIdleNotifier",
            "contents": "process._startProfilerIdleNotifier();$0"
        },
        {
            "trigger": "process._stopProfilerIdleNotifier",
            "contents": "process._stopProfilerIdleNotifier();$0"
        },
        {
            "trigger": "process.abort",
            "contents": "process.abort();$0"
        },
        {
            "trigger": "process.umask",
            "contents": "process.umask(${1:mask});$0"
        },
        {
            "trigger": "process.chdir",
            "contents": "process.chdir(${1:directory});$0"
        },
        {
            "trigger": "process.cwd",
            "contents": "process.cwd();$0"
        },
        {
            "trigger": "process.initgroups",
            "contents": "process.initgroups(${1:user}, ${2:extraGroup});$0"
        },
        {
            "trigger": "process.setgroups",
            "contents": "process.setgroups(${1:groups});$0"
        },
        {
            "trigger": "process.setegid",
            "contents": "process.setegid(${1:id});$0"
        },
        {
            "trigger": "process.seteuid",
            "contents": "process.seteuid(${1:id});$0"
        },
        {
            "trigger": "process.setgid",
            "contents": "process.setgid(${1:id});$0"
        },
        {
            "trigger": "process.setuid",
            "contents": "process.setuid(${1:id});$0"
        },
        {
            "trigger": "process.setMaxListeners",
            "contents": "process.setMaxListeners(${1:n});$0"
        },
        {
            "trigger": "process.getMaxListeners",
            "contents": "process.getMaxListeners();$0"
        },
        {
            "trigger": "process.emit",
            "contents": "process.emit(${1:type}, ${2:...args});$0"
        },
        {
            "trigger": "process.addListener",
            "contents": "process.addListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.on",
            "contents": "process.on(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.prependListener",
            "contents": "process.prependListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.once",
            "contents": "process.once(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.prependOnceListener",
            "contents": "process.prependOnceListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.removeListener",
            "contents": "process.removeListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.off",
            "contents": "process.off(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "process.removeAllListeners",
            "contents": "process.removeAllListeners(${1:type});$0"
        },
        {
            "trigger": "process.listeners",
            "contents": "process.listeners(${1:type});$0"
        },
        {
            "trigger": "process.rawListeners",
            "contents": "process.rawListeners(${1:type});$0"
        },
        {
            "trigger": "process.listenerCount",
            "contents": "process.listenerCount(${1:type});$0"
        },
        {
            "trigger": "process.eventNames",
            "contents": "process.eventNames();$0"
        },
        {
            "trigger": "require.resolve",
            "contents": "require.resolve(${1:request}, ${2:options});$0"
        },
        {
            "trigger": "assert.fail",
            "contents": "assert.fail(${1:actual}, ${2:expected}, ${3:message}, ${4:operator}, ${5:stackStartFn});$0"
        },
        {
            "trigger": "assert.AssertionError",
            "contents": "assert.AssertionError(${1:options});$0"
        },
        {
            "trigger": "assert.ok",
            "contents": "assert.ok(${1:...args});$0"
        },
        {
            "trigger": "assert.equal",
            "contents": "assert.equal(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.notEqual",
            "contents": "assert.notEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.deepEqual",
            "contents": "assert.deepEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.notDeepEqual",
            "contents": "assert.notDeepEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.deepStrictEqual",
            "contents": "assert.deepStrictEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.notDeepStrictEqual",
            "contents": "assert.notDeepStrictEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.strictEqual",
            "contents": "assert.strictEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.notStrictEqual",
            "contents": "assert.notStrictEqual(${1:actual}, ${2:expected}, ${3:message});$0"
        },
        {
            "trigger": "assert.throws",
            "contents": "assert.throws(${1:promiseFn}, ${2:...args});$0"
        },
        {
            "trigger": "assert.rejects",
            "contents": "assert.rejects(${1:promiseFn}, ${2:...args});$0"
        },
        {
            "trigger": "assert.doesNotThrow",
            "contents": "assert.doesNotThrow(${1:fn}, ${2:...args});$0"
        },
        {
            "trigger": "assert.doesNotReject",
            "contents": "assert.doesNotReject(${1:fn}, ${2:...args});$0"
        },
        {
            "trigger": "assert.ifError",
            "contents": "assert.ifError(${1:err});$0"
        },
        {
            "trigger": "assert.match",
            "contents": "assert.match(${1:string}, ${2:regexp}, ${3:message});$0"
        },
        {
            "trigger": "assert.doesNotMatch",
            "contents": "assert.doesNotMatch(${1:string}, ${2:regexp}, ${3:message});$0"
        },
        {
            "trigger": "assert.strict",
            "contents": "assert.strict(${1:...args});$0"
        },
        {
            "trigger": "buffer.Buffer",
            "contents": "buffer.Buffer(${1:arg}, ${2:encodingOrOffset}, ${3:length});$0"
        },
        {
            "trigger": "buffer.SlowBuffer",
            "contents": "buffer.SlowBuffer(${1:length});$0"
        },
        {
            "trigger": "buffer.transcode",
            "contents": "buffer.transcode(${1:source}, ${2:fromEncoding}, ${3:toEncoding});$0"
        },
        {
            "trigger": "child_process._forkChild",
            "contents": "child_process._forkChild(${1:fd}, ${2:serializationMode});$0"
        },
        {
            "trigger": "child_process.ChildProcess",
            "contents": "child_process.ChildProcess();$0"
        },
        {
            "trigger": "child_process.exec",
            "contents": "child_process.exec(${1:command}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "child_process.execFile",
            "contents": "child_process.execFile(${1:file}, ${2:/*}, ${3:args}, ${4:options}, ${5:callback}, ${6:*/});$0"
        },
        {
            "trigger": "child_process.execFileSync",
            "contents": "child_process.execFileSync(${1:command}, ${2:args}, ${3:options});$0"
        },
        {
            "trigger": "child_process.execSync",
            "contents": "child_process.execSync(${1:command}, ${2:options});$0"
        },
        {
            "trigger": "child_process.fork",
            "contents": "child_process.fork(${1:modulePath}, ${2:/*}, ${3:args}, ${4:options}, ${5:*/});$0"
        },
        {
            "trigger": "child_process.spawn",
            "contents": "child_process.spawn(${1:file}, ${2:args}, ${3:options});$0"
        },
        {
            "trigger": "child_process.spawnSync",
            "contents": "child_process.spawnSync(${1:file}, ${2:args}, ${3:options});$0"
        },
        {
            "trigger": "cluster.Worker",
            "contents": "cluster.Worker(${1:options});$0"
        },
        {
            "trigger": "cluster.setupMaster",
            "contents": "cluster.setupMaster(${1:options});$0"
        },
        {
            "trigger": "cluster.fork",
            "contents": "cluster.fork(${1:env});$0"
        },
        {
            "trigger": "cluster.disconnect",
            "contents": "cluster.disconnect(${1:cb});$0"
        },
        {
            "trigger": "cluster.setMaxListeners",
            "contents": "cluster.setMaxListeners(${1:n});$0"
        },
        {
            "trigger": "cluster.getMaxListeners",
            "contents": "cluster.getMaxListeners();$0"
        },
        {
            "trigger": "cluster.emit",
            "contents": "cluster.emit(${1:type}, ${2:...args});$0"
        },
        {
            "trigger": "cluster.addListener",
            "contents": "cluster.addListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.on",
            "contents": "cluster.on(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.prependListener",
            "contents": "cluster.prependListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.once",
            "contents": "cluster.once(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.prependOnceListener",
            "contents": "cluster.prependOnceListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.removeListener",
            "contents": "cluster.removeListener(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.off",
            "contents": "cluster.off(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "cluster.removeAllListeners",
            "contents": "cluster.removeAllListeners(${1:type});$0"
        },
        {
            "trigger": "cluster.listeners",
            "contents": "cluster.listeners(${1:type});$0"
        },
        {
            "trigger": "cluster.rawListeners",
            "contents": "cluster.rawListeners(${1:type});$0"
        },
        {
            "trigger": "cluster.listenerCount",
            "contents": "cluster.listenerCount(${1:type});$0"
        },
        {
            "trigger": "cluster.eventNames",
            "contents": "cluster.eventNames();$0"
        },
        {
            "trigger": "console.log",
            "contents": "console.log();$0"
        },
        {
            "trigger": "console.warn",
            "contents": "console.warn();$0"
        },
        {
            "trigger": "console.dir",
            "contents": "console.dir();$0"
        },
        {
            "trigger": "console.time",
            "contents": "console.time();$0"
        },
        {
            "trigger": "console.timeEnd",
            "contents": "console.timeEnd();$0"
        },
        {
            "trigger": "console.timeLog",
            "contents": "console.timeLog();$0"
        },
        {
            "trigger": "console.trace",
            "contents": "console.trace();$0"
        },
        {
            "trigger": "console.assert",
            "contents": "console.assert();$0"
        },
        {
            "trigger": "console.clear",
            "contents": "console.clear();$0"
        },
        {
            "trigger": "console.count",
            "contents": "console.count();$0"
        },
        {
            "trigger": "console.countReset",
            "contents": "console.countReset();$0"
        },
        {
            "trigger": "console.group",
            "contents": "console.group();$0"
        },
        {
            "trigger": "console.groupEnd",
            "contents": "console.groupEnd();$0"
        },
        {
            "trigger": "console.table",
            "contents": "console.table();$0"
        },
        {
            "trigger": "console.debug",
            "contents": "console.debug();$0"
        },
        {
            "trigger": "console.info",
            "contents": "console.info();$0"
        },
        {
            "trigger": "console.dirxml",
            "contents": "console.dirxml();$0"
        },
        {
            "trigger": "console.error",
            "contents": "console.error();$0"
        },
        {
            "trigger": "console.groupCollapsed",
            "contents": "console.groupCollapsed();$0"
        },
        {
            "trigger": "console.Console",
            "contents": "console.Console(${1:options}, ${2:/*}, ${3:or:}, ${4:stdout}, ${5:stderr}, ${6:ignoreErrors}, ${7:=}, ${8:true}, ${9:*/});$0"
        },
        {
            "trigger": "console.profile",
            "contents": "console.profile();$0"
        },
        {
            "trigger": "console.profileEnd",
            "contents": "console.profileEnd();$0"
        },
        {
            "trigger": "console.timeStamp",
            "contents": "console.timeStamp();$0"
        },
        {
            "trigger": "console.context",
            "contents": "console.context();$0"
        },
        {
            "trigger": "crypto.createCipheriv",
            "contents": "crypto.createCipheriv(${1:cipher}, ${2:key}, ${3:iv}, ${4:options});$0"
        },
        {
            "trigger": "crypto.createDecipheriv",
            "contents": "crypto.createDecipheriv(${1:cipher}, ${2:key}, ${3:iv}, ${4:options});$0"
        },
        {
            "trigger": "crypto.createDiffieHellman",
            "contents": "crypto.createDiffieHellman(${1:sizeOrKey}, ${2:keyEncoding}, ${3:generator}, ${4:genEncoding});$0"
        },
        {
            "trigger": "crypto.createDiffieHellmanGroup",
            "contents": "crypto.createDiffieHellmanGroup(${1:name});$0"
        },
        {
            "trigger": "crypto.createECDH",
            "contents": "crypto.createECDH(${1:curve});$0"
        },
        {
            "trigger": "crypto.createHash",
            "contents": "crypto.createHash(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "crypto.createHmac",
            "contents": "crypto.createHmac(${1:hmac}, ${2:key}, ${3:options});$0"
        },
        {
            "trigger": "crypto.createPrivateKey",
            "contents": "crypto.createPrivateKey(${1:key});$0"
        },
        {
            "trigger": "crypto.createPublicKey",
            "contents": "crypto.createPublicKey(${1:key});$0"
        },
        {
            "trigger": "crypto.createSecretKey",
            "contents": "crypto.createSecretKey(${1:key});$0"
        },
        {
            "trigger": "crypto.createSign",
            "contents": "crypto.createSign(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "crypto.createVerify",
            "contents": "crypto.createVerify(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "crypto.getCiphers",
            "contents": "crypto.getCiphers();$0"
        },
        {
            "trigger": "crypto.getCurves",
            "contents": "crypto.getCurves();$0"
        },
        {
            "trigger": "crypto.getDiffieHellman",
            "contents": "crypto.getDiffieHellman(${1:name});$0"
        },
        {
            "trigger": "crypto.getHashes",
            "contents": "crypto.getHashes();$0"
        },
        {
            "trigger": "crypto.pbkdf2",
            "contents": "crypto.pbkdf2(${1:password}, ${2:salt}, ${3:iterations}, ${4:keylen}, ${5:digest}, ${6:callback});$0"
        },
        {
            "trigger": "crypto.pbkdf2Sync",
            "contents": "crypto.pbkdf2Sync(${1:password}, ${2:salt}, ${3:iterations}, ${4:keylen}, ${5:digest});$0"
        },
        {
            "trigger": "crypto.generateKeyPair",
            "contents": "crypto.generateKeyPair(${1:type}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "crypto.generateKeyPairSync",
            "contents": "crypto.generateKeyPairSync(${1:type}, ${2:options});$0"
        },
        {
            "trigger": "crypto.privateDecrypt",
            "contents": "crypto.privateDecrypt(${1:options}, ${2:buffer});$0"
        },
        {
            "trigger": "crypto.privateEncrypt",
            "contents": "crypto.privateEncrypt(${1:options}, ${2:buffer});$0"
        },
        {
            "trigger": "crypto.publicDecrypt",
            "contents": "crypto.publicDecrypt(${1:options}, ${2:buffer});$0"
        },
        {
            "trigger": "crypto.publicEncrypt",
            "contents": "crypto.publicEncrypt(${1:options}, ${2:buffer});$0"
        },
        {
            "trigger": "crypto.randomBytes",
            "contents": "crypto.randomBytes(${1:size}, ${2:cb});$0"
        },
        {
            "trigger": "crypto.randomFill",
            "contents": "crypto.randomFill(${1:buf}, ${2:offset}, ${3:size}, ${4:cb});$0"
        },
        {
            "trigger": "crypto.randomFillSync",
            "contents": "crypto.randomFillSync(${1:buf}, ${2:offset}, ${3:=}, ${4:0}, ${5:size});$0"
        },
        {
            "trigger": "crypto.scrypt",
            "contents": "crypto.scrypt(${1:password}, ${2:salt}, ${3:keylen}, ${4:options}, ${5:callback}, ${6:=}, ${7:defaults});$0"
        },
        {
            "trigger": "crypto.scryptSync",
            "contents": "crypto.scryptSync(${1:password}, ${2:salt}, ${3:keylen}, ${4:options}, ${5:=}, ${6:defaults});$0"
        },
        {
            "trigger": "crypto.sign",
            "contents": "crypto.sign(${1:algorithm}, ${2:data}, ${3:key});$0"
        },
        {
            "trigger": "crypto.setEngine",
            "contents": "crypto.setEngine(${1:id}, ${2:flags});$0"
        },
        {
            "trigger": "crypto.timingSafeEqual",
            "contents": "crypto.timingSafeEqual(${1:buf1}, ${2:buf2});$0"
        },
        {
            "trigger": "crypto.getFips",
            "contents": "crypto.getFips();$0"
        },
        {
            "trigger": "crypto.setFips",
            "contents": "crypto.setFips();$0"
        },
        {
            "trigger": "crypto.verify",
            "contents": "crypto.verify(${1:algorithm}, ${2:data}, ${3:key}, ${4:signature});$0"
        },
        {
            "trigger": "crypto.Certificate",
            "contents": "crypto.Certificate();$0"
        },
        {
            "trigger": "crypto.Cipher",
            "contents": "crypto.Cipher(${1:cipher}, ${2:password}, ${3:options});$0"
        },
        {
            "trigger": "crypto.Cipheriv",
            "contents": "crypto.Cipheriv(${1:cipher}, ${2:key}, ${3:iv}, ${4:options});$0"
        },
        {
            "trigger": "crypto.Decipher",
            "contents": "crypto.Decipher(${1:cipher}, ${2:password}, ${3:options});$0"
        },
        {
            "trigger": "crypto.Decipheriv",
            "contents": "crypto.Decipheriv(${1:cipher}, ${2:key}, ${3:iv}, ${4:options});$0"
        },
        {
            "trigger": "crypto.DiffieHellman",
            "contents": "crypto.DiffieHellman(${1:sizeOrKey}, ${2:keyEncoding}, ${3:generator}, ${4:genEncoding});$0"
        },
        {
            "trigger": "crypto.DiffieHellmanGroup",
            "contents": "crypto.DiffieHellmanGroup(${1:name});$0"
        },
        {
            "trigger": "crypto.ECDH",
            "contents": "crypto.ECDH(${1:curve});$0"
        },
        {
            "trigger": "crypto.Hash",
            "contents": "crypto.Hash(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "crypto.Hmac",
            "contents": "crypto.Hmac(${1:hmac}, ${2:key}, ${3:options});$0"
        },
        {
            "trigger": "crypto.KeyObject",
            "contents": "crypto.KeyObject(${1:type}, ${2:handle});$0"
        },
        {
            "trigger": "crypto.Sign",
            "contents": "crypto.Sign(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "crypto.Verify",
            "contents": "crypto.Verify(${1:algorithm}, ${2:options});$0"
        },
        {
            "trigger": "dns.lookup",
            "contents": "dns.lookup(${1:hostname}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "dns.lookupService",
            "contents": "dns.lookupService(${1:address}, ${2:port}, ${3:callback});$0"
        },
        {
            "trigger": "dns.Resolver",
            "contents": "dns.Resolver();$0"
        },
        {
            "trigger": "dns.setServers",
            "contents": "dns.setServers(${1:servers});$0"
        },
        {
            "trigger": "dns.getServers",
            "contents": "dns.getServers();$0"
        },
        {
            "trigger": "dns.resolve",
            "contents": "dns.resolve();$0"
        },
        {
            "trigger": "dns.resolve4",
            "contents": "dns.resolve4();$0"
        },
        {
            "trigger": "dns.resolve6",
            "contents": "dns.resolve6();$0"
        },
        {
            "trigger": "dns.resolveAny",
            "contents": "dns.resolveAny();$0"
        },
        {
            "trigger": "dns.resolveCname",
            "contents": "dns.resolveCname();$0"
        },
        {
            "trigger": "dns.resolveMx",
            "contents": "dns.resolveMx();$0"
        },
        {
            "trigger": "dns.resolveNaptr",
            "contents": "dns.resolveNaptr();$0"
        },
        {
            "trigger": "dns.resolveNs",
            "contents": "dns.resolveNs();$0"
        },
        {
            "trigger": "dns.resolvePtr",
            "contents": "dns.resolvePtr();$0"
        },
        {
            "trigger": "dns.resolveSoa",
            "contents": "dns.resolveSoa();$0"
        },
        {
            "trigger": "dns.resolveSrv",
            "contents": "dns.resolveSrv();$0"
        },
        {
            "trigger": "dns.resolveTxt",
            "contents": "dns.resolveTxt();$0"
        },
        {
            "trigger": "dns.reverse",
            "contents": "dns.reverse();$0"
        },
        {
            "trigger": "events.once",
            "contents": "events.once(${1:emitter}, ${2:name});$0"
        },
        {
            "trigger": "events.on",
            "contents": "events.on(${1:emitter}, ${2:event});$0"
        },
        {
            "trigger": "events.EventEmitter",
            "contents": "events.EventEmitter(${1:opts});$0"
        },
        {
            "trigger": "events.init",
            "contents": "events.init(${1:opts});$0"
        },
        {
            "trigger": "events.listenerCount",
            "contents": "events.listenerCount(${1:emitter}, ${2:type});$0"
        },
        {
            "trigger": "fs.appendFile",
            "contents": "fs.appendFile(${1:path}, ${2:data}, ${3:options}, ${4:callback});$0"
        },
        {
            "trigger": "fs.appendFileSync",
            "contents": "fs.appendFileSync(${1:path}, ${2:data}, ${3:options});$0"
        },
        {
            "trigger": "fs.access",
            "contents": "fs.access(${1:path}, ${2:mode}, ${3:callback});$0"
        },
        {
            "trigger": "fs.accessSync",
            "contents": "fs.accessSync(${1:path}, ${2:mode});$0"
        },
        {
            "trigger": "fs.chown",
            "contents": "fs.chown(${1:path}, ${2:uid}, ${3:gid}, ${4:callback});$0"
        },
        {
            "trigger": "fs.chownSync",
            "contents": "fs.chownSync(${1:path}, ${2:uid}, ${3:gid});$0"
        },
        {
            "trigger": "fs.chmod",
            "contents": "fs.chmod(${1:path}, ${2:mode}, ${3:callback});$0"
        },
        {
            "trigger": "fs.chmodSync",
            "contents": "fs.chmodSync(${1:path}, ${2:mode});$0"
        },
        {
            "trigger": "fs.close",
            "contents": "fs.close(${1:fd}, ${2:callback});$0"
        },
        {
            "trigger": "fs.closeSync",
            "contents": "fs.closeSync(${1:fd});$0"
        },
        {
            "trigger": "fs.copyFile",
            "contents": "fs.copyFile(${1:src}, ${2:dest}, ${3:flags}, ${4:callback});$0"
        },
        {
            "trigger": "fs.copyFileSync",
            "contents": "fs.copyFileSync(${1:src}, ${2:dest}, ${3:flags});$0"
        },
        {
            "trigger": "fs.createReadStream",
            "contents": "fs.createReadStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.createWriteStream",
            "contents": "fs.createWriteStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.exists",
            "contents": "fs.exists(${1:path}, ${2:callback});$0"
        },
        {
            "trigger": "fs.existsSync",
            "contents": "fs.existsSync(${1:path});$0"
        },
        {
            "trigger": "fs.fchown",
            "contents": "fs.fchown(${1:fd}, ${2:uid}, ${3:gid}, ${4:callback});$0"
        },
        {
            "trigger": "fs.fchownSync",
            "contents": "fs.fchownSync(${1:fd}, ${2:uid}, ${3:gid});$0"
        },
        {
            "trigger": "fs.fchmod",
            "contents": "fs.fchmod(${1:fd}, ${2:mode}, ${3:callback});$0"
        },
        {
            "trigger": "fs.fchmodSync",
            "contents": "fs.fchmodSync(${1:fd}, ${2:mode});$0"
        },
        {
            "trigger": "fs.fdatasync",
            "contents": "fs.fdatasync(${1:fd}, ${2:callback});$0"
        },
        {
            "trigger": "fs.fdatasyncSync",
            "contents": "fs.fdatasyncSync(${1:fd});$0"
        },
        {
            "trigger": "fs.fstat",
            "contents": "fs.fstat(${1:fd}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}}, ${8:callback});$0"
        },
        {
            "trigger": "fs.fstatSync",
            "contents": "fs.fstatSync(${1:fd}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}});$0"
        },
        {
            "trigger": "fs.fsync",
            "contents": "fs.fsync(${1:fd}, ${2:callback});$0"
        },
        {
            "trigger": "fs.fsyncSync",
            "contents": "fs.fsyncSync(${1:fd});$0"
        },
        {
            "trigger": "fs.ftruncate",
            "contents": "fs.ftruncate(${1:fd}, ${2:len}, ${3:=}, ${4:0}, ${5:callback});$0"
        },
        {
            "trigger": "fs.ftruncateSync",
            "contents": "fs.ftruncateSync(${1:fd}, ${2:len}, ${3:=}, ${4:0});$0"
        },
        {
            "trigger": "fs.futimes",
            "contents": "fs.futimes(${1:fd}, ${2:atime}, ${3:mtime}, ${4:callback});$0"
        },
        {
            "trigger": "fs.futimesSync",
            "contents": "fs.futimesSync(${1:fd}, ${2:atime}, ${3:mtime});$0"
        },
        {
            "trigger": "fs.lchown",
            "contents": "fs.lchown(${1:path}, ${2:uid}, ${3:gid}, ${4:callback});$0"
        },
        {
            "trigger": "fs.lchownSync",
            "contents": "fs.lchownSync(${1:path}, ${2:uid}, ${3:gid});$0"
        },
        {
            "trigger": "fs.lchmod",
            "contents": "fs.lchmod(${1:path}, ${2:mode}, ${3:callback});$0"
        },
        {
            "trigger": "fs.lchmodSync",
            "contents": "fs.lchmodSync(${1:path}, ${2:mode});$0"
        },
        {
            "trigger": "fs.link",
            "contents": "fs.link(${1:existingPath}, ${2:newPath}, ${3:callback});$0"
        },
        {
            "trigger": "fs.linkSync",
            "contents": "fs.linkSync(${1:existingPath}, ${2:newPath});$0"
        },
        {
            "trigger": "fs.lstat",
            "contents": "fs.lstat(${1:path}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}}, ${8:callback});$0"
        },
        {
            "trigger": "fs.lstatSync",
            "contents": "fs.lstatSync(${1:path}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}});$0"
        },
        {
            "trigger": "fs.mkdir",
            "contents": "fs.mkdir(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.mkdirSync",
            "contents": "fs.mkdirSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.mkdtemp",
            "contents": "fs.mkdtemp(${1:prefix}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.mkdtempSync",
            "contents": "fs.mkdtempSync(${1:prefix}, ${2:options});$0"
        },
        {
            "trigger": "fs.open",
            "contents": "fs.open(${1:path}, ${2:flags}, ${3:mode}, ${4:callback});$0"
        },
        {
            "trigger": "fs.openSync",
            "contents": "fs.openSync(${1:path}, ${2:flags}, ${3:mode});$0"
        },
        {
            "trigger": "fs.opendir",
            "contents": "fs.opendir(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.opendirSync",
            "contents": "fs.opendirSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.readdir",
            "contents": "fs.readdir(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.readdirSync",
            "contents": "fs.readdirSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.read",
            "contents": "fs.read(${1:fd}, ${2:buffer}, ${3:offset}, ${4:length}, ${5:position}, ${6:callback});$0"
        },
        {
            "trigger": "fs.readSync",
            "contents": "fs.readSync(${1:fd}, ${2:buffer}, ${3:offset}, ${4:length}, ${5:position});$0"
        },
        {
            "trigger": "fs.readFile",
            "contents": "fs.readFile(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.readFileSync",
            "contents": "fs.readFileSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.readlink",
            "contents": "fs.readlink(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.readlinkSync",
            "contents": "fs.readlinkSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.realpath",
            "contents": "fs.realpath(${1:p}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.realpathSync",
            "contents": "fs.realpathSync(${1:p}, ${2:options});$0"
        },
        {
            "trigger": "fs.rename",
            "contents": "fs.rename(${1:oldPath}, ${2:newPath}, ${3:callback});$0"
        },
        {
            "trigger": "fs.renameSync",
            "contents": "fs.renameSync(${1:oldPath}, ${2:newPath});$0"
        },
        {
            "trigger": "fs.rmdir",
            "contents": "fs.rmdir(${1:path}, ${2:options}, ${3:callback});$0"
        },
        {
            "trigger": "fs.rmdirSync",
            "contents": "fs.rmdirSync(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.stat",
            "contents": "fs.stat(${1:path}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}}, ${8:callback});$0"
        },
        {
            "trigger": "fs.statSync",
            "contents": "fs.statSync(${1:path}, ${2:options}, ${3:=}, ${4:{}, ${5:bigint:}, ${6:false}, ${7:}});$0"
        },
        {
            "trigger": "fs.symlink",
            "contents": "fs.symlink(${1:target}, ${2:path}, ${3:type_}, ${4:callback_});$0"
        },
        {
            "trigger": "fs.symlinkSync",
            "contents": "fs.symlinkSync(${1:target}, ${2:path}, ${3:type});$0"
        },
        {
            "trigger": "fs.truncate",
            "contents": "fs.truncate(${1:path}, ${2:len}, ${3:callback});$0"
        },
        {
            "trigger": "fs.truncateSync",
            "contents": "fs.truncateSync(${1:path}, ${2:len});$0"
        },
        {
            "trigger": "fs.unwatchFile",
            "contents": "fs.unwatchFile(${1:filename}, ${2:listener});$0"
        },
        {
            "trigger": "fs.unlink",
            "contents": "fs.unlink(${1:path}, ${2:callback});$0"
        },
        {
            "trigger": "fs.unlinkSync",
            "contents": "fs.unlinkSync(${1:path});$0"
        },
        {
            "trigger": "fs.utimes",
            "contents": "fs.utimes(${1:path}, ${2:atime}, ${3:mtime}, ${4:callback});$0"
        },
        {
            "trigger": "fs.utimesSync",
            "contents": "fs.utimesSync(${1:path}, ${2:atime}, ${3:mtime});$0"
        },
        {
            "trigger": "fs.watch",
            "contents": "fs.watch(${1:filename}, ${2:options}, ${3:listener});$0"
        },
        {
            "trigger": "fs.watchFile",
            "contents": "fs.watchFile(${1:filename}, ${2:options}, ${3:listener});$0"
        },
        {
            "trigger": "fs.writeFile",
            "contents": "fs.writeFile(${1:path}, ${2:data}, ${3:options}, ${4:callback});$0"
        },
        {
            "trigger": "fs.writeFileSync",
            "contents": "fs.writeFileSync(${1:path}, ${2:data}, ${3:options});$0"
        },
        {
            "trigger": "fs.write",
            "contents": "fs.write(${1:fd}, ${2:buffer}, ${3:offset}, ${4:length}, ${5:position}, ${6:callback});$0"
        },
        {
            "trigger": "fs.writeSync",
            "contents": "fs.writeSync(${1:fd}, ${2:buffer}, ${3:offset}, ${4:length}, ${5:position});$0"
        },
        {
            "trigger": "fs.writev",
            "contents": "fs.writev(${1:fd}, ${2:buffers}, ${3:position}, ${4:callback});$0"
        },
        {
            "trigger": "fs.writevSync",
            "contents": "fs.writevSync(${1:fd}, ${2:buffers}, ${3:position});$0"
        },
        {
            "trigger": "fs.Dir",
            "contents": "fs.Dir(${1:handle}, ${2:path}, ${3:options});$0"
        },
        {
            "trigger": "fs.Dirent",
            "contents": "fs.Dirent(${1:name}, ${2:type});$0"
        },
        {
            "trigger": "fs.Stats",
            "contents": "fs.Stats(${1:dev}, ${2:mode}, ${3:nlink}, ${4:uid}, ${5:gid}, ${6:rdev}, ${7:blksize}, ${8:\n}, ${9:ino}, ${10:size}, ${11:blocks}, ${12:\n}, ${13:atimeMs}, ${14:mtimeMs}, ${15:ctimeMs}, ${16:birthtimeMs});$0"
        },
        {
            "trigger": "fs.ReadStream",
            "contents": "fs.ReadStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.WriteStream",
            "contents": "fs.WriteStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.FileReadStream",
            "contents": "fs.FileReadStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs.FileWriteStream",
            "contents": "fs.FileWriteStream(${1:path}, ${2:options});$0"
        },
        {
            "trigger": "fs._toUnixTimestamp",
            "contents": "fs._toUnixTimestamp(${1:time}, ${2:name}, ${3:=}, ${4:'time'});$0"
        },
        {
            "trigger": "http._connectionListener",
            "contents": "http._connectionListener(${1:socket});$0"
        },
        {
            "trigger": "http.Agent",
            "contents": "http.Agent(${1:options});$0"
        },
        {
            "trigger": "http.ClientRequest",
            "contents": "http.ClientRequest(${1:input}, ${2:options}, ${3:cb});$0"
        },
        {
            "trigger": "http.IncomingMessage",
            "contents": "http.IncomingMessage(${1:socket});$0"
        },
        {
            "trigger": "http.OutgoingMessage",
            "contents": "http.OutgoingMessage();$0"
        },
        {
            "trigger": "http.Server",
            "contents": "http.Server(${1:options}, ${2:requestListener});$0"
        },
        {
            "trigger": "http.ServerResponse",
            "contents": "http.ServerResponse(${1:req});$0"
        },
        {
            "trigger": "http.createServer",
            "contents": "http.createServer(${1:opts}, ${2:requestListener});$0"
        },
        {
            "trigger": "http.get",
            "contents": "http.get(${1:url}, ${2:options}, ${3:cb});$0"
        },
        {
            "trigger": "http.request",
            "contents": "http.request(${1:url}, ${2:options}, ${3:cb});$0"
        },
        {
            "trigger": "https.Agent",
            "contents": "https.Agent(${1:options});$0"
        },
        {
            "trigger": "https.Server",
            "contents": "https.Server(${1:opts}, ${2:requestListener});$0"
        },
        {
            "trigger": "https.createServer",
            "contents": "https.createServer(${1:opts}, ${2:requestListener});$0"
        },
        {
            "trigger": "https.get",
            "contents": "https.get(${1:input}, ${2:options}, ${3:cb});$0"
        },
        {
            "trigger": "https.request",
            "contents": "https.request(${1:...args});$0"
        },
        {
            "trigger": "module._debug",
            "contents": "module._debug(${1:...args});$0"
        },
        {
            "trigger": "module._findPath",
            "contents": "module._findPath(${1:request}, ${2:paths}, ${3:isMain});$0"
        },
        {
            "trigger": "module._nodeModulePaths",
            "contents": "module._nodeModulePaths(${1:from});$0"
        },
        {
            "trigger": "module._resolveLookupPaths",
            "contents": "module._resolveLookupPaths(${1:request}, ${2:parent});$0"
        },
        {
            "trigger": "module._load",
            "contents": "module._load(${1:request}, ${2:parent}, ${3:isMain});$0"
        },
        {
            "trigger": "module._resolveFilename",
            "contents": "module._resolveFilename(${1:request}, ${2:parent}, ${3:isMain}, ${4:options});$0"
        },
        {
            "trigger": "module.createRequireFromPath",
            "contents": "module.createRequireFromPath(${1:filename});$0"
        },
        {
            "trigger": "module.createRequire",
            "contents": "module.createRequire(${1:filename});$0"
        },
        {
            "trigger": "module._initPaths",
            "contents": "module._initPaths();$0"
        },
        {
            "trigger": "module._preloadModules",
            "contents": "module._preloadModules(${1:requests});$0"
        },
        {
            "trigger": "module.syncBuiltinESMExports",
            "contents": "module.syncBuiltinESMExports();$0"
        },
        {
            "trigger": "module.Module",
            "contents": "module.Module(${1:id}, ${2:=}, ${3:''}, ${4:parent});$0"
        },
        {
            "trigger": "module.runMain",
            "contents": "module.runMain(${1:main}, ${2:=}, ${3:process.argv[1]});$0"
        },
        {
            "trigger": "net._createServerHandle",
            "contents": "net._createServerHandle(${1:address}, ${2:port}, ${3:addressType}, ${4:fd}, ${5:flags});$0"
        },
        {
            "trigger": "net._normalizeArgs",
            "contents": "net._normalizeArgs(${1:args});$0"
        },
        {
            "trigger": "net._setSimultaneousAccepts",
            "contents": "net._setSimultaneousAccepts();$0"
        },
        {
            "trigger": "net.connect",
            "contents": "net.connect(${1:...args});$0"
        },
        {
            "trigger": "net.createConnection",
            "contents": "net.createConnection(${1:...args});$0"
        },
        {
            "trigger": "net.createServer",
            "contents": "net.createServer(${1:options}, ${2:connectionListener});$0"
        },
        {
            "trigger": "net.isIP",
            "contents": "net.isIP(${1:s});$0"
        },
        {
            "trigger": "net.isIPv4",
            "contents": "net.isIPv4(${1:s});$0"
        },
        {
            "trigger": "net.isIPv6",
            "contents": "net.isIPv6(${1:s});$0"
        },
        {
            "trigger": "net.Server",
            "contents": "net.Server(${1:options}, ${2:connectionListener});$0"
        },
        {
            "trigger": "net.Socket",
            "contents": "net.Socket(${1:options});$0"
        },
        {
            "trigger": "net.Stream",
            "contents": "net.Stream(${1:options});$0"
        },
        {
            "trigger": "os.arch",
            "contents": "os.arch();$0"
        },
        {
            "trigger": "os.cpus",
            "contents": "os.cpus();$0"
        },
        {
            "trigger": "os.endianness",
            "contents": "os.endianness();$0"
        },
        {
            "trigger": "os.freemem",
            "contents": "os.freemem();$0"
        },
        {
            "trigger": "os.getPriority",
            "contents": "os.getPriority(${1:pid});$0"
        },
        {
            "trigger": "os.homedir",
            "contents": "os.homedir(${1:...args});$0"
        },
        {
            "trigger": "os.hostname",
            "contents": "os.hostname(${1:...args});$0"
        },
        {
            "trigger": "os.loadavg",
            "contents": "os.loadavg();$0"
        },
        {
            "trigger": "os.networkInterfaces",
            "contents": "os.networkInterfaces();$0"
        },
        {
            "trigger": "os.platform",
            "contents": "os.platform();$0"
        },
        {
            "trigger": "os.release",
            "contents": "os.release(${1:...args});$0"
        },
        {
            "trigger": "os.setPriority",
            "contents": "os.setPriority(${1:pid}, ${2:priority});$0"
        },
        {
            "trigger": "os.tmpdir",
            "contents": "os.tmpdir();$0"
        },
        {
            "trigger": "os.totalmem",
            "contents": "os.totalmem();$0"
        },
        {
            "trigger": "os.type",
            "contents": "os.type(${1:...args});$0"
        },
        {
            "trigger": "os.userInfo",
            "contents": "os.userInfo(${1:options});$0"
        },
        {
            "trigger": "os.uptime",
            "contents": "os.uptime();$0"
        },
        {
            "trigger": "os.tmpDir",
            "contents": "os.tmpDir(${1:...args});$0"
        },
        {
            "trigger": "path.resolve",
            "contents": "path.resolve(${1:...args});$0"
        },
        {
            "trigger": "path.normalize",
            "contents": "path.normalize(${1:path});$0"
        },
        {
            "trigger": "path.isAbsolute",
            "contents": "path.isAbsolute(${1:path});$0"
        },
        {
            "trigger": "path.join",
            "contents": "path.join(${1:...args});$0"
        },
        {
            "trigger": "path.relative",
            "contents": "path.relative(${1:from}, ${2:to});$0"
        },
        {
            "trigger": "path.toNamespacedPath",
            "contents": "path.toNamespacedPath(${1:path});$0"
        },
        {
            "trigger": "path.dirname",
            "contents": "path.dirname(${1:path});$0"
        },
        {
            "trigger": "path.basename",
            "contents": "path.basename(${1:path}, ${2:ext});$0"
        },
        {
            "trigger": "path.extname",
            "contents": "path.extname(${1:path});$0"
        },
        {
            "trigger": "path.format",
            "contents": "path.format();$0"
        },
        {
            "trigger": "path.parse",
            "contents": "path.parse(${1:path});$0"
        },
        {
            "trigger": "path._makeLong",
            "contents": "path._makeLong(${1:path});$0"
        },
        {
            "trigger": "punycode.decode",
            "contents": "punycode.decode(${1:input});$0"
        },
        {
            "trigger": "punycode.encode",
            "contents": "punycode.encode(${1:input});$0"
        },
        {
            "trigger": "punycode.toASCII",
            "contents": "punycode.toASCII(${1:input});$0"
        },
        {
            "trigger": "punycode.toUnicode",
            "contents": "punycode.toUnicode(${1:input});$0"
        },
        {
            "trigger": "querystring.unescapeBuffer",
            "contents": "querystring.unescapeBuffer(${1:s}, ${2:decodeSpaces});$0"
        },
        {
            "trigger": "querystring.unescape",
            "contents": "querystring.unescape(${1:s}, ${2:decodeSpaces});$0"
        },
        {
            "trigger": "querystring.escape",
            "contents": "querystring.escape(${1:str});$0"
        },
        {
            "trigger": "querystring.stringify",
            "contents": "querystring.stringify(${1:obj}, ${2:sep}, ${3:eq}, ${4:options});$0"
        },
        {
            "trigger": "querystring.encode",
            "contents": "querystring.encode(${1:obj}, ${2:sep}, ${3:eq}, ${4:options});$0"
        },
        {
            "trigger": "querystring.parse",
            "contents": "querystring.parse(${1:qs}, ${2:sep}, ${3:eq}, ${4:options});$0"
        },
        {
            "trigger": "querystring.decode",
            "contents": "querystring.decode(${1:qs}, ${2:sep}, ${3:eq}, ${4:options});$0"
        },
        {
            "trigger": "readline.Interface",
            "contents": "readline.Interface(${1:input}, ${2:output}, ${3:completer}, ${4:terminal});$0"
        },
        {
            "trigger": "readline.clearLine",
            "contents": "readline.clearLine(${1:stream}, ${2:dir}, ${3:callback});$0"
        },
        {
            "trigger": "readline.clearScreenDown",
            "contents": "readline.clearScreenDown(${1:stream}, ${2:callback});$0"
        },
        {
            "trigger": "readline.createInterface",
            "contents": "readline.createInterface(${1:input}, ${2:output}, ${3:completer}, ${4:terminal});$0"
        },
        {
            "trigger": "readline.cursorTo",
            "contents": "readline.cursorTo(${1:stream}, ${2:x}, ${3:y}, ${4:callback});$0"
        },
        {
            "trigger": "readline.emitKeypressEvents",
            "contents": "readline.emitKeypressEvents(${1:stream}, ${2:iface});$0"
        },
        {
            "trigger": "readline.moveCursor",
            "contents": "readline.moveCursor(${1:stream}, ${2:dx}, ${3:dy}, ${4:callback});$0"
        },
        {
            "trigger": "repl.writer",
            "contents": "repl.writer(${1:obj});$0"
        },
        {
            "trigger": "repl.REPLServer",
            "contents": "repl.REPLServer(${1:prompt}, ${2:\n}, ${3:stream}, ${4:\n}, ${5:eval_}, ${6:\n}, ${7:useGlobal}, ${8:\n}, ${9:ignoreUndefined}, ${10:\n}, ${11:replMode});$0"
        },
        {
            "trigger": "repl.start",
            "contents": "repl.start(${1:prompt}, ${2:\n}, ${3:source}, ${4:\n}, ${5:eval_}, ${6:\n}, ${7:useGlobal}, ${8:\n}, ${9:ignoreUndefined}, ${10:\n}, ${11:replMode});$0"
        },
        {
            "trigger": "repl.Recoverable",
            "contents": "repl.Recoverable(${1:err});$0"
        },
        {
            "trigger": "stream.Readable",
            "contents": "stream.Readable(${1:options});$0"
        },
        {
            "trigger": "stream.Writable",
            "contents": "stream.Writable(${1:options});$0"
        },
        {
            "trigger": "stream.Duplex",
            "contents": "stream.Duplex(${1:options});$0"
        },
        {
            "trigger": "stream.Transform",
            "contents": "stream.Transform(${1:options});$0"
        },
        {
            "trigger": "stream.PassThrough",
            "contents": "stream.PassThrough(${1:options});$0"
        },
        {
            "trigger": "stream.pipeline",
            "contents": "stream.pipeline(${1:...streams});$0"
        },
        {
            "trigger": "stream.finished",
            "contents": "stream.finished(${1:stream}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "stream.Stream",
            "contents": "stream.Stream(${1:opts});$0"
        },
        {
            "trigger": "stream._isUint8Array",
            "contents": "stream._isUint8Array(${1:value});$0"
        },
        {
            "trigger": "stream._uint8ArrayToBuffer",
            "contents": "stream._uint8ArrayToBuffer(${1:chunk});$0"
        },
        {
            "trigger": "stream.once",
            "contents": "stream.once(${1:emitter}, ${2:name});$0"
        },
        {
            "trigger": "stream.on",
            "contents": "stream.on(${1:emitter}, ${2:event});$0"
        },
        {
            "trigger": "stream.EventEmitter",
            "contents": "stream.EventEmitter(${1:opts});$0"
        },
        {
            "trigger": "stream.init",
            "contents": "stream.init();$0"
        },
        {
            "trigger": "stream.listenerCount",
            "contents": "stream.listenerCount(${1:emitter}, ${2:type});$0"
        },
        {
            "trigger": "string_decoder.StringDecoder",
            "contents": "string_decoder.StringDecoder(${1:encoding});$0"
        },
        {
            "trigger": "timers.setTimeout",
            "contents": "timers.setTimeout(${1:callback}, ${2:after}, ${3:arg1}, ${4:arg2}, ${5:arg3});$0"
        },
        {
            "trigger": "timers.clearTimeout",
            "contents": "timers.clearTimeout(${1:timer});$0"
        },
        {
            "trigger": "timers.setImmediate",
            "contents": "timers.setImmediate(${1:callback}, ${2:arg1}, ${3:arg2}, ${4:arg3});$0"
        },
        {
            "trigger": "timers.clearImmediate",
            "contents": "timers.clearImmediate(${1:immediate});$0"
        },
        {
            "trigger": "timers.setInterval",
            "contents": "timers.setInterval(${1:callback}, ${2:repeat}, ${3:arg1}, ${4:arg2}, ${5:arg3});$0"
        },
        {
            "trigger": "timers.clearInterval",
            "contents": "timers.clearInterval(${1:timer});$0"
        },
        {
            "trigger": "timers._unrefActive",
            "contents": "timers._unrefActive(${1:...args});$0"
        },
        {
            "trigger": "timers.active",
            "contents": "timers.active(${1:...args});$0"
        },
        {
            "trigger": "timers.unenroll",
            "contents": "timers.unenroll(${1:...args});$0"
        },
        {
            "trigger": "timers.enroll",
            "contents": "timers.enroll(${1:...args});$0"
        },
        {
            "trigger": "tls.getCiphers",
            "contents": "tls.getCiphers();$0"
        },
        {
            "trigger": "tls.convertALPNProtocols",
            "contents": "tls.convertALPNProtocols(${1:protocols}, ${2:out});$0"
        },
        {
            "trigger": "tls.checkServerIdentity",
            "contents": "tls.checkServerIdentity(${1:hostname}, ${2:cert});$0"
        },
        {
            "trigger": "tls.parseCertString",
            "contents": "tls.parseCertString(${1:...args});$0"
        },
        {
            "trigger": "tls.createSecureContext",
            "contents": "tls.createSecureContext(${1:options});$0"
        },
        {
            "trigger": "tls.SecureContext",
            "contents": "tls.SecureContext(${1:secureProtocol}, ${2:secureOptions}, ${3:minVersion}, ${4:maxVersion});$0"
        },
        {
            "trigger": "tls.TLSSocket",
            "contents": "tls.TLSSocket(${1:socket}, ${2:opts});$0"
        },
        {
            "trigger": "tls.Server",
            "contents": "tls.Server(${1:options}, ${2:listener});$0"
        },
        {
            "trigger": "tls.createServer",
            "contents": "tls.createServer(${1:options}, ${2:listener});$0"
        },
        {
            "trigger": "tls.connect",
            "contents": "tls.connect(${1:...args});$0"
        },
        {
            "trigger": "tls.createSecurePair",
            "contents": "tls.createSecurePair(${1:...args});$0"
        },
        {
            "trigger": "dgram._createSocketHandle",
            "contents": "dgram._createSocketHandle(${1:...args});$0"
        },
        {
            "trigger": "dgram.createSocket",
            "contents": "dgram.createSocket(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "dgram.Socket",
            "contents": "dgram.Socket(${1:type}, ${2:listener});$0"
        },
        {
            "trigger": "url.Url",
            "contents": "url.Url();$0"
        },
        {
            "trigger": "url.parse",
            "contents": "url.parse(${1:url}, ${2:parseQueryString}, ${3:slashesDenoteHost});$0"
        },
        {
            "trigger": "url.resolve",
            "contents": "url.resolve(${1:source}, ${2:relative});$0"
        },
        {
            "trigger": "url.resolveObject",
            "contents": "url.resolveObject(${1:source}, ${2:relative});$0"
        },
        {
            "trigger": "url.format",
            "contents": "url.format(${1:urlObject}, ${2:options});$0"
        },
        {
            "trigger": "url.URL",
            "contents": "url.URL(${1:input}, ${2:base});$0"
        },
        {
            "trigger": "url.URLSearchParams",
            "contents": "url.URLSearchParams(${1:init}, ${2:=}, ${3:undefined});$0"
        },
        {
            "trigger": "url.domainToASCII",
            "contents": "url.domainToASCII(${1:domain});$0"
        },
        {
            "trigger": "url.domainToUnicode",
            "contents": "url.domainToUnicode(${1:domain});$0"
        },
        {
            "trigger": "url.pathToFileURL",
            "contents": "url.pathToFileURL(${1:filepath});$0"
        },
        {
            "trigger": "url.fileURLToPath",
            "contents": "url.fileURLToPath(${1:path});$0"
        },
        {
            "trigger": "util._errnoException",
            "contents": "util._errnoException(${1:err}, ${2:syscall}, ${3:original});$0"
        },
        {
            "trigger": "util._exceptionWithHostPort",
            "contents": "util._exceptionWithHostPort(${1:err}, ${2:syscall}, ${3:address}, ${4:port}, ${5:additional});$0"
        },
        {
            "trigger": "util._extend",
            "contents": "util._extend(${1:target}, ${2:source});$0"
        },
        {
            "trigger": "util.callbackify",
            "contents": "util.callbackify(${1:original});$0"
        },
        {
            "trigger": "util.debuglog",
            "contents": "util.debuglog(${1:set});$0"
        },
        {
            "trigger": "util.deprecate",
            "contents": "util.deprecate(${1:fn}, ${2:msg}, ${3:code});$0"
        },
        {
            "trigger": "util.format",
            "contents": "util.format(${1:...args});$0"
        },
        {
            "trigger": "util.formatWithOptions",
            "contents": "util.formatWithOptions(${1:inspectOptions}, ${2:...args});$0"
        },
        {
            "trigger": "util.getSystemErrorName",
            "contents": "util.getSystemErrorName(${1:err});$0"
        },
        {
            "trigger": "util.inherits",
            "contents": "util.inherits(${1:ctor}, ${2:superCtor});$0"
        },
        {
            "trigger": "util.inspect",
            "contents": "util.inspect(${1:value}, ${2:opts});$0"
        },
        {
            "trigger": "util.isArray",
            "contents": "util.isArray();$0"
        },
        {
            "trigger": "util.isBoolean",
            "contents": "util.isBoolean(${1:arg});$0"
        },
        {
            "trigger": "util.isBuffer",
            "contents": "util.isBuffer(${1:b});$0"
        },
        {
            "trigger": "util.isDeepStrictEqual",
            "contents": "util.isDeepStrictEqual(${1:a}, ${2:b});$0"
        },
        {
            "trigger": "util.isNull",
            "contents": "util.isNull(${1:arg});$0"
        },
        {
            "trigger": "util.isNullOrUndefined",
            "contents": "util.isNullOrUndefined(${1:arg});$0"
        },
        {
            "trigger": "util.isNumber",
            "contents": "util.isNumber(${1:arg});$0"
        },
        {
            "trigger": "util.isString",
            "contents": "util.isString(${1:arg});$0"
        },
        {
            "trigger": "util.isSymbol",
            "contents": "util.isSymbol(${1:arg});$0"
        },
        {
            "trigger": "util.isUndefined",
            "contents": "util.isUndefined(${1:arg});$0"
        },
        {
            "trigger": "util.isRegExp",
            "contents": "util.isRegExp();$0"
        },
        {
            "trigger": "util.isObject",
            "contents": "util.isObject(${1:arg});$0"
        },
        {
            "trigger": "util.isDate",
            "contents": "util.isDate();$0"
        },
        {
            "trigger": "util.isError",
            "contents": "util.isError(${1:e});$0"
        },
        {
            "trigger": "util.isFunction",
            "contents": "util.isFunction(${1:arg});$0"
        },
        {
            "trigger": "util.isPrimitive",
            "contents": "util.isPrimitive(${1:arg});$0"
        },
        {
            "trigger": "util.log",
            "contents": "util.log(${1:...args});$0"
        },
        {
            "trigger": "util.promisify",
            "contents": "util.promisify(${1:original});$0"
        },
        {
            "trigger": "util.TextDecoder",
            "contents": "util.TextDecoder(${1:encoding}, ${2:=}, ${3:'utf-8'}, ${4:options}, ${5:=}, ${6:{}});$0"
        },
        {
            "trigger": "util.TextEncoder",
            "contents": "util.TextEncoder();$0"
        },
        {
            "trigger": "v8.cachedDataVersionTag",
            "contents": "v8.cachedDataVersionTag();$0"
        },
        {
            "trigger": "v8.getHeapSnapshot",
            "contents": "v8.getHeapSnapshot();$0"
        },
        {
            "trigger": "v8.getHeapStatistics",
            "contents": "v8.getHeapStatistics();$0"
        },
        {
            "trigger": "v8.getHeapSpaceStatistics",
            "contents": "v8.getHeapSpaceStatistics();$0"
        },
        {
            "trigger": "v8.getHeapCodeStatistics",
            "contents": "v8.getHeapCodeStatistics();$0"
        },
        {
            "trigger": "v8.setFlagsFromString",
            "contents": "v8.setFlagsFromString(${1:flags});$0"
        },
        {
            "trigger": "v8.Serializer",
            "contents": "v8.Serializer(${1:class}, ${2:Serializer}, ${3:extends}, ${4:_Serializer}, ${5:{});$0"
        },
        {
            "trigger": "v8.Deserializer",
            "contents": "v8.Deserializer(${1:class}, ${2:Deserializer}, ${3:extends}, ${4:_Deserializer}, ${5:{});$0"
        },
        {
            "trigger": "v8.DefaultSerializer",
            "contents": "v8.DefaultSerializer();$0"
        },
        {
            "trigger": "v8.DefaultDeserializer",
            "contents": "v8.DefaultDeserializer();$0"
        },
        {
            "trigger": "v8.deserialize",
            "contents": "v8.deserialize(${1:buffer});$0"
        },
        {
            "trigger": "v8.serialize",
            "contents": "v8.serialize(${1:value});$0"
        },
        {
            "trigger": "v8.writeHeapSnapshot",
            "contents": "v8.writeHeapSnapshot(${1:filename});$0"
        },
        {
            "trigger": "vm.Script",
            "contents": "vm.Script(${1:code}, ${2:options}, ${3:=}, ${4:{}});$0"
        },
        {
            "trigger": "vm.createContext",
            "contents": "vm.createContext(${1:contextObject}, ${2:=}, ${3:{}}, ${4:options}, ${5:=}, ${6:{}});$0"
        },
        {
            "trigger": "vm.createScript",
            "contents": "vm.createScript(${1:code}, ${2:options});$0"
        },
        {
            "trigger": "vm.runInContext",
            "contents": "vm.runInContext(${1:code}, ${2:contextifiedObject}, ${3:options});$0"
        },
        {
            "trigger": "vm.runInNewContext",
            "contents": "vm.runInNewContext(${1:code}, ${2:contextObject}, ${3:options});$0"
        },
        {
            "trigger": "vm.runInThisContext",
            "contents": "vm.runInThisContext(${1:code}, ${2:options});$0"
        },
        {
            "trigger": "vm.isContext",
            "contents": "vm.isContext(${1:object});$0"
        },
        {
            "trigger": "vm.compileFunction",
            "contents": "vm.compileFunction(${1:code}, ${2:params}, ${3:options}, ${4:=}, ${5:{}});$0"
        },
        {
            "trigger": "zlib.Deflate",
            "contents": "zlib.Deflate(${1:opts});$0"
        },
        {
            "trigger": "zlib.Inflate",
            "contents": "zlib.Inflate(${1:opts});$0"
        },
        {
            "trigger": "zlib.Gzip",
            "contents": "zlib.Gzip(${1:opts});$0"
        },
        {
            "trigger": "zlib.Gunzip",
            "contents": "zlib.Gunzip(${1:opts});$0"
        },
        {
            "trigger": "zlib.DeflateRaw",
            "contents": "zlib.DeflateRaw(${1:opts});$0"
        },
        {
            "trigger": "zlib.InflateRaw",
            "contents": "zlib.InflateRaw(${1:opts});$0"
        },
        {
            "trigger": "zlib.Unzip",
            "contents": "zlib.Unzip(${1:opts});$0"
        },
        {
            "trigger": "zlib.BrotliCompress",
            "contents": "zlib.BrotliCompress(${1:opts});$0"
        },
        {
            "trigger": "zlib.BrotliDecompress",
            "contents": "zlib.BrotliDecompress(${1:opts});$0"
        },
        {
            "trigger": "zlib.deflate",
            "contents": "zlib.deflate(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.deflateSync",
            "contents": "zlib.deflateSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.gzip",
            "contents": "zlib.gzip(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.gzipSync",
            "contents": "zlib.gzipSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.deflateRaw",
            "contents": "zlib.deflateRaw(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.deflateRawSync",
            "contents": "zlib.deflateRawSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.unzip",
            "contents": "zlib.unzip(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.unzipSync",
            "contents": "zlib.unzipSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.inflate",
            "contents": "zlib.inflate(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.inflateSync",
            "contents": "zlib.inflateSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.gunzip",
            "contents": "zlib.gunzip(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.gunzipSync",
            "contents": "zlib.gunzipSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.inflateRaw",
            "contents": "zlib.inflateRaw(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.inflateRawSync",
            "contents": "zlib.inflateRawSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.brotliCompress",
            "contents": "zlib.brotliCompress(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.brotliCompressSync",
            "contents": "zlib.brotliCompressSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.brotliDecompress",
            "contents": "zlib.brotliDecompress(${1:buffer}, ${2:opts}, ${3:callback});$0"
        },
        {
            "trigger": "zlib.brotliDecompressSync",
            "contents": "zlib.brotliDecompressSync(${1:buffer}, ${2:opts});$0"
        },
        {
            "trigger": "zlib.createDeflate",
            "contents": "zlib.createDeflate(${1:options});$0"
        },
        {
            "trigger": "zlib.createInflate",
            "contents": "zlib.createInflate(${1:options});$0"
        },
        {
            "trigger": "zlib.createDeflateRaw",
            "contents": "zlib.createDeflateRaw(${1:options});$0"
        },
        {
            "trigger": "zlib.createInflateRaw",
            "contents": "zlib.createInflateRaw(${1:options});$0"
        },
        {
            "trigger": "zlib.createGzip",
            "contents": "zlib.createGzip(${1:options});$0"
        },
        {
            "trigger": "zlib.createGunzip",
            "contents": "zlib.createGunzip(${1:options});$0"
        },
        {
            "trigger": "zlib.createUnzip",
            "contents": "zlib.createUnzip(${1:options});$0"
        },
        {
            "trigger": "zlib.createBrotliCompress",
            "contents": "zlib.createBrotliCompress(${1:options});$0"
        },
        {
            "trigger": "zlib.createBrotliDecompress",
            "contents": "zlib.createBrotliDecompress(${1:options});$0"
        }
    ]
}