monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/overviewZoneManager.js

@@ -0,0 +1,176 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ColorZone {
+    constructor(from, to, colorId) {
+        this._colorZoneBrand = undefined;
+        this.from = from | 0;
+        this.to = to | 0;
+        this.colorId = colorId | 0;
+    }
+    static compare(a, b) {
+        if (a.colorId === b.colorId) {
+            if (a.from === b.from) {
+                return a.to - b.to;
+            }
+            return a.from - b.from;
+        }
+        return a.colorId - b.colorId;
+    }
+}
+/**
+ * A zone in the overview ruler
+ */
+class OverviewRulerZone {
+    constructor(startLineNumber, endLineNumber, heightInLines, color) {
+        this._overviewRulerZoneBrand = undefined;
+        this.startLineNumber = startLineNumber;
+        this.endLineNumber = endLineNumber;
+        this.heightInLines = heightInLines;
+        this.color = color;
+        this._colorZone = null;
+    }
+    static compare(a, b) {
+        if (a.color === b.color) {
+            if (a.startLineNumber === b.startLineNumber) {
+                if (a.heightInLines === b.heightInLines) {
+                    return a.endLineNumber - b.endLineNumber;
+                }
+                return a.heightInLines - b.heightInLines;
+            }
+            return a.startLineNumber - b.startLineNumber;
+        }
+        return a.color < b.color ? -1 : 1;
+    }
+    setColorZone(colorZone) {
+        this._colorZone = colorZone;
+    }
+    getColorZones() {
+        return this._colorZone;
+    }
+}
+class OverviewZoneManager {
+    constructor(getVerticalOffsetForLine) {
+        this._getVerticalOffsetForLine = getVerticalOffsetForLine;
+        this._zones = [];
+        this._colorZonesInvalid = false;
+        this._lineHeight = 0;
+        this._domWidth = 0;
+        this._domHeight = 0;
+        this._outerHeight = 0;
+        this._pixelRatio = 1;
+        this._lastAssignedId = 0;
+        this._color2Id = Object.create(null);
+        this._id2Color = [];
+    }
+    getId2Color() {
+        return this._id2Color;
+    }
+    setZones(newZones) {
+        this._zones = newZones;
+        this._zones.sort(OverviewRulerZone.compare);
+    }
+    setLineHeight(lineHeight) {
+        if (this._lineHeight === lineHeight) {
+            return false;
+        }
+        this._lineHeight = lineHeight;
+        this._colorZonesInvalid = true;
+        return true;
+    }
+    setPixelRatio(pixelRatio) {
+        this._pixelRatio = pixelRatio;
+        this._colorZonesInvalid = true;
+    }
+    getDOMWidth() {
+        return this._domWidth;
+    }
+    getCanvasWidth() {
+        return this._domWidth * this._pixelRatio;
+    }
+    setDOMWidth(width) {
+        if (this._domWidth === width) {
+            return false;
+        }
+        this._domWidth = width;
+        this._colorZonesInvalid = true;
+        return true;
+    }
+    getDOMHeight() {
+        return this._domHeight;
+    }
+    getCanvasHeight() {
+        return this._domHeight * this._pixelRatio;
+    }
+    setDOMHeight(height) {
+        if (this._domHeight === height) {
+            return false;
+        }
+        this._domHeight = height;
+        this._colorZonesInvalid = true;
+        return true;
+    }
+    getOuterHeight() {
+        return this._outerHeight;
+    }
+    setOuterHeight(outerHeight) {
+        if (this._outerHeight === outerHeight) {
+            return false;
+        }
+        this._outerHeight = outerHeight;
+        this._colorZonesInvalid = true;
+        return true;
+    }
+    resolveColorZones() {
+        const colorZonesInvalid = this._colorZonesInvalid;
+        const lineHeight = Math.floor(this._lineHeight);
+        const totalHeight = Math.floor(this.getCanvasHeight());
+        const outerHeight = Math.floor(this._outerHeight);
+        const heightRatio = totalHeight / outerHeight;
+        const halfMinimumHeight = Math.floor(4 /* Constants.MINIMUM_HEIGHT */ * this._pixelRatio / 2);
+        const allColorZones = [];
+        for (let i = 0, len = this._zones.length; i < len; i++) {
+            const zone = this._zones[i];
+            if (!colorZonesInvalid) {
+                const colorZone = zone.getColorZones();
+                if (colorZone) {
+                    allColorZones.push(colorZone);
+                    continue;
+                }
+            }
+            const offset1 = this._getVerticalOffsetForLine(zone.startLineNumber);
+            const offset2 = (zone.heightInLines === 0
+                ? this._getVerticalOffsetForLine(zone.endLineNumber) + lineHeight
+                : offset1 + zone.heightInLines * lineHeight);
+            const y1 = Math.floor(heightRatio * offset1);
+            const y2 = Math.floor(heightRatio * offset2);
+            let ycenter = Math.floor((y1 + y2) / 2);
+            let halfHeight = (y2 - ycenter);
+            if (halfHeight < halfMinimumHeight) {
+                halfHeight = halfMinimumHeight;
+            }
+            if (ycenter - halfHeight < 0) {
+                ycenter = halfHeight;
+            }
+            if (ycenter + halfHeight > totalHeight) {
+                ycenter = totalHeight - halfHeight;
+            }
+            const color = zone.color;
+            let colorId = this._color2Id[color];
+            if (!colorId) {
+                colorId = (++this._lastAssignedId);
+                this._color2Id[color] = colorId;
+                this._id2Color[colorId] = color;
+            }
+            const colorZone = new ColorZone(ycenter - halfHeight, ycenter + halfHeight, colorId);
+            zone.setColorZone(colorZone);
+            allColorZones.push(colorZone);
+        }
+        this._colorZonesInvalid = false;
+        allColorZones.sort(ColorZone.compare);
+        return allColorZones;
+    }
+}
+
+export { ColorZone, OverviewRulerZone, OverviewZoneManager };

