monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/glyphMargin.js

@@ -0,0 +1,403 @@
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ArrayQueue } from '../../../../base/common/arrays.js';
+import './glyphMargin.css';
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import { ViewPart } from '../../view/viewPart.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { GlyphMarginLane } from '../../../common/model.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Represents a decoration that should be shown along the lines from `startLineNumber` to `endLineNumber`.
+ * This can end up producing multiple `LineDecorationToRender`.
+ */
+class DecorationToRender {
+    constructor(startLineNumber, endLineNumber, className, tooltip, zIndex) {
+        this.startLineNumber = startLineNumber;
+        this.endLineNumber = endLineNumber;
+        this.className = className;
+        this.tooltip = tooltip;
+        this._decorationToRenderBrand = undefined;
+        this.zIndex = zIndex ?? 0;
+    }
+}
+/**
+ * A decoration that should be shown along a line.
+ */
+class LineDecorationToRender {
+    constructor(className, zIndex, tooltip) {
+        this.className = className;
+        this.zIndex = zIndex;
+        this.tooltip = tooltip;
+    }
+}
+/**
+ * Decorations to render on a visible line.
+ */
+class VisibleLineDecorationsToRender {
+    constructor() {
+        this.decorations = [];
+    }
+    add(decoration) {
+        this.decorations.push(decoration);
+    }
+    getDecorations() {
+        return this.decorations;
+    }
+}
+class DedupOverlay extends DynamicViewOverlay {
+    /**
+     * Returns an array with an element for each visible line number.
+     */
+    _render(visibleStartLineNumber, visibleEndLineNumber, decorations) {
+        const output = [];
+        for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            output[lineIndex] = new VisibleLineDecorationsToRender();
+        }
+        if (decorations.length === 0) {
+            return output;
+        }
+        // Sort decorations by className, then by startLineNumber and then by endLineNumber
+        decorations.sort((a, b) => {
+            if (a.className === b.className) {
+                if (a.startLineNumber === b.startLineNumber) {
+                    return a.endLineNumber - b.endLineNumber;
+                }
+                return a.startLineNumber - b.startLineNumber;
+            }
+            return (a.className < b.className ? -1 : 1);
+        });
+        let prevClassName = null;
+        let prevEndLineIndex = 0;
+        for (let i = 0, len = decorations.length; i < len; i++) {
+            const d = decorations[i];
+            const className = d.className;
+            const zIndex = d.zIndex;
+            let startLineIndex = Math.max(d.startLineNumber, visibleStartLineNumber) - visibleStartLineNumber;
+            const endLineIndex = Math.min(d.endLineNumber, visibleEndLineNumber) - visibleStartLineNumber;
+            if (prevClassName === className) {
+                // Here we avoid rendering the same className multiple times on the same line
+                startLineIndex = Math.max(prevEndLineIndex + 1, startLineIndex);
+                prevEndLineIndex = Math.max(prevEndLineIndex, endLineIndex);
+            }
+            else {
+                prevClassName = className;
+                prevEndLineIndex = endLineIndex;
+            }
+            for (let i = startLineIndex; i <= prevEndLineIndex; i++) {
+                output[i].add(new LineDecorationToRender(className, zIndex, d.tooltip));
+            }
+        }
+        return output;
+    }
+}
+class GlyphMarginWidgets extends ViewPart {
+    constructor(context) {
+        super(context);
+        this._widgets = {};
+        this._context = context;
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this.domNode = createFastDomNode(document.createElement('div'));
+        this.domNode.setClassName('glyph-margin-widgets');
+        this.domNode.setPosition('absolute');
+        this.domNode.setTop(0);
+        this._lineHeight = options.get(75 /* EditorOption.lineHeight */);
+        this._glyphMargin = options.get(66 /* EditorOption.glyphMargin */);
+        this._glyphMarginLeft = layoutInfo.glyphMarginLeft;
+        this._glyphMarginWidth = layoutInfo.glyphMarginWidth;
+        this._glyphMarginDecorationLaneCount = layoutInfo.glyphMarginDecorationLaneCount;
+        this._managedDomNodes = [];
+        this._decorationGlyphsToRender = [];
+    }
+    dispose() {
+        this._managedDomNodes = [];
+        this._decorationGlyphsToRender = [];
+        this._widgets = {};
+        super.dispose();
+    }
+    getWidgets() {
+        return Object.values(this._widgets);
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this._lineHeight = options.get(75 /* EditorOption.lineHeight */);
+        this._glyphMargin = options.get(66 /* EditorOption.glyphMargin */);
+        this._glyphMarginLeft = layoutInfo.glyphMarginLeft;
+        this._glyphMarginWidth = layoutInfo.glyphMarginWidth;
+        this._glyphMarginDecorationLaneCount = layoutInfo.glyphMarginDecorationLaneCount;
+        return true;
+    }
+    onDecorationsChanged(e) {
+        return true;
+    }
+    onFlushed(e) {
+        return true;
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollTopChanged;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    // --- end event handlers
+    // --- begin widget management
+    addWidget(widget) {
+        const domNode = createFastDomNode(widget.getDomNode());
+        this._widgets[widget.getId()] = {
+            widget: widget,
+            preference: widget.getPosition(),
+            domNode: domNode,
+            renderInfo: null
+        };
+        domNode.setPosition('absolute');
+        domNode.setDisplay('none');
+        domNode.setAttribute('widgetId', widget.getId());
+        this.domNode.appendChild(domNode);
+        this.setShouldRender();
+    }
+    setWidgetPosition(widget, preference) {
+        const myWidget = this._widgets[widget.getId()];
+        if (myWidget.preference.lane === preference.lane
+            && myWidget.preference.zIndex === preference.zIndex
+            && Range.equalsRange(myWidget.preference.range, preference.range)) {
+            return false;
+        }
+        myWidget.preference = preference;
+        this.setShouldRender();
+        return true;
+    }
+    removeWidget(widget) {
+        const widgetId = widget.getId();
+        if (this._widgets[widgetId]) {
+            const widgetData = this._widgets[widgetId];
+            const domNode = widgetData.domNode.domNode;
+            delete this._widgets[widgetId];
+            domNode.remove();
+            this.setShouldRender();
+        }
+    }
+    // --- end widget management
+    _collectDecorationBasedGlyphRenderRequest(ctx, requests) {
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        const decorations = ctx.getDecorationsInViewport();
+        for (const d of decorations) {
+            const glyphMarginClassName = d.options.glyphMarginClassName;
+            if (!glyphMarginClassName) {
+                continue;
+            }
+            const startLineNumber = Math.max(d.range.startLineNumber, visibleStartLineNumber);
+            const endLineNumber = Math.min(d.range.endLineNumber, visibleEndLineNumber);
+            const lane = d.options.glyphMargin?.position ?? GlyphMarginLane.Center;
+            const zIndex = d.options.zIndex ?? 0;
+            for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+                const modelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(new Position(lineNumber, 0));
+                const laneIndex = this._context.viewModel.glyphLanes.getLanesAtLine(modelPosition.lineNumber).indexOf(lane);
+                requests.push(new DecorationBasedGlyphRenderRequest(lineNumber, laneIndex, zIndex, glyphMarginClassName));
+            }
+        }
+    }
+    _collectWidgetBasedGlyphRenderRequest(ctx, requests) {
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        for (const widget of Object.values(this._widgets)) {
+            const range = widget.preference.range;
+            const { startLineNumber, endLineNumber } = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(Range.lift(range));
+            if (!startLineNumber || !endLineNumber || endLineNumber < visibleStartLineNumber || startLineNumber > visibleEndLineNumber) {
+                // The widget is not in the viewport
+                continue;
+            }
+            // The widget is in the viewport, find a good line for it
+            const widgetLineNumber = Math.max(startLineNumber, visibleStartLineNumber);
+            const modelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(new Position(widgetLineNumber, 0));
+            const laneIndex = this._context.viewModel.glyphLanes.getLanesAtLine(modelPosition.lineNumber).indexOf(widget.preference.lane);
+            requests.push(new WidgetBasedGlyphRenderRequest(widgetLineNumber, laneIndex, widget.preference.zIndex, widget));
+        }
+    }
+    _collectSortedGlyphRenderRequests(ctx) {
+        const requests = [];
+        this._collectDecorationBasedGlyphRenderRequest(ctx, requests);
+        this._collectWidgetBasedGlyphRenderRequest(ctx, requests);
+        // sort requests by lineNumber ASC, lane  ASC, zIndex DESC, type DESC (widgets first), className ASC
+        // don't change this sort unless you understand `prepareRender` below.
+        requests.sort((a, b) => {
+            if (a.lineNumber === b.lineNumber) {
+                if (a.laneIndex === b.laneIndex) {
+                    if (a.zIndex === b.zIndex) {
+                        if (b.type === a.type) {
+                            if (a.type === 0 /* GlyphRenderRequestType.Decoration */ && b.type === 0 /* GlyphRenderRequestType.Decoration */) {
+                                return (a.className < b.className ? -1 : 1);
+                            }
+                            return 0;
+                        }
+                        return b.type - a.type;
+                    }
+                    return b.zIndex - a.zIndex;
+                }
+                return a.laneIndex - b.laneIndex;
+            }
+            return a.lineNumber - b.lineNumber;
+        });
+        return requests;
+    }
+    /**
+     * Will store render information in each widget's renderInfo and in `_decorationGlyphsToRender`.
+     */
+    prepareRender(ctx) {
+        if (!this._glyphMargin) {
+            this._decorationGlyphsToRender = [];
+            return;
+        }
+        for (const widget of Object.values(this._widgets)) {
+            widget.renderInfo = null;
+        }
+        const requests = new ArrayQueue(this._collectSortedGlyphRenderRequests(ctx));
+        const decorationGlyphsToRender = [];
+        while (requests.length > 0) {
+            const first = requests.peek();
+            if (!first) {
+                // not possible
+                break;
+            }
+            // Requests are sorted by lineNumber and lane, so we read all requests for this particular location
+            const requestsAtLocation = requests.takeWhile((el) => el.lineNumber === first.lineNumber && el.laneIndex === first.laneIndex);
+            if (!requestsAtLocation || requestsAtLocation.length === 0) {
+                // not possible
+                break;
+            }
+            const winner = requestsAtLocation[0];
+            if (winner.type === 0 /* GlyphRenderRequestType.Decoration */) {
+                // combine all decorations with the same z-index
+                const classNames = [];
+                // requests are sorted by zIndex, type, and className so we can dedup className by looking at the previous one
+                for (const request of requestsAtLocation) {
+                    if (request.zIndex !== winner.zIndex || request.type !== winner.type) {
+                        break;
+                    }
+                    if (classNames.length === 0 || classNames[classNames.length - 1] !== request.className) {
+                        classNames.push(request.className);
+                    }
+                }
+                decorationGlyphsToRender.push(winner.accept(classNames.join(' '))); // TODO@joyceerhl Implement overflow for remaining decorations
+            }
+            else {
+                // widgets cannot be combined
+                winner.widget.renderInfo = {
+                    lineNumber: winner.lineNumber,
+                    laneIndex: winner.laneIndex,
+                };
+            }
+        }
+        this._decorationGlyphsToRender = decorationGlyphsToRender;
+    }
+    render(ctx) {
+        if (!this._glyphMargin) {
+            for (const widget of Object.values(this._widgets)) {
+                widget.domNode.setDisplay('none');
+            }
+            while (this._managedDomNodes.length > 0) {
+                const domNode = this._managedDomNodes.pop();
+                domNode?.domNode.remove();
+            }
+            return;
+        }
+        const width = (Math.round(this._glyphMarginWidth / this._glyphMarginDecorationLaneCount));
+        // Render widgets
+        for (const widget of Object.values(this._widgets)) {
+            if (!widget.renderInfo) {
+                // this widget is not visible
+                widget.domNode.setDisplay('none');
+            }
+            else {
+                const top = ctx.viewportData.relativeVerticalOffset[widget.renderInfo.lineNumber - ctx.viewportData.startLineNumber];
+                const left = this._glyphMarginLeft + widget.renderInfo.laneIndex * this._lineHeight;
+                widget.domNode.setDisplay('block');
+                widget.domNode.setTop(top);
+                widget.domNode.setLeft(left);
+                widget.domNode.setWidth(width);
+                widget.domNode.setHeight(this._lineHeight);
+            }
+        }
+        // Render decorations, reusing previous dom nodes as possible
+        for (let i = 0; i < this._decorationGlyphsToRender.length; i++) {
+            const dec = this._decorationGlyphsToRender[i];
+            const decLineNumber = dec.lineNumber;
+            const top = ctx.viewportData.relativeVerticalOffset[decLineNumber - ctx.viewportData.startLineNumber];
+            const left = this._glyphMarginLeft + dec.laneIndex * this._lineHeight;
+            let domNode;
+            if (i < this._managedDomNodes.length) {
+                domNode = this._managedDomNodes[i];
+            }
+            else {
+                domNode = createFastDomNode(document.createElement('div'));
+                this._managedDomNodes.push(domNode);
+                this.domNode.appendChild(domNode);
+            }
+            const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(decLineNumber);
+            domNode.setClassName(`cgmr codicon ` + dec.combinedClassName);
+            domNode.setPosition(`absolute`);
+            domNode.setTop(top);
+            domNode.setLeft(left);
+            domNode.setWidth(width);
+            domNode.setHeight(lineHeight);
+        }
+        // remove extra dom nodes
+        while (this._managedDomNodes.length > this._decorationGlyphsToRender.length) {
+            const domNode = this._managedDomNodes.pop();
+            domNode?.domNode.remove();
+        }
+    }
+}
+/**
+ * A request to render a decoration in the glyph margin at a certain location.
+ */
+class DecorationBasedGlyphRenderRequest {
+    constructor(lineNumber, laneIndex, zIndex, className) {
+        this.lineNumber = lineNumber;
+        this.laneIndex = laneIndex;
+        this.zIndex = zIndex;
+        this.className = className;
+        this.type = 0 /* GlyphRenderRequestType.Decoration */;
+    }
+    accept(combinedClassName) {
+        return new DecorationBasedGlyph(this.lineNumber, this.laneIndex, combinedClassName);
+    }
+}
+/**
+ * A request to render a widget in the glyph margin at a certain location.
+ */
+class WidgetBasedGlyphRenderRequest {
+    constructor(lineNumber, laneIndex, zIndex, widget) {
+        this.lineNumber = lineNumber;
+        this.laneIndex = laneIndex;
+        this.zIndex = zIndex;
+        this.widget = widget;
+        this.type = 1 /* GlyphRenderRequestType.Widget */;
+    }
+}
+class DecorationBasedGlyph {
+    constructor(lineNumber, laneIndex, combinedClassName) {
+        this.lineNumber = lineNumber;
+        this.laneIndex = laneIndex;
+        this.combinedClassName = combinedClassName;
+    }
+}
+
+export { DecorationToRender, DedupOverlay, GlyphMarginWidgets, LineDecorationToRender, VisibleLineDecorationsToRender };

