=== tests/cases/conformance/parser/ecmascript5/RealWorld/parserindenter.ts ===
//
// Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

///<reference path='formatting.ts' />


module Formatting {
>Formatting : typeof Formatting

    export class Indenter implements ILineIndenationResolver  {
>Indenter : Indenter

        private indentationBag: IndentationBag;
>indentationBag : any

        private scriptBlockBeginLineNumber: number;
>scriptBlockBeginLineNumber : number

        private offsetIndentationDeltas: Dictionary_int_int;
>offsetIndentationDeltas : any

        constructor(
            public logger: TypeScript.ILogger,
>logger : any
>TypeScript : any

            public tree: ParseTree,
>tree : any

            public snapshot: ITextSnapshot,
>snapshot : any

            public languageHostIndentation: string,
>languageHostIndentation : string

            public editorOptions: Services.EditorOptions,
>editorOptions : any
>Services : any

            public firstToken: TokenSpan,
>firstToken : any

            public smartIndent: boolean) {
>smartIndent : boolean

            this.indentationBag = new IndentationBag(this.snapshot);
>this.indentationBag = new IndentationBag(this.snapshot) : any
>this.indentationBag : any
>this : this
>indentationBag : any
>new IndentationBag(this.snapshot) : any
>IndentationBag : any
>this.snapshot : any
>this : this
>snapshot : any

            this.scriptBlockBeginLineNumber = -1;
>this.scriptBlockBeginLineNumber = -1 : -1
>this.scriptBlockBeginLineNumber : number
>this : this
>scriptBlockBeginLineNumber : number
>-1 : -1
>1 : 1

            this.offsetIndentationDeltas = new Dictionary_int_int();     // text offset -> indentation delta
>this.offsetIndentationDeltas = new Dictionary_int_int() : any
>this.offsetIndentationDeltas : any
>this : this
>offsetIndentationDeltas : any
>new Dictionary_int_int() : any
>Dictionary_int_int : any

            // by default the root (program) has zero indendation
            this.tree.Root.SetIndentationOverride("");
>this.tree.Root.SetIndentationOverride("") : any
>this.tree.Root.SetIndentationOverride : any
>this.tree.Root : any
>this.tree : any
>this : this
>tree : any
>Root : any
>SetIndentationOverride : any
>"" : ""

            this.ApplyScriptBlockIndentation(this.languageHostIndentation, this.tree);
>this.ApplyScriptBlockIndentation(this.languageHostIndentation, this.tree) : void
>this.ApplyScriptBlockIndentation : (languageHostIndentation: string, tree: any) => void
>this : this
>ApplyScriptBlockIndentation : (languageHostIndentation: string, tree: any) => void
>this.languageHostIndentation : string
>this : this
>languageHostIndentation : string
>this.tree : any
>this : this
>tree : any

            this.FillInheritedIndentation(this.tree);
>this.FillInheritedIndentation(this.tree) : void
>this.FillInheritedIndentation : (tree: any) => void
>this : this
>FillInheritedIndentation : (tree: any) => void
>this.tree : any
>this : this
>tree : any

        }

        public GetIndentationEdits(token: TokenSpan, nextToken: TokenSpan, node: ParseNode, sameLineIndent: boolean): List_TextEditInfo {
>GetIndentationEdits : (token: any, nextToken: any, node: any, sameLineIndent: boolean) => any
>token : any
>nextToken : any
>node : any
>sameLineIndent : boolean

            if (this.logger.information()) {
>this.logger.information() : any
>this.logger.information : any
>this.logger : any
>this : this
>logger : any
>information : any

                this.logger.log("GetIndentationEdits(" +
>this.logger.log("GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +                    "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" +                    ")") : any
>this.logger.log : any
>this.logger : any
>this : this
>logger : any
>log : any
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +                    "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" +                    ")" : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +                    "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +                    "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +                    "t2=[" : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition() : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() + "," : string
>"GetIndentationEdits(" +                    "t1=[" + token.Span.startPosition() : string
>"GetIndentationEdits(" +                    "t1=[" : string
>"GetIndentationEdits(" : "GetIndentationEdits("

                    "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition()+ "], " +
>"t1=[" : "t1=["
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>"," : ","
>token.Span.endPosition() : any
>token.Span.endPosition : any
>token.Span : any
>token : any
>Span : any
>endPosition : any
>"], " : "], "

                    "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" +
>"t2=[" : "t2=["
>(nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) : string
>nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition()) : string
>nextToken == null : boolean
>nextToken : any
>null : null
>"null" : "null"
>(nextToken.Span.startPosition() + "," + nextToken.Span.endPosition()) : string
>nextToken.Span.startPosition() + "," + nextToken.Span.endPosition() : string
>nextToken.Span.startPosition() + "," : string
>nextToken.Span.startPosition() : any
>nextToken.Span.startPosition : any
>nextToken.Span : any
>nextToken : any
>Span : any
>startPosition : any
>"," : ","
>nextToken.Span.endPosition() : any
>nextToken.Span.endPosition : any
>nextToken.Span : any
>nextToken : any
>Span : any
>endPosition : any
>"]" : "]"

                    ")");
>")" : ")"
            }

            var result = this.GetIndentationEditsWorker(token, nextToken, node, sameLineIndent);
>result : any
>this.GetIndentationEditsWorker(token, nextToken, node, sameLineIndent) : any
>this.GetIndentationEditsWorker : (token: any, nextToken: any, node: any, sameLineIndent: boolean) => any
>this : this
>GetIndentationEditsWorker : (token: any, nextToken: any, node: any, sameLineIndent: boolean) => any
>token : any
>nextToken : any
>node : any
>sameLineIndent : boolean

            if (this.logger.information()) {
>this.logger.information() : any
>this.logger.information : any
>this.logger : any
>this : this
>logger : any
>information : any

                for (var i = 0; i < result.count() ; i++) {
>i : number
>0 : 0
>i < result.count() : boolean
>i : number
>result.count() : any
>result.count : any
>result : any
>count : any
>i++ : number
>i : number

                    var edit = result.get(i);
>edit : any
>result.get(i) : any
>result.get : any
>result : any
>get : any
>i : number

                    this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
>this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"") : any
>this.logger.log : any
>this.logger : any
>this : this
>logger : any
>log : any
>"edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"" : string
>"edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) : string
>"edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" : string
>"edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) : string
>"edit: minChar=" + edit.position + ", limChar=" : string
>"edit: minChar=" + edit.position : string
>"edit: minChar=" : "edit: minChar="
>edit.position : any
>edit : any
>position : any
>", limChar=" : ", limChar="
>(edit.position + edit.length) : any
>edit.position + edit.length : any
>edit.position : any
>edit : any
>position : any
>edit.length : any
>edit : any
>length : any
>", text=\"" : ", text=\""
>TypeScript.stringToLiteral(edit.replaceWith, 30) : any
>TypeScript.stringToLiteral : any
>TypeScript : any
>stringToLiteral : any
>edit.replaceWith : any
>edit : any
>replaceWith : any
>30 : 30
>"\"" : "\""
                }
            }

            return result;