package/dist/workers/editor/common/parser.js

@@ -0,0 +1,121 @@
+import { ListAstNode, TextAstNode, PairAstNode, InvalidBracketAstNode } from './ast.js';
+import { BeforeEditPositionMapper } from './beforeEditPositionMapper.js';
+import { SmallImmutableSet } from './smallImmutableSet.js';
+import { lengthIsZero, lengthLessThan } from './length.js';
+import { concat23Trees, concat23TreesOfSameHeight } from './concat23Trees.js';
+import { NodeReader } from './nodeReader.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Non incrementally built ASTs are immutable.
+*/
+function parseDocument(tokenizer, edits, oldNode, createImmutableLists) {
+    const parser = new Parser(tokenizer, edits, oldNode, createImmutableLists);
+    return parser.parseDocument();
+}
+/**
+ * Non incrementally built ASTs are immutable.
+*/
+class Parser {
+    constructor(tokenizer, edits, oldNode, createImmutableLists) {
+        this.tokenizer = tokenizer;
+        this.createImmutableLists = createImmutableLists;
+        this._itemsConstructed = 0;
+        this._itemsFromCache = 0;
+        if (oldNode && createImmutableLists) {
+            throw new Error('Not supported');
+        }
+        this.oldNodeReader = oldNode ? new NodeReader(oldNode) : undefined;
+        this.positionMapper = new BeforeEditPositionMapper(edits);
+    }
+    parseDocument() {
+        this._itemsConstructed = 0;
+        this._itemsFromCache = 0;
+        let result = this.parseList(SmallImmutableSet.getEmpty(), 0);
+        if (!result) {
+            result = ListAstNode.getEmpty();
+        }
+        return result;
+    }
+    parseList(openedBracketIds, level) {
+        const items = [];
+        while (true) {
+            let child = this.tryReadChildFromCache(openedBracketIds);
+            if (!child) {
+                const token = this.tokenizer.peek();
+                if (!token ||
+                    (token.kind === 2 /* TokenKind.ClosingBracket */ &&
+                        token.bracketIds.intersects(openedBracketIds))) {
+                    break;
+                }
+                child = this.parseChild(openedBracketIds, level + 1);
+            }
+            if (child.kind === 4 /* AstNodeKind.List */ && child.childrenLength === 0) {
+                continue;
+            }
+            items.push(child);
+        }
+        // When there is no oldNodeReader, all items are created from scratch and must have the same height.
+        const result = this.oldNodeReader ? concat23Trees(items) : concat23TreesOfSameHeight(items, this.createImmutableLists);
+        return result;
+    }
+    tryReadChildFromCache(openedBracketIds) {
+        if (this.oldNodeReader) {
+            const maxCacheableLength = this.positionMapper.getDistanceToNextChange(this.tokenizer.offset);
+            if (maxCacheableLength === null || !lengthIsZero(maxCacheableLength)) {
+                const cachedNode = this.oldNodeReader.readLongestNodeAt(this.positionMapper.getOffsetBeforeChange(this.tokenizer.offset), curNode => {
+                    // The edit could extend the ending token, thus we cannot re-use nodes that touch the edit.
+                    // If there is no edit anymore, we can re-use the node in any case.
+                    if (maxCacheableLength !== null && !lengthLessThan(curNode.length, maxCacheableLength)) {
+                        // Either the node contains edited text or touches edited text.
+                        // In the latter case, brackets might have been extended (`end` -> `ending`), so even touching nodes cannot be reused.
+                        return false;
+                    }
+                    const canBeReused = curNode.canBeReused(openedBracketIds);
+                    return canBeReused;
+                });
+                if (cachedNode) {
+                    this._itemsFromCache++;
+                    this.tokenizer.skip(cachedNode.length);
+                    return cachedNode;
+                }
+            }
+        }
+        return undefined;
+    }
+    parseChild(openedBracketIds, level) {
+        this._itemsConstructed++;
+        const token = this.tokenizer.read();
+        switch (token.kind) {
+            case 2 /* TokenKind.ClosingBracket */:
+                return new InvalidBracketAstNode(token.bracketIds, token.length);
+            case 0 /* TokenKind.Text */:
+                return token.astNode;
+            case 1 /* TokenKind.OpeningBracket */: {
+                if (level > 300) {
+                    // To prevent stack overflows
+                    return new TextAstNode(token.length);
+                }
+                const set = openedBracketIds.merge(token.bracketIds);
+                const child = this.parseList(set, level + 1);
+                const nextToken = this.tokenizer.peek();
+                if (nextToken &&
+                    nextToken.kind === 2 /* TokenKind.ClosingBracket */ &&
+                    (nextToken.bracketId === token.bracketId || nextToken.bracketIds.intersects(token.bracketIds))) {
+                    this.tokenizer.read();
+                    return PairAstNode.create(token.astNode, child, nextToken.astNode);
+                }
+                else {
+                    return PairAstNode.create(token.astNode, child, null);
+                }
+            }
+            default:
+                throw new Error('unexpected');
+        }
+    }
+}
+
+export { parseDocument };