dota2-fork/node_modules/google-closure-compiler/contrib/externs/ace-1.2.3.js

A node-steam plugin for Dota 2. Fork with fresh updates

/*
 * Copyright 2016 The Closure Compiler Authors.
 *
 * 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.
 */

/**
 * @fileoverview Externs for Ace Editor API v. 1.2.3.
 * @see https://ace.c9.io/#nav=api
 * @externs
 */

/**
 * The main class required to set up an Ace instance in the browser.
 * @const
 * @see https://ace.c9.io/#nav=api&api=ace
 */
var ace;

/**
 * Creates a new EditSession, and returns the associated Document.
 * @param {(!ace.Document|string)} text
 * @param {?} mode // TODO: define !ace.Mode.
 * @return {!ace.Document}
 */
ace.createEditSession = function(text, mode) {};

/**
 * Embeds the Ace editor into the DOM, at the element provided by el.
 * @param {(string|!Element)} el
 * @return {!ace.Editor}
 */
ace.edit = function(el) {};

/**
 * Provides access to require in packed noconflict mode.
 * @param {string} moduleName
 * @return {!Object}
 */
ace.require = function(moduleName) {};

/**
 * Creates a new Anchor and associates it with a document.
 * @constructor
 * @param {!ace.Document} doc
 * @param {number} row
 * @param {number} column
 * @see https://ace.c9.io/#nav=api&api=anchor
 */
ace.Anchor = function(doc, row, column) {};

/**
 * Fires whenever the anchor position changes.
 * @param {string} event
 * @param {function(!Object)} fn
 */
ace.Anchor.prototype.on = function(event, fn) {};

/**
 * When called, the 'change' event listener is removed.
 */
ace.Anchor.prototype.detach = function() {};

/**
 * Returns the current document.
 * @return {!ace.Document}
 */
ace.Anchor.prototype.getDocument = function() {};

/**
 * Returns an object identifying the row and column position of the current
 * anchor.
 * @return {!Object}
 */
ace.Anchor.prototype.getPosition = function() {};

/** Undocumented */
ace.Anchor.prototype.onChange = function() {};

/**
 * Sets the anchor position to the specified row and column. If noClip is true,
 * the position is not clipped.
 * @param {number} row
 * @param {number} column
 * @param {boolean} noClip
 */
ace.Anchor.prototype.setPosition = function(row, column, noClip) {};

/**
 * Creates a new BackgroundTokenizer object.
 * @constructor
 * @param {!ace.Tokenizer} tokenizer
 * @param {!ace.Editor} editor
 * @see https://ace.c9.io/#nav=api&api=background_tokenizer
 */
ace.BackgroundTokenizer = function(tokenizer, editor) {};

/**
 * @param {string} event
 * @param {function(!Object)} fn
 */
ace.BackgroundTokenizer.prototype.on = function(event, fn) {};

/**
 * Emits the 'update' event. firstRow and lastRow are used to define the
 * boundaries of the region to be updated.
 * @param {number} firstRow
 * @param {number} lastRow
 */
ace.BackgroundTokenizer.prototype.fireUpdateEvent = function(firstRow, lastRow) {};

/**
 * Returns the state of tokenization at the end of a row.
 * @param {number} row
 * @return {!Object}
 */
ace.BackgroundTokenizer.prototype.getState = function(row) {};

/**
 * Gives list of tokens of the row (tokens are cached).
 * @param {number} row
 */
ace.BackgroundTokenizer.prototype.getTokens = function(row) {};

/**
 * Sets a new document to associate with this object.
 * @param {!ace.Document} doc
 */
ace.BackgroundTokenizer.prototype.setDocument = function(doc) {};

/**
 * Sets a new tokenizer for this object.
 * @param {!ace.Tokenizer} tokenizer
 */
ace.BackgroundTokenizer.prototype.setTokenizer = function(tokenizer) {};

/**
 * Starts tokenizing at the row indicated.
 * @param {number} startRow
 */
ace.BackgroundTokenizer.prototype.start = function(startRow) {};

/**
 * Stops tokenizing.
 */
ace.BackgroundTokenizer.prototype.stop = function() {};

/**
 * Creates a new Document. If text is included, the Document contains those
 * strings; otherwise, it's empty.
 * @constructor
 * @param {(string|!Array<string>)} text
 * @see https://ace.c9.io/#nav=api&api=document
 */
ace.Document = function(text) {};

/**
 * Fires whenever the document changes.
 * @param {string} event
 * @param {function(!Object)} fn
 */
ace.Document.prototype.on = function(event, fn) {};

/**
 * Applies all the changes previously accumulated.
 * These can be either 'includeText', 'insertLines', 'removeText', and
 * 'removeLines'.
 * @param {!Object} deltas
 */
ace.Document.prototype.applyDeltas = function(deltas) {};

/**
 * Creates a new Anchor to define a floating point in the document.
 * @param {number} row
 * @param {number} column
 */
ace.Document.prototype.createAnchor = function(row, column) {};

/**
 * Returns all lines in the document as string array.
 * @return {!Array<string>}
 */
ace.Document.prototype.getAllLines = function() {};

/**
 * Returns the number of rows in the document.
 * @return {number}
 */
ace.Document.prototype.getLength = function() {};

/**
 * Returns a verbatim copy of the given line as it is in the document
 * @param {number} row
 * @return {!Object}
 */
ace.Document.prototype.getLine = function(row) {};

/**
 * Returns an array of strings of the rows between firstRow and lastRow. This
 * function is inclusive of lastRow.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {!Array<string>}
 */
ace.Document.prototype.getLines = function(firstRow, lastRow) {};

/**
 * Returns the newline character that's being used, depending on the value of
 * newLineMode.
 * @return {string}
 */
ace.Document.prototype.getNewLineCharacter = function() {};

/**
 * Returns the type of newlines being used; either windows, unix, or auto.
 * @return {string}
 */
ace.Document.prototype.getNewLineMode = function() {};

/**
 * Given a range within the document, this function returns all the text within
 * that range as a single string.
 * @param {!ace.Range} range
 * @return {string}
 */
