Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/build/lib/typings/cgmanifest.json

@@ -0,0 +1,16 @@
+{
+	"registrations": [
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "definitelytyped",
+					"repositoryUrl": "https://github.com/DefinitelyTyped/DefinitelyTyped",
+					"commitHash": "69e3ac6bec3008271f76bbfa7cf69aa9198c4ff0"
+				}
+			},
+			"license": "MIT"
+		}
+	],
+	"version": 1
+}

lib/vscode/build/lib/typings/event-stream.d.ts

@@ -0,0 +1,27 @@
+declare module "event-stream" {
+	import { Stream } from 'stream';
+	import { ThroughStream as _ThroughStream } from 'through';
+	import * as File from 'vinyl';
+
+	export interface ThroughStream extends _ThroughStream {
+		queue(data: File | null): any;
+		push(data: File | null): any;
+		paused: boolean;
+	}
+
+	function merge(streams: Stream[]): ThroughStream;
+	function merge(...streams: Stream[]): ThroughStream;
+	function concat(...stream: Stream[]): ThroughStream;
+	function duplex(istream: Stream, ostream: Stream): ThroughStream;
+
+	function through(write?: (this: ThroughStream, data: any) => void, end?: (this: ThroughStream) => void,
+		opts?: { autoDestroy: boolean; }): ThroughStream;
+
+	function readArray<T>(array: T[]): ThroughStream;
+	function writeArray<T>(cb: (err: Error, array: T[]) => void): ThroughStream;
+
+	function mapSync<I, O>(cb: (data: I) => O): ThroughStream;
+	function map<I, O>(cb: (data: I, cb: (err?: Error, data?: O) => void) => O): ThroughStream;
+
+	function readable(asyncFunction: (this: ThroughStream, ...args: any[]) => any): any;
+}

lib/vscode/build/lib/typings/github-releases.d.ts

@@ -0,0 +1,3 @@
+declare module 'github-releases' {
+
+}

lib/vscode/build/lib/typings/gulp-bom.d.ts