>result : any
        }

        public GetIndentationEditsWorker(token: TokenSpan, nextToken: TokenSpan, node: ParseNode, sameLineIndent: boolean): List_TextEditInfo {
>GetIndentationEditsWorker : (token: any, nextToken: any, node: any, sameLineIndent: boolean) => any
>token : any
>nextToken : any
>node : any
>sameLineIndent : boolean

            var result = new List_TextEditInfo();
>result : any
>new List_TextEditInfo() : any
>List_TextEditInfo : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            // This handles the case:
            //      return (
            //              function() {
            //              })
            // The given function's node indicates that the function starts directly after "return (".
            // In this case, we adjust the span to point to the function keyword.
            // The same applies to objects and arrays.
            // The reason this is done inside the Indenter is because it only affects indentation behavior.
            // It's also done in ParseTree when we traverse up the tree because we don't have the 
            // tokens for nodes outside the span we are formatting.
            this.AdjustStartOffsetIfNeeded(token, node);
>this.AdjustStartOffsetIfNeeded(token, node) : void
>this.AdjustStartOffsetIfNeeded : (token: any, node: any) => void
>this : this
>AdjustStartOffsetIfNeeded : (token: any, node: any) => void
>token : any
>node : any

            // Don't adjust indentation on the same line of a script block
            if (this.scriptBlockBeginLineNumber == token.lineNumber()) {
>this.scriptBlockBeginLineNumber == token.lineNumber() : boolean
>this.scriptBlockBeginLineNumber : number
>this : this
>scriptBlockBeginLineNumber : number
>token.lineNumber() : any
>token.lineNumber : any
>token : any
>lineNumber : any

                return result;
>result : any
            }

            // Don't indent multi-line strings
            if (!sameLineIndent && this.IsMultiLineString(token)) {
>!sameLineIndent && this.IsMultiLineString(token) : boolean
>!sameLineIndent : boolean
>sameLineIndent : boolean
>this.IsMultiLineString(token) : boolean
>this.IsMultiLineString : (token: any) => boolean
>this : this
>IsMultiLineString : (token: any) => boolean
>token : any

                return result;
>result : any
            }

            // Special cases for the tokens that don't show up in the tree, such as curly braces and comments
            indentationInfo = this.GetSpecialCaseIndentation(token, node);
>indentationInfo = this.GetSpecialCaseIndentation(token, node) : any
>indentationInfo : any
>this.GetSpecialCaseIndentation(token, node) : any
>this.GetSpecialCaseIndentation : (token: any, node: any) => any
>this : this
>GetSpecialCaseIndentation : (token: any, node: any) => any
>token : any
>node : any

            if (indentationInfo == null) {
>indentationInfo == null : boolean
>indentationInfo : any
>null : null

                //// For anything else

                // Get the indentation level only from the node that starts on the same offset as the token
                // otherwise the token is not meant to be indented
                while (!node.CanIndent() && node.Parent != null && token.Span.span.start() == node.Parent.AuthorNode.Details.StartOffset)
>!node.CanIndent() && node.Parent != null && token.Span.span.start() == node.Parent.AuthorNode.Details.StartOffset : boolean
>!node.CanIndent() && node.Parent != null : boolean
>!node.CanIndent() : boolean
>node.CanIndent() : any
>node.CanIndent : any
>node : any
>CanIndent : any
>node.Parent != null : boolean
>node.Parent : any
>node : any
>Parent : any
>null : null
>token.Span.span.start() == node.Parent.AuthorNode.Details.StartOffset : boolean
>token.Span.span.start() : any
>token.Span.span.start : any
>token.Span.span : any
>token.Span : any
>token : any
>Span : any
>span : any
>start : any
>node.Parent.AuthorNode.Details.StartOffset : any
>node.Parent.AuthorNode.Details : any
>node.Parent.AuthorNode : any
>node.Parent : any
>node : any
>Parent : any
>AuthorNode : any
>Details : any
>StartOffset : any

                    node = node.Parent;
>node = node.Parent : any
>node : any
>node.Parent : any
>node : any
>Parent : any

                if (node.CanIndent() && token.Span.span.start() == node.AuthorNode.Details.StartOffset) {
>node.CanIndent() && token.Span.span.start() == node.AuthorNode.Details.StartOffset : boolean
>node.CanIndent() : any
>node.CanIndent : any
>node : any
>CanIndent : any
>token.Span.span.start() == node.AuthorNode.Details.StartOffset : boolean
>token.Span.span.start() : any
>token.Span.span.start : any
>token.Span.span : any
>token.Span : any
>token : any
>Span : any
>span : any
>start : any
>node.AuthorNode.Details.StartOffset : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>StartOffset : any

                    indentationInfo = node.GetEffectiveIndentation(this);
>indentationInfo = node.GetEffectiveIndentation(this) : any
>indentationInfo : any
>node.GetEffectiveIndentation(this) : any
>node.GetEffectiveIndentation : any
>node : any
>GetEffectiveIndentation : any
>this : this
                }
                else {
                    //// Special cases for anything else that is not in the tree and should be indented

                    // check for label (identifier followed by a colon)
                    if (token.Token == AuthorTokenKind.atkIdentifier && nextToken != null && nextToken.Token == AuthorTokenKind.atkColon) {
>token.Token == AuthorTokenKind.atkIdentifier && nextToken != null && nextToken.Token == AuthorTokenKind.atkColon : boolean
>token.Token == AuthorTokenKind.atkIdentifier && nextToken != null : boolean
>token.Token == AuthorTokenKind.atkIdentifier : boolean
>token.Token : any
>token : any
>Token : any
>AuthorTokenKind.atkIdentifier : any
>AuthorTokenKind : any
>atkIdentifier : any
>nextToken != null : boolean
>nextToken : any
>null : null
>nextToken.Token == AuthorTokenKind.atkColon : boolean
>nextToken.Token : any
>nextToken : any
>Token : any
>AuthorTokenKind.atkColon : any
>AuthorTokenKind : any
>atkColon : any

                        // This will make the label on the same level as the surrounding function/block
                        // ex: 
                        // {
                        //      statement;
                        //      label:
                        //          statement;
                        // }
                        indentationInfo = node.GetEffectiveChildrenIndentation(this);
>indentationInfo = node.GetEffectiveChildrenIndentation(this) : any
>indentationInfo : any
>node.GetEffectiveChildrenIndentation(this) : any
>node.GetEffectiveChildrenIndentation : any
>node : any
>GetEffectiveChildrenIndentation : any
>this : this
                    }
                    else {
                        //// Move the token the same indentation-delta that moved its indentable parent
                        //// For example:
                        ////    var a,
                        ////        b;
                        //// The declaration 'b' would remain under 'a' even if 'var' got indented.
                        indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
>indentationInfo = this.ApplyIndentationDeltaFromParent(token, node) : any
>indentationInfo : any
>this.ApplyIndentationDeltaFromParent(token, node) : any
>this.ApplyIndentationDeltaFromParent : (token: any, node: any) => any
>this : this
>ApplyIndentationDeltaFromParent : (token: any, node: any) => any
>token : any
>node : any
                    }
                }
            }

            // Get the indent edit from the indentation info
            if (indentationInfo != null) {
>indentationInfo != null : boolean
>indentationInfo : any
>null : null

                var edit = this.GetIndentEdit(indentationInfo, token.Span.startPosition(), sameLineIndent);
>edit : any
>this.GetIndentEdit(indentationInfo, token.Span.startPosition(), sameLineIndent) : any
>this.GetIndentEdit : (indentInfo: any, tokenStartPosition: number, sameLineIndent: boolean) => any
>this : this
>GetIndentEdit : (indentInfo: any, tokenStartPosition: number, sameLineIndent: boolean) => any
>indentationInfo : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>sameLineIndent : boolean

                if (edit != null) {
>edit != null : boolean
>edit : any
>null : null

                    this.RegisterIndentation(edit, sameLineIndent);
>this.RegisterIndentation(edit, sameLineIndent) : void
>this.RegisterIndentation : (indent: any, sameLineIndent: boolean) => void
>this : this
>RegisterIndentation : (indent: any, sameLineIndent: boolean) => void
>edit : any
>sameLineIndent : boolean

                    result.add(edit);
>result.add(edit) : any
>result.add : any
>result : any
>add : any
>edit : any

                    // multi-line comments, apply delta indentation to all the other lines
                    if (token.Token == AuthorTokenKind.atkComment) {
>token.Token == AuthorTokenKind.atkComment : boolean
>token.Token : any
>token : any
>Token : any
>AuthorTokenKind.atkComment : any
>AuthorTokenKind : any
>atkComment : any

                        var commentEdits = this.GetCommentIndentationEdits(token);
>commentEdits : any
>this.GetCommentIndentationEdits(token) : any
>this.GetCommentIndentationEdits : (token: any) => any
>this : this
>GetCommentIndentationEdits : (token: any) => any
>token : any

                        commentEdits.foreach((item) => {
>commentEdits.foreach((item) => {                            result.add(item);                        }) : any
>commentEdits.foreach : any
>commentEdits : any
>foreach : any
>(item) => {                            result.add(item);                        } : (item: any) => void
>item : any

                            result.add(item);
>result.add(item) : any
>result.add : any
>result : any
>add : any
>item : any

                        });
                    }
                }
            }

            return result;
>result : any
        }

        private GetCommentIndentationEdits(token: TokenSpan): List_TextEditInfo {
>GetCommentIndentationEdits : (token: any) => any
>token : any

            var result = new List_TextEditInfo();
>result : any
>new List_TextEditInfo() : any
>List_TextEditInfo : any

            if (token.Token != AuthorTokenKind.atkComment)
>token.Token != AuthorTokenKind.atkComment : boolean
>token.Token : any
>token : any
>Token : any
>AuthorTokenKind.atkComment : any
>AuthorTokenKind : any
>atkComment : any

                return result;
>result : any

            var commentLastLineNumber = this.snapshot.GetLineNumberFromPosition(token.Span.endPosition());
>commentLastLineNumber : any
>this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>token.Span.endPosition() : any
>token.Span.endPosition : any
>token.Span : any
>token : any
>Span : any
>endPosition : any

            if (token.lineNumber() == commentLastLineNumber)
>token.lineNumber() == commentLastLineNumber : boolean
>token.lineNumber() : any
>token.lineNumber : any
>token : any
>lineNumber : any
>commentLastLineNumber : any

                return result;
>result : any

            var commentFirstLineIndentationDelta = this.GetIndentationDelta(token.Span.startPosition(), null);
>commentFirstLineIndentationDelta : number
>this.GetIndentationDelta(token.Span.startPosition(), null) : number
>this.GetIndentationDelta : (tokenStartPosition: number, childTokenStartPosition: number) => number
>this : this
>GetIndentationDelta : (tokenStartPosition: number, childTokenStartPosition: number) => number
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>null : null

            if (commentFirstLineIndentationDelta != undefined) {
>commentFirstLineIndentationDelta != undefined : boolean
>commentFirstLineIndentationDelta : number
>undefined : undefined

                for (var line = token.lineNumber() + 1; line <= commentLastLineNumber; line++) {
>line : any
>token.lineNumber() + 1 : any
>token.lineNumber() : any
>token.lineNumber : any
>token : any
>lineNumber : any
>1 : 1
>line <= commentLastLineNumber : boolean
>line : any
>commentLastLineNumber : any
>line++ : number
>line : any

                    var lineStartPosition = this.snapshot.GetLineFromLineNumber(line).startPosition();
>lineStartPosition : any
>this.snapshot.GetLineFromLineNumber(line).startPosition() : any
>this.snapshot.GetLineFromLineNumber(line).startPosition : any
>this.snapshot.GetLineFromLineNumber(line) : any
>this.snapshot.GetLineFromLineNumber : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromLineNumber : any
>line : any
>startPosition : any

                    var lineIndent = this.GetLineIndentationForOffset(lineStartPosition);
>lineIndent : string
>this.GetLineIndentationForOffset(lineStartPosition) : string
>this.GetLineIndentationForOffset : (offset: number) => string
>this : this
>GetLineIndentationForOffset : (offset: number) => string
>lineStartPosition : any

                    var commentIndentationInfo = this.ApplyIndentationDelta2(lineIndent, commentFirstLineIndentationDelta);
>commentIndentationInfo : any
>this.ApplyIndentationDelta2(lineIndent, commentFirstLineIndentationDelta) : any
>this.ApplyIndentationDelta2 : (currentIndent: string, delta: number) => any
>this : this
>ApplyIndentationDelta2 : (currentIndent: string, delta: number) => any
>lineIndent : string
>commentFirstLineIndentationDelta : number

                    if (commentIndentationInfo != null) {
>commentIndentationInfo != null : boolean
>commentIndentationInfo : any
>null : null

                        var tokenStartPosition = lineStartPosition + lineIndent.length;
>tokenStartPosition : any
>lineStartPosition + lineIndent.length : any
>lineStartPosition : any
>lineIndent.length : number
>lineIndent : string
>length : number

                        var commentIndentationEdit = this.GetIndentEdit(commentIndentationInfo, tokenStartPosition, false);
>commentIndentationEdit : any
>this.GetIndentEdit(commentIndentationInfo, tokenStartPosition, false) : any
>this.GetIndentEdit : (indentInfo: any, tokenStartPosition: number, sameLineIndent: boolean) => any
>this : this
>GetIndentEdit : (indentInfo: any, tokenStartPosition: number, sameLineIndent: boolean) => any
>commentIndentationInfo : any
>tokenStartPosition : any
>false : false

                        if (commentIndentationEdit != null) {
>commentIndentationEdit != null : boolean
>commentIndentationEdit : any
>null : null

                            result.add(commentIndentationEdit);
>result.add(commentIndentationEdit) : any
>result.add : any
>result : any
>add : any
>commentIndentationEdit : any
                        }
                    }
                }
            }

            return result;
>result : any
        }

        static GetIndentSizeFromIndentText(indentText: string, editorOptions: Services.EditorOptions): number {
>GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>indentText : string
>editorOptions : any
>Services : any

            return GetIndentSizeFromText(indentText, editorOptions, /*includeNonIndentChars:*/ false);
>GetIndentSizeFromText(indentText, editorOptions, /*includeNonIndentChars:*/ false) : any
>GetIndentSizeFromText : any
>indentText : string
>editorOptions : any
>false : false
        }

        static GetIndentSizeFromText(text: string, editorOptions: Services.EditorOptions, includeNonIndentChars: boolean): number {
>GetIndentSizeFromText : (text: string, editorOptions: any, includeNonIndentChars: boolean) => number
>text : string
>editorOptions : any
>Services : any
>includeNonIndentChars : boolean

            var indentSize = 0;
>indentSize : number
>0 : 0

            for (var i = 0; i < text.length; i++) {
>i : number
>0 : 0
>i < text.length : boolean
>i : number
>text.length : number
>text : string
>length : number
>i++ : number
>i : number

                var c = text.charAt(i);
>c : string
>text.charAt(i) : string
>text.charAt : (pos: number) => string
>text : string
>charAt : (pos: number) => string
>i : number

                if (c == '\t')
>c == '\t' : boolean
>c : string
>'\t' : "\t"

                    indentSize = (indentSize + editorOptions.TabSize) - (indentSize % editorOptions.TabSize);
>indentSize = (indentSize + editorOptions.TabSize) - (indentSize % editorOptions.TabSize) : number
>indentSize : number
>(indentSize + editorOptions.TabSize) - (indentSize % editorOptions.TabSize) : number
>(indentSize + editorOptions.TabSize) : any
>indentSize + editorOptions.TabSize : any
>indentSize : number
>editorOptions.TabSize : any
>editorOptions : any
>TabSize : any
>(indentSize % editorOptions.TabSize) : number
>indentSize % editorOptions.TabSize : number
>indentSize : number
>editorOptions.TabSize : any
>editorOptions : any
>TabSize : any

                else if (c == ' ')
>c == ' ' : boolean
>c : string
>' ' : " "

                    indentSize += 1;
>indentSize += 1 : number
>indentSize : number
>1 : 1

                else {
                    if (includeNonIndentChars)
>includeNonIndentChars : boolean

                        indentSize += 1;
>indentSize += 1 : number
>indentSize : number
>1 : 1

                    else
                        break;
                }
            }

            return indentSize;
>indentSize : number
        }

        private GetSpecialCaseIndentation(token: TokenSpan, node: ParseNode): IndentationInfo {
>GetSpecialCaseIndentation : (token: any, node: any) => any
>token : any
>node : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            switch (token.Token) {
>token.Token : any
>token : any
>Token : any

                case AuthorTokenKind.atkLCurly: // { is not part of the tree
>AuthorTokenKind.atkLCurly : any
>AuthorTokenKind : any
>atkLCurly : any

                    indentationInfo = this.GetSpecialCaseIndentationForLCurly(node);
>indentationInfo = this.GetSpecialCaseIndentationForLCurly(node) : any
>indentationInfo : any
>this.GetSpecialCaseIndentationForLCurly(node) : any
>this.GetSpecialCaseIndentationForLCurly : (node: any) => any
>this : this
>GetSpecialCaseIndentationForLCurly : (node: any) => any
>node : any

                    return indentationInfo;
>indentationInfo : any

                case AuthorTokenKind.atkElse:   // else is not part of the tree
>AuthorTokenKind.atkElse : any
>AuthorTokenKind : any
>atkElse : any

                case AuthorTokenKind.atkRBrack: // ] is not part of the tree
>AuthorTokenKind.atkRBrack : any
>AuthorTokenKind : any
>atkRBrack : any

                    indentationInfo = node.GetNodeStartLineIndentation(this);
>indentationInfo = node.GetNodeStartLineIndentation(this) : any
>indentationInfo : any
>node.GetNodeStartLineIndentation(this) : any
>node.GetNodeStartLineIndentation : any
>node : any
>GetNodeStartLineIndentation : any
>this : this

                    return indentationInfo;
>indentationInfo : any

                case AuthorTokenKind.atkRCurly: // } is not part of the tree
>AuthorTokenKind.atkRCurly : any
>AuthorTokenKind : any
>atkRCurly : any

                    // if '}' is for a body-block, get indentation based on its parent.
                    if (node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkBlock && node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneBody)
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkBlock && node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneBody : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkBlock : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkBlock : any
>AuthorParseNodeKind : any
>apnkBlock : any
>node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneBody : boolean
>node.AuthorNode.EdgeLabel : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>EdgeLabel : any
>AuthorParseNodeEdge.apneBody : any
>AuthorParseNodeEdge : any
>apneBody : any

                        node = node.Parent;
>node = node.Parent : any
>node : any
>node.Parent : any
>node : any
>Parent : any

                    indentationInfo = node.GetNodeStartLineIndentation(this);
>indentationInfo = node.GetNodeStartLineIndentation(this) : any
>indentationInfo : any
>node.GetNodeStartLineIndentation(this) : any
>node.GetNodeStartLineIndentation : any
>node : any
>GetNodeStartLineIndentation : any
>this : this

                    return indentationInfo;
>indentationInfo : any

                case AuthorTokenKind.atkWhile: // while (in do-while) is not part of the tree
>AuthorTokenKind.atkWhile : any
>AuthorTokenKind : any
>atkWhile : any

                    if (node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkDoWhile) {
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkDoWhile : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkDoWhile : any
>AuthorParseNodeKind : any
>apnkDoWhile : any

                        indentationInfo = node.GetNodeStartLineIndentation(this);
>indentationInfo = node.GetNodeStartLineIndentation(this) : any
>indentationInfo : any
>node.GetNodeStartLineIndentation(this) : any
>node.GetNodeStartLineIndentation : any
>node : any
>GetNodeStartLineIndentation : any
>this : this

                        return indentationInfo;
>indentationInfo : any
                    }

                    return null;
>null : null

                case AuthorTokenKind.atkSColon:
>AuthorTokenKind.atkSColon : any
>AuthorTokenKind : any
>atkSColon : any

                    return this.GetSpecialCaseIndentationForSemicolon(token, node);
>this.GetSpecialCaseIndentationForSemicolon(token, node) : any
>this.GetSpecialCaseIndentationForSemicolon : (token: any, node: any) => any
>this : this
>GetSpecialCaseIndentationForSemicolon : (token: any, node: any) => any
>token : any
>node : any

                case AuthorTokenKind.atkComment:
>AuthorTokenKind.atkComment : any
>AuthorTokenKind : any
>atkComment : any

                    return this.GetSpecialCaseIndentationForComment(token, node);
>this.GetSpecialCaseIndentationForComment(token, node) : any
>this.GetSpecialCaseIndentationForComment : (token: any, node: any) => any
>this : this
>GetSpecialCaseIndentationForComment : (token: any, node: any) => any
>token : any
>node : any

                default:
                    return indentationInfo;
>indentationInfo : any
            }
        }

        private GetSpecialCaseIndentationForLCurly(node: ParseNode): IndentationInfo {
>GetSpecialCaseIndentationForLCurly : (node: any) => any
>node : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            if (node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl ||
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl ||                node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneThen || node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneElse : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl ||                node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneThen : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkFncDecl : any
>AuthorParseNodeKind : any
>apnkFncDecl : any

                node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneThen || node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneElse) {
>node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneThen : boolean
>node.AuthorNode.EdgeLabel : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>EdgeLabel : any
>AuthorParseNodeEdge.apneThen : any
>AuthorParseNodeEdge : any
>apneThen : any
>node.AuthorNode.EdgeLabel == AuthorParseNodeEdge.apneElse : boolean
>node.AuthorNode.EdgeLabel : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>EdgeLabel : any
>AuthorParseNodeEdge.apneElse : any
>AuthorParseNodeEdge : any
>apneElse : any

                    // flushed with the node (function & if)
                indentationInfo = node.GetNodeStartLineIndentation(this);
>indentationInfo = node.GetNodeStartLineIndentation(this) : any
>indentationInfo : any
>node.GetNodeStartLineIndentation(this) : any
>node.GetNodeStartLineIndentation : any
>node : any
>GetNodeStartLineIndentation : any
>this : this

                return indentationInfo;
>indentationInfo : any
            }
            else if (node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject && !node.CanIndent()) {
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject && !node.CanIndent() : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkObject : any
>AuthorParseNodeKind : any
>apnkObject : any
>!node.CanIndent() : boolean
>node.CanIndent() : any
>node.CanIndent : any
>node : any
>CanIndent : any

                // if the open curly belongs to a non-indented object, do nothing here.
                return null;
>null : null
            }

            // effective identation of the block
            indentationInfo = node.GetEffectiveIndentation(this);
>indentationInfo = node.GetEffectiveIndentation(this) : any
>indentationInfo : any
>node.GetEffectiveIndentation(this) : any
>node.GetEffectiveIndentation : any
>node : any
>GetEffectiveIndentation : any
>this : this

            return indentationInfo;
>indentationInfo : any
        }

        private GetSpecialCaseIndentationForSemicolon(token: TokenSpan, node: ParseNode): IndentationInfo {
>GetSpecialCaseIndentationForSemicolon : (token: any, node: any) => any
>token : any
>node : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            if (this.smartIndent) {
>this.smartIndent : boolean
>this : this
>smartIndent : boolean

                indentationInfo = node.GetEffectiveChildrenIndentation(this);
>indentationInfo = node.GetEffectiveChildrenIndentation(this) : any
>indentationInfo : any
>node.GetEffectiveChildrenIndentation(this) : any
>node.GetEffectiveChildrenIndentation : any
>node : any
>GetEffectiveChildrenIndentation : any
>this : this

                return indentationInfo;
>indentationInfo : any
            }
            else {
                // Indent all semicolons except the ones that belong to the for statement parts (initalizer, condition, itnrement)
                if (node.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkFor) {
>node.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkFor : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkFor : any
>AuthorParseNodeKind : any
>apnkFor : any

                    // The passed node is actually either the program or the list because semicolon doesn't belong
                    // to any statement in the tree, though the statement extends up to the semicolon position.
                    // To find the correct statement, we look for the adjacent node on the left of the semicolon.
                    var semiColonStartSpan = new Span(token.Span.startPosition(), 0);
>semiColonStartSpan : any
>new Span(token.Span.startPosition(), 0) : any
>Span : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>0 : 0

                    node = ParseTree.FindCommonParentNode(semiColonStartSpan, semiColonStartSpan, node);
>node = ParseTree.FindCommonParentNode(semiColonStartSpan, semiColonStartSpan, node) : any
>node : any
>ParseTree.FindCommonParentNode(semiColonStartSpan, semiColonStartSpan, node) : any
>ParseTree.FindCommonParentNode : any
>ParseTree : any
>FindCommonParentNode : any
>semiColonStartSpan : any
>semiColonStartSpan : any
>node : any

                    indentationInfo = node.GetEffectiveChildrenIndentation(this);
>indentationInfo = node.GetEffectiveChildrenIndentation(this) : any
>indentationInfo : any
>node.GetEffectiveChildrenIndentation(this) : any
>node.GetEffectiveChildrenIndentation : any
>node : any
>GetEffectiveChildrenIndentation : any
>this : this

                    return indentationInfo;
>indentationInfo : any
                }
            }

            return null;
>null : null
        }

        private GetSpecialCaseIndentationForComment(token: TokenSpan, node: ParseNode): IndentationInfo {
>GetSpecialCaseIndentationForComment : (token: any, node: any) => any
>token : any
>node : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            // Only indent line comment and the first line of block comment
            var twoCharSpan = token.Span.Intersection(new Span(token.Span.startPosition(), 2));
>twoCharSpan : any
>token.Span.Intersection(new Span(token.Span.startPosition(), 2)) : any
>token.Span.Intersection : any
>token.Span : any
>token : any
>Span : any
>Intersection : any
>new Span(token.Span.startPosition(), 2) : any
>Span : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>2 : 2

            if (twoCharSpan != null && (twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*")) {
>twoCharSpan != null && (twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*") : boolean
>twoCharSpan != null : boolean
>twoCharSpan : any
>null : null
>(twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*") : boolean
>twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*" : boolean
>twoCharSpan.GetText() == "//" : boolean
>twoCharSpan.GetText() : any
>twoCharSpan.GetText : any
>twoCharSpan : any
>GetText : any
>"//" : "//"
>twoCharSpan.GetText() == "/*" : boolean
>twoCharSpan.GetText() : any
>twoCharSpan.GetText : any
>twoCharSpan : any
>GetText : any
>"/*" : "/*"

                while (node.ChildrenIndentationDelta == null && node.Parent != null)
>node.ChildrenIndentationDelta == null && node.Parent != null : boolean
>node.ChildrenIndentationDelta == null : boolean
>node.ChildrenIndentationDelta : any
>node : any
>ChildrenIndentationDelta : any
>null : null
>node.Parent != null : boolean
>node.Parent : any
>node : any
>Parent : any
>null : null

                    node = node.Parent;
>node = node.Parent : any
>node : any
>node.Parent : any
>node : any
>Parent : any

                if (this.CanIndentComment(token, node)) {
>this.CanIndentComment(token, node) : boolean
>this.CanIndentComment : (token: any, node: any) => boolean
>this : this
>CanIndentComment : (token: any, node: any) => boolean
>token : any
>node : any

                    indentationInfo = node.GetEffectiveChildrenIndentationForComment(this);
>indentationInfo = node.GetEffectiveChildrenIndentationForComment(this) : any
>indentationInfo : any
>node.GetEffectiveChildrenIndentationForComment(this) : any
>node.GetEffectiveChildrenIndentationForComment : any
>node : any
>GetEffectiveChildrenIndentationForComment : any
>this : this
                }
                else {
                    indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
>indentationInfo = this.ApplyIndentationDeltaFromParent(token, node) : any
>indentationInfo : any
>this.ApplyIndentationDeltaFromParent(token, node) : any
>this.ApplyIndentationDeltaFromParent : (token: any, node: any) => any
>this : this
>ApplyIndentationDeltaFromParent : (token: any, node: any) => any
>token : any
>node : any
                }
            }

            return indentationInfo;
>indentationInfo : any
        }

        private CanIndentComment(token: TokenSpan, node: ParseNode): boolean {
>CanIndentComment : (token: any, node: any) => boolean
>token : any
>node : any

            switch (node.AuthorNode.Details.Kind) {
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any

                case AuthorParseNodeKind.apnkProg:
>AuthorParseNodeKind.apnkProg : any
>AuthorParseNodeKind : any
>apnkProg : any

                case AuthorParseNodeKind.apnkBlock:
>AuthorParseNodeKind.apnkBlock : any
>AuthorParseNodeKind : any
>apnkBlock : any

                case AuthorParseNodeKind.apnkSwitch:
>AuthorParseNodeKind.apnkSwitch : any
>AuthorParseNodeKind : any
>apnkSwitch : any

                case AuthorParseNodeKind.apnkCase:
>AuthorParseNodeKind.apnkCase : any
>AuthorParseNodeKind : any
>apnkCase : any

                case AuthorParseNodeKind.apnkDefaultCase:
>AuthorParseNodeKind.apnkDefaultCase : any
>AuthorParseNodeKind : any
>apnkDefaultCase : any

                case AuthorParseNodeKind.apnkIf:
>AuthorParseNodeKind.apnkIf : any
>AuthorParseNodeKind : any
>apnkIf : any

                case AuthorParseNodeKind.apnkFor:
>AuthorParseNodeKind.apnkFor : any
>AuthorParseNodeKind : any
>apnkFor : any

                case AuthorParseNodeKind.apnkForIn:
>AuthorParseNodeKind.apnkForIn : any
>AuthorParseNodeKind : any
>apnkForIn : any

                case AuthorParseNodeKind.apnkWhile:
>AuthorParseNodeKind.apnkWhile : any
>AuthorParseNodeKind : any
>apnkWhile : any

                case AuthorParseNodeKind.apnkWith:
>AuthorParseNodeKind.apnkWith : any
>AuthorParseNodeKind : any
>apnkWith : any

                case AuthorParseNodeKind.apnkDoWhile:
>AuthorParseNodeKind.apnkDoWhile : any
>AuthorParseNodeKind : any
>apnkDoWhile : any

                case AuthorParseNodeKind.apnkObject:
>AuthorParseNodeKind.apnkObject : any
>AuthorParseNodeKind : any
>apnkObject : any

                    return true;
>true : true

                case AuthorParseNodeKind.apnkFncDecl:
>AuthorParseNodeKind.apnkFncDecl : any
>AuthorParseNodeKind : any
>apnkFncDecl : any

                    // Comments before arguments are not indented.
                    // This code doesn't cover the cases of comment after the last argument or 
                    // when there are no arguments. Though this is okay since the only case we care about is:
                    // function foo(/* test */ a,
                    //              /* test */ b)
                    var result = true;
>result : boolean
>true : true

                    var children = ParseNodeExtensions.FindChildrenWithEdge(node, AuthorParseNodeEdge.apneArgument);
>children : any
>ParseNodeExtensions.FindChildrenWithEdge(node, AuthorParseNodeEdge.apneArgument) : any
>ParseNodeExtensions.FindChildrenWithEdge : any
>ParseNodeExtensions : any
>FindChildrenWithEdge : any
>node : any
>AuthorParseNodeEdge.apneArgument : any
>AuthorParseNodeEdge : any
>apneArgument : any

                    children.foreach((argumentNode) => {
>children.foreach((argumentNode) => {                        if (token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset)                            result = false;                    }) : any
>children.foreach : any
>children : any
>foreach : any
>(argumentNode) => {                        if (token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset)                            result = false;                    } : (argumentNode: any) => void
>argumentNode : any

                        if (token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset)
>token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset : boolean
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>argumentNode.AuthorNode.Details.StartOffset : any
>argumentNode.AuthorNode.Details : any
>argumentNode.AuthorNode : any
>argumentNode : any
>AuthorNode : any
>Details : any
>StartOffset : any

                            result = false;
>result = false : false
>result : boolean
>false : false

                    });

                    return result;
>result : true
            }

            return false;
>false : false
        }

        private ApplyScriptBlockIndentation(languageHostIndentation: string, tree: ParseTree): void
>ApplyScriptBlockIndentation : (languageHostIndentation: string, tree: any) => void
>languageHostIndentation : string
>tree : any
        {
            if (languageHostIndentation == null || tree.StartNodeSelf == null)
>languageHostIndentation == null || tree.StartNodeSelf == null : boolean
>languageHostIndentation == null : boolean
>languageHostIndentation : string
>null : null
>tree.StartNodeSelf == null : boolean
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any
>null : null

                return;

            var scriptBlockIndentation = this.ApplyIndentationLevel(languageHostIndentation, 1);
>scriptBlockIndentation : string
>this.ApplyIndentationLevel(languageHostIndentation, 1) : string
>this.ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>this : this
>ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>languageHostIndentation : string
>1 : 1

            //TypeScript: Projection snapshots not supported

            // Disconnect the sibling node if it belongs to a different script block
            //IProjectionSnapshot projectionSnapshot = this.snapshot as IProjectionSnapshot;
            //if (projectionSnapshot != null)
            //{
            //    // Get script block spans.
            //    foreach (SnapshotSpan sourceSpan in projectionSnapshot.GetSourceSpans())
            //    {
            //        // Map the spans to the JavaScript buffer.
            //        ReadOnlyCollection<Span> spans = projectionSnapshot.MapFromSourceSnapshot(sourceSpan);

            //        Debug.Assert(spans.Count == 1, string.Format(CultureInfo.InvariantCulture, "Unexpected span count of {0}.", spans.Count));

            //        if (spans.Count > 0)
            //        {
            //            Span span = spans.First();

            //            // If the "self" node is the first root-level node in a script block, then remove the start node.
            //            if (span.Contains(tree.StartNodethis.AuthorNode.Details.StartOffset))
            //            {
            //                this.scriptBlockBeginLineNumber = projectionSnapshot.GetLineNumberFromPosition(span.Start);

            //                if (tree.StartNodePreviousSibling.HasValue)
            //                {
            //                    int siblingStartOffset = tree.StartNodePreviousSibling.Value.Details.StartOffset;

            //                    // Don't consider sibling in these cases:
            //                    // 1. The sibling belongs to another script block
            //                    // 2. The sibling is on the same line of the script block
            //                    if (!span.Contains(siblingStartOffset) || projectionSnapshot.GetLineNumberFromPosition(siblingStartOffset) == this.scriptBlockBeginLineNumber)
            //                    {
            //                        tree.StartNodePreviousSibling = null;
            //                    }
            //                }

            //                break;
            //            }
            //        }
            //    }
            //}

            // The root is the program.
            tree.Root.SetIndentationOverride(scriptBlockIndentation);
>tree.Root.SetIndentationOverride(scriptBlockIndentation) : any
>tree.Root.SetIndentationOverride : any
>tree.Root : any
>tree : any
>Root : any
>SetIndentationOverride : any
>scriptBlockIndentation : string
        }

        private GetIndentEdit(indentInfo: IndentationInfo, tokenStartPosition: number, sameLineIndent: boolean): TextEditInfo {
>GetIndentEdit : (indentInfo: any, tokenStartPosition: number, sameLineIndent: boolean) => any
>indentInfo : any
>tokenStartPosition : number
>sameLineIndent : boolean

            var indentText = this.ApplyIndentationLevel(indentInfo.Prefix, indentInfo.Level);
>indentText : string
>this.ApplyIndentationLevel(indentInfo.Prefix, indentInfo.Level) : string
>this.ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>this : this
>ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>indentInfo.Prefix : any
>indentInfo : any
>Prefix : any
>indentInfo.Level : any
>indentInfo : any
>Level : any

            if (sameLineIndent) {
>sameLineIndent : boolean

                return new TextEditInfo(tokenStartPosition, 0, indentText);
>new TextEditInfo(tokenStartPosition, 0, indentText) : any
>TextEditInfo : any
>tokenStartPosition : number
>0 : 0
>indentText : string
            }
            else {
                var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
>snapshotLine : any
>this.snapshot.GetLineFromPosition(tokenStartPosition) : any
>this.snapshot.GetLineFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromPosition : any
>tokenStartPosition : number

                var currentIndentSpan = new Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
>currentIndentSpan : any
>new Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition()) : any
>Span : any
>snapshotLine.startPosition() : any
>snapshotLine.startPosition : any
>snapshotLine : any
>startPosition : any
>tokenStartPosition - snapshotLine.startPosition() : number
>tokenStartPosition : number
>snapshotLine.startPosition() : any
>snapshotLine.startPosition : any
>snapshotLine : any
>startPosition : any

                var currentIndentText = this.snapshot.GetText(currentIndentSpan);
>currentIndentText : any
>this.snapshot.GetText(currentIndentSpan) : any
>this.snapshot.GetText : any
>this.snapshot : any
>this : this
>snapshot : any
>GetText : any
>currentIndentSpan : any

                if (currentIndentText !== indentText) {
>currentIndentText !== indentText : boolean
>currentIndentText : any
>indentText : string

                    if (this.logger.debug()) {
>this.logger.debug() : any
>this.logger.debug : any
>this.logger : any
>this : this
>logger : any
>debug : any

                        // Verify that currentIndentText is all whitespaces
                        for (var i = 0, len = currentIndentText.length; i < len; i++) {
>i : number
>0 : 0
>len : any
>currentIndentText.length : any
>currentIndentText : any
>length : any
>i < len : boolean
>i : number
>len : any
>i++ : number
>i : number

                            var c = currentIndentText.charCodeAt(i);
>c : any
>currentIndentText.charCodeAt(i) : any
>currentIndentText.charCodeAt : any
>currentIndentText : any
>charCodeAt : any
>i : number

                            if (!StringUtils.IsWhiteSpace(c)) {
>!StringUtils.IsWhiteSpace(c) : boolean
>StringUtils.IsWhiteSpace(c) : any
>StringUtils.IsWhiteSpace : any
>StringUtils : any
>IsWhiteSpace : any
>c : any

                                Debug.Fail("Formatting error: Will remove user code when indenting the line: " + snapshotLine.getText());
>Debug.Fail("Formatting error: Will remove user code when indenting the line: " + snapshotLine.getText()) : any
>Debug.Fail : any
>Debug : any
>Fail : any
>"Formatting error: Will remove user code when indenting the line: " + snapshotLine.getText() : string
>"Formatting error: Will remove user code when indenting the line: " : "Formatting error: Will remove user code when indenting the line: "
>snapshotLine.getText() : any
>snapshotLine.getText : any
>snapshotLine : any
>getText : any

                                break;
                            }
                        }
                    }
                    return new TextEditInfo(currentIndentSpan.start(), currentIndentSpan.length(), indentText);
>new TextEditInfo(currentIndentSpan.start(), currentIndentSpan.length(), indentText) : any
>TextEditInfo : any
>currentIndentSpan.start() : any
>currentIndentSpan.start : any
>currentIndentSpan : any
>start : any
>currentIndentSpan.length() : any
>currentIndentSpan.length : any
>currentIndentSpan : any
>length : any
>indentText : string
                }
            }

            return null;
>null : null
        }

        private ApplyIndentationLevel(existingIndentation: string, level: number): string {
>ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>existingIndentation : string
>level : number

            var indentSize = this.editorOptions.IndentSize;
>indentSize : any
>this.editorOptions.IndentSize : any
>this.editorOptions : any
>this : this
>editorOptions : any
>IndentSize : any

            var tabSize = this.editorOptions.TabSize;
>tabSize : any
>this.editorOptions.TabSize : any
>this.editorOptions : any
>this : this
>editorOptions : any
>TabSize : any

            var convertTabsToSpaces = this.editorOptions.ConvertTabsToSpaces;
>convertTabsToSpaces : any
>this.editorOptions.ConvertTabsToSpaces : any
>this.editorOptions : any
>this : this
>editorOptions : any
>ConvertTabsToSpaces : any

            if (level < 0) {
>level < 0 : boolean
>level : number
>0 : 0

                if (StringUtils.IsNullOrEmpty(existingIndentation))
>StringUtils.IsNullOrEmpty(existingIndentation) : any
>StringUtils.IsNullOrEmpty : any
>StringUtils : any
>IsNullOrEmpty : any
>existingIndentation : string

                    return "";
>"" : ""

                var totalIndent = 0;
>totalIndent : number
>0 : 0

                StringUtils.foreach(existingIndentation, (c) => {
>StringUtils.foreach(existingIndentation, (c) => {                    if (c == '\t')                        totalIndent += tabSize;                    else                        totalIndent++;                }) : any
>StringUtils.foreach : any
>StringUtils : any
>foreach : any
>existingIndentation : string
>(c) => {                    if (c == '\t')                        totalIndent += tabSize;                    else                        totalIndent++;                } : (c: any) => void
>c : any

                    if (c == '\t')
>c == '\t' : boolean
>c : any
>'\t' : "\t"

                        totalIndent += tabSize;
>totalIndent += tabSize : any
>totalIndent : number
>tabSize : any

                    else
                        totalIndent++;
>totalIndent++ : number
>totalIndent : number

                });

                totalIndent += level * indentSize;
>totalIndent += level * indentSize : number
>totalIndent : number
>level * indentSize : number
>level : number
>indentSize : any

                if (totalIndent < 0)
>totalIndent < 0 : boolean
>totalIndent : number
>0 : 0

                    return "";
>"" : ""

                else
                    return this.GetIndentString(null, totalIndent, tabSize, convertTabsToSpaces);
>this.GetIndentString(null, totalIndent, tabSize, convertTabsToSpaces) : string
>this.GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>this : this
>GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>null : null
>totalIndent : number
>tabSize : any
>convertTabsToSpaces : any
            }

            var totalIndentSize = level * indentSize;
>totalIndentSize : number
>level * indentSize : number
>level : number
>indentSize : any

            return this.GetIndentString(existingIndentation, totalIndentSize, tabSize, convertTabsToSpaces);
>this.GetIndentString(existingIndentation, totalIndentSize, tabSize, convertTabsToSpaces) : string
>this.GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>this : this
>GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>existingIndentation : string
>totalIndentSize : number
>tabSize : any
>convertTabsToSpaces : any
        }

        private GetIndentString(prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean): string {
>GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>prefix : string
>totalIndentSize : number
>tabSize : number
>convertTabsToSpaces : boolean

            var tabString = convertTabsToSpaces ? StringUtils.create(' ', tabSize) : "\t";
>tabString : any
>convertTabsToSpaces ? StringUtils.create(' ', tabSize) : "\t" : any
>convertTabsToSpaces : boolean
>StringUtils.create(' ', tabSize) : any
>StringUtils.create : any
>StringUtils : any
>create : any
>' ' : " "
>tabSize : number
>"\t" : "\t"

            var text = "";
>text : string
>"" : ""

            if (!StringUtils.IsNullOrEmpty(prefix))
>!StringUtils.IsNullOrEmpty(prefix) : boolean
>StringUtils.IsNullOrEmpty(prefix) : any
>StringUtils.IsNullOrEmpty : any
>StringUtils : any
>IsNullOrEmpty : any
>prefix : string

                text += prefix;
>text += prefix : string
>text : string
>prefix : string

            var pos = 0;
>pos : number
>0 : 0

            // fill first with tabs
            while (pos <= totalIndentSize - tabSize) {
>pos <= totalIndentSize - tabSize : boolean
>pos : number
>totalIndentSize - tabSize : number
>totalIndentSize : number
>tabSize : number

                text += tabString;
>text += tabString : string
>text : string
>tabString : any

                pos += tabSize;
>pos += tabSize : number
>pos : number
>tabSize : number
            }

            // fill the reminder with spaces
            while (pos < totalIndentSize) {
>pos < totalIndentSize : boolean
>pos : number
>totalIndentSize : number

                text += ' ';
>text += ' ' : string
>text : string
>' ' : " "

                pos++;
>pos++ : number
>pos : number
            }

            return text;
>text : string
        }

        private  ApplyIndentationDeltaFromParent(token: TokenSpan, node: ParseNode): IndentationInfo {
>ApplyIndentationDeltaFromParent : (token: any, node: any) => any
>token : any
>node : any

            var indentationInfo: IndentationInfo = null;
>indentationInfo : any
>null : null

            var indentableParent = node;
>indentableParent : any
>node : any

            while (indentableParent != null && !indentableParent.CanIndent())
>indentableParent != null && !indentableParent.CanIndent() : boolean
>indentableParent != null : boolean
>indentableParent : any
>null : null
>!indentableParent.CanIndent() : boolean
>indentableParent.CanIndent() : any
>indentableParent.CanIndent : any
>indentableParent : any
>CanIndent : any

                indentableParent = indentableParent.Parent;
>indentableParent = indentableParent.Parent : any
>indentableParent : any
>indentableParent.Parent : any
>indentableParent : any
>Parent : any

            if (indentableParent != null && indentableParent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg) {
>indentableParent != null && indentableParent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg : boolean
>indentableParent != null : boolean
>indentableParent : any
>null : null
>indentableParent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg : boolean
>indentableParent.AuthorNode.Details.Kind : any
>indentableParent.AuthorNode.Details : any
>indentableParent.AuthorNode : any
>indentableParent : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkProg : any
>AuthorParseNodeKind : any
>apnkProg : any

                var parentIndentationDeltaSize = this.GetIndentationDelta(indentableParent.AuthorNode.Details.StartOffset, token.Span.startPosition());
>parentIndentationDeltaSize : number
>this.GetIndentationDelta(indentableParent.AuthorNode.Details.StartOffset, token.Span.startPosition()) : number
>this.GetIndentationDelta : (tokenStartPosition: number, childTokenStartPosition: number) => number
>this : this
>GetIndentationDelta : (tokenStartPosition: number, childTokenStartPosition: number) => number
>indentableParent.AuthorNode.Details.StartOffset : any
>indentableParent.AuthorNode.Details : any
>indentableParent.AuthorNode : any
>indentableParent : any
>AuthorNode : any
>Details : any
>StartOffset : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any

                if (parentIndentationDeltaSize !== undefined) {
>parentIndentationDeltaSize !== undefined : boolean
>parentIndentationDeltaSize : number
>undefined : undefined

                    indentationInfo = this.ApplyIndentationDelta1(token.Span.startPosition(), parentIndentationDeltaSize);
>indentationInfo = this.ApplyIndentationDelta1(token.Span.startPosition(), parentIndentationDeltaSize) : any
>indentationInfo : any
>this.ApplyIndentationDelta1(token.Span.startPosition(), parentIndentationDeltaSize) : any
>this.ApplyIndentationDelta1 : (tokenStartPosition: number, delta: number) => any
>this : this
>ApplyIndentationDelta1 : (tokenStartPosition: number, delta: number) => any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>parentIndentationDeltaSize : number
                }
            }

            return indentationInfo;
>indentationInfo : any
        }

        private ApplyIndentationDelta1(tokenStartPosition: number, delta: number): IndentationInfo {
>ApplyIndentationDelta1 : (tokenStartPosition: number, delta: number) => any
>tokenStartPosition : number
>delta : number

            // Get current indentation
            var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
>snapshotLine : any
>this.snapshot.GetLineFromPosition(tokenStartPosition) : any
>this.snapshot.GetLineFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromPosition : any
>tokenStartPosition : number

            var currentIndentSpan = new Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
>currentIndentSpan : any
>new Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition()) : any
>Span : any
>snapshotLine.startPosition() : any
>snapshotLine.startPosition : any
>snapshotLine : any
>startPosition : any
>tokenStartPosition - snapshotLine.startPosition() : number
>tokenStartPosition : number
>snapshotLine.startPosition() : any
>snapshotLine.startPosition : any
>snapshotLine : any
>startPosition : any

            var currentIndent = this.snapshot.GetText(currentIndentSpan);
>currentIndent : any
>this.snapshot.GetText(currentIndentSpan) : any
>this.snapshot.GetText : any
>this.snapshot : any
>this : this
>snapshot : any
>GetText : any
>currentIndentSpan : any

            // Calculate new indentation from current-indentation and delta
            return this.ApplyIndentationDelta2(currentIndent, delta);
>this.ApplyIndentationDelta2(currentIndent, delta) : any
>this.ApplyIndentationDelta2 : (currentIndent: string, delta: number) => any
>this : this
>ApplyIndentationDelta2 : (currentIndent: string, delta: number) => any
>currentIndent : any
>delta : number
        }

        private ApplyIndentationDelta2(currentIndent: string, delta: number): IndentationInfo {
>ApplyIndentationDelta2 : (currentIndent: string, delta: number) => any
>currentIndent : string
>delta : number

            if (delta == 0)
>delta == 0 : boolean
>delta : number
>0 : 0

                return null;
>null : null

            var currentIndentSize = Indenter.GetIndentSizeFromIndentText(currentIndent, this.editorOptions);
>currentIndentSize : number
>Indenter.GetIndentSizeFromIndentText(currentIndent, this.editorOptions) : number
>Indenter.GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>Indenter : typeof Indenter
>GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>currentIndent : string
>this.editorOptions : any
>this : this
>editorOptions : any

            var newIndentSize = currentIndentSize + delta;
>newIndentSize : number
>currentIndentSize + delta : number
>currentIndentSize : number
>delta : number

            if (newIndentSize < 0) {
>newIndentSize < 0 : boolean
>newIndentSize : number
>0 : 0

                newIndentSize = 0;
>newIndentSize = 0 : 0
>newIndentSize : number
>0 : 0
            }

            var newIndent = this.GetIndentString(null, newIndentSize, this.editorOptions.TabSize, this.editorOptions.ConvertTabsToSpaces);
>newIndent : string
>this.GetIndentString(null, newIndentSize, this.editorOptions.TabSize, this.editorOptions.ConvertTabsToSpaces) : string
>this.GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>this : this
>GetIndentString : (prefix: string, totalIndentSize: number, tabSize: number, convertTabsToSpaces: boolean) => string
>null : null
>newIndentSize : number
>this.editorOptions.TabSize : any
>this.editorOptions : any
>this : this
>editorOptions : any
>TabSize : any
>this.editorOptions.ConvertTabsToSpaces : any
>this.editorOptions : any
>this : this
>editorOptions : any
>ConvertTabsToSpaces : any

            if (newIndent != null) {
>newIndent != null : boolean
>newIndent : string
>null : null

                return new IndentationInfo(newIndent, 0);
>new IndentationInfo(newIndent, 0) : any
>IndentationInfo : any
>newIndent : string
>0 : 0
            }

            return null;
>null : null
        }

        private GetIndentationDelta(tokenStartPosition: number, childTokenStartPosition: number/*?*/): number/*?*/ {
>GetIndentationDelta : (tokenStartPosition: number, childTokenStartPosition: number) => number
>tokenStartPosition : number
>childTokenStartPosition : number

            Debug.Assert(childTokenStartPosition !== undefined, "Error: caller must pass 'null' for undefined position");
>Debug.Assert(childTokenStartPosition !== undefined, "Error: caller must pass 'null' for undefined position") : any
>Debug.Assert : any
>Debug : any
>Assert : any
>childTokenStartPosition !== undefined : boolean
>childTokenStartPosition : number
>undefined : undefined
>"Error: caller must pass 'null' for undefined position" : "Error: caller must pass 'null' for undefined position"

            var indentationDeltaSize = this.offsetIndentationDeltas.GetValue(tokenStartPosition);
>indentationDeltaSize : any
>this.offsetIndentationDeltas.GetValue(tokenStartPosition) : any
>this.offsetIndentationDeltas.GetValue : any
>this.offsetIndentationDeltas : any
>this : this
>offsetIndentationDeltas : any
>GetValue : any
>tokenStartPosition : number

            if (indentationDeltaSize === null) {
>indentationDeltaSize === null : boolean
>indentationDeltaSize : any
>null : null

                var indentEditInfo = this.indentationBag.FindIndent(tokenStartPosition);
>indentEditInfo : any
>this.indentationBag.FindIndent(tokenStartPosition) : any
>this.indentationBag.FindIndent : any
>this.indentationBag : any
>this : this
>indentationBag : any
>FindIndent : any
>tokenStartPosition : number

                // No recorded indentation, return null
                if (indentEditInfo == null)
>indentEditInfo == null : boolean
>indentEditInfo : any
>null : null

                    return null;
>null : null

                var origIndentText = this.snapshot.GetText(new Span(indentEditInfo.OrigIndentPosition, indentEditInfo.OrigIndentLength()));
>origIndentText : any
>this.snapshot.GetText(new Span(indentEditInfo.OrigIndentPosition, indentEditInfo.OrigIndentLength())) : any
>this.snapshot.GetText : any
>this.snapshot : any
>this : this
>snapshot : any
>GetText : any
>new Span(indentEditInfo.OrigIndentPosition, indentEditInfo.OrigIndentLength()) : any
>Span : any
>indentEditInfo.OrigIndentPosition : any
>indentEditInfo : any
>OrigIndentPosition : any
>indentEditInfo.OrigIndentLength() : any
>indentEditInfo.OrigIndentLength : any
>indentEditInfo : any
>OrigIndentLength : any

                var newIndentText = indentEditInfo.Indentation();
>newIndentText : any
>indentEditInfo.Indentation() : any
>indentEditInfo.Indentation : any
>indentEditInfo : any
>Indentation : any

                var origIndentSize = Indenter.GetIndentSizeFromText(origIndentText, this.editorOptions, /*includeNonIndentChars*/true);
>origIndentSize : number
>Indenter.GetIndentSizeFromText(origIndentText, this.editorOptions, /*includeNonIndentChars*/true) : number
>Indenter.GetIndentSizeFromText : (text: string, editorOptions: any, includeNonIndentChars: boolean) => number
>Indenter : typeof Indenter
>GetIndentSizeFromText : (text: string, editorOptions: any, includeNonIndentChars: boolean) => number
>origIndentText : any
>this.editorOptions : any
>this : this
>editorOptions : any
>true : true

                var newIndentSize = Indenter.GetIndentSizeFromIndentText(newIndentText, this.editorOptions);
>newIndentSize : number
>Indenter.GetIndentSizeFromIndentText(newIndentText, this.editorOptions) : number
>Indenter.GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>Indenter : typeof Indenter
>GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>newIndentText : any
>this.editorOptions : any
>this : this
>editorOptions : any

                // Check the child's position whether it's before the parent position
                // if so indent the child based on the first token on the line as opposed to the parent position
                //
                // Example of relative to parent (not line), relative indentation should be "4 (newIndentSize) - 9 (indentSize up to for) = -5"
                //
                // if (1) { for (i = 0; i < 10;       =>          if (1) {
                //                      i++) {                       for (i = 0; i < 10;
                //                                                               i++) {
                //
                // Example of relative to line, relative indentation should be "4 (newIndentSize) - 0 (indentSize up to if) = 4"
                //
                // if (1) { for (i = 0; i < 10;      =>          if (1) {
                //     i++) {                                        for (i = 0; i < 10;
                //                                                       i++) {
                if (childTokenStartPosition !== null) {
>childTokenStartPosition !== null : boolean
>childTokenStartPosition : number
>null : null

                    var childTokenLineStartPosition = this.snapshot.GetLineFromPosition(childTokenStartPosition).startPosition();
>childTokenLineStartPosition : any
>this.snapshot.GetLineFromPosition(childTokenStartPosition).startPosition() : any
>this.snapshot.GetLineFromPosition(childTokenStartPosition).startPosition : any
>this.snapshot.GetLineFromPosition(childTokenStartPosition) : any
>this.snapshot.GetLineFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromPosition : any
>childTokenStartPosition : number
>startPosition : any

                    var childIndentText = this.snapshot.GetText(new Span(childTokenLineStartPosition, childTokenStartPosition - childTokenLineStartPosition));
>childIndentText : any
>this.snapshot.GetText(new Span(childTokenLineStartPosition, childTokenStartPosition - childTokenLineStartPosition)) : any
>this.snapshot.GetText : any
>this.snapshot : any
>this : this
>snapshot : any
>GetText : any
>new Span(childTokenLineStartPosition, childTokenStartPosition - childTokenLineStartPosition) : any
>Span : any
>childTokenLineStartPosition : any
>childTokenStartPosition - childTokenLineStartPosition : number
>childTokenStartPosition : number
>childTokenLineStartPosition : any

                    var childIndentSize = Indenter.GetIndentSizeFromIndentText(childIndentText, this.editorOptions);
>childIndentSize : number
>Indenter.GetIndentSizeFromIndentText(childIndentText, this.editorOptions) : number
>Indenter.GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>Indenter : typeof Indenter
>GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>childIndentText : any
>this.editorOptions : any
>this : this
>editorOptions : any

                    if (childIndentSize < origIndentSize)
>childIndentSize < origIndentSize : boolean
>childIndentSize : number
>origIndentSize : number

                        origIndentSize = Indenter.GetIndentSizeFromIndentText(origIndentText, this.editorOptions);
>origIndentSize = Indenter.GetIndentSizeFromIndentText(origIndentText, this.editorOptions) : number
>origIndentSize : number
>Indenter.GetIndentSizeFromIndentText(origIndentText, this.editorOptions) : number
>Indenter.GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>Indenter : typeof Indenter
>GetIndentSizeFromIndentText : (indentText: string, editorOptions: any) => number
>origIndentText : any
>this.editorOptions : any
>this : this
>editorOptions : any
                }

                indentationDeltaSize = newIndentSize - origIndentSize;
>indentationDeltaSize = newIndentSize - origIndentSize : number
>indentationDeltaSize : any
>newIndentSize - origIndentSize : number
>newIndentSize : number
>origIndentSize : number

                this.offsetIndentationDeltas.Add(tokenStartPosition, indentationDeltaSize);
>this.offsetIndentationDeltas.Add(tokenStartPosition, indentationDeltaSize) : any
>this.offsetIndentationDeltas.Add : any
>this.offsetIndentationDeltas : any
>this : this
>offsetIndentationDeltas : any
>Add : any
>tokenStartPosition : number
>indentationDeltaSize : any
            }

            return indentationDeltaSize;
>indentationDeltaSize : any
        }

        private FillInheritedIndentation(tree: ParseTree): void
>FillInheritedIndentation : (tree: any) => void
>tree : any
        {
            var offset = -1;
>offset : number
>-1 : -1
>1 : 1

            var indentNode: ParseNode = null;
>indentNode : any
>null : null

            if (tree.StartNodeSelf != null) {
>tree.StartNodeSelf != null : boolean
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any
>null : null

                if (!this.smartIndent && tree.StartNodePreviousSibling !== null && tree.StartNodeSelf.AuthorNode.Label == 0 && tree.StartNodePreviousSibling.Label == 0) {
>!this.smartIndent && tree.StartNodePreviousSibling !== null && tree.StartNodeSelf.AuthorNode.Label == 0 && tree.StartNodePreviousSibling.Label == 0 : boolean
>!this.smartIndent && tree.StartNodePreviousSibling !== null && tree.StartNodeSelf.AuthorNode.Label == 0 : boolean
>!this.smartIndent && tree.StartNodePreviousSibling !== null : boolean
>!this.smartIndent : boolean
>this.smartIndent : boolean
>this : this
>smartIndent : boolean
>tree.StartNodePreviousSibling !== null : boolean
>tree.StartNodePreviousSibling : any
>tree : any
>StartNodePreviousSibling : any
>null : null
>tree.StartNodeSelf.AuthorNode.Label == 0 : boolean
>tree.StartNodeSelf.AuthorNode.Label : any
>tree.StartNodeSelf.AuthorNode : any
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any
>AuthorNode : any
>Label : any
>0 : 0
>tree.StartNodePreviousSibling.Label == 0 : boolean
>tree.StartNodePreviousSibling.Label : any
>tree.StartNodePreviousSibling : any
>tree : any
>StartNodePreviousSibling : any
>Label : any
>0 : 0

                    indentNode = tree.StartNodeSelf;
>indentNode = tree.StartNodeSelf : any
>indentNode : any
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any

                    offset = tree.StartNodePreviousSibling.Details.StartOffset;
>offset = tree.StartNodePreviousSibling.Details.StartOffset : any
>offset : number
>tree.StartNodePreviousSibling.Details.StartOffset : any
>tree.StartNodePreviousSibling.Details : any
>tree.StartNodePreviousSibling : any
>tree : any
>StartNodePreviousSibling : any
>Details : any
>StartOffset : any

                    // In case the sibling node is on the same line of a parent node, ex:
                    //      case 1: a++;
                    //          break;
                    // In this example, the sibling of break is a++ but a++ is on the same line of its parent.
                    var lineNum = this.snapshot.GetLineNumberFromPosition(offset);
>lineNum : any
>this.snapshot.GetLineNumberFromPosition(offset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>offset : number

                    var node = indentNode;
>node : any
>indentNode : any

                    while (node.Parent != null && this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) == lineNum) {
>node.Parent != null && this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) == lineNum : boolean
>node.Parent != null : boolean
>node.Parent : any
>node : any
>Parent : any
>null : null
>this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) == lineNum : boolean
>this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>node.Parent.AuthorNode.Details.StartOffset : any
>node.Parent.AuthorNode.Details : any
>node.Parent.AuthorNode : any
>node.Parent : any
>node : any
>Parent : any
>AuthorNode : any
>Details : any
>StartOffset : any
>lineNum : any

                        node = node.Parent;
>node = node.Parent : any
>node : any
>node.Parent : any
>node : any
>Parent : any

                        if (node.CanIndent()) {
>node.CanIndent() : any
>node.CanIndent : any
>node : any
>CanIndent : any

                            indentNode = node;
>indentNode = node : any
>indentNode : any
>node : any

                            indentNode.IndentationDelta = 0;
>indentNode.IndentationDelta = 0 : 0
>indentNode.IndentationDelta : any
>indentNode : any
>IndentationDelta : any
>0 : 0
                        }
                    }
                }
                else {
                    var parent: ParseNode;
>parent : any

                    // Otherwise base on parent indentation.
                    if (this.smartIndent) {
>this.smartIndent : boolean
>this : this
>smartIndent : boolean

                        // in smartIndent the self node is the parent node since it's the closest node to the new line
                        // ... unless in case if the startNodeSelf represents the firstToken then we need to choose its parent
                        parent = tree.StartNodeSelf;
>parent = tree.StartNodeSelf : any
>parent : any
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any

                        while (parent != null && parent.AuthorNode.Details.StartOffset == this.firstToken.Span.startPosition())
>parent != null && parent.AuthorNode.Details.StartOffset == this.firstToken.Span.startPosition() : boolean
>parent != null : boolean
>parent : any
>null : null
>parent.AuthorNode.Details.StartOffset == this.firstToken.Span.startPosition() : boolean
>parent.AuthorNode.Details.StartOffset : any
>parent.AuthorNode.Details : any
>parent.AuthorNode : any
>parent : any
>AuthorNode : any
>Details : any
>StartOffset : any
>this.firstToken.Span.startPosition() : any
>this.firstToken.Span.startPosition : any
>this.firstToken.Span : any
>this.firstToken : any
>this : this
>firstToken : any
>Span : any
>startPosition : any

                            parent = parent.Parent;
>parent = parent.Parent : any
>parent : any
>parent.Parent : any
>parent : any
>Parent : any
                    }
                    else {
                        // Get the parent that is really on a different line from the self node
                        var startNodeLineNumber = this.snapshot.GetLineNumberFromPosition(tree.StartNodeSelf.AuthorNode.Details.StartOffset);
>startNodeLineNumber : any
>this.snapshot.GetLineNumberFromPosition(tree.StartNodeSelf.AuthorNode.Details.StartOffset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>tree.StartNodeSelf.AuthorNode.Details.StartOffset : any
>tree.StartNodeSelf.AuthorNode.Details : any
>tree.StartNodeSelf.AuthorNode : any
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any
>AuthorNode : any
>Details : any
>StartOffset : any

                        parent = tree.StartNodeSelf.Parent;
>parent = tree.StartNodeSelf.Parent : any
>parent : any
>tree.StartNodeSelf.Parent : any
>tree.StartNodeSelf : any
>tree : any
>StartNodeSelf : any
>Parent : any

                        while (parent != null &&
>parent != null &&                                startNodeLineNumber == this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset) : boolean
>parent != null : boolean
>parent : any
>null : null

                                startNodeLineNumber == this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset)) {
>startNodeLineNumber == this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset) : boolean
>startNodeLineNumber : any
>this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>parent.AuthorNode.Details.StartOffset : any
>parent.AuthorNode.Details : any
>parent.AuthorNode : any
>parent : any
>AuthorNode : any
>Details : any
>StartOffset : any

                            parent = parent.Parent;
>parent = parent.Parent : any
>parent : any
>parent.Parent : any
>parent : any
>Parent : any
                        }
                    }

                    // The parent node to take its indentation is the first parent that has indentation.
                    while (parent != null && !parent.CanIndent()) {
>parent != null && !parent.CanIndent() : boolean
>parent != null : boolean
>parent : any
>null : null
>!parent.CanIndent() : boolean
>parent.CanIndent() : any
>parent.CanIndent : any
>parent : any
>CanIndent : any

                        parent = parent.Parent;
>parent = parent.Parent : any
>parent : any
>parent.Parent : any
>parent : any
>Parent : any
                    }

                    // Skip Program since it has no indentation
                    if (parent != null && parent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg) {
>parent != null && parent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg : boolean
>parent != null : boolean
>parent : any
>null : null
>parent.AuthorNode.Details.Kind != AuthorParseNodeKind.apnkProg : boolean
>parent.AuthorNode.Details.Kind : any
>parent.AuthorNode.Details : any
>parent.AuthorNode : any
>parent : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkProg : any
>AuthorParseNodeKind : any
>apnkProg : any

                        offset = parent.AuthorNode.Details.StartOffset;
>offset = parent.AuthorNode.Details.StartOffset : any
>offset : number
>parent.AuthorNode.Details.StartOffset : any
>parent.AuthorNode.Details : any
>parent.AuthorNode : any
>parent : any
>AuthorNode : any
>Details : any
>StartOffset : any

                        indentNode = parent;
>indentNode = parent : any
>indentNode : any
>parent : any
                    }
                }
            }

            if (indentNode != null) {
>indentNode != null : boolean
>indentNode : any
>null : null

                var indentOverride = this.GetLineIndentationForOffset(offset);
>indentOverride : string
>this.GetLineIndentationForOffset(offset) : string
>this.GetLineIndentationForOffset : (offset: number) => string
>this : this
>GetLineIndentationForOffset : (offset: number) => string
>offset : number

                // Set the indentation on all the siblings to be the same as indentNode
                if (!this.smartIndent && tree.StartNodePreviousSibling !== null && indentNode.Parent != null) {
>!this.smartIndent && tree.StartNodePreviousSibling !== null && indentNode.Parent != null : boolean
>!this.smartIndent && tree.StartNodePreviousSibling !== null : boolean
>!this.smartIndent : boolean
>this.smartIndent : boolean
>this : this
>smartIndent : boolean
>tree.StartNodePreviousSibling !== null : boolean
>tree.StartNodePreviousSibling : any
>tree : any
>StartNodePreviousSibling : any
>null : null
>indentNode.Parent != null : boolean
>indentNode.Parent : any
>indentNode : any
>Parent : any
>null : null

                    ParseNodeExtensions.GetChildren(indentNode.Parent).foreach((sibling) => {
>ParseNodeExtensions.GetChildren(indentNode.Parent).foreach((sibling) => {                        if (sibling !== indentNode) {                            if (sibling.CanIndent())                                sibling.SetIndentationOverride(indentOverride);                        }                    }) : any
>ParseNodeExtensions.GetChildren(indentNode.Parent).foreach : any
>ParseNodeExtensions.GetChildren(indentNode.Parent) : any
>ParseNodeExtensions.GetChildren : any
>ParseNodeExtensions : any
>GetChildren : any
>indentNode.Parent : any
>indentNode : any
>Parent : any
>foreach : any
>(sibling) => {                        if (sibling !== indentNode) {                            if (sibling.CanIndent())                                sibling.SetIndentationOverride(indentOverride);                        }                    } : (sibling: any) => void
>sibling : any

                        if (sibling !== indentNode) {
>sibling !== indentNode : boolean
>sibling : any
>indentNode : any

                            if (sibling.CanIndent())
>sibling.CanIndent() : any
>sibling.CanIndent : any
>sibling : any
>CanIndent : any

                                sibling.SetIndentationOverride(indentOverride);
>sibling.SetIndentationOverride(indentOverride) : any
>sibling.SetIndentationOverride : any
>sibling : any
>SetIndentationOverride : any
>indentOverride : string
                        }
                    });
                }

                // Set the indent override string on the indent node and on every parent (on different line) after adjusting the indent by the negative delta
                var lastDelta = 0;
>lastDelta : number
>0 : 0

                var lastLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
>lastLine : any
>this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>indentNode.AuthorNode.Details.StartOffset : any
>indentNode.AuthorNode.Details : any
>indentNode.AuthorNode : any
>indentNode : any
>AuthorNode : any
>Details : any
>StartOffset : any

                do {
                    var currentLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
>currentLine : any
>this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>indentNode.AuthorNode.Details.StartOffset : any
>indentNode.AuthorNode.Details : any
>indentNode.AuthorNode : any
>indentNode : any
>AuthorNode : any
>Details : any
>StartOffset : any

                    if (lastLine != currentLine) {
>lastLine != currentLine : boolean
>lastLine : any
>currentLine : any

                        lastLine = currentLine;
>lastLine = currentLine : any
>lastLine : any
>currentLine : any

                        indentOverride = this.ApplyIndentationLevel(indentOverride, -lastDelta);
>indentOverride = this.ApplyIndentationLevel(indentOverride, -lastDelta) : string
>indentOverride : string
>this.ApplyIndentationLevel(indentOverride, -lastDelta) : string
>this.ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>this : this
>ApplyIndentationLevel : (existingIndentation: string, level: number) => string
>indentOverride : string
>-lastDelta : number
>lastDelta : number

                        lastDelta = 0;
>lastDelta = 0 : 0
>lastDelta : number
>0 : 0
                    }

                    if (indentNode.CanIndent()) {
>indentNode.CanIndent() : any
>indentNode.CanIndent : any
>indentNode : any
>CanIndent : any

                        indentNode.SetIndentationOverride(indentOverride);
>indentNode.SetIndentationOverride(indentOverride) : any
>indentNode.SetIndentationOverride : any
>indentNode : any
>SetIndentationOverride : any
>indentOverride : string

                        lastDelta = indentNode.IndentationDelta;
>lastDelta = indentNode.IndentationDelta : any
>lastDelta : number
>indentNode.IndentationDelta : any
>indentNode : any
>IndentationDelta : any
                    }

                    indentNode = indentNode.Parent;
>indentNode = indentNode.Parent : any
>indentNode : any
>indentNode.Parent : any
>indentNode : any
>Parent : any
                }
                while (indentNode != null);
>indentNode != null : boolean
>indentNode : any
>null : null
            }
        }

        public GetLineIndentationForOffset(offset: number): string {
>GetLineIndentationForOffset : (offset: number) => string
>offset : number

            var indentationEdit: IndentationEditInfo;
>indentationEdit : any

            // First check if we already have indentation info in our indentation bag
            indentationEdit = this.indentationBag.FindIndent(offset);
>indentationEdit = this.indentationBag.FindIndent(offset) : any
>indentationEdit : any
>this.indentationBag.FindIndent(offset) : any
>this.indentationBag.FindIndent : any
>this.indentationBag : any
>this : this
>indentationBag : any
>FindIndent : any
>offset : number

            if (indentationEdit != null) {
>indentationEdit != null : boolean
>indentationEdit : any
>null : null

                return indentationEdit.Indentation();
>indentationEdit.Indentation() : any
>indentationEdit.Indentation : any
>indentationEdit : any
>Indentation : any
            }
            else {
                // Otherwise, use the indentation from the textBuffer
                var line = this.snapshot.GetLineFromPosition(offset);
>line : any
>this.snapshot.GetLineFromPosition(offset) : any
>this.snapshot.GetLineFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromPosition : any
>offset : number

                var lineText = line.getText();
>lineText : any
>line.getText() : any
>line.getText : any
>line : any
>getText : any

                var index = 0;
>index : number
>0 : 0

                while (index < lineText.length && (lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t')) {
>index < lineText.length && (lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t') : boolean
>index < lineText.length : boolean
>index : number
>lineText.length : any
>lineText : any
>length : any
>(lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t') : boolean
>lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t' : boolean
>lineText.charAt(index) == ' ' : boolean
>lineText.charAt(index) : any
>lineText.charAt : any
>lineText : any
>charAt : any
>index : number
>' ' : " "
>lineText.charAt(index) == '\t' : boolean
>lineText.charAt(index) : any
>lineText.charAt : any
>lineText : any
>charAt : any
>index : number
>'\t' : "\t"

                    ++index;
>++index : number
>index : number
                }

                return lineText.substr(0, index);
>lineText.substr(0, index) : any
>lineText.substr : any
>lineText : any
>substr : any
>0 : 0
>index : number
            }
        }

        private RegisterIndentation(indent: TextEditInfo, sameLineIndent: boolean): void
>RegisterIndentation : (indent: any, sameLineIndent: boolean) => void
>indent : any
>sameLineIndent : boolean
        {
            var indentationInfo: IndentationEditInfo = null;
>indentationInfo : any
>null : null

            if (sameLineIndent) {
>sameLineIndent : boolean

                // Consider the original indentation from the beginning of the line up to the indent position (or really the token position)
                var lineStartPosition = this.snapshot.GetLineFromPosition(indent.Position).startPosition();
>lineStartPosition : any
>this.snapshot.GetLineFromPosition(indent.Position).startPosition() : any
>this.snapshot.GetLineFromPosition(indent.Position).startPosition : any
>this.snapshot.GetLineFromPosition(indent.Position) : any
>this.snapshot.GetLineFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineFromPosition : any
>indent.Position : any
>indent : any
>Position : any
>startPosition : any

                var lineIndentLength = indent.Position - lineStartPosition;
>lineIndentLength : number
>indent.Position - lineStartPosition : number
>indent.Position : any
>indent : any
>Position : any
>lineStartPosition : any

                indentationInfo = IndentationEditInfo.create2(indent.Position, indent.ReplaceWith, lineStartPosition, lineIndentLength);
>indentationInfo = IndentationEditInfo.create2(indent.Position, indent.ReplaceWith, lineStartPosition, lineIndentLength) : any
>indentationInfo : any
>IndentationEditInfo.create2(indent.Position, indent.ReplaceWith, lineStartPosition, lineIndentLength) : any
>IndentationEditInfo.create2 : any
>IndentationEditInfo : any
>create2 : any
>indent.Position : any
>indent : any
>Position : any
>indent.ReplaceWith : any
>indent : any
>ReplaceWith : any
>lineStartPosition : any
>lineIndentLength : number
            }
            else {
                indentationInfo = new IndentationEditInfo(indent);
>indentationInfo = new IndentationEditInfo(indent) : any
>indentationInfo : any
>new IndentationEditInfo(indent) : any
>IndentationEditInfo : any
>indent : any
            }

            this.indentationBag.AddIndent(indentationInfo);
>this.indentationBag.AddIndent(indentationInfo) : any
>this.indentationBag.AddIndent : any
>this.indentationBag : any
>this : this
>indentationBag : any
>AddIndent : any
>indentationInfo : any
        }

        public RegisterIndentation2(position: number, indent: string): void
>RegisterIndentation2 : (position: number, indent: string) => void
>position : number
>indent : string
        {
            this.RegisterIndentation(new TextEditInfo(position, 0, indent), false);
>this.RegisterIndentation(new TextEditInfo(position, 0, indent), false) : void
>this.RegisterIndentation : (indent: any, sameLineIndent: boolean) => void
>this : this
>RegisterIndentation : (indent: any, sameLineIndent: boolean) => void
>new TextEditInfo(position, 0, indent) : any
>TextEditInfo : any
>position : number
>0 : 0
>indent : string
>false : false
        }

        private AdjustStartOffsetIfNeeded(token: TokenSpan, node: ParseNode): void
>AdjustStartOffsetIfNeeded : (token: any, node: any) => void
>token : any
>node : any
        {
            if (token == null)
>token == null : boolean
>token : any
>null : null

                return;

            var updateStartOffset = false;
>updateStartOffset : boolean
>false : false

            switch (token.Token) {
>token.Token : any
>token : any
>Token : any

                case AuthorTokenKind.atkFunction:
>AuthorTokenKind.atkFunction : any
>AuthorTokenKind : any
>atkFunction : any

                    updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl;
>updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl : boolean
>updateStartOffset : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkFncDecl : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkFncDecl : any
>AuthorParseNodeKind : any
>apnkFncDecl : any

                    break;

                case AuthorTokenKind.atkLCurly:
>AuthorTokenKind.atkLCurly : any
>AuthorTokenKind : any
>atkLCurly : any

                    updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject;
>updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject : boolean
>updateStartOffset : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkObject : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkObject : any
>AuthorParseNodeKind : any
>apnkObject : any

                    break;

                case AuthorTokenKind.atkLBrack:
>AuthorTokenKind.atkLBrack : any
>AuthorTokenKind : any
>atkLBrack : any

                    updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkArray;
>updateStartOffset = node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkArray : boolean
>updateStartOffset : boolean
>node.AuthorNode.Details.Kind == AuthorParseNodeKind.apnkArray : boolean
>node.AuthorNode.Details.Kind : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>Kind : any
>AuthorParseNodeKind.apnkArray : any
>AuthorParseNodeKind : any
>apnkArray : any

                    break;
            }

            if (updateStartOffset) {
>updateStartOffset : boolean

                ParseNodeExtensions.SetNodeSpan(node, token.Span.startPosition(), node.AuthorNode.Details.EndOffset);
>ParseNodeExtensions.SetNodeSpan(node, token.Span.startPosition(), node.AuthorNode.Details.EndOffset) : any
>ParseNodeExtensions.SetNodeSpan : any
>ParseNodeExtensions : any
>SetNodeSpan : any
>node : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
>node.AuthorNode.Details.EndOffset : any
>node.AuthorNode.Details : any
>node.AuthorNode : any
>node : any
>AuthorNode : any
>Details : any
>EndOffset : any
            }
        }

        private IsMultiLineString(token: TokenSpan): boolean {
>IsMultiLineString : (token: any) => boolean
>token : any

            return token.tokenID === TypeScript.TokenID.StringLiteral &&
>token.tokenID === TypeScript.TokenID.StringLiteral &&                this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) > this.snapshot.GetLineNumberFromPosition(token.Span.startPosition()) : boolean
>token.tokenID === TypeScript.TokenID.StringLiteral : boolean
>token.tokenID : any
>token : any
>tokenID : any
>TypeScript.TokenID.StringLiteral : any
>TypeScript.TokenID : any
>TypeScript : any
>TokenID : any
>StringLiteral : any

                this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) > this.snapshot.GetLineNumberFromPosition(token.Span.startPosition());
>this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) > this.snapshot.GetLineNumberFromPosition(token.Span.startPosition()) : boolean
>this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>token.Span.endPosition() : any
>token.Span.endPosition : any
>token.Span : any
>token : any
>Span : any
>endPosition : any
>this.snapshot.GetLineNumberFromPosition(token.Span.startPosition()) : any
>this.snapshot.GetLineNumberFromPosition : any
>this.snapshot : any
>this : this
>snapshot : any
>GetLineNumberFromPosition : any
>token.Span.startPosition() : any
>token.Span.startPosition : any
>token.Span : any
>token : any
>Span : any
>startPosition : any
        }
    }
}