ace.Document.prototype.getTextRange = function(range) {};

/**
 * Returns all the lines in the document as a single string, split by the new
 * line character.
 * @return {string}
 */
ace.Document.prototype.getValue = function() {};

/**
 * Converts an index position in a document to a {row, column} object.
 * @param {number} index
 * @param {number} startRow
 * @return {{row: number, column: number}}
 */
ace.Document.prototype.indexToPosition = function(index, startRow) {};

/**
 * Inserts a block of text and the indicated position.
 * @param {!Object} position
 * @param {string} text
 * @return {!Object}
 */
ace.Document.prototype.insert = function(position, text) {};

/**
 * Inserts text into the position at the current row. This method also triggers
 * the 'change' event.
 * @param {!Object} position
 * @param {string} text
 * @return {!Object}
 */
ace.Document.prototype.insertInLine = function(position, text) {};

/**
 * Inserts the elements in lines into the document, starting at the row index
 * given by row.
 * This method also triggers the 'change' event.
 * @param {number} row
 * @param {!Array<number>} lines
 * @return {!Object}
 */
ace.Document.prototype.insertLines = function(row, lines) {};

/**
 * Inserts a new line into the document at the current row's position.
 * This method also triggers the 'change' event.
 * @param {!Object} position
 * @return {!Object}
 */
ace.Document.prototype.insertNewLine = function(position) {};

/**
 * Returns true if text is a newline character (either \r\n, \r, or \n).
 * @param {string} text
 * @return {boolean}
 */
ace.Document.prototype.isNewLine = function(text) {};

/**
 * Converts the {row, column} position in a document to the character's index.
 * @param {{row: number, column: number}} pos
 * @param {number} startRow
 * @return {number}
 */
ace.Document.prototype.positionToIndex = function(pos, startRow) {};

/**
 * Removes the range from the document.
 * @param {!ace.Range} range
 * @return {!Object}
 */
ace.Document.prototype.remove = function(range) {};

/**
 * Removes the specified columns from the row. This method also triggers the
 * 'change' event.
 * @param {number} row
 * @param {number} startColumn
 * @param {number} endColumn
 * @return {!Object}
 */
ace.Document.prototype.removeInLine = function(row, startColumn, endColumn) {};

/**
 * Removes a range of full lines. This method also triggers the 'change' event.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {string}
 */
ace.Document.prototype.removeLines = function(firstRow, lastRow) {};

/**
 * Removes the new line between row and the row immediately following it.
 * This method also triggers the 'change' event.
 * @param {number} row
 */
ace.Document.prototype.removeNewLine = function(row) {};

/**
 * Replaces a range in the document with the new text.
 * @param {!ace.Range} range
 * @param {string} text
 * @return {!Object}
 */
ace.Document.prototype.replace = function(range, text) {};

/**
 * Reverts any changes previously applied.
 * These can be either 'includeText', 'insertLines', 'removeText', and
 * 'removeLines'.
 * @param {!Object} deltas
 */
ace.Document.prototype.revertDeltas = function(deltas) {};

/**
 * Sets the new line mode.
 * @param {string} newLineMode
 */
ace.Document.prototype.setNewLineMode = function(newLineMode) {};

/**
 * Replaces all the lines in the current Document with the value of text.
 * @param {string} text
 */
ace.Document.prototype.setValue = function(text) {};

/**
 * Stores all the data about Editor state providing easy way to change editor's
 * state.
 * @constructor
 * @param {(!ace.Document|string)} text
 * @param {?} mode
 * @see https://ace.c9.io/#nav=api&api=edit_session
 */
ace.EditSession = function(text, mode) {};

/**
 * Adds a dynamic marker to the session.
 * @param {!Object} marker
 * @param {boolean} inFront
 * @return {!Object}
 */
ace.EditSession.prototype.addDynamicMarker = function(marker, inFront) {};

/**
 * Adds className to the row, to be used for CSS stylings and whatnot.
 * @param {number} row
 * @param {string} className
 */
ace.EditSession.prototype.addGutterDecoration = function(row, className) {};

/**
 * 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 {!ace.Range} range
 * @param {string} clazz
 * @param {!Function|string} type
 * @param {boolean} inFront
 * @return {number}
 */
ace.EditSession.prototype.addMarker = function(range, clazz, type, inFront) {};

/**
 * Clears all the annotations for this session. This function also triggers the
 * 'changeAnnotation' event.
 */
ace.EditSession.prototype.clearAnnotations = function() {};

/**
 * Removes a breakpoint on the row number given by rows. This function also
 * emits the 'changeBreakpoint' event.
 * @param {number} row
 */
ace.EditSession.prototype.clearBreakpoint = function(row) {};

/**
 * Removes all breakpoints on the rows. This function also emits the
 * 'changeBreakpoint' event.
 */
ace.EditSession.prototype.clearBreakpoints = function() {};

/**
 * For the given document row and column, returns the screen column.
 * @param {number} row
 * @param {number} docColumn
 * @return {number}
 */
ace.EditSession.prototype.documentToScreenColumn = function(row, docColumn) {};

/**
 * Converts document coordinates to screen coordinates.
 * This takes into account code folding, word wrap, tab size, and any other
 * visual modifications.
 * @param {number} docRow
 * @param {number} docColumn
 * @return {!Object}
 */
ace.EditSession.prototype.documentToScreenPosition = function(docRow, docColumn) {};

/**
 * For the given document row and column, returns the screen row.
 * @param {number} docRow
 * @param {number} docColumn
 * @return {number}
 */
ace.EditSession.prototype.documentToScreenRow = function(docRow, docColumn) {};

/**
 * Duplicates all the text between firstRow and lastRow.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {number}
 */
ace.EditSession.prototype.duplicateLines = function(firstRow, lastRow) {};

/**
 * Returns the annotations for the EditSession.
 * @return {!Object}
 */
ace.EditSession.prototype.getAnnotations = function() {};

/**
 * Gets the range of a word, including its right whitespace.
 * @param {number} row
 * @param {number} column
 * @return {!ace.Range}
 */
ace.EditSession.prototype.getAWordRange = function(row, column) {};

