monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/minimapCharRenderer.js

@@ -0,0 +1,90 @@
+import { getCharIndex } from './minimapCharSheet.js';
+import { toUint8 } from '../../../../base/common/uint.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class MinimapCharRenderer {
+    constructor(charData, scale) {
+        this.scale = scale;
+        this._minimapCharRendererBrand = undefined;
+        this.charDataNormal = MinimapCharRenderer.soften(charData, 12 / 15);
+        this.charDataLight = MinimapCharRenderer.soften(charData, 50 / 60);
+    }
+    static soften(input, ratio) {
+        const result = new Uint8ClampedArray(input.length);
+        for (let i = 0, len = input.length; i < len; i++) {
+            result[i] = toUint8(input[i] * ratio);
+        }
+        return result;
+    }
+    renderChar(target, dx, dy, chCode, color, foregroundAlpha, backgroundColor, backgroundAlpha, fontScale, useLighterFont, force1pxHeight) {
+        const charWidth = 1 /* Constants.BASE_CHAR_WIDTH */ * this.scale;
+        const charHeight = 2 /* Constants.BASE_CHAR_HEIGHT */ * this.scale;
+        const renderHeight = (force1pxHeight ? 1 : charHeight);
+        if (dx + charWidth > target.width || dy + renderHeight > target.height) {
+            console.warn('bad render request outside image data');
+            return;
+        }
+        const charData = useLighterFont ? this.charDataLight : this.charDataNormal;
+        const charIndex = getCharIndex(chCode, fontScale);
+        const destWidth = target.width * 4 /* Constants.RGBA_CHANNELS_CNT */;
+        const backgroundR = backgroundColor.r;
+        const backgroundG = backgroundColor.g;
+        const backgroundB = backgroundColor.b;
+        const deltaR = color.r - backgroundR;
+        const deltaG = color.g - backgroundG;
+        const deltaB = color.b - backgroundB;
+        const destAlpha = Math.max(foregroundAlpha, backgroundAlpha);
+        const dest = target.data;
+        let sourceOffset = charIndex * charWidth * charHeight;
+        let row = dy * destWidth + dx * 4 /* Constants.RGBA_CHANNELS_CNT */;
+        for (let y = 0; y < renderHeight; y++) {
+            let column = row;
+            for (let x = 0; x < charWidth; x++) {
+                const c = (charData[sourceOffset++] / 255) * (foregroundAlpha / 255);
+                dest[column++] = backgroundR + deltaR * c;
+                dest[column++] = backgroundG + deltaG * c;
+                dest[column++] = backgroundB + deltaB * c;
+                dest[column++] = destAlpha;
+            }
+            row += destWidth;
+        }
+    }
+    blockRenderChar(target, dx, dy, color, foregroundAlpha, backgroundColor, backgroundAlpha, force1pxHeight) {
+        const charWidth = 1 /* Constants.BASE_CHAR_WIDTH */ * this.scale;
+        const charHeight = 2 /* Constants.BASE_CHAR_HEIGHT */ * this.scale;
+        const renderHeight = (force1pxHeight ? 1 : charHeight);
+        if (dx + charWidth > target.width || dy + renderHeight > target.height) {
+            console.warn('bad render request outside image data');
+            return;
+        }
+        const destWidth = target.width * 4 /* Constants.RGBA_CHANNELS_CNT */;
+        const c = 0.5 * (foregroundAlpha / 255);
+        const backgroundR = backgroundColor.r;
+        const backgroundG = backgroundColor.g;
+        const backgroundB = backgroundColor.b;
+        const deltaR = color.r - backgroundR;
+        const deltaG = color.g - backgroundG;
+        const deltaB = color.b - backgroundB;
+        const colorR = backgroundR + deltaR * c;
+        const colorG = backgroundG + deltaG * c;
+        const colorB = backgroundB + deltaB * c;
+        const destAlpha = Math.max(foregroundAlpha, backgroundAlpha);
+        const dest = target.data;
+        let row = dy * destWidth + dx * 4 /* Constants.RGBA_CHANNELS_CNT */;
+        for (let y = 0; y < renderHeight; y++) {
+            let column = row;
+            for (let x = 0; x < charWidth; x++) {
+                dest[column++] = colorR;
+                dest[column++] = colorG;
+                dest[column++] = colorB;
+                dest[column++] = destAlpha;
+            }
+            row += destWidth;
+        }
+    }
+}
+
+export { MinimapCharRenderer };

