diff --git a/node/node-0.8.8-tests.ts b/node/node-0.8.8-tests.ts
new file mode 100644
index 000000000..ceff094d7
--- /dev/null
+++ b/node/node-0.8.8-tests.ts
@@ -0,0 +1,28 @@
+///
+
+import assert = module("assert");
+import fs = module("fs");
+
+assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
+
+assert.deepEqual({ x: { y: 3 } }, { x: { y: 3 } }, "DEEP WENT DERP");
+
+assert.equal(3, "3", "uses == comparator");
+
+assert.notStrictEqual(2, "2", "uses === comparator");
+
+assert.throws(() => { throw "a hammer at your face"; }, undefined, "DODGED IT");
+
+assert.doesNotThrow(() => {
+ if (false) { throw "a hammer at your face"; }
+}, undefined, "What the...*crunch*");
+
+
+fs.writeFile("thebible.txt",
+ "Do unto others as you would have them do unto you.",
+ assert.ifError);
+
+fs.writeFile("Harry Potter",
+ "\"You be wizzing, Harry,\" jived Dumbledore.",
+ "ascii",
+ assert.ifError);
\ No newline at end of file
diff --git a/node/node-0.8.8.d.ts b/node/node-0.8.8.d.ts
new file mode 100644
index 000000000..152b8a9f8
--- /dev/null
+++ b/node/node-0.8.8.d.ts
@@ -0,0 +1,1059 @@
+/************************************************
+* *
+* Node.js v0.8.8 API *
+* *
+************************************************/
+
+/************************************************
+* *
+* GLOBAL *
+* *
+************************************************/
+declare var process: NodeProcess;
+declare var global: any;
+
+declare var console: {
+ log(...data: any[]): void;
+ info(...data: any[]): void;
+ error(...data: any[]): void;
+ warn(...data: any[]): void;
+ dir(obj: any): void;
+ timeEnd(label: string): void;
+ trace(label: string): void;
+ assert(expression: any, ...message: string[]): void;
+}
+
+declare var __filename: string;
+declare var __dirname: string;
+
+declare function setTimeout(callback: () => void , ms: number): any;
+declare function clearTimeout(timeoutId: any);
+declare function setInterval(callback: () => void , ms: number): any;
+declare function clearInterval(intervalId: any);
+
+declare var require: {
+ (id: string): any;
+ resolve(): string;
+ cache: any;
+ extensions: any;
+}
+
+declare var module: {
+ exports: any;
+ require(id: string): any;
+ id: string;
+ filename: string;
+ loaded: bool;
+ parent: any;
+ children: any[];
+}
+
+// Same as module.exports
+declare var exports: any;
+declare var SlowBuffer: {
+ new (str: string, encoding?: string): NodeBuffer;
+ new (size: number): NodeBuffer;
+ new (array: any[]): NodeBuffer;
+ prototype: NodeBuffer;
+ isBuffer(obj: any): bool;
+ byteLength(string: string, encoding?: string): number;
+ concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+};
+declare var Buffer: {
+ new (str: string, encoding?: string): NodeBuffer;
+ new (size: number): NodeBuffer;
+ new (array: any[]): NodeBuffer;
+ prototype: NodeBuffer;
+ isBuffer(obj: any): bool;
+ byteLength(string: string, encoding?: string): number;
+ concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+}
+
+/************************************************
+* *
+* INTERFACES *
+* *
+************************************************/
+
+interface EventEmitter {
+ addListener(event: string, listener: Function);
+ on(event: string, listener: Function);
+ once(event: string, listener: Function): void;
+ removeListener(event: string, listener: Function): void;
+ removeAllListener(event: string): void;
+ setMaxListeners(n: number): void;
+ listeners(event: string): { Function; }[];
+ emit(event: string, arg1?: any, arg2?: any): void;
+}
+
+interface WritableStream extends EventEmitter {
+ writable: bool;
+ write(str: string, encoding?: string, fd?: string): bool;
+ write(buffer: NodeBuffer): bool;
+ end(): void;
+ end(str: string, enconding: string): void;
+ end(buffer: NodeBuffer): void;
+ destroy(): void;
+ destroySoon(): void;
+}
+
+interface ReadableStream extends EventEmitter {
+ readable: bool;
+ setEncoding(encoding: string): void;
+ pause(): void;
+ resume(): void;
+ destroy(): void;
+ pipe(destination: WritableStream, options?: { end?: bool; }): void;
+}
+
+interface NodeProcess extends EventEmitter {
+ stdout: WritableStream;
+ stderr: WritableStream;
+ stdin: ReadableStream;
+ argv: string[];
+ execPath: string;
+ abort(): void;
+ chdir(directory: string): void;
+ cwd(): void;
+ env: any;
+ exit(code?: number): void;
+ getgid(): number;
+ setgid(id: number): void;
+ getuid(): number;
+ setuid(id: number): void;
+ version: string;
+ versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; };
+ config: {
+ target_defaults: {
+ cflags: any[];
+ default_configuration: string;
+ defines: string[];
+ include_dirs: string[];
+ libraries: string[];
+ };
+ variables: {
+ clang: number;
+ host_arch: string;
+ node_install_npm: bool;
+ node_install_waf: bool;
+ node_prefix: string;
+ node_shared_openssl: bool;
+ node_shared_v8: bool;
+ node_shared_zlib: bool;
+ node_use_dtrace: bool;
+ node_use_etw: bool;
+ node_use_openssl: bool;
+ target_arch: string;
+ v8_no_strict_aliasing: number;
+ v8_use_snapshot: bool;
+ visibility: string;
+ };
+ };
+ kill(pid: number, signal?: string): void;
+ pid: number;
+ title: string;
+ arch: string;
+ platform: string;
+ memoryUsage(): { rss: number; heapTotal; number; heapUsed: number; };
+ nextTick(callback: Function): void;
+ umask(mask?: number): number;
+ uptime(): number;
+ hrtime(): number[];
+}
+
+// Buffer class
+interface NodeBuffer {
+ [index: number]: number;
+ write(string: string, offset?: number, length?: number, encoding?: string): number;
+ toString(encoding?: string, start?: number, end?: number): string;
+ length: number;
+ copy(targetBuffer: NodeBuffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): void;
+ slice(start?: number, end?: number): NodeBuffer;
+ readUInt8(offset: number, noAsset?: bool): number;
+ readUInt16LE(offset: number, noAssert?: bool): number;
+ readUInt16BE(offset: number, noAssert?: bool): number;
+ readUInt32LE(offset: number, noAssert?: bool): number;
+ readUInt32BE(offset: number, noAssert?: bool): number;
+ readInt8(offset: number, noAssert?: bool): number;
+ readInt16LE(offset: number, noAssert?: bool): number;
+ readInt16BE(offset: number, noAssert?: bool): number;
+ readInt32LE(offset: number, noAssert?: bool): number;
+ readInt32BE(offset: number, noAssert?: bool): number;
+ readFloatLE(offset: number, noAssert?: bool): number;
+ readFloatBE(offset: number, noAssert?: bool): number;
+ readDoubleLE(offset: number, noAssert?: bool): number;
+ readDoubleBE(offset: number, noAssert?: bool): number;
+ writeUInt8(value: number, offset: number, noAssert?: bool): void;
+ writeUInt16LE(value: number, offset: number, noAssert?: bool): void;
+ writeUInt16BE(value: number, offset: number, noAssert?: bool): void;
+ writeUInt32LE(value: number, offset: number, noAssert?: bool): void;
+ writeUInt32BE(value: number, offset: number, noAssert?: bool): void;
+ writeInt8(value: number, offset: number, noAssert?: bool): void;
+ writeInt16LE(value: number, offset: number, noAssert?: bool): void;
+ writeInt16BE(value: number, offset: number, noAssert?: bool): void;
+ writeInt32LE(value: number, offset: number, noAssert?: bool): void;
+ writeInt32BE(value: number, offset: number, noAssert?: bool): void;
+ writeFloatLE(value: number, offset: number, noAssert?: bool): void;
+ writeFloatBE(value: number, offset: number, noAssert?: bool): void;
+ writeDoubleLE(value: number, offset: number, noAssert?: bool): void;
+ writeDoubleBE(value: number, offset: number, noAssert?: bool): void;
+ fill(value: any, offset?: number, end?: number): void;
+ INSPECT_MAX_BYTES: number;
+}
+
+/************************************************
+* *
+* MODULES *
+* *
+************************************************/
+declare module "querystring" {
+ export function stringify(obj: any, sep?: string, eq?: string): string;
+ export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
+ export function escape(): any;
+ export function unescape(): any;
+}
+
+declare module "events" {
+ export interface NodeEventEmitter {
+ addListener(event: string, listener: Function);
+ on(event: string, listener: Function): any;
+ once(event: string, listener: Function): void;
+ removeListener(event: string, listener: Function): void;
+ removeAllListener(event: string): void;
+ setMaxListeners(n: number): void;
+ listeners(event: string): { Function; }[];
+ emit(event: string, arg1?: any, arg2?: any): void;
+ }
+
+ export var EventEmitter: NodeEventEmitter;
+}
+
+declare module "http" {
+ import events = module("events");
+ import net = module("net");
+ import stream = module("stream");
+
+ export interface Server extends events.NodeEventEmitter {
+ listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
+ listen(path: string, callback?: Function): void;
+ listen(handle: any, listeningListener?: Function): void;
+ close(cb?: any): void;
+ maxHeadersCount: number;
+ }
+ export interface ServerRequest extends events.NodeEventEmitter, stream.ReadableStream {
+ method: string;
+ url: string;
+ headers: string;
+ trailers: string;
+ httpVersion: string;
+ setEncoding(encoding?: string): void;
+ pause(): void;
+ resume(): void;
+ connection: net.NodeSocket;
+ }
+ export interface ServerResponse extends events.NodeEventEmitter, stream.WritableStream {
+ // Extended base methods
+ write(str: string, encoding?: string, fd?: string): bool;
+ write(buffer: NodeBuffer): bool;
+
+ writeContinue(): void;
+ writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
+ writeHead(statusCode: number, headers?: any): void;
+ statusCode: number;
+ setHeader(name: string, value: string): void;
+ sendDate: bool;
+ getHeader(name: string): string;
+ removeHeader(name: string): void;
+ write(chunk: any, encoding?: string): any;
+ addTrailers(headers: any): void;
+ end(data?: any, encoding?: string): void;
+ }
+ export interface ClientRequest extends events.NodeEventEmitter, stream.WritableStream {
+ // Extended base methods
+ write(str: string, encoding?: string, fd?: string): bool;
+ write(buffer: NodeBuffer): bool;
+
+ write(chunk: any, encoding?: string): void;
+ end(data?: any, encoding?: string): void;
+ abort(): void;
+ setTimeout(timeout: number, callback?: Function): void;
+ setNoDelay(noDelay?: Function): void;
+ setSocketKeepAlive(enable?: bool, initialDelay?: number): void;
+ }
+ export interface ClientResponse extends events.NodeEventEmitter, stream.ReadableStream {
+ statusCode: number;
+ httpVersion: string;
+ headers: any;
+ trailers: any;
+ setEncoding(encoding?: string): void;
+ pause(): void;
+ resume(): void;
+ }
+ export interface Agent { maxSockets: number; sockets: any; requests: any; }
+
+ export var STATUS_CODES;
+ export function createServer(requestListener?: (request: ServerRequest, response: ServerResponse) =>void ): Server;
+ export function createClient(port?: number, host?: string): any;
+ export function request(options: any, callback?: Function): ClientRequest;
+ export function get(options: any, callback?: Function): ClientRequest;
+ export var globalAgent: Agent;
+}
+
+declare module "cluster" {
+ import child_process = module("child_process");
+
+ export interface ClusterSettings {
+ exec: string;
+ args: string[];
+ silent: bool;
+ }
+ export interface Worker {
+ id: string;
+ process: child_process;
+ suicide: bool;
+ send(message: any, sendHandle?: any): void;
+ destroy(): void;
+ disconnect(): void;
+ }
+
+
+ export var settings: ClusterSettings;
+ export var isMaster: bool;
+ export var isWorker: bool;
+ export function setupMaster(settings?: ClusterSettings): void;
+ export function fork(env?: any): Worker;
+ export function disconnect(callback?: Function): void;
+ export var workers: any;
+
+ // Event emitter
+ export function addListener(event: string, listener: Function): void;
+ export function on(event: string, listener: Function): any;
+ export function once(event: string, listener: Function): void;
+ export function removeListener(event: string, listener: Function): void;
+ export function removeAllListener(event: string): void;
+ export function setMaxListeners(n: number): void;
+ export function listeners(event: string): { Function; }[];
+ export function emit(event: string, arg1?: any, arg2?: any): void;
+}
+
+declare module "zlib" {
+ import stream = module("stream");
+ export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
+
+ export interface Gzip extends stream.ReadWriteStream { }
+ export interface Gunzip extends stream.ReadWriteStream { }
+ export interface Deflate extends stream.ReadWriteStream { }
+ export interface Inflate extends stream.ReadWriteStream { }
+ export interface DeflateRaw extends stream.ReadWriteStream { }
+ export interface InflateRaw extends stream.ReadWriteStream { }
+ export interface Unzip extends stream.ReadWriteStream { }
+
+ export function createGzip(options: ZlibOptions): Gzip;
+ export function createGunzip(options: ZlibOptions): Gunzip;
+ export function createDeflate(options: ZlibOptions): Deflate;
+ export function createInflate(options: ZlibOptions): Inflate;
+ export function createDeflateRaw(options: ZlibOptions): DeflateRaw;
+ export function createInflateRaw(options: ZlibOptions): InflateRaw;
+ export function createUnzip(options: ZlibOptions): Unzip;
+
+ export function deflate(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function gzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function gunzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function inflate(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+ export function unzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+
+ // Constants
+ export var Z_NO_FLUSH: number;
+ export var Z_PARTIAL_FLUSH: number;
+ export var Z_SYNC_FLUSH: number;
+ export var Z_FULL_FLUSH: number;
+ export var Z_FINISH: number;
+ export var Z_BLOCK: number;
+ export var Z_TREES: number;
+ export var Z_OK: number;
+ export var Z_STREAM_END: number;
+ export var Z_NEED_DICT: number;
+ export var Z_ERRNO: number;
+ export var Z_STREAM_ERROR: number;
+ export var Z_DATA_ERROR: number;
+ export var Z_MEM_ERROR: number;
+ export var Z_BUF_ERROR: number;
+ export var Z_VERSION_ERROR: number;
+ export var Z_NO_COMPRESSION: number;
+ export var Z_BEST_SPEED: number;
+ export var Z_BEST_COMPRESSION: number;
+ export var Z_DEFAULT_COMPRESSION: number;
+ export var Z_FILTERED: number;
+ export var Z_HUFFMAN_ONLY: number;
+ export var Z_RLE: number;
+ export var Z_FIXED: number;
+ export var Z_DEFAULT_STRATEGY: number;
+ export var Z_BINARY: number;
+ export var Z_TEXT: number;
+ export var Z_ASCII: number;
+ export var Z_UNKNOWN: number;
+ export var Z_DEFLATED: number;
+ export var Z_NULL: number;
+}
+
+declare module "os" {
+ export function tmpDir(): string;
+ export function hostname(): string;
+ export function type(): string;
+ export function platform(): string;
+ export function arch(): string;
+ export function release(): string;
+ export function uptime(): number;
+ export function loadavg(): number[];
+ export function totalmem(): number;
+ export function freemem(): number;
+ export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
+ export function networkInterfaces(): any;
+ export var EOL: string;
+}
+
+declare module "https" {
+ import tls = module("tls");
+ import events = module("events");
+ import http = module("http");
+
+ export interface ServerOptions {
+ pfx?: any;
+ key?: any;
+ passphrase?: string;
+ cert?: any;
+ ca?: any;
+ crl?: any;
+ ciphers?: string;
+ honorCipherOrder?: bool;
+ requestCert?: bool;
+ rejectUnauthorized?: bool;
+ NPNProtocols?: any;
+ SNICallback?: (servername: string) => any;
+ }
+
+ export interface RequestOptions {
+ host?: string;
+ hostname?: string;
+ port?: number;
+ path?: string;
+ method?: string;
+ headers?: any;
+ auth?: string;
+ agent?: any;
+ pfx?: any;
+ key?: any;
+ passphrase?: string;
+ cert?: any;
+ ca?: any;
+ ciphers?: string;
+ rejectUnauthorized?: bool;
+ }
+
+ export interface NodeAgent {
+ maxSockets: number;
+ sockets: any;
+ requests: any;
+ }
+ export var Agent: {
+ new (options?: RequestOptions): NodeAgent;
+ };
+ export interface Server extends tls.Server { }
+ export function createServer(options: ServerOptions, requestListener?: Function): Server;
+ export function request(options: RequestOptions, callback?: (res: events.NodeEventEmitter) =>void ): http.ClientRequest;
+ export function get(options: RequestOptions, callback?: (res: events.NodeEventEmitter) =>void ): http.ClientRequest;
+ export var globalAgent: NodeAgent;
+}
+
+declare module "punycode" {
+ export function decode(string: string): string;
+ export function encode(string: string): string;
+ export function toUnicode(domain: string): string;
+ export function toASCII(domain: string): string;
+ export var ucs2: ucs2;
+ interface ucs2 {
+ decode(string: string): string;
+ encode(codePoints: number[]): string;
+ }
+ export var version;
+}
+
+declare module "repl" {
+ import stream = module("stream");
+ import events = module("events");
+
+ export interface ReplOptions {
+ prompt?: string;
+ input?: stream.ReadableStream;
+ output?: stream.WritableStream;
+ terminal?: bool;
+ eval?: Function;
+ useColors?: bool;
+ useGlobal?: bool;
+ ignoreUndefined?: bool;
+ writer?: Function;
+ }
+ export function start(options: ReplOptions): events.NodeEventEmitter;
+}
+
+declare module "readline" {
+ import events = module("events");
+ import stream = module("stream");
+
+ export interface ReadLine extends events.NodeEventEmitter {
+ setPrompt(prompt: string, length: number): void;
+ prompt(preserveCursor?: bool): void;
+ question(query: string, callback: Function): void;
+ pause(): void;
+ resume(): void;
+ close(): void;
+ write(data: any, key?: any): void;
+ }
+ export interface ReadLineOptions {
+ input: stream.ReadableStream;
+ output: stream.WritableStream;
+ completer?: Function;
+ terminal?: bool;
+ }
+ export function createInterface(options: ReadLineOptions): ReadLine;
+}
+
+declare module "vm" {
+ export interface Context { }
+ export interface Script {
+ runInThisContext(): void;
+ runInNewContext(sandbox?: Context): void;
+ }
+ export function runInThisContext(code: string, filename?: string): void;
+ export function runInNewContext(code: string, sandbox?: Context, filename?: string): void;
+ export function runInContext(code: string, context: Context, filename?: string): void;
+ export function createContext(initSandbox?: Context): Context;
+ export function createScript(code: string, filename?: string): Script;
+}
+
+declare module "child_process" {
+ import events = module("events");
+ import stream = module("stream");
+
+ export interface ChildProcess extends events.NodeEventEmitter {
+ stdin: stream.WritableStream;
+ stdout: stream.ReadableStream;
+ stderr: stream.ReadableStream;
+ pid: number;
+ kill(signal?: string): void;
+ send(message: any, sendHandle: any): void;
+ disconnect(): void;
+ }
+
+ export function spawn(command: string, args?: string[], options?: {
+ cwd?: string;
+ stdio?: any;
+ custom?: any;
+ env?: any;
+ detached?: bool;
+ }): ChildProcess;
+ export function exec(command: string, options: {
+ cwd?: string;
+ stdio?: any;
+ customFds?: any;
+ env?: any;
+ encoding?: string;
+ timeout?: number;
+ maxBuffer?: number;
+ killSignal?: string;
+ }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+ export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+ export function execFile(file: string, args: string[], options: {
+ cwd?: string;
+ stdio?: any;
+ customFds?: any;
+ env?: any;
+ encoding?: string;
+ timeout?: number;
+ maxBuffer?: string;
+ killSignal?: string;
+ }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+ export function fork(modulePath: string, args?: string[], options?: {
+ cwd?: string;
+ env?: any;
+ encoding?: string;
+ }): ChildProcess;
+}
+
+declare module "url" {
+ export interface Url {
+ href: string;
+ protocol: string;
+ auth: string;
+ hostname: string;
+ port: string;
+ host: string;
+ pathname: string;
+ search: string;
+ query: string;
+ slashes: bool;
+ }
+
+ export function parse(urlStr: string, parseQueryString? , slashesDenoteHost? ): Url;
+ export function format(url: Url): string;
+ export function resolve(from: string, to: string): string;
+}
+
+declare module "dns" {
+ export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
+ export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
+ export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+ export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
+}
+
+declare module "net" {
+ import stream = module("stream");
+
+ export interface NodeSocket extends stream.ReadWriteStream {
+ // Extended base methods
+ write(str: string, encoding?: string, fd?: string): bool;
+ write(buffer: NodeBuffer): bool;
+
+ connect(port: number, host?: string, connectionListener?: Function): void;
+ connect(path: string, connectionListener?: Function): void;
+ bufferSize: number;
+ setEncoding(encoding?: string): void;
+ write(data: any, encoding?: string, callback?: Function): void;
+ end(data?: any, encoding?: string): void;
+ destroy(): void;
+ pause(): void;
+ resume(): void;
+ setTimeout(timeout: number, callback?: Function): void;
+ setNoDelay(noDelay?: bool): void;
+ setKeepAlive(enable?: bool, initialDelay?: number): void;
+ address(): { port: number; family: string; address: string; };
+ remoteAddress: string;
+ remotePort: number;
+ bytesRead: number;
+ bytesWritten: number;
+ }
+
+ export var Socket: {
+ new (options?: { fd?: string; type?: string; allowHalfOpen?: bool; }): NodeSocket;
+ };
+
+ export interface Server extends NodeSocket {
+ listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+ listen(path: string, listeningListener?: Function): void;
+ listen(handle: any, listeningListener?: Function): void;
+ close(callback?: Function): void;
+ address(): { port: number; family: string; address: string; };
+ maxConnections: number;
+ connections: number;
+ }
+ export function createServer(connectionListener?: (socket: NodeSocket) =>void ): Server;
+ export function createServer(options?: { allowHalfOpen?: bool; }, connectionListener?: (socket: NodeSocket) =>void ): Server;
+ export function connect(options: { allowHalfOpen?: bool; }, connectionListener?: Function): void;
+ export function connect(port: number, host?: string, connectionListener?: Function): void;
+ export function connect(path: string, connectionListener?: Function): void;
+ export function createConnection(options: { allowHalfOpen?: bool; }, connectionListener?: Function): void;
+ export function createConnection(port: number, host?: string, connectionListener?: Function): void;
+ export function createConnection(path: string, connectionListener?: Function): void;
+ export function isIP(input: string): number;
+ export function isIPv4(input: string): bool;
+ export function isIPv6(input: string): bool;
+}
+
+declare module "dgram" {
+ import events = module("events");
+
+ export function createSocket(type: string, callback?: Function): Socket;
+
+ interface Socket extends events.NodeEventEmitter {
+ send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
+ bind(port: number, address?: string): void;
+ close(): void;
+ address: { address: string; family: string; port: number; };
+ setBroadcast(flag: bool): void;
+ setMulticastTTL(ttl: number): void;
+ setMulticastLoopback(flag: bool): void;
+ addMembership(multicastAddress: string, multicastInterface?: string): void;
+ dropMembership(multicastAddress: string, multicastInterface?: string): void;
+ }
+}
+
+declare module "fs" {
+ import stream = module("stream");
+
+ interface Stats {
+ isFile(): bool;
+ isDirectory(): bool;
+ isBlockDevice(): bool;
+ isCharacterDevice(): bool;
+ isSymbolicLink(): bool;
+ isFIFO(): bool;
+ isSocket(): bool;
+ dev: number;
+ ino: number;
+ mode: number;
+ nlink: number;
+ uid: number;
+ gid: number;
+ rdev: number;
+ size: number;
+ blksize: number;
+ blocks: number;
+ atime: Date;
+ mtime: Date;
+ ctime: Date;
+ }
+
+ interface FSWatcher {
+ close(): void;
+ }
+
+ export interface ReadStream extends stream.ReadableStream { }
+ export interface WriteStream extends stream.WritableStream { }
+
+ export function rename(oldPath: string, newPath: string, callback?: Function): void;
+ export function renameSync(oldPath: string, newPath: string): void;
+ export function truncate(fd: string, len: number, callback?: Function): void;
+ export function truncateSync(fd: string, len: number): void;
+ export function chown(path: string, uid: number, gid: number, callback?: Function): void;
+ export function chownSync(path: string, uid: number, gid: number): void;
+ export function fchown(fd: string, uid: number, gid: number, callback?: Function): void;
+ export function fchownSync(fd: string, uid: number, gid: number): void;
+ export function lchown(path: string, uid: number, gid: number, callback?: Function): void;
+ export function lchownSync(path: string, uid: number, gid: number): void;
+ export function chmod(path: string, mode: string, callback?: Function): void;
+ export function chmodSync(path: string, mode: string): void;
+ export function fchmod(fd: string, mode: string, callback?: Function): void;
+ export function fchmodSync(fd: string, mode: string): void;
+ export function lchmod(path: string, mode: string, callback?: Function): void;
+ export function lchmodSync(path: string, mode: string): void;
+ export function stat(path: string, callback?: (err: Error, stats: Stats) =>any): Stats;
+ export function lstat(path: string, callback?: (err: Error, stats: Stats) =>any): Stats;
+ export function fstat(fd: string, callback?: (err: Error, stats: Stats) =>any): Stats;
+ export function statSync(path: string): Stats;
+ export function lstatSync(path: string): Stats;
+ export function fstatSync(fd: string): Stats;
+ export function link(srcpath: string, dstpath: string, callback?: Function): void;
+ export function linkSync(srcpath: string, dstpath: string): void;
+ export function symlink(srcpath: string, dstpath: string, type?: string, callback?: Function): void;
+ export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
+ export function readlink(path: string, callback?: (err: Error, linkString: string) =>any): void;
+ export function realpath(path: string, callback?: (err: Error, resolvedPath: string) =>any): void;
+ export function realpath(path: string, cache: string, callback: (err: Error, resolvedPath: string) =>any): void;
+ export function realpathSync(path: string, cache?: string): void;
+ export function unlink(path: string, callback?: Function): void;
+ export function unlinkSync(path: string): void;
+ export function rmdir(path: string, callback?: Function): void;
+ export function rmdirSync(path: string): void;
+ export function mkdir(path: string, mode?: string, callback?: Function): void;
+ export function mkdirSync(path: string, mode?: string): void;
+ export function readdir(path: string, callback?: (err: Error, files: string[]) => void): void;
+ export function readdirSync(path: string): string[];
+ export function close(fd: string, callback?: Function): void;
+ export function closeSync(fd: string): void;
+ export function open(path: string, flags: string, mode?: string, callback?: (err: Error, fd: string) =>any): void;
+ export function openSync(path: string, flags: string, mode?: string): void;
+ export function utimes(path: string, atime: number, mtime: number, callback?: Function): void;
+ export function utimesSync(path: string, atime: number, mtime: number): void;
+ export function futimes(fd: string, atime: number, mtime: number, callback?: Function): void;
+ export function futimesSync(fd: string, atime: number, mtime: number): void;
+ export function fsync(fd: string, callback?: Function): void;
+ export function fsyncSync(fd: string): void;
+ export function write(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, written: number, buffer: NodeBuffer) =>any): void;
+ export function writeSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): void;
+ export function read(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, bytesRead: number, buffer: NodeBuffer) => void): void;
+ export function readSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): any[];
+ export function readFile(filename: string, encoding: string, callback: (err: Error, data: string) => void ): void;
+ export function readFile(filename: string, callback: (err: Error, data: NodeBuffer) => void ): void;
+ export function readFileSync(filename: string): NodeBuffer;
+ export function readFileSync(filename: string, encoding: string): string;
+ export function writeFile(filename: string, data: any, callback?: (err) => void): void;
+ export function writeFile(filename: string, data: any, encoding?: string, callback?: (err) => void): void;
+ export function writeFileSync(filename: string, data: any, encoding?: string): void;
+ export function appendFile(filename: string, data: any, encoding?: string, callback?: Function): void;
+ export function appendFileSync(filename: string, data: any, encoding?: string): void;
+ export function watchFile(filename: string, listener: { curr: Stats; prev: Stats; }): void;
+ export function watchFile(filename: string, options: { persistent?: bool; interval?: number; }, listener: { curr: Stats; prev: Stats; }): void;
+ export function unwatchFile(filename: string, listener?: Stats): void;
+ export function watch(filename: string, options?: { persistent?: bool; }, listener?: (event: string, filename: string) =>any): FSWatcher;
+ export function exists(path: string, callback?: (exists: bool) =>void ): void;
+ export function existsSync(path: string): bool;
+ export function createReadStream(path: string, options?: {
+ flags?: string;
+ encoding?: string;
+ fd?: string;
+ mode?: number;
+ bufferSize?: number;
+ }): ReadStream;
+ export function createWriteStream(path: string, options?: {
+ flags?: string;
+ encoding?: string;
+ string?: string;
+ }): WriteStream;
+}
+
+declare module "path" {
+ export function normalize(p: string): string;
+ export function join(...paths: any[]): string;
+ export function resolve(from: string, to: string): string;
+ export function resolve(from: string, from2: string, to: string): string;
+ export function resolve(from: string, from2: string, from3: string, to: string): string;
+ export function resolve(from: string, from2: string, from3: string, from4: string, to: string): string;
+ export function resolve(from: string, from2: string, from3: string, from4: string, from5: string, to: string): string;
+ export function relative(from: string, to: string): string;
+ export function dirname(p: string): string;
+ export function basename(p: string, ext?: string): string;
+ export function extname(p: string): string;
+ export var sep: string;
+}
+
+declare module "string_decoder" {
+ export interface NodeStringDecoder {
+ write(buffer: NodeBuffer): string;
+ detectIncompleteChar(buffer: NodeBuffer): number;
+ }
+ export var StringDecoder: {
+ new (encoding: string): NodeStringDecoder;
+ };
+}
+
+declare module "tls" {
+ import crypto = module("crypto");
+ import net = module("net");
+ import stream = module("stream");
+
+ var CLIENT_RENEG_LIMIT: number;
+ var CLIENT_RENEG_WINDOW: number;
+
+ export interface TlsOptions {
+ pfx?: any; //string or buffer
+ key?: any; //string or buffer
+ passphrase?: string;
+ cert?: any;
+ ca?: any; //string or buffer
+ crl?: any; //string or string array
+ ciphers?: string;
+ honorCipherOrder?: any;
+ requestCert?: bool;
+ rejectUnauthorized?: bool;
+ NPNProtocols?: any; //array or Buffer;
+ SNICallback?: (servername: string) => any;
+ }
+
+ export interface ConnectionOptions {
+ host?: string;
+ port?: number;
+ socket?: net.NodeSocket;
+ pfx?: any; //string | Buffer
+ key?: any; //string | Buffer
+ passphrase?: string;
+ cert?: any; //string | Buffer
+ ca?: any; //Array of string | Buffer
+ rejectUnauthorized?: bool;
+ NPNProtocols?: any; //Array of string | Buffer
+ servername?: string;
+ }
+
+ export interface Server extends net.Server {
+ // Extended base methods
+ listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+ listen(path: string, listeningListener?: Function): void;
+ listen(handle: any, listeningListener?: Function): void;
+
+ listen(port: number, host?: string, callback?: Function): void;
+ close(): void;
+ address(): { port: number; family: string; address: string; };
+ addContext(hostName: string, credentials: {
+ key: string;
+ cert: string;
+ ca: string;
+ }): void;
+ maxConnections: number;
+ connections: number;
+ }
+
+ export interface ClearTextStream extends stream.ReadWriteStream {
+ authorized: bool;
+ authorizationError: Error;
+ getPeerCertificate(): any;
+ getCipher: {
+ name: string;
+ version: string;
+ };
+ address: {
+ port: number;
+ family: string;
+ address: string;
+ };
+ remoteAddress: string;
+ remotePort: number;
+ }
+
+ export interface SecurePair {
+ encrypted: any;
+ cleartext: any;
+ }
+
+ export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
+ export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
+ export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+ export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+ export function createSecurePair(credentials?: crypto.Credentials, isServer?: bool, requestCert?: bool, rejectUnauthorized?: bool): SecurePair;
+}
+
+declare module "crypto" {
+ export interface CredentialDetails {
+ pfx: string;
+ key: string;
+ passphrase: string;
+ cert: string;
+ ca: any; //string | string array
+ crl: any; //string | string array
+ ciphers: string;
+ }
+ export interface Credentials { context?: any; }
+ export function createCredentials(details: CredentialDetails): Credentials;
+ export function createHash(algorithm: string): Hash;
+ export function createHmac(algorithm: string, key: string): Hmac;
+ interface Hash {
+ update(data: any, input_encoding?: string): void;
+ digest(encoding?: string): string;
+ }
+ interface Hmac {
+ update(data: any): void;
+ digest(encoding?: string): void;
+ }
+ export function createCipher(algorithm: string, password: any): Cipher;
+ export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;
+ interface Cipher {
+ update(data: any, input_encoding?: string, output_encoding?: string): string;
+ final(output_encoding?: string): string;
+ setAutoPadding(auto_padding: bool): void;
+ createDecipher(algorithm: string, password: any): Decipher;
+ createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
+ }
+ interface Decipher {
+ update(data: any, input_encoding?: string, output_encoding?: string): void;
+ final(output_encoding?: string): string;
+ setAutoPadding(auto_padding: bool): void;
+ }
+ export function createSign(algorithm: string): Signer;
+ interface Signer {
+ update(data: any): void;
+ sign(private_key: string, output_format: string): string;
+ }
+ export function createVerify(algorith: string): Verify;
+ interface Verify {
+ update(data: any): void;
+ verify(object: string, signature: string, signature_format?: string): bool;
+ }
+ export function createDiffieHellman(prime_length: number): DiffieHellman;
+ export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman;
+ interface DiffieHellman {
+ generateKeys(encoding?: string): string;
+ computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
+ getPrime(encoding?: string): string;
+ getGenerator(encoding: string): string;
+ getPublicKey(encoding?: string): string;
+ getPrivateKey(encoding?: string): string;
+ setPublicKey(public_key: string, encoding?: string): void;
+ setPrivateKey(public_key: string, encoding?: string): void;
+ }
+ export function getDiffieHellman(group_name: string): DiffieHellman;
+ export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
+ export function randomBytes(size: number, callback?: (err: Error, buf: NodeBuffer) =>void );
+}
+
+declare module "stream" {
+ import events = module("events");
+
+ export interface WritableStream extends events.NodeEventEmitter {
+ writable: bool;
+ write(str: string, encoding?: string, fd?: string): bool;
+ write(buffer: NodeBuffer): bool;
+ end(): void;
+ end(str: string, enconding: string): void;
+ end(buffer: NodeBuffer): void;
+ destroy(): void;
+ destroySoon(): void;
+ }
+
+ export interface ReadableStream extends events.NodeEventEmitter {
+ readable: bool;
+ setEncoding(encoding: string): void;
+ pause(): void;
+ resume(): void;
+ destroy(): void;
+ pipe(destination: WritableStream, options?: { end?: bool; }): void;
+ }
+
+ export interface ReadWriteStream extends ReadableStream, WritableStream { }
+}
+
+declare module "util" {
+ export function format(format: any, ...param: any[]): string;
+ export function debug(string: string): void;
+ export function error(...param: any[]): void;
+ export function puts(...param: any[]): void;
+ export function print(...param: any[]): void;
+ export function log(string: string): void;
+ export function inspect(object: any, showHidden?: bool, depth?: number, color?: bool): void;
+ export function isArray(object: any): bool;
+ export function isRegExp(object: any): bool;
+ export function isDate(object: any): bool;
+ export function isError(object: any): bool;
+ export function inherits(constructor: any, superConstructor: any): void;
+}
+
+declare module "assert" {
+ export function (booleanValue: bool, message?: string);
+ export function fail(actual: any, expected: any, message: string, operator: string): void;
+ export function assert(value: any, message: string): void;
+ export function ok(value: any, message?: string): void;
+ export function equal(actual: any, expected: any, message?: string): void;
+ export function notEqual(actual: any, expected: any, message?: string): void;
+ export function deepEqual(actual: any, expected: any, message?: string): void;
+ export function notDeepEqual(acutal: any, expected: any, message?: string): void;
+ export function strictEqual(actual: any, expected: any, message?: string): void;
+ export function notStrictEqual(actual: any, expected: any, message?: string): void;
+ export function throws(block: any, error?: any, messsage?: string): void;
+ export function doesNotThrow(block: any, error?: any, messsage?: string): void;
+ export function ifError(value: any): void;
+}
+
+declare module "tty" {
+ import net = module("net");
+
+ export function isatty(fd: string): bool;
+ export interface ReadStream extends net.NodeSocket {
+ isRaw: bool;
+ setRawMode(mode: bool): void;
+ }
+ export interface WriteStream extends net.NodeSocket {
+ columns: number;
+ rows: number;
+ }
+}
+
+declare module "domain" {
+ import events = module("events");
+
+ export interface Domain extends events.NodeEventEmitter { }
+
+ export function create(): Domain;
+ export function run(fn: Function): void;
+ export function add(emitter: events.NodeEventEmitter): void;
+ export function remove(emitter: events.NodeEventEmitter): void;
+ export function bind(cb: (er: Error, data: any) =>any): any;
+ export function intercept(cb: (data: any) => any): any;
+ export function dispose(): void;
+}
diff --git a/node/node-tests.ts b/node/node-tests.ts
new file mode 100644
index 000000000..00e08b006
--- /dev/null
+++ b/node/node-tests.ts
@@ -0,0 +1,30 @@
+///
+
+import assert = module("assert");
+import fs = module("fs");
+
+assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
+
+assert.deepEqual({ x: { y: 3 } }, { x: { y: 3 } }, "DEEP WENT DERP");
+
+assert.equal(3, "3", "uses == comparator");
+
+assert.notStrictEqual(2, "2", "uses === comparator");
+
+assert.throws(() => { throw "a hammer at your face"; }, undefined, "DODGED IT");
+
+assert.doesNotThrow(() => {
+ if (false) { throw "a hammer at your face"; }
+}, undefined, "What the...*crunch*");
+
+
+fs.writeFile("thebible.txt",
+ "Do unto others as you would have them do unto you.",
+ assert.ifError);
+
+fs.writeFile("Harry Potter",
+ "\"You be wizzing, Harry,\" jived Dumbledore.",
+ {
+ encoding: "ascii"
+ },
+ assert.ifError);
\ No newline at end of file
diff --git a/node/node.d.ts b/node/node.d.ts
index 7d0cf5fbc..10ba918c2 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -1,6 +1,6 @@
/************************************************
* *
-* Node.js v0.8.8 API *
+* Node.js v0.10.1 API *
* *
************************************************/
@@ -768,18 +768,20 @@ declare module "fs" {
export function futimesSync(fd: string, atime: number, mtime: number): void;
export function fsync(fd: string, callback?: Function): void;
export function fsyncSync(fd: string): void;
- export function write(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, written: number, buffer: NodeBuffer) =>any): void;
+ export function write(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err, written: number, buffer: NodeBuffer) =>any): void;
export function writeSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): void;
- export function read(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, bytesRead: number, buffer: NodeBuffer) => void): void;
+ export function read(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err, bytesRead: number, buffer: NodeBuffer) => void): void;
export function readSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): any[];
- export function readFile(filename: string, encoding: string, callback: (err: Error, data: string) => void ): void;
- export function readFile(filename: string, callback: (err: Error, data: NodeBuffer) => void ): void;
+ export function readFile(filename: string, options: { encoding?: string; flag?: string; }, callback: (err, data: any) => void ): void;
+ export function readFile(filename: string, callback: (err, data: NodeBuffer) => void ): void;
export function readFileSync(filename: string): NodeBuffer;
- export function readFileSync(filename: string, encoding: string): string;
- export function writeFile(filename: string, data: any, encoding?: string, callback?: Function): void;
- export function writeFileSync(filename: string, data: any, encoding?: string): void;
- export function appendFile(filename: string, data: any, encoding?: string, callback?: Function): void;
- export function appendFileSync(filename: string, data: any, encoding?: string): void;
+ export function readFileSync(filename: string, options: { encoding?: string; flag?: string; }): any;
+ export function writeFile(filename: string, data: any, callback?: (err) => void): void;
+ export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err) => void): void;
+ export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+ export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err) => void): void;
+ export function appendFile(filename: string, data: any, callback?: (err) => void): void;
+ export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
export function watchFile(filename: string, listener: { curr: Stats; prev: Stats; }): void;
export function watchFile(filename: string, options: { persistent?: bool; interval?: number; }, listener: { curr: Stats; prev: Stats; }): void;
export function unwatchFile(filename: string, listener?: Stats): void;
@@ -1014,6 +1016,7 @@ declare module "util" {
}
declare module "assert" {
+ export function (booleanValue: bool, message?: string);
export function fail(actual: any, expected: any, message: string, operator: string): void;
export function assert(value: any, message: string): void;
export function ok(value: any, message?: string): void;
@@ -1054,4 +1057,4 @@ declare module "domain" {
export function bind(cb: (er: Error, data: any) =>any): any;
export function intercept(cb: (data: any) => any): any;
export function dispose(): void;
-}
+}