/**
 * Returns an array of numbers, indicating which rows have breakpoints.
 * @return {number}
 */
ace.EditSession.prototype.getBreakpoints = function() {};

/**
 * Returns the Document associated with this session.
 * @return {!ace.Document}
 */
ace.EditSession.prototype.getDocument = function() {};

/**
 * For the given document row and column, this returns the column position of
 * the last screen row.
 * @param {number} docRow
 * @param {number} docColumn
 * @return {number}
 */
ace.EditSession.prototype.getDocumentLastRowColumn = function(docRow, docColumn) {};

/**
 * For the given document row and column, this returns the document position of
 * the last row.
 * @param {number} docRow
 * @param {number} docColumn
 * @return {!Object}
 */
ace.EditSession.prototype.getDocumentLastRowColumnPosition = function(docRow, docColumn) {};

/**
 * Returns the number of rows in the document.
 * @return {number}
 */
ace.EditSession.prototype.getLength = function() {};

/**
 * Returns a verbatim copy of the given line as it is in the document
 * @param {number} row
 * @return {string}
 */
ace.EditSession.prototype.getLine = function(row) {};

/**
 * Returns an array of strings of the rows between firstRow and lastRow.
 * This function is inclusive of lastRow.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {string}
 */
ace.EditSession.prototype.getLines = function(firstRow, lastRow) {};

/**
 * Returns an array containing the IDs of all the markers, either front or back.
 * @param {boolean} inFront
 * @return {!Array<string>}
 */
ace.EditSession.prototype.getMarkers = function(inFront) {};

/**
 * Returns the current text mode.
 * @return {!Object}
 */
ace.EditSession.prototype.getMode = function() {};

/**
 * Returns the current new line mode.
 * @return {string}
 */
ace.EditSession.prototype.getNewLineMode = function() {};

/**
 * Returns true if overwrites are enabled; false otherwise.
 * @return {boolean}
 */
ace.EditSession.prototype.getOverwrite = function() {};

/**
 * Returns number of screenrows in a wrapped line.
 * @param {number} row
 * @return {number}
 */
ace.EditSession.prototype.getRowLength = function(row) {};

/**
 * For the given row, this returns the split data.
 * @param {!Object} row
 * @return {string}
 */
ace.EditSession.prototype.getRowSplitData = function(row) {};

/**
 * Returns the position (on screen) for the last character in the provided
 * screen row.
 * @param {number} screenRow
 * @return {number}
 */
ace.EditSession.prototype.getScreenLastRowColumn = function(screenRow) {};

/**
 * Returns the length of the screen.
 * @return {number}
 */
ace.EditSession.prototype.getScreenLength = function() {};

/**
 * The distance to the next tab stop at the specified screen column.
 * @param {number} screenColumn
 * @return {number}
 */
ace.EditSession.prototype.getScreenTabSize = function(screenColumn) {};

/**
 * Returns the width of the screen.
 * @return {number}
 */
ace.EditSession.prototype.getScreenWidth = function() {};

/**
 * Returns the value of the distance between the left of the editor and the
 * leftmost part of the visible content.
 * @return {number}
 */
ace.EditSession.prototype.getScrollLeft = function() {};

/**
 * Returns the value of the distance between the top of the editor and the
 * topmost part of the visible content.
 * @return {number}
 */
ace.EditSession.prototype.getScrollTop = function() {};

/**
 * Returns selection object.
 * @return {!Object}
 */
ace.EditSession.prototype.getSelection = function() {};

/**
 * Returns the state of tokenization at the end of a row.
 * @param {number} row
 * @return {!Object}
 */
ace.EditSession.prototype.getState = function(row) {};

/**
 * Returns the current tab size.
 * @return {number}
 */
ace.EditSession.prototype.getTabSize = function() {};

/**
 * Returns the current value for tabs. If the user is using soft tabs, this
 * will be a series of spaces (defined by getTabSize()); otherwise it's simply
 * '\t'.
 * @return {string}
 */
ace.EditSession.prototype.getTabString = function() {};

/**
 * Given a range within the document, this function returns all the text
 * within that range as a single string.
 * @param {!ace.Range} range
 * @return {string}
 */
ace.EditSession.prototype.getTextRange = function(range) {};

/**
 * Returns an object indicating the token at the current row. The object has
 * two properties: index and start.
 * @param {number} row
 * @param {number} column
 * @return {!Object}
 */
ace.EditSession.prototype.getTokenAt = function(row, column) {};

/**
 * Starts tokenizing at the row indicated. Returns a list of objects of the
 * tokenized rows.
 * @param {number} row
 * @return {!Array<!Object>} row
 */
ace.EditSession.prototype.getTokens = function(row) {};

/**
 * Returns the current undo manager.
 * @return {!ace.UndoManager}
 */
ace.EditSession.prototype.getUndoManager = function() {};

/**
 * Returns true if soft tabs are being used, false otherwise.
 * @return {boolean}
 */
ace.EditSession.prototype.getUseSoftTabs = function() {};

/**
 * Returns true if workers are being used.
 * @return {boolean}
 */
ace.EditSession.prototype.getUseWorker = function() {};

/**
 * Returns true if wrap mode is being used; false otherwise.
 * @return {boolean}
 */
ace.EditSession.prototype.getUseWrapMode = function() {};

/**
 * Returns the current Document as a string.
 * @return {string}
 */
ace.EditSession.prototype.getValue = function() {};

/**
 * Given a starting row and column, this method returns the Range of the first
 * word boundary it finds.
 * @param {number} row
 * @param {number} column
 * @return {!ace.Range}
 */
ace.EditSession.prototype.getWordRange = function(row, column) {};

/**
 * Returns the value of wrap limit.
 * @return {number}
 */
ace.EditSession.prototype.getWrapLimit = function() {};

/**
 * Returns an object that defines the minimum and maximum of the wrap limit.
 * @return {!Object}
 */
ace.EditSession.prototype.getWrapLimitRange = function() {};

/** Undocumented */
ace.EditSession.prototype.highlight = function() {};

/** Undocumented */
ace.EditSession.prototype.highlightLines = function() {};

