var trueInput = [

    { left: 'prefix*', right: 'prefix:extended*' },

    { left: '*suffix', right: '*:extended:suffix' },

    { left: 'left*right', right: 'left*middle*right' },

    { left: 'a*b*c', right: 'a*b*d*b*c' },

    { left: 'hello*', right: '*ok' },

    { left: '*', right: '*'},

    { left: '*', right: '**'},

    { left: '*', right: ''},

    { left: '', right: ''},

    { left: 'abc', right: 'a*c'},

    { left: 'a*c', right: 'a*c'},

    { left: 'a[bc]d', right: 'acd'},

    { left: 'a[bc]d', right: 'a[ce]d'},

    { left: 'a?d', right: 'acd'},

    { left: 'a[bc]d*wyz', right: 'abd*w[xy]z'},

    { left: 'abc[def]?fghi?*nop*[tuv]uv[wxy]?yz', right: 'a?[cde]defg*?ilmn[opq]*tu*[xyz]*' },

];

​

var falseInput = [

    { left: 'prefix*', right: 'wrong:prefix:*' },

    { left: '*suffix', right: '*suffix:wrong' },

    { left: 'left*right', right: 'right*middle*left' },

    { left: 'abc', right: 'abcde'},

    { left: 'abcde', right: 'abc'},

    { left: 'a[bc]d', right: 'aed'},

    { left: 'a[bc]d', right: 'a[fe]d'},

    { left: 'a?e', right: 'acd'},

    { left: 'a[bc]d*wyz', right: 'abc*w[ab]z'},

];

​

// Expects either a single-character string (for literal strings

// and single-character wildcards) or an array (for character

// classes).

var characterIntersect = function(a,b) {

    // If one is a wildcard, there is an intersection.

    if (a === '?' || b === '?')

        return true;

​

    // If both are characters, they must be the same.

    if (typeof a === 'string' && typeof b === 'string')

        return a === b;

​

    // If one is a character class, we check that the other

    // is contained in the class.

    if (a instanceof Array && typeof b === 'string')

        return (a.indexOf(b) > -1);

    if (b instanceof Array && typeof a === 'string')

        return (b.indexOf(a) > -1);

​

    // Now both have to be arrays, so we need to check whether

    // they intersect.

    return a.filter(function(character) {

        return (b.indexOf(character) > -1);

    }).length > 0;

};

​

var patternIntersect = function(a,b) {

    // Turn the strings into character arrays because they are

    // easier to deal with.

    a = a.split("");

    b = b.split("");

​

    // Check the beginnings of the string (up until the first *

    // in either of them).

    while (a.length && b.length && a[0] !== '*' && b[0] !== '*')

    {

        // Remove the first character from each. If it's a [,

        // extract an array of all characters in the class.

        aChar = a.shift();

        if (aChar == '[')

        {

            aChar = a.splice(0, a.indexOf(']'));

            a.shift(); // remove the ]

        }

        bChar = b.shift();

        if (bChar == '[')

        {

            bChar = b.splice(0, b.indexOf(']'));

            b.shift(); // remove the ]

        }

​

        // Check if the two characters or classes overlap.

        if (!characterIntersect(aChar, bChar))

            return false;

    }

​

    // Same thing, but for the end of the string.

    while (a.length && b.length && a[a.length-1] !== '*' && b[b.length-1] !== '*')

    {

        aChar = a.pop();

        if (aChar == ']')

        {

            aChar = a.splice(a.indexOf('[')+1, Number.MAX_VALUE);

            a.pop(); // remove the [

        }

        bChar = b.pop();

        if (bChar == ']')

        {

            bChar = b.splice(b.indexOf('[')+1, Number.MAX_VALUE);

            b.pop(); // remove the [

        }

​

        if (!characterIntersect(aChar, bChar))

            return false;

    }

​

    // If one string is empty, the other has to be empty, too, or

    // consist only of stars.

    if (!a.length && /[^*]/.test(b.join('')) ||

        !b.length && /[^*]/.test(b.join('')))

        return false;

​

    // The only case not covered above is that both strings contain

    // a * in which case they certainly overlap.

    return true;

};

​

​

console.clear();

​

console.log('Should be all true:');

console.log(trueInput.map(function(pair) {

    return patternIntersect(pair.left, pair.right);

}));

​

console.log('Should be all false:');

console.log(falseInput.map(function(pair) {

    return patternIntersect(pair.left, pair.right);

}));