monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/editorExtensions.js

@@ -0,0 +1,489 @@
+import { localize } from '../../nls.js';
+import { URI } from '../../base/common/uri.js';
+import { ICodeEditorService } from './services/codeEditorService.js';
+import { Position } from '../common/core/position.js';
+import { IModelService } from '../common/services/model.js';
+import { ITextModelService } from '../common/services/resolverService.js';
+import { MenuId, MenuRegistry, Action2 } from '../../platform/actions/common/actions.js';
+import { CommandsRegistry } from '../../platform/commands/common/commands.js';
+import { IContextKeyService, ContextKeyExpr } from '../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
+import { KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
+import { Registry } from '../../platform/registry/common/platform.js';
+import { ITelemetryService } from '../../platform/telemetry/common/telemetry.js';
+import { assertType } from '../../base/common/types.js';
+import { ILogService } from '../../platform/log/common/log.js';
+import { getActiveElement } from '../../base/browser/dom.js';
+import { TriggerInlineEditCommandsRegistry } from './triggerInlineEditCommandsRegistry.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Command {
+    constructor(opts) {
+        this.id = opts.id;
+        this.precondition = opts.precondition;
+        this._kbOpts = opts.kbOpts;
+        this._menuOpts = opts.menuOpts;
+        this.metadata = opts.metadata;
+        this.canTriggerInlineEdits = opts.canTriggerInlineEdits;
+    }
+    register() {
+        if (Array.isArray(this._menuOpts)) {
+            this._menuOpts.forEach(this._registerMenuItem, this);
+        }
+        else if (this._menuOpts) {
+            this._registerMenuItem(this._menuOpts);
+        }
+        if (this._kbOpts) {
+            const kbOptsArr = Array.isArray(this._kbOpts) ? this._kbOpts : [this._kbOpts];
+            for (const kbOpts of kbOptsArr) {
+                let kbWhen = kbOpts.kbExpr;
+                if (this.precondition) {
+                    if (kbWhen) {
+                        kbWhen = ContextKeyExpr.and(kbWhen, this.precondition);
+                    }
+                    else {
+                        kbWhen = this.precondition;
+                    }
+                }
+                const desc = {
+                    id: this.id,
+                    weight: kbOpts.weight,
+                    args: kbOpts.args,
+                    when: kbWhen,
+                    primary: kbOpts.primary,
+                    secondary: kbOpts.secondary,
+                    win: kbOpts.win,
+                    linux: kbOpts.linux,
+                    mac: kbOpts.mac,
+                };
+                KeybindingsRegistry.registerKeybindingRule(desc);
+            }
+        }
+        CommandsRegistry.registerCommand({
+            id: this.id,
+            handler: (accessor, args) => this.runCommand(accessor, args),
+            metadata: this.metadata
+        });
+        if (this.canTriggerInlineEdits) {
+            TriggerInlineEditCommandsRegistry.registerCommand(this.id);
+        }
+    }
+    _registerMenuItem(item) {
+        MenuRegistry.appendMenuItem(item.menuId, {
+            group: item.group,
+            command: {
+                id: this.id,
+                title: item.title,
+                icon: item.icon,
+                precondition: this.precondition
+            },
+            when: item.when,
+            order: item.order
+        });
+    }
+}
+class MultiCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this._implementations = [];
+    }
+    /**
+     * A higher priority gets to be looked at first
+     */
+    addImplementation(priority, name, implementation, when) {
+        this._implementations.push({ priority, name, implementation, when });
+        this._implementations.sort((a, b) => b.priority - a.priority);
+        return {
+            dispose: () => {
+                for (let i = 0; i < this._implementations.length; i++) {
+                    if (this._implementations[i].implementation === implementation) {
+                        this._implementations.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        };
+    }
+    runCommand(accessor, args) {
+        const logService = accessor.get(ILogService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        logService.trace(`Executing Command '${this.id}' which has ${this._implementations.length} bound.`);
+        for (const impl of this._implementations) {
+            if (impl.when) {
+                const context = contextKeyService.getContext(getActiveElement());
+                const value = impl.when.evaluate(context);
+                if (!value) {
+                    continue;
+                }
+            }
+            const result = impl.implementation(accessor, args);
+            if (result) {
+                logService.trace(`Command '${this.id}' was handled by '${impl.name}'.`);
+                if (typeof result === 'boolean') {
+                    return;
+                }
+                return result;
+            }
+        }
+        logService.trace(`The Command '${this.id}' was not handled by any implementation.`);
+    }
+}
+//#endregion
+/**
+ * A command that delegates to another command's implementation.
+ *
+ * This lets different commands be registered but share the same implementation
+ */
+class ProxyCommand extends Command {
+    constructor(command, opts) {
+        super(opts);
+        this.command = command;
+    }
+    runCommand(accessor, args) {
+        return this.command.runCommand(accessor, args);
+    }
+}
+class EditorCommand extends Command {
+    /**
+     * Create a command class that is bound to a certain editor contribution.
+     */
+    static bindToContribution(controllerGetter) {
+        return class EditorControllerCommandImpl extends EditorCommand {
+            constructor(opts) {
+                super(opts);
+                this._callback = opts.handler;
+            }
+            runEditorCommand(accessor, editor, args) {
+                const controller = controllerGetter(editor);
+                if (controller) {
+                    this._callback(controller, args);
+                }
+            }
+        };
+    }
+    static runEditorCommand(accessor, args, precondition, runner) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        // Find the editor with text focus or active
+        const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+        if (!editor) {
+            // well, at least we tried...
+            return;
+        }
+        return editor.invokeWithinContext((editorAccessor) => {
+            const kbService = editorAccessor.get(IContextKeyService);
+            if (!kbService.contextMatchesRules(precondition ?? undefined)) {
+                // precondition does not hold
+                return;
+            }
+            return runner(editorAccessor, editor, args);
+        });
+    }
+    runCommand(accessor, args) {
+        return EditorCommand.runEditorCommand(accessor, args, this.precondition, (accessor, editor, args) => this.runEditorCommand(accessor, editor, args));
+    }
+}
+class EditorAction extends EditorCommand {
+    static convertOptions(opts) {
+        let menuOpts;
+        if (Array.isArray(opts.menuOpts)) {
+            menuOpts = opts.menuOpts;
+        }
+        else if (opts.menuOpts) {
+            menuOpts = [opts.menuOpts];
+        }
+        else {
+            menuOpts = [];
+        }
+        function withDefaults(item) {
+            if (!item.menuId) {
+                item.menuId = MenuId.EditorContext;
+            }
+            if (!item.title) {
+                item.title = typeof opts.label === 'string' ? opts.label : opts.label.value;
+            }
+            item.when = ContextKeyExpr.and(opts.precondition, item.when);
+            return item;
+        }
+        if (Array.isArray(opts.contextMenuOpts)) {
+            menuOpts.push(...opts.contextMenuOpts.map(withDefaults));
+        }
+        else if (opts.contextMenuOpts) {
+            menuOpts.push(withDefaults(opts.contextMenuOpts));
+        }
+        opts.menuOpts = menuOpts;
+        return opts;
+    }
+    constructor(opts) {
+        super(EditorAction.convertOptions(opts));
+        if (typeof opts.label === 'string') {
+            this.label = opts.label;
+            this.alias = opts.alias ?? opts.label;
+        }
+        else {
+            this.label = opts.label.value;
+            this.alias = opts.alias ?? opts.label.original;
+        }
+    }
+    runEditorCommand(accessor, editor, args) {
+        this.reportTelemetry(accessor, editor);
+        return this.run(accessor, editor, args || {});
+    }
+    reportTelemetry(accessor, editor) {
+        accessor.get(ITelemetryService).publicLog2('editorActionInvoked', { name: this.label, id: this.id });
+    }
+}
+class MultiEditorAction extends EditorAction {
+    constructor() {
+        super(...arguments);
+        this._implementations = [];
+    }
+    /**
+     * A higher priority gets to be looked at first
+     */
+    addImplementation(priority, implementation) {
+        this._implementations.push([priority, implementation]);
+        this._implementations.sort((a, b) => b[0] - a[0]);
+        return {
+            dispose: () => {
+                for (let i = 0; i < this._implementations.length; i++) {
+                    if (this._implementations[i][1] === implementation) {
+                        this._implementations.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        };
+    }
+    run(accessor, editor, args) {
+        for (const impl of this._implementations) {
+            const result = impl[1](accessor, editor, args);
+            if (result) {
+                if (typeof result === 'boolean') {
+                    return;
+                }
+                return result;
+            }
+        }
+    }
+}
+//#endregion EditorAction
+//#region EditorAction2
+class EditorAction2 extends Action2 {
+    run(accessor, ...args) {
+        // Find the editor with text focus or active
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+        if (!editor) {
+            // well, at least we tried...
+            return;
+        }
+        // precondition does hold
+        return editor.invokeWithinContext((editorAccessor) => {
+            const kbService = editorAccessor.get(IContextKeyService);
+            const logService = editorAccessor.get(ILogService);
+            const enabled = kbService.contextMatchesRules(this.desc.precondition ?? undefined);
+            if (!enabled) {
+                logService.debug(`[EditorAction2] NOT running command because its precondition is FALSE`, this.desc.id, this.desc.precondition?.serialize());
+                return;
+            }
+            return this.runEditorCommand(editorAccessor, editor, ...args);
+        });
+    }
+}
+//#endregion
+// --- Registration of commands and actions
+function registerModelAndPositionCommand(id, handler) {
+    CommandsRegistry.registerCommand(id, function (accessor, ...args) {
+        const instaService = accessor.get(IInstantiationService);
+        const [resource, position] = args;
+        assertType(URI.isUri(resource));
+        assertType(Position.isIPosition(position));
+        const model = accessor.get(IModelService).getModel(resource);
+        if (model) {
+            const editorPosition = Position.lift(position);
+            return instaService.invokeFunction(handler, model, editorPosition, ...args.slice(2));
+        }
+        return accessor.get(ITextModelService).createModelReference(resource).then(reference => {
+            return new Promise((resolve, reject) => {
+                try {
+                    const result = instaService.invokeFunction(handler, reference.object.textEditorModel, Position.lift(position), args.slice(2));
+                    resolve(result);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }).finally(() => {
+                reference.dispose();
+            });
+        });
+    });
+}
+function registerEditorCommand(editorCommand) {
+    EditorContributionRegistry.INSTANCE.registerEditorCommand(editorCommand);
+    return editorCommand;
+}
+function registerEditorAction(ctor) {
+    const action = new ctor();
+    EditorContributionRegistry.INSTANCE.registerEditorAction(action);
+    return action;
+}
+function registerMultiEditorAction(action) {
+    EditorContributionRegistry.INSTANCE.registerEditorAction(action);
+    return action;
+}
+function registerInstantiatedEditorAction(editorAction) {
+    EditorContributionRegistry.INSTANCE.registerEditorAction(editorAction);
+}
+/**
+ * Registers an editor contribution. Editor contributions have a lifecycle which is bound
+ * to a specific code editor instance.
+ */
+function registerEditorContribution(id, ctor, instantiation) {
+    EditorContributionRegistry.INSTANCE.registerEditorContribution(id, ctor, instantiation);
+}
+var EditorExtensionsRegistry;
+(function (EditorExtensionsRegistry) {
+    function getEditorCommand(commandId) {
+        return EditorContributionRegistry.INSTANCE.getEditorCommand(commandId);
+    }
+    EditorExtensionsRegistry.getEditorCommand = getEditorCommand;
+    function getEditorActions() {
+        return EditorContributionRegistry.INSTANCE.getEditorActions();
+    }
+    EditorExtensionsRegistry.getEditorActions = getEditorActions;
+    function getEditorContributions() {
+        return EditorContributionRegistry.INSTANCE.getEditorContributions();
+    }
+    EditorExtensionsRegistry.getEditorContributions = getEditorContributions;
+    function getSomeEditorContributions(ids) {
+        return EditorContributionRegistry.INSTANCE.getEditorContributions().filter(c => ids.indexOf(c.id) >= 0);
+    }
+    EditorExtensionsRegistry.getSomeEditorContributions = getSomeEditorContributions;
+    function getDiffEditorContributions() {
+        return EditorContributionRegistry.INSTANCE.getDiffEditorContributions();
+    }
+    EditorExtensionsRegistry.getDiffEditorContributions = getDiffEditorContributions;
+})(EditorExtensionsRegistry || (EditorExtensionsRegistry = {}));
+// Editor extension points
+const Extensions = {
+    EditorCommonContributions: 'editor.contributions'
+};
+class EditorContributionRegistry {
+    static { this.INSTANCE = new EditorContributionRegistry(); }
+    constructor() {
+        this.editorContributions = [];
+        this.diffEditorContributions = [];
+        this.editorActions = [];
+        this.editorCommands = Object.create(null);
+    }
+    registerEditorContribution(id, ctor, instantiation) {
+        this.editorContributions.push({ id, ctor: ctor, instantiation });
+    }
+    getEditorContributions() {
+        return this.editorContributions.slice(0);
+    }
+    getDiffEditorContributions() {
+        return this.diffEditorContributions.slice(0);
+    }
+    registerEditorAction(action) {
+        action.register();
+        this.editorActions.push(action);
+    }
+    getEditorActions() {
+        return this.editorActions;
+    }
+    registerEditorCommand(editorCommand) {
+        editorCommand.register();
+        this.editorCommands[editorCommand.id] = editorCommand;
+    }
+    getEditorCommand(commandId) {
+        return (this.editorCommands[commandId] || null);
+    }
+}
+Registry.add(Extensions.EditorCommonContributions, EditorContributionRegistry.INSTANCE);
+function registerCommand(command) {
+    command.register();
+    return command;
+}
+const UndoCommand = registerCommand(new MultiCommand({
+    id: 'undo',
+    precondition: undefined,
+    kbOpts: {
+        weight: 0 /* KeybindingWeight.EditorCore */,
+        primary: 2048 /* KeyMod.CtrlCmd */ | 56 /* KeyCode.KeyZ */
+    },
+    menuOpts: [{
+            menuId: MenuId.MenubarEditMenu,
+            group: '1_do',
+            title: localize(69, "&&Undo"),
+            order: 1
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: localize(70, "Undo"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '1_do',
+            title: localize(71, "Undo"),
+            order: 1
+        }]
+}));
+registerCommand(new ProxyCommand(UndoCommand, { id: 'default:undo', precondition: undefined }));
+const RedoCommand = registerCommand(new MultiCommand({
+    id: 'redo',
+    precondition: undefined,
+    kbOpts: {
+        weight: 0 /* KeybindingWeight.EditorCore */,
+        primary: 2048 /* KeyMod.CtrlCmd */ | 55 /* KeyCode.KeyY */,
+        secondary: [2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 56 /* KeyCode.KeyZ */],
+        mac: { primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 56 /* KeyCode.KeyZ */ }
+    },
+    menuOpts: [{
+            menuId: MenuId.MenubarEditMenu,
+            group: '1_do',
+            title: localize(72, "&&Redo"),
+            order: 2
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: localize(73, "Redo"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '1_do',
+            title: localize(74, "Redo"),
+            order: 2
+        }]
+}));
+registerCommand(new ProxyCommand(RedoCommand, { id: 'default:redo', precondition: undefined }));
+const SelectAllCommand = registerCommand(new MultiCommand({
+    id: 'editor.action.selectAll',
+    precondition: undefined,
+    kbOpts: {
+        weight: 0 /* KeybindingWeight.EditorCore */,
+        kbExpr: null,
+        primary: 2048 /* KeyMod.CtrlCmd */ | 31 /* KeyCode.KeyA */
+    },
+    menuOpts: [{
+            menuId: MenuId.MenubarSelectionMenu,
+            group: '1_basic',
+            title: localize(75, "&&Select All"),
+            order: 1
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: localize(76, "Select All"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '9_select',
+            title: localize(77, "Select All"),
+            order: 1
+        }]
+}));
+
+export { Command, EditorAction, EditorAction2, EditorCommand, EditorExtensionsRegistry, MultiCommand, MultiEditorAction, ProxyCommand, RedoCommand, SelectAllCommand, UndoCommand, registerEditorAction, registerEditorCommand, registerEditorContribution, registerInstantiatedEditorAction, registerModelAndPositionCommand, registerMultiEditorAction };

package/dist/workers/editorFeatures.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const editorFeatures = [];
+/**
+ * Registers an editor feature. Editor features will be instantiated only once, as soon as
+ * the first code editor is instantiated.
+ */
+function registerEditorFeature(ctor) {
+    editorFeatures.push(ctor);
+}
+function getEditorFeatures() {
+    return editorFeatures.slice(0);
+}
+
+export { getEditorFeatures, registerEditorFeature };

package/dist/workers/editorGutter.js

@@ -0,0 +1,117 @@
+import { h, reset } from '../../../../../base/browser/dom.js';
+import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { LineRange } from '../../../../common/core/ranges/lineRange.js';
+import { OffsetRange } from '../../../../common/core/ranges/offsetRange.js';
+import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
+import { observableSignal } from '../../../../../base/common/observableInternal/observables/observableSignal.js';
+import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class EditorGutter extends Disposable {
+    constructor(_editor, _domNode, itemProvider) {
+        super();
+        this._editor = _editor;
+        this._domNode = _domNode;
+        this.itemProvider = itemProvider;
+        this.scrollTop = observableFromEvent(this, this._editor.onDidScrollChange, (e) => /** @description editor.onDidScrollChange */ this._editor.getScrollTop());
+        this.isScrollTopZero = this.scrollTop.map((scrollTop) => /** @description isScrollTopZero */ scrollTop === 0);
+        this.modelAttached = observableFromEvent(this, this._editor.onDidChangeModel, (e) => /** @description editor.onDidChangeModel */ this._editor.hasModel());
+        this.editorOnDidChangeViewZones = observableSignalFromEvent('onDidChangeViewZones', this._editor.onDidChangeViewZones);
+        this.editorOnDidContentSizeChange = observableSignalFromEvent('onDidContentSizeChange', this._editor.onDidContentSizeChange);
+        this.domNodeSizeChanged = observableSignal('domNodeSizeChanged');
+        this.views = new Map();
+        this._domNode.className = 'gutter monaco-editor';
+        const scrollDecoration = this._domNode.appendChild(h('div.scroll-decoration', { role: 'presentation', ariaHidden: 'true', style: { width: '100%' } })
+            .root);
+        const o = new ResizeObserver(() => {
+            transaction(tx => {
+                /** @description ResizeObserver: size changed */
+                this.domNodeSizeChanged.trigger(tx);
+            });
+        });
+        o.observe(this._domNode);
+        this._register(toDisposable(() => o.disconnect()));
+        this._register(autorun(reader => {
+            /** @description update scroll decoration */
+            scrollDecoration.className = this.isScrollTopZero.read(reader) ? '' : 'scroll-decoration';
+        }));
+        this._register(autorun(reader => /** @description EditorGutter.Render */ this.render(reader)));
+    }
+    dispose() {
+        super.dispose();
+        reset(this._domNode);
+    }
+    render(reader) {
+        if (!this.modelAttached.read(reader)) {
+            return;
+        }
+        this.domNodeSizeChanged.read(reader);
+        this.editorOnDidChangeViewZones.read(reader);
+        this.editorOnDidContentSizeChange.read(reader);
+        const scrollTop = this.scrollTop.read(reader);
+        const visibleRanges = this._editor.getVisibleRanges();
+        const unusedIds = new Set(this.views.keys());
+        const viewRange = OffsetRange.ofStartAndLength(0, this._domNode.clientHeight);
+        if (!viewRange.isEmpty) {
+            for (const visibleRange of visibleRanges) {
+                const visibleRange2 = new LineRange(visibleRange.startLineNumber, visibleRange.endLineNumber + 1);
+                const gutterItems = this.itemProvider.getIntersectingGutterItems(visibleRange2, reader);
+                transaction(tx => {
+                    /** EditorGutter.render */
+                    for (const gutterItem of gutterItems) {
+                        if (!gutterItem.range.intersect(visibleRange2)) {
+                            continue;
+                        }
+                        unusedIds.delete(gutterItem.id);
+                        let view = this.views.get(gutterItem.id);
+                        if (!view) {
+                            const viewDomNode = document.createElement('div');
+                            this._domNode.appendChild(viewDomNode);
+                            const gutterItemObs = observableValue('item', gutterItem);
+                            const itemView = this.itemProvider.createView(gutterItemObs, viewDomNode);
+                            view = new ManagedGutterItemView(gutterItemObs, itemView, viewDomNode);
+                            this.views.set(gutterItem.id, view);
+                        }
+                        else {
+                            view.item.set(gutterItem, tx);
+                        }
+                        const top = gutterItem.range.startLineNumber <= this._editor.getModel().getLineCount()
+                            ? this._editor.getTopForLineNumber(gutterItem.range.startLineNumber, true) - scrollTop
+                            : gutterItem.range.startLineNumber > 1
+                                ? this._editor.getBottomForLineNumber(gutterItem.range.startLineNumber - 1, false) - scrollTop
+                                : 0;
+                        const bottom = gutterItem.range.endLineNumberExclusive === 1 ?
+                            Math.max(top, this._editor.getTopForLineNumber(gutterItem.range.startLineNumber, false) - scrollTop)
+                            : Math.max(top, this._editor.getBottomForLineNumber(gutterItem.range.endLineNumberExclusive - 1, true) - scrollTop);
+                        const height = bottom - top;
+                        view.domNode.style.top = `${top}px`;
+                        view.domNode.style.height = `${height}px`;
+                        view.gutterItemView.layout(OffsetRange.ofStartAndLength(top, height), viewRange);
+                    }
+                });
+            }
+        }
+        for (const id of unusedIds) {
+            const view = this.views.get(id);
+            view.gutterItemView.dispose();
+            view.domNode.remove();
+            this.views.delete(id);
+        }
+    }
+}
+class ManagedGutterItemView {
+    constructor(item, gutterItemView, domNode) {
+        this.item = item;
+        this.gutterItemView = gutterItemView;
+        this.domNode = domNode;
+    }
+}
+
+export { EditorGutter };