/**
 * Indents all the rows, from startRow to endRow (inclusive), by prefixing each
 * row with the token in indentString.
 * @param {number} startRow
 * @param {number} endRow
 * @param {string} indentString
 */
ace.EditSession.prototype.indentRows = function(startRow, endRow, indentString) {};

/**
 * Inserts a block of text and the indicated position.
 * @param {!Object} position
 * @param {string} text
 * @return {!Object}
 */
ace.EditSession.prototype.insert = function(position, text) {};

/**
 * Returns true if the character at the position is a soft tab.
 * @param {!Object} position
 * @return {boolean}
 */
ace.EditSession.prototype.isTabStop = function(position) {};

/**
 * Shifts all the lines in the document down one, starting from firstRow and
 * ending at lastRow.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {number}
 */
ace.EditSession.prototype.moveLinesDown = function(firstRow, lastRow) {};

/**
 * Shifts all the lines in the document up one, starting from firstRow and
 * ending at lastRow.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {number}
 */
ace.EditSession.prototype.moveLinesUp = function(firstRow, lastRow) {};

/**
 * Moves a range of text from the given range to the given position.toPosition
 * is an object that looks like this:
 * { row: newRowLocation, column: newColumnLocation }
 * @param {!ace.Range} fromRange
 * @param {{row: number, column: number}} toPosition
 * @return {!ace.Range}
 */
ace.EditSession.prototype.moveText = function(fromRange, toPosition) {};

/**
 * @param {string} event
 * @param {function((Object|number|null))} fn
 */
ace.EditSession.prototype.on = function(event, fn) {};

/** Undocumented */
ace.EditSession.prototype.onChange = function() {};

/** Undocumented */
ace.EditSession.prototype.onChangeFold = function() {};

/**
 * Reloads all the tokens on the current session. This function calls
 * BackgroundTokenizer.start() to all the rows;
 * it also emits the 'tokenizerUpdate' event.
 * @param {!Object} e
 */
ace.EditSession.prototype.onReloadTokenizer = function(e) {};

/**
 * Outdents all the rows defined by the start and end properties of range.
 * @param {!ace.Range} range
 */
ace.EditSession.prototype.outdentRows = function(range) {};

/** Undocumented */
ace.EditSession.prototype.redo = function() {};

/**
 * Re-implements a previously undone change to your document.
 * @param {!Array<!Object>} deltas
 * @param {boolean} dontSelect
 * @return {!ace.Range}
 */
ace.EditSession.prototype.redoChanges = function(deltas, dontSelect) {};

/**
 * Removes the range from the document.
 * @param {!ace.Range} range
 * @return {!Object}
 */
ace.EditSession.prototype.remove = function(range) {};

/**
 * Removes className from the row.
 * @param {number} row
 * @param {string} className
 */
ace.EditSession.prototype.removeGutterDecoration = function(row, className) {};

/**
 * 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 {number} markerId
 */
ace.EditSession.prototype.removeMarker = function(markerId) {};

/**
 * Replaces a range in the document with the new text.
 * @param {!ace.Range} range
 * @param {string} text
 * @return {!Object}
 */
ace.EditSession.prototype.replace = function(range, text) {};

/** Undocumented */
ace.EditSession.prototype.reset = function() {};

/** Undocumented */
ace.EditSession.prototype.resetCaches = function() {};

/** Undocumented */
ace.EditSession.prototype.screenToDocumentColumn = function() {};

/**
 * 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.
 * @param {number} screenRow
 * @param {number} screenColumn
 * @return {!Object}
 */
ace.EditSession.prototype.screenToDocumentPosition = function(screenRow, screenColumn) {};

/** Undocumented */
ace.EditSession.prototype.screenToDocumentRow = function() {};

/**
 * Sets annotations for the EditSession. This functions emits the
 * 'changeAnnotation' event.
 * @param {!Array<!Object>} annotations
 */
ace.EditSession.prototype.setAnnotations = function(annotations) {};

/**
 * Sets a breakpoint on the row number given by rows. This function also emits
 * the 'changeBreakpoint' event.
 * @param {number} row
 * @param {string} className
 */
ace.EditSession.prototype.setBreakpoint = function(row, className) {};

/**
 * Sets a breakpoint on every row number given by rows. This function also
 * emits the 'changeBreakpoint' event.
 * @param {!Array<number>} rows
 */
ace.EditSession.prototype.setBreakpoints = function(rows) {};

/**
 * Sets the EditSession to point to a new Document. If a BackgroundTokenizer
 * exists, it also points to doc.
 * @param {!ace.Document} doc
 */
ace.EditSession.prototype.setDocument = function(doc) {};

/** Undocumented */
ace.EditSession.prototype.setMode = function() {};

/**
 * Sets the new line mode.
 * @param {string} newLineMode
 */
ace.EditSession.prototype.setNewLineMode = function(newLineMode) {};

/**
 * Pass in true to enable overwrites in your session, or false to disable.
 * @param {boolean} overwrite
 */
ace.EditSession.prototype.setOverwrite = function(overwrite) {};

/**
 * Sets the value of the distance between the left of the editor and the
 * leftmost part of the visible content.
 * @param {!Object} scrollLeft
 */
ace.EditSession.prototype.setScrollLeft = function(scrollLeft) {};

/**
 * This function sets the scroll top value. It also emits the 'changeScrollTop'
 * event.
 * @param {number} scrollTop
 */
ace.EditSession.prototype.setScrollTop = function(scrollTop) {};

/**
 * @param {boolean} margin
 */
ace.EditSession.prototype.setShowPrintMargin = function(margin) {};

/**
 * 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 {number} tabSize
 */
ace.EditSession.prototype.setTabSize = function(tabSize) {};

/**
 * Sets the undo manager.
 * @param {!ace.UndoManager} undoManager
 */
ace.EditSession.prototype.setUndoManager = function(undoManager) {};

/**
 * Enables or disables highlighting of the range where an undo occured.
 * @param {boolean} enable
 */
ace.EditSession.prototype.setUndoSelect = function(enable) {};

