monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,176 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,121 +0,0 @@
-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 };