lmcarreiro

    export function getSyntaxKindName(kind: SyntaxKind): string
    {
        const markers: { [name: string]: string } = {
            FirstAssignment         : "EqualsToken",
            LastAssignment          : "CaretEqualsToken",
            FirstCompoundAssignment : "PlusEqualsToken",
            LastCompoundAssignment  : "CaretEqualsToken",
            FirstReservedWord       : "BreakKeyword",
            LastReservedWord        : "WithKeyword",

lmcarreiro

const columns = [
  { name: 'id'     , index: 'id'               , width: 55                   },
  { name: 'invdate', index: 'invdate'          , width: 90                   },
  { name: 'name'   , index: 'name asc, invdate', width: 100                  },
  { name: 'amount' , index: 'amount'           , width: 80 , align: "right"  },
  { name: 'tax'    , index: 'tax'              , width: 80 , align: "right"  },
  { name: 'total'  , index: 'total'            , width: 80 , align: "right"  },
  { name: 'note'   , index: 'note'             , width: 150, sortable: false }
];

lmcarreiro

const columns = [
  { name: 'id', index: 'id', width: 55 },
  { name: 'invdate', index: 'invdate', width: 90 },
  { name: 'name', index: 'name asc, invdate', width: 100 },
  { name: 'amount', index: 'amount', width: 80, align: "right" },
  { name: 'tax', index: 'tax', width: 80, align: "right" },
  { name: 'total', index: 'total', width: 80, align: "right" },
  { name: 'note', index: 'note', width: 150, sortable: false }
];

lmcarreiro

const columns = [
  {
    name: 'id',
    index: 'id',
    width: 55
  },
  {
    name: 'invdate',
    index: 'invdate',
    width: 90

lmcarreiro

import { Schemas } from 'vs/base/common/network';
import { IProcessEnvironment , isMacintosh } from 'vs/base/common/platform';
import { TPromise } from 'vs/base/common/winjs.base';
import { whenDeleted } from 'vs/base/node/pfs';
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { ParsedArgs , IEnvironmentService } from 'vs/platform/environment/common/environment';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { ILogService } from 'vs/platform/log/common/log';
import { IURLService } from 'vs/platform/url/common/url';

lmcarreiro

import { Schemas                                      } from 'vs/base/common/network'                         ;
import { IProcessEnvironment    , isMacintosh         } from 'vs/base/common/platform'                        ;
import { TPromise                                     } from 'vs/base/common/winjs.base'                      ;
import { whenDeleted                                  } from 'vs/base/node/pfs'                               ;
import { IChannel                                     } from 'vs/base/parts/ipc/common/ipc'                   ;
import { IConfigurationService                        } from 'vs/platform/configuration/common/configuration' ;
import { ParsedArgs             , IEnvironmentService } from 'vs/platform/environment/common/environment'     ;
import { createDecorator                              } from 'vs/platform/instantiation/common/instantiation' ;
import { ILogService                                  } from 'vs/platform/log/common/log'                     ;
import { IURLSer

lmcarreiro

/**
 * Filters an array by a predicate function. Returns the same array instance if the predicate is
 * true for all elements, otherwise returns a new array instance containing the filtered subset.
 */
export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];
export function filter<T>(array: T[], f: (x: T) => boolean): T[];
export function filter<T, U extends T>(array: ReadonlyArray<T>, f: (x: T) => x is U): ReadonlyArray<U>;
export function filter<T, U extends T>(array: ReadonlyArray<T>, f: (x: T) => boolean): ReadonlyArray<T>;
export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
    if (array) {

lmcarreiro

/**
 * Filters an array by a predicate function. Returns the same array instance if the predicate is
 * true for all elements, otherwise returns a new array instance containing the filtered subset.
 */
export function filter<T, U extends T>(array:               T[], f: (x: T) => x is U ): U[];
export function filter<T             >(array:               T[], f: (x: T) => boolean): T[];
export function filter<T, U extends T>(array: ReadonlyArray<T> , f: (x: T) => x is U ): ReadonlyArray<U>;
export function filter<T, U extends T>(array: ReadonlyArray<T> , f: (x: T) => boolean): ReadonlyArray<T>;
export function filter<T             >(array:               T[], f: (x: T) => boolean): T[] {
    if (array) {

lmcarreiro

function Node(this: Node, kind: SyntaxKind, pos: number, end: number) {
    this.pos = pos;
    this.end = end;
    this.kind = kind;
    this.id = 0;
    this.flags = NodeFlags.None;
    this.modifierFlagsCache = ModifierFlags.None;
    this.transformFlags = TransformFlags.None;
    this.parent = undefined;
    this.original = undefined;

lmcarreiro

export function filter<T, U extends T>(
    array: T[],
    f: (x: T) => x is U
  ) : U[];
export function filter<T>(
    array: T[],
    f: (x: T) => boolean
  ) : T[];
export function filter<T, U extends T>(
    array: ReadonlyArray<T>,