/**
 * Pass true to enable the use of soft tabs. Soft tabs means you're using
 * spaces instead of the tab character ('\t').
 * @param {boolean} useSoftTabs
 */
ace.EditSession.prototype.setUseSoftTabs = function(useSoftTabs) {};

/**
 * Identifies if you want to use a worker for the EditSession.
 * @param {boolean} useWorker
 */
ace.EditSession.prototype.setUseWorker = function(useWorker) {};

/**
 * Sets whether or not line wrapping is enabled. If useWrapMode is different
 * than the current value, the 'changeWrapMode' event is emitted.
 * @param {boolean} useWrapMode
 */
ace.EditSession.prototype.setUseWrapMode = function(useWrapMode) {};

/**
 * Sets the session text.
 * @param {string} text
 */
ace.EditSession.prototype.setValue = function(text) {};

/**
 * 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 {?number} min
 * @param {?number} max
 */
ace.EditSession.prototype.setWrapLimitRange = function(min, max) {};

/**
 * Sets the value of overwrite to the opposite of whatever it currently is.
 */
ace.EditSession.prototype.toggleOverwrite = function() {};

/**
 * Returns the current Document as a string.
 * @override
 */
ace.EditSession.prototype.toString = function() {};

/** Undocumented */
ace.EditSession.prototype.undo = function() {};

/**
 * Reverts previous changes to your document.
 * @param {!Array<!Object>} deltas
 * @param {boolean} dontSelect
 * @return {!Object}
 */
ace.EditSession.prototype.undoChanges = function(deltas, dontSelect) {};

/**
 * Creates a new Editor object.
 * @constructor
 * @param {!ace.VirtualRenderer} renderer
 * @param {!ace.EditSession} session
 * @see https://ace.c9.io/#nav=api&api=editor
 */
ace.Editor = function(renderer, session) {};

/**
 * @param {string} event
 * @param {function((Object|string|null))} fn
 */
ace.Editor.prototype.on = function(event, fn) {};

/**
 * Adds the selection and cursor.
 * @param {!ace.Range} orientedRange
 * @return {!ace.Range}
 */
ace.Editor.prototype.addSelectionMarker = function(orientedRange) {};

/**
 * Aligns the cursors or selected text.
 */
ace.Editor.prototype.alignCursors = function() {};

/**
 * Outdents the current line.
 */
ace.Editor.prototype.blockOutdent = function() {};

/**
 * Blurs the current textInput.
 */
ace.Editor.prototype.blur = function() {};

/**
 * Attempts to center the current selection on the screen.
 */
ace.Editor.prototype.centerSelection = function() {};

/**
 * Empties the selection (by de-selecting it). This function also emits the
 * 'changeSelection' event.
 */
ace.Editor.prototype.clearSelection = function() {};

/**
 * Copies all the selected lines down one row.
 * @return {number}
 */
ace.Editor.prototype.copyLinesDown = function() {};

/**
 * Copies all the selected lines up one row.
 * @return {number}
 */
ace.Editor.prototype.copyLinesUp = function() {};

/**
 * Cleans up the entire editor.
 */
ace.Editor.prototype.destroy = function() {};

/** Undocumented */
ace.Editor.prototype.duplicateSelection = function() {};

/** Undocumented */
ace.Editor.prototype.execCommand = function() {};

/**
 * Removes all the selections except the last added one.
 */
ace.Editor.prototype.exitMultiSelectMode = function() {};

/**
 * Attempts to find needle within the document. For more information on
 * options, see Search.
 * @param {string} needle
 * @param {!Object} options
 * @param {boolean} animate
 */
ace.Editor.prototype.find = function(needle, options, animate) {};

/**
 * Finds and selects all the occurences of needle.
 * @param {string} needle
 * @param {!Object} options
 * @param {boolean} keeps
 * @return {number}
 */
ace.Editor.prototype.findAll = function(needle, options, keeps) {};

/**
 * Performs another search for needle in the document. For more information on
 * options, see Search.
 * @param {!Object} options
 * @param {boolean} animate
 */
ace.Editor.prototype.findNext = function(options, animate) {};

/**
 * Performs a search for needle backwards. For more information on options, see
 * Search.
 * @param {!Object} options
 * @param {boolean} animate
 */
ace.Editor.prototype.findPrevious = function(options, animate) {};

/**
 * Brings the current textInput into focus.
 */
ace.Editor.prototype.focus = function() {};

/**
 * Executes a command for each selection range.
 * @param {string} cmd
 * @param {string} args
 */
ace.Editor.prototype.forEachSelection = function(cmd, args) {};

/** Undocumented */
ace.Editor.prototype.getAnimatedScroll = function() {};

/**
 * Returns true if the behaviors are currently enabled.
 * "Behaviors" in this case is the auto-pairing of special characters, like
 * quotation marks, parenthesis, or brackets.
 * @return {boolean}
 */
ace.Editor.prototype.getBehavioursEnabled = function() {};

/**
 * Returns the string of text currently highlighted.
 * @return {string}
 */
ace.Editor.prototype.getCopyText = function() {};

/**
 * Gets the current position of the cursor.
 * @return {!Object}
 */
ace.Editor.prototype.getCursorPosition = function() {};

/**
 * Returns the screen position of the cursor.
 * @return {number}
 */
ace.Editor.prototype.getCursorPositionScreen = function() {};

/** Undocumented */
ace.Editor.prototype.getDisplayIndentGuides = function() {};

/**
 * Returns the current mouse drag delay.
 * @return {number}
 */
ace.Editor.prototype.getDragDelay = function() {};

/** Undocumented */
ace.Editor.prototype.getFadeFoldWidgets = function() {};

/**
 * Returns the index of the first visible row.
 * @return {number}
 */
ace.Editor.prototype.getFirstVisibleRow = function() {};

/**
 * Returns true if current lines are always highlighted.
 * @return {boolean}
 */
ace.Editor.prototype.getHighlightActiveLine = function() {};

/** Undocumented */
ace.Editor.prototype.getHighlightGutterLine = function() {};

/**
 * Returns true if currently highlighted words are to be highlighted.
 * @return {boolean}
 */