package/dist/workers/minimapCharRendererFactory.js

@@ -0,0 +1,136 @@
+import { MinimapCharRenderer } from './minimapCharRenderer.js';
+import { allCharCodes } from './minimapCharSheet.js';
+import { prebakedMiniMaps } from './minimapPreBaked.js';
+import { toUint8 } from '../../../../base/common/uint.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Creates character renderers. It takes a 'scale' that determines how large
+ * characters should be drawn. Using this, it draws data into a canvas and
+ * then downsamples the characters as necessary for the current display.
+ * This makes rendering more efficient, rather than drawing a full (tiny)
+ * font, or downsampling in real-time.
+ */
+class MinimapCharRendererFactory {
+    /**
+     * Creates a new character renderer factory with the given scale.
+     */
+    static create(scale, fontFamily) {
+        // renderers are immutable. By default we'll 'create' a new minimap
+        // character renderer whenever we switch editors, no need to do extra work.
+        if (this.lastCreated && scale === this.lastCreated.scale && fontFamily === this.lastFontFamily) {
+            return this.lastCreated;
+        }
+        let factory;
+        if (prebakedMiniMaps[scale]) {
+            factory = new MinimapCharRenderer(prebakedMiniMaps[scale](), scale);
+        }
+        else {
+            factory = MinimapCharRendererFactory.createFromSampleData(MinimapCharRendererFactory.createSampleData(fontFamily).data, scale);
+        }
+        this.lastFontFamily = fontFamily;
+        this.lastCreated = factory;
+        return factory;
+    }
+    /**
+     * Creates the font sample data, writing to a canvas.
+     */
+    static createSampleData(fontFamily) {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        canvas.style.height = `${16 /* Constants.SAMPLED_CHAR_HEIGHT */}px`;
+        canvas.height = 16 /* Constants.SAMPLED_CHAR_HEIGHT */;
+        canvas.width = 96 /* Constants.CHAR_COUNT */ * 10 /* Constants.SAMPLED_CHAR_WIDTH */;
+        canvas.style.width = 96 /* Constants.CHAR_COUNT */ * 10 /* Constants.SAMPLED_CHAR_WIDTH */ + 'px';
+        ctx.fillStyle = '#ffffff';
+        ctx.font = `bold ${16 /* Constants.SAMPLED_CHAR_HEIGHT */}px ${fontFamily}`;
+        ctx.textBaseline = 'middle';
+        let x = 0;
+        for (const code of allCharCodes) {
+            ctx.fillText(String.fromCharCode(code), x, 16 /* Constants.SAMPLED_CHAR_HEIGHT */ / 2);
+            x += 10 /* Constants.SAMPLED_CHAR_WIDTH */;
+        }
+        return ctx.getImageData(0, 0, 96 /* Constants.CHAR_COUNT */ * 10 /* Constants.SAMPLED_CHAR_WIDTH */, 16 /* Constants.SAMPLED_CHAR_HEIGHT */);
+    }
+    /**
+     * Creates a character renderer from the canvas sample data.
+     */
+    static createFromSampleData(source, scale) {
+        const expectedLength = 16 /* Constants.SAMPLED_CHAR_HEIGHT */ * 10 /* Constants.SAMPLED_CHAR_WIDTH */ * 4 /* Constants.RGBA_CHANNELS_CNT */ * 96 /* Constants.CHAR_COUNT */;
+        if (source.length !== expectedLength) {
+            throw new Error('Unexpected source in MinimapCharRenderer');
+        }
+        const charData = MinimapCharRendererFactory._downsample(source, scale);
+        return new MinimapCharRenderer(charData, scale);
+    }
+    static _downsampleChar(source, sourceOffset, dest, destOffset, scale) {
+        const width = 1 /* Constants.BASE_CHAR_WIDTH */ * scale;
+        const height = 2 /* Constants.BASE_CHAR_HEIGHT */ * scale;
+        let targetIndex = destOffset;
+        let brightest = 0;
+        // This is essentially an ad-hoc rescaling algorithm. Standard approaches
+        // like bicubic interpolation are awesome for scaling between image sizes,
+        // but don't work so well when scaling to very small pixel values, we end
+        // up with blurry, indistinct forms.
+        //
+        // The approach taken here is simply mapping each source pixel to the target
+        // pixels, and taking the weighted values for all pixels in each, and then
+        // averaging them out. Finally we apply an intensity boost in _downsample,
+        // since when scaling to the smallest pixel sizes there's more black space
+        // which causes characters to be much less distinct.
+        for (let y = 0; y < height; y++) {
+            // 1. For this destination pixel, get the source pixels we're sampling
+            // from (x1, y1) to the next pixel (x2, y2)
+            const sourceY1 = (y / height) * 16 /* Constants.SAMPLED_CHAR_HEIGHT */;
+            const sourceY2 = ((y + 1) / height) * 16 /* Constants.SAMPLED_CHAR_HEIGHT */;
+            for (let x = 0; x < width; x++) {
+                const sourceX1 = (x / width) * 10 /* Constants.SAMPLED_CHAR_WIDTH */;
+                const sourceX2 = ((x + 1) / width) * 10 /* Constants.SAMPLED_CHAR_WIDTH */;
+                // 2. Sample all of them, summing them up and weighting them. Similar
+                // to bilinear interpolation.
+                let value = 0;
+                let samples = 0;
+                for (let sy = sourceY1; sy < sourceY2; sy++) {
+                    const sourceRow = sourceOffset + Math.floor(sy) * 3840 /* Constants.RGBA_SAMPLED_ROW_WIDTH */;
+                    const yBalance = 1 - (sy - Math.floor(sy));
+                    for (let sx = sourceX1; sx < sourceX2; sx++) {
+                        const xBalance = 1 - (sx - Math.floor(sx));
+                        const sourceIndex = sourceRow + Math.floor(sx) * 4 /* Constants.RGBA_CHANNELS_CNT */;
+                        const weight = xBalance * yBalance;
+                        samples += weight;
+                        value += ((source[sourceIndex] * source[sourceIndex + 3]) / 255) * weight;
+                    }
+                }
+                const final = value / samples;
+                brightest = Math.max(brightest, final);
+                dest[targetIndex++] = toUint8(final);
+            }
+        }
+        return brightest;
+    }
+    static _downsample(data, scale) {
+        const pixelsPerCharacter = 2 /* Constants.BASE_CHAR_HEIGHT */ * scale * 1 /* Constants.BASE_CHAR_WIDTH */ * scale;
+        const resultLen = pixelsPerCharacter * 96 /* Constants.CHAR_COUNT */;
+        const result = new Uint8ClampedArray(resultLen);
+        let resultOffset = 0;
+        let sourceOffset = 0;
+        let brightest = 0;
+        for (let charIndex = 0; charIndex < 96 /* Constants.CHAR_COUNT */; charIndex++) {
+            brightest = Math.max(brightest, this._downsampleChar(data, sourceOffset, result, resultOffset, scale));
+            resultOffset += pixelsPerCharacter;
+            sourceOffset += 10 /* Constants.SAMPLED_CHAR_WIDTH */ * 4 /* Constants.RGBA_CHANNELS_CNT */;
+        }
+        if (brightest > 0) {
+            const adjust = 255 / brightest;
+            for (let i = 0; i < resultLen; i++) {
+                result[i] *= adjust;
+            }
+        }
+        return result;
+    }
+}
+
+export { MinimapCharRendererFactory };

