unexpectedly 1.0.0 → 2.0.0

package/README.md

@@ -11,13 +11,20 @@ npm install -g unexpectedly
 ## Usage
 
 ```
-unexpectedly [--defaultScript jsPattern] <...file|directory>
-  jsPattern (default: "../$<base>.js"): find the JS file relative to
-    the .tests file, replacing `$<base>` with the basename of the test file.
-    This may be specified multiple times, and modifies all files/directories
-    after.
-  file: a file that contains tests
-  directory (default: "."): a directory containing ".tests" files
+Usage: unexpectedly [options] [...file]
+
+Arguments:
+  ...file                           Files or directories to test (default:
+                                    "./test/")
+
+Options:
+  -V, --version                     output the version number
+  -d,--defaultScript <replacement>  Find the script from the file name.
+                                    Replace `$<base>` with the basename of the
+                                    file. (default: "../$<base>.js")
+  -f,--function <functionName>      Use this function for testing in the
+                                    associated script (default: "test")
+  -h, --help                        display help for command
 ```
 
 ## Example
@@ -63,8 +70,10 @@ unexpectedly tests/
 ```js
 import {suite} from 'unexpectedly';
 
-// returns a Promise
-suite(directoryOrFile, jsPattern).catch(console.error)
+await suite(directoryOrFile, {
+  defaultScript: '../$<base>.js',
+  function: 'test',
+}).catch(console.error)
 ```
 
 ## Test language
@@ -101,6 +110,9 @@ Special globals include:
    instead of the default
  - "timeout": If any test in the file takes longer than this (in ms),
    it fails.  Default: 2000
+ - "peggy": Treat the input as a compiled peggy grammar; look for a "parse"
+   function in the input script, provide better errors, and use the value
+   of the peggy global (if any) as the startRule.
 
 Environment variables can be set for the test code with `#!! name: value`.
 

package/bin/unexpectedly.js

@@ -1,23 +1,36 @@
 #!/usr/bin/env -S node --experimental-vm-modules --no-warnings
 /* eslint-disable no-console */
 