ace.Editor.prototype.getHighlightSelectedWord = function() {};

/**
 * Returns the keyboard handler, such as "vim" or "windows".
 * @return {string}
 */
ace.Editor.prototype.getKeyboardHandler = function() {};

/**
 * Returns an object containing all the search options. For more information on
 * options, see Search.
 * @return {!Object}
 */
ace.Editor.prototype.getLastSearchOptions = function() {};

/**
 * Returns the index of the last visible row.
 * @return {number}
 */
ace.Editor.prototype.getLastVisibleRow = function() {};

/**
 * Works like EditSession.getTokenAt(), except it returns a number.
 * @param {!Object} row
 * @param {!Object} column
 * @return {number}
 */
ace.Editor.prototype.getNumberAt = function(row, column) {};

/**
 * Returns true if overwrites are enabled; false otherwise.
 * @return {boolean}
 */
ace.Editor.prototype.getOverwrite = function() {};

/**
 * Returns the column number of where the print margin is.
 * @return {number}
 */
ace.Editor.prototype.getPrintMarginColumn = function() {};

/**
 * Returns true if the editor is set to read-only mode.
 * @return {boolean}
 */
ace.Editor.prototype.getReadOnly = function() {};

/**
 * Returns the value indicating how fast the mouse scroll speed is (in
 * milliseconds).
 * @return {number}
 */
ace.Editor.prototype.getScrollSpeed = function() {};

/**
 * Returns selection object.
 * @return {!ace.Selection}
 */
ace.Editor.prototype.getSelection = function() {};

/**
 * Returns the Range for the selected text.
 * @return {!ace.Range}
 */
ace.Editor.prototype.getSelectionRange = function() {};

/**
 * Returns the current selection style.
 * @return {string}
 */
ace.Editor.prototype.getSelectionStyle = function() {};

/**
 * Returns the current session being used.
 * @return {!ace.EditSession}
 */
ace.Editor.prototype.getSession = function() {};

/**
 * Returns true if the fold widgets are shown.
 * @return {boolean}
 */
ace.Editor.prototype.getShowFoldWidgets = function() {};

/**
 * Returns true if invisible characters are being shown.
 * @return {boolean}
 */
ace.Editor.prototype.getShowInvisibles = function() {};

/**
 * Returns true if the print margin is being shown.
 * @return {boolean}
 */
ace.Editor.prototype.getShowPrintMargin = function() {};

/**
 * Returns the path of the current theme.
 * @return {string}
 */
ace.Editor.prototype.getTheme = function() {};

/**
 * Returns the current session's content.
 * @return {string}
 */
ace.Editor.prototype.getValue = function() {};

/**
 * Returns true if the wrapping behaviors are currently enabled.
 */
ace.Editor.prototype.getWrapBehavioursEnabled = function() {};

/**
 * Moves the cursor to the specified line number, and also into the indiciated
 * column.
 * @param {number} lineNumber
 * @param {number} column
 * @param {boolean} animate
 */
ace.Editor.prototype.gotoLine = function(lineNumber, column, animate) {};

/**
 * Shifts the document to wherever "page down" is, as well as moving the cursor
 * position.
 */
ace.Editor.prototype.gotoPageDown = function() {};

/**
 * Shifts the document to wherever "page up" is, as well as moving the cursor
 * position.
 */
ace.Editor.prototype.gotoPageUp = function() {};

/**
 * Indents the current line.
 */
ace.Editor.prototype.indent = function() {};

/**
 * Inserts text into wherever the cursor is pointing.
 * @param {string} text
 */
ace.Editor.prototype.insert = function(text) {};

/**
 * Returns true if the current textInput is in focus.
 * @return {boolean}
 */
ace.Editor.prototype.isFocused = function() {};

/**
 * Indicates if the entire row is currently visible on the screen.
 * @param {number} row
 * @return {boolean}
 */
ace.Editor.prototype.isRowFullyVisible = function(row) {};

/**
 * Indicates if the row is currently visible on the screen.
 * @param {number} row
 * @return {boolean}
 */
ace.Editor.prototype.isRowVisible = function(row) {};

/**
 * Moves the cursor's row and column to the next matching bracket.
 * @param {!Object} select
 */
ace.Editor.prototype.jumpToMatching = function(select) {};

/**
 * If the character before the cursor is a number, this functions changes its
 * value by amount.
 * @param {number} amount
 */
ace.Editor.prototype.modifyNumber = function(amount) {};

/**
 * Moves the cursor to the specified row and column. Note that this does not
 * de-select the current selection.
 * @param {number} row
 * @param {number} column
 */
ace.Editor.prototype.moveCursorTo = function(row, column) {};

/**
 * Moves the cursor to the position indicated by pos.row and pos.column.
 * @param {{row: number, column: number}} pos
 */
ace.Editor.prototype.moveCursorToPosition = function(pos) {};

/**
 * Shifts all the selected lines down one row.
 * @return {number}
 */
ace.Editor.prototype.moveLinesDown = function() {};

/**
 * Shifts all the selected lines up one row.
 * @return {number}
 */
ace.Editor.prototype.moveLinesUp = function() {};

/** Undocumented */
ace.Editor.prototype.moveText = function() {};

/**
 * Moves the cursor down in the document the specified number of times. Note
 * that this does de-select the current selection.
 * @param {number} times
 */
ace.Editor.prototype.navigateDown = function(times) {};

/**
 * Moves the cursor to the end of the current file. Note that this does
 * de-select the current selection.
 */
ace.Editor.prototype.navigateFileEnd = function() {};

/**
 * Moves the cursor to the start of the current file. Note that this does
 * de-select the current selection.
 */
ace.Editor.prototype.navigateFileStart = function() {};

/**
 * Moves the cursor left in the document the specified number of times. Note
 * that this does de-select the current selection.
 * @param {number} times
 */
ace.Editor.prototype.navigateLeft = function(times) {};

/**
 * Moves the cursor to the end of the current line. Note that this does
 * de-select the current selection.
 */
ace.Editor.prototype.navigateLineEnd = function() {};

