highlight-ts/compile.js

Highlight.JS in TypeScript (and ES6).

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
function reStr(re) {
    return (re && re.source) || re;
}
var noneRe = { exec: function ( /*s*/) { return null; } };
function langRe(language, value, global) {
    return new RegExp(reStr(value), 'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : ''));
}
function compileLanguage(language) {
    var cached_modes = [];
    function getCompiled(sub) {
        for (var _i = 0, cached_modes_1 = cached_modes; _i < cached_modes_1.length; _i++) {
            var _a = cached_modes_1[_i], mode = _a[0], compiled_1 = _a[1];
            if (sub === mode) {
                return compiled_1;
            }
        }
    }
    var cached_variants = [];
    function getVariants(mode) {
        if (!mode.variants || !mode.variants.length) {
            return undefined;
        }
        for (var _i = 0, cached_variants_1 = cached_variants; _i < cached_variants_1.length; _i++) {
            var _a = cached_variants_1[_i], mode_ = _a[0], variants_1 = _a[1];
            if (mode === mode_) {
                return variants_1;
            }
        }
        var variants = mode.variants.map(function (variant) { return (tslib_1.__assign({}, mode, { variants: undefined }, variant)); });
        cached_variants.push([mode, variants]);
        return variants;
    }
    ;
    function compileMode(mode, parent, parent_terminator_end) {
        var already_compiled = getCompiled(mode);
        if (already_compiled) {
            return already_compiled;
        }
        var compiled = {
            lexemesRe: langRe(language, mode.lexemes || /\w+/, true),
            relevance: mode.relevance == null ? 1 : mode.relevance,
            contains: [],
            terminators: noneRe,
            subLanguage: mode.subLanguage == null ? undefined :
                typeof mode.subLanguage == 'string' ? [mode.subLanguage] :
                    mode.subLanguage
        };
        cached_modes.push([mode, compiled]);
        if (mode.className) {
            compiled.className = mode.className;
        }
        if (mode.illegal) {
            compiled.illegalRe = langRe(language, mode.illegal);
        }
        for (var _i = 0, _a = ['endsParent', 'endsWithParent', 'skip', 'excludeBegin', 'excludeEnd', 'returnBegin', 'returnEnd']; _i < _a.length; _i++) {
            var key = _a[_i];
            if (mode[key]) {
                compiled[key] = true;
            }
        }
        // compile parenthes
        var compiled_terminator_end;
        if (parent) {
            var begin = mode.beginKeywords ?
                ("\\b(" + mode.beginKeywords.split(/\s+/).join('|') + ")\\b") :
                (mode.begin || /\B|\b/);
            mode.begin = begin;
            compiled.beginRe = langRe(language, begin);
            var end = !mode.end && !mode.endsWithParent ? /\B|\b/ : mode.end;
            if (end) {
                mode.end = end;
                compiled.endRe = langRe(language, end);
            }
            compiled_terminator_end = reStr(end) || '';
            if (mode.endsWithParent && parent_terminator_end) {
                compiled_terminator_end += (end ? '|' : '') + parent_terminator_end;
            }
        }
        // compile keywords
        var keywords = mode.keywords || mode.beginKeywords;
        if (keywords) {
            var compiled_keywords_1 = {};
            var flatten = function (className, str) {
                if (language.case_insensitive) {
                    str = str.toLowerCase();
                }
                var kws = str.split(/\s+/);
                for (var _i = 0, kws_1 = kws; _i < kws_1.length; _i++) {
                    var kw = kws_1[_i];
                    var _a = kw.split(/\|/), key = _a[0], rel = _a[1];
                    compiled_keywords_1[key] = [className, rel ? Number(rel) : 1];
                }
            };
            if (typeof keywords == 'string') { // string
                flatten('keyword', keywords);
            }
            else {
                for (var className in keywords) {
                    flatten(className, keywords[className]);
                }
            }
            compiled.keywords = compiled_keywords_1;
        }
        // compile contains
        var contains = [];
        if (mode.contains && mode.contains.length) {
            // expand mode
            for (var _b = 0, _c = mode.contains; _b < _c.length; _b++) {
                var child = _c[_b];
                var sub = child === 'self' ? mode : child;
                var variants = getVariants(sub) || (sub.endsWithParent && [tslib_1.__assign({}, sub)]) || [sub];
                for (var _d = 0, variants_2 = variants; _d < variants_2.length; _d++) {
                    var variant = variants_2[_d];
                    contains.push(variant);
                }
            }
            compiled.contains = contains.map(function (child) { return compileMode(child, compiled, compiled_terminator_end); });
        }
        if (mode.starts) {
            compiled.starts = compileMode(mode.starts, parent, parent_terminator_end);
        }
        var terminators = contains.map(function (child) { return child.beginKeywords ? "\\.?(" + child.begin + ")\\.?" : child.begin; }).concat([
            compiled_terminator_end,
            mode.illegal
        ]).map(reStr).filter(Boolean);
        if (terminators.length)
            compiled.terminators = langRe(language, terminators.join('|'), true);
        return compiled;
    }
    var compiled = compileMode(language);
    if (language.case_insensitive)
        compiled.case_insensitive = true;
    return compiled;
}
exports.compileLanguage = compileLanguage;
//# sourceMappingURL=compile.js.map