Shock

var TeX = {
    lib : {
        safeHTML : function (string) {
            return string.replace(/&|"|'|<|>/g, function (symb) {
                switch (symb) {
                    case "&"  : return "&amp;";
                    case "\"" : return "&quot;";
                    case "\'" : return "&#039;";
                    case "<"  : return "&lt;";
                    case ">"  : return "&gt;";
                }
            })
        }
    },
    // This is container for private functions
    office  : {
        tags     : {},
        rules    : {},
        validate : {
            tag : function (tag) {
                var errors = []
                if (!tag.name) {
                    errors.push('Name of tag is empty (tag.name);');
                }
                if (!tag.args) {
                    errors.push('Arguments count is empty (tag.args);');
                }
                if (!tag.func) {
                    errors.push('There are no function in tag (tag.func);');
                }
                if (errors.length) {
                    throw errors.join("\n");
                    return false;
                }
                return true;
            }
        },
        analizeTags : function () {
            if (!TeX.office.analizeTagsCache) {
                var longestName = 0;
                for (var i in TeX.office.tags) {
                    var tag = TeX.office.tags[i];
                    if (!tag) {
                        continue;
                    }
                    if (tag.name.length > longestName) {
                        longestName = tag.name.length;
                    }
                    tag.argsMax = tag.args.toString().toLowerCase() == 'unlimited' ?
                        null : TeX.office.arrayEdges(tag.args)['max'];
                }
                TeX.office.analizeTagsCache = {
                    longest : longestName
                };
            }
            return TeX.office.analizeTagsCache;
        },
        analizeTagsCache : {},
        arrayHas : function (array, value) {
            for (var i in array) {
                if (value == array[i]) {
                    return true;
                }
            }
            return false;
        },
        arrayEdges : function (array) {
            var max = array[0];
            var min = array[0];
            for (var i in array) {
                if (array[i] > max) {
                    max = array[i];
                }
                if (array[i] < min) {
                    min = array[i];
                }
            }
            return {max:max, min:min};
        },
        findBlock: function (string, startFrom) {
            var opened = 0;
            for (var i = startFrom, l = string.length; i < l; i++) {
                var chr = string.charAt(i);
                if (chr == '{') {
                    opened++;
                } else if (chr == '}' && !--opened) {
                    return i;
                }
            }
            return null;
        },
        findTag: function (string, startFrom) {
            var possibleTag;
            var tag = {
                start:startFrom,
                blocks:[]
            };
            var tagStat = TeX.office.analizeTags();
            var srcLine = string.substr(startFrom);
            for (var i = 0; i <= tagStat.longest + 1; i++) {
                var chr = srcLine.charAt(i);
                if (chr == '{') {
                    tag.name  = srcLine.substring(1, i);
                    possibleTag = TeX.getTag(tag.name);
                    if(!possibleTag) {
                        break;
                    }
                    var blogsEnds = [];
                    var max = possibleTag.argsMax;
                    while (max === null ? true : max--) {
                        var end = TeX.office.findBlock(srcLine, i);
                        if (!end) {
                            break;
                        }
                        tag.blocks.push(srcLine.substring(i+1, end));
                        blogsEnds.push(end);
                        if (srcLine.charAt(end+1) == '{') {
                            i = end+1;
                        } else {
                            break;
                        }
                    }
                    while (max !== null && tag.blocks.length && !TeX.office.arrayHas(possibleTag.args, tag.blocks.length)) {
                        tag.blocks.pop();
                        blogsEnds.pop();
                    }
                    if (!tag.blocks.length) {
                        break;
                    }
                    tag.finish = startFrom + 1 + blogsEnds.pop();
                    tag.func   = possibleTag.func;
                    return tag;
                }
            }
            return null;
        }
    },
    markup  : function (string) {
        var result = '';
        for (var i = 0; i < string.length; i++) {
            var chr = string.charAt(i);
            if (chr == "\\") {
                try {
                    var tag = TeX.office.findTag(string, i);
                } catch (ignored) {
                    break;
                }

                if (tag) {
                    result += TeX.markupPlain(string.substring(0, tag.start));
                    result += tag.func(tag.blocks);
                    string = string.substr (tag.finish);
                    i = -1;
                }
            }
        }
        return result + TeX.markupPlain(string);

    },
    markupPlain : function (string) {
        for (var i in TeX.office.rules) {
            var rule = TeX.office.rules[i];
            if (!rule) {
                continue;
            }
            string = rule.func(string);
        }
        return string;
    },

    // Rules
    getRule  : function (name) {
        var rule = TeX.office.rules[name];
        return rule ? rule : null;
    },
    getRules  : function () {
        return TeX.office.rules;
    },
    addRule : function (rule) {
        TeX.office.rules[rule.name] = rule;
    },
    addRules : function (rules) {
        for (var i in rules) {
            TeX.addRule(rules[i]);
        }
    },
    rmRule : function (name) {
        TeX.office.rules[name] = null;
    },

    // Tags
    getTag  : function (name) {
        var tag = TeX.office.tags[name];
        return tag ? tag : null;
    },
    getTags  : function () {
        return TeX.office.tags;
    },
    addTag  : function (tag) {
        if (TeX.office.validate.tag(tag)) {
            TeX.office.tags[tag.name] = tag;
            TeX.office.analizeTagsCache = null;
        }
    },
    addTags : function (tags) {
        for (var i in tags) {
            TeX.addTag(tags[i]);
        }
    },
    rmTag : function (name) {
        TeX.office.analizeTagsCache = null;
        TeX.office.tags[name] = null;
    }
};