/**
 * Moves the cursor to the start of the current line. Note that this does
 * de-select the current selection.
 */
ace.Editor.prototype.navigateLineStart = function() {};

/**
 * Moves the cursor right in the document the specified number of times. Note
 * that this does de-select the current selection.
 * @param {number} times
 */
ace.Editor.prototype.navigateRight = function(times) {};

/**
 * Moves the cursor to the specified row and column. Note that this does
 * de-select the current selection.
 * @param {number} row
 * @param {number} column
 */
ace.Editor.prototype.navigateTo = function(row, column) {};

/**
 * Moves the cursor up in the document the specified number of times. Note that
 * this does de-select the current selection.
 * @param {number} times
 */
ace.Editor.prototype.navigateUp = function(times) {};

/**
 * Moves the cursor to the word immediately to the left of the current
 * position. Note that this does de-select the current selection.
 */
ace.Editor.prototype.navigateWordLeft = function() {};

/**
 * Moves the cursor to the word immediately to the right of the current
 * position. Note that this does de-select the current selection.
 */
/** Undocumented */
ace.Editor.prototype.navigateWordRight = function() {};

/** Undocumented */
ace.Editor.prototype.onBlur = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeAnnotation = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeBackMarker = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeBreakpoint = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeFold = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeFrontMarker = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeMode = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeWrapLimit = function() {};

/** Undocumented */
ace.Editor.prototype.onChangeWrapMode = function() {};

/** Undocumented */
ace.Editor.prototype.onCommandKey = function() {};

/** Undocumented */
ace.Editor.prototype.onCompositionEnd = function() {};

/** Undocumented */
ace.Editor.prototype.onCompositionStart = function() {};

/** Undocumented */
ace.Editor.prototype.onCompositionUpdate = function() {};

/**
 * Called whenever a text "copy" happens.
 */
ace.Editor.prototype.onCopy = function() {};

/**
 * Emitted when the selection changes.
 */
ace.Editor.prototype.onCursorChange = function() {};

/**
 * Called whenever a text "cut" happens.
 */
ace.Editor.prototype.onCut = function() {};

/** Undocumented */
ace.Editor.prototype.onDocumentChange = function() {};

/** Undocumented */
ace.Editor.prototype.onFocus = function() {};

/**
 * Called whenever a text "paste" happens.
 * @param {string} text
 */
ace.Editor.prototype.onPaste = function(text) {};

/** Undocumented */
ace.Editor.prototype.onScrollLeftChange = function() {};

/** Undocumented */
ace.Editor.prototype.onScrollTopChange = function() {};

/** Undocumented */
ace.Editor.prototype.onSelectionChange = function() {};

/** Undocumented */
ace.Editor.prototype.onTextInput = function() {};

/** Undocumented */
ace.Editor.prototype.onTokenizerUpdate = function() {};

/**
 * Perform a redo operation on the document, reimplementing the last change.
 */
ace.Editor.prototype.redo = function() {};

/**
 * Removes words of text from the editor. A "word" is defined as a string of
 * characters bookended by whitespace.
 * @param {string} dir
 */
ace.Editor.prototype.remove = function(dir) {};

/**
 * Removes all the lines in the current selection.
 */
ace.Editor.prototype.removeLines = function() {};

/**
 * Removes the selection marker.
 * @param {!ace.Range} range
 */
ace.Editor.prototype.removeSelectionMarker = function(range) {};

/**
 * Removes all the words to the right of the current selection, until the end
 * of the line.
 */
ace.Editor.prototype.removeToLineEnd = function() {};

/**
 * Removes all the words to the left of the current selection, until the start
 * of the line.
 */
ace.Editor.prototype.removeToLineStart = function() {};

/**
 * Removes the word directly to the left of the current selection.
 */
ace.Editor.prototype.removeWordLeft = function() {};

/**
 * Removes the word directly to the right of the current selection.
 */
ace.Editor.prototype.removeWordRight = function() {};

/**
 * Replaces the first occurance of options.needle with the value in replacement.
 * @param {string} replacement
 * @return {{needle: string}} options
 */
ace.Editor.prototype.replace = function(replacement, options) {};

/**
 * Replaces all occurences of options.needle with the value in replacement.
 * @param {string} replacement
 * @return {{needle: string}} options
 */
ace.Editor.prototype.replaceAll = function(replacement, options) {};

/**
 * Triggers a resize of the editor.
 * @param {boolean} force
 */
ace.Editor.prototype.resize = function(force) {};

/** Undocumented */
ace.Editor.prototype.revealRange = function() {};

/**
 * Scrolls the document to wherever "page down" is, without changing the cursor
 * position.
 */
ace.Editor.prototype.scrollPageDown = function() {};

/**
 * Scrolls the document to wherever "page up" is, without changing the cursor
 * position.
 */
ace.Editor.prototype.scrollPageUp = function() {};

/**
 * Scrolls to a line. If center is true, it puts the line in middle of screen
 * (or attempts to).
 * @param {number} line
 * @param {boolean} center
 * @param {boolean} animate
 * @param {!Function} callback
 */
ace.Editor.prototype.scrollToLine = function(line, center, animate, callback) {};

/**
 * Moves the editor to the specified row.
 * @param {!Object} row
 */
ace.Editor.prototype.scrollToRow = function(row) {};

/**
 * Selects all the text in editor.
 */
ace.Editor.prototype.selectAll = function() {};

/**
 * Finds the next occurence of text in an active selection and adds it to the
 * selections.
 * @param {number} dir
 * @param {boolean} skip
 */
ace.Editor.prototype.selectMore = function(dir, skip) {};

/**
 * Adds a cursor above or below the active cursor.
 * @param {number} dir
 * @param {boolean} skip
 */
ace.Editor.prototype.selectMoreLines = function(dir, skip) {};

/**
 * Selects the text from the current position of the document until where a
 * "page down" finishes.
 */
ace.Editor.prototype.selectPageDown = function() {};

/**
 * Selects the text from the current position of the document until where a
 * "page up" finishes.
 */
ace.Editor.prototype.selectPageUp = function() {};

/** Undocumented */
ace.Editor.prototype.setAnimatedScroll = function() {};

