@descent-vtt/spec-harness 0.0.0 → 0.1.0

package/dist/vendor/spec-core/path/index.js

@@ -0,0 +1,2 @@
+export { basename, dirname, extname, isAbsolutePath, isInside, isRelativeReference, joinPosix, normalise, normalisePosix, relativePath, resolveInside, segments, splitReference, toPosix, } from './posix.js';
+//# sourceMappingURL=index.js.map

package/dist/vendor/spec-core/path/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/vendor/spec-core/path/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,OAAO,EACP,OAAO,EACP,cAAc,EACd,QAAQ,EACR,mBAAmB,EACnB,SAAS,EACT,SAAS,EACT,cAAc,EACd,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,cAAc,EACd,OAAO,GACR,MAAM,YAAY,CAAC","sourcesContent":["export {\n  basename,\n  dirname,\n  extname,\n  isAbsolutePath,\n  isInside,\n  isRelativeReference,\n  joinPosix,\n  normalise,\n  normalisePosix,\n  relativePath,\n  resolveInside,\n  segments,\n  splitReference,\n  toPosix,\n} from './posix.js';\n"]}

package/dist/vendor/spec-core/path/posix.d.ts

@@ -0,0 +1,83 @@
+/**
+ * POSIX path arithmetic, independent of the host.
+ *
+ * Every path the spec-* tools compare is a repository-relative POSIX path, on
+ * Windows as much as on Linux. A finding, a graph node or a collision witness
+ * that spelled a path one way on one machine and another way on the next would
+ * make the same repository give two answers. Node's `path` module takes the
+ * host's side, so none of this uses it.
+ *
+ * Two families of function live here, and the difference matters:
+ *
+ * - Repository paths (`normalise`, `resolveInside`, `isInside`) may not leave
+ *   the repository. A `..` that climbs past the root is an answer of its own -
+ *   `null` - never a path silently clamped to the root.
+ * - General POSIX paths (`normalisePosix`, `joinPosix`) keep leading `..` and a
+ *   leading `/`, for callers that resolve against something other than a
+ *   repository root.
+ */
+/** A host path in POSIX form: every backslash becomes a slash. */
+export declare function toPosix(value: string): string;
+/**
+ * Whether a path names a place outright rather than relative to one.
+ *
+ * Both platforms' spellings, whichever this runs on: one repository is read on
+ * a Windows checkout and in Linux CI, so a path is absolute where it was
+ * written. `C:docs` counts - it is relative to a drive, not to a root, and
+ * prefixing it with a root would name a third place.
+ */
+export declare function isAbsolutePath(value: string): boolean;
+/**
+ * Whether a link destination is a path relative to the file holding it: not
+ * empty, not a fragment, not rooted, and not a URL or `mailto:`.
+ *
+ * A Windows drive path has a one-letter "scheme" and is excluded with the rest,
+ * which is right: it is not relative to anything in the repository.
+ */
+export declare function isRelativeReference(target: string): boolean;
+/** The path part of a link destination, and the `?query` or `#fragment` after it. */
+export declare function splitReference(target: string): {
+    readonly path: string;
+    readonly suffix: string;
+};
+/** The non-empty segments of a POSIX path, without `.`. */
+export declare function segments(value: string): string[];
+/**
+ * A repository path in canonical form - no `.`, no empty segments, no leading
+ * or trailing slash, `..` resolved - or `null` when the path climbs out of the
+ * repository or is absolute.
+ *
+ * Backslashes are separators here: a path typed on Windows is the same path.
+ */
+export declare function normalise(value: string): string | null;
+/**
+ * A relative path resolved against a repository directory, or `null` when it
+ * climbs out of the repository.
+ */
+export declare function resolveInside(directory: string, relative: string): string | null;
+/** Whether a canonical repository path is the directory itself or lies beneath it. */
+export declare function isInside(path: string, directory: string): boolean;
+/** The directory holding a path, or `''` at the root. */
+export declare function dirname(value: string): string;
+/** The last segment of a path. */
+export declare function basename(value: string): string;
+/**
+ * The extension of the last segment, dot included and lower-cased, or `''`.
+ *
+ * A leading dot is a hidden name, not an extension: `.github` has none, and
+ * `.eslintrc.json` has `.json`.
+ */
+export declare function extname(value: string): string;
+/**
+ * The relative path from a repository directory to a repository path: what a
+ * link written in that directory must say to reach it. `.` for the directory
+ * itself.
+ */
+export declare function relativePath(fromDirectory: string, to: string): string;
+/**
+ * Removes `.` and `..` segments from a general POSIX path. Leading `..` of a
+ * relative path are kept; a `..` above `/` is dropped, as the kernel does.
+ */
+export declare function normalisePosix(value: string): string;
+/** Joins general POSIX paths and normalises the result. */
+export declare function joinPosix(...parts: readonly string[]): string;