@@ -0,0 +1,12 @@
+
+declare module "gulp-bom" {
+	function f(): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-cssnano.d.ts

@@ -0,0 +1,12 @@
+
+declare module "gulp-cssnano" {
+	function f(opts:{reduceIdents:boolean;}): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-flatmap.d.ts

@@ -0,0 +1,12 @@
+declare module 'gulp-flatmap' {
+	import File = require('vinyl');
+	function f(fn:(stream:NodeJS.ReadWriteStream, file:File)=>NodeJS.ReadWriteStream): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-remote-src.d.ts

@@ -0,0 +1,23 @@
+declare module 'gulp-remote-retry-src' {
+
+	import stream = require("stream");
+
+	function remote(url: string, options: remote.IOptions): stream.Stream;
+
+	module remote {
+		export interface IRequestOptions {
+			body?: any;
+			json?: boolean;
+			method?: string;
+			headers?: any;
+		}
+
+		export interface IOptions {
+			base?: string;
+			buffer?: boolean;
+			requestOptions?: IRequestOptions;
+		}
+	}
+
+	export = remote;
+}

lib/vscode/build/lib/typings/gulp-tsb.d.ts

@@ -0,0 +1,18 @@
+
+
+declare module "gulp-tsb" {
+
+	export interface ICancellationToken {
+		isCancellationRequested(): boolean;
+	}
+
+	export interface IncrementalCompiler {
+		(token?: ICancellationToken): NodeJS.ReadWriteStream;
+		src(opts?: {
+			cwd?: string;
+			base?: string;
+		}): NodeJS.ReadStream;
+	}
+	export function create(projectPath: string, existingOptions: any, verbose?: boolean, onError?: (message: any) => void): IncrementalCompiler;
+
+}

lib/vscode/build/lib/typings/is.d.ts

@@ -0,0 +1,11 @@
+declare module 'is' {
+	function a(value: any, type: string): boolean;
+	function defined(value: any): boolean;
+	function undef(value: any): boolean;
+	function object(value: any): boolean;
+	function string(value: any): value is string;
+	function boolean(value: any): boolean;
+	function array(value: any): boolean;
+	function empty<T>(value: Object | Array<T>): boolean;
+	function equal<T extends Object | Array<any> | Function | Date>(value: T, other: T): boolean;
+}

lib/vscode/build/lib/typings/lazy.js.d.ts

@@ -0,0 +1,276 @@
+// Type definitions for Lazy.js 0.3.2
+// Project: https://github.com/dtao/lazy.js/
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare function Lazy(value: string): Lazy.StringLikeSequence;
+declare function Lazy<T>(value: T[]): Lazy.ArrayLikeSequence<T>;
+declare function Lazy(value: any[]): Lazy.ArrayLikeSequence<any>;
+declare function Lazy<T>(value: Object): Lazy.ObjectLikeSequence<T>;
+declare function Lazy(value: Object): Lazy.ObjectLikeSequence<any>;
+
+declare module Lazy {
+	function strict(): StrictLazy;
+	function generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
+	function range(to: number): GeneratedSequence<number>;
+	function range(from: number, to: number, step?: number): GeneratedSequence<number>;
+	function repeat<T>(value: T, count?: number): GeneratedSequence<T>;
+	function on<T>(eventType: string): Sequence<T>;
+	function readFile(path: string): StringLikeSequence;
+	function makeHttpRequest(path: string): StringLikeSequence;
+
+	interface StrictLazy {
+		(value: string): StringLikeSequence;
+		<T>(value: T[]): ArrayLikeSequence<T>;
+		(value: any[]): ArrayLikeSequence<any>;
+		<T>(value: Object): ObjectLikeSequence<T>;
+		(value: Object): ObjectLikeSequence<any>;
+		strict(): StrictLazy;
+		generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
+		range(to: number): GeneratedSequence<number>;
+		range(from: number, to: number, step?: number): GeneratedSequence<number>;
+		repeat<T>(value: T, count?: number): GeneratedSequence<T>;
+		on<T>(eventType: string): Sequence<T>;
+		readFile(path: string): StringLikeSequence;
+		makeHttpRequest(path: string): StringLikeSequence;
+	}
+
+	interface ArrayLike<T> {
+		length: number;
+		[index: number]: T;
+	}
+
+	interface Callback {
+		(): void;
+	}
+
+	interface ErrorCallback {
+		(error: any): void;
+	}
+
+	interface ValueCallback<T> {
+		(value: T): void;
+	}
+
+	interface GetKeyCallback<T> {
+		(value: T): string;
+	}
+
+	interface TestCallback<T> {
+		(value: T): boolean;
+	}
+
+	interface MapCallback<T, U> {
+		(value: T): U;
+	}
+
+	interface MapStringCallback {
+		(value: string): string;
+	}
+
+	interface NumberCallback<T> {
+		(value: T): number;
+	}
+
+	interface MemoCallback<T, U> {
+		(memo: U, value: T): U;
+	}
+
+	interface GeneratorCallback<T> {
+		(index: number): T;
+	}
+
+	interface CompareCallback {
+		(x: any, y: any): number;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	interface Iterator<T> {
+		new(sequence: Sequence<T>): Iterator<T>;
+		current(): T;
+		moveNext(): boolean;
+	}
+
+	interface GeneratedSequence<T> extends Sequence<T> {
+		new(generatorFn: GeneratorCallback<T>, length: number): GeneratedSequence<T>;
+		length(): number;
+	}
+
+	interface AsyncSequence<T> extends SequenceBase<T> {
+		each(callback: ValueCallback<T>): AsyncHandle<T>;
+	}
+
+	interface AsyncHandle<T> {
+		cancel(): void;
+		onComplete(callback: Callback): void;
+		onError(callback: ErrorCallback): void;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module Sequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface Sequence<T> extends SequenceBase<T> {
+		each(eachFn: ValueCallback<T>): Sequence<T>;
+	}
+
+	interface ArraySequence<T> extends SequenceBase<T[]> {
+		flatten(): Sequence<T>;
+	}
+
+	interface SequenceBase<T> extends SequenceBaser<T> {
+		first(): any;
+		first(count: number): Sequence<T>;
+		indexOf(value: any, startIndex?: number): Sequence<T>;
+
+		last(): any;
+		last(count: number): Sequence<T>;
+		lastIndexOf(value: any): Sequence<T>;
+
+		reverse(): Sequence<T>;
+	}
+
+	interface SequenceBaser<T> {
+		// TODO improve define() (needs ugly overload)
+		async(interval: number): AsyncSequence<T>;
+		chunk(size: number): Sequence<T>;
+		compact(): Sequence<T>;
+		concat(var_args: T[]): Sequence<T>;
+		concat(sequence: Sequence<T>): Sequence<T>;
+		consecutive(length: number): Sequence<T>;
+		contains(value: T): boolean;
+		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		countBy(propertyName: string): ObjectLikeSequence<T>;
+		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		every(predicateFn: TestCallback<T>): boolean;
+		filter(predicateFn: TestCallback<T>): Sequence<T>;
+		find(predicateFn: TestCallback<T>): Sequence<T>;
+		findWhere(properties: Object): Sequence<T>;
+
+		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		initial(count?: number): Sequence<T>;
+		intersection(var_args: T[]): Sequence<T>;
+		invoke(methodName: string): Sequence<T>;
+		isEmpty(): boolean;
+		join(delimiter?: string): string;
+		map<U>(mapFn: MapCallback<T, U[]>): ArraySequence<U>;
+		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
+
+		// TODO: vscode addition to workaround strict null errors
+		flatten(): Sequence<any>;
+
+		max(valueFn?: NumberCallback<T>): T;
+		min(valueFn?: NumberCallback<T>): T;
+		none(valueFn?: TestCallback<T>): boolean;
+		pluck(propertyName: string): Sequence<T>;
+		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+		reject(predicateFn: TestCallback<T>): Sequence<T>;
+		rest(count?: number): Sequence<T>;
+		shuffle(): Sequence<T>;
+		some(predicateFn?: TestCallback<T>): boolean;
+		sort(sortFn?: CompareCallback, descending?: boolean): Sequence<T>;
+		sortBy(sortFn: string, descending?: boolean): Sequence<T>;
+		sortBy(sortFn: NumberCallback<T>, descending?: boolean): Sequence<T>;
+		sortedIndex(value: T): Sequence<T>;
+		size(): number;
+		sum(valueFn?: NumberCallback<T>): Sequence<T>;
+		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		union(var_args: T[]): Sequence<T>;
+		uniq(): Sequence<T>;
+		where(properties: Object): Sequence<T>;
+		without(...var_args: T[]): Sequence<T>;
+		without(var_args: T[]): Sequence<T>;
+		zip(var_args: T[]): ArraySequence<T>;
+
+		toArray(): T[];
+		toObject(): Object;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module ArrayLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface ArrayLikeSequence<T> extends Sequence<T> {
+		// define()X;
+		concat(var_args: T[]): ArrayLikeSequence<T>;
+		concat(sequence: Sequence<T>): Sequence<T>;
+		first(count?: number): ArrayLikeSequence<T>;
+		get(index: number): T;
+		length(): number;
+		map<U>(mapFn: MapCallback<T, U[]>): ArraySequence<U>;
+		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+		pop(): ArrayLikeSequence<T>;
+		rest(count?: number): ArrayLikeSequence<T>;
+		reverse(): ArrayLikeSequence<T>;
+		shift(): ArrayLikeSequence<T>;
+		slice(begin: number, end?: number): ArrayLikeSequence<T>;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module ObjectLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface ObjectLikeSequence<T> extends Sequence<T> {
+		assign(other: Object): ObjectLikeSequence<T>;
+		// throws error
+		//async(): X;
+		defaults(defaults: Object): ObjectLikeSequence<T>;
+		functions(): Sequence<T>;
+		get(property: string): ObjectLikeSequence<T>;
+		invert(): ObjectLikeSequence<T>;
+		keys(): Sequence<string>;
+		omit(properties: string[]): ObjectLikeSequence<T>;
+		pairs(): Sequence<T>;
+		pick(properties: string[]): ObjectLikeSequence<T>;
+		toArray(): T[];
+		toObject(): Object;
+		values(): Sequence<T>;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module StringLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface StringLikeSequence extends SequenceBaser<string> {
+		charAt(index: number): string;
+		charCodeAt(index: number): number;
+		contains(value: string): boolean;
+		endsWith(suffix: string): boolean;
+
+		first(): string;
+		first(count: number): StringLikeSequence;
+
+		indexOf(substring: string, startIndex?: number): number;
+
+		last(): string;
+		last(count: number): StringLikeSequence;
+
+		lastIndexOf(substring: string, startIndex?: number): number;
+		mapString(mapFn: MapStringCallback): StringLikeSequence;
+		match(pattern: RegExp): StringLikeSequence;
+		reverse(): StringLikeSequence;
+
+		split(delimiter: string): StringLikeSequence;
+		split(delimiter: RegExp): StringLikeSequence;
+
+		startsWith(prefix: string): boolean;
+		substring(start: number, stop?: number): StringLikeSequence;
+		toLowerCase(): StringLikeSequence;
+		toUpperCase(): StringLikeSequence;
+	}
+}
+
+declare module 'lazy.js' {
+	export = Lazy;
+}
+

lib/vscode/build/lib/typings/vinyl.d.ts

@@ -0,0 +1,112 @@
+// Type definitions for vinyl 0.4.3
+// Project: https://github.com/wearefractal/vinyl
+// Definitions by: vvakame <https://github.com/vvakame/>, jedmao <https://github.com/jedmao>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "vinyl" {
+
+	import fs = require("fs");
+
+	/**
+	 * A virtual file format.
+	 */
+	class File {
+		constructor(options?: {
+			/**
+			* Default: process.cwd()
+			*/
+			cwd?: string;
+			/**
+			 * Used for relative pathing. Typically where a glob starts.
+			 */
+			base?: string;
+			/**
+			 * Full path to the file.
+			 */
+			path?: string;
+			/**
+			 * Path history. Has no effect if options.path is passed.
+			 */
+			history?: string[];
+			/**
+			 * The result of an fs.stat call. See fs.Stats for more information.
+			 */
+			stat?: fs.Stats;
+			/**
+			 * File contents.
+			 * Type: Buffer, Stream, or null
+			 */
+			contents?: Buffer | NodeJS.ReadWriteStream;
+		});
+
+		/**
+		 * Default: process.cwd()
+		 */
+		public cwd: string;
+		/**
+		 * Used for relative pathing. Typically where a glob starts.
+		 */
+		public base: string;
+		/**
+		 * Full path to the file.
+		 */
+		public path: string;
+		public stat: fs.Stats;
+		/**
+		 * Type: Buffer|Stream|null (Default: null)
+		 */
+		public contents: Buffer | NodeJS.ReadableStream;
+		/**
+		 * Returns path.relative for the file base and file path.
+		 * Example:
+		 *  var file = new File({
+		 *    cwd: "/",
+		 *    base: "/test/",
+		 *    path: "/test/file.js"
+		 *  });
+		 *  console.log(file.relative); // file.js
+		 */
+		public relative: string;
+
+		public isBuffer(): boolean;
+
+		public isStream(): boolean;
+
+		public isNull(): boolean;
+
+		public isDirectory(): boolean;
+
+		/**
+		 * Returns a new File object with all attributes cloned. Custom attributes are deep-cloned.
+		 */
+		public clone(opts?: { contents?: boolean }): File;
+
+		/**
+		 * If file.contents is a Buffer, it will write it to the stream.
+		 * If file.contents is a Stream, it will pipe it to the stream.
+		 * If file.contents is null, it will do nothing.
+		 */
+		public pipe<T extends NodeJS.ReadWriteStream>(
+			stream: T,
+			opts?: {
+				/**
+				 * If false, the destination stream will not be ended (same as node core).
+				 */
+				end?: boolean;
+			}): T;
+
+		/**
+		 * Returns a pretty String interpretation of the File. Useful for console.log.
+		 */
+		public inspect(): string;
+	}
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace File {}
+
+	export = File;
+
+}