monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/pla.contribution.js

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

package/dist/workers/pla.js

@@ -0,0 +1,136 @@
+const conf = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["[", "]"],
+    ["<", ">"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "[", close: "]" },
+    { open: "<", close: ">" },
+    { open: "(", close: ")" }
+  ],
+  surroundingPairs: [
+    { open: "[", close: "]" },
+    { open: "<", close: ">" },
+    { open: "(", close: ")" }
+  ]
+};
+const language = {
+  defaultToken: "",
+  tokenPostfix: ".pla",
+  brackets: [
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "<", close: ">", token: "delimiter.angle" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  keywords: [
+    ".i",
+    ".o",
+    ".mv",
+    ".ilb",
+    ".ob",
+    ".label",
+    ".type",
+    ".phase",
+    ".pair",
+    ".symbolic",
+    ".symbolic-output",
+    ".kiss",
+    ".p",
+    ".e",
+    ".end"
+  ],
+  // regular expressions
+  comment: /#.*$/,
+  identifier: /[a-zA-Z]+[a-zA-Z0-9_\-]*/,
+  plaContent: /[01\-~\|]+/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // comments and whitespace
+      { include: "@whitespace" },
+      [/@comment/, "comment"],
+      // keyword
+      [
+        /\.([a-zA-Z_\-]+)/,
+        {
+          cases: {
+            "@eos": { token: "keyword.$1" },
+            "@keywords": {
+              cases: {
+                ".type": { token: "keyword.$1", next: "@type" },
+                "@default": { token: "keyword.$1", next: "@keywordArg" }
+              }
+            },
+            "@default": { token: "keyword.$1" }
+          }
+        }
+      ],
+      // identifiers
+      [/@identifier/, "identifier"],
+      // PLA row
+      [/@plaContent/, "string"]
+    ],
+    whitespace: [[/[ \t\r\n]+/, ""]],
+    type: [{ include: "@whitespace" }, [/\w+/, { token: "type", next: "@pop" }]],
+    keywordArg: [
+      // whitespace
+      [
+        /[ \t\r\n]+/,
+        {
+          cases: {
+            "@eos": { token: "", next: "@pop" },
+            "@default": ""
+          }
+        }
+      ],
+      // comments
+      [/@comment/, "comment", "@pop"],
+      // brackets
+      [
+        /[<>()\[\]]/,
+        {
+          cases: {
+            "@eos": { token: "@brackets", next: "@pop" },
+            "@default": "@brackets"
+          }
+        }
+      ],
+      // numbers
+      [
+        /\-?\d+/,
+        {
+          cases: {
+            "@eos": { token: "number", next: "@pop" },
+            "@default": "number"
+          }
+        }
+      ],
+      // identifiers
+      [
+        /@identifier/,
+        {
+          cases: {
+            "@eos": { token: "identifier", next: "@pop" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // delimiter
+      [
+        /[;=]/,
+        {
+          cases: {
+            "@eos": { token: "delimiter", next: "@pop" },
+            "@default": "delimiter"
+          }
+        }
+      ]
+    ]
+  }
+};
+
+export { conf, language };

package/dist/workers/placeholderText.contribution.js

@@ -0,0 +1,14 @@
+import './placeholderText.css';
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { ghostTextForeground } from '../../../common/core/editorColorRegistry.js';
+import { localize } from '../../../../nls.js';
+import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
+import { PlaceholderTextContribution } from './placeholderTextContribution.js';
+import { wrapInReloadableClass1 } from '../../../../platform/observable/common/wrapInReloadableClass.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerEditorContribution(PlaceholderTextContribution.ID, wrapInReloadableClass1(() => PlaceholderTextContribution), 0 /* EditorContributionInstantiation.Eager */);
+registerColor('editor.placeholder.foreground', ghostTextForeground, localize(1334, 'Foreground color of the placeholder text in the editor.'));

package/dist/workers/placeholderTextContribution.js

@@ -0,0 +1,77 @@
+import { h } from '../../../../base/browser/dom.js';
+import { structuralEquals } from '../../../../base/common/equals.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
+import { derivedOpts, derived } from '../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
+import { derivedObservableWithCache } from '../../../../base/common/observableInternal/utils/utils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Use the editor option to set the placeholder text.
+*/
+class PlaceholderTextContribution extends Disposable {
+    static { this.ID = 'editor.contrib.placeholderText'; }
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._editorObs = observableCodeEditor(this._editor);
+        this._placeholderText = this._editorObs.getOption(100 /* EditorOption.placeholder */);
+        this._state = derivedOpts({ owner: this, equalsFn: structuralEquals }, reader => {
+            const p = this._placeholderText.read(reader);
+            if (!p) {
+                return undefined;
+            }
+            if (!this._editorObs.valueIsEmpty.read(reader)) {
+                return undefined;
+            }
+            return { placeholder: p };
+        });
+        this._shouldViewBeAlive = isOrWasTrue(this, reader => this._state.read(reader)?.placeholder !== undefined);
+        this._view = derived((reader) => {
+            if (!this._shouldViewBeAlive.read(reader)) {
+                return;
+            }
+            const element = h('div.editorPlaceholder');
+            reader.store.add(autorun(reader => {
+                const data = this._state.read(reader);
+                const shouldBeVisibile = data?.placeholder !== undefined;
+                element.root.style.display = shouldBeVisibile ? 'block' : 'none';
+                element.root.innerText = data?.placeholder ?? '';
+            }));
+            reader.store.add(autorun(reader => {
+                const info = this._editorObs.layoutInfo.read(reader);
+                element.root.style.left = `${info.contentLeft}px`;
+                element.root.style.width = (info.contentWidth - info.verticalScrollbarWidth) + 'px';
+                element.root.style.top = `${this._editor.getTopForLineNumber(0)}px`;
+            }));
+            reader.store.add(autorun(reader => {
+                element.root.style.fontFamily = this._editorObs.getOption(58 /* EditorOption.fontFamily */).read(reader);
+                element.root.style.fontSize = this._editorObs.getOption(61 /* EditorOption.fontSize */).read(reader) + 'px';
+                element.root.style.lineHeight = this._editorObs.getOption(75 /* EditorOption.lineHeight */).read(reader) + 'px';
+            }));
+            reader.store.add(this._editorObs.createOverlayWidget({
+                allowEditorOverflow: false,
+                minContentWidthInPx: constObservable(0),
+                position: constObservable(null),
+                domNode: element.root,
+            }));
+        });
+        this._view.recomputeInitiallyAndOnChange(this._store);
+    }
+}
+function isOrWasTrue(owner, fn) {
+    return derivedObservableWithCache(owner, (reader, lastValue) => {
+        if (lastValue === true) {
+            return true;
+        }
+        return fn(reader);
+    });
+}
+
+export { PlaceholderTextContribution };

package/dist/workers/platform.js

@@ -0,0 +1,32 @@
+import { ok } from '../../../base/common/assert.js';
+import { isFunction, isString, isObject } from '../../../base/common/types.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class RegistryImpl {
+    constructor() {
+        this.data = new Map();
+    }
+    add(id, data) {
+        ok(isString(id));
+        ok(isObject(data));
+        ok(!this.data.has(id), 'There is already an extension with this id');
+        this.data.set(id, data);
+    }
+    as(id) {
+        return this.data.get(id) || null;
+    }
+    dispose() {
+        this.data.forEach((value) => {
+            if (isFunction(value.dispose)) {
+                value.dispose();
+            }
+        });
+        this.data.clear();
+    }
+}
+const Registry = new RegistryImpl();
+
+export { Registry };

package/dist/workers/platformObservableUtils.js

@@ -0,0 +1,31 @@
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import '../../../base/common/observableInternal/index.js';
+import { DebugLocation } from '../../../base/common/observableInternal/debugLocation.js';
+import { observableFromEventOpts } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derivedOpts } from '../../../base/common/observableInternal/observables/derived.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/** Creates an observable update when a configuration key updates. */
+function observableConfigValue(key, defaultValue, configurationService, debugLocation = DebugLocation.ofCaller()) {
+    return observableFromEventOpts({ debugName: () => `Configuration Key "${key}"`, }, (handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key) ?? defaultValue, debugLocation);
+}
+/** Update the configuration key with a value derived from observables. */
+function bindContextKey(key, service, computeValue, debugLocation = DebugLocation.ofCaller()) {
+    const boundKey = key.bindTo(service);
+    const store = new DisposableStore();
+    derivedOpts({ debugName: () => `Set Context Key "${key.key}"` }, reader => {
+        const value = computeValue(reader);
+        boundKey.set(value);
+        return value;
+    }, debugLocation).recomputeInitiallyAndOnChange(store);
+    return store;
+}
+
+export { bindContextKey, observableConfigValue };

