@spyglassmc/core 0.1.0

package/lib/parser/util.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acceptOnly = exports.stopBefore = exports.validate = exports.setType = exports.map = exports.select = exports.recover = exports.optional = exports.failOnEmpty = exports.any = exports.repeat = exports.sequence = exports.attempt = void 0;
+const node_1 = require("../node");
+const service_1 = require("../service");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+function attempt(parser, src, ctx) {
+    const tmpSrc = src.clone();
+    const tmpCtx = {
+        ...ctx,
+        err: new service_1.ErrorReporter(),
+        symbols: ctx.symbols.clone(),
+    };
+    const result = parser(tmpSrc, tmpCtx);
+    return {
+        result,
+        endCursor: tmpSrc.cursor,
+        errorAmount: tmpCtx.err.errors.length,
+        updateSrcAndCtx: () => {
+            src.innerCursor = tmpSrc.innerCursor;
+            ctx.err.absorb(tmpCtx.err);
+            tmpCtx.symbols.applyDelayedEdits();
+        },
+    };
+}
+exports.attempt = attempt;
+function sequence(parsers, parseGap) {
+    return (src, ctx) => {
+        const ans = {
+            isSequenceUtil: true,
+            children: [],
+            range: source_1.Range.create(src),
+        };
+        for (const [i, p] of parsers.entries()) {
+            const parser = typeof p === 'function' ? p : p.get(ans);
+            if (parser === undefined) {
+                continue;
+            }
+            if (i > 0 && parseGap) {
+                ans.children.push(...parseGap(src, ctx));
+            }
+            const result = parser(src, ctx);
+            if (result === Parser_1.Failure) {
+                return Parser_1.Failure;
+            }
+            else if (result === undefined) {
+                continue;
+            }
+            else if (node_1.SequenceUtil.is(result)) {
+                ans.children.push(...result.children);
+            }
+            else {
+                ans.children.push(result);
+            }
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.sequence = sequence;
+function repeat(parser, parseGap) {
+    return (src, ctx) => {
+        const ans = {
+            isSequenceUtil: true,
+            children: [],
+            range: source_1.Range.create(src),
+        };
+        while (src.canRead()) {
+            if (parseGap) {
+                ans.children.push(...parseGap(src, ctx));
+            }
+            const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
+            if (result === Parser_1.Failure) {
+                break;
+            }
+            updateSrcAndCtx();
+            if (node_1.SequenceUtil.is(result)) {
+                ans.children.push(...result.children);
+            }
+            else {
+                ans.children.push(result);
+            }
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.repeat = repeat;
+function any(parsers, out) {
+    return (src, ctx) => {
+        const results = parsers
+            .map((parser, i) => ({ attempt: attempt(parser, src, ctx), index: i }))
+            .filter(({ attempt }) => attempt.result !== Parser_1.Failure)
+            .sort((a, b) => (b.attempt.endCursor - a.attempt.endCursor) || (a.attempt.errorAmount - b.attempt.errorAmount));
+        if (results.length === 0) {
+            if (out) {
+                out.index = -1;
+            }
+            return Parser_1.Failure;
+        }
+        results[0].attempt.updateSrcAndCtx();
+        if (out) {
+            out.index = results[0].index;
+        }
+        return results[0].attempt.result;
+    };
+}
+exports.any = any;
+/**
+ * @returns A parser that fails when the passed-in parser didn't move the cursor at all.
+ */
+function failOnEmpty(parser) {
+    return (src, ctx) => {
+        const start = src.cursor;
+        const { endCursor, updateSrcAndCtx, result } = attempt(parser, src, ctx);
+        if (endCursor - start > 0) {
+            updateSrcAndCtx();
+            return result;
+        }
+        return Parser_1.Failure;
+    };
+}
+exports.failOnEmpty = failOnEmpty;
+function optional(parser) {
+    // return any<N | undefined>([
+    // 	parser,
+    // 	empty,
+    // ])
+    return (src, ctx) => {
+        const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
+        if (result === Parser_1.Failure) {
+            return undefined;
+        }
+        else {
+            updateSrcAndCtx();
+            return result;
+        }
+    };
+}
+exports.optional = optional;
+function recover(parser, defaultValue) {
+    return (src, ctx) => {
+        const result = parser(src, ctx);
+        if (result === Parser_1.Failure) {
+            const ans = defaultValue(src, ctx);
+            return ans;
+        }
+        return result;
+    };
+}
+exports.recover = recover;
+function select(cases) {
+    return (src, ctx) => {
+        for (const { predicate, parser } of cases) {
+            if (predicate?.(src) ?? true) {
+                return parser(src, ctx);
+            }
+        }
+        return Parser_1.Failure;
+    };
+}
+exports.select = select;
+function map(parser, fn) {
+    return (src, ctx) => {
+        const result = parser(src, ctx);
+        if (result === Parser_1.Failure) {
+            return Parser_1.Failure;
+        }
+        const ans = fn(result, src, ctx);
+        return ans;
+    };
+}
+exports.map = map;
+function setType(type, parser) {
+    return map(parser, res => ({
+        ...res,
+        type,
+    }));
+}
+exports.setType = setType;
+function validate(parser, validator, message, severity) {
+    return map(parser, (res, src, ctx) => {
+        const isLegal = validator(res, src, ctx);
+        if (!isLegal) {
+            ctx.err.report(message, res.range, severity);
+        }
+        return res;
+    });
+}
+exports.validate = validate;
+function stopBefore(parser, ...teminators) {
+    const flatTerminators = teminators.flat();
+    return (src, ctx) => {
+        const tmpSrc = src.clone();
+        // Cut tmpSrc.string before the nearest terminator.
+        tmpSrc.string = tmpSrc.string.slice(0, flatTerminators.reduce((p, c) => {
+            const index = tmpSrc.string.indexOf(c, tmpSrc.innerCursor);
+            return Math.min(p, index === -1 ? Infinity : index);
+        }, Infinity));
+        const ans = parser(tmpSrc, ctx);
+        src.cursor = tmpSrc.cursor;
+        return ans;
+    };
+}
+exports.stopBefore = stopBefore;
+function acceptOnly(parser, ...characters) {
+    const set = new Set(characters.flat());
+    return (src, ctx) => {
+        const tmpSrc = src.clone();
+        // Cut tmpSrc.string before the nearest unacceptable character.
+        for (let i = tmpSrc.innerCursor; i < tmpSrc.string.length; i++) {
+            if (!set.has(tmpSrc.string.charAt(i))) {
+                tmpSrc.string = tmpSrc.string.slice(0, i);
+                break;
+            }
+        }
+        const ans = parser(tmpSrc, ctx);
+        src.cursor = tmpSrc.cursor;
+        return ans;
+    };
+}
+exports.acceptOnly = acceptOnly;
+//# sourceMappingURL=util.js.map

package/lib/processor/ColorInfoProvider.d.ts

@@ -0,0 +1,87 @@
+import type { Range } from '../source';
+export interface ColorInfo {
+    range: Range;
+    color: Color;
+}
+/**
+ * An array of four decimal numbers within the interval [0, 1] that represent R, G, B, and A respectively.
+ */
+export declare type Color = [number, number, number, number];
+export declare namespace Color {
+    const NamedColors: Map<string, number>;
+    const ColorNames: string[];
+    /**
+     * @param r A decimal within [0.0, 1.0].
+     * @param g A decimal within [0.0, 1.0].
+     * @param b A decimal within [0.0, 1.0].
+     * @param a A decimal within [0.0, 1.0].
+     */
+    function fromDecRGBA(r: number, g: number, b: number, a: number): Color;
+    /**
+     * @param r A decimal within [0.0, 1.0].
+     * @param g A decimal within [0.0, 1.0].
+     * @param b A decimal within [0.0, 1.0].
+     */
+    function fromDecRGB(r: number, g: number, b: number): Color;
+    /**
+     * @param r An integer within [0, 255].
+     * @param g An integer within [0, 255].
+     * @param b An integer within [0, 255].
+     * @param a An integer within [0, 255].
+     */
+    function fromIntRGBA(r: number, g: number, b: number, a: number): Color;
+    /**
+     * @param r An integer within [0, 255].
+     * @param g An integer within [0, 255].
+     * @param b An integer within [0, 255].
+     */
+    function fromIntRGB(r: number, g: number, b: number): Color;
+    /**
+     * @param value `R << 16 + G << 8 + B`. Negative values result in white.
+     */
+    function fromCompositeInt(value: number): Color;
+}
+export declare enum ColorFormat {
+    /**
+     * `1 0.6 0.2 1.0`
+     */
+    DecRGBA = 0,
+    /**
+     * `1 0.6 0.2`
+     */
+    DecRGB = 1,
+    /**
+     * `255 153 51 25`
+     */
+    IntRGBA = 2,
+    /**
+     * `255 153 51`
+     */
+    IntRGB = 3,
+    /**
+     * `#ff9933ff`
+     */
+    HexRGBA = 4,
+    /**
+     * `#ff9933`
+     */
+    HexRGB = 5,
+    /**
+     * `16620441`
+     */
+    CompositeInt = 6
+}
+export declare type FormattableColor = {
+    value: Color;
+    format: ColorFormat[];
+    range?: Range;
+};
+export declare type ColorPresentation = {
+    label: string;
+    text: string;
+    range: Range;
+};
+export declare namespace ColorPresentation {
+    function fromColorFormat(format: ColorFormat, color: Color, range: Range): ColorPresentation;
+}
+//# sourceMappingURL=ColorInfoProvider.d.ts.map

package/lib/processor/ColorInfoProvider.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorPresentation = exports.ColorFormat = exports.Color = void 0;
+var Color;
+(function (Color) {
+    Color.NamedColors = new Map([
+        ['aqua', 0x55ffff],
+        ['black', 0x000000],
+        ['blue', 0x5555ff],
+        ['dark_aqua', 0x00aaaa],
+        ['dark_blue', 0x0000aa],
+        ['dark_gray', 0x555555],
+        ['dark_green', 0x00aa00],
+        ['dark_purple', 0xaa00aa],
+        ['dark_red', 0xaa0000],
+        ['gold', 0xffaa00],
+        ['gray', 0xaaaaaa],
+        ['green', 0x55ff55],
+        ['light_purple', 0xff55ff],
+        ['red', 0xff5555],
+        ['white', 0xffffff],
+        ['yellow', 0xffff55],
+    ]);
+    Color.ColorNames = [...Color.NamedColors.keys()];
+    /**
+     * @param r A decimal within [0.0, 1.0].
+     * @param g A decimal within [0.0, 1.0].
+     * @param b A decimal within [0.0, 1.0].
+     * @param a A decimal within [0.0, 1.0].
+     */
+    function fromDecRGBA(r, g, b, a) {
+        return [r, g, b, a];
+    }
+    Color.fromDecRGBA = fromDecRGBA;
+    /**
+     * @param r A decimal within [0.0, 1.0].
+     * @param g A decimal within [0.0, 1.0].
+     * @param b A decimal within [0.0, 1.0].
+     */
+    function fromDecRGB(r, g, b) {
+        return fromDecRGBA(r, g, b, 1.0);
+    }
+    Color.fromDecRGB = fromDecRGB;
+    /**
+     * @param r An integer within [0, 255].
+     * @param g An integer within [0, 255].
+     * @param b An integer within [0, 255].
+     * @param a An integer within [0, 255].
+     */
+    function fromIntRGBA(r, g, b, a) {
+        return fromDecRGBA(r / 255, g / 255, b / 255, a / 255);
+    }
+    Color.fromIntRGBA = fromIntRGBA;
+    /**
+     * @param r An integer within [0, 255].
+     * @param g An integer within [0, 255].
+     * @param b An integer within [0, 255].
+     */
+    function fromIntRGB(r, g, b) {
+        return fromIntRGBA(r, g, b, 255);
+    }
+    Color.fromIntRGB = fromIntRGB;
+    /**
+     * @param value `R << 16 + G << 8 + B`. Negative values result in white.
+     */
+    function fromCompositeInt(value) {
+        if (value < 0) {
+            return fromDecRGB(1.0, 1.0, 1.0);
+        }
+        const b = value % 256;
+        value >>= 8;
+        const g = value % 256;
+        value >>= 8;
+        const r = value % 256;
+        return fromIntRGB(r, g, b);
+    }
+    Color.fromCompositeInt = fromCompositeInt;
+})(Color = exports.Color || (exports.Color = {}));
+var ColorFormat;
+(function (ColorFormat) {
+    /**
+     * `1 0.6 0.2 1.0`
+     */
+    ColorFormat[ColorFormat["DecRGBA"] = 0] = "DecRGBA";
+    /**
+     * `1 0.6 0.2`
+     */
+    ColorFormat[ColorFormat["DecRGB"] = 1] = "DecRGB";
+    /**
+     * `255 153 51 25`
+     */
+    ColorFormat[ColorFormat["IntRGBA"] = 2] = "IntRGBA";
+    /**
+     * `255 153 51`
+     */
+    ColorFormat[ColorFormat["IntRGB"] = 3] = "IntRGB";
+    /**
+     * `#ff9933ff`
+     */
+    ColorFormat[ColorFormat["HexRGBA"] = 4] = "HexRGBA";
+    /**
+     * `#ff9933`
+     */
+    ColorFormat[ColorFormat["HexRGB"] = 5] = "HexRGB";
+    /**
+     * `16620441`
+     */
+    ColorFormat[ColorFormat["CompositeInt"] = 6] = "CompositeInt";
+})(ColorFormat = exports.ColorFormat || (exports.ColorFormat = {}));
+var ColorPresentation;
+(function (ColorPresentation) {
+    function fromColorFormat(format, color, range) {
+        const presentation = colorPresentation(format, color);
+        return {
+            label: presentation,
+            text: presentation,
+            range,
+        };
+    }
+    ColorPresentation.fromColorFormat = fromColorFormat;
+    function colorPresentation(format, color) {
+        const round = (num) => parseFloat(num.toFixed(3));
+        switch (format) {
+            case ColorFormat.DecRGBA:
+                return color.map(c => round(c)).join(' ');
+            case ColorFormat.DecRGB:
+                return color.slice(0, 3).map(c => round(c)).join(' ');
+            case ColorFormat.IntRGBA:
+                return color.map(c => Math.round(c * 255)).join(' ');
+            case ColorFormat.IntRGB:
+                return color.slice(0, 3).map(c => Math.round(c * 255)).join(' ');
+            case ColorFormat.HexRGBA:
+                return `#${Math.round((color[0] * 255 << 24) + (color[1] * 255 << 16) + (color[2] * 255) << 8 + color[3] * 255).toString(16).padStart(8, '0')}`;
+            case ColorFormat.HexRGB:
+                return `#${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255).toString(16).padStart(6, '0')}`;
+            case ColorFormat.CompositeInt:
+                return `${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255)}`;
+        }
+    }
+})(ColorPresentation = exports.ColorPresentation || (exports.ColorPresentation = {}));
+//# sourceMappingURL=ColorInfoProvider.js.map

package/lib/processor/InlayHintProvider.d.ts

@@ -0,0 +1,8 @@
+import type { AstNode } from '../node';
+import type { ProcessorContext } from '../service';
+export interface InlayHint {
+    offset: number;
+    text: string;
+}
+export declare type InlayHintProvider<N = AstNode> = (node: N, ctx: ProcessorContext) => readonly InlayHint[];
+//# sourceMappingURL=InlayHintProvider.d.ts.map

package/lib/processor/InlayHintProvider.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InlayHintProvider.js.map

package/lib/processor/SignatureHelpProvider.d.ts

@@ -0,0 +1,18 @@
+import type { AstNode } from '../node';
+import type { SignatureHelpProviderContext } from '../service';
+export interface SignatureHelp {
+    signatures: SignatureInfo[];
+    activeSignature: number;
+}
+export interface SignatureInfo {
+    label: string;
+    documentation?: string;
+    parameters: ParameterInfo[];
+    activeParameter: number;
+}
+export interface ParameterInfo {
+    label: [number, number];
+    documentation?: string;
+}
+export declare type SignatureHelpProvider<N = AstNode> = (node: N, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
+//# sourceMappingURL=SignatureHelpProvider.d.ts.map

package/lib/processor/SignatureHelpProvider.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SignatureHelpProvider.js.map

package/lib/processor/checker/Checker.d.ts

@@ -0,0 +1,7 @@
+import type { AstNode } from '../../node';
+import type { CheckerContext } from '../../service';
+export declare type Checker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void> | void;
+export declare type SyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => void;
+export declare type AsyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void>;
+export declare const FallbackChecker: Checker<any>;
+//# sourceMappingURL=Checker.d.ts.map

package/lib/processor/checker/Checker.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackChecker = void 0;
+/* istanbul ignore next */
+const FallbackChecker = () => Promise.resolve();
+exports.FallbackChecker = FallbackChecker;
+//# sourceMappingURL=Checker.js.map

package/lib/processor/checker/builtin.d.ts

@@ -0,0 +1,23 @@
+import type { AstNode, SymbolBaseNode } from '../../node';
+import { ResourceLocationNode } from '../../node';
+import type { CheckerContext, MetaRegistry } from '../../service';
+import type { Checker, SyncChecker } from './Checker';
+export declare type AttemptResult = {
+    errorAmount: number;
+    totalErrorSpan: number;
+    updateNodeAndCtx: () => void;
+};
+export declare function attempt<N extends AstNode>(checker: Checker<N>, node: N, ctx: CheckerContext): AttemptResult;
+export declare function any<N extends AstNode>(checkers: Checker<N>[]): Checker<N>;
+/**
+ * No operation.
+ */
+export declare const noop: SyncChecker<AstNode>;
+/**
+ * Use the shallowest children that have their own checker to validate.
+ */
+export declare const fallback: Checker<AstNode>;
+export declare const resourceLocation: Checker<ResourceLocationNode>;
+export declare const symbol: Checker<SymbolBaseNode>;
+export declare function registerCheckers(meta: MetaRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/checker/builtin.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCheckers = exports.symbol = exports.resourceLocation = exports.fallback = exports.noop = exports.any = exports.attempt = void 0;
+const lib_1 = require("../../../../locales/lib");
+const node_1 = require("../../node");
+const service_1 = require("../../service");
+const util_1 = require("../util");
+function attempt(checker, node, ctx) {
+    const tempCtx = {
+        ...ctx,
+        err: new service_1.ErrorReporter(),
+        ops: new service_1.Operations(),
+        symbols: ctx.symbols.clone(),
+    };
+    // FIXME: await
+    checker(node, tempCtx);
+    tempCtx.ops.undo();
+    const totalErrorSpan = tempCtx.err.errors
+        .map(e => e.range.end - e.range.start)
+        .reduce((a, b) => a + b, 0);
+    return {
+        errorAmount: tempCtx.err.errors.length,
+        totalErrorSpan,
+        updateNodeAndCtx: () => {
+            ctx.err.absorb(tempCtx.err);
+            tempCtx.ops.redo();
+            tempCtx.symbols.applyDelayedEdits();
+        },
+    };
+}
+exports.attempt = attempt;
+function any(checkers) {
+    if (checkers.length === 0) {
+        throw new Error('Expected at least one checker');
+    }
+    return (node, ctx) => {
+        const attempts = checkers
+            .map(checker => attempt(checker, node, ctx))
+            .sort((a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan);
+        attempts[0].updateNodeAndCtx();
+    };
+}
+exports.any = any;
+/**
+ * No operation.
+ */
+const noop = () => { };
+exports.noop = noop;
+/**
+ * Use the shallowest children that have their own checker to validate.
+ */
+const fallback = async (node, ctx) => {
+    const promises = [];
+    (0, util_1.traversePreOrder)(node, node => !ctx.meta.hasChecker(node.type), node => ctx.meta.hasChecker(node.type), node => {
+        const checker = ctx.meta.getChecker(node.type);
+        const result = checker(node, ctx);
+        if (result instanceof Promise) {
+            promises.push(result);
+        }
+    });
+    await Promise.allSettled(promises);
+};
+exports.fallback = fallback;
+const resourceLocation = (node, ctx) => {
+    const full = node_1.ResourceLocationNode.toString(node, 'full');
+    if (node.options.pool) {
+        if (!node.options.pool.includes(full)) {
+            ctx.err.report((0, lib_1.localize)('expected', node.options.pool), node, 3 /* Error */);
+        }
+        return;
+    }
+};
+exports.resourceLocation = resourceLocation;
+const symbol = (_node, _ctx) => {
+    // TODO
+};
+exports.symbol = symbol;
+function registerCheckers(meta) {
+    meta.registerChecker('resource_location', exports.resourceLocation);
+    meta.registerChecker('symbol', exports.symbol);
+}
+exports.registerCheckers = registerCheckers;
+//# sourceMappingURL=builtin.js.map

package/lib/processor/checker/index.d.ts

@@ -0,0 +1,3 @@
+export * as checker from './builtin';
+export * from './Checker';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/checker/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checker = void 0;
+exports.checker = __importStar(require("./builtin"));
+__exportStar(require("./Checker"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/colorizer/Colorizer.d.ts

@@ -0,0 +1,23 @@
+import type { AstNode } from '../../node';
+import type { ColorizerContext } from '../../service';
+import type { RangeLike } from '../../source';
+import { Range } from '../../source';
+export declare type Colorizer<N = AstNode> = (node: N, ctx: ColorizerContext) => readonly ColorToken[];
+export interface ColorToken {
+    range: Range;
+    type: ColorTokenType;
+    modifiers?: ColorTokenModifier[];
+}
+export declare namespace ColorToken {
+    function create(range: RangeLike, type: ColorTokenType, modifiers?: ColorTokenModifier[]): ColorToken;
+    /**
+     * @returns An array of color tokens that cover the whole range of `targetRange`, with gaps in `tokens` filled
+     * with tokens created from the specified `type` and `modifiers`.
+     */
+    function fillGap(tokens: readonly ColorToken[], targetRange: Range, type: ColorTokenType, modifiers?: ColorTokenModifier[]): ColorToken[];
+}
+export declare const ColorTokenTypes: readonly ["comment", "enum", "enumMember", "function", "keyword", "modifier", "number", "operator", "property", "string", "struct", "type", "type", "variable", "error", "literal", "operator", "resourceLocation", "vector"];
+export declare type ColorTokenType = typeof ColorTokenTypes[number];
+export declare const ColorTokenModifiers: readonly ["declaration", "defaultLibrary", "definition", "deprecated", "documentation", "modification", "readonly"];
+export declare type ColorTokenModifier = typeof ColorTokenModifiers[number];
+//# sourceMappingURL=Colorizer.d.ts.map