diff --git a/README.md b/README.md
index dfc5671f8..f263e56d3 100644
--- a/README.md
+++ b/README.md
@@ -22,12 +22,15 @@ It is very desirable each new contribution to contain tests too.
Other means to get the definitions
----------------------------------
-[TypeScript definition package manager](https://github.com/Diullei/tsd)
+* [TypeScript definition package manager](https://github.com/Diullei/tsd)
-NuGet package(s) coming soon
+* [tsdpm](http://www.tsdpm.com/) - Online search
+
+> NuGet package(s) coming soon
List of Definitions
-------------------
+* [Ace Cloud9 Editor](http://ace.ajax.org/) (by [Diullei Gomes](https://github.com/Diullei))
* [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes))
* [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
* [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
diff --git a/ace/ace-tests.ts b/ace/ace-tests.ts
new file mode 100644
index 000000000..43556fb83
--- /dev/null
+++ b/ace/ace-tests.ts
@@ -0,0 +1,453 @@
+///
+
+var assert: any;
+
+var editor = ace.edit("editor");
+editor.setTheme("ace/theme/monokai");
+editor.getSession().setMode("ace/mode/javascript");
+
+editor.setTheme("ace/theme/twilight");
+
+editor.getSession().setMode("ace/mode/javascript");
+
+editor.setValue("the new text here"); // or session.setValue
+editor.getValue(); // or session.getValue
+
+editor.session.getTextRange(editor.getSelectionRange());
+
+editor.insert("Something cool");
+
+editor.selection.getCursor();
+
+editor.gotoLine(123);
+
+editor.session.getLength();
+
+editor.getSession().setTabSize(4);
+
+editor.getSession().setUseSoftTabs(true);
+
+document.getElementById('editor').style.fontSize = '12px';
+
+editor.getSession().setUseWrapMode(true);
+
+editor.setHighlightActiveLine(false);
+
+editor.setShowPrintMargin(false);
+
+editor.setReadOnly(true); // false to make it editable
+
+editor.resize()
+
+editor.find('needle', {
+ backwards: false,
+ wrap: false,
+ caseSensitive: false,
+ wholeWord: false,
+ regExp: false
+});
+editor.findNext();
+editor.findPrevious();
+
+editor.find('foo');
+editor.replace('bar');
+
+editor.replaceAll('bar');
+
+editor.getSession().on('change', function (e) {
+// e.type, etc
+});
+
+editor.getSession().selection.on('changeSelection', function (e) {
+});
+
+editor.getSession().selection.on('changeCursor', function (e) {
+});
+
+editor.commands.addCommand({
+name: 'myCommand',
+bindKey: { win: 'Ctrl-M', mac: 'Command-M' },
+exec: function (editor) {
+//...
+},
+readOnly: true // false if this command should not apply in readOnly mode
+});
+
+editor.moveCursorTo(1, 1);
+editor.removeLines();
+
+editor.removeLines();
+
+editor.removeLines();
+
+editor.removeLines();
+
+editor.moveCursorTo(1, 1);
+editor.getSelection().selectDown();
+
+editor.removeLines();
+
+editor.removeLines();
+
+editor.moveCursorTo(3, 0);
+
+editor.removeLines();
+
+editor.removeLines();
+
+editor.moveCursorTo(1, 3);
+editor.getSelection().selectDown();
+
+editor.indent();
+
+var range = editor.getSelectionRange();
+
+editor.moveCursorTo(1, 0);
+editor.getSelection().selectDown();
+
+editor.indent();
+
+editor.moveCursorTo(0, 0);
+editor.onTextInput("\n");
+
+editor.moveCursorTo(0, 5);
+editor.getSelection().selectDown();
+editor.getSelection().selectDown();
+
+editor.blockOutdent();
+
+editor.moveCursorTo(1, 1);
+editor.removeLines();
+
+var session = new AceAjax.EditSession(["a", "b", "c", "d"].join("\n"));
+
+assert.equal(session.toString(), "a\nc\nd");
+assert.position(editor.getCursorPosition(), 1, 0);
+
+editor.removeLines();
+
+assert.equal(session.toString(), "a\nd");
+assert.position(editor.getCursorPosition(), 1, 0);
+
+editor.removeLines();
+
+assert.equal(session.toString(), "a");
+assert.position(editor.getCursorPosition(), 0, 1);
+
+editor.removeLines();
+
+assert.equal(session.toString(), "");
+assert.position(editor.getCursorPosition(), 0, 0);
+
+editor.moveCursorTo(1, 1);
+editor.getSelection().selectDown();
+
+editor.removeLines();
+assert.equal(session.toString(), "a\nd");
+assert.position(editor.getCursorPosition(), 1, 0);
+
+
+editor.removeLines();
+
+assert.equal(session.toString(), "b\nc");
+assert.position(editor.getCursorPosition(), 0, 0);
+
+
+editor.moveCursorTo(3, 0);
+
+editor.removeLines();
+assert.equal(session.toString(), "a\nb\nc");
+assert.position(editor.getCursorPosition(), 2, 1);
+
+editor.removeLines();
+assert.equal(session.toString(), "a\nb");
+assert.position(editor.getCursorPosition(), 1, 1);
+
+
+editor.moveCursorTo(1, 3);
+editor.getSelection().selectDown();
+
+editor.indent();
+
+assert.equal(["a12345", " b12345", " c12345"].join("\n"), session.toString());
+
+assert.position(editor.getCursorPosition(), 2, 7);
+
+range = editor.getSelectionRange();
+assert.position(range.start, 1, 7);
+assert.position(range.end, 2, 7);
+
+
+editor.moveCursorTo(1, 0);
+editor.getSelection().selectDown();
+
+editor.indent();
+assert.equal(["a12345", " b12345", "c12345"].join("\n"), session.toString());
+
+
+editor.moveCursorTo(0, 0);
+editor.onTextInput("\n");
+assert.equal(["", "{"].join("\n"), session.toString());
+
+
+editor.moveCursorTo(0, 5);
+editor.getSelection().selectDown();
+editor.getSelection().selectDown();
+
+editor.blockOutdent();
+assert.equal(session.toString(), [" a12345", "b12345", " c12345"].join("\n"));
+
+assert.position(editor.getCursorPosition(), 2, 1);
+
+range = editor.getSelectionRange();
+assert.position(range.start, 0, 1);
+assert.position(range.end, 2, 1);
+
+editor.blockOutdent();
+assert.equal(session.toString(), ["a12345", "b12345", "c12345"].join("\n"));
+
+range = editor.getSelectionRange();
+assert.position(range.start, 0, 0);
+assert.position(range.end, 2, 0);
+
+
+editor.moveCursorTo(0, 3);
+editor.blockOutdent(" ");
+
+assert.equal(session.toString(), " 12");
+assert.position(editor.getCursorPosition(), 0, 0);
+
+
+editor.moveCursorTo(0, 2);
+editor.getSelection().selectDown();
+editor.toggleCommentLines();
+
+assert.equal(["// abc", "//cde"].join("\n"), session.toString());
+
+var selection = editor.getSelectionRange();
+assert.position(selection.start, 0, 4);
+assert.position(selection.end, 1, 4);
+
+
+editor.moveCursorTo(0, 1);
+editor.getSelection().selectDown();
+editor.getSelection().selectRight();
+editor.getSelection().selectRight();
+
+editor.toggleCommentLines();
+
+assert.equal([" abc", "cde"].join("\n"), session.toString());
+assert.range(editor.getSelectionRange(), 0, 0, 1, 1);
+
+
+editor.moveCursorTo(0, 0);
+editor.getSelection().selectDown();
+editor.getSelection().selectDown();
+
+editor.toggleCommentLines();
+editor.toggleCommentLines();
+
+assert.equal([" abc", "cde", "fg"].join("\n"), session.toString());
+
+
+editor.moveCursorTo(0, 0);
+editor.getSelection().selectDown();
+
+editor.toggleCommentLines();
+assert.range(editor.getSelectionRange(), 0, 2, 1, 0);
+
+
+
+editor.moveCursorTo(1, 0);
+editor.getSelection().selectUp();
+
+editor.toggleCommentLines();
+assert.range(editor.getSelectionRange(), 0, 2, 1, 0);
+
+
+editor.moveCursorTo(0, 1);
+editor.getSelection().selectDown();
+
+editor.moveLinesDown();
+assert.equal(["33", "11", "22", "44"].join("\n"), session.toString());
+assert.position(editor.getCursorPosition(), 1, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 3, 0);
+assert.position(editor.getSelection().getSelectionLead(), 1, 0);
+
+editor.moveLinesDown();
+assert.equal(["33", "44", "11", "22"].join("\n"), session.toString());
+assert.position(editor.getCursorPosition(), 2, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 3, 2);
+assert.position(editor.getSelection().getSelectionLead(), 2, 0);
+
+// moving again should have no effect
+editor.moveLinesDown();
+assert.equal(["33", "44", "11", "22"].join("\n"), session.toString());
+assert.position(editor.getCursorPosition(), 2, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 3, 2);
+assert.position(editor.getSelection().getSelectionLead(), 2, 0);
+
+
+editor.moveCursorTo(2, 1);
+editor.getSelection().selectDown();
+
+editor.moveLinesUp();
+assert.equal(session.toString(), ["11", "33", "44", "22"].join("\n"));
+assert.position(editor.getCursorPosition(), 1, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 3, 0);
+assert.position(editor.getSelection().getSelectionLead(), 1, 0);
+
+editor.moveLinesUp();
+assert.equal(session.toString(), ["33", "44", "11", "22"].join("\n"));
+assert.position(editor.getCursorPosition(), 0, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 2, 0);
+assert.position(editor.getSelection().getSelectionLead(), 0, 0);
+
+
+editor.moveCursorTo(1, 1);
+editor.clearSelection();
+
+editor.moveLinesDown();
+assert.equal(["11", "33", "22", "44"].join("\n"), session.toString());
+assert.position(editor.getCursorPosition(), 2, 1);
+
+editor.clearSelection();
+
+editor.moveLinesUp();
+assert.equal(["11", "22", "33", "44"].join("\n"), session.toString());
+assert.position(editor.getCursorPosition(), 1, 1);
+
+
+editor.moveCursorTo(1, 1);
+editor.getSelection().selectDown();
+
+editor.copyLinesDown();
+assert.equal(["11", "22", "33", "22", "33", "44"].join("\n"), session.toString());
+
+assert.position(editor.getCursorPosition(), 3, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 5, 0);
+assert.position(editor.getSelection().getSelectionLead(), 3, 0);
+
+
+editor.moveCursorTo(1, 1);
+editor.getSelection().selectDown();
+
+editor.copyLinesUp();
+assert.equal(["11", "22", "33", "22", "33", "44"].join("\n"), session.toString());
+
+assert.position(editor.getCursorPosition(), 1, 0);
+assert.position(editor.getSelection().getSelectionAnchor(), 3, 0);
+assert.position(editor.getSelection().getSelectionLead(), 1, 0);
+
+
+session.setTabSize(2);
+session.setUseSoftTabs(true);
+
+editor.onTextInput("\t");
+assert.equal(session.toString(), " ");
+
+session.setTabSize(5);
+editor.onTextInput("\t");
+assert.equal(session.toString(), " ");
+
+
+session.setUseSoftTabs(false);
+
+editor.onTextInput("\t");
+assert.equal(session.toString(), "\t");
+
+editor.removeLines();
+var step1 = session.toString();
+assert.equal(step1, "222\n333");
+
+editor.removeLines();
+var step2 = session.toString();
+assert.equal(step2, "333");
+
+editor.removeLines();
+var step3 = session.toString();
+assert.equal(step3, "");
+
+var undoManager = new AceAjax.UndoManager();
+
+undoManager.undo();
+assert.equal(session.toString(), step2);
+
+undoManager.undo();
+assert.equal(session.toString(), step1);
+
+undoManager.undo();
+assert.equal(session.toString(), "");
+
+undoManager.undo();
+assert.equal(session.toString(), "");
+
+editor.moveCursorTo(1, 1);
+editor.remove("left");
+assert.equal(session.toString(), "123\n56");
+
+editor.moveCursorTo(1, 0);
+editor.remove("left");
+assert.equal(session.toString(), "123456");
+
+session.setUseSoftTabs(true);
+session.setTabSize(4);
+
+editor.moveCursorTo(1, 8);
+editor.remove("left");
+assert.equal(session.toString(), "123\n 456");
+
+editor.moveCursorTo(1, 0);
+editor.transposeLetters();
+
+assert.equal(session.getValue(), ["123", "4567", "89"].join("\n"));
+
+editor.moveCursorTo(1, 2);
+editor.transposeLetters();
+
+assert.equal(session.getValue(), ["123", "4657", "89"].join("\n"));
+
+editor.moveCursorTo(1, 4);
+editor.transposeLetters();
+
+assert.equal(session.getValue(), ["123", "4576", "89"].join("\n"));
+
+editor.moveCursorTo(1, 1);
+editor.getSelection().selectRight();
+editor.transposeLetters();
+
+assert.equal(session.getValue(), ["123", "4567", "89"].join("\n"));
+
+editor.moveCursorTo(1, 2);
+editor.transposeLetters();
+assert.position(editor.getCursorPosition(), 1, 3);
+
+editor.moveCursorTo(1, 2);
+editor.removeToLineEnd();
+assert.equal(session.getValue(), ["123", "45", "89"].join("\n"));
+
+editor.moveCursorTo(1, 4);
+editor.removeToLineEnd();
+assert.position(editor.getCursorPosition(), 1, 4);
+assert.equal(session.getValue(), ["123", "456789"].join("\n"));
+
+editor.moveCursorTo(1, 0);
+editor.getSelection().selectLineEnd();
+editor.toUpperCase()
+assert.equal(session.getValue(), ["ajax", "DOT", "org"].join("\n"));
+
+editor.moveCursorTo(1, 0);
+editor.toUpperCase()
+assert.equal(session.getValue(), ["ajax", "DOT", "org"].join("\n"));
+assert.position(editor.getCursorPosition(), 1, 0);
+
+editor.moveCursorTo(1, 0);
+editor.getSelection().selectLineEnd();
+editor.toLowerCase()
+assert.equal(session.getValue(), ["AJAX", "dot", "ORG"].join("\n"));
+
+editor.moveCursorTo(1, 0);
+editor.toLowerCase()
+assert.equal(session.getValue(), ["AJAX", "dot", "ORG"].join("\n"));
+assert.position(editor.getCursorPosition(), 1, 0);
+
diff --git a/ace/ace.d.ts b/ace/ace.d.ts
new file mode 100644
index 000000000..e0adada66
--- /dev/null
+++ b/ace/ace.d.ts
@@ -0,0 +1,2755 @@
+// Type definitions for Ace Ajax.org Cloud9 Editor
+// Project: http://ace.ajax.org/
+// Definitions by: Diullei Gomes
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+module AceAjax {
+
+ interface CommandManager {
+ addCommand(command);
+ }
+
+ interface TextMode {
+ getTokenizer(): any;
+ toggleCommentLines(state, doc, startRow, endRow);
+ getNextLineIndent (state, line, tab): any;
+ checkOutdent(state, line, input);
+ autoOutdent(state, doc, row);
+ createWorker(session);
+ createModeDelegates (mapping);
+ transformAction(state, action, editor, session, param);
+ }
+
+ ////////////////
+ /// Ace
+ ////////////////
+
+ /**
+ * The main class required to set up an Ace instance in the browser.
+ **/
+ interface Ace {
+
+ /**
+ * Provides access to require in packed noconflict mode
+ * @param moduleName
+ **/
+ require(moduleName: string): any;
+
+ /**
+ * Embeds the Ace editor into the DOM, at the element provided by `el`.
+ * @param el Either the id of an element, or the element itself
+ **/
+ edit(el: string): Editor;
+
+ /**
+ * Embeds the Ace editor into the DOM, at the element provided by `el`.
+ * @param el Either the id of an element, or the element itself
+ **/
+ edit(el: HTMLElement): Editor;
+
+ /**
+ * Creates a new [[EditSession]], and returns the associated [[Document]].
+ * @param text {:textParam}
+ * @param mode {:modeParam}
+ **/
+ createEditSession(text: Document, mode: TextMode): EditSession;
+
+ /**
+ * Creates a new [[EditSession]], and returns the associated [[Document]].
+ * @param text {:textParam}
+ * @param mode {:modeParam}
+ **/
+ createEditSession(text: string, mode: TextMode): EditSession;
+ }
+
+ ////////////////
+ /// Anchor
+ ////////////////
+
+ /**
+ * Defines the floating pointer in the document. Whenever text is inserted or deleted before the cursor, the position of the cursor is updated.
+ **/
+ interface Anchor {
+
+ on(event: string, fn: (e) => any);
+
+ /**
+ * Returns an object identifying the `row` and `column` position of the current anchor.
+ **/
+ getPosition(): any;
+
+ /**
+ * Returns the current document.
+ **/
+ getDocument(): Document;
+
+ /**
+ * Fires whenever the anchor position changes.
+ * Both of these objects have a `row` and `column` property corresponding to the position.
+ * Events that can trigger this function include [[Anchor.setPosition `setPosition()`]].
+ * @param e An object containing information about the anchor position. It has two properties:
+ * - `old`: An object describing the old Anchor position
+ * - `value`: An object describing the new Anchor position
+ **/
+ onChange(e: any);
+
+ /**
+ * Sets the anchor position to the specified row and column. If `noClip` is `true`, the position is not clipped.
+ * @param row The row index to move the anchor to
+ * @param column The column index to move the anchor to
+ * @param noClip Identifies if you want the position to be clipped
+ **/
+ setPosition(row: number, column: number, noClip: bool);
+
+ /**
+ * When called, the `'change'` event listener is removed.
+ **/
+ detach();
+ }
+ declare var Anchor: {
+ /**
+ * Creates a new `Anchor` and associates it with a document.
+ * @param doc The document to associate with the anchor
+ * @param row The starting row position
+ * @param column The starting column position
+ **/
+ new(doc: Document, row: number, column: number): Anchor;
+ }
+
+ ////////////////////////////////
+ /// BackgroundTokenizer
+ ////////////////////////////////
+
+ /**
+ * Tokenizes the current [[Document `Document`]] in the background, and caches the tokenized rows for future use.
+ * If a certain row is changed, everything below that row is re-tokenized.
+ **/
+ interface BackgroundTokenizer {
+
+ /**
+ * Sets a new tokenizer for this object.
+ * @param tokenizer The new tokenizer to use
+ **/
+ setTokenizer(tokenizer: Tokenizer);
+
+ /**
+ * Sets a new document to associate with this object.
+ * @param doc The new document to associate with
+ **/
+ setDocument(doc: Document);
+
+ /**
+ * Emits the `'update'` event. `firstRow` and `lastRow` are used to define the boundaries of the region to be updated.
+ * @param firstRow The starting row region
+ * @param lastRow The final row region
+ **/
+ fireUpdateEvent(firstRow: number, lastRow: number);
+
+ /**
+ * Starts tokenizing at the row indicated.
+ * @param startRow The row to start at
+ **/
+ start(startRow: number);
+
+ /**
+ * Stops tokenizing.
+ **/
+ stop();
+
+ /**
+ * Gives list of tokens of the row. (tokens are cached)
+ * @param row The row to get tokens at
+ **/
+ getTokens(row: number);
+
+ /**
+ * [Returns the state of tokenization at the end of a row.]{: #BackgroundTokenizer.getState}
+ * @param row The row to get state at
+ **/
+ getState(row: number);
+ }
+ declare var BackgroundTokenizer: {
+ /**
+ * Creates a new `BackgroundTokenizer` object.
+ * @param tokenizer The tokenizer to use
+ * @param editor The editor to associate with
+ **/
+ new(tokenizer: Tokenizer, editor: Editor): BackgroundTokenizer;
+ }
+
+ ////////////////
+ /// Document
+ ////////////////
+
+ /**
+ * Contains the text of the document. Document can be attached to several [[EditSession `EditSession`]]s.
+ * At its core, `Document`s are just an array of strings, with each row in the document matching up to the array index.
+ **/
+ interface Document {
+
+ /**
+ * Replaces all the lines in the current `Document` with the value of `text`.
+ * @param text The text to use
+ **/
+ setValue(text: string);
+
+ /**
+ * Returns all the lines in the document as a single string, split by the new line character.
+ **/
+ getValue();
+
+ /**
+ * Creates a new `Anchor` to define a floating point in the document.
+ * @param row The row number to use
+ * @param column The column number to use
+ **/
+ createAnchor(row: number, column: number);
+
+ /**
+ * Returns the newline character that's being used, depending on the value of `newLineMode`.
+ **/
+ getNewLineCharacter(): string;
+
+ /**
+ * [Sets the new line mode.]{: #Document.setNewLineMode.desc}
+ * @param newLineMode [The newline mode to use; can be either `windows`, `unix`, or `auto`]{: #Document.setNewLineMode.param}
+ **/
+ setNewLineMode(newLineMode: string);
+
+ /**
+ * [Returns the type of newlines being used; either `windows`, `unix`, or `auto`]{: #Document.getNewLineMode}
+ **/
+ getNewLineMode(): string;
+
+ /**
+ * Returns `true` if `text` is a newline character (either `\r\n`, `\r`, or `\n`).
+ * @param text The text to check
+ **/
+ isNewLine(text: string);
+
+ /**
+ * Returns a verbatim copy of the given line as it is in the document
+ * @param row The row index to retrieve
+ **/
+ getLine(row: number);
+
+ /**
+ * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`.
+ * @param firstRow The first row index to retrieve
+ * @param lastRow The final row index to retrieve
+ **/
+ getLines(firstRow: number, lastRow: number);
+
+ /**
+ * Returns all lines in the document as string array. Warning: The caller should not modify this array!
+ **/
+ getAllLines();
+
+ /**
+ * Returns the number of rows in the document.
+ **/
+ getLength();
+
+ /**
+ * [Given a range within the document, this function returns all the text within that range as a single string.]{: #Document.getTextRange.desc}
+ * @param range The range to work with
+ **/
+ getTextRange(range: Range);
+
+ /**
+ * Inserts a block of `text` and the indicated `position`.
+ * @param position The position to start inserting at
+ * @param text A chunk of text to insert
+ **/
+ insert(position: any, text: string): any;
+
+ /**
+ * Inserts the elements in `lines` into the document, starting at the row index given by `row`. This method also triggers the `'change'` event.
+ * @param row The index of the row to insert at
+ * @param lines An array of strings
+ **/
+ insertLines(row: number, lines: Array): any;
+
+ /**
+ * Inserts a new line into the document at the current row's `position`. This method also triggers the `'change'` event.
+ * @param position The position to insert at
+ **/
+ insertNewLine(position: any): any;
+
+ /**
+ * Inserts `text` into the `position` at the current row. This method also triggers the `'change'` event.
+ * @param position The position to insert at
+ * @param text A chunk of text
+ **/
+ insertInLine(position: any, text: string): any;
+
+ /**
+ * Removes the `range` from the document.
+ * @param range A specified Range to remove
+ **/
+ remove(range: Range): any;
+
+ /**
+ * Removes the specified columns from the `row`. This method also triggers the `'change'` event.
+ * @param row The row to remove from
+ * @param startColumn The column to start removing at
+ * @param endColumn The column to stop removing at
+ **/
+ removeInLine(row: number, startColumn: number, endColumn: number): any;
+
+ /**
+ * Removes a range of full lines. This method also triggers the `'change'` event.
+ * @param firstRow The first row to be removed
+ * @param lastRow The last row to be removed
+ **/
+ removeLines(firstRow: number, lastRow: number): string[];
+
+ /**
+ * Removes the new line between `row` and the row immediately following it. This method also triggers the `'change'` event.
+ * @param row The row to check
+ **/
+ removeNewLine(row: number);
+
+ /**
+ * Replaces a range in the document with the new `text`.
+ * @param range A specified Range to replace
+ * @param text The new text to use as a replacement
+ **/
+ replace(range: Range, text: string): any;
+
+ /**
+ * Applies all the changes previously accumulated. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`.
+ **/
+ applyDeltas();
+
+ /**
+ * Reverts any changes previously applied. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`.
+ **/
+ revertDeltas();
+
+ /**
+ * Converts an index position in a document to a `{row, column}` object.
+ * Index refers to the "absolute position" of a character in the document. For example:
+ * ```javascript
+ * var x = 0; // 10 characters, plus one for newline
+ * var y = -1;
+ * ```
+ * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second.
+ * @param index An index to convert
+ * @param startRow=0 The row from which to start the conversion
+ **/
+ indexToPosition(index: number, startRow: number): any;
+
+ /**
+ * Converts the `{row, column}` position in a document to the character's index.
+ * Index refers to the "absolute position" of a character in the document. For example:
+ * ```javascript
+ * var x = 0; // 10 characters, plus one for newline
+ * var y = -1;
+ * ```
+ * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second.
+ * @param pos The `{row, column}` to convert
+ * @param startRow=0 The row from which to start the conversion
+ **/
+ positionToIndex(pos: any, startRow: number): number;
+ }
+ declare var Document: {
+ /**
+ * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty.
+ * @param text The starting text
+ **/
+ new(text?: string): Document;
+ /**
+ * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty.
+ * @param text The starting text
+ **/
+ new(text?: string[]): Document;
+ }
+
+ ////////////////////////////////
+ /// EditSession
+ ////////////////////////////////
+
+ /**
+ * Stores all the data about [[Editor `Editor`]] state providing easy way to change editors state.
+ * `EditSession` can be attached to only one [[Document `Document`]]. Same `Document` can be attached to several `EditSession`s.
+ **/
+ interface EditSession {
+
+ on(event: string, fn: (e) => any);
+
+ selection: Selection;
+
+ /**
+ * Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`.
+ * @param doc The new `Document` to use
+ **/
+ setDocument(doc: Document);
+
+ /**
+ * Returns the `Document` associated with this session.
+ **/
+ getDocument();
+
+ /**
+ * undefined
+ * @param row The row to work with
+ **/
+ $resetRowCache(row: number);
+
+ /**
+ * Sets the session text.
+ * @param text The new text to place
+ **/
+ setValue(text: string);
+
+ setMode(mode: string);
+
+ /**
+ * Returns the current [[Document `Document`]] as a string.
+ **/
+ getValue(): string;
+
+ /**
+ * Returns the string of the current selection.
+ **/
+ getSelection(): Selection;
+
+ /**
+ * {:BackgroundTokenizer.getState}
+ * @param row The row to start at
+ **/
+ getState(row: number);
+
+ /**
+ * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows.
+ * @param row The row to start at
+ **/
+ getTokens(row: number);
+
+ /**
+ * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`.
+ * @param row The row number to retrieve from
+ * @param column The column number to retrieve from
+ **/
+ getTokenAt(row: number, column: number);
+
+ /**
+ * Sets the undo manager.
+ * @param undoManager The new undo manager
+ **/
+ setUndoManager(undoManager: UndoManager);
+
+ /**
+ * Returns the current undo manager.
+ **/
+ getUndoManager();
+
+ /**
+ * Returns the current value for tabs. If the user is using soft tabs, this will be a series of spaces (defined by [[EditSession.getTabSize `getTabSize()`]]); otherwise it's simply `'\t'`.
+ **/
+ getTabString();
+
+ /**
+ * Pass `true` to enable the use of soft tabs. Soft tabs means you're using spaces instead of the tab character (`'\t'`).
+ * @param useSoftTabs Value indicating whether or not to use soft tabs
+ **/
+ setUseSoftTabs(useSoftTabs: bool);
+
+ /**
+ * Returns `true` if soft tabs are being used, `false` otherwise.
+ **/
+ getUseSoftTabs(): bool;
+
+ /**
+ * Set the number of spaces that define a soft tab; for example, passing in `4` transforms the soft tabs to be equivalent to four spaces. This function also emits the `changeTabSize` event.
+ * @param tabSize The new tab size
+ **/
+ setTabSize(tabSize: number);
+
+ /**
+ * Returns the current tab size.
+ **/
+ getTabSize();
+
+ /**
+ * Returns `true` if the character at the position is a soft tab.
+ * @param position The position to check
+ **/
+ isTabStop(position: any);
+
+ /**
+ * Pass in `true` to enable overwrites in your session, or `false` to disable.
+ * If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event.
+ * @param overwrite Defines wheter or not to set overwrites
+ **/
+ setOverwrite(overwrite: bool);
+
+ /**
+ * Returns `true` if overwrites are enabled; `false` otherwise.
+ **/
+ getOverwrite();
+
+ /**
+ * Sets the value of overwrite to the opposite of whatever it currently is.
+ **/
+ toggleOverwrite();
+
+ /**
+ * Adds `className` to the `row`, to be used for CSS stylings and whatnot.
+ * @param row The row number
+ * @param className The class to add
+ **/
+ addGutterDecoration(row: number, className: string);
+
+ /**
+ * Removes `className` from the `row`.
+ * @param row The row number
+ * @param className The class to add
+ **/
+ removeGutterDecoration(row: number, className: string);
+
+ /**
+ * Returns an array of numbers, indicating which rows have breakpoints.
+ **/
+ getBreakpoints(): number[];
+
+ /**
+ * Sets a breakpoint on every row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
+ * @param rows An array of row indices
+ **/
+ setBreakpoints(rows: Array);
+
+ /**
+ * Removes all breakpoints on the rows. This function also emites the `'changeBreakpoint'` event.
+ **/
+ clearBreakpoints();
+
+ /**
+ * Sets a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
+ * @param row A row index
+ * @param className Class of the breakpoint
+ **/
+ setBreakpoint(row: number, className: string);
+
+ /**
+ * Removes a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
+ * @param row A row index
+ **/
+ clearBreakpoint(row: number);
+
+ /**
+ * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires.
+ * @param range Define the range of the marker
+ * @param clazz Set the CSS class for the marker
+ * @param type Identify the type of the marker
+ * @param inFront Set to `true` to establish a front marker
+ **/
+ addMarker(range: Range, clazz: string, type: Function, inFront: bool);
+
+ /**
+ * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires.
+ * @param range Define the range of the marker
+ * @param clazz Set the CSS class for the marker
+ * @param type Identify the type of the marker
+ * @param inFront Set to `true` to establish a front marker
+ **/
+ addMarker(range: Range, clazz: string, type: string, inFront: bool);
+
+ /**
+ * Adds a dynamic marker to the session.
+ * @param marker object with update method
+ * @param inFront Set to `true` to establish a front marker
+ **/
+ addDynamicMarker(marker: any, inFront: bool);
+
+ /**
+ * Removes the marker with the specified ID. If this marker was in front, the `'changeFrontMarker'` event is emitted. If the marker was in the back, the `'changeBackMarker'` event is emitted.
+ * @param markerId A number representing a marker
+ **/
+ removeMarker(markerId: number);
+
+ /**
+ * Returns an array containing the IDs of all the markers, either front or back.
+ * @param inFront If `true`, indicates you only want front markers; `false` indicates only back markers
+ **/
+ getMarkers(inFront: bool): Array;
+
+ /**
+ * Sets annotations for the `EditSession`. This functions emits the `'changeAnnotation'` event.
+ * @param annotations A list of annotations
+ **/
+ setAnnotations(annotations: Array);
+
+ /**
+ * Returns the annotations for the `EditSession`.
+ **/
+ getAnnotations(): any;
+
+ /**
+ * Clears all the annotations for this session. This function also triggers the `'changeAnnotation'` event.
+ **/
+ clearAnnotations();
+
+ /**
+ * If `text` contains either the newline (`\n`) or carriage-return ('\r') characters, `$autoNewLine` stores that value.
+ * @param text A block of text
+ **/
+ $detectNewLine(text: string);
+
+ /**
+ * Given a starting row and column, this method returns the `Range` of the first word boundary it finds.
+ * @param row The row to start at
+ * @param column The column to start at
+ **/
+ getWordRange(row: number, column: number): Range;
+
+ /**
+ * Gets the range of a word, including its right whitespace.
+ * @param row The row number to start from
+ * @param column The column number to start from
+ **/
+ getAWordRange(row: number, column: number);
+
+ /**
+ * {:Document.setNewLineMode.desc}
+ * @param newLineMode {:Document.setNewLineMode.param}
+ **/
+ setNewLineMode(newLineMode: string);
+
+ /**
+ * Returns the current new line mode.
+ **/
+ getNewLineMode(): string;
+
+ /**
+ * Identifies if you want to use a worker for the `EditSession`.
+ * @param useWorker Set to `true` to use a worker
+ **/
+ setUseWorker(useWorker: bool);
+
+ /**
+ * Returns `true` if workers are being used.
+ **/
+ getUseWorker();
+
+ /**
+ * Reloads all the tokens on the current session. This function calls [[BackgroundTokenizer.start `BackgroundTokenizer.start ()`]] to all the rows; it also emits the `'tokenizerUpdate'` event.
+ **/
+ onReloadTokenizer();
+
+ /**
+ * Sets a new text mode for the `EditSession`. This method also emits the `'changeMode'` event. If a [[BackgroundTokenizer `BackgroundTokenizer`]] is set, the `'tokenizerUpdate'` event is also emitted.
+ * @param mode Set a new text mode
+ **/
+ $mode(mode: TextMode);
+
+ /**
+ * Returns the current text mode.
+ **/
+ getMode(): TextMode;
+
+ /**
+ * This function sets the scroll top value. It also emits the `'changeScrollTop'` event.
+ * @param scrollTop The new scroll top value
+ **/
+ setScrollTop(scrollTop: number);
+
+ /**
+ * [Returns the value of the distance between the top of the editor and the topmost part of the visible content.]{: #EditSession.getScrollTop}
+ **/
+ getScrollTop(): number;
+
+ /**
+ * [Sets the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.setScrollLeft}
+ **/
+ setScrollLeft();
+
+ /**
+ * [Returns the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.getScrollLeft}
+ **/
+ getScrollLeft(): number;
+
+ /**
+ * Returns the width of the screen.
+ **/
+ getScreenWidth(): number;
+
+ /**
+ * Returns a verbatim copy of the given line as it is in the document
+ * @param row The row to retrieve from
+ **/
+ getLine(row: number): string;
+
+ /**
+ * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`.
+ * @param firstRow The first row index to retrieve
+ * @param lastRow The final row index to retrieve
+ **/
+ getLines(firstRow: number, lastRow: number): string[];
+
+ /**
+ * Returns the number of rows in the document.
+ **/
+ getLength(): number;
+
+ /**
+ * {:Document.getTextRange.desc}
+ * @param range The range to work with
+ **/
+ getTextRange(range: Range): string;
+
+ /**
+ * Inserts a block of `text` and the indicated `position`.
+ * @param position The position {row, column} to start inserting at
+ * @param text A chunk of text to insert
+ **/
+ insert(position: any, text: string): any;
+
+ /**
+ * Removes the `range` from the document.
+ * @param range A specified Range to remove
+ **/
+ remove(range: Range): any;
+
+ /**
+ * Reverts previous changes to your document.
+ * @param deltas An array of previous changes
+ * @param dontSelect [If `true`, doesn't select the range of where the change occured]{: #dontSelect}
+ **/
+ undoChanges(deltas: Array, dontSelect: bool): Range;
+
+ /**
+ * Re-implements a previously undone change to your document.
+ * @param deltas An array of previous changes
+ * @param dontSelect {:dontSelect}
+ **/
+ redoChanges(deltas: Array, dontSelect: bool): Range;
+
+ /**
+ * Enables or disables highlighting of the range where an undo occured.
+ * @param enable If `true`, selects the range of the reinserted change
+ **/
+ setUndoSelect(enable: bool);
+
+ /**
+ * Replaces a range in the document with the new `text`.
+ * @param range A specified Range to replace
+ * @param text The new text to use as a replacement
+ **/
+ replace(range: Range, text: string): any;
+
+ /**
+ * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this:
+ * ```json
+ * { row: newRowLocation, column: newColumnLocation }
+ * ```
+ * @param fromRange The range of text you want moved within the document
+ * @param toPosition The location (row and column) where you want to move the text to
+ **/
+ moveText(fromRange: Range, toPosition: any): Range;
+
+ /**
+ * Indents all the rows, from `startRow` to `endRow` (inclusive), by prefixing each row with the token in `indentString`.
+ * If `indentString` contains the `'\t'` character, it's replaced by whatever is defined by [[EditSession.getTabString `getTabString()`]].
+ * @param startRow Starting row
+ * @param endRow Ending row
+ * @param indentString The indent token
+ **/
+ indentRows(startRow: number, endRow: number, indentString: string);
+
+ /**
+ * Outdents all the rows defined by the `start` and `end` properties of `range`.
+ * @param range A range of rows
+ **/
+ outdentRows(range: Range);
+
+ /**
+ * Shifts all the lines in the document up one, starting from `firstRow` and ending at `lastRow`.
+ * @param firstRow The starting row to move up
+ * @param lastRow The final row to move up
+ **/
+ moveLinesUp(firstRow: number, lastRow: number): number;
+
+ /**
+ * Shifts all the lines in the document down one, starting from `firstRow` and ending at `lastRow`.
+ * @param firstRow The starting row to move down
+ * @param lastRow The final row to move down
+ **/
+ moveLinesDown(firstRow: number, lastRow: number): number;
+
+ /**
+ * Duplicates all the text between `firstRow` and `lastRow`.
+ * @param firstRow The starting row to duplicate
+ * @param lastRow The final row to duplicate
+ **/
+ duplicateLines(firstRow: number, lastRow: number): number;
+
+ /**
+ * Sets whether or not line wrapping is enabled. If `useWrapMode` is different than the current value, the `'changeWrapMode'` event is emitted.
+ * @param useWrapMode Enable (or disable) wrap mode
+ **/
+ setUseWrapMode(useWrapMode: bool);
+
+ /**
+ * Returns `true` if wrap mode is being used; `false` otherwise.
+ **/
+ getUseWrapMode(): bool;
+
+ /**
+ * Sets the boundaries of wrap. Either value can be `null` to have an unconstrained wrap, or, they can be the same number to pin the limit. If the wrap limits for `min` or `max` are different, this method also emits the `'changeWrapMode'` event.
+ * @param min The minimum wrap value (the left side wrap)
+ * @param max The maximum wrap value (the right side wrap)
+ **/
+ setWrapLimitRange(min: number, max: number);
+
+ /**
+ * This should generally only be called by the renderer when a resize is detected.
+ * @param desiredLimit The new wrap limit
+ **/
+ adjustWrapLimit(desiredLimit: number): bool;
+
+ /**
+ * Returns the value of wrap limit.
+ **/
+ getWrapLimit(): number;
+
+ /**
+ * Returns an object that defines the minimum and maximum of the wrap limit; it looks something like this:
+ * { min: wrapLimitRange_min, max: wrapLimitRange_max }
+ **/
+ getWrapLimitRange(): any;
+
+ /**
+ * Given a string, returns an array of the display characters, including tabs and spaces.
+ * @param str The string to check
+ * @param offset The value to start at
+ **/
+ $getDisplayTokens(str: string, offset: number);
+
+ /**
+ * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen.
+ * @param str The string to calculate the screen width of
+ * @param maxScreenColumn
+ * @param screenColumn
+ **/
+ $getStringScreenWidth(str: string, maxScreenColumn: number, screenColumn: number): number[];
+
+ /**
+ * Returns number of screenrows in a wrapped line.
+ * @param row The row number to check
+ **/
+ getRowLength(row: number): number;
+
+ /**
+ * Returns the position (on screen) for the last character in the provided screen row.
+ * @param screenRow The screen row to check
+ **/
+ getScreenLastRowColumn(screenRow: number): number;
+
+ /**
+ * For the given document row and column, this returns the column position of the last screen row.
+ * @param docRow
+ * @param docColumn
+ **/
+ getDocumentLastRowColumn(docRow: number, docColumn: number);
+
+ /**
+ * For the given document row and column, this returns the document position of the last row.
+ * @param docRow
+ * @param docColumn
+ **/
+ getDocumentLastRowColumnPosition(docRow: number, docColumn: number);
+
+ /**
+ * For the given row, this returns the split data.
+ **/
+ getRowSplitData(): string;
+
+ /**
+ * The distance to the next tab stop at the specified screen column.
+ * @param screenColumn The screen column to check
+ **/
+ getScreenTabSize(screenColumn: number): number;
+
+ /**
+ * Converts characters coordinates on the screen to characters coordinates within the document. [This takes into account code folding, word wrap, tab size, and any other visual modifications.]{: #conversionConsiderations}
+ * @param screenRow The screen row to check
+ * @param screenColumn The screen column to check
+ **/
+ screenToDocumentPosition(screenRow: number, screenColumn: number): any;
+
+ /**
+ * Converts document coordinates to screen coordinates. {:conversionConsiderations}
+ * @param docRow The document row to check
+ * @param docColumn The document column to check
+ **/
+ documentToScreenPosition(docRow: number, docColumn: number): any;
+
+ /**
+ * For the given document row and column, returns the screen column.
+ * @param row
+ * @param docColumn
+ **/
+ documentToScreenColumn(row: number, docColumn: number): number;
+
+ /**
+ * For the given document row and column, returns the screen row.
+ * @param docRow
+ * @param docColumn
+ **/
+ documentToScreenRow(docRow: number, docColumn: number);
+
+ /**
+ * Returns the length of the screen.
+ **/
+ getScreenLength(): number;
+ }
+ declare var EditSession: {
+ /**
+ * Sets up a new `EditSession` and associates it with the given `Document` and `TextMode`.
+ * @param text [If `text` is a `Document`, it associates the `EditSession` with it. Otherwise, a new `Document` is created, with the initial text]{: #textParam}
+ * @param mode [The inital language mode to use for the document]{: #modeParam}
+ **/
+ new(text: string, mode?: TextMode): EditSession;
+
+ new(text: string[]): EditSession;
+ }
+
+ ////////////////////////////////
+ /// Editor
+ ////////////////////////////////
+
+ /**
+ * The main entry point into the Ace functionality.
+ * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen.
+ * Event sessions dealing with the mouse and keyboard are bubbled up from `Document` to the `Editor`, which decides what to do with them.
+ **/
+ interface Editor {
+
+ onTextInput(text: string);
+
+ onCommandKey(e, hashId, keyCode);
+
+ commands: CommandManager;
+
+ session: EditSession;
+
+ selection: Selection;
+
+ /**
+ * Sets a new key handler, such as "vim" or "windows".
+ * @param keyboardHandler The new key handler
+ **/
+ setKeyboardHandler(keyboardHandler: string);
+
+ /**
+ * Returns the keyboard handler, such as "vim" or "windows".
+ **/
+ getKeyboardHandler(): string;
+
+ /**
+ * Sets a new editsession to use. This method also emits the `'changeSession'` event.
+ * @param session The new session to use
+ **/
+ setSession(session: EditSession);
+
+ /**
+ * Returns the current session being used.
+ **/
+ getSession(): EditSession;
+
+ /**
+ * Sets the current document to `val`.
+ * @param val The new value to set for the document
+ * @param cursorPos Where to set the new value. `undefined` or 0 is selectAll, -1 is at the document start, and 1 is at the end
+ **/
+ setValue(val: string, cursorPos?: number): string;
+
+ /**
+ * Returns the current session's content.
+ **/
+ getValue(): string;
+
+ /**
+ * Returns the currently highlighted selection.
+ **/
+ getSelection(): Selection;
+
+ /**
+ * {:VirtualRenderer.onResize}
+ * @param force If `true`, recomputes the size, even if the height and width haven't changed
+ **/
+ resize(force?: bool);
+
+ /**
+ * {:VirtualRenderer.setTheme}
+ * @param theme The path to a theme
+ **/
+ setTheme(theme: string);
+
+ /**
+ * {:VirtualRenderer.getTheme}
+ **/
+ getTheme(): string;
+
+ /**
+ * {:VirtualRenderer.setStyle}
+ * @param style A class name
+ **/
+ setStyle(style: string);
+
+ /**
+ * {:VirtualRenderer.unsetStyle}
+ **/
+ unsetStyle();
+
+ /**
+ * Set a new font size (in pixels) for the editor text.
+ * @param size A font size ( _e.g._ "12px")
+ **/
+ setFontSize(size: string);
+
+ /**
+ * Brings the current `textInput` into focus.
+ **/
+ focus();
+
+ /**
+ * Returns `true` if the current `textInput` is in focus.
+ **/
+ isFocused();
+
+ /**
+ * Blurs the current `textInput`.
+ **/
+ blur();
+
+ /**
+ * Emitted once the editor comes into focus.
+ **/
+ onFocus();
+
+ /**
+ * Emitted once the editor has been blurred.
+ **/
+ onBlur();
+
+ /**
+ * Emitted whenever the document is changed.
+ * @param e Contains a single property, `data`, which has the delta of changes
+ **/
+ onDocumentChange(e: any);
+
+ /**
+ * Emitted when the selection changes.
+ **/
+ onCursorChange();
+
+ /**
+ * Returns the string of text currently highlighted.
+ **/
+ getCopyText(): string;
+
+ /**
+ * Called whenever a text "copy" happens.
+ **/
+ onCopy();
+
+ /**
+ * Called whenever a text "cut" happens.
+ **/
+ onCut();
+
+ /**
+ * Called whenever a text "paste" happens.
+ * @param text The pasted text
+ **/
+ onPaste(text: string);
+
+ /**
+ * Inserts `text` into wherever the cursor is pointing.
+ * @param text The new text to add
+ **/
+ insert(text: string);
+
+ /**
+ * Pass in `true` to enable overwrites in your session, or `false` to disable. If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event.
+ * @param overwrite Defines wheter or not to set overwrites
+ **/
+ setOverwrite(overwrite: bool);
+
+ /**
+ * Returns `true` if overwrites are enabled; `false` otherwise.
+ **/
+ getOverwrite(): bool;
+
+ /**
+ * Sets the value of overwrite to the opposite of whatever it currently is.
+ **/
+ toggleOverwrite();
+
+ /**
+ * Sets how fast the mouse scrolling should do.
+ * @param speed A value indicating the new speed (in milliseconds)
+ **/
+ setScrollSpeed(speed: number);
+
+ /**
+ * Returns the value indicating how fast the mouse scroll speed is (in milliseconds).
+ **/
+ getScrollSpeed(): number;
+
+ /**
+ * Sets the delay (in milliseconds) of the mouse drag.
+ * @param dragDelay A value indicating the new delay
+ **/
+ setDragDelay(dragDelay: number);
+
+ /**
+ * Returns the current mouse drag delay.
+ **/
+ getDragDelay(): number;
+
+ /**
+ * Indicates how selections should occur.
+ * By default, selections are set to "line". There are no other styles at the moment,
+ * although this code change in the future.
+ * This function also emits the `'changeSelectionStyle'` event.
+ * @param style The new selection style
+ **/
+ setSelectionStyle(style: string);
+
+ /**
+ * Returns the current selection style.
+ **/
+ getSelectionStyle(): string;
+
+ /**
+ * Determines whether or not the current line should be highlighted.
+ * @param shouldHighlight Set to `true` to highlight the current line
+ **/
+ setHighlightActiveLine(shouldHighlight: bool);
+
+ /**
+ * Returns `true` if current lines are always highlighted.
+ **/
+ getHighlightActiveLine();
+
+ /**
+ * Determines if the currently selected word should be highlighted.
+ * @param shouldHighlight Set to `true` to highlight the currently selected word
+ **/
+ setHighlightSelectedWord(shouldHighlight: bool);
+
+ /**
+ * Returns `true` if currently highlighted words are to be highlighted.
+ **/
+ getHighlightSelectedWord(): bool;
+
+ /**
+ * If `showInvisibiles` is set to `true`, invisible characters—like spaces or new lines—are show in the editor.
+ * @param showInvisibles Specifies whether or not to show invisible characters
+ **/
+ setShowInvisibles(showInvisibles: bool);
+
+ /**
+ * Returns `true` if invisible characters are being shown.
+ **/
+ getShowInvisibles(): bool;
+
+ /**
+ * If `showPrintMargin` is set to `true`, the print margin is shown in the editor.
+ * @param showPrintMargin Specifies whether or not to show the print margin
+ **/
+ setShowPrintMargin(showPrintMargin: bool);
+
+ /**
+ * Returns `true` if the print margin is being shown.
+ **/
+ getShowPrintMargin(): bool;
+
+ /**
+ * Sets the column defining where the print margin should be.
+ * @param showPrintMargin Specifies the new print margin
+ **/
+ setPrintMarginColumn(showPrintMargin: number);
+
+ /**
+ * Returns the column number of where the print margin is.
+ **/
+ getPrintMarginColumn(): number;
+
+ /**
+ * If `readOnly` is true, then the editor is set to read-only mode, and none of the content can change.
+ * @param readOnly Specifies whether the editor can be modified or not
+ **/
+ setReadOnly(readOnly: bool);
+
+ /**
+ * Returns `true` if the editor is set to read-only mode.
+ **/
+ getReadOnly(): bool;
+
+ /**
+ * Specifies whether to use behaviors or not. ["Behaviors" in this case is the auto-pairing of special characters, like quotation marks, parenthesis, or brackets.]{: #BehaviorsDef}
+ * @param enabled Enables or disables behaviors
+ **/
+ setBehavioursEnabled(enabled: bool);
+
+ /**
+ * Returns `true` if the behaviors are currently enabled. {:BehaviorsDef}
+ **/
+ getBehavioursEnabled(): bool;
+
+ /**
+ * Specifies whether to use wrapping behaviors or not, i.e. automatically wrapping the selection with characters such as brackets
+ * when such a character is typed in.
+ * @param enabled Enables or disables wrapping behaviors
+ **/
+ setWrapBehavioursEnabled(enabled: bool);
+
+ /**
+ * Returns `true` if the wrapping behaviors are currently enabled.
+ **/
+ getWrapBehavioursEnabled();
+
+ /**
+ * Indicates whether the fold widgets are shown or not.
+ * @param show Specifies whether the fold widgets are shown
+ **/
+ setShowFoldWidgets(show: bool);
+
+ /**
+ * Returns `true` if the fold widgets are shown.
+ **/
+ getShowFoldWidgets();
+
+ /**
+ * Removes words of text from the editor. A "word" is defined as a string of characters bookended by whitespace.
+ * @param dir The direction of the deletion to occur, either "left" or "right"
+ **/
+ remove(dir: string);
+
+ /**
+ * Removes the word directly to the right of the current selection.
+ **/
+ removeWordRight();
+
+ /**
+ * Removes the word directly to the left of the current selection.
+ **/
+ removeWordLeft();
+
+ /**
+ * Removes all the words to the left of the current selection, until the start of the line.
+ **/
+ removeToLineStart();
+
+ /**
+ * Removes all the words to the right of the current selection, until the end of the line.
+ **/
+ removeToLineEnd();
+
+ /**
+ * Splits the line at the current selection (by inserting an `'\n'`).
+ **/
+ splitLine();
+
+ /**
+ * Transposes current line.
+ **/
+ transposeLetters();
+
+ /**
+ * Converts the current selection entirely into lowercase.
+ **/
+ toLowerCase();
+
+ /**
+ * Converts the current selection entirely into uppercase.
+ **/
+ toUpperCase();
+
+ /**
+ * Inserts an indentation into the current cursor position or indents the selected lines.
+ **/
+ indent();
+
+ /**
+ * Indents the current line.
+ **/
+ blockIndent();
+
+ /**
+ * Outdents the current line.
+ **/
+ blockOutdent(arg?: string);
+
+ /**
+ * Given the currently selected range, this function either comments all the lines, or uncomments all of them.
+ **/
+ toggleCommentLines();
+
+ /**
+ * Works like [[EditSession.getTokenAt]], except it returns a number.
+ **/
+ getNumberAt(): number;
+
+ /**
+ * If the character before the cursor is a number, this functions changes its value by `amount`.
+ * @param amount The value to change the numeral by (can be negative to decrease value)
+ **/
+ modifyNumber(amount: number);
+
+ /**
+ * Removes all the lines in the current selection
+ **/
+ removeLines();
+
+ /**
+ * Shifts all the selected lines down one row.
+ **/
+ moveLinesDown(): number;
+
+ /**
+ * Shifts all the selected lines up one row.
+ **/
+ moveLinesUp(): number;
+
+ /**
+ * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this:
+ * ```json
+ * { row: newRowLocation, column: newColumnLocation }
+ * ```
+ * @param fromRange The range of text you want moved within the document
+ * @param toPosition The location (row and column) where you want to move the text to
+ **/
+ moveText(fromRange: Range, toPosition: any): Range;
+
+ /**
+ * Copies all the selected lines up one row.
+ **/
+ copyLinesUp(): number;
+
+ /**
+ * Copies all the selected lines down one row.
+ **/
+ copyLinesDown(): number;
+
+ /**
+ * {:VirtualRenderer.getFirstVisibleRow}
+ **/
+ getFirstVisibleRow(): number;
+
+ /**
+ * {:VirtualRenderer.getLastVisibleRow}
+ **/
+ getLastVisibleRow(): number;
+
+ /**
+ * Indicates if the row is currently visible on the screen.
+ * @param row The row to check
+ **/
+ isRowVisible(row: number): bool;
+
+ /**
+ * Indicates if the entire row is currently visible on the screen.
+ * @param row The row to check
+ **/
+ isRowFullyVisible(row: number): bool;
+
+ /**
+ * Selects the text from the current position of the document until where a "page down" finishes.
+ **/
+ selectPageDown();
+
+ /**
+ * Selects the text from the current position of the document until where a "page up" finishes.
+ **/
+ selectPageUp();
+
+ /**
+ * Shifts the document to wherever "page down" is, as well as moving the cursor position.
+ **/
+ gotoPageDown();
+
+ /**
+ * Shifts the document to wherever "page up" is, as well as moving the cursor position.
+ **/
+ gotoPageUp();
+
+ /**
+ * Scrolls the document to wherever "page down" is, without changing the cursor position.
+ **/
+ scrollPageDown();
+
+ /**
+ * Scrolls the document to wherever "page up" is, without changing the cursor position.
+ **/
+ scrollPageUp();
+
+ /**
+ * Moves the editor to the specified row.
+ **/
+ scrollToRow();
+
+ /**
+ * Scrolls to a line. If `center` is `true`, it puts the line in middle of screen (or attempts to).
+ * @param line The line to scroll to
+ * @param center If `true`
+ * @param animate If `true` animates scrolling
+ * @param callback Function to be called when the animation has finished
+ **/
+ scrollToLine(line: number, center: bool, animate: bool, callback: Function);
+
+ /**
+ * Attempts to center the current selection on the screen.
+ **/
+ centerSelection();
+
+ /**
+ * Gets the current position of the cursor.
+ **/
+ getCursorPosition(): any;
+
+ /**
+ * Returns the screen position of the cursor.
+ **/
+ getCursorPositionScreen(): number;
+
+ /**
+ * {:Selection.getRange}
+ **/
+ getSelectionRange(): Range;
+
+ /**
+ * Selects all the text in editor.
+ **/
+ selectAll();
+
+ /**
+ * {:Selection.clearSelection}
+ **/
+ clearSelection();
+
+ /**
+ * Moves the cursor to the specified row and column. Note that this does not de-select the current selection.
+ * @param row The new row number
+ * @param column The new column number
+ **/
+ moveCursorTo(row: number, column: number);
+
+ /**
+ * Moves the cursor to the position indicated by `pos.row` and `pos.column`.
+ * @param pos An object with two properties, row and column
+ **/
+ moveCursorToPosition(pos: any);
+
+ /**
+ * Moves the cursor's row and column to the next matching bracket.
+ **/
+ jumpToMatching();
+
+ /**
+ * Moves the cursor to the specified line number, and also into the indiciated column.
+ * @param lineNumber The line number to go to
+ * @param column A column number to go to
+ * @param animate If `true` animates scolling
+ **/
+ gotoLine(lineNumber: number, column?: number, animate?: bool);
+
+ /**
+ * Moves the cursor to the specified row and column. Note that this does de-select the current selection.
+ * @param row The new row number
+ * @param column The new column number
+ **/
+ navigateTo(row: number, column: number);
+
+ /**
+ * Moves the cursor up in the document the specified number of times. Note that this does de-select the current selection.
+ * @param times The number of times to change navigation
+ **/
+ navigateUp(times: number);
+
+ /**
+ * Moves the cursor down in the document the specified number of times. Note that this does de-select the current selection.
+ * @param times The number of times to change navigation
+ **/
+ navigateDown(times: number);
+
+ /**
+ * Moves the cursor left in the document the specified number of times. Note that this does de-select the current selection.
+ * @param times The number of times to change navigation
+ **/
+ navigateLeft(times: number);
+
+ /**
+ * Moves the cursor right in the document the specified number of times. Note that this does de-select the current selection.
+ * @param times The number of times to change navigation
+ **/
+ navigateRight(times: number);
+
+ /**
+ * Moves the cursor to the start of the current line. Note that this does de-select the current selection.
+ **/
+ navigateLineStart();
+
+ /**
+ * Moves the cursor to the end of the current line. Note that this does de-select the current selection.
+ **/
+ navigateLineEnd();
+
+ /**
+ * Moves the cursor to the end of the current file. Note that this does de-select the current selection.
+ **/
+ navigateFileEnd();
+
+ /**
+ * Moves the cursor to the start of the current file. Note that this does de-select the current selection.
+ **/
+ navigateFileStart();
+
+ /**
+ * Moves the cursor to the word immediately to the right of the current position. Note that this does de-select the current selection.
+ **/
+ navigateWordRight();
+
+ /**
+ * Moves the cursor to the word immediately to the left of the current position. Note that this does de-select the current selection.
+ **/
+ navigateWordLeft();
+
+ /**
+ * Replaces the first occurance of `options.needle` with the value in `replacement`.
+ * @param replacement The text to replace with
+ * @param options The [[Search `Search`]] options to use
+ **/
+ replace(replacement: string, options?: any);
+
+ /**
+ * Replaces all occurances of `options.needle` with the value in `replacement`.
+ * @param replacement The text to replace with
+ * @param options The [[Search `Search`]] options to use
+ **/
+ replaceAll(replacement: string, options?: any);
+
+ /**
+ * {:Search.getOptions} For more information on `options`, see [[Search `Search`]].
+ **/
+ getLastSearchOptions(): any;
+
+ /**
+ * Attempts to find `needle` within the document. For more information on `options`, see [[Search `Search`]].
+ * @param needle The text to search for (optional)
+ * @param options An object defining various search properties
+ * @param animate If `true` animate scrolling
+ **/
+ find(needle: string, options?: any, animate?: bool);
+
+ /**
+ * Performs another search for `needle` in the document. For more information on `options`, see [[Search `Search`]].
+ * @param options search options
+ * @param animate If `true` animate scrolling
+ **/
+ findNext(options?: any, animate?: bool);
+
+ /**
+ * Performs a search for `needle` backwards. For more information on `options`, see [[Search `Search`]].
+ * @param options search options
+ * @param animate If `true` animate scrolling
+ **/
+ findPrevious(options?: any, animate?: bool);
+
+ /**
+ * {:UndoManager.undo}
+ **/
+ undo();
+
+ /**
+ * {:UndoManager.redo}
+ **/
+ redo();
+
+ /**
+ * Cleans up the entire editor.
+ **/
+ destroy();
+
+ }
+
+ declare var Editor: {
+ /**
+ * Creates a new `Editor` object.
+ * @param renderer Associated `VirtualRenderer` that draws everything
+ * @param session The `EditSession` to refer to
+ **/
+ new(renderer: VirtualRenderer, session: EditSession): Editor;
+ }
+
+ ////////////////////////////////
+ /// PlaceHolder
+ ////////////////////////////////
+
+ interface PlaceHolder {
+
+ /**
+ * PlaceHolder.setup()
+ * TODO
+ **/
+ setup();
+
+ /**
+ * PlaceHolder.showOtherMarkers()
+ * TODO
+ **/
+ showOtherMarkers();
+
+ /**
+ * PlaceHolder.hideOtherMarkers()
+ * Hides all over markers in the [[EditSession `EditSession`]] that are not the currently selected one.
+ **/
+ hideOtherMarkers();
+
+ /**
+ * PlaceHolder@onUpdate(e)
+ * Emitted when the place holder updates.
+ **/
+ onUpdate();
+
+ /**
+ * PlaceHolder@onCursorChange(e)
+ * Emitted when the cursor changes.
+ **/
+ onCursorChange();
+
+ /**
+ * PlaceHolder.detach()
+ * TODO
+ **/
+ detach();
+
+ /**
+ * PlaceHolder.cancel()
+ * TODO
+ **/
+ cancel();
+ }
+ declare var PlaceHolder: {
+ /**
+ * - session (Document): The document to associate with the anchor
+ * - length (Number): The starting row position
+ * - pos (Number): The starting column position
+ * - others (String):
+ * - mainClass (String):
+ * - othersClass (String):
+ **/
+ new(): PlaceHolder;
+ }
+
+ ////////////////
+ /// Range
+ ////////////////
+
+ /**
+ * This object is used in various places to indicate a region within the editor. To better visualize how this works, imagine a rectangle. Each quadrant of the rectangle is analogus to a range, as ranges contain a starting row and starting column, and an ending row, and ending column.
+ **/
+ interface Range {
+
+ start: number;
+
+ end: number;
+
+ /**
+ * Returns `true` if and only if the starting row and column, and ending row and column, are equivalent to those given by `range`.
+ * @param range A range to check against
+ **/
+ isEqual(range: Range);
+
+ /**
+ * Returns a string containing the range's row and column information, given like this:
+ * ```
+ * [start.row/start.column] -> [end.row/end.column]
+ * ```
+ **/
+ toString();
+
+ /**
+ * Returns `true` if the `row` and `column` provided are within the given range. This can better be expressed as returning `true` if:
+ * ```javascript
+ * this.start.row <= row <= this.end.row &&
+ * this.start.column <= column <= this.end.column
+ * ```
+ * @param row A row to check for
+ * @param column A column to check for
+ **/
+ contains(row: number, column: number): bool;
+
+ /**
+ * Compares `this` range (A) with another range (B).
+ * @param range A range to compare with
+ **/
+ compareRange(range: Range): number;
+
+ /**
+ * Checks the row and column points of `p` with the row and column points of the calling range.
+ * @param p A point to compare with
+ **/
+ comparePoint(p: Range): number;
+
+ /**
+ * Checks the start and end points of `range` and compares them to the calling range. Returns `true` if the `range` is contained within the caller's range.
+ * @param range A range to compare with
+ **/
+ containsRange(range: Range): bool;
+
+ /**
+ * Returns `true` if passed in `range` intersects with the one calling this method.
+ * @param range A range to compare with
+ **/
+ intersects(range: Range): bool;
+
+ /**
+ * Returns `true` if the caller's ending row point is the same as `row`, and if the caller's ending column is the same as `column`.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ isEnd(row: number, column: number): bool;
+
+ /**
+ * Returns `true` if the caller's starting row point is the same as `row`, and if the caller's starting column is the same as `column`.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ isStart(row: number, column: number): bool;
+
+ /**
+ * Sets the starting row and column for the range.
+ * @param row A row point to set
+ * @param column A column point to set
+ **/
+ setStart(row: number, column: number);
+
+ /**
+ * Sets the starting row and column for the range.
+ * @param row A row point to set
+ * @param column A column point to set
+ **/
+ setEnd(row: number, column: number);
+
+ /**
+ * Returns `true` if the `row` and `column` are within the given range.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ inside(row: number, column: number): bool;
+
+ /**
+ * Returns `true` if the `row` and `column` are within the given range's starting points.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ insideStart(row: number, column: number): bool;
+
+ /**
+ * Returns `true` if the `row` and `column` are within the given range's ending points.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ insideEnd(row: number, column: number): bool;
+
+ /**
+ * Checks the row and column points with the row and column points of the calling range.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ compare(row: number, column: number): number;
+
+ /**
+ * Checks the row and column points with the row and column points of the calling range.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ compareStart(row: number, column: number): number;
+
+ /**
+ * Checks the row and column points with the row and column points of the calling range.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ compareEnd(row: number, column: number): number;
+
+ /**
+ * Checks the row and column points with the row and column points of the calling range.
+ * @param row A row point to compare with
+ * @param column A column point to compare with
+ **/
+ compareInside(row: number, column: number): number;
+
+ /**
+ * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object.
+ * @param firstRow The starting row
+ * @param lastRow The ending row
+ **/
+ clipRows(firstRow: number, lastRow: number): Range;
+
+ /**
+ * Changes the row and column points for the calling range for both the starting and ending points.
+ * @param row A new row to extend to
+ * @param column A new column to extend to
+ **/
+ extend(row: number, column: number): Range;
+
+ /**
+ * Returns `true` if the range spans across multiple lines.
+ **/
+ isMultiLine(): bool;
+
+ /**
+ * Returns a duplicate of the calling range.
+ **/
+ clone(): Range;
+
+ /**
+ * Returns a range containing the starting and ending rows of the original range, but with a column value of `0`.
+ **/
+ collapseRows(): Range;
+
+ /**
+ * Given the current `Range`, this function converts those starting and ending points into screen positions, and then returns a new `Range` object.
+ * @param session The `EditSession` to retrieve coordinates from
+ **/
+ toScreenRange(session: EditSession): Range;
+
+ /**
+ * Creates and returns a new `Range` based on the row and column of the given parameters.
+ * @param start A starting point to use
+ * @param end An ending point to use
+ **/
+ fromPoints(start: Range, end: Range): Range;
+
+ }
+ /**
+ * Creates a new `Range` object with the given starting and ending row and column points.
+ * @param startRow The starting row
+ * @param startColumn The starting column
+ * @param endRow The ending row
+ * @param endColumn The ending column
+ **/
+ declare var Range: {
+ new(startRow: number, startColumn: number, endRow: number, endColumn: number): Range;
+ }
+
+ ////////////////
+ /// RenderLoop
+ ////////////////
+
+ interface RenderLoop { }
+ declare var RenderLoop: {
+ new(): RenderLoop;
+ }
+
+ ////////////////
+ /// ScrollBar
+ ////////////////
+
+ /**
+ * A set of methods for setting and retrieving the editor's scrollbar.
+ **/
+ interface ScrollBar {
+
+ /**
+ * Emitted when the scroll bar, well, scrolls.
+ * @param e Contains one property, `"data"`, which indicates the current scroll top position
+ **/
+ onScroll(e: any);
+
+ /**
+ * Returns the width of the scroll bar.
+ **/
+ getWidth(): number;
+
+ /**
+ * Sets the height of the scroll bar, in pixels.
+ * @param height The new height
+ **/
+ setHeight(height: number);
+
+ /**
+ * Sets the inner height of the scroll bar, in pixels.
+ * @param height The new inner height
+ **/
+ setInnerHeight(height: number);
+
+ /**
+ * Sets the scroll top of the scroll bar.
+ * @param scrollTop The new scroll top
+ **/
+ setScrollTop(scrollTop: number);
+ }
+ declare var ScrollBar: {
+ /**
+ * Creates a new `ScrollBar`. `parent` is the owner of the scroll bar.
+ * @param parent A DOM element
+ **/
+ new(parent: HTMLElement): ScrollBar;
+ }
+
+ ////////////////
+ /// Search
+ ////////////////
+
+ /**
+ * A class designed to handle all sorts of text searches within a [[Document `Document`]].
+ **/
+ interface Search {
+
+ /**
+ * Sets the search options via the `options` parameter.
+ * @param options An object containing all the new search properties
+ **/
+ set(options: any): Search;
+
+ /**
+ * [Returns an object containing all the search options.]{: #Search.getOptions}
+ **/
+ getOptions(): any;
+
+ /**
+ * Sets the search options via the `options` parameter.
+ * @param An object containing all the search propertie
+ **/
+ setOptions(An: any);
+
+ /**
+ * Searches for `options.needle`. If found, this method returns the [[Range `Range`]] where the text first occurs. If `options.backwards` is `true`, the search goes backwards in the session.
+ * @param session The session to search with
+ **/
+ find(session: EditSession): Range;
+
+ /**
+ * Searches for all occurances `options.needle`. If found, this method returns an array of [[Range `Range`s]] where the text first occurs. If `options.backwards` is `true`, the search goes backwards in the session.
+ * @param session The session to search with
+ **/
+ findAll(session: EditSession): Range[];
+
+ /**
+ * Searches for `options.needle` in `input`, and, if found, replaces it with `replacement`.
+ * @param input The text to search in
+ * @param replacement The replacing text
+ * + (String): If `options.regExp` is `true`, this function returns `input` with the replacement already made. Otherwise, this function just returns `replacement`.
+ * If `options.needle` was not found, this function returns `null`.
+ **/
+ replace(input: string, replacement: string): string;
+ }
+ declare var Search: {
+ /**
+ * Creates a new `Search` object. The following search options are avaliable:
+ * - `needle`: The string or regular expression you're looking for
+ * - `backwards`: Whether to search backwards from where cursor currently is. Defaults to `false`.
+ * - `wrap`: Whether to wrap the search back to the beginning when it hits the end. Defaults to `false`.
+ * - `caseSensitive`: Whether the search ought to be case-sensitive. Defaults to `false`.
+ * - `wholeWord`: Whether the search matches only on whole words. Defaults to `false`.
+ * - `range`: The [[Range]] to search within. Set this to `null` for the whole document
+ * - `regExp`: Whether the search is a regular expression or not. Defaults to `false`.
+ * - `start`: The starting [[Range]] or cursor position to begin the search
+ * - `skipCurrent`: Whether or not to include the current line in the search. Default to `false`.
+ **/
+ new(): Search;
+ }
+
+ ////////////////
+ /// Search
+ ////////////////
+
+ /**
+ * Contains the cursor position and the text selection of an edit session.
+ * The row/columns used in the selection are in document coordinates representing ths coordinates as thez appear in the document before applying soft wrap and folding.
+ **/
+ interface Selection {
+
+ on(event: string, fn: (e) => any);
+
+ /**
+ * Returns `true` if the selection is empty.
+ **/
+ isEmpty(): bool;
+
+ /**
+ * Returns `true` if the selection is a multi-line.
+ **/
+ isMultiLine(): bool;
+
+ /**
+ * Gets the current position of the cursor.
+ **/
+ getCursor(): number;
+
+ /**
+ * Sets the row and column position of the anchor. This function also emits the `'changeSelection'` event.
+ * @param row The new row
+ * @param column The new column
+ **/
+ setSelectionAnchor(row: number, column: number);
+
+ /**
+ * Returns an object containing the `row` and `column` of the calling selection anchor.
+ **/
+ getSelectionAnchor(): any;
+
+ /**
+ * Returns an object containing the `row` and `column` of the calling selection lead.
+ **/
+ getSelectionLead(): any;
+
+ /**
+ * Shifts the selection up (or down, if [[Selection.isBackwards `isBackwards()`]] is true) the given number of columns.
+ * @param columns The number of columns to shift by
+ **/
+ shiftSelection(columns: number);
+
+ /**
+ * Returns `true` if the selection is going backwards in the document.
+ **/
+ isBackwards(): bool;
+
+ /**
+ * [Returns the [[Range]] for the selected text.]{: #Selection.getRange}
+ **/
+ getRange(): Range;
+
+ /**
+ * [Empties the selection (by de-selecting it). This function also emits the `'changeSelection'` event.]{: #Selection.clearSelection}
+ **/
+ clearSelection();
+
+ /**
+ * Selects all the text in the document.
+ **/
+ selectAll();
+
+ /**
+ * Sets the selection to the provided range.
+ * @param range The range of text to select
+ * @param reverse Indicates if the range should go backwards (`true`) or not
+ **/
+ setRange(range: Range, reverse: bool);
+
+ /**
+ * Moves the selection cursor to the indicated row and column.
+ * @param row The row to select to
+ * @param column The column to select to
+ **/
+ selectTo(row: number, column: number);
+
+ /**
+ * Moves the selection cursor to the row and column indicated by `pos`.
+ * @param pos An object containing the row and column
+ **/
+ selectToPosition(pos: any);
+
+ /**
+ * Moves the selection up one row.
+ **/
+ selectUp();
+
+ /**
+ * Moves the selection down one row.
+ **/
+ selectDown();
+
+ /**
+ * Moves the selection right one column.
+ **/
+ selectRight();
+
+ /**
+ * Moves the selection left one column.
+ **/
+ selectLeft();
+
+ /**
+ * Moves the selection to the beginning of the current line.
+ **/
+ selectLineStart();
+
+ /**
+ * Moves the selection to the end of the current line.
+ **/
+ selectLineEnd();
+
+ /**
+ * Moves the selection to the end of the file.
+ **/
+ selectFileEnd();
+
+ /**
+ * Moves the selection to the start of the file.
+ **/
+ selectFileStart();
+
+ /**
+ * Moves the selection to the first word on the right.
+ **/
+ selectWordRight();
+
+ /**
+ * Moves the selection to the first word on the left.
+ **/
+ selectWordLeft();
+
+ /**
+ * Moves the selection to highlight the entire word.
+ **/
+ getWordRange();
+
+ /**
+ * Selects an entire word boundary.
+ **/
+ selectWord();
+
+ /**
+ * Selects a word, including its right whitespace.
+ **/
+ selectAWord();
+
+ /**
+ * Selects the entire line.
+ **/
+ selectLine();
+
+ /**
+ * Moves the cursor up one row.
+ **/
+ moveCursorUp();
+
+ /**
+ * Moves the cursor down one row.
+ **/
+ moveCursorDown();
+
+ /**
+ * Moves the cursor left one column.
+ **/
+ moveCursorLeft();
+
+ /**
+ * Moves the cursor right one column.
+ **/
+ moveCursorRight();
+
+ /**
+ * Moves the cursor to the start of the line.
+ **/
+ moveCursorLineStart();
+
+ /**
+ * Moves the cursor to the end of the line.
+ **/
+ moveCursorLineEnd();
+
+ /**
+ * Moves the cursor to the end of the file.
+ **/
+ moveCursorFileEnd();
+
+ /**
+ * Moves the cursor to the start of the file.
+ **/
+ moveCursorFileStart();
+
+ /**
+ * Moves the cursor to the word on the right.
+ **/
+ moveCursorLongWordRight();
+
+ /**
+ * Moves the cursor to the word on the left.
+ **/
+ moveCursorLongWordLeft();
+
+ /**
+ * Moves the cursor to position indicated by the parameters. Negative numbers move the cursor backwards in the document.
+ * @param rows The number of rows to move by
+ * @param chars The number of characters to move by
+ **/
+ moveCursorBy(rows: number, chars: number);
+
+ /**
+ * Moves the selection to the position indicated by its `row` and `column`.
+ * @param position The position to move to
+ **/
+ moveCursorToPosition(position: any);
+
+ /**
+ * Moves the cursor to the row and column provided. [If `preventUpdateDesiredColumn` is `true`, then the cursor stays in the same column position as its original point.]{: #preventUpdateBoolDesc}
+ * @param row The row to move to
+ * @param column The column to move to
+ * @param keepDesiredColumn [If `true`, the cursor move does not respect the previous column]{: #preventUpdateBool}
+ **/
+ moveCursorTo(row: number, column: number, keepDesiredColumn: bool);
+
+ /**
+ * Moves the cursor to the screen position indicated by row and column. {:preventUpdateBoolDesc}
+ * @param row The row to move to
+ * @param column The column to move to
+ * @param keepDesiredColumn {:preventUpdateBool}
+ **/
+ moveCursorToScreen(row: number, column: number, keepDesiredColumn: bool);
+ }
+ declare var Selection: {
+ /**
+ * Creates a new `Selection` object.
+ * @param session The session to use
+ **/
+ new(session: EditSession): Selection;
+ }
+
+ ////////////////
+ /// Split
+ ////////////////
+
+ interface Split {
+
+ /**
+ * Returns the number of splits.
+ **/
+ getSplits(): number;
+
+ /**
+ * Returns the editor identified by the index `idx`.
+ * @param idx The index of the editor you want
+ **/
+ getEditor(idx: number);
+
+ /**
+ * Returns the current editor.
+ **/
+ getCurrentEditor(): Editor;
+
+ /**
+ * Focuses the current editor.
+ **/
+ focus();
+
+ /**
+ * Blurs the current editor.
+ **/
+ blur();
+
+ /**
+ * Sets a theme for each of the available editors.
+ * @param theme The name of the theme to set
+ **/
+ setTheme(theme: string);
+
+ /**
+ * Sets the keyboard handler for the editor.
+ * @param keybinding
+ **/
+ setKeyboardHandler(keybinding: string);
+
+ /**
+ * Executes `callback` on all of the available editors.
+ * @param callback A callback function to execute
+ * @param scope The default scope for the callback
+ **/
+ forEach(callback: Function, scope: string);
+
+ /**
+ * Sets the font size, in pixels, for all the available editors.
+ * @param size The new font size
+ **/
+ setFontSize(size: number);
+
+ /**
+ * Sets a new [[EditSession `EditSession`]] for the indicated editor.
+ * @param session The new edit session
+ * @param idx The editor's index you're interested in
+ **/
+ setSession(session: EditSession, idx: number);
+
+ /**
+ * Returns the orientation.
+ **/
+ getOrientation(): number;
+
+ /**
+ * Sets the orientation.
+ * @param orientation The new orientation value
+ **/
+ setOrientation(orientation: number);
+
+ /**
+ * Resizes the editor.
+ **/
+ resize();
+ }
+ declare var Split: {
+ new(): Split;
+ }
+
+ //////////////////
+ /// TokenIterator
+ //////////////////
+
+ /**
+ * This class provides an essay way to treat the document as a stream of tokens, and provides methods to iterate over these tokens.
+ **/
+ interface TokenIterator {
+
+ /**
+ * Tokenizes all the items from the current point to the row prior in the document.
+ **/
+ stepBackward(): string[];
+
+ /**
+ * Tokenizes all the items from the current point until the next row in the document. If the current point is at the end of the file, this function returns `null`. Otherwise, it returns the tokenized string.
+ **/
+ stepForward(): string;
+
+ /**
+ * Returns the current tokenized string.
+ **/
+ getCurrentToken(): string;
+
+ /**
+ * Returns the current row.
+ **/
+ getCurrentTokenRow(): number;
+
+ /**
+ * Returns the current column.
+ **/
+ getCurrentTokenColumn(): number;
+ }
+ declare var TokenIterator: {
+ /**
+ * Creates a new token iterator object. The inital token index is set to the provided row and column coordinates.
+ * @param session The session to associate with
+ * @param initialRow The row to start the tokenizing at
+ * @param initialColumn The column to start the tokenizing at
+ **/
+ new(session: EditSession, initialRow: number, initialColumn: number): TokenIterator;
+ }
+
+ //////////////////
+ /// Tokenizer
+ //////////////////
+
+
+ /**
+ * This class takes a set of highlighting rules, and creates a tokenizer out of them. For more information, see [the wiki on extending highlighters](https://github.com/ajaxorg/ace/wiki/Creating-or-Extending-an-Edit-Mode#wiki-extendingTheHighlighter).
+ **/
+ interface Tokenizer {
+
+ /**
+ * Returns an object containing two properties: `tokens`, which contains all the tokens; and `state`, the current state.
+ **/
+ getLineTokens(): any;
+ }
+ declare var Tokenizer: {
+ /**
+ * Constructs a new tokenizer based on the given rules and flags.
+ * @param rules The highlighting rules
+ * @param flag Any additional regular expression flags to pass (like "i" for case insensitive)
+ **/
+ new(rules: any, flag: string): Tokenizer;
+ }
+
+ //////////////////
+ /// UndoManager
+ //////////////////
+
+ /**
+ * This object maintains the undo stack for an [[EditSession `EditSession`]].
+ **/
+ interface UndoManager {
+
+ /**
+ * Provides a means for implementing your own undo manager. `options` has one property, `args`, an [[Array `Array`]], with two elements:
+ * - `args[0]` is an array of deltas
+ * - `args[1]` is the document to associate with
+ * @param options Contains additional properties
+ **/
+ execute(options: any);
+
+ /**
+ * [Perform an undo operation on the document, reverting the last change.]{: #UndoManager.undo}
+ * @param dontSelect {:dontSelect}
+ **/
+ undo(dontSelect?: bool): Range;
+
+ /**
+ * [Perform a redo operation on the document, reimplementing the last change.]{: #UndoManager.redo}
+ * @param dontSelect {:dontSelect}
+ **/
+ redo(dontSelect: bool);
+
+ /**
+ * Destroys the stack of undo and redo redo operations.
+ **/
+ reset();
+
+ /**
+ * Returns `true` if there are undo operations left to perform.
+ **/
+ hasUndo(): bool;
+
+ /**
+ * Returns `true` if there are redo operations left to perform.
+ **/
+ hasRedo(): bool;
+
+ }
+ declare var UndoManager: {
+ /**
+ * Resets the current undo state and creates a new `UndoManager`.
+ **/
+ new(): UndoManager;
+ }
+
+ ////////////////////
+ /// VirtualRenderer
+ ////////////////////
+
+ /**
+ * The class that is responsible for drawing everything you see on the screen!
+ **/
+ interface VirtualRenderer {
+
+ /**
+ * Associates the renderer with an [[EditSession `EditSession`]].
+ **/
+ setSession();
+
+ /**
+ * Triggers a partial update of the text, from the range given by the two parameters.
+ * @param firstRow The first row to update
+ * @param lastRow The last row to update
+ **/
+ updateLines(firstRow: number, lastRow: number);
+
+ /**
+ * Triggers a full update of the text, for all the rows.
+ **/
+ updateText();
+
+ /**
+ * Triggers a full update of all the layers, for all the rows.
+ * @param force If `true`, forces the changes through
+ **/
+ updateFull(force: bool);
+
+ /**
+ * Updates the font size.
+ **/
+ updateFontSize();
+
+ /**
+ * [Triggers a resize of the editor.]{: #VirtualRenderer.onResize}
+ * @param force If `true`, recomputes the size, even if the height and width haven't changed
+ * @param gutterWidth The width of the gutter in pixels
+ * @param width The width of the editor in pixels
+ * @param height The hiehgt of the editor, in pixels
+ **/
+ onResize(force: bool, gutterWidth: number, width: number, height: number);
+
+ /**
+ * Adjusts the wrap limit, which is the number of characters that can fit within the width of the edit area on screen.
+ **/
+ adjustWrapLimit();
+
+ /**
+ * Identifies whether you want to have an animated scroll or not.
+ * @param shouldAnimate Set to `true` to show animated scrolls
+ **/
+ setAnimatedScroll(shouldAnimate: bool);
+
+ /**
+ * Returns whether an animated scroll happens or not.
+ **/
+ getAnimatedScroll(): bool;
+
+ /**
+ * Identifies whether you want to show invisible characters or not.
+ * @param showInvisibles Set to `true` to show invisibles
+ **/
+ setShowInvisibles(showInvisibles: bool);
+
+ /**
+ * Returns whether invisible characters are being shown or not.
+ **/
+ getShowInvisibles(): bool;
+
+ /**
+ * Identifies whether you want to show the print margin or not.
+ * @param showPrintMargin Set to `true` to show the print margin
+ **/
+ setShowPrintMargin(showPrintMargin: bool);
+
+ /**
+ * Returns whether the print margin is being shown or not.
+ **/
+ getShowPrintMargin(): bool;
+
+ /**
+ * Identifies whether you want to show the print margin column or not.
+ * @param showPrintMargin Set to `true` to show the print margin column
+ **/
+ setPrintMarginColumn(showPrintMargin: bool);
+
+ /**
+ * Returns whether the print margin column is being shown or not.
+ **/
+ getPrintMarginColumn(): bool;
+
+ /**
+ * Returns `true` if the gutter is being shown.
+ **/
+ getShowGutter(): bool;
+
+ /**
+ * Identifies whether you want to show the gutter or not.
+ * @param show Set to `true` to show the gutter
+ **/
+ setShowGutter(show: bool);
+
+ /**
+ * Returns the root element containing this renderer.
+ **/
+ getContainerElement(): HTMLElement;
+
+ /**
+ * Returns the element that the mouse events are attached to
+ **/
+ getMouseEventTarget(): HTMLElement;
+
+ /**
+ * Returns the element to which the hidden text area is added.
+ **/
+ getTextAreaContainer(): HTMLElement;
+
+ /**
+ * [Returns the index of the first visible row.]{: #VirtualRenderer.getFirstVisibleRow}
+ **/
+ getFirstVisibleRow(): number;
+
+ /**
+ * Returns the index of the first fully visible row. "Fully" here means that the characters in the row are not truncated; that the top and the bottom of the row are on the screen.
+ **/
+ getFirstFullyVisibleRow(): number;
+
+ /**
+ * Returns the index of the last fully visible row. "Fully" here means that the characters in the row are not truncated; that the top and the bottom of the row are on the screen.
+ **/
+ getLastFullyVisibleRow(): number;
+
+ /**
+ * [Returns the index of the last visible row.]{: #VirtualRenderer.getLastVisibleRow}
+ **/
+ getLastVisibleRow(): number;
+
+ /**
+ * Sets the padding for all the layers.
+ * @param padding A new padding value (in pixels)
+ **/
+ setPadding(padding: number);
+
+ /**
+ * Returns whether the horizontal scrollbar is set to be always visible.
+ **/
+ getHScrollBarAlwaysVisible(): bool;
+
+ /**
+ * Identifies whether you want to show the horizontal scrollbar or not.
+ * @param alwaysVisible Set to `true` to make the horizontal scroll bar visible
+ **/
+ setHScrollBarAlwaysVisible(alwaysVisible: bool);
+
+ /**
+ * Schedules an update to all the front markers in the document.
+ **/
+ updateFrontMarkers();
+
+ /**
+ * Schedules an update to all the back markers in the document.
+ **/
+ updateBackMarkers();
+
+ /**
+ * Deprecated; (moved to [[EditSession]])
+ **/
+ addGutterDecoration();
+
+ /**
+ * Deprecated; (moved to [[EditSession]])
+ **/
+ removeGutterDecoration();
+
+ /**
+ * Redraw breakpoints.
+ **/
+ updateBreakpoints();
+
+ /**
+ * Sets annotations for the gutter.
+ * @param annotations An array containing annotations
+ **/
+ setAnnotations(annotations: Array);
+
+ /**
+ * Updates the cursor icon.
+ **/
+ updateCursor();
+
+ /**
+ * Hides the cursor icon.
+ **/
+ hideCursor();
+
+ /**
+ * Shows the cursor icon.
+ **/
+ showCursor();
+
+ /**
+ * Scrolls the cursor into the first visibile area of the editor
+ **/
+ scrollCursorIntoView();
+
+ /**
+ * {:EditSession.getScrollTop}
+ **/
+ getScrollTop(): number;
+
+ /**
+ * {:EditSession.getScrollLeft}
+ **/
+ getScrollLeft(): number;
+
+ /**
+ * Returns the first visible row, regardless of whether it's fully visible or not.
+ **/
+ getScrollTopRow(): number;
+
+ /**
+ * Returns the last visible row, regardless of whether it's fully visible or not.
+ **/
+ getScrollBottomRow(): number;
+
+ /**
+ * Gracefully scrolls from the top of the editor to the row indicated.
+ * @param row A row id
+ **/
+ scrollToRow(row: number);
+
+ /**
+ * Gracefully scrolls the editor to the row indicated.
+ * @param line A line number
+ * @param center If `true`, centers the editor the to indicated line
+ * @param animate If `true` animates scrolling
+ * @param callback Function to be called after the animation has finished
+ **/
+ scrollToLine(line: number, center: bool, animate: bool, callback: Function);
+
+ /**
+ * Scrolls the editor to the y pixel indicated.
+ * @param scrollTop The position to scroll to
+ **/
+ scrollToY(scrollTop: number): number;
+
+ /**
+ * Scrolls the editor across the x-axis to the pixel indicated.
+ * @param scrollLeft The position to scroll to
+ **/
+ scrollToX(scrollLeft: number): number;
+
+ /**
+ * Scrolls the editor across both x- and y-axes.
+ * @param deltaX The x value to scroll by
+ * @param deltaY The y value to scroll by
+ **/
+ scrollBy(deltaX: number, deltaY: number);
+
+ /**
+ * Returns `true` if you can still scroll by either parameter; in other words, you haven't reached the end of the file or line.
+ * @param deltaX The x value to scroll by
+ * @param deltaY The y value to scroll by
+ **/
+ isScrollableBy(deltaX: number, deltaY: number): bool;
+
+ /**
+ * Returns an object containing the `pageX` and `pageY` coordinates of the document position.
+ * @param row The document row position
+ * @param column The document column position
+ **/
+ textToScreenCoordinates(row: number, column: number): any;
+
+ /**
+ * Focuses the current container.
+ **/
+ visualizeFocus();
+
+ /**
+ * Blurs the current container.
+ **/
+ visualizeBlur();
+
+ /**
+ * undefined
+ * @param position
+ **/
+ showComposition(position: number);
+
+ /**
+ * Sets the inner text of the current composition to `text`.
+ * @param text A string of text to use
+ **/
+ setCompositionText(text: string);
+
+ /**
+ * Hides the current composition.
+ **/
+ hideComposition();
+
+ /**
+ * [Sets a new theme for the editor. `theme` should exist, and be a directory path, like `ace/theme/textmate`.]{: #VirtualRenderer.setTheme}
+ * @param theme The path to a theme
+ **/
+ setTheme(theme: string);
+
+ /**
+ * [Returns the path of the current theme.]{: #VirtualRenderer.getTheme}
+ **/
+ getTheme(): string;
+
+ /**
+ * [Adds a new class, `style`, to the editor.]{: #VirtualRenderer.setStyle}
+ * @param style A class name
+ **/
+ setStyle(style: string);
+
+ /**
+ * [Removes the class `style` from the editor.]{: #VirtualRenderer.unsetStyle}
+ * @param style A class name
+ **/
+ unsetStyle(style: string);
+
+ /**
+ * Destroys the text and cursor layers for this renderer.
+ **/
+ destroy();
+
+ }
+ declare var VirtualRenderer: {
+ /**
+ * Constructs a new `VirtualRenderer` within the `container` specified, applying the given `theme`.
+ * @param container The root element of the editor
+ * @param theme The starting theme
+ **/
+ new(container: HTMLElement, theme: string): VirtualRenderer;
+ }
+}
+
+declare var ace: AceAjax.Ace;
\ No newline at end of file