Run results for: Rule Benchmark (3)

Test name	Executions per second
VERBOSE (1)	1950.6 Ops/sec
VERBOSE (2)	2044.1 Ops/sec
INFO (1)	851.6 Ops/sec
INFO (2)	915.1 Ops/sec
WARN (1)	871.9 Ops/sec
WARN (2)	868.5 Ops/sec
ERROR (1)	1128.2 Ops/sec
ERROR (2)	1154.4 Ops/sec
SILENT (1)	2086.1 Ops/sec
SILENT (2)	89109.9 Ops/sec

VERBOSE (1)

const level = 'LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

VERBOSE (2)

const level = 'LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  let enabled_ = false;
  if (rules.enabled?.some(testRule)) {
    enabled_ = !rules.disabled?.some(testRule);
  }
}

INFO (1)

const level = 'LH:*, -LH:*:verbose';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

INFO (2)

const level = 'LH:*, -LH:*:verbose';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  let enabled_ = false;
  if (rules.enabled?.some(testRule)) {
    enabled_ = !rules.disabled?.some(testRule);
  }
}

WARN (1)

const level = '-LH:*, LH:*:warn, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

WARN (2)

const level = '-LH:*, LH:*:warn, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  let enabled_ = false;
  if (rules.enabled?.some(testRule)) {
    enabled_ = !rules.disabled?.some(testRule);
  }
}

ERROR (1)

const level = '-LH:*, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

ERROR (2)

const level = '-LH:*, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  let enabled_ = false;
  if (rules.enabled?.some(testRule)) {
    enabled_ = !rules.disabled?.some(testRule);
  }
}

SILENT (1)

const level = '-LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

SILENT (2)

const level = '-LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  let enabled_ = false;
  if (rules.enabled?.some(testRule)) {
    enabled_ = !rules.disabled?.some(testRule);
  }
}