package/dist/workers/minimapCharSheet.js

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const allCharCodes = (() => {
+    const v = [];
+    for (let i = 32 /* Constants.START_CH_CODE */; i <= 126 /* Constants.END_CH_CODE */; i++) {
+        v.push(i);
+    }
+    v.push(65533 /* Constants.UNKNOWN_CODE */);
+    return v;
+})();
+const getCharIndex = (chCode, fontScale) => {
+    chCode -= 32 /* Constants.START_CH_CODE */;
+    if (chCode < 0 || chCode > 96 /* Constants.CHAR_COUNT */) {
+        if (fontScale <= 2) {
+            // for smaller scales, we can get away with using any ASCII character...
+            return (chCode + 96 /* Constants.CHAR_COUNT */) % 96 /* Constants.CHAR_COUNT */;
+        }
+        return 96 /* Constants.CHAR_COUNT */ - 1; // unknown symbol
+    }
+    return chCode;
+};
+
+export { allCharCodes, getCharIndex };

package/dist/workers/minimapColors.js

@@ -0,0 +1,23 @@
+import { localize } from '../../../../nls.js';
+import { Color, RGBA } from '../../../../base/common/color.js';
+import { registerColor, transparent } from '../colorUtils.js';
+import { editorInfoBorder, editorInfoForeground, editorWarningBorder, editorWarningForeground } from './editorColors.js';
+import { scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground } from './miscColors.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const minimapFindMatch = registerColor('minimap.findMatchHighlight', { light: '#d18616', dark: '#d18616', hcDark: '#AB5A00', hcLight: '#0F4A85' }, localize(1983, 'Minimap marker color for find matches.'), true);
+const minimapSelectionOccurrenceHighlight = registerColor('minimap.selectionOccurrenceHighlight', { light: '#c9c9c9', dark: '#676767', hcDark: '#ffffff', hcLight: '#0F4A85' }, localize(1984, 'Minimap marker color for repeating editor selections.'), true);
+const minimapSelection = registerColor('minimap.selectionHighlight', { light: '#ADD6FF', dark: '#264F78', hcDark: '#ffffff', hcLight: '#0F4A85' }, localize(1985, 'Minimap marker color for the editor selection.'), true);
+const minimapInfo = registerColor('minimap.infoHighlight', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, localize(1986, 'Minimap marker color for infos.'));
+const minimapWarning = registerColor('minimap.warningHighlight', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, localize(1987, 'Minimap marker color for warnings.'));
+const minimapError = registerColor('minimap.errorHighlight', { dark: new Color(new RGBA(255, 18, 18, 0.7)), light: new Color(new RGBA(255, 18, 18, 0.7)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '#B5200D' }, localize(1988, 'Minimap marker color for errors.'));
+const minimapBackground = registerColor('minimap.background', null, localize(1989, "Minimap background color."));
+const minimapForegroundOpacity = registerColor('minimap.foregroundOpacity', Color.fromHex('#000f'), localize(1990, 'Opacity of foreground elements rendered in the minimap. For example, "#000000c0" will render the elements with 75% opacity.'));
+registerColor('minimapSlider.background', transparent(scrollbarSliderBackground, 0.5), localize(1991, "Minimap slider background color."));
+registerColor('minimapSlider.hoverBackground', transparent(scrollbarSliderHoverBackground, 0.5), localize(1992, "Minimap slider background color when hovering."));
+registerColor('minimapSlider.activeBackground', transparent(scrollbarSliderActiveBackground, 0.5), localize(1993, "Minimap slider background color when clicked on."));
+
+export { minimapBackground, minimapError, minimapFindMatch, minimapForegroundOpacity, minimapInfo, minimapSelection, minimapSelectionOccurrenceHighlight, minimapWarning };

package/dist/workers/minimapPreBaked.js

@@ -0,0 +1,52 @@
+import { createSingleCallFunction } from '../../../../base/common/functional.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const charTable = {
+    '0': 0,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+    '6': 6,
+    '7': 7,
+    '8': 8,
+    '9': 9,
+    A: 10,
+    B: 11,
+    C: 12,
+    D: 13,
+    E: 14,
+    F: 15
+};
+const decodeData = (str) => {
+    const output = new Uint8ClampedArray(str.length / 2);
+    for (let i = 0; i < str.length; i += 2) {
+        output[i >> 1] = (charTable[str[i]] << 4) | (charTable[str[i + 1]] & 0xF);
+    }
+    return output;
+};
+/*
+const encodeData = (data: Uint8ClampedArray, length: string) => {
+    const chars = '0123456789ABCDEF';
+    let output = '';
+    for (let i = 0; i < data.length; i++) {
+        output += chars[data[i] >> 4] + chars[data[i] & 0xf];
+    }
+    return output;
+};
+*/
+/**
+ * Map of minimap scales to prebaked sample data at those scales. We don't
+ * sample much larger data, because then font family becomes visible, which
+ * is use-configurable.
+ */
+const prebakedMiniMaps = {
+    1: createSingleCallFunction(() => decodeData('0000511D6300CF609C709645A78432005642574171487021003C451900274D35D762755E8B629C5BA856AF57BA649530C167D1512A272A3F6038604460398526BCA2A968DB6F8957C768BE5FBE2FB467CF5D8D5B795DC7625B5DFF50DE64C466DB2FC47CD860A65E9A2EB96CB54CE06DA763AB2EA26860524D3763536601005116008177A8705E53AB738E6A982F88BAA35B5F5B626D9C636B449B737E5B7B678598869A662F6B5B8542706C704C80736A607578685B70594A49715A4522E792')),
+    2: createSingleCallFunction(() => decodeData('000000000000000055394F383D2800008B8B1F210002000081B1CBCBCC820000847AAF6B9AAF2119BE08B8881AD60000A44FD07DCCF107015338130C00000000385972265F390B406E2437634B4B48031B12B8A0847000001E15B29A402F0000000000004B33460B00007A752C2A0000000000004D3900000084394B82013400ABA5CFC7AD9C0302A45A3E5A98AB000089A43382D97900008BA54AA087A70A0248A6A7AE6DBE0000BF6F94987EA40A01A06DCFA7A7A9030496C32F77891D0000A99FB1A0AFA80603B29AB9CA75930D010C0948354D3900000C0948354F37460D0028BE673D8400000000AF9D7B6E00002B007AA8933400007AA642675C2700007984CFB9C3985B768772A8A6B7B20000CAAECAAFC4B700009F94A6009F840009D09F9BA4CA9C0000CC8FC76DC87F0000C991C472A2000000A894A48CA7B501079BA2C9C69BA20000B19A5D3FA89000005CA6009DA2960901B0A7F0669FB200009D009E00B7890000DAD0F5D092820000D294D4C48BD10000B5A7A4A3B1A50402CAB6CBA6A2000000B5A7A4A3B1A8044FCDADD19D9CB00000B7778F7B8AAE0803C9AB5D3F5D3F00009EA09EA0BAB006039EA0989A8C7900009B9EF4D6B7C00000A9A7816CACA80000ABAC84705D3F000096DA635CDC8C00006F486F266F263D4784006124097B00374F6D2D6D2D6D4A3A95872322000000030000000000008D8939130000000000002E22A5C9CBC70600AB25C0B5C9B400061A2DB04CA67001082AA6BEBEBFC606002321DACBC19E03087AA08B6768380000282FBAC0B8CA7A88AD25BBA5A29900004C396C5894A6000040485A6E356E9442A32CD17EADA70000B4237923628600003E2DE9C1D7B500002F25BBA5A2990000231DB6AFB4A804023025C0B5CAB588062B2CBDBEC0C706882435A75CA20000002326BD6A82A908048B4B9A5A668000002423A09CB4BB060025259C9D8A7900001C1FCAB2C7C700002A2A9387ABA200002626A4A47D6E9D14333163A0C87500004B6F9C2D643A257049364936493647358A34438355497F1A0000A24C1D590000D38DFFBDD4CD3126'))
+};
+
+export { prebakedMiniMaps };