package/dist/workers/point.js

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Point {
+    static equals(a, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    add(other) {
+        return new Point(this.x + other.x, this.y + other.y);
+    }
+    deltaX(delta) {
+        return new Point(this.x + delta, this.y);
+    }
+    deltaY(delta) {
+        return new Point(this.x, this.y + delta);
+    }
+    toString() {
+        return `(${this.x},${this.y})`;
+    }
+    subtract(other) {
+        return new Point(this.x - other.x, this.y - other.y);
+    }
+    scale(factor) {
+        return new Point(this.x * factor, this.y * factor);
+    }
+    mapComponents(map) {
+        return new Point(map(this.x), map(this.y));
+    }
+    isZero() {
+        return this.x === 0 && this.y === 0;
+    }
+    withThreshold(threshold) {
+        return this.mapComponents(axisVal => {
+            if (axisVal > threshold) {
+                return axisVal - threshold;
+            }
+            else if (axisVal < -threshold) {
+                return axisVal + threshold;
+            }
+            return 0;
+        });
+    }
+}
+
+export { Point };

package/dist/workers/pointerHandler.js

@@ -0,0 +1,132 @@
+import { BrowserFeatures } from '../../../base/browser/canIUse.js';
+import { addDisposableListener } from '../../../base/browser/dom.js';
+import { Gesture, EventType } from '../../../base/browser/touch.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { isIOS, isAndroid, isMobile } from '../../../base/common/platform.js';
+import { MouseHandler } from './mouseHandler.js';
+import { EditorMouseEvent, EditorPointerEventFactory } from '../editorDom.js';
+import { TextAreaSyntethicEvents } from './editContext/textArea/textAreaEditContextInput.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Currently only tested on iOS 13/ iPadOS.
+ */
+class PointerEventHandler extends MouseHandler {
+    constructor(context, viewController, viewHelper) {
+        super(context, viewController, viewHelper);
+        this._register(Gesture.addTarget(this.viewHelper.linesContentDomNode));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Tap, (e) => this.onTap(e)));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Change, (e) => this.onChange(e)));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e) => this._onContextMenu(new EditorMouseEvent(e, false, this.viewHelper.viewDomNode), false)));
+        this._lastPointerType = 'mouse';
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, 'pointerdown', (e) => {
+            const pointerType = e.pointerType;
+            if (pointerType === 'mouse') {
+                this._lastPointerType = 'mouse';
+                return;
+            }
+            else if (pointerType === 'touch') {
+                this._lastPointerType = 'touch';
+            }
+            else {
+                this._lastPointerType = 'pen';
+            }
+        }));
+        // PonterEvents
+        const pointerEvents = new EditorPointerEventFactory(this.viewHelper.viewDomNode);
+        this._register(pointerEvents.onPointerMove(this.viewHelper.viewDomNode, (e) => this._onMouseMove(e)));
+        this._register(pointerEvents.onPointerUp(this.viewHelper.viewDomNode, (e) => this._onMouseUp(e)));
+        this._register(pointerEvents.onPointerLeave(this.viewHelper.viewDomNode, (e) => this._onMouseLeave(e)));
+        this._register(pointerEvents.onPointerDown(this.viewHelper.viewDomNode, (e, pointerId) => this._onMouseDown(e, pointerId)));
+    }
+    onTap(event) {
+        if (!event.initialTarget || !this.viewHelper.linesContentDomNode.contains(event.initialTarget)) {
+            return;
+        }
+        event.preventDefault();
+        this.viewHelper.focusTextArea();
+        this._dispatchGesture(event, /*inSelectionMode*/ false);
+    }
+    onChange(event) {
+        if (this._lastPointerType === 'touch') {
+            this._context.viewModel.viewLayout.deltaScrollNow(-event.translationX, -event.translationY);
+        }
+        if (this._lastPointerType === 'pen') {
+            this._dispatchGesture(event, /*inSelectionMode*/ true);
+        }
+    }
+    _dispatchGesture(event, inSelectionMode) {
+        const target = this._createMouseTarget(new EditorMouseEvent(event, false, this.viewHelper.viewDomNode), false);
+        if (target.position) {
+            this.viewController.dispatchMouse({
+                position: target.position,
+                mouseColumn: target.position.column,
+                startedOnLineNumbers: false,
+                revealType: 1 /* NavigationCommandRevealType.Minimal */,
+                mouseDownCount: event.tapCount,
+                inSelectionMode,
+                altKey: false,
+                ctrlKey: false,
+                metaKey: false,
+                shiftKey: false,
+                leftButton: false,
+                middleButton: false,
+                onInjectedText: target.type === 6 /* MouseTargetType.CONTENT_TEXT */ && target.detail.injectedText !== null
+            });
+        }
+    }
+    _onMouseDown(e, pointerId) {
+        if (e.browserEvent.pointerType === 'touch') {
+            return;
+        }
+        super._onMouseDown(e, pointerId);
+    }
+}
+class TouchHandler extends MouseHandler {
+    constructor(context, viewController, viewHelper) {
+        super(context, viewController, viewHelper);
+        this._register(Gesture.addTarget(this.viewHelper.linesContentDomNode));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Tap, (e) => this.onTap(e)));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Change, (e) => this.onChange(e)));
+        this._register(addDisposableListener(this.viewHelper.linesContentDomNode, EventType.Contextmenu, (e) => this._onContextMenu(new EditorMouseEvent(e, false, this.viewHelper.viewDomNode), false)));
+    }
+    onTap(event) {
+        event.preventDefault();
+        this.viewHelper.focusTextArea();
+        const target = this._createMouseTarget(new EditorMouseEvent(event, false, this.viewHelper.viewDomNode), false);
+        if (target.position) {
+            // Send the tap event also to the <textarea> (for input purposes)
+            const event = document.createEvent('CustomEvent');
+            event.initEvent(TextAreaSyntethicEvents.Tap, false, true);
+            this.viewHelper.dispatchTextAreaEvent(event);
+            this.viewController.moveTo(target.position, 1 /* NavigationCommandRevealType.Minimal */);
+        }
+    }
+    onChange(e) {
+        this._context.viewModel.viewLayout.deltaScrollNow(-e.translationX, -e.translationY);
+    }
+}
+class PointerHandler extends Disposable {
+    constructor(context, viewController, viewHelper) {
+        super();
+        const isPhone = isIOS || (isAndroid && isMobile);
+        if (isPhone && BrowserFeatures.pointerEvents) {
+            this.handler = this._register(new PointerEventHandler(context, viewController, viewHelper));
+        }
+        else if (mainWindow.TouchEvent) {
+            this.handler = this._register(new TouchHandler(context, viewController, viewHelper));
+        }
+        else {
+            this.handler = this._register(new MouseHandler(context, viewController, viewHelper));
+        }
+    }
+    getTargetAtClientPoint(clientX, clientY) {
+        return this.handler.getTargetAtClientPoint(clientX, clientY);
+    }
+}
+
+export { PointerEventHandler, PointerHandler };

