all files / lib/ index.js

81.01% Statements 64/79
71.43% Branches 30/42
71.43% Functions 5/7
89.23% Lines 58/65
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143                              15×       15× 15×   15× 87×     87×             84×     87× 92×           92×   92×     702×     702×   702×   343×   343×   343×   80× 16×     80×   80×   80×       80×   80× 51×     80×   80×   80× 66×     80×         15×     15×                                          
"use strict";
 
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.tokenize = tokenize;
exports.getLanguage = getLanguage;
exports.highlight = highlight;
exports.addPlugin = addPlugin;
 
var _languages = require("./languages");
 
var languages = _interopRequireWildcard(_languages);
 
var _utils = require("./utils");
 
var utils = _interopRequireWildcard(_utils);
 
var _hooks = require("./hooks");
 
var _hooks2 = _interopRequireDefault(_hooks);
 
var _token = require("./token");
 
var _token2 = _interopRequireDefault(_token);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function tokenize(text, grammar) {
    Iif (!grammar.hasOwnProperty("_order") || !Array.isArray(grammar._order)) {
        throw new Error("A grammar must have an _order array");
    }
 
    var start_array = [text];
    var order = grammar._order;
 
    tokenloop: for (var z = 0; z < order.length; z++) {
        var token = order[z],
            patterns = grammar[token];
 
        if (Array.isArray(patterns)) {
            Iif (token === "keyword" && patterns.every(function (a) {
                return typeof a === "string";
            })) {
                patterns = "\b(" + patterns.join("|") + ")\b";
                patterns = [new RegExp(patterns)];
            }
        } else {
            patterns = [patterns];
        }
 
        for (var j = 0; j < patterns.length; ++j) {
            var pattern = patterns[j],
                inside = pattern.inside,
                lookbehind = Boolean(pattern.lookbehind),
                lookbehindLength = 0,
                alias = pattern.alias;
 
            pattern = pattern.pattern || pattern;
 
            for (var i = 0; i < start_array.length; i++) {
                // Don’t cache length as it changes during the loop
 
                var node = start_array[i];
 
                // Something went terribly wrong, ABORT, ABORT!
                Iif (start_array.length > text.length) break tokenloop;
 
                if (node instanceof _token2.default) continue;
 
                pattern.lastIndex = 0;
 
                var match = pattern.exec(node);
 
                if (!match) continue;
 
                if (lookbehind) {
                    lookbehindLength = match[1].length;
                }
 
                var string_from = match.index - 1 + lookbehindLength;
 
                match = match[0].slice(lookbehindLength);
 
                var string_to = string_from + match.length,
                    before = node.slice(0, string_from + 1),
                    after = node.slice(string_to + 1);
 
                var args = [i, 1];
 
                if (before) {
                    args.push(before);
                }
 
                var wrapped = new _token2.default(token, inside ? tokenize(match, inside) : match, alias);
 
                args.push(wrapped);
 
                if (after) {
                    args.push(after);
                }
 
                start_array.splice.apply(start_array, args);
            }
        }
    }
 
    return start_array;
}
 
function getLanguage(name) {
    return languages[name] || false;
}
 
function highlight(text, language) {
    var grammar = getLanguage(language),
        env = {
        grammar: grammar,
        language: language,
        code: text
    };
 
    _hooks2.default.run("before-highlight", env);
 
    var tokens = tokenize(env.code, env.grammar),
        // Specific for plugins
    highlightedCode = _token2.default.stringify(utils.encode(tokens), language);
 
    env.highlightedCode = highlightedCode;
    _hooks2.default.run("after-highlight", env);
 
    return env.highlightedCode; // Specific for plugins
}
 
function addPlugin(plugin) {
    if (typeof plugin !== "function") {
        throw new Error("Given Plugin must be a function");
    }
 
    plugin(_hooks2.default.add);
}