package/dist/workers/glyphRasterizer.js

@@ -0,0 +1,276 @@
+import { memoize } from '../../../../base/common/decorators.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import { StringBuilder } from '../../../common/core/stringBuilder.js';
+import { TokenMetadata } from '../../../common/encodedTokenAttributes.js';
+import { ensureNonNullable } from '../gpuUtils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  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;
+};
+let nextId = 0;
+class GlyphRasterizer extends Disposable {
+    get cacheKey() {
+        return `${this.fontFamily}_${this.fontSize}px`;
+    }
+    constructor(fontSize, fontFamily, devicePixelRatio, _decorationStyleCache) {
+        super();
+        this.fontSize = fontSize;
+        this.fontFamily = fontFamily;
+        this.devicePixelRatio = devicePixelRatio;
+        this._decorationStyleCache = _decorationStyleCache;
+        this.id = nextId++;
+        this._workGlyph = {
+            source: null,
+            boundingBox: {
+                left: 0,
+                bottom: 0,
+                right: 0,
+                top: 0,
+            },
+            originOffset: {
+                x: 0,
+                y: 0,
+            },
+            fontBoundingBoxAscent: 0,
+            fontBoundingBoxDescent: 0,
+        };
+        this._workGlyphConfig = { chars: undefined, tokenMetadata: 0, decorationStyleSetId: 0 };
+        // TODO: Support workbench.fontAliasing correctly
+        this._antiAliasing = isMacintosh ? 'greyscale' : 'subpixel';
+        const devicePixelFontSize = Math.ceil(this.fontSize * devicePixelRatio);
+        this._canvas = new OffscreenCanvas(devicePixelFontSize * 3, devicePixelFontSize * 3);
+        this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
+            willReadFrequently: true,
+            alpha: this._antiAliasing === 'greyscale',
+        }));
+        this._ctx.textBaseline = 'top';
+        this._ctx.fillStyle = '#FFFFFF';
+        this._ctx.font = `${devicePixelFontSize}px ${this.fontFamily}`;
+        this._textMetrics = this._ctx.measureText('A');
+    }
+    /**
+     * Rasterizes a glyph. Note that the returned object is reused across different glyphs and
+     * therefore is only safe for synchronous access.
+     */
+    rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap) {
+        if (chars === '') {
+            return {
+                source: this._canvas,
+                boundingBox: { top: 0, left: 0, bottom: -1, right: -1 },
+                originOffset: { x: 0, y: 0 },
+                fontBoundingBoxAscent: 0,
+                fontBoundingBoxDescent: 0,
+            };
+        }
+        // Check if the last glyph matches the config, reuse if so. This helps avoid unnecessary
+        // work when the rasterizer is called multiple times like when the glyph doesn't fit into a
+        // page.
+        if (this._workGlyphConfig.chars === chars && this._workGlyphConfig.tokenMetadata === tokenMetadata && this._workGlyphConfig.decorationStyleSetId === decorationStyleSetId) {
+            return this._workGlyph;
+        }
+        this._workGlyphConfig.chars = chars;
+        this._workGlyphConfig.tokenMetadata = tokenMetadata;
+        this._workGlyphConfig.decorationStyleSetId = decorationStyleSetId;
+        return this._rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap);
+    }
+    _rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap) {
+        const devicePixelFontSize = Math.ceil(this.fontSize * this.devicePixelRatio);
+        const canvasDim = devicePixelFontSize * 3;
+        if (this._canvas.width !== canvasDim) {
+            this._canvas.width = canvasDim;
+            this._canvas.height = canvasDim;
+        }
+        this._ctx.save();
+        // The sub-pixel x offset is the fractional part of the x pixel coordinate of the cell, this
+        // is used to improve the spacing between rendered characters.
+        const xSubPixelXOffset = (tokenMetadata & 0b1111) / 10;
+        const bgId = TokenMetadata.getBackground(tokenMetadata);
+        const bg = colorMap[bgId];
+        const decorationStyleSet = this._decorationStyleCache.getStyleSet(decorationStyleSetId);
+        // When SPAA is used, the background color must be present to get the right glyph
+        if (this._antiAliasing === 'subpixel') {
+            this._ctx.fillStyle = bg;
+            this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);
+        }
+        else {
+            this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+        }
+        const fontSb = new StringBuilder(200);
+        const fontStyle = TokenMetadata.getFontStyle(tokenMetadata);
+        if (fontStyle & 1 /* FontStyle.Italic */) {
+            fontSb.appendString('italic ');
+        }
+        if (decorationStyleSet?.bold !== undefined) {
+            if (decorationStyleSet.bold) {
+                fontSb.appendString('bold ');
+            }
+        }
+        else if (fontStyle & 2 /* FontStyle.Bold */) {
+            fontSb.appendString('bold ');
+        }
+        fontSb.appendString(`${devicePixelFontSize}px ${this.fontFamily}`);
+        this._ctx.font = fontSb.build();
+        // TODO: Support FontStyle.Strikethrough and FontStyle.Underline text decorations, these
+        //       need to be drawn manually to the canvas. See xterm.js for "dodging" the text for
+        //       underlines.
+        const originX = devicePixelFontSize;
+        const originY = devicePixelFontSize;
+        if (decorationStyleSet?.color !== undefined) {
+            this._ctx.fillStyle = `#${decorationStyleSet.color.toString(16).padStart(8, '0')}`;
+        }
+        else {
+            this._ctx.fillStyle = colorMap[TokenMetadata.getForeground(tokenMetadata)];
+        }
+        this._ctx.textBaseline = 'top';
+        if (decorationStyleSet?.opacity !== undefined) {
+            this._ctx.globalAlpha = decorationStyleSet.opacity;
+        }
+        this._ctx.fillText(chars, originX + xSubPixelXOffset, originY);
+        this._ctx.restore();
+        const imageData = this._ctx.getImageData(0, 0, this._canvas.width, this._canvas.height);
+        if (this._antiAliasing === 'subpixel') {
+            const bgR = parseInt(bg.substring(1, 3), 16);
+            const bgG = parseInt(bg.substring(3, 5), 16);
+            const bgB = parseInt(bg.substring(5, 7), 16);
+            this._clearColor(imageData, bgR, bgG, bgB);
+            this._ctx.putImageData(imageData, 0, 0);
+        }
+        this._findGlyphBoundingBox(imageData, this._workGlyph.boundingBox);
+        // const offset = {
+        // 	x: textMetrics.actualBoundingBoxLeft,
+        // 	y: textMetrics.actualBoundingBoxAscent
+        // };
+        // const size = {
+        // 	w: textMetrics.actualBoundingBoxRight + textMetrics.actualBoundingBoxLeft,
+        // 	y: textMetrics.actualBoundingBoxDescent + textMetrics.actualBoundingBoxAscent,
+        // 	wInt: Math.ceil(textMetrics.actualBoundingBoxRight + textMetrics.actualBoundingBoxLeft),
+        // 	yInt: Math.ceil(textMetrics.actualBoundingBoxDescent + textMetrics.actualBoundingBoxAscent),
+        // };
+        // console.log(`${chars}_${fg}`, textMetrics, boundingBox, originX, originY, { width: boundingBox.right - boundingBox.left, height: boundingBox.bottom - boundingBox.top });
+        this._workGlyph.source = this._canvas;
+        this._workGlyph.originOffset.x = this._workGlyph.boundingBox.left - originX;
+        this._workGlyph.originOffset.y = this._workGlyph.boundingBox.top - originY;
+        this._workGlyph.fontBoundingBoxAscent = this._textMetrics.fontBoundingBoxAscent;
+        this._workGlyph.fontBoundingBoxDescent = this._textMetrics.fontBoundingBoxDescent;
+        // const result2: IRasterizedGlyph = {
+        // 	source: this._canvas,
+        // 	boundingBox: {
+        // 		left: Math.floor(originX - textMetrics.actualBoundingBoxLeft),
+        // 		right: Math.ceil(originX + textMetrics.actualBoundingBoxRight),
+        // 		top: Math.floor(originY - textMetrics.actualBoundingBoxAscent),
+        // 		bottom: Math.ceil(originY + textMetrics.actualBoundingBoxDescent),
+        // 	},
+        // 	originOffset: {
+        // 		x: Math.floor(boundingBox.left - originX),
+        // 		y: Math.floor(boundingBox.top - originY)
+        // 	}
+        // };
+        // TODO: Verify result 1 and 2 are the same
+        // if (result2.boundingBox.left > result.boundingBox.left) {
+        // 	debugger;
+        // }
+        // if (result2.boundingBox.top > result.boundingBox.top) {
+        // 	debugger;
+        // }
+        // if (result2.boundingBox.right < result.boundingBox.right) {
+        // 	debugger;
+        // }
+        // if (result2.boundingBox.bottom < result.boundingBox.bottom) {
+        // 	debugger;
+        // }
+        // if (JSON.stringify(result2.originOffset) !== JSON.stringify(result.originOffset)) {
+        // 	debugger;
+        // }
+        return this._workGlyph;
+    }
+    _clearColor(imageData, r, g, b) {
+        for (let offset = 0; offset < imageData.data.length; offset += 4) {
+            // Check exact match
+            if (imageData.data[offset] === r &&
+                imageData.data[offset + 1] === g &&
+                imageData.data[offset + 2] === b) {
+                imageData.data[offset + 3] = 0;
+            }
+        }
+    }
+    // TODO: Does this even need to happen when measure text is used?
+    _findGlyphBoundingBox(imageData, outBoundingBox) {
+        const height = this._canvas.height;
+        const width = this._canvas.width;
+        let found = false;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.top = y;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.left = 0;
+        found = false;
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.left = x;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.right = width;
+        found = false;
+        for (let x = width - 1; x >= outBoundingBox.left; x--) {
+            for (let y = 0; y < height; y++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.right = x;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.bottom = outBoundingBox.top;
+        found = false;
+        for (let y = height - 1; y >= 0; y--) {
+            for (let x = 0; x < width; x++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.bottom = y;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+    }
+    getTextMetrics(text) {
+        return this._ctx.measureText(text);
+    }
+}
+__decorate([
+    memoize
+], GlyphRasterizer.prototype, "cacheKey", null);
+
+export { GlyphRasterizer };

package/dist/workers/go.contribution.js

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