package/dist/workers/position.js

@@ -0,0 +1,142 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A position in the editor.
+ */
+class Position {
+    constructor(lineNumber, column) {
+        this.lineNumber = lineNumber;
+        this.column = column;
+    }
+    /**
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
+     */
+    with(newLineNumber = this.lineNumber, newColumn = this.column) {
+        if (newLineNumber === this.lineNumber && newColumn === this.column) {
+            return this;
+        }
+        else {
+            return new Position(newLineNumber, newColumn);
+        }
+    }
+    /**
+     * Derive a new position from this position.
+     *
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
+     */
+    delta(deltaLineNumber = 0, deltaColumn = 0) {
+        return this.with(Math.max(1, this.lineNumber + deltaLineNumber), Math.max(1, this.column + deltaColumn));
+    }
+    /**
+     * Test if this position equals other position
+     */
+    equals(other) {
+        return Position.equals(this, other);
+    }
+    /**
+     * Test if position `a` equals position `b`
+     */
+    static equals(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        return (!!a &&
+            !!b &&
+            a.lineNumber === b.lineNumber &&
+            a.column === b.column);
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
+     */
+    isBefore(other) {
+        return Position.isBefore(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
+     */
+    static isBefore(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column < b.column;
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
+     */
+    isBeforeOrEqual(other) {
+        return Position.isBeforeOrEqual(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
+     */
+    static isBeforeOrEqual(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column <= b.column;
+    }
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a, b) {
+        const aLineNumber = a.lineNumber | 0;
+        const bLineNumber = b.lineNumber | 0;
+        if (aLineNumber === bLineNumber) {
+            const aColumn = a.column | 0;
+            const bColumn = b.column | 0;
+            return aColumn - bColumn;
+        }
+        return aLineNumber - bLineNumber;
+    }
+    /**
+     * Clone this position.
+     */
+    clone() {
+        return new Position(this.lineNumber, this.column);
+    }
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString() {
+        return '(' + this.lineNumber + ',' + this.column + ')';
+    }
+    // ---
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos) {
+        return new Position(pos.lineNumber, pos.column);
+    }
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj) {
+        return (!!obj
+            && (typeof obj.lineNumber === 'number')
+            && (typeof obj.column === 'number'));
+    }
+    toJSON() {
+        return {
+            lineNumber: this.lineNumber,
+            column: this.column
+        };
+    }
+}
+
+export { Position };

package/dist/workers/positionToOffset.js

@@ -0,0 +1,17 @@
+import { StringReplacement, StringEdit } from '../edits/stringEdit.js';
+import { TextEdit, TextReplacement } from '../edits/textEdit.js';
+import { _setPositionOffsetTransformerDependencies } from './positionToOffsetImpl.js';
+export { PositionOffsetTransformer, PositionOffsetTransformerBase } from './positionToOffsetImpl.js';
+import { TextLength } from './textLength.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+_setPositionOffsetTransformerDependencies({
+    StringEdit: StringEdit,
+    StringReplacement: StringReplacement,
+    TextReplacement: TextReplacement,
+    TextEdit: TextEdit,
+    TextLength: TextLength,
+});