package/dist/vendor/spec-core/path/posix.js

@@ -0,0 +1,150 @@
+/**
+ * POSIX path arithmetic, independent of the host.
+ *
+ * Every path the spec-* tools compare is a repository-relative POSIX path, on
+ * Windows as much as on Linux. A finding, a graph node or a collision witness
+ * that spelled a path one way on one machine and another way on the next would
+ * make the same repository give two answers. Node's `path` module takes the
+ * host's side, so none of this uses it.
+ *
+ * Two families of function live here, and the difference matters:
+ *
+ * - Repository paths (`normalise`, `resolveInside`, `isInside`) may not leave
+ *   the repository. A `..` that climbs past the root is an answer of its own -
+ *   `null` - never a path silently clamped to the root.
+ * - General POSIX paths (`normalisePosix`, `joinPosix`) keep leading `..` and a
+ *   leading `/`, for callers that resolve against something other than a
+ *   repository root.
+ */
+const ABSOLUTE = /^(?:[/\\]|[A-Za-z]:)/;
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+/** A host path in POSIX form: every backslash becomes a slash. */
+export function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+/**
+ * Whether a path names a place outright rather than relative to one.
+ *
+ * Both platforms' spellings, whichever this runs on: one repository is read on
+ * a Windows checkout and in Linux CI, so a path is absolute where it was
+ * written. `C:docs` counts - it is relative to a drive, not to a root, and
+ * prefixing it with a root would name a third place.
+ */
+export function isAbsolutePath(value) {
+    return ABSOLUTE.test(value);
+}
+/**
+ * Whether a link destination is a path relative to the file holding it: not
+ * empty, not a fragment, not rooted, and not a URL or `mailto:`.
+ *
+ * A Windows drive path has a one-letter "scheme" and is excluded with the rest,
+ * which is right: it is not relative to anything in the repository.
+ */
+export function isRelativeReference(target) {
+    if (target === '' || target.startsWith('#') || isAbsolutePath(target))
+        return false;
+    return !SCHEME.test(target);
+}
+/** The path part of a link destination, and the `?query` or `#fragment` after it. */
+export function splitReference(target) {
+    const cut = target.search(/[?#]/);
+    return cut < 0 ? { path: target, suffix: '' } : { path: target.slice(0, cut), suffix: target.slice(cut) };
+}
+/** The non-empty segments of a POSIX path, without `.`. */
+export function segments(value) {
+    return value.split('/').filter((part) => part !== '' && part !== '.');
+}
+/**
+ * A repository path in canonical form - no `.`, no empty segments, no leading
+ * or trailing slash, `..` resolved - or `null` when the path climbs out of the
+ * repository or is absolute.
+ *
+ * Backslashes are separators here: a path typed on Windows is the same path.
+ */
+export function normalise(value) {
+    const posix = toPosix(value);
+    if (isAbsolutePath(posix))
+        return null;
+    return resolveInside('', posix);
+}
+/**
+ * A relative path resolved against a repository directory, or `null` when it
+ * climbs out of the repository.
+ */
+export function resolveInside(directory, relative) {
+    const out = segments(directory);
+    for (const part of segments(relative)) {
+        if (part !== '..') {
+            out.push(part);
+            continue;
+        }
+        if (out.length === 0)
+            return null;
+        out.pop();
+    }
+    return out.join('/');
+}
+/** Whether a canonical repository path is the directory itself or lies beneath it. */
+export function isInside(path, directory) {
+    return directory === '' || path === directory || path.startsWith(`${directory}/`);
+}
+/** The directory holding a path, or `''` at the root. */
+export function dirname(value) {
+    const slash = value.lastIndexOf('/');
+    return slash < 0 ? '' : value.slice(0, slash);
+}
+/** The last segment of a path. */
+export function basename(value) {
+    return value.slice(value.lastIndexOf('/') + 1);
+}
+/**
+ * The extension of the last segment, dot included and lower-cased, or `''`.
+ *
+ * A leading dot is a hidden name, not an extension: `.github` has none, and
+ * `.eslintrc.json` has `.json`.
+ */
+export function extname(value) {
+    const base = basename(value);
+    const dot = base.lastIndexOf('.');
+    return dot <= 0 ? '' : base.slice(dot).toLowerCase();
+}
+/**
+ * The relative path from a repository directory to a repository path: what a
+ * link written in that directory must say to reach it. `.` for the directory
+ * itself.
+ */
+export function relativePath(fromDirectory, to) {
+    const from = segments(fromDirectory);
+    const target = segments(to);
+    let common = 0;
+    while (common < from.length && common < target.length && from[common] === target[common])
+        common += 1;
+    const up = from.slice(common).map(() => '..');
+    const joined = [...up, ...target.slice(common)].join('/');
+    return joined === '' ? '.' : joined;
+}
+/**
+ * Removes `.` and `..` segments from a general POSIX path. Leading `..` of a
+ * relative path are kept; a `..` above `/` is dropped, as the kernel does.
+ */
+export function normalisePosix(value) {
+    const absolute = value.startsWith('/');
+    const out = [];
+    for (const part of segments(value)) {
+        if (part !== '..') {
+            out.push(part);
+            continue;
+        }
+        if (out.length > 0 && out[out.length - 1] !== '..')
+            out.pop();
+        else if (!absolute)
+            out.push('..');
+    }
+    const joined = out.join('/');
+    return absolute ? `/${joined}` : joined;
+}
+/** Joins general POSIX paths and normalises the result. */
+export function joinPosix(...parts) {
+    return normalisePosix(parts.filter((part) => part.length > 0).join('/'));
+}
+//# sourceMappingURL=posix.js.map

package/dist/vendor/spec-core/path/posix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"posix.js","sourceRoot":"","sources":["../../../../src/vendor/spec-core/path/posix.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * POSIX path arithmetic, independent of the host.\n *\n * Every path the spec-* tools compare is a repository-relative POSIX path, on\n * Windows as much as on Linux. A finding, a graph node or a collision witness\n * that spelled a path one way on one machine and another way on the next would\n * make the same repository give two answers. Node's `path` module takes the\n * host's side, so none of this uses it.\n *\n * Two families of function live here, and the difference matters:\n *\n * - Repository paths (`normalise`, `resolveInside`, `isInside`) may not leave\n *   the repository. A `..` that climbs past the root is an answer of its own -\n *   `null` - never a path silently clamped to the root.\n * - General POSIX paths (`normalisePosix`, `joinPosix`) keep leading `..` and a\n *   leading `/`, for callers that resolve against something other than a\n *   repository root.\n */\n\nconst ABSOLUTE = /^(?:[/\\\\]|[A-Za-z]:)/;\nconst SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;\n\n/** A host path in POSIX form: every backslash becomes a slash. */\nexport function toPosix(value: string): string {\n  return value.replace(/\\\\/g, '/');\n}\n\n/**\n * Whether a path names a place outright rather than relative to one.\n *\n * Both platforms' spellings, whichever this runs on: one repository is read on\n * a Windows checkout and in Linux CI, so a path is absolute where it was\n * written. `C:docs` counts - it is relative to a drive, not to a root, and\n * prefixing it with a root would name a third place.\n */\nexport function isAbsolutePath(value: string): boolean {\n  return ABSOLUTE.test(value);\n}\n\n/**\n * Whether a link destination is a path relative to the file holding it: not\n * empty, not a fragment, not rooted, and not a URL or `mailto:`.\n *\n * A Windows drive path has a one-letter \"scheme\" and is excluded with the rest,\n * which is right: it is not relative to anything in the repository.\n */\nexport function isRelativeReference(target: string): boolean {\n  if (target === '' || target.startsWith('#') || isAbsolutePath(target)) return false;\n  return !SCHEME.test(target);\n}\n\n/** The path part of a link destination, and the `?query` or `#fragment` after it. */\nexport function splitReference(target: string): { readonly path: string; readonly suffix: string } {\n  const cut = target.search(/[?#]/);\n  return cut < 0 ? { path: target, suffix: '' } : { path: target.slice(0, cut), suffix: target.slice(cut) };\n}\n\n/** The non-empty segments of a POSIX path, without `.`. */\nexport function segments(value: string): string[] {\n  return value.split('/').filter((part) => part !== '' && part !== '.');\n}\n\n/**\n * A repository path in canonical form - no `.`, no empty segments, no leading\n * or trailing slash, `..` resolved - or `null` when the path climbs out of the\n * repository or is absolute.\n *\n * Backslashes are separators here: a path typed on Windows is the same path.\n */\nexport function normalise(value: string): string | null {\n  const posix = toPosix(value);\n  if (isAbsolutePath(posix)) return null;\n  return resolveInside('', posix);\n}\n\n/**\n * A relative path resolved against a repository directory, or `null` when it\n * climbs out of the repository.\n */\nexport function resolveInside(directory: string, relative: string): string | null {\n  const out = segments(directory);\n  for (const part of segments(relative)) {\n    if (part !== '..') {\n      out.push(part);\n      continue;\n    }\n    if (out.length === 0) return null;\n    out.pop();\n  }\n  return out.join('/');\n}\n\n/** Whether a canonical repository path is the directory itself or lies beneath it. */\nexport function isInside(path: string, directory: string): boolean {\n  return directory === '' || path === directory || path.startsWith(`${directory}/`);\n}\n\n/** The directory holding a path, or `''` at the root. */\nexport function dirname(value: string): string {\n  const slash = value.lastIndexOf('/');\n  return slash < 0 ? '' : value.slice(0, slash);\n}\n\n/** The last segment of a path. */\nexport function basename(value: string): string {\n  return value.slice(value.lastIndexOf('/') + 1);\n}\n\n/**\n * The extension of the last segment, dot included and lower-cased, or `''`.\n *\n * A leading dot is a hidden name, not an extension: `.github` has none, and\n * `.eslintrc.json` has `.json`.\n */\nexport function extname(value: string): string {\n  const base = basename(value);\n  const dot = base.lastIndexOf('.');\n  return dot <= 0 ? '' : base.slice(dot).toLowerCase();\n}\n\n/**\n * The relative path from a repository directory to a repository path: what a\n * link written in that directory must say to reach it. `.` for the directory\n * itself.\n */\nexport function relativePath(fromDirectory: string, to: string): string {\n  const from = segments(fromDirectory);\n  const target = segments(to);\n  let common = 0;\n  while (common < from.length && common < target.length && from[common] === target[common]) common += 1;\n  const up = from.slice(common).map(() => '..');\n  const joined = [...up, ...target.slice(common)].join('/');\n  return joined === '' ? '.' : joined;\n}\n\n/**\n * Removes `.` and `..` segments from a general POSIX path. Leading `..` of a\n * relative path are kept; a `..` above `/` is dropped, as the kernel does.\n */\nexport function normalisePosix(value: string): string {\n  const absolute = value.startsWith('/');\n  const out: string[] = [];\n  for (const part of segments(value)) {\n    if (part !== '..') {\n      out.push(part);\n      continue;\n    }\n    if (out.length > 0 && out[out.length - 1] !== '..') out.pop();\n    else if (!absolute) out.push('..');\n  }\n  const joined = out.join('/');\n  return absolute ? `/${joined}` : joined;\n}\n\n/** Joins general POSIX paths and normalises the result. */\nexport function joinPosix(...parts: readonly string[]): string {\n  return normalisePosix(parts.filter((part) => part.length > 0).join('/'));\n}\n"]}

package/dist/vendor/spec-core/pattern/automaton.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Non-deterministic finite automata over code points: built by Thompson's
+ * construction, run by keeping a set of live states, and searched for a
+ * shortest string several of them accept and several others refuse.
+ *
+ * Why an automaton rather than a `RegExp`: a glob such as `*-*-*-*-*-*x`
+ * handed to a backtracking engine tries every way of dividing a long name
+ * between its stars, and one spec-* tool measured 28 seconds for one path. A
+ * set of live states visits each state at most once per character, so a match
+ * costs at most the pattern's size times the path's length, whatever the
+ * pattern says.
+ *
+ * Why the same automaton for the witness: whether two scopes can name the same
+ * file, and whether one lies wholly inside another, are questions about the
+ * languages the patterns accept. Asked of the automata that do the matching,
+ * the answers cannot drift from what matching does.
+ */
+import { type CharSet } from './charset.js';
+/** A compiled automaton. Immutable once built, and safe to share. */
+export interface Automaton {
+    readonly kinds: Uint8Array;
+    /** A CHAR's next state, a SPLIT's first branch, a JUMP's target. */
+    readonly first: Int32Array;
+    /** A SPLIT's second branch. */
+    readonly second: Int32Array;
+    /** A CHAR's set; unused for the others. */
+    readonly sets: readonly (CharSet | null)[];
+    readonly start: number;
+    readonly caseSensitive: boolean;
+}
+/** A piece of an automaton under construction: where it starts, and the arrows still unaimed. */
+export interface Fragment {
+    readonly start: number;
+    readonly holes: readonly Hole[];
+}
+interface Hole {
+    readonly state: number;
+    readonly slot: 1 | 2;
+}
+/**
+ * Ceiling on the size of one automaton.
+ *
+ * Brace alternatives are compiled side by side, so a pattern's size is the
+ * sum of its alternatives'. Far above anything a scope list says; it exists
+ * so that a pathological pattern is refused while compiling rather than
+ * matched slowly.
+ */
+export declare const MAX_STATES = 65536;
+export declare class AutomatonTooLarge extends Error {
+    constructor();
+}
+/** Thompson's construction, one fragment at a time. */
+export declare class Builder {
+    private readonly kinds;
+    private readonly first;
+    private readonly second;
+    private readonly sets;
+    private add;
+    private patch;
+    /** One character from a set. */
+    char(set: CharSet): Fragment;
+    /** The empty string. */
+    empty(): Fragment;
+    /** Each fragment after the one before it. */
+    sequence(parts: readonly Fragment[]): Fragment;
+    /** Any one of the fragments. */
+    either(options: readonly Fragment[]): Fragment;
+    /** Zero or more of a fragment. */
+    star(body: Fragment): Fragment;
+    /** One or more of a fragment. */
+    plus(body: Fragment): Fragment;
+    /** Zero or one of a fragment. */
+    optional(body: Fragment): Fragment;
+    /** Closes the automaton: every unaimed arrow reaches acceptance. */
+    finish(body: Fragment, caseSensitive: boolean): Automaton;
+}
+/**
+ * A reusable matcher over one automaton.
+ *
+ * Holds its buffers between subjects; it is not reentrant, and nothing needs
+ * it to be - matching calls out to nothing.
+ */
+export declare class Matcher {
+    private readonly automaton;
+    private readonly visited;
+    private stamp;
+    private readonly stack;
+    private live;
+    private next;
+    constructor(automaton: Automaton);
+    /** Whether the automaton accepts the whole of a subject. */
+    test(subject: string): boolean;
+}
+/** The answer to a witness search. */
+export type Witness = {
+    readonly kind: 'found';
+    readonly path: string;
+} | {
+    readonly kind: 'none';
+}
+/** The search met its budget before deciding. Rare, and never a guess either way. */
+ | {
+    readonly kind: 'undecided';
+};
+/**
+ * How many distinct search states a witness search may visit. The search is
+ * polynomial in the sizes of the automata it must satisfy and, for the ones
+ * it must avoid, bounded by the subsets of their states it reaches; scope
+ * patterns reach a handful. The bound turns a pathological input into an
+ * `undecided` rather than a hang.
+ */
+export declare const WITNESS_BUDGET = 200000;
+/**
+ * A shortest path every automaton in `include` accepts and none in `exclude`
+ * does, spelled with readable characters where there is a choice.
+ *
+ * Breadth-first over the product of one live state per included automaton
+ * (existential: some run of each must accept) and the whole live set per
+ * excluded one (universal: no run of it may). Characters are tried at the
+ * boundary points of every set in play, which meets every combination of
+ * answers those sets can give, so the search is exact: `none` means no path
+ * exists, not that none was found. The first path reached is a shortest one.
+ *
+ * Case-sensitive automata only. Every scope comparison in the family is
+ * case-sensitive, and folding case exactly would need every set's closure
+ * under case mapping.
+ */
+export declare function findWitness(include: readonly Automaton[], exclude?: readonly Automaton[], budget?: number): Witness;
+export {};