BABLR for globbing mockup (public domain)

index.js

import { test as nonbacktrackingTest } from '@bablr/regex-vm';
import * as bablrLanguage from '@bablr/language-regex-vm-pattern';
import { buildTag } from 'bablr';
import { printCSTML } from '@bablr/agast-helpers/tree';

const re = buildTag(bablrLanguage, 'Pattern');

const weakMemo = (fn) => {
  const cache = new WeakMap();
  return (arg) => {
    if (cache.has(arg)) {
      return cache.get(arg);
    }
    const returnValue = fn(arg);
    cache.set(arg, returnValue);
    return returnValue;
  }
};

export const globASTToBABLRRegexCST = weakMemo((globAST) => {
  switch(globAST.type) {
    case 'GlobStar': return re`/.*?/`;
    case 'Literal': return re.Literal([globAst[1]]);
    default: throw new Error('unimplemented');
  }
});

export const globPatternMightBacktrackCatastrophically = weakMemo((globPattern) => {
  let globstars = 0;
  // glob node iterator should assert that Object.isFrozen(node) for cacheability
  for (const node of globASTIterator(globPattern)) {
    if (node.type === 1) globstars++;
    if (globstars === 2) break;
  }

  return globstars === 2;
});

export const globMatch = (globPattern, text) => {
  const regexPatternTree = globASTToBABLRRegexCST(globPattern);

  if (globPatternMightBacktrackCatastrophically(regexPatternTree)) {
    return nonbacktrackingTest(regexPatternTree, text);
  }

  const printArr = (name, sep = '') => {
    return patternTree.properties[name].map(node => printCSTML(node)).join(sep);
  }

  return new RegExp(printArr('alternatives', '|'), printArr('flags')).test(text);
}

globMatch('foo/**', 'foo/bar/abc'); // true