package/dist/workers/minimapTokensColorTracker.js

@@ -0,0 +1,58 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, markAsSingleton } from '../../../base/common/lifecycle.js';
+import { RGBA8 } from '../core/misc/rgba.js';
+import { TokenizationRegistry } from '../languages.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class MinimapTokensColorTracker extends Disposable {
+    static { this._INSTANCE = null; }
+    static getInstance() {
+        if (!this._INSTANCE) {
+            this._INSTANCE = markAsSingleton(new MinimapTokensColorTracker());
+        }
+        return this._INSTANCE;
+    }
+    constructor() {
+        super();
+        this._onDidChange = new Emitter();
+        this.onDidChange = this._onDidChange.event;
+        this._updateColorMap();
+        this._register(TokenizationRegistry.onDidChange(e => {
+            if (e.changedColorMap) {
+                this._updateColorMap();
+            }
+        }));
+    }
+    _updateColorMap() {
+        const colorMap = TokenizationRegistry.getColorMap();
+        if (!colorMap) {
+            this._colors = [RGBA8.Empty];
+            this._backgroundIsLight = true;
+            return;
+        }
+        this._colors = [RGBA8.Empty];
+        for (let colorId = 1; colorId < colorMap.length; colorId++) {
+            const source = colorMap[colorId].rgba;
+            // Use a VM friendly data-type
+            this._colors[colorId] = new RGBA8(source.r, source.g, source.b, Math.round(source.a * 255));
+        }
+        const backgroundLuminosity = colorMap[2 /* ColorId.DefaultBackground */].getRelativeLuminance();
+        this._backgroundIsLight = backgroundLuminosity >= 0.5;
+        this._onDidChange.fire(undefined);
+    }
+    getColor(colorId) {
+        if (colorId < 1 || colorId >= this._colors.length) {
+            // background color (basically invisible)
+            colorId = 2 /* ColorId.DefaultBackground */;
+        }
+        return this._colors[colorId];
+    }
+    backgroundIsLight() {
+        return this._backgroundIsLight;
+    }
+}
+
+export { MinimapTokensColorTracker };

