monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/sash.js

@@ -0,0 +1,451 @@
+import { getWindow, append, $, addDisposableListener, EventHelper, isHTMLElement } from '../../dom.js';
+import { createStyleSheet } from '../../domStylesheets.js';
+import { DomEmitter } from '../../event.js';
+import { EventType, Gesture } from '../../touch.js';
+import { Delayer } from '../../../common/async.js';
+import { memoize } from '../../../common/decorators.js';
+import { Emitter } from '../../../common/event.js';
+import { DisposableStore, Disposable, toDisposable } from '../../../common/lifecycle.js';
+import { isMacintosh } from '../../../common/platform.js';
+import './sash.css';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * Allow the sashes to be visible at runtime.
+ * @remark Use for development purposes only.
+ */
+const DEBUG = false;
+var OrthogonalEdge;
+(function (OrthogonalEdge) {
+    OrthogonalEdge["North"] = "north";
+    OrthogonalEdge["South"] = "south";
+    OrthogonalEdge["East"] = "east";
+    OrthogonalEdge["West"] = "west";
+})(OrthogonalEdge || (OrthogonalEdge = {}));
+let globalSize = 4;
+const onDidChangeGlobalSize = new Emitter();
+let globalHoverDelay = 300;
+const onDidChangeHoverDelay = new Emitter();
+class MouseEventFactory {
+    constructor(el) {
+        this.el = el;
+        this.disposables = new DisposableStore();
+    }
+    get onPointerMove() {
+        return this.disposables.add(new DomEmitter(getWindow(this.el), 'mousemove')).event;
+    }
+    get onPointerUp() {
+        return this.disposables.add(new DomEmitter(getWindow(this.el), 'mouseup')).event;
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+__decorate([
+    memoize
+], MouseEventFactory.prototype, "onPointerMove", null);
+__decorate([
+    memoize
+], MouseEventFactory.prototype, "onPointerUp", null);
+class GestureEventFactory {
+    get onPointerMove() {
+        return this.disposables.add(new DomEmitter(this.el, EventType.Change)).event;
+    }
+    get onPointerUp() {
+        return this.disposables.add(new DomEmitter(this.el, EventType.End)).event;
+    }
+    constructor(el) {
+        this.el = el;
+        this.disposables = new DisposableStore();
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+__decorate([
+    memoize
+], GestureEventFactory.prototype, "onPointerMove", null);
+__decorate([
+    memoize
+], GestureEventFactory.prototype, "onPointerUp", null);
+class OrthogonalPointerEventFactory {
+    get onPointerMove() {
+        return this.factory.onPointerMove;
+    }
+    get onPointerUp() {
+        return this.factory.onPointerUp;
+    }
+    constructor(factory) {
+        this.factory = factory;
+    }
+    dispose() {
+        // noop
+    }
+}
+__decorate([
+    memoize
+], OrthogonalPointerEventFactory.prototype, "onPointerMove", null);
+__decorate([
+    memoize
+], OrthogonalPointerEventFactory.prototype, "onPointerUp", null);
+const PointerEventsDisabledCssClass = 'pointer-events-disabled';
+/**
+ * The {@link Sash} is the UI component which allows the user to resize other
+ * components. It's usually an invisible horizontal or vertical line which, when
+ * hovered, becomes highlighted and can be dragged along the perpendicular dimension
+ * to its direction.
+ *
+ * Features:
+ * - Touch event handling
+ * - Corner sash support
+ * - Hover with different mouse cursor support
+ * - Configurable hover size
+ * - Linked sash support, for 2x2 corner sashes
+ */
+class Sash extends Disposable {
+    get state() { return this._state; }
+    get orthogonalStartSash() { return this._orthogonalStartSash; }
+    get orthogonalEndSash() { return this._orthogonalEndSash; }
+    /**
+     * The state of a sash defines whether it can be interacted with by the user
+     * as well as what mouse cursor to use, when hovered.
+     */
+    set state(state) {
+        if (this._state === state) {
+            return;
+        }
+        this.el.classList.toggle('disabled', state === 0 /* SashState.Disabled */);
+        this.el.classList.toggle('minimum', state === 1 /* SashState.AtMinimum */);
+        this.el.classList.toggle('maximum', state === 2 /* SashState.AtMaximum */);
+        this._state = state;
+        this.onDidEnablementChange.fire(state);
+    }
+    /**
+     * An event which fires whenever the user starts dragging this sash.
+     */
+    get onDidStart() { return this._onDidStart.event; }
+    /**
+     * An event which fires whenever the user moves the mouse while
+     * dragging this sash.
+     */
+    get onDidChange() { return this._onDidChange.event; }
+    /**
+     * An event which fires whenever the user double clicks this sash.
+     */
+    get onDidReset() { return this._onDidReset.event; }
+    /**
+     * An event which fires whenever the user stops dragging this sash.
+     */
+    get onDidEnd() { return this._onDidEnd.event; }
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the start of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The start of a horizontal sash is its left-most position.
+     * The start of a vertical sash is its top-most position.
+     */
+    set orthogonalStartSash(sash) {
+        if (this._orthogonalStartSash === sash) {
+            return;
+        }
+        this.orthogonalStartDragHandleDisposables.clear();
+        this.orthogonalStartSashDisposables.clear();
+        if (sash) {
+            const onChange = (state) => {
+                this.orthogonalStartDragHandleDisposables.clear();
+                if (state !== 0 /* SashState.Disabled */) {
+                    this._orthogonalStartDragHandle = append(this.el, $('.orthogonal-drag-handle.start'));
+                    this.orthogonalStartDragHandleDisposables.add(toDisposable(() => this._orthogonalStartDragHandle.remove()));
+                    this.orthogonalStartDragHandleDisposables.add(addDisposableListener(this._orthogonalStartDragHandle, 'mouseenter', () => Sash.onMouseEnter(sash)));
+                    this.orthogonalStartDragHandleDisposables.add(addDisposableListener(this._orthogonalStartDragHandle, 'mouseleave', () => Sash.onMouseLeave(sash)));
+                }
+            };
+            this.orthogonalStartSashDisposables.add(sash.onDidEnablementChange.event(onChange, this));
+            onChange(sash.state);
+        }
+        this._orthogonalStartSash = sash;
+    }
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the end of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The end of a horizontal sash is its right-most position.
+     * The end of a vertical sash is its bottom-most position.
+     */
+    set orthogonalEndSash(sash) {
+        if (this._orthogonalEndSash === sash) {
+            return;
+        }
+        this.orthogonalEndDragHandleDisposables.clear();
+        this.orthogonalEndSashDisposables.clear();
+        if (sash) {
+            const onChange = (state) => {
+                this.orthogonalEndDragHandleDisposables.clear();
+                if (state !== 0 /* SashState.Disabled */) {
+                    this._orthogonalEndDragHandle = append(this.el, $('.orthogonal-drag-handle.end'));
+                    this.orthogonalEndDragHandleDisposables.add(toDisposable(() => this._orthogonalEndDragHandle.remove()));
+                    this.orthogonalEndDragHandleDisposables.add(addDisposableListener(this._orthogonalEndDragHandle, 'mouseenter', () => Sash.onMouseEnter(sash)));
+                    this.orthogonalEndDragHandleDisposables.add(addDisposableListener(this._orthogonalEndDragHandle, 'mouseleave', () => Sash.onMouseLeave(sash)));
+                }
+            };
+            this.orthogonalEndSashDisposables.add(sash.onDidEnablementChange.event(onChange, this));
+            onChange(sash.state);
+        }
+        this._orthogonalEndSash = sash;
+    }
+    constructor(container, layoutProvider, options) {
+        super();
+        this.hoverDelay = globalHoverDelay;
+        this.hoverDelayer = this._register(new Delayer(this.hoverDelay));
+        this._state = 3 /* SashState.Enabled */;
+        this.onDidEnablementChange = this._register(new Emitter());
+        this._onDidStart = this._register(new Emitter());
+        this._onDidChange = this._register(new Emitter());
+        this._onDidReset = this._register(new Emitter());
+        this._onDidEnd = this._register(new Emitter());
+        this.orthogonalStartSashDisposables = this._register(new DisposableStore());
+        this.orthogonalStartDragHandleDisposables = this._register(new DisposableStore());
+        this.orthogonalEndSashDisposables = this._register(new DisposableStore());
+        this.orthogonalEndDragHandleDisposables = this._register(new DisposableStore());
+        /**
+         * A linked sash will be forwarded the same user interactions and events
+         * so it moves exactly the same way as this sash.
+         *
+         * Useful in 2x2 grids. Not meant for widespread usage.
+         */
+        this.linkedSash = undefined;
+        this.el = append(container, $('.monaco-sash'));
+        if (options.orthogonalEdge) {
+            this.el.classList.add(`orthogonal-edge-${options.orthogonalEdge}`);
+        }
+        if (isMacintosh) {
+            this.el.classList.add('mac');
+        }
+        this._register(addDisposableListener(this.el, 'mousedown', e => this.onPointerStart(e, new MouseEventFactory(container))));
+        this._register(addDisposableListener(this.el, 'dblclick', e => this.onPointerDoublePress(e)));
+        this._register(addDisposableListener(this.el, 'mouseenter', () => Sash.onMouseEnter(this)));
+        this._register(addDisposableListener(this.el, 'mouseleave', () => Sash.onMouseLeave(this)));
+        this._register(Gesture.addTarget(this.el));
+        this._register(addDisposableListener(this.el, EventType.Start, e => this.onPointerStart(e, new GestureEventFactory(this.el))));
+        let doubleTapTimeout = undefined;
+        this._register(addDisposableListener(this.el, EventType.Tap, event => {
+            if (doubleTapTimeout) {
+                clearTimeout(doubleTapTimeout);
+                doubleTapTimeout = undefined;
+                this.onPointerDoublePress(event);
+                return;
+            }
+            clearTimeout(doubleTapTimeout);
+            doubleTapTimeout = setTimeout(() => doubleTapTimeout = undefined, 250);
+        }));
+        if (typeof options.size === 'number') {
+            this.size = options.size;
+            if (options.orientation === 0 /* Orientation.VERTICAL */) {
+                this.el.style.width = `${this.size}px`;
+            }
+            else {
+                this.el.style.height = `${this.size}px`;
+            }
+        }
+        else {
+            this.size = globalSize;
+            this._register(onDidChangeGlobalSize.event(size => {
+                this.size = size;
+                this.layout();
+            }));
+        }
+        this._register(onDidChangeHoverDelay.event(delay => this.hoverDelay = delay));
+        this.layoutProvider = layoutProvider;
+        this.orthogonalStartSash = options.orthogonalStartSash;
+        this.orthogonalEndSash = options.orthogonalEndSash;
+        this.orientation = options.orientation || 0 /* Orientation.VERTICAL */;
+        if (this.orientation === 1 /* Orientation.HORIZONTAL */) {
+            this.el.classList.add('horizontal');
+            this.el.classList.remove('vertical');
+        }
+        else {
+            this.el.classList.remove('horizontal');
+            this.el.classList.add('vertical');
+        }
+        this.el.classList.toggle('debug', DEBUG);
+        this.layout();
+    }
+    onPointerStart(event, pointerEventFactory) {
+        EventHelper.stop(event);
+        let isMultisashResize = false;
+        // eslint-disable-next-line local/code-no-any-casts
+        if (!event.__orthogonalSashEvent) {
+            const orthogonalSash = this.getOrthogonalSash(event);
+            if (orthogonalSash) {
+                isMultisashResize = true;
+                // eslint-disable-next-line local/code-no-any-casts
+                event.__orthogonalSashEvent = true;
+                orthogonalSash.onPointerStart(event, new OrthogonalPointerEventFactory(pointerEventFactory));
+            }
+        }
+        // eslint-disable-next-line local/code-no-any-casts
+        if (this.linkedSash && !event.__linkedSashEvent) {
+            // eslint-disable-next-line local/code-no-any-casts
+            event.__linkedSashEvent = true;
+            this.linkedSash.onPointerStart(event, new OrthogonalPointerEventFactory(pointerEventFactory));
+        }
+        if (!this.state) {
+            return;
+        }
+        // eslint-disable-next-line no-restricted-syntax
+        const iframes = this.el.ownerDocument.getElementsByTagName('iframe');
+        for (const iframe of iframes) {
+            iframe.classList.add(PointerEventsDisabledCssClass); // disable mouse events on iframes as long as we drag the sash
+        }
+        const startX = event.pageX;
+        const startY = event.pageY;
+        const altKey = event.altKey;
+        const startEvent = { startX, currentX: startX, startY, currentY: startY, altKey };
+        this.el.classList.add('active');
+        this._onDidStart.fire(startEvent);
+        // fix https://github.com/microsoft/vscode/issues/21675
+        const style = createStyleSheet(this.el);
+        const updateStyle = () => {
+            let cursor = '';
+            if (isMultisashResize) {
+                cursor = 'all-scroll';
+            }
+            else if (this.orientation === 1 /* Orientation.HORIZONTAL */) {
+                if (this.state === 1 /* SashState.AtMinimum */) {
+                    cursor = 's-resize';
+                }
+                else if (this.state === 2 /* SashState.AtMaximum */) {
+                    cursor = 'n-resize';
+                }
+                else {
+                    cursor = isMacintosh ? 'row-resize' : 'ns-resize';
+                }
+            }
+            else {
+                if (this.state === 1 /* SashState.AtMinimum */) {
+                    cursor = 'e-resize';
+                }
+                else if (this.state === 2 /* SashState.AtMaximum */) {
+                    cursor = 'w-resize';
+                }
+                else {
+                    cursor = isMacintosh ? 'col-resize' : 'ew-resize';
+                }
+            }
+            style.textContent = `* { cursor: ${cursor} !important; }`;
+        };
+        const disposables = new DisposableStore();
+        updateStyle();
+        if (!isMultisashResize) {
+            this.onDidEnablementChange.event(updateStyle, null, disposables);
+        }
+        const onPointerMove = (e) => {
+            EventHelper.stop(e, false);
+            const event = { startX, currentX: e.pageX, startY, currentY: e.pageY, altKey };
+            this._onDidChange.fire(event);
+        };
+        const onPointerUp = (e) => {
+            EventHelper.stop(e, false);
+            style.remove();
+            this.el.classList.remove('active');
+            this._onDidEnd.fire();
+            disposables.dispose();
+            for (const iframe of iframes) {
+                iframe.classList.remove(PointerEventsDisabledCssClass);
+            }
+        };
+        pointerEventFactory.onPointerMove(onPointerMove, null, disposables);
+        pointerEventFactory.onPointerUp(onPointerUp, null, disposables);
+        disposables.add(pointerEventFactory);
+    }
+    onPointerDoublePress(e) {
+        const orthogonalSash = this.getOrthogonalSash(e);
+        if (orthogonalSash) {
+            orthogonalSash._onDidReset.fire();
+        }
+        if (this.linkedSash) {
+            this.linkedSash._onDidReset.fire();
+        }
+        this._onDidReset.fire();
+    }
+    static onMouseEnter(sash, fromLinkedSash = false) {
+        if (sash.el.classList.contains('active')) {
+            sash.hoverDelayer.cancel();
+            sash.el.classList.add('hover');
+        }
+        else {
+            sash.hoverDelayer.trigger(() => sash.el.classList.add('hover'), sash.hoverDelay).then(undefined, () => { });
+        }
+        if (!fromLinkedSash && sash.linkedSash) {
+            Sash.onMouseEnter(sash.linkedSash, true);
+        }
+    }
+    static onMouseLeave(sash, fromLinkedSash = false) {
+        sash.hoverDelayer.cancel();
+        sash.el.classList.remove('hover');
+        if (!fromLinkedSash && sash.linkedSash) {
+            Sash.onMouseLeave(sash.linkedSash, true);
+        }
+    }
+    /**
+     * Forcefully stop any user interactions with this sash.
+     * Useful when hiding a parent component, while the user is still
+     * interacting with the sash.
+     */
+    clearSashHoverState() {
+        Sash.onMouseLeave(this);
+    }
+    /**
+     * Layout the sash. The sash will size and position itself
+     * based on its provided {@link ISashLayoutProvider layout provider}.
+     */
+    layout() {
+        if (this.orientation === 0 /* Orientation.VERTICAL */) {
+            const verticalProvider = this.layoutProvider;
+            this.el.style.left = verticalProvider.getVerticalSashLeft(this) - (this.size / 2) + 'px';
+            if (verticalProvider.getVerticalSashTop) {
+                this.el.style.top = verticalProvider.getVerticalSashTop(this) + 'px';
+            }
+            if (verticalProvider.getVerticalSashHeight) {
+                this.el.style.height = verticalProvider.getVerticalSashHeight(this) + 'px';
+            }
+        }
+        else {
+            const horizontalProvider = this.layoutProvider;
+            this.el.style.top = horizontalProvider.getHorizontalSashTop(this) - (this.size / 2) + 'px';
+            if (horizontalProvider.getHorizontalSashLeft) {
+                this.el.style.left = horizontalProvider.getHorizontalSashLeft(this) + 'px';
+            }
+            if (horizontalProvider.getHorizontalSashWidth) {
+                this.el.style.width = horizontalProvider.getHorizontalSashWidth(this) + 'px';
+            }
+        }
+    }
+    getOrthogonalSash(e) {
+        const target = e.initialTarget ?? e.target;
+        if (!target || !(isHTMLElement(target))) {
+            return undefined;
+        }
+        if (target.classList.contains('orthogonal-drag-handle')) {
+            return target.classList.contains('start') ? this.orthogonalStartSash : this.orthogonalEndSash;
+        }
+        return undefined;
+    }
+    dispose() {
+        super.dispose();
+        this.el.remove();
+    }
+}
+
+export { OrthogonalEdge, Sash };

package/dist/workers/sb.contribution.js

@@ -0,0 +1,8 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "sb",
+  extensions: [".sb"],
+  aliases: ["Small Basic", "sb"],
+  loader: () => import('./sb.js')
+});

package/dist/workers/sb.js

@@ -0,0 +1,114 @@
+const conf = {
+  comments: {
+    lineComment: "'"
+  },
+  brackets: [
+    ["(", ")"],
+    ["[", "]"],
+    ["If", "EndIf"],
+    ["While", "EndWhile"],
+    ["For", "EndFor"],
+    ["Sub", "EndSub"]
+  ],
+  autoClosingPairs: [
+    { open: '"', close: '"', notIn: ["string", "comment"] },
+    { open: "(", close: ")", notIn: ["string", "comment"] },
+    { open: "[", close: "]", notIn: ["string", "comment"] }
+  ]
+};
+const language = {
+  defaultToken: "",
+  tokenPostfix: ".sb",
+  ignoreCase: true,
+  brackets: [
+    { token: "delimiter.array", open: "[", close: "]" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" },
+    // Special bracket statement pairs
+    { token: "keyword.tag-if", open: "If", close: "EndIf" },
+    { token: "keyword.tag-while", open: "While", close: "EndWhile" },
+    { token: "keyword.tag-for", open: "For", close: "EndFor" },
+    { token: "keyword.tag-sub", open: "Sub", close: "EndSub" }
+  ],
+  keywords: [
+    "Else",
+    "ElseIf",
+    "EndFor",
+    "EndIf",
+    "EndSub",
+    "EndWhile",
+    "For",
+    "Goto",
+    "If",
+    "Step",
+    "Sub",
+    "Then",
+    "To",
+    "While"
+  ],
+  tagwords: ["If", "Sub", "While", "For"],
+  operators: [">", "<", "<>", "<=", ">=", "And", "Or", "+", "-", "*", "/", "="],
+  // we include these common regular expressions
+  identifier: /[a-zA-Z_][\w]*/,
+  symbols: /[=><:+\-*\/%\.,]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // whitespace
+      { include: "@whitespace" },
+      // classes
+      [/(@identifier)(?=[.])/, "type"],
+      // identifiers, tagwords, and keywords
+      [
+        /@identifier/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@operators": "operator",
+            "@default": "variable.name"
+          }
+        }
+      ],
+      // methods, properties, and events
+      [
+        /([.])(@identifier)/,
+        {
+          cases: {
+            $2: ["delimiter", "type.member"],
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/\d*\.\d+/, "number.float"],
+      [/\d+/, "number"],
+      // delimiters and operators
+      [/[()\[\]]/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "operator",
+            "@default": "delimiter"
+          }
+        }
+      ],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, "string", "@string"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/(\').*$/, "comment"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"C?/, "string", "@pop"]
+    ]
+  }
+};
+
+export { conf, language };

package/dist/workers/scala.contribution.js

@@ -0,0 +1,9 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "scala",
+  extensions: [".scala", ".sc", ".sbt"],
+  aliases: ["Scala", "scala", "SBT", "Sbt", "sbt", "Dotty", "dotty"],
+  mimetypes: ["text/x-scala-source", "text/x-scala", "text/x-sbt", "text/x-dotty"],
+  loader: () => import('./scala.js')
+});