+import {Command, Option} from 'commander';
+import fs from 'node:fs/promises';
 import {suite} from '../index.js';
 
 let failures = 0;
 
 async function main() {
-  let defaultScript = undefined;
-  let nextDefault = false;
-  for (const arg of process.argv.slice(2)) {
-    if (nextDefault) {
-      defaultScript = arg;
-      nextDefault = false;
-    } else if (arg === '--defaultScript') {
-      nextDefault = true;
-    } else {
-      // eslint-disable-next-line require-atomic-updates
-      failures += await suite(arg, defaultScript);
-    }
+  const pkg = JSON.parse(await fs.readFile(
+    new URL('../package.json', import.meta.url),
+    'utf-8'
+  ));
+
+  const program = new Command();
+  const opts = program
+    .version(pkg.version)
+    .argument('[...file]', 'Files or directories to test', './test/')
+    .option('-d,--defaultScript <replacement>', 'Find the script from the file name.  Replace `$<base>` with the basename of the file.', '../$<base>.js')
+    .option('-f,--function <functionName>', 'Use this function for testing in the associated script', 'test')
+    .addOption(new Option('-s,--silent18', 'Silently skip mjs tests on node 18.').hideHelp())
+    .parse()
+    .opts();
+
+  const {args} = program;
+  if (args.length === 0) {
+    args.push('./test/');
+  }
+
+  for (const arg of args) {
+    // eslint-disable-next-line require-atomic-updates
+    failures += await suite(arg, opts);
   }
 }
 

package/index.js

@@ -1,6 +1,6 @@
+import {Runner, SKIPPED} from './runner.js';
 import {hexlify, mapObj} from './utils.js';
 import Mocha from 'mocha';
-import {Runner} from './runner.js';
 import assert from 'node:assert';
 import fs from 'node:fs/promises';
 import {parse} from './testFile.peg.js';
@@ -13,6 +13,9 @@ async function coerce(actual, pt, runner) {
   if (typeof actual === 'string') {
     return [actual, expected];
   }
+  if (actual === SKIPPED) {
+    return [SKIPPED, SKIPPED];
+  }
   if (actual && (typeof actual === 'object') && actual.constructor) {
     if (/^0x/.test(expected)) {
       const {name} = actual.constructor;
@@ -42,18 +45,30 @@ async function coerce(actual, pt, runner) {
   return [actual, def];
 }
 
+/**
+ * @typedef {object} SuiteOptions
+ * @property {string} [defaultScript='../$<base>.js'] Find the script from the
+ *   file name.  Replace `$<base>` with the basename of the file.  For
+ *   example, "foo.test" will use "../foo.js" by default.
+ * @property {string} [function='test'] Use this function for testing in the
+ *   associated script.
+ */
+
 /**
  * Run a test suite from a file or directory.
  *
  * @param {string} [target='.'] The file or directory to read.  If a
  *   directory, reads all files ending in `.tests`.
- * @param {string} [defaultScript='../$<base>.js'] Find the script from the
- *   file name.  Replace $1 with the basename of the file.  For example,
- *   "foo.test" will use "../foo.js" by default.
+ * @param {SuiteOptions} [options={}] Options for processing the suite.
  * @returns {Promise<number>} Promise fulfills on completion, with number of
  *   test failures.
  */
-export async function suite(target = '.', defaultScript = '../$<base>.js') {
+export async function suite(target = '.', options = {}) {
+  options = {
+    defaultScript: '../$<base>.js',
+    function: 'test',
+    ...options,
+  };
   let dir = path.resolve(target);
   let files = [dir];
   const mocha = new Mocha();
@@ -90,34 +105,39 @@ export async function suite(target = '.', defaultScript = '../$<base>.js') {
       throw er;
     }
 
-    const opts = {};
-    let text = '';
-    if (parsed.vars.inline) {
-      opts.filename = f;
-      text = parsed.vars.inline.value;
-      opts.lineOffset = parsed.vars.inline.line - 1;
-      opts.columnOffset = parsed.vars.inline.column;
-    } else {
-      opts.filename = parsed.vars.script ?
-        path.resolve(dir, parsed.vars.script.value) :
-        path.resolve(dir, f.replace(/(?<base>[^./]*)\.tests?$/, defaultScript));
-      text = await fs.readFile(opts.filename, 'utf8');
-    }
-    if (parsed.vars.timeout) {
-      msuite.timeout(parseInt(parsed.vars.timeout.value, 10));
-    }
-    opts.sandbox = mapObj(
-      Object.entries(parsed.vars).filter(([k, v]) => !v.env),
-      ([key, value]) => [key, value.value]
-    );
-    opts.env = mapObj(
-      Object.entries(parsed.vars).filter(([k, v]) => v.env),
-      ([key, value]) => [key, value.value]
-    );
-    const runner = new Runner(opts);
+    for (const pt of parsed) {
+      const opts = {
+        testFunction: options.function,
+      };
+      let text = '';
+      if (pt.vars.inline) {
+        opts.filename = f;
+        text = pt.vars.inline.value;
+        opts.lineOffset = pt.vars.inline.line - 1;
+        opts.columnOffset = pt.vars.inline.column;
+      } else {
+        opts.filename = pt.vars.script ?
+          path.resolve(dir, pt.vars.script.value) :
+          path.resolve(dir,
+            f.replace(/(?<base>[^\\/]*)\.tests?$/, options.defaultScript));
+        text = await fs.readFile(opts.filename, 'utf8');
+      }
+      if (pt.vars.timeout) {
+        msuite.timeout(parseInt(pt.vars.timeout.value, 10));
+      }
+      opts.context = mapObj(
+        Object.entries(pt.vars).filter(([k, v]) => !v.env),
+        ([key, value]) => [key, value.value]
+      );
+      opts.env = mapObj(
+        Object.entries(pt.vars).filter(([k, v]) => v.env),
+        ([key, value]) => [key, value.value]
+      );
+      opts.silent18 = Boolean(options.silent18);
+
+      const runner = new Runner(opts);
 
-    for (const pt of parsed.tests) {
-      const firstLine = (pt.expected === EXCEPTION) ? '!' : pt.expected.split(/\n/)[0];
+      const firstLine = (pt.expected === EXCEPTION) ? `! ${pt.inputs[0]}` : pt.expected.split(/\n/)[0];
       const t = new Mocha.Test(`line ${pt.line}: ${firstLine || '""'}`, async() => {
         let actual = null;
         try {
@@ -125,7 +145,12 @@ export async function suite(target = '.', defaultScript = '../$<base>.js') {
             __expected: pt.expected,
             __line: pt.line,
             __column: pt.column,
+            __offset: pt.offset,
           }, ...pt.inputs);
+          if (actual === SKIPPED) {
+            t.skip('Node 20.8 required');
+            return;
+          }
         } catch (e) {
           if (pt.expected !== EXCEPTION) {
             throw e;
@@ -135,6 +160,7 @@ export async function suite(target = '.', defaultScript = '../$<base>.js') {
         assert.notStrictEqual(pt.expected, EXCEPTION);
         assert.deepEqual.apply(null, await coerce(actual, pt, runner));
       });
+
       msuite.addTest(t);
     }
   }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "unexpectedly",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Keep a bunch of test cases in a file, with their expected results",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "build": "peggy -o testFile.peg.js --format es testFile.pegjs",
+    "build": "peggy -o testFile.peg.js --format es testFile.peggy",
     "pretest": "npm run build",
     "test": "c8 npm run runtests",
-    "runtests": "mocha && bin/unexpectedly.js test test/pkg_mjs/test test/pkg_cjs/test",
+    "runtests": "mocha && bin/unexpectedly.js -s test test/pkg_mjs/test test/pkg_cjs/test",
     "lint": "eslint --ext js,cjs,mjs . bin/*",
     "ci": "npm run lint && npm run test",
     "clean": "rimraf coverage testFile.peg.js"
@@ -32,23 +32,21 @@
   },
   "license": "MPL-2.0",
   "dependencies": {
-    "mocha": "^10.2.0"
+    "@peggyjs/from-mem": "1.3.0",
+    "commander": "12.0.0",
+    "mocha": "^10.3.0",
+    "semver": "7.6.0"
   },
   "devDependencies": {
-    "@cto.af/eslint-config": "3.0.2",
-    "c8": "8.0.1",
-    "eslint": "^8.54.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-jsdoc": "46.9.0",
-    "eslint-plugin-n": "16.3.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-standard": "^4.1.0",
-    "peggy": "^3.0.2",
+    "@cto.af/eslint-config": "3.1.0",
+    "c8": "9.1.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-jsdoc": "48.2.0",
+    "peggy": "^4.0.2",
     "rimraf": "5.0.5",
     "zx": "7.2.3"
   },
+  "packageManager": "pnpm@8.15.4",
   "engines": {
     "node": ">=18"
   }

package/runner.js

@@ -1,38 +1,19 @@
-import {ModType} from './modtype.js';
-import {createRequire} from 'node:module';
-import {mapObj} from './utils.js';
+import GrammarLocation from './vendor/peggy/grammar-location.cjs';
+import fromMem from '@peggyjs/from-mem';
 import path from 'node:path';
-import vm from 'node:vm';
+import semver from 'semver';
 
-const vmGlobals = new vm.Script('Object.getOwnPropertyNames(globalThis)')
-  .runInNewContext()
-  .filter(f => !f.startsWith('global'));
-vmGlobals.push('process', 'Buffer');
+const PREFIX_MJS = 'export default ';
+const PREFIX_CJS = 'module.exports = ';
+const PREFIX_MJS_LEN = PREFIX_MJS.length;
+const PREFIX_CJS_LEN = PREFIX_CJS.length;
 
-async function linker(specifier, referencingModule, cache) {
-  // Note: not convinced the cache actually does anything, due to timing.
-  if (cache?.has(specifier)) {
-    return cache.get(specifier);
-  }
-  const m = await import(specifier);
-  const exportNames = Object.keys(m);
-  const imported = new vm.SyntheticModule(
-    exportNames,
-    // eslint-disable-next-line func-names
-    function() {
-      // eslint-disable-next-line no-invalid-this
-      exportNames.forEach(key => this.setExport(key, m[key]));
-    },
-    {identifier: specifier, context: referencingModule.context}
-  );
+const is20 = semver.satisfies(process.version, '>=20.8');
 
-  cache?.set(specifier, imported);
-  return imported;
-}
+export const SKIPPED = Symbol('SKIPPED');
 
 /**
- * Fancy "eval".  This is NOT for adding security, even though we're using
- * node:vm.  This is about providing:
+ * Fancy "eval".  This is NOT for adding security. This is about providing:
  *
  * - Good backtraces with file/line/column information correct, even when the
  *   code was inlined into a test.
@@ -42,111 +23,130 @@ async function linker(specifier, referencingModule, cache) {
  */
 export class Runner {
   #columnOffset;
+  #context;
   #dirname;
   #env;
   #filename;
   #lineOffset;
-  #sandbox;
+  #silent18;
+  #testFunction;
   #type;
+  #skipped;
 
   constructor({
-    filename = null, // Resolved
+    filename = null, // Fully-qualified
     lineOffset = 0,
     columnOffset = 0,
-    sandbox = null,
+    context = {},
     env = {},
-    type = null,
+    silent18 = false,
+    testFunction = 'test',
+    type = 'guess',
   } = {}) {
+    if (typeof filename !== 'string') {
+      throw new TypeError('filename not specified');
+    }
     this.#filename = filename;
     this.#dirname = path.dirname(filename);
     this.#env = env;
-    this.#sandbox = sandbox;
+    this.#context = context;
     this.#columnOffset = columnOffset;
     this.#lineOffset = lineOffset;
+    this.#silent18 = silent18;
+    this.#skipped = null;
     this.#type = type;
+    this.#testFunction = testFunction;
+  }
+
+  get skipped() {
+    return this.#skipped;
   }
 
   async parse(text, extra = {}) {
-    if (!this.#type) {
-      this.#type = await ModType.find(this.#filename);
+    const format = this.#type === 'guess' ?
+      await fromMem.guessModuleType(this.#filename) :
+      this.#type;
+
+    let columnOffset = this.#columnOffset;
+    if (format === 'es') {
+      if (this.#silent18 && !is20) {
+        this.#skipped = true;
+        return SKIPPED;
+      }
+
+      if (text.indexOf('export') === -1) {
+        text = PREFIX_MJS + text; // Most common case
+        columnOffset -= PREFIX_MJS_LEN;
+      }
+    } else if (text.indexOf('exports') === -1) {
+      text = PREFIX_CJS + text; // Most common case
+      columnOffset -= PREFIX_CJS_LEN;
     }
-    // Find package.json relative to test, decide whether we're commonjs or
-    // module.
-    const exports = {};
-    const context = {
-      ...mapObj(vmGlobals, g => (
-        (typeof globalThis[g] === 'function') ?
-          globalThis[g] :
-          {...globalThis[g]}
-      )),
-      require: createRequire(this.#filename),
-      exports,
-      module: {
-        exports,
+
+    return await fromMem(text, {
+      filename: this.#filename,
+      format,
+      env: this.#env,
+      lineOffset: this.#lineOffset,
+      columnOffset,
+      context: {
         filename: this.#filename,
         id: this.#filename,
         path: this.#dirname,
+        ...this.#context,
+        ...extra,
       },
-      __filename: this.#filename,
-      __dirname: this.#dirname,
-      ...this.#sandbox,
-      ...extra,
-    };
-    context.process.env = this.#env;
-    context.global = context;
-    context.globalThis = context;
-    vm.createContext(context);
+    });
+  }
 
-    let f = null;
-    const imports = new Map();
+  async run(text, extra = {}, ...params) {
+    let f = await this.parse(text, extra);
+    if (f === SKIPPED) {
+      return f;
+    }
 
-    if (this.#type === 'module') {
-      if (text.indexOf('export') === -1) {
-        text = `export default ${text}`; // Most common case
-      }
+    const possibleFunctions = [
+      this.#context.function,
+      this.#testFunction,
+      'default',
+    ];
 
-      const mod = new vm.SourceTextModule(text, {
-        context,
-        id: this.#filename,
-        lineOffset: this.#lineOffset,
-        columnOffset: this.#columnOffset,
+    let source = null;
+    if ('peggy' in this.#context) {
+      source = new GrammarLocation(this.#filename, {
+        line: extra.__line,
+        column: extra.__column,
+        offset: extra.__offset,
       });
+      const popts = {
+        grammarSource: source,
+      };
+      if (this.#context.peggy?.length > 0) {
+        popts.startRule = this.#context.peggy;
+      }
+      params[1] = popts;
+      possibleFunctions.splice(1, 0, 'parse');
+    }
 
-      await mod.link((specifier, referencingModule) => {
-        if (path.isAbsolute(specifier) || !/^\.\.?\//.test(specifier)) {
-          return linker(specifier, referencingModule, imports);
+    if (f && (typeof f !== 'function')) {
+      for (const possible of possibleFunctions) {
+        if (possible && (typeof f[possible] === 'function')) {
+          f = f[possible];
+          break;
         }
-        return linker(
-          path.resolve(path.dirname(this.#filename), specifier),
-          referencingModule,
-          imports
-        );
-      });
-      await mod.evaluate();
-      f = mod.namespace;
-    } else {
-      if (text.indexOf('exports') === -1) {
-        text = `module.exports= ${text}`; // Most common case
       }
-
-      const script = new vm.Script(text, {
-        filename: this.#filename,
-        lineOffset: this.#lineOffset,
-        columnOffset: this.#columnOffset,
-      });
-      f = script.runInContext(context);
     }
-    return f;
-  }
-
-  async run(text, extra = {}, ...params) {
-    let f = await this.parse(text, extra);
     if (typeof f !== 'function') {
-      f = f?.test ?? f?.default;
-      if (typeof f !== 'function') {
-        throw new Error('Must export function or {test}');
+      throw new Error('Must export function or {test}');
+    }
+
+    try {
+      return f(...params);
+    } catch (er) {
+      if (source && (typeof er.format === 'function')) {
+        er.message = er.format([{source, text: params[0]}]);
       }
+      throw er;
     }
-    return f(...params);
   }
 }

package/testFile.peg.js

@@ -1,8 +1,9 @@
-// Generated by Peggy 3.0.2.
+// @generated by Peggy 4.0.2.
 //
 // https://peggyjs.org/
 
 
+
 import { mapObj } from './utils.js'
 
 function peg$subclass(child, parent) {
@@ -248,17 +249,22 @@ function peg$parse(input, options) {
   var peg$e37 = peg$literalExpectation("\r", false);
 
   var peg$f0 = function(all) {
-    const vars = mapObj(all.filter(t => t && t.hasOwnProperty('name')),
-      ({name, ...rest}) => [name, rest])
-    return {
-      tests: all.filter(t => t && t.hasOwnProperty('expected')),
-      vars
-    }
+    return all.filter(t => t && t.hasOwnProperty('expected'));
   };
   var peg$f1 = function(env, name, value) {
-    value.name = name;
+    if (!value) {
+      const start = location().start;
+      value = {
+        value: undefined,
+        line: start.line,
+        column: start.column,
+      }
+    }
     value.env = Boolean(env);
-    return value;
+    vars = {
+      ...vars,
+      [name]: value
+    }
   };
   var peg$f2 = function(value) {
     const start = location().start;
@@ -266,7 +272,7 @@ function peg$parse(input, options) {
   };
   var peg$f3 = function(expected, inputs) {
     const start = location().start;
-    return { expected, inputs, line: start.line, column: start.column }
+    return { expected, inputs, vars, line: start.line, column: start.column }
   };
   var peg$f4 = function() { return options.EXCEPTION || "!" };
   var peg$f5 = function(info) { return info.join('') };
@@ -288,16 +294,16 @@ function peg$parse(input, options) {
   var peg$f21 = function() { return undefined };
   var peg$f22 = function() { return undefined};
   var peg$f23 = function() { return undefined };
-  var peg$currPos = 0;
-  var peg$savedPos = 0;
+  var peg$currPos = options.peg$currPos | 0;
+  var peg$savedPos = peg$currPos;
   var peg$posDetailsCache = [{ line: 1, column: 1 }];
-  var peg$maxFailPos = 0;
-  var peg$maxFailExpected = [];
-  var peg$silentFails = 0;
+  var peg$maxFailPos = peg$currPos;
+  var peg$maxFailExpected = options.peg$maxFailExpected || [];
+  var peg$silentFails = options.peg$silentFails | 0;
 
   var peg$result;
 
-  if ("startRule" in options) {
+  if (options.startRule) {
     if (!(options.startRule in peg$startRuleFunctions)) {
       throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
     }
@@ -372,9 +378,11 @@ function peg$parse(input, options) {
     if (details) {
       return details;
     } else {
-      p = pos - 1;
-      while (!peg$posDetailsCache[p]) {
-        p--;
+      if (pos >= peg$posDetailsCache.length) {
+        p = peg$posDetailsCache.length - 1;
+      } else {
+        p = pos;
+        while (!peg$posDetailsCache[--p]) {}
       }
 
       details = peg$posDetailsCache[p];
@@ -504,7 +512,7 @@ function peg$parse(input, options) {
   }
 
   function peg$parsevar() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
     s0 = peg$currPos;
     if (input.substr(peg$currPos, 2) === peg$c0) {
@@ -538,15 +546,20 @@ function peg$parse(input, options) {
         }
         if (s6 !== peg$FAILED) {
           s7 = peg$parse_();
-          s8 = peg$parseval();
-          if (s8 !== peg$FAILED) {
-            s9 = peg$parse_();
-            peg$savedPos = s0;
-            s0 = peg$f1(s2, s4, s8);
+          s8 = peg$currPos;
+          s9 = peg$parseval();
+          if (s9 !== peg$FAILED) {
+            s10 = peg$parse_();
+            s8 = s9;
           } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
+            peg$currPos = s8;
+            s8 = peg$FAILED;
           }
+          if (s8 === peg$FAILED) {
+            s8 = null;
+          }
+          peg$savedPos = s0;
+          s0 = peg$f1(s2, s4, s8);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -798,8 +811,8 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = [];
-        if (peg$r0.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r0.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
@@ -808,8 +821,8 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           while (s2 !== peg$FAILED) {
             s1.push(s2);
-            if (peg$r0.test(input.charAt(peg$currPos))) {
-              s2 = input.charAt(peg$currPos);
+            s2 = input.charAt(peg$currPos);
+            if (peg$r0.test(s2)) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
@@ -857,8 +870,8 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = [];
-        if (peg$r1.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r1.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
@@ -867,8 +880,8 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           while (s2 !== peg$FAILED) {
             s1.push(s2);
-            if (peg$r1.test(input.charAt(peg$currPos))) {
-              s2 = input.charAt(peg$currPos);
+            s2 = input.charAt(peg$currPos);
+            if (peg$r1.test(s2)) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
@@ -916,8 +929,8 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$currPos;
         s1 = [];
-        if (peg$r2.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r2.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
@@ -926,8 +939,8 @@ function peg$parse(input, options) {
         if (s2 !== peg$FAILED) {
           while (s2 !== peg$FAILED) {
             s1.push(s2);
-            if (peg$r2.test(input.charAt(peg$currPos))) {
-              s2 = input.charAt(peg$currPos);
+            s2 = input.charAt(peg$currPos);
+            if (peg$r2.test(s2)) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
@@ -967,8 +980,8 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = [];
-      if (peg$r3.test(input.charAt(peg$currPos))) {
-        s4 = input.charAt(peg$currPos);
+      s4 = input.charAt(peg$currPos);
+      if (peg$r3.test(s4)) {
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
@@ -977,8 +990,8 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         while (s4 !== peg$FAILED) {
           s3.push(s4);
-          if (peg$r3.test(input.charAt(peg$currPos))) {
-            s4 = input.charAt(peg$currPos);
+          s4 = input.charAt(peg$currPos);
+          if (peg$r3.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
@@ -1048,8 +1061,8 @@ function peg$parse(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       s1 = [];
-      if (peg$r4.test(input.charAt(peg$currPos))) {
-        s2 = input.charAt(peg$currPos);
+      s2 = input.charAt(peg$currPos);
+      if (peg$r4.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
@@ -1058,8 +1071,8 @@ function peg$parse(input, options) {
       if (s2 !== peg$FAILED) {
         while (s2 !== peg$FAILED) {
           s1.push(s2);
-          if (peg$r4.test(input.charAt(peg$currPos))) {
-            s2 = input.charAt(peg$currPos);
+          s2 = input.charAt(peg$currPos);
+          if (peg$r4.test(s2)) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
@@ -1201,7 +1214,7 @@ function peg$parse(input, options) {
   }
 
   function peg$parsecomment() {
-    var s0, s1, s2, s3, s4;
+    var s0, s1, s2, s3, s4, s5;
 
     s0 = peg$currPos;
     s1 = peg$parseWS();
@@ -1213,26 +1226,47 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
     if (s2 !== peg$FAILED) {
-      s3 = [];
-      if (peg$r5.test(input.charAt(peg$currPos))) {
-        s4 = input.charAt(peg$currPos);
+      s3 = peg$currPos;
+      peg$silentFails++;
+      if (input.charCodeAt(peg$currPos) === 33) {
+        s4 = peg$c1;
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        if (peg$silentFails === 0) { peg$fail(peg$e1); }
       }
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
-        if (peg$r5.test(input.charAt(peg$currPos))) {
-          s4 = input.charAt(peg$currPos);
+      peg$silentFails--;
+      if (s4 === peg$FAILED) {
+        s3 = undefined;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = [];
+        s5 = input.charAt(peg$currPos);
+        if (peg$r5.test(s5)) {
           peg$currPos++;
         } else {
-          s4 = peg$FAILED;
+          s5 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
+        while (s5 !== peg$FAILED) {
+          s4.push(s5);
+          s5 = input.charAt(peg$currPos);
+          if (peg$r5.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e28); }
+          }
+        }
+        peg$savedPos = s0;
+        s0 = peg$f20();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
-      peg$savedPos = s0;
-      s0 = peg$f20();
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1247,8 +1281,8 @@ function peg$parse(input, options) {
     peg$silentFails++;
     s0 = peg$currPos;
     s1 = [];
-    if (peg$r6.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
+    s2 = input.charAt(peg$currPos);
+    if (peg$r6.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
@@ -1256,8 +1290,8 @@ function peg$parse(input, options) {
     }
     while (s2 !== peg$FAILED) {
       s1.push(s2);
-      if (peg$r6.test(input.charAt(peg$currPos))) {
-        s2 = input.charAt(peg$currPos);
+      s2 = input.charAt(peg$currPos);
+      if (peg$r6.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
@@ -1280,8 +1314,8 @@ function peg$parse(input, options) {
     peg$silentFails++;
     s0 = peg$currPos;
     s1 = [];
-    if (peg$r7.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
+    s2 = input.charAt(peg$currPos);
+    if (peg$r7.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
@@ -1289,8 +1323,8 @@ function peg$parse(input, options) {
     }
     while (s2 !== peg$FAILED) {
       s1.push(s2);
-      if (peg$r7.test(input.charAt(peg$currPos))) {
-        s2 = input.charAt(peg$currPos);
+      s2 = input.charAt(peg$currPos);
+      if (peg$r7.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
@@ -1313,8 +1347,8 @@ function peg$parse(input, options) {
     peg$silentFails++;
     s0 = peg$currPos;
     s1 = [];
-    if (peg$r6.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
+    s2 = input.charAt(peg$currPos);
+    if (peg$r6.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
@@ -1323,8 +1357,8 @@ function peg$parse(input, options) {
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
         s1.push(s2);
-        if (peg$r6.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r6.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
@@ -1386,8 +1420,20 @@ function peg$parse(input, options) {
     return s0;
   }
 
+
+  let vars = {};
+
   peg$result = peg$startRuleFunction();
 
+  if (options.peg$library) {
+    return /** @type {any} */ ({
+      peg$result,
+      peg$currPos,
+      peg$FAILED,
+      peg$maxFailExpected,
+      peg$maxFailPos
+    });
+  }
   if (peg$result !== peg$FAILED && peg$currPos === input.length) {
     return peg$result;
   } else {
@@ -1405,8 +1451,12 @@ function peg$parse(input, options) {
   }
 }
 
+const peg$allowedStartRules = [
+  "start"
+];
+
 export {
+  peg$allowedStartRules as StartRules,
   peg$SyntaxError as SyntaxError,
-
   peg$parse as parse
 };

package/testFile.peggy

@@ -0,0 +1,111 @@
+{{
+import { mapObj } from './utils.js'
+}}
+
+{
+  let vars = {};
+}
+start
+  = all:(WS @line? _)|.., EOL| {
+    return all.filter(t => t && t.hasOwnProperty('expected'));
+  }
+
+line
+  = var
+  / comment
+  / test
+  / '' // hack
+
+var
+  = '#!' env:"!"? _ name:chunk _ ':' _ value:(@val _)? {
+    if (!value) {
+      const start = location().start;
+      value = {
+        value: undefined,
+        line: start.line,
+        column: start.column,
+      }
+    }
+    value.env = Boolean(env);
+    vars = {
+      ...vars,
+      [name]: value
+    }
+  }
+
+val
+  = value:chunk {
+    const start = location().start;
+    return { value, line: start.line, column: start.column}
+  }
+
+test
+  = expected:results inputs:(LWS @chunk)* comment? {
+    const start = location().start;
+    return { expected, inputs, vars, line: start.line, column: start.column }
+  }
+
+results
+  = "!" { return options.EXCEPTION || "!" }
+  / chunk
+
+chunk
+  = quoted
+  / hex
+  / word
+
+quoted
+  = '"' info:dqchar* '"' { return info.join('') }
+  / "'" info:sqchar* "'" { return info.join('') }
+  / "`" info:bqchar* "`" { return info.join('') }
+
+dqchar "characters that go inside double quotes, including escaped dquotes"
+  = '\\"' { return '"' }
+  / qchar
+  / $[^\\"]+
+
+sqchar "characters that go inside single quotes, including escaped squotes"
+  = "\\'" { return "'" }
+  / qchar
+  / $[^\\']+
+
+bqchar "characters that go inside back quotes, including escaped bquotes"
+  = "\\`" { return "`" }
+  / qchar
+  / $[^\\`]+
+
+hex
+  = '0x' hx:$[a-fA-F0-9]+ { return '0x' + hx.toLowerCase(hx) }
+
+word
+  = chars:wchar+ { return chars.join('') }
+
+wchar "words can contain quoted bits"
+  = qchar+
+  / $[^ #:'"\t\r\n]+
+
+qchar "other quoted characters, as needed"
+  = '\\\\' { return '\\' }
+  / '\\r' { return '\r' }
+  / '\\n' { return '\n' }
+  / '\\t' { return '\t' }
+  / '\\#' { return '#' }
+  / '\\:' { return ':' }
+  / '\\ ' { return ' ' }
+
+comment
+  = WS "#" !"!" [^\r\n]* { return undefined }
+
+_ "optional whitespace"
+  = [ \t]* { return undefined }
+
+WS "optional whitespace, including newlines"
+  = [ \t\r\n]* { return undefined}
+
+LWS "required whitespace"
+  = [ \t]+ { return undefined }
+
+EOL "End of line"
+  = '\n'
+  / '\r\n'
+  / '\r'

package/vendor/peggy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010-2024 The Peggy AUTHORS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/peggy/grammar-location.cjs

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * When used as a grammarSource, allows grammars embedded in larger files to
+ * specify their offset.  The start location is the first character in the
+ * grammar.  The first line is often moved to the right by some number of
+ * columns, but subsequent lines all start at the first column.
+ */
+class GrammarLocation {
+  /**
+   * Create an instance.
+   *
+   * @param {any} source The original grammarSource.  Should be a string or
+   *   have a toString() method.
+   * @param {import("./peg").Location} start The starting offset for the
+   *   grammar in the larger file.
+   */
+  constructor(source, start) {
+    this.source = source;
+    this.start = start;
+  }
+
+  /**
+   * Coerce to a string.
+   *
+   * @returns {string} The source, stringified.
+   */
+  toString() {
+    return String(this.source);
+  }
+
+  /**
+   * Return a new Location offset from the given location by the start of the
+   * grammar.
+   *
+   * @param {import("./peg").Location} loc The location as if the start of the
+   *   grammar was the start of the file.
+   * @returns {import("./peg").Location} The offset location.
+   */
+  offset(loc) {
+    return {
+      line: loc.line + this.start.line - 1,
+      column: (loc.line === 1)
+        ? loc.column + this.start.column - 1
+        : loc.column,
+      offset: loc.offset + this.start.offset,
+    };
+  }
+
+  /**
+   * If the range has a grammarSource that is a GrammarLocation, offset the
+   * start of that range by the GrammarLocation.
+   *
+   * @param {import("./peg").LocationRange} range The range to extract from.
+   * @returns {import("./peg").Location} The offset start if possible, or the
+   *   original start.
+   */
+  static offsetStart(range) {
+    if (range.source && (typeof range.source.offset === "function")) {
+      return range.source.offset(range.start);
+    }
+    return range.start;
+  }
+
+  /**
+   * If the range has a grammarSource that is a GrammarLocation, offset the
+   * end of that range by the GrammarLocation.
+   *
+   * @param {import("./peg").LocationRange} range The range to extract from.
+   * @returns {import("./peg").Location} The offset end if possible, or the
+   *   original end.
+   */
+  static offsetEnd(range) {
+    if (range.source && (typeof range.source.offset === "function")) {
+      return range.source.offset(range.end);
+    }
+    return range.end;
+  }
+}
+
+module.exports = GrammarLocation;

package/vendor/peggy/rationale.md

@@ -0,0 +1,4 @@
+I don't want to take a runtime dependency on Peggy just for the
+GrammarLocation class.  If this works, I may refactor that into
+@peggyjs/grammar-location, but I'm worried about making that change completely
+transparent to Peggy users.

package/modtype.js

@@ -1,60 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-export class ModType {
-  static #cache = new Map(); // Filename => 'commonjs', 'module', 'unknown'
-
-  static async #readPkg(dir) {
-    const pkg = path.join(dir, 'package.json');
-    try {
-      const {type = 'commonjs'} = JSON.parse(await fs.readFile(pkg, 'utf8'));
-      return type;
-    } catch {
-      return undefined;
-    }
-  }
-
-  static async find(name, dir = false, root = undefined) {
-    const prev = this.#cache.get(name);
-    if (prev) {
-      return prev;
-    }
-    let res = 'unknown';
-
-    if (!root) {
-      const p = path.parse(name);
-      switch (p.ext) {
-        case '.mjs':
-          res = 'module';
-          this.#cache.set(name, res);
-          return res;
-        case '.cjs':
-          res = 'commonjs';
-          this.#cache.set(name, res);
-          return res;
-      }
-      ({root} = p);
-      try {
-        // Avoid problems if an existing directory name is passed in originally.
-        dir = (await fs.stat(name)).isDirectory();
-      } catch {
-        // File doesn't exist.  Safe to assume it's file-ish, keep dir = false.
-      }
-    }
-
-    if (name !== root) { // Never go all the way to the root directory.
-      const t = dir ? await this.#readPkg(name) : undefined;
-      res = t ?? this.find(path.dirname(name), true, root);
-    }
-    this.#cache.set(name, res);
-    return res;
-  }
-
-  static clear() {
-    this.#cache.clear();
-  }
-
-  static get cacheSize() {
-    return this.#cache.size;
-  }
-}