unexpectedly 1.0.0 → 3.0.3

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/version.js

@@ -0,0 +1,4 @@
+// Generated by package-extract v3.1.3
+// Do not modify by hand.
+
+export const version = '3.0.3';

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;
-  }
-}