/**
 * Specifies whether to use behaviors or not.
 * "Behaviors" in this case is the auto-pairing of special characters, like
 * quotation marks, parenthesis, or brackets.
 * @param {boolean} enabled
 */
ace.Editor.prototype.setBehavioursEnabled = function(enabled) {};

/** Undocumented */
ace.Editor.prototype.setDisplayIndentGuides = function() {};

/**
 * Sets the delay (in milliseconds) of the mouse drag.
 * @param {number} dragDelay
 */
ace.Editor.prototype.setDragDelay = function(dragDelay) {};

/** Undocumented */
ace.Editor.prototype.setFadeFoldWidgets = function() {};

/**
 * Set a new font size (in pixels) for the editor text.
 * @param {number} size
 */
ace.Editor.prototype.setFontSize = function(size) {};

/**
 * Determines whether or not the current line should be highlighted.
 * @param {boolean} shouldHighlight
 */
ace.Editor.prototype.setHighlightActiveLine = function(shouldHighlight) {};

/** Undocumented */
ace.Editor.prototype.setHighlightGutterLine = function() {};

/**
 * Determines if the currently selected word should be highlighted.
 * @param {boolean} shouldHighlight
 */
ace.Editor.prototype.setHighlightSelectedWord = function(shouldHighlight) {};

/**
 * Sets a new key handler, such as "vim" or "windows".
 * @param {string} keyboardHandler
 */
ace.Editor.prototype.setKeyboardHandler = function(keyboardHandler) {};

/**
 * 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 emits the
 * changeOverwrite event.
 * @param {boolean} overwrite
 */
ace.Editor.prototype.setOverwrite = function(overwrite) {};

/**
 * Sets the column defining where the print margin should be.
 * @param {number} showPrintMargin
 */
ace.Editor.prototype.setPrintMarginColumn = function(showPrintMargin) {};

/**
 * If readOnly is true, then the editor is set to read-only mode, and none of
 * the content can change.
 * @param {boolean} readOnly
 */
ace.Editor.prototype.setReadOnly = function(readOnly) {};

/**
 * Sets how fast the mouse scrolling should do.
 * @param {number} speed
 */
ace.Editor.prototype.setScrollSpeed = function(speed) {};

/**
 * Indicates how selections should occur.
 * @param {string} style
 */
ace.Editor.prototype.setSelectionStyle = function(style) {};

/**
 * Sets a new editsession to use. This method also emits the 'changeSession'
 * event.
 * @param {!ace.EditSession} session
 */
ace.Editor.prototype.setSession = function(session) {};

/**
 * Indicates whether the fold widgets are shown or not.
 * @param {boolean} show
 */
ace.Editor.prototype.setShowFoldWidgets = function(show) {};

/**
 * If showInvisibles is set to true, invisible characters—like spaces or new
 * lines—are show in the editor.
 * @param {boolean} showInvisibles
 */
ace.Editor.prototype.setShowInvisibles = function(showInvisibles) {};

/**
 * If showPrintMargin is set to true, the print margin is shown in the editor.
 * @param {boolean} showPrintMargin
 */
ace.Editor.prototype.setShowPrintMargin = function(showPrintMargin) {};

/**
 * Adds a new class, style, to the editor.
 * @param {string} style
 */
ace.Editor.prototype.setStyle = function(style) {};

/**
 * Sets a new theme for the editor. theme should exist, and be a directory
 * path, like ace/theme/textmate.
 * @param {string} theme
 */
ace.Editor.prototype.setTheme = function(theme) {};

/**
 * Sets the current document to val.
 * @param {string} val
 * @param {number} cursorPos
 * @return {string}
 */
ace.Editor.prototype.setValue = function(val, cursorPos) {};

/**
 * 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 {boolean} enabled
 */
ace.Editor.prototype.setWrapBehavioursEnabled = function(enabled) {};

/** Undocumented */
ace.Editor.prototype.sortLines = function() {};

/**
 * Splits the line at the current selection (by inserting an '\n').
 */
ace.Editor.prototype.splitLine = function() {};

/**
 * Given the currently selected range, this function either comments all the
 * lines, or uncomments all of them.
 */
ace.Editor.prototype.toggleCommentLines = function() {};

/**
 * Sets the value of overwrite to the opposite of whatever it currently is.
 */
ace.Editor.prototype.toggleOverwrite = function() {};

/**
 * Converts the current selection entirely into lowercase.
 */
ace.Editor.prototype.toLowerCase = function() {};

/**
 * Converts the current selection entirely into uppercase.
 */
ace.Editor.prototype.toUpperCase = function() {};

/**
 * Transposes current line.
 */
ace.Editor.prototype.transposeLetters = function() {};

/**
 * Transposes the selected ranges.
 * @param {number} dir
 */
ace.Editor.prototype.transposeSelections = function(dir) {};

/**
 * Perform an undo operation on the document, reverting the last change.
 */
ace.Editor.prototype.undo = function() {};

/**
 * Removes the class style from the editor.
 * @param {!Object} style
 */
ace.Editor.prototype.unsetStyle = function(style) {};

/**
 * Updates the cursor and marker layers.
 */
ace.Editor.prototype.updateSelectionMarkers = function() {};

/**
 * Creates a new Range object with the given starting and ending row and column
 * points.
 * @constructor
 * @param {number} startRow
 * @param {number} startColumn
 * @param {number} endRow
 * @param {number} endColumn
 * @see https://ace.c9.io/#nav=api&api=range
 */
ace.Range = function(startRow, startColumn, endRow, endColumn) {};

/**
 * Returns the part of the current Range that occurs within the boundaries of
 * firstRow and lastRow as a new Range object.
 * @param {number} firstRow
 * @param {number} lastRow
 * @return {!ace.Range}
 */
ace.Range.prototype.clipRows = function(firstRow, lastRow) {};

/**
 * Returns a duplicate of the calling range.
 * @return {!ace.Range}
 */
ace.Range.prototype.clone = function() {};

/**
 * Returns a range containing the starting and ending rows of the original
 * range, but with a column value of 0.
 * @