package/dist/workers/mips.contribution.js

@@ -0,0 +1,9 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "mips",
+  extensions: [".s"],
+  aliases: ["MIPS", "MIPS-V"],
+  mimetypes: ["text/x-mips", "text/mips", "text/plaintext"],
+  loader: () => import('./mips.js')
+});

package/dist/workers/mips.js

@@ -0,0 +1,197 @@
+const conf = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    blockComment: ["###", "###"],
+    lineComment: "#"
+  },
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+};
+const language = {
+  defaultToken: "",
+  ignoreCase: false,
+  tokenPostfix: ".mips",
+  regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+  keywords: [
+    ".data",
+    ".text",
+    "syscall",
+    "trap",
+    "add",
+    "addu",
+    "addi",
+    "addiu",
+    "and",
+    "andi",
+    "div",
+    "divu",
+    "mult",
+    "multu",
+    "nor",
+    "or",
+    "ori",
+    "sll",
+    "slv",
+    "sra",
+    "srav",
+    "srl",
+    "srlv",
+    "sub",
+    "subu",
+    "xor",
+    "xori",
+    "lhi",
+    "lho",
+    "lhi",
+    "llo",
+    "slt",
+    "slti",
+    "sltu",
+    "sltiu",
+    "beq",
+    "bgtz",
+    "blez",
+    "bne",
+    "j",
+    "jal",
+    "jalr",
+    "jr",
+    "lb",
+    "lbu",
+    "lh",
+    "lhu",
+    "lw",
+    "li",
+    "la",
+    "sb",
+    "sh",
+    "sw",
+    "mfhi",
+    "mflo",
+    "mthi",
+    "mtlo",
+    "move"
+  ],
+  // we include these common regular expressions
+  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: [
+      // identifiers and keywords
+      [/\$[a-zA-Z_]\w*/, "variable.predefined"],
+      [
+        /[.a-zA-Z_]\w*/,
+        {
+          cases: {
+            this: "variable.predefined",
+            "@keywords": { token: "keyword.$0" },
+            "@default": ""
+          }
+        }
+      ],
+      // whitespace
+      [/[ \t\r\n]+/, ""],
+      // Comments
+      [/#.*$/, "comment"],
+      // regular expressions
+      ["///", { token: "regexp", next: "@hereregexp" }],
+      [/^(\s*)(@regEx)/, ["", "regexp"]],
+      [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      // delimiters
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+      [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/0[0-7]+(?!\d)/, "number.octal"],
+      [/\d+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[,.]/, "delimiter"],
+      // strings:
+      [/"""/, "string", '@herestring."""'],
+      [/'''/, "string", "@herestring.'''"],
+      [
+        /"/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: '@string."' }
+          }
+        }
+      ],
+      [
+        /'/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: "@string.'" }
+          }
+        }
+      ]
+    ],
+    string: [
+      [/[^"'\#\\]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/\./, "string.escape.invalid"],
+      [
+        /#{/,
+        {
+          cases: {
+            '$S2=="': {
+              token: "string",
+              next: "root.interpolatedstring"
+            },
+            "@default": "string"
+          }
+        }
+      ],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/#/, "string"]
+    ],
+    herestring: [
+      [
+        /("""|''')/,
+        {
+          cases: {
+            "$1==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/[^#\\'"]+/, "string"],
+      [/['"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+      [/#/, "string"]
+    ],
+    comment: [
+      [/[^#]+/, "comment"],
+      [/#/, "comment"]
+    ],
+    hereregexp: [
+      [/[^\\\/#]+/, "regexp"],
+      [/\\./, "regexp"],
+      [/#.*$/, "comment"],
+      ["///[igm]*", { token: "regexp", next: "@pop" }],
+      [/\//, "regexp"]
+    ]
+  }
+};
+
+export { conf, language };