ace-builds
Version:
Ace (Ajax.org Cloud9 Editor)
1,160 lines (1,159 loc) • 52.7 kB
TypeScript
/* This file is generated using `npm run update-types` */
declare module "ace-builds/src-noconflict/ext-command_bar" {
/**
* Displays a command tooltip above the currently active line selection, with clickable elements.
*
* Internally it is a composite of two tooltips, one for the main tooltip and one for the
* overflowing commands.
* The commands are added sequentially in registration order.
* When attached to an editor, it is either always shown or only when the active line is hovered
* with mouse, depending on the alwaysShow property.
*/
export class CommandBarTooltip {
constructor(parentNode: HTMLElement, options?: Partial<import("ace-builds").Ace.CommandBarOptions>);
parentNode: HTMLElement;
tooltip: Tooltip;
moreOptions: Tooltip;
maxElementsOnTooltip: number;
eventListeners: {};
elements: {};
commands: {};
tooltipEl: HTMLDivElement;
moreOptionsEl: HTMLDivElement;
/**
* Registers a command on the command bar tooltip.
*
* The commands are added in sequential order. If there is not enough space on the main
* toolbar, the remaining elements are added to the overflow menu.
*
*/
registerCommand(id: string, command: TooltipCommand): void;
isShown(): boolean;
isMoreOptionsShown(): boolean;
getAlwaysShow(): boolean;
/**
* Sets the display mode of the tooltip
*
* When true, the tooltip is always displayed while it is attached to an editor.
* When false, the tooltip is displayed only when the mouse hovers over the active editor line.
*
*/
setAlwaysShow(alwaysShow: boolean): void;
/**
* Attaches the clickable command bar tooltip to an editor
*
* Depending on the alwaysShow parameter it either displays the tooltip immediately,
* or subscribes to the necessary events to display the tooltip on hover.
*
*/
attach(editor: Editor): void;
editor: import("ace-builds-internal/editor").Editor;
/**
* Updates the position of the command bar tooltip. It aligns itself above the active line in the editor.
*/
updatePosition(): void;
/**
* Updates each command element in the tooltip.
*
* This is automatically called on certain events, but can be called manually as well.
*/
update(): void;
/**
* Detaches the tooltip from the editor.
*/
detach(): void;
destroy(): void;
}
export type Editor = import("ace-builds-internal/editor").Editor;
export type TooltipCommand = import("ace-builds").Ace.TooltipCommand;
import { Tooltip } from "ace-builds-internal/tooltip";
export var TOOLTIP_CLASS_NAME: string;
export var BUTTON_CLASS_NAME: string;
namespace Ace {
type EventEmitter<T extends {
[K in keyof T]: (...args: any[]) => any;
}> = import("ace-builds").Ace.EventEmitter<T>;
type CommandBarEvents = import("ace-builds").Ace.CommandBarEvents;
}
export interface CommandBarTooltip extends Ace.EventEmitter<Ace.CommandBarEvents> {
}
}
declare module "ace-builds/src-noconflict/ext-language_tools" {
export function setCompleters(val?: import("ace-builds").Ace.Completer[]): void;
export function addCompleter(completer: import("ace-builds").Ace.Completer): void;
import textCompleter = require("ace-builds-internal/autocomplete/text_completer");
export var keyWordCompleter: import("ace-builds").Ace.Completer;
export var snippetCompleter: import("ace-builds").Ace.Completer;
import { MarkerGroup } from "ace-builds-internal/marker_group";
export { textCompleter, MarkerGroup };
}
declare module "ace-builds/src-noconflict/ext-inline_autocomplete" {
/**
* This class controls the inline-only autocompletion components and their lifecycle.
* This is more lightweight than the popup-based autocompletion, as it can only work with exact prefix matches.
* There is an inline ghost text renderer and an optional command bar tooltip inside.
*/
export class InlineAutocomplete {
constructor(editor: Editor);
editor: Editor;
keyboardHandler: HashHandler;
blurListener(e: any): void;
changeListener(e: any): void;
changeTimer: {
(timeout?: number): void;
delay(timeout?: number): void;
schedule: any;
call(): void;
cancel(): void;
isPending(): any;
};
getInlineRenderer(): AceInline;
inlineRenderer: AceInline;
getInlineTooltip(): CommandBarTooltip;
inlineTooltip: CommandBarTooltip;
/**
* This function is the entry point to the class. This triggers the gathering of the autocompletion and displaying the results;
*/
show(options: import("ace-builds").Ace.CompletionOptions): void;
activated: boolean;
insertMatch(): boolean;
goTo(where: import("ace-builds").Ace.InlineAutocompleteAction): void;
getLength(): any;
getData(index?: number): import("ace-builds").Ace.Completion | undefined;
getIndex(): number;
isOpen(): boolean;
setIndex(value: number): void;
getCompletionProvider(initialPosition: any): CompletionProvider;
completionProvider: CompletionProvider;
updateCompletions(options?: import("ace-builds").Ace.CompletionOptions): void;
base: import("ace-builds-internal/anchor").Anchor;
completions: FilteredList;
detach(): void;
destroy(): void;
updateDocTooltip(): void;
commands: {
[key: string]: import("ace-builds").Ace.Command;
};
}
export namespace InlineAutocomplete {
function _for(editor: any): any;
export { _for as for };
export namespace startCommand {
let name: string;
function exec(editor: any, options: any): void;
export namespace bindKey {
let win: string;
let mac: string;
}
}
/**
* Factory method to create a command bar tooltip for inline autocomplete.
*
* @param {HTMLElement} parentEl The parent element where the tooltip HTML elements will be added.
* @returns {CommandBarTooltip} The command bar tooltip for inline autocomplete
*/
export function createInlineTooltip(parentEl: HTMLElement): CommandBarTooltip;
}
import { Editor } from "ace-builds-internal/editor";
import { HashHandler } from "ace-builds-internal/keyboard/hash_handler";
import { AceInline } from "ace-builds-internal/autocomplete/inline";
import { CommandBarTooltip } from "ace-builds/src-noconflict/ext-command_bar";
import { CompletionProvider } from "ace-builds-internal/autocomplete";
import { FilteredList } from "ace-builds-internal/autocomplete";
}
declare module "ace-builds/src-noconflict/ext-searchbox-css" {
const _exports: string;
export = _exports;
}
declare module "ace-builds/src-noconflict/ext-searchbox" {
export function Search(editor: Editor, isReplace?: boolean): void;
export type Editor = import("ace-builds-internal/editor").Editor;
export class SearchBox {
constructor(editor: Editor, range?: never, showReplaceForm?: never);
activeInput: HTMLInputElement;
element: HTMLDivElement;
setSession(e: any): void;
setEditor(editor: Editor): void;
editor: Editor;
searchRange: any;
onEditorInput(): void;
searchBox: HTMLElement;
replaceBox: HTMLElement;
searchOption: HTMLInputElement;
replaceOption: HTMLInputElement;
regExpOption: HTMLInputElement;
caseSensitiveOption: HTMLInputElement;
wholeWordOption: HTMLInputElement;
searchInput: HTMLInputElement;
replaceInput: HTMLInputElement;
searchCounter: HTMLElement;
/**
*
* @external
*/
$onChange: {
schedule: (timeout?: number) => void;
};
setSearchRange(range: any): void;
searchRangeMarker: number;
/**
* @external
*/
$syncOptions(preventScroll?: boolean): void;
highlight(re?: RegExp): void;
find(skipCurrent: boolean, backwards: boolean, preventScroll?: any): void;
updateCounter(): void;
findNext(): void;
findPrev(): void;
findAll(): void;
replace(): void;
replaceAndFindNext(): void;
replaceAll(): void;
hide(): void;
active: boolean;
show(value: string, isReplace?: boolean): void;
isFocused(): boolean;
}
import { HashHandler } from "ace-builds-internal/keyboard/hash_handler";
}
declare module "ace-builds/src-noconflict/ext-diff/scroll_diff_decorator" {
export class ScrollDiffDecorator extends Decorator {
constructor(scrollbarV: import("ace-builds").Ace.VScrollbar, renderer: import("ace-builds-internal/virtual_renderer").VirtualRenderer, forInlineDiff?: boolean);
addZone(startRow: number, endRow: number, type: "delete" | "insert"): void;
setSessions(sessionA: import("ace-builds-internal/edit_session").EditSession, sessionB: import("ace-builds-internal/edit_session").EditSession): void;
sessionA: import("ace-builds-internal/edit_session").EditSession;
sessionB: import("ace-builds-internal/edit_session").EditSession;
}
import { Decorator } from "ace-builds-internal/layer/decorators";
}
declare module "ace-builds/src-noconflict/ext-diff/styles-css" {
export const cssText: "\n/*\n * Line Markers\n */\n.ace_diff {\n position: absolute;\n z-index: 0;\n}\n.ace_diff.inline {\n z-index: 20;\n}\n/*\n * Light Colors \n */\n.ace_diff.insert {\n background-color: #EFFFF1;\n}\n.ace_diff.delete {\n background-color: #FFF1F1;\n}\n.ace_diff.aligned_diff {\n background: rgba(206, 194, 191, 0.26);\n background: repeating-linear-gradient(\n 45deg,\n rgba(122, 111, 108, 0.26),\n rgba(122, 111, 108, 0.26) 5px,\n rgba(0, 0, 0, 0) 5px,\n rgba(0, 0, 0, 0) 10px \n );\n}\n\n.ace_diff.insert.inline {\n background-color: rgb(74 251 74 / 18%); \n}\n.ace_diff.delete.inline {\n background-color: rgb(251 74 74 / 15%);\n}\n\n.ace_diff.delete.inline.empty {\n background-color: rgba(255, 128, 79, 0.7);\n width: 2px !important;\n}\n\n.ace_diff.insert.inline.empty {\n background-color: rgba(49, 230, 96, 0.7);\n width: 2px !important;\n}\n\n.ace_diff-active-line {\n border-bottom: 1px solid;\n border-top: 1px solid;\n background: transparent;\n position: absolute;\n box-sizing: border-box;\n border-color: #9191ac;\n}\n\n.ace_dark .ace_diff-active-line {\n background: transparent;\n border-color: #75777a;\n}\n \n\n/* gutter changes */\n.ace_mini-diff_gutter-enabled > .ace_gutter-cell,\n.ace_mini-diff_gutter-enabled > .ace_gutter-cell_svg-icons {\n padding-right: 13px;\n}\n\n.ace_mini-diff_gutter_other > .ace_gutter-cell,\n.ace_mini-diff_gutter_other > .ace_gutter-cell_svg-icons {\n display: none;\n}\n\n.ace_mini-diff_gutter_other {\n pointer-events: none;\n}\n\n\n.ace_mini-diff_gutter-enabled > .mini-diff-added {\n background-color: #EFFFF1;\n border-left: 3px solid #2BB534;\n padding-left: 16px;\n display: block;\n}\n\n.ace_mini-diff_gutter-enabled > .mini-diff-deleted {\n background-color: #FFF1F1;\n border-left: 3px solid #EA7158;\n padding-left: 16px;\n display: block;\n}\n\n\n.ace_mini-diff_gutter-enabled > .mini-diff-added:after {\n position: absolute;\n right: 2px;\n content: \"+\";\n color: darkgray;\n background-color: inherit;\n}\n\n.ace_mini-diff_gutter-enabled > .mini-diff-deleted:after {\n position: absolute;\n right: 2px;\n content: \"-\";\n color: darkgray;\n background-color: inherit;\n}\n.ace_fade-fold-widgets:hover > .ace_folding-enabled > .mini-diff-added:after,\n.ace_fade-fold-widgets:hover > .ace_folding-enabled > .mini-diff-deleted:after {\n display: none;\n}\n\n.ace_diff_other .ace_selection {\n filter: drop-shadow(1px 2px 3px darkgray);\n}\n\n.ace_hidden_marker-layer .ace_bracket {\n display: none;\n}\n\n\n\n/*\n * Dark Colors \n */\n\n.ace_dark .ace_diff.insert {\n background-color: #212E25;\n}\n.ace_dark .ace_diff.delete {\n background-color: #3F2222;\n}\n\n.ace_dark .ace_mini-diff_gutter-enabled > .mini-diff-added {\n background-color: #212E25;\n border-left-color:#00802F;\n}\n\n.ace_dark .ace_mini-diff_gutter-enabled > .mini-diff-deleted {\n background-color: #3F2222;\n border-left-color: #9C3838;\n}\n\n";
}
declare module "ace-builds/src-noconflict/ext-diff/gutter_decorator" {
export class MinimalGutterDiffDecorator {
constructor(editor: import("ace-builds-internal/editor").Editor, type: number);
gutterClass: string;
gutterCellsClasses: {
add: string;
delete: string;
};
editor: import("ace-builds-internal/editor").Editor;
type: number;
chunks: any[];
attachToEditor(): void;
renderGutters(e: any, gutterLayer: any): void;
setDecorations(changes: any): void;
dispose(): void;
}
}
declare module "ace-builds/src-noconflict/ext-diff/inline_diff_view" {
export class InlineDiffView extends BaseDiffView {
/**
* Constructs a new inline DiffView instance.
* @param {import("ace-builds-internal/diff").DiffModel} [diffModel] - The model for the diff view.
* @param {HTMLElement} [container] - optional container element for the DiffView.
*/
constructor(diffModel?: import("ace-builds/src-noconflict/ext-diff").DiffModel, container?: HTMLElement);
init(diffModel: any): void;
onAfterRender(changes: number, renderer: import("ace-builds").VirtualRenderer): void;
textLayer: any;
markerLayer: any;
gutterLayer: any;
cursorLayer: any;
initRenderer(restore: any): void;
initTextLayer(): void;
initTextInput(restore: any): void;
othertextInput: any;
otherEditorContainer: any;
selectEditor(editor: any): void;
removeBracketHighlight(editor: any): void;
initMouse(): void;
onMouseDetach: () => void;
onChangeWrapLimit(): void;
}
import { BaseDiffView } from "ace-builds/src-noconflict/ext-diff/base_diff_view";
}
declare module "ace-builds/src-noconflict/ext-diff/split_diff_view" {
export class SplitDiffView extends BaseDiffView {
/**
* Constructs a new side by side DiffView instance.
*
* @param {import("ace-builds-internal/diff").DiffModel} [diffModel] - The model for the diff view.
*/
constructor(diffModel?: import("ace-builds/src-noconflict/ext-diff").DiffModel);
init(diffModel: any): void;
onMouseWheel(ev: any): any;
onScroll(e: any, session: any): void;
onChangeWrapLimit(): void;
syncScroll(renderer: import("ace-builds-internal/virtual_renderer").VirtualRenderer): void;
scrollA: any;
scrollB: any;
scrollSetBy: any;
scrollSetAt: number;
}
import { BaseDiffView } from "ace-builds/src-noconflict/ext-diff/base_diff_view";
}
declare module "ace-builds/src-noconflict/ext-diff/providers/default" {
export function computeDiff(originalLines: any, modifiedLines: any, options: any): any;
/**
* VSCode’s computeDiff provider
*/
export class DiffProvider {
compute(originalLines: any, modifiedLines: any, opts: any): any;
}
}
declare module "ace-builds/src-noconflict/ext-diff" {
/**
* Interface representing a model for handling differences between two views or states.
*/
export type DiffModel = {
/**
* - The editor for the original view.
*/
editorA?: import("ace-builds-internal/editor").Editor;
/**
* - The editor for the edited view.
*/
editorB?: import("ace-builds-internal/editor").Editor;
/**
* - The edit session for the original view.
*/
sessionA?: import("ace-builds-internal/edit_session").EditSession;
/**
* - The edit session for the edited view.
*/
sessionB?: import("ace-builds-internal/edit_session").EditSession;
/**
* - The original content.
*/
valueA?: string;
/**
* - The modified content.
*/
valueB?: string;
/**
* - Whether to show the original view("a") or modified view("b") for inline diff view
*/
inline?: "a" | "b";
/**
* - Provider for computing differences between original and modified content.
*/
diffProvider?: IDiffProvider;
};
export type DiffViewOptions = {
/**
* - Whether to show line numbers in the other editor's gutter
*/
showOtherLineNumbers?: boolean;
/**
* - Whether to enable code folding widgets
*/
folding?: boolean;
/**
* - Whether to synchronize selections between both editors
*/
syncSelections?: boolean;
/**
* - Whether to ignore trimmed whitespace when computing diffs
*/
ignoreTrimWhitespace?: boolean;
/**
* - Whether to enable word wrapping in both editors
*/
wrap?: boolean;
/**
* - Maximum number of diffs to compute before failing silently
*/
maxDiffs?: number;
/**
* - Theme to apply to both editors
*/
theme?: string | import("ace-builds").Ace.Theme;
};
export type IDiffProvider = {
/**
* - Computes differences between original and modified lines
*/
compute: (originalLines: string[], modifiedLines: string[], opts?: any) => import("ace-builds/src-noconflict/ext-diff/base_diff_view").DiffChunk[];
};
import { InlineDiffView } from "ace-builds/src-noconflict/ext-diff/inline_diff_view";
import { SplitDiffView } from "ace-builds/src-noconflict/ext-diff/split_diff_view";
import { DiffProvider } from "ace-builds/src-noconflict/ext-diff/providers/default";
/**
* Interface representing a model for handling differences between two views or states.
* @property {import("ace-builds-internal/editor").Editor} [editorA] - The editor for the original view.
* @property {import("ace-builds-internal/editor").Editor} [editorB] - The editor for the edited view.
* @property {import("ace-builds-internal/edit_session").EditSession} [sessionA] - The edit session for the original view.
* @property {import("ace-builds-internal/edit_session").EditSession} [sessionB] - The edit session for the edited view.
* @property {string} [valueA] - The original content.
* @property {string} [valueB] - The modified content.
* @property {"a"|"b"} [inline] - Whether to show the original view("a") or modified view("b") for inline diff view
* @property {IDiffProvider} [diffProvider] - Provider for computing differences between original and modified content.
*/
/**
* @property {boolean} [showOtherLineNumbers=true] - Whether to show line numbers in the other editor's gutter
* @property {boolean} [folding] - Whether to enable code folding widgets
* @property {boolean} [syncSelections] - Whether to synchronize selections between both editors
* @property {boolean} [ignoreTrimWhitespace] - Whether to ignore trimmed whitespace when computing diffs
* @property {boolean} [wrap] - Whether to enable word wrapping in both editors
* @property {number} [maxDiffs=5000] - Maximum number of diffs to compute before failing silently
* @property {string|import("ace-builds").Ace.Theme} [theme] - Theme to apply to both editors
*/
/**
* @property {(originalLines: string[], modifiedLines: string[], opts?: any) => import("ace-builds-internal/diff/base_diff_view").DiffChunk[]} compute - Computes differences between original and modified lines
*/
/**
* Creates a diff view for comparing code.
* @param {DiffModel} [diffModel] model for the diff view
* @param {DiffViewOptions} [options] options for the diff view
* @returns {InlineDiffView|SplitDiffView} Configured diff view instance
*/
export function createDiffView(diffModel?: DiffModel, options?: DiffViewOptions): InlineDiffView | SplitDiffView;
export { InlineDiffView, SplitDiffView, DiffProvider };
}
declare module "ace-builds/src-noconflict/ext-diff/base_diff_view" {
export class BaseDiffView {
/**
* Constructs a new base DiffView instance.
* @param {boolean} [inlineDiffEditor] - Whether to use an inline diff editor.
* @param {HTMLElement} [container] - optional container element for the DiffView.
*/
constructor(inlineDiffEditor?: boolean, container?: HTMLElement);
onChangeTheme(e: any): void;
onInput(): void;
onChangeFold(ev: any, session: EditSession): void;
realign(): void;
onSelect(e: any, selection: any): void;
onChangeWrapLimit(e: any, session: any): void;
realignPending: boolean;
diffSession: {
sessionA: EditSession;
sessionB: EditSession;
chunks: DiffChunk[];
};
/**@type DiffChunk[]*/ chunks: DiffChunk[];
inlineDiffEditor: boolean;
currentDiffIndex: number;
diffProvider: {
compute: (val1: any, val2: any, options: any) => any[];
};
container: HTMLElement;
markerB: DiffHighlight;
markerA: DiffHighlight;
showSideA: boolean;
savedOptionsA: Partial<import("ace-builds").Ace.EditorOptions>;
savedOptionsB: Partial<import("ace-builds").Ace.EditorOptions>;
editorA: any;
editorB: any;
activeEditor: any;
otherSession: EditSession;
otherEditor: any;
addGutterDecorators(): void;
gutterDecoratorA: MinimalGutterDiffDecorator;
gutterDecoratorB: MinimalGutterDiffDecorator;
foldUnchanged(): boolean;
unfoldUnchanged(): void;
toggleFoldUnchanged(): void;
setDiffSession(session: {
sessionA: any;
sessionB: EditSession;
chunks: DiffChunk[];
}): void;
sessionA: EditSession;
sessionB: EditSession;
getDiffSession(): {
sessionA: EditSession;
sessionB: EditSession;
chunks: DiffChunk[];
};
setTheme(theme: any): void;
getTheme(): any;
resize(force: any): void;
scheduleOnInput(): void;
selectionRangeA: any;
selectionRangeB: any;
setupScrollbars(): void;
updateScrollBarDecorators(): void;
setProvider(provider: import("ace-builds/src-noconflict/ext-diff").DiffProvider): void;
/**
* scroll locking
* @abstract
**/
align(): void;
syncSelect(selection: any): void;
updateSelectionMarker(marker: any, session: any, range: any): void;
scheduleRealign(): void;
detach(): void;
destroy(): void;
gotoNext(dir: any): void;
firstDiffSelected(): boolean;
lastDiffSelected(): boolean;
transformRange(range: Range, isOriginal: boolean): Range;
transformPosition(pos: import("ace-builds").Ace.Point, isOriginal: boolean): import("ace-builds").Ace.Point;
printDiffs(): void;
findChunkIndex(chunks: DiffChunk[], row: number, isOriginal: boolean): number;
searchHighlight(selection: any): void;
initSelectionMarkers(): void;
syncSelectionMarkerA: SyncSelectionMarker;
syncSelectionMarkerB: SyncSelectionMarker;
clearSelectionMarkers(): void;
}
import { EditSession } from "ace-builds-internal/edit_session";
export class DiffChunk {
/**
* @param {{originalStartLineNumber: number, originalStartColumn: number,
* originalEndLineNumber: number, originalEndColumn: number, modifiedStartLineNumber: number,
* modifiedStartColumn: number, modifiedEndLineNumber: number, modifiedEndColumn: number}[]} [charChanges]
*/
constructor(originalRange: Range, modifiedRange: Range, charChanges?: {
originalStartLineNumber: number;
originalStartColumn: number;
originalEndLineNumber: number;
originalEndColumn: number;
modifiedStartLineNumber: number;
modifiedStartColumn: number;
modifiedEndLineNumber: number;
modifiedEndColumn: number;
}[]);
old: Range;
new: Range;
charChanges: DiffChunk[];
}
export class DiffHighlight {
constructor(diffView: import("ace-builds/src-noconflict/ext-diff/base_diff_view").BaseDiffView, type: any);
id: number;
diffView: BaseDiffView;
type: any;
update(html: any, markerLayer: any, session: any, config: any): void;
}
import { MinimalGutterDiffDecorator } from "ace-builds/src-noconflict/ext-diff/gutter_decorator";
import { Editor } from "ace-builds-internal/editor";
import { Range } from "ace-builds-internal/range";
class SyncSelectionMarker {
id: number;
type: string;
clazz: string;
update(html: any, markerLayer: any, session: any, config: any): void;
setRange(range: Range): void;
range: Range;
}
namespace Ace {
type OptionsProvider<T> = import("ace-builds").Ace.OptionsProvider<T>;
}
export interface BaseDiffView extends Ace.OptionsProvider<import("ace-builds/src-noconflict/ext-diff").DiffViewOptions> {
}
}
declare module "ace-builds/src-noconflict/ext-elastic_tabstops_lite" {
export class ElasticTabstopsLite {
constructor(editor: Editor);
onAfterExec: () => void;
onExec: () => void;
onChange: (delta: any) => void;
processRows(rows: number[]): void;
}
import { Editor } from "ace-builds-internal/editor";
}
declare module "ace-builds/src-noconflict/ext-error_marker" {
export function showErrorMarker(editor: import("ace-builds-internal/editor").Editor, dir: number): void;
}
declare module "ace-builds/src-noconflict/ext-beautify" {
export const singletonTags: string[];
export const blockTags: string[];
export const formatOptions: {
lineBreaksAfterCommasInCurlyBlock?: boolean;
};
export function beautify(session: import("ace-builds-internal/edit_session").EditSession): void;
export const commands: import("ace-builds").Ace.Command[];
}
declare module "ace-builds/src-noconflict/ext-code_lens" {
export function setLenses(session: EditSession, lenses: import("ace-builds").Ace.CodeLense[]): number;
export function registerCodeLensProvider(editor: import("ace-builds-internal/editor").Editor, codeLensProvider: import("ace-builds").Ace.CodeLenseProvider): void;
export function clear(session: EditSession): void;
export type EditSession = import("ace-builds-internal/edit_session").EditSession;
export type VirtualRenderer = import("ace-builds-internal/virtual_renderer").VirtualRenderer & {
};
export type CodeLenseCommand = import("ace-builds").Ace.CodeLenseCommand;
export type CodeLense = import("ace-builds").Ace.CodeLense;
import { Editor } from "ace-builds-internal/editor";
}
declare module "ace-builds/src-noconflict/ext-emmet" {
export const commands: HashHandler;
export function runEmmetCommand(editor: Editor): ReturnType<typeof setTimeout> | boolean;
export function updateCommands(editor: Editor, enabled?: boolean): void;
export function isSupportedMode(mode: any | string): boolean;
export function isAvailable(editor: Editor, command: string): boolean;
export function load(cb?: Function): boolean;
export function setCore(e: string | any): void;
import { HashHandler } from "ace-builds-internal/keyboard/hash_handler";
import { Editor } from "ace-builds-internal/editor";
/**
* Implementation of {@link IEmmetEditor} interface for Ace
*/
export class AceEmmetEditor {
setupContext(editor: Editor): void;
ace: Editor;
indentation: string;
/**
* Returns character indexes of selected text: object with <code>start</code>
* and <code>end</code> properties. If there's no selection, should return
* object with <code>start</code> and <code>end</code> properties referring
* to current caret position
* @example
* var selection = editor.getSelectionRange();
* alert(selection.start + ', ' + selection.end);
*/
getSelectionRange(): any;
/**
* Creates selection from <code>start</code> to <code>end</code> character
* indexes. If <code>end</code> is ommited, this method should place caret
* and <code>start</code> index
* @example
* editor.createSelection(10, 40);
*
* //move caret to 15th character
* editor.createSelection(15);
*/
createSelection(start: number, end?: number): void;
/**
* Returns current line's start and end indexes as object with <code>start</code>
* and <code>end</code> properties
* @example
* var range = editor.getCurrentLineRange();
* alert(range.start + ', ' + range.end);
*/
getCurrentLineRange(): any;
/**
* Returns current caret position
*/
getCaretPos(): number | null;
/**
* Set new caret position
* @param {Number} index Caret position
*/
setCaretPos(index: number): void;
/**
* Returns content of current line
*/
getCurrentLine(): string;
/**
* Replace editor's content or it's part (from <code>start</code> to
* <code>end</code> index). If <code>value</code> contains
* <code>caret_placeholder</code>, the editor will put caret into
* this position. If you skip <code>start</code> and <code>end</code>
* arguments, the whole target's content will be replaced with
* <code>value</code>.
*
* If you pass <code>start</code> argument only,
* the <code>value</code> will be placed at <code>start</code> string
* index of current content.
*
* If you pass <code>start</code> and <code>end</code> arguments,
* the corresponding substring of current target's content will be
* replaced with <code>value</code>.
* @param {String} value Content you want to paste
* @param {Number} [start] Start index of editor's content
* @param {Number} [end] End index of editor's content
* @param {Boolean} [noIndent] Do not auto indent <code>value</code>
*/
replaceContent(value: string, start?: number, end?: number, noIndent?: boolean): void;
/**
* Returns editor's content
*/
getContent(): string;
/**
* Returns current editor's syntax mode
*/
getSyntax(): string;
/**
* Returns current output profile name (@see emmet#setupProfile)
*/
getProfileName(): string;
/**
* Ask user to enter something
* @param {String} title Dialog title
* @return {String} Entered data
* @since 0.65
*/
prompt(title: string): string;
/**
* Returns current selection
* @since 0.65
*/
getSelection(): string;
/**
* Returns current editor's file path
* @since 0.65
*/
getFilePath(): string;
}
}
declare module "ace-builds/src-noconflict/ext-hardwrap" {
/**
* Wraps lines at specified column limits and optionally merges short adjacent lines.
*
* Processes text within the specified row range, breaking lines that exceed the maximum column
* width at appropriate word boundaries while preserving indentation. When merge is enabled,
* combines short consecutive lines that can fit within the column limit. Automatically adjusts
* the end row when new line breaks are inserted to ensure all affected content is processed.
*
* @param {import("ace-builds-internal/editor").Editor} editor - The editor instance containing the text to wrap
* @param {import("ace-builds").Ace.HardWrapOptions} options - Configuration options for wrapping behavior
*/
export function hardWrap(editor: import("ace-builds-internal/editor").Editor, options: import("ace-builds").Ace.HardWrapOptions): void;
import { Editor } from "ace-builds-internal/editor";
}
declare module "ace-builds/src-noconflict/ext-menu_tools/settings_menu.css" {
const _exports: string;
export = _exports;
}
declare module "ace-builds/src-noconflict/ext-menu_tools/overlay_page" {
export function overlayPage(editor: import("ace-builds-internal/editor").Editor, contentElement: HTMLElement, callback?: () => void): {
close: () => void;
setIgnoreFocusOut: (ignore: boolean) => void;
};
}
declare module "ace-builds/src-noconflict/ext-menu_tools/get_editor_keyboard_shortcuts" {
export function getEditorKeybordShortcuts(editor: import("ace-builds-internal/editor").Editor): any[];
}
declare module "ace-builds/src-noconflict/ext-keybinding_menu" {
export function init(editor: Editor): void;
import { Editor } from "ace-builds-internal/editor";
}
declare module "ace-builds/src-noconflict/ext-linking" { }
declare module "ace-builds/src-noconflict/ext-modelist" {
/**
* Suggests a mode based on the file extension present in the given path
* @param {string} path The path to the file
* @returns {Mode} Returns an object containing information about the
* suggested mode.
*/
export function getModeForPath(path: string): Mode;
/**
* Represents an array to store various syntax modes.
*
*
*/
export var modes: Mode[];
/**
* An object that serves as a mapping of mode names to their corresponding mode data.
* The keys of this object are mode names (as strings), and the values are expected
* to represent data associated with each mode.
*
* This structure can be used for quick lookups of mode information by name.
*
*/
export var modesByName: Record<string, Mode>;
class Mode {
constructor(name: string, caption: string, extensions: string);
name: string;
caption: string;
mode: string;
extensions: string;
extRe: RegExp;
supportsFile(filename: string): RegExpMatchArray | null;
}
}
declare module "ace-builds/src-noconflict/ext-themelist" {
export const themesByName: {
[x: string]: Theme;
};
export const themes: Theme[];
export type Theme = {
/**
* - The display caption of the theme.
*/
caption: string;
/**
* - The path or identifier for the ACE theme.
*/
theme: string;
/**
* - Indicates whether the theme is dark or light.
*/
isDark: boolean;
/**
* - The normalized name used as the key.
*/
name: string;
};
}
declare module "ace-builds/src-noconflict/ext-options" {
/**
* Option panel component for configuring settings or options.
* The panel is designed to integrate with an editor and render various UI controls based on provided configuration.
*/
export class OptionPanel {
constructor(editor: Editor, element?: HTMLElement);
editor: import("ace-builds-internal/editor").Editor;
container: HTMLElement;
groups: any[];
options: {};
add(config: any): void;
render(): void;
renderOptionGroup(group: any): any[];
renderOptionControl(key: string, option: any): any;
renderOption(key: any, option: any): (string | any[] | {
class: string;
})[];
setOption(option: string | number | any, value: string | number | boolean): void;
getOption(option: any): any;
}
export type Editor = import("ace-builds-internal/editor").Editor;
export namespace optionGroups {
let Main: {
Mode: {
path: string;
type: string;
items: {
caption: string;
value: string;
}[];
};
Theme: {
path: string;
type: string;
items: {
Bright: any[];
Dark: any[];
};
};
Keybinding: {
type: string;
path: string;
items: {
caption: string;
value: string;
}[];
};
"Font Size": {
path: string;
type: string;
defaultValue: number;
defaults: {
caption: string;
value: number;
}[];
};
"Soft Wrap": {
type: string;
path: string;
items: {
caption: string;
value: string;
}[];
};
"Cursor Style": {
path: string;
items: {
caption: string;
value: string;
}[];
};
Folding: {
path: string;
items: {
caption: string;
value: string;
}[];
};
"Soft Tabs": ({
path: string;
ariaLabel?: undefined;
type?: undefined;
values?: undefined;
} | {
ariaLabel: string;
path: string;
type: string;
values: number[];
})[];
Overscroll: {
type: string;
path: string;
items: {
caption: string;
value: number;
}[];
};
};
let More: {
"Atomic soft tabs": {
path: string;
};
"Enable Behaviours": {
path: string;
};
"Wrap with quotes": {
path: string;
};
"Enable Auto Indent": {
path: string;
};
"Full Line Selection": {
type: string;
values: string;
path: string;
};
"Highlight Active Line": {
path: string;
};
"Show Invisibles": {
path: string;
};
"Show Indent Guides": {
path: string;
};
"Highlight Indent Guides": {
path: string;
};
"Persistent HScrollbar": {
path: string;
};
"Persistent VScrollbar": {
path: string;
};
"Animate scrolling": {
path: string;
};
"Show Gutter": {
path: string;
};
"Show Line Numbers": {
path: string;
};
"Relative Line Numbers": {
path: string;
};
"Fixed Gutter Width": {
path: string;
};
"Show Print Margin": ({
path: string;
ariaLabel?: undefined;
type?: undefined;
} | {
ariaLabel: string;
type: string;
path: string;
})[];
"Indented Soft Wrap": {
path: string;
};
"Highlight selected word": {
path: string;
};
"Fade Fold Widgets": {
path: string;
};
"Use textarea for IME": {
path: string;
};
"Merge Undo Deltas": {
path: string;
items: {
caption: string;
value: string;
}[];
};
"Elastic Tabstops": {
path: string;
};
"Incremental Search": {
path: string;
};
"Read-only": {
path: string;
};
"Copy without selection": {
path: string;
};
"Live Autocompletion": {
path: string;
};
"Custom scrollbar": {
path: string;
};
"Use SVG gutter icons": {
path: string;
};
"Annotations for folded lines": {
path: string;
};
"Keyboard Accessibility Mode": {
path: string;
};
"Gutter tooltip follows mouse": {
path: string;
defaultValue: boolean;
};
};
}
namespace Ace {
type EventEmitter<T extends {
[K in keyof T]: (...args: any[]) => any;
}> = import("ace-builds").Ace.EventEmitter<T>;
type OptionPanelEvents = import("ace-builds").Ace.OptionPanelEvents;
}
export interface OptionPanel extends Ace.EventEmitter<Ace.OptionPanelEvents> {
}
}
declare module "ace-builds/src-noconflict/ext-prompt" {
export type PromptOptions = {
/**
* Prompt name.
*/
name: string;
/**
* Defines which part of the predefined value should be highlighted.
*/
selection: [
number,
number
];
/**
* Set to true if prompt has description below input box.
*/
hasDescription: boolean;
/**
* Description below input box.
*/
prompt: string;
/**
* Placeholder for value.
*/
placeholder: string;
/**
* Set to true to keep the prompt open when focus moves to another part of the editor.
*/
ignoreFocusOut: boolean;
/**
* Function for defining list of options for value.
*/
getCompletions: Function;
/**
* Function for defining current value prefix.
*/
getPrefix: Function;
/**
* Function called when Enter is pressed.
*/
onAccept: Function;
/**
* Function called when input is added to prompt input box.
*/
onInput: Function;
/**
* Function called when Esc|Shift-Esc is pressed.
*/
onCancel: Function;
/**
* Function for defining history list.
*/
history: Function;
maxHistoryCount: number;
addToHistory: Function;
};
export type Editor = import("ace-builds-internal/editor").Editor;
/**
* @property {String} name Prompt name.
* @property {String} $type Use prompt of specific type (gotoLine|commands|modes or default if empty).
* @property {[number, number]} selection Defines which part of the predefined value should be highlighted.
* @property {Boolean} hasDescription Set to true if prompt has description below input box.
* @property {String} prompt Description below input box.
* @property {String} placeholder Placeholder for value.
* @property {Object} $rules Specific rules for input like password or regexp.
* @property {Boolean} ignoreFocusOut Set to true to keep the prompt open when focus moves to another part of the editor.
* @property {Function} getCompletions Function for defining list of options for value.
* @property {Function} getPrefix Function for defining current value prefix.
* @property {Function} onAccept Function called when Enter is pressed.
* @property {Function} onInput Function called when input is added to prompt input box.
* @property {Function} onCancel Function called when Esc|Shift-Esc is pressed.
* @property {Function} history Function for defining history list.
* @property {number} maxHistoryCount
* @property {Function} addToHistory
*/
/**
* Prompt plugin is used for getting input from user.
*
* @param {Editor} editor Ouside editor related to this prompt. Will be blurred when prompt is open.
* @param {String | Partial<PromptOptions>} message Predefined value of prompt input box.
* @param {Partial<PromptOptions>} options Cusomizable options for this prompt.
* @param {Function} [callback] Function called after done.
* */
export function prompt(editor: Editor, message: string | Partial<PromptOptions>, options: Partial<PromptOptions>, callback?: Function): any;
export namespace prompt {
/**
* Displays a "Go to Line" prompt for navigating to specific line and column positions with selection support.
*
* @param {Editor} editor - The editor instance to navigate within
*/
function gotoLine(editor: Editor, callback?: Function): void;
/**
* Displays a searchable command palette for executing editor commands with keyboard shortcuts and history.
*
* @param {Editor} editor - The editor instance to execute commands on
*/
function commands(editor: Editor, callback?: Function): void;
/**
* Shows an interactive prompt containing all available syntax highlighting modes
* that can be applied to the editor session. Users can type to filter through the modes list
* and select one to change the editor's syntax highlighting mode. The prompt includes real-time
* filtering based on mode names and captions.
*
* @param {Editor} editor - The editor instance to change the language mode for
*/
function modes(editor: Editor, callback?: Function): void;
}
}
declare module "ace-builds/src-noconflict/ext-rtl" {
}
declare module "ace-builds/src-noconflict/ext-settings_menu" {
export function init(): void;
}
declare module "ace-builds/src-noconflict/ext-simple_tokenizer" {
/**
* Parses provided content according to provided highlighting rules and return tokens.
* Tokens either have the className set according to Ace themes or have no className if they are just pure text tokens.
* Result is a list of list of tokens, where each line from the provided content is a separate list of tokens.
*
* @param {string} content to tokenize
* @param {import("ace-builds").Ace.HighlightRules} highlightRules defining the language grammar
* @returns {import("ace-builds").Ace.TokenizeResult} tokenization result containing a list of token for each of the lines from content
*/
export function tokenize(content: string, highlightRules: import("ace-builds").Ace.HighlightRules): import("ace-builds").Ace.TokenizeResult;
}
declare module "ace-builds/src-noconflict/ext-spellcheck" {
export function contextMenuHandler(e: any): void;
}
declare module "ace-builds/src-noconflict/ext-split" {
const _exports: typeof import("ace-builds-internal/split");
export = _exports;
}
declare module "ace-builds/src-noconflict/ext-static-css" {
const _exports: string;
export = _exports;
}
declare module "ace-builds/src-noconflict/ext-static_highlight" {
/**
* Applies syntax highlighting to an HTML element containing code.
*
* Automatically detects the language from CSS class names (e.g., 'lang-javascript') or uses
* the specified mode. Transforms the element's content into syntax-highlighted HTML with
* CSS styling and preserves any existing child elements by repositioning them after highlighting.
*
* @param {HTMLElement} el - The HTML element containing code to highlight
* @param {import("ace-builds").Ace.StaticHighlightOptions} opts - Highlighting options
* @param {function} [callback] - Optional callback executed after highlighting is complete
* @returns {boolean} Returns false if no valid mode is found, otherwise true
*/
function highlight(el: HTMLElement, opts: import("ace-builds").Ace.StaticHighlightOptions, callback?: Function): boolean;
export namespace highlight {
export { render, renderSync, highlight, SyntaxMode, Theme };
}
/**
* Transforms a given input code snippet into HTML using the given mode
*
* @param {string} input Code snippet
* @param {string | SyntaxMode} mode String specifying the mode to load such as
* `ace/mode/javascript` or, a mode loaded from `/ace/mode`
*