/* The MIT License (c) 2017 Gleb Mazovetskiy */
var SPACE = '·';
var TAB = '→';
var WHITESPACE_OPACITY = 0.78;

var ROOT_SELECTOR = 'table[data-tab-size]';
var NODE_FILTER = {
    acceptNode(node) {
        let parent = node.parentNode;
        while (parent.nodeName != 'TABLE') {
            if (parent.classList.contains('blob-code-inner')) {
                return !(parent.firstChild === node && node.nodeValue === ' ') ?
                    NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
            }
            parent = parent.parentNode;
        }
        return NodeFilter.FILTER_SKIP;
    }
};

function showWhitespace() {
    for (const root of document.querySelectorAll(ROOT_SELECTOR)) {
        const tab = TAB.padEnd(+root.dataset.tabSize);
        const treeWalker =
            document.createTreeWalker(root, NodeFilter.SHOW_TEXT, NODE_FILTER);
        const nodes = [];
        while (treeWalker.nextNode()) nodes.push(treeWalker.currentNode);
        for (const node of nodes) replaceWhitespace(node, tab, SPACE);
    }
}

function replaceWhitespace(node, tab, space) {
    const tabParts = node.nodeValue.split('\t');
    const tabSpaceParts = tabParts.map(s => s.split(' '));
    if (tabSpaceParts.length === 1 && tabSpaceParts[0].length === 1) return;
    const parent = node.parentNode;
    const insert = (newNode) => {
        parent.insertBefore(newNode, node);
    };
    insertParts(tabSpaceParts,
        spaceParts => spaceParts.length === 1 && spaceParts[0] === '',
        n => insert(createWhitespaceNode(tab.repeat(n))),
        spaceParts =>
            insertParts(spaceParts,
                text => text === '',
                n => insert(createWhitespaceNode(space.repeat(n))),
                text => insert(document.createTextNode(text))));
    parent.removeChild(node);
}

function createWhitespaceNode(text) {
    const node = document.createElement('span');
    node.textContent = text;
    node.style.opacity = WHITESPACE_OPACITY;
    return node;
}

function insertParts(parts, isConsecutiveFn, addInterFn, addPartFn) {
    const n = parts.length;
    parts.reduce((consecutive, part, i) => {
        const isConsecutive = isConsecutiveFn(part);
        if (isConsecutive) {
            if (i !== n - 1) return consecutive + 1;
        }
        if (consecutive > 0) addInterFn(consecutive);
        if (!isConsecutive) addPartFn(part);
        return 1;
    }, 0);
}

showWhitespace();