@descent-vtt/spec-guard 0.10.3 → 0.12.0

package/dist/vendor/spec-core/pattern/automaton.js

@@ -0,0 +1,340 @@
+/**
+ * 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 { accepts, acceptsIgnoringCase, boundaryPoints, DOT, SLASH } from './charset.js';
+const CHAR = 0;
+const SPLIT = 1;
+const JUMP = 2;
+const MATCH = 3;
+/**
+ * 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 const MAX_STATES = 65_536;
+export class AutomatonTooLarge extends Error {
+    constructor() {
+        super(`the pattern compiles to more than ${MAX_STATES} states`);
+        this.name = 'AutomatonTooLarge';
+    }
+}
+/** Thompson's construction, one fragment at a time. */
+export class Builder {
+    kinds = [];
+    first = [];
+    second = [];
+    sets = [];
+    add(kind, set, first, second) {
+        if (this.kinds.length >= MAX_STATES)
+            throw new AutomatonTooLarge();
+        this.kinds.push(kind);
+        this.first.push(first);
+        this.second.push(second);
+        this.sets.push(set);
+        return this.kinds.length - 1;
+    }
+    patch(holes, target) {
+        for (const hole of holes) {
+            if (hole.slot === 1)
+                this.first[hole.state] = target;
+            else
+                this.second[hole.state] = target;
+        }
+    }
+    /** One character from a set. */
+    char(set) {
+        const state = this.add(CHAR, set, -1, -1);
+        return { start: state, holes: [{ state, slot: 1 }] };
+    }
+    /** The empty string. */
+    empty() {
+        const state = this.add(JUMP, null, -1, -1);
+        return { start: state, holes: [{ state, slot: 1 }] };
+    }
+    /** Each fragment after the one before it. */
+    sequence(parts) {
+        if (parts.length === 0)
+            return this.empty();
+        let current = parts[0];
+        for (let i = 1; i < parts.length; i += 1) {
+            const next = parts[i];
+            this.patch(current.holes, next.start);
+            current = { start: current.start, holes: next.holes };
+        }
+        return current;
+    }
+    /** Any one of the fragments. */
+    either(options) {
+        if (options.length === 0)
+            throw new Error('an alternation needs at least one option');
+        let current = options[options.length - 1];
+        for (let i = options.length - 2; i >= 0; i -= 1) {
+            const option = options[i];
+            const split = this.add(SPLIT, null, option.start, current.start);
+            current = { start: split, holes: [...option.holes, ...current.holes] };
+        }
+        return current;
+    }
+    /** Zero or more of a fragment. */
+    star(body) {
+        const split = this.add(SPLIT, null, body.start, -1);
+        this.patch(body.holes, split);
+        return { start: split, holes: [{ state: split, slot: 2 }] };
+    }
+    /** One or more of a fragment. */
+    plus(body) {
+        const split = this.add(SPLIT, null, body.start, -1);
+        this.patch(body.holes, split);
+        return { start: body.start, holes: [{ state: split, slot: 2 }] };
+    }
+    /** Zero or one of a fragment. */
+    optional(body) {
+        const empty = this.empty();
+        return this.either([body, empty]);
+    }
+    /** Closes the automaton: every unaimed arrow reaches acceptance. */
+    finish(body, caseSensitive) {
+        const match = this.add(MATCH, null, -1, -1);
+        this.patch(body.holes, match);
+        return {
+            kinds: Uint8Array.from(this.kinds),
+            first: Int32Array.from(this.first),
+            second: Int32Array.from(this.second),
+            sets: [...this.sets],
+            start: body.start,
+            caseSensitive,
+        };
+    }
+}
+/**
+ * Follows every empty arrow out of the states on a stack, appending each
+ * CHAR or MATCH state reached to `into`. `visited[state] === stamp` marks a
+ * state already taken this round, which is what bounds the work.
+ */
+function close(automaton, stack, visited, stamp, into) {
+    const { kinds, first, second } = automaton;
+    while (stack.length > 0) {
+        const state = stack.pop();
+        if (visited[state] === stamp)
+            continue;
+        visited[state] = stamp;
+        switch (kinds[state]) {
+            case SPLIT:
+                stack.push(second[state], first[state]);
+                break;
+            case JUMP:
+                stack.push(first[state]);
+                break;
+            default:
+                into.push(state);
+        }
+    }
+}
+/**
+ * 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 class Matcher {
+    automaton;
+    visited;
+    stamp = 0;
+    stack = [];
+    live = [];
+    next = [];
+    constructor(automaton) {
+        this.automaton = automaton;
+        this.visited = new Int32Array(automaton.kinds.length).fill(-1);
+    }
+    /** Whether the automaton accepts the whole of a subject. */
+    test(subject) {
+        const { automaton } = this;
+        const accept = automaton.caseSensitive ? accepts : acceptsIgnoringCase;
+        this.live.length = 0;
+        this.stack.length = 0;
+        this.stack.push(automaton.start);
+        this.stamp += 1;
+        close(automaton, this.stack, this.visited, this.stamp, this.live);
+        for (let i = 0; i < subject.length; i += 1) {
+            const point = subject.codePointAt(i);
+            if (point > 0xffff)
+                i += 1;
+            this.next.length = 0;
+            this.stamp += 1;
+            for (const state of this.live) {
+                if (automaton.kinds[state] !== CHAR)
+                    continue;
+                if (!accept(automaton.sets[state], point))
+                    continue;
+                this.stack.push(automaton.first[state]);
+                close(automaton, this.stack, this.visited, this.stamp, this.next);
+            }
+            if (this.next.length === 0)
+                return false;
+            const spent = this.live;
+            this.live = this.next;
+            this.next = spent;
+        }
+        return this.live.some((state) => automaton.kinds[state] === MATCH);
+    }
+}
+/**
+ * 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 const WITNESS_BUDGET = 200_000;
+/**
+ * Path validity as a four-state machine: at the start of a segment, inside a
+ * segment reading `.` or `..` so far, or inside a segment that is a name. A
+ * witness must end inside a name, and a `/` is only legal after one, so no
+ * witness has an empty segment, a `.` or `..` segment, or a slash at either
+ * end - which a pattern such as `a/*\/b` would otherwise produce as `a//b`.
+ * NUL is refused outright: no filesystem and no git tree holds a path with one.
+ */
+const SEGMENT_START = 0;
+const ONE_DOT = 1;
+const TWO_DOTS = 2;
+const IN_NAME = 3;
+const INVALID = -1;
+const NUL = 0;
+function stepValidity(state, point) {
+    if (point === NUL)
+        return INVALID;
+    if (point === SLASH)
+        return state === IN_NAME ? SEGMENT_START : INVALID;
+    if (point === DOT)
+        return state === SEGMENT_START ? ONE_DOT : state === ONE_DOT ? TWO_DOTS : IN_NAME;
+    return IN_NAME;
+}
+function closureOf(automaton, seeds) {
+    const visited = new Int32Array(automaton.kinds.length).fill(-1);
+    const out = [];
+    close(automaton, [...seeds], visited, 0, out);
+    return out;
+}
+function stepSet(automaton, states, point) {
+    const seeds = [];
+    for (const state of states) {
+        if (automaton.kinds[state] === CHAR && accepts(automaton.sets[state], point)) {
+            seeds.push(automaton.first[state]);
+        }
+    }
+    return closureOf(automaton, seeds).sort((a, b) => a - b);
+}
+/** Every way of choosing one element from each list. */
+function combinations(lists) {
+    let out = [[]];
+    for (const list of lists) {
+        const grown = [];
+        for (const prefix of out)
+            for (const state of list)
+                grown.push([...prefix, state]);
+        out = grown;
+    }
+    return out;
+}
+function isMatch(automaton, state) {
+    return automaton.kinds[state] === MATCH;
+}
+/**
+ * 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 function findWitness(include, exclude = [], budget = WITNESS_BUDGET) {
+    if (include.length === 0)
+        throw new Error('a witness search needs at least one automaton to satisfy');
+    for (const automaton of [...include, ...exclude]) {
+        if (!automaton.caseSensitive)
+            throw new Error('a witness search is defined for case-sensitive patterns only');
+    }
+    const startPositive = include.map((automaton) => closureOf(automaton, [automaton.start]));
+    const startNegative = exclude.map((automaton) => closureOf(automaton, [automaton.start]).sort((a, b) => a - b));
+    const nodes = [];
+    const seen = new Set();
+    const key = (positive, negative, validity) => `${positive.join(',')}|${validity}|${negative.map((set) => set.join(',')).join('|')}`;
+    const enqueue = (positive, negative, validity, parent, point) => {
+        const id = key(positive, negative, validity);
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        nodes.push({ positive, negative, validity, parent, point });
+    };
+    for (const positive of combinations(startPositive))
+        enqueue(positive, startNegative, SEGMENT_START, -1, 0);
+    for (let cursor = 0; cursor < nodes.length; cursor += 1) {
+        if (cursor >= budget)
+            return { kind: 'undecided' };
+        const node = nodes[cursor];
+        const accepted = node.positive.every((state, i) => isMatch(include[i], state));
+        const refused = node.negative.every((set, i) => !set.some((state) => isMatch(exclude[i], state)));
+        if (accepted && refused && node.validity === IN_NAME)
+            return { kind: 'found', path: spell(nodes, cursor) };
+        // A MATCH state reads nothing more: an included automaton sitting on one
+        // can only accept here, so no longer path extends this node.
+        if (node.positive.some((state, i) => include[i].kinds[state] !== CHAR))
+            continue;
+        const sets = [];
+        node.positive.forEach((state, i) => sets.push(include[i].sets[state]));
+        node.negative.forEach((set, i) => {
+            const automaton = exclude[i];
+            for (const state of set)
+                if (automaton.kinds[state] === CHAR)
+                    sets.push(automaton.sets[state]);
+        });
+        // Where each included automaton goes next does not depend on the
+        // character, only whether it may go; what the excluded ones reach does.
+        const successors = combinations(node.positive.map((state, i) => closureOf(include[i], [include[i].first[state]])));
+        for (const point of boundaryPoints(sets)) {
+            const validity = stepValidity(node.validity, point);
+            if (validity === INVALID)
+                continue;
+            if (!node.positive.every((state, i) => accepts(include[i].sets[state], point))) {
+                continue;
+            }
+            const negative = node.negative.map((set, i) => stepSet(exclude[i], set, point));
+            for (const positive of successors)
+                enqueue(positive, negative, validity, cursor, point);
+        }
+    }
+    return { kind: 'none' };
+}
+function spell(nodes, index) {
+    const points = [];
+    for (let i = index; nodes[i].parent >= 0; i = nodes[i].parent) {
+        points.push(nodes[i].point);
+    }
+    return String.fromCodePoint(...points.reverse());
+}
+//# sourceMappingURL=automaton.js.map

package/dist/vendor/spec-core/pattern/automaton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automaton.js","sourceRoot":"","sources":["../../../../src/vendor/spec-core/pattern/automaton.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,GAAG,EAAE,KAAK,EAAgB,MAAM,cAAc,CAAC;AAEtG,MAAM,IAAI,GAAG,CAAC,CAAC;AACf,MAAM,KAAK,GAAG,CAAC,CAAC;AAChB,MAAM,IAAI,GAAG,CAAC,CAAC;AACf,MAAM,KAAK,GAAG,CAAC,CAAC;AA0BhB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC;AAEjC,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAC1C;QACE,KAAK,CAAC,qCAAqC,UAAU,SAAS,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AAED,uDAAuD;AACvD,MAAM,OAAO,OAAO;IACD,KAAK,GAAa,EAAE,CAAC;IACrB,KAAK,GAAa,EAAE,CAAC;IACrB,MAAM,GAAa,EAAE,CAAC;IACtB,IAAI,GAAuB,EAAE,CAAC;IAEvC,GAAG,CAAC,IAAY,EAAE,GAAmB,EAAE,KAAa,EAAE,MAAc;QAC1E,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,UAAU;YAAE,MAAM,IAAI,iBAAiB,EAAE,CAAC;QACnE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/B,CAAC;IAEO,KAAK,CAAC,KAAsB,EAAE,MAAc;QAClD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC;gBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;;gBAChD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;QACxC,CAAC;IACH,CAAC;IAED,gCAAgC;IAChC,IAAI,CAAC,GAAY;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC1C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACvD,CAAC;IAED,wBAAwB;IACxB,KAAK;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACvD,CAAC;IAED,6CAA6C;IAC7C,QAAQ,CAAC,KAA0B;QACjC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;QAC5C,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,CAAa,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAa,CAAC;YAClC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,OAAO,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;QACxD,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,gCAAgC;IAChC,MAAM,CAAC,OAA4B;QACjC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QACtF,IAAI,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAa,CAAC;QACtD,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAa,CAAC;YACtC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;YACjE,OAAO,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzE,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,kCAAkC;IAClC,IAAI,CAAC,IAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9D,CAAC;IAED,iCAAiC;IACjC,IAAI,CAAC,IAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACnE,CAAC;IAED,iCAAiC;IACjC,QAAQ,CAAC,IAAc;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IACpC,CAAC;IAED,oEAAoE;IACpE,MAAM,CAAC,IAAc,EAAE,aAAsB;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;YACpC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YACpB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,aAAa;SACd,CAAC;IACJ,CAAC;CACF;AAED;;;;GAIG;AACH,SAAS,KAAK,CACZ,SAAoB,EACpB,KAAe,EACf,OAAmB,EACnB,KAAa,EACb,IAAc;IAEd,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAY,CAAC;QACpC,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK;YAAE,SAAS;QACvC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QACvB,QAAQ,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,KAAK,KAAK;gBACR,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAW,EAAE,KAAK,CAAC,KAAK,CAAW,CAAC,CAAC;gBAC5D,MAAM;YACR,KAAK,IAAI;gBACP,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAW,CAAC,CAAC;gBACnC,MAAM;YACR;gBACE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,OAAO;IACD,SAAS,CAAY;IACrB,OAAO,CAAa;IAC7B,KAAK,GAAG,CAAC,CAAC;IACD,KAAK,GAAa,EAAE,CAAC;IAC9B,IAAI,GAAa,EAAE,CAAC;IACpB,IAAI,GAAa,EAAE,CAAC;IAE5B,YAAY,SAAoB;QAC9B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,4DAA4D;IAC5D,IAAI,CAAC,OAAe;QAClB,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;QAC3B,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,mBAAmB,CAAC;QACvE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QAChB,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAElE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAW,CAAC;YAC/C,IAAI,KAAK,GAAG,MAAM;gBAAE,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;YACrB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;YAChB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC9B,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI;oBAAE,SAAS;gBAC9C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAY,EAAE,KAAK,CAAC;oBAAE,SAAS;gBAC/D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAW,CAAC,CAAC;gBAClD,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACpE,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;YACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YACtB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,CAAC;IACrE,CAAC;CACF;AASD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,aAAa,GAAG,CAAC,CAAC;AACxB,MAAM,OAAO,GAAG,CAAC,CAAC;AAClB,MAAM,QAAQ,GAAG,CAAC,CAAC;AACnB,MAAM,OAAO,GAAG,CAAC,CAAC;AAClB,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC;AACnB,MAAM,GAAG,GAAG,CAAC,CAAC;AAEd,SAAS,YAAY,CAAC,KAAa,EAAE,KAAa;IAChD,IAAI,KAAK,KAAK,GAAG;QAAE,OAAO,OAAO,CAAC;IAClC,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC;IACxE,IAAI,KAAK,KAAK,GAAG;QAAE,OAAO,KAAK,KAAK,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;IACrG,OAAO,OAAO,CAAC;AACjB,CAAC;AAYD,SAAS,SAAS,CAAC,SAAoB,EAAE,KAAwB;IAC/D,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,CAAC,SAAS,EAAE,CAAC,GAAG,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAC9C,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,OAAO,CAAC,SAAoB,EAAE,MAAyB,EAAE,KAAa;IAC7E,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAY,EAAE,KAAK,CAAC,EAAE,CAAC;YACxF,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAW,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,wDAAwD;AACxD,SAAS,YAAY,CAAC,KAAqC;IACzD,IAAI,GAAG,GAAe,CAAC,EAAE,CAAC,CAAC;IAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAe,EAAE,CAAC;QAC7B,KAAK,MAAM,MAAM,IAAI,GAAG;YAAE,KAAK,MAAM,KAAK,IAAI,IAAI;gBAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;QACnF,GAAG,GAAG,KAAK,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,OAAO,CAAC,SAAoB,EAAE,KAAa;IAClD,OAAO,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CACzB,OAA6B,EAC7B,OAAO,GAAyB,EAAE,EAClC,MAAM,GAAW,cAAc;IAE/B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IACtG,KAAK,MAAM,SAAS,IAAI,CAAC,GAAG,OAAO,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;QACjD,IAAI,CAAC,SAAS,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IAChH,CAAC;IAED,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1F,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAEhH,MAAM,KAAK,GAAiB,EAAE,CAAC;IAC/B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAG,CAAC,QAA2B,EAAE,QAAwC,EAAE,QAAgB,EAAU,EAAE,CAC9G,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IAExF,MAAM,OAAO,GAAG,CACd,QAA2B,EAC3B,QAAwC,EACxC,QAAgB,EAChB,MAAc,EACd,KAAa,EACP,EAAE;QACR,MAAM,EAAE,GAAG,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC7C,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO;QACzB,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACb,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9D,CAAC,CAAC;IAEF,KAAK,MAAM,QAAQ,IAAI,YAAY,CAAC,aAAa,CAAC;QAAE,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3G,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,CAAC;QACxD,IAAI,MAAM,IAAI,MAAM;YAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;QACnD,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAe,CAAC;QAEzC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAc,EAAE,KAAK,CAAC,CAAC,CAAC;QAC5F,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAc,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/G,IAAI,QAAQ,IAAI,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;YAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;QAE3G,yEAAyE;QACzE,6DAA6D;QAC7D,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAE,OAAO,CAAC,CAAC,CAAe,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;YAAE,SAAS;QAEhG,MAAM,IAAI,GAAc,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAE,OAAO,CAAC,CAAC,CAAe,CAAC,IAAI,CAAC,KAAK,CAAY,CAAC,CAAC,CAAC;QACjG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;YAC/B,MAAM,SAAS,GAAG,OAAO,CAAC,CAAC,CAAc,CAAC;YAC1C,KAAK,MAAM,KAAK,IAAI,GAAG;gBAAE,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI;oBAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAY,CAAC,CAAC;QAC5G,CAAC,CAAC,CAAC;QAEH,iEAAiE;QACjE,wEAAwE;QACxE,MAAM,UAAU,GAAG,YAAY,CAC7B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAc,EAAE,CAAE,OAAO,CAAC,CAAC,CAAe,CAAC,KAAK,CAAC,KAAK,CAAW,CAAC,CAAC,CAAC,CACxH,CAAC;QACF,KAAK,MAAM,KAAK,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACpD,IAAI,QAAQ,KAAK,OAAO;gBAAE,SAAS;YACnC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAE,OAAO,CAAC,CAAC,CAAe,CAAC,IAAI,CAAC,KAAK,CAAY,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;gBACzG,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAc,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;YAC7F,KAAK,MAAM,QAAQ,IAAI,UAAU;gBAAE,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAC1B,CAAC;AAED,SAAS,KAAK,CAAC,KAA4B,EAAE,KAAa;IACxD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,IAAI,CAAC,GAAG,KAAK,EAAG,KAAK,CAAC,CAAC,CAAgB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,GAAI,KAAK,CAAC,CAAC,CAAgB,CAAC,MAAM,EAAE,CAAC;QAC9F,MAAM,CAAC,IAAI,CAAE,KAAK,CAAC,CAAC,CAAgB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,MAAM,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;AACnD,CAAC"}

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

@@ -0,0 +1,59 @@
+/**
+ * Sets of characters a glob position accepts, over Unicode code points.
+ *
+ * A glob matches a path one character at a time, and a character is a code
+ * point: `?` matches `é` whether it is stored as one UTF-16 unit or not, and an
+ * emoji as one. That is what a person counting characters in a file name
+ * expects, and it is the same on every host.
+ *
+ * No set but the separator's accepts `/`. A path is matched a segment at a
+ * time, and a `*` or a `[!a]` that swallowed a slash would let one segment of
+ * a pattern match two of a path.
+ */
+/** An inclusive range of code points. */
+export type CodeRange = readonly [number, number];
+export interface CharSet {
+    readonly negated: boolean;
+    readonly ranges: readonly CodeRange[];
+    /** True only for the path separator itself. */
+    readonly separator: boolean;
+}
+export declare const SLASH = 47;
+export declare const DOT = 46;
+export declare const MAX_CODE_POINT = 1114111;
+/** The separator, and nothing else. */
+export declare const SEPARATOR: CharSet;
+/** Any character but the separator: `?`, and the body of `*`. */
+export declare const ANY: CharSet;
+export declare function literalSet(point: number): CharSet;
+export declare function classSet(ranges: readonly CodeRange[], negated: boolean): CharSet;
+/** Whether a set accepts a code point as written. */
+export declare function accepts(set: CharSet, point: number): boolean;
+/**
+ * The code points a code point is the same letter as, ignoring case: itself,
+ * and its lower- and upper-case forms where each is a single code point.
+ *
+ * Simple case mapping, which is what `toLowerCase` and `toUpperCase` give one
+ * character at a time. It is locale-free, so two hosts agree; `ß` has no single
+ * upper-case code point and so matches only itself.
+ */
+export declare function caseVariants(point: number): readonly number[];
+/**
+ * Whether a set accepts a code point with case ignored: whether it accepts
+ * the point or one of its case variants. A negated set is negated over the
+ * same question, so `[!a]` refuses `A` as well as `a`.
+ */
+export declare function acceptsIgnoringCase(set: CharSet, point: number): boolean;
+/**
+ * Every code point at which the answer "which of these sets accept it" can
+ * change, readable ones first.
+ *
+ * Each set accepts a union of intervals, so the sets' memberships are constant
+ * between consecutive interval ends. The start of each interval and the point
+ * after its end therefore meet every distinct combination of answers, and
+ * trying them all decides every question a witness search can ask of one
+ * character. The separator and the dot are always included: path validity
+ * turns on them.
+ */
+export declare function boundaryPoints(sets: readonly CharSet[]): number[];
+//# sourceMappingURL=charset.d.ts.map

package/dist/vendor/spec-core/pattern/charset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charset.d.ts","sourceRoot":"","sources":["../../../../src/vendor/spec-core/pattern/charset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yCAAyC;AACzC,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAElD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,eAAO,MAAM,KAAK,KAAO,CAAC;AAC1B,eAAO,MAAM,GAAG,KAAO,CAAC;AACxB,eAAO,MAAM,cAAc,UAAW,CAAC;AAEvC,uCAAuC;AACvC,eAAO,MAAM,SAAS,EAAE,OAAuE,CAAC;AAEhG,iEAAiE;AACjE,eAAO,MAAM,GAAG,EAAE,OAAyD,CAAC;AAE5E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAEhF;AAUD,qDAAqD;AACrD,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAa7D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAMxE;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,EAAE,CAiBjE"}

package/dist/vendor/spec-core/pattern/charset.js

@@ -0,0 +1,116 @@
+/**
+ * Sets of characters a glob position accepts, over Unicode code points.
+ *
+ * A glob matches a path one character at a time, and a character is a code
+ * point: `?` matches `é` whether it is stored as one UTF-16 unit or not, and an
+ * emoji as one. That is what a person counting characters in a file name
+ * expects, and it is the same on every host.
+ *
+ * No set but the separator's accepts `/`. A path is matched a segment at a
+ * time, and a `*` or a `[!a]` that swallowed a slash would let one segment of
+ * a pattern match two of a path.
+ */
+export const SLASH = 0x2f;
+export const DOT = 0x2e;
+export const MAX_CODE_POINT = 0x10ffff;
+/** The separator, and nothing else. */
+export const SEPARATOR = { negated: false, ranges: [[SLASH, SLASH]], separator: true };
+/** Any character but the separator: `?`, and the body of `*`. */
+export const ANY = { negated: true, ranges: [], separator: false };
+export function literalSet(point) {
+    return { negated: false, ranges: [[point, point]], separator: point === SLASH };
+}
+export function classSet(ranges, negated) {
+    return { negated, ranges, separator: false };
+}
+function within(ranges, point) {
+    for (let i = 0; i < ranges.length; i += 1) {
+        const range = ranges[i];
+        if (point >= range[0] && point <= range[1])
+            return true;
+    }
+    return false;
+}
+/** Whether a set accepts a code point as written. */
+export function accepts(set, point) {
+    if (point === SLASH)
+        return set.separator;
+    return within(set.ranges, point) !== set.negated;
+}
+/**
+ * The code points a code point is the same letter as, ignoring case: itself,
+ * and its lower- and upper-case forms where each is a single code point.
+ *
+ * Simple case mapping, which is what `toLowerCase` and `toUpperCase` give one
+ * character at a time. It is locale-free, so two hosts agree; `ß` has no single
+ * upper-case code point and so matches only itself.
+ */
+export function caseVariants(point) {
+    if (point < 0x80) {
+        if (point >= 0x41 && point <= 0x5a)
+            return [point, point + 32];
+        if (point >= 0x61 && point <= 0x7a)
+            return [point, point - 32];
+        return [point];
+    }
+    const char = String.fromCodePoint(point);
+    const out = [point];
+    for (const variant of [char.toLowerCase(), char.toUpperCase()]) {
+        const code = variant.codePointAt(0);
+        if (variant.length === String.fromCodePoint(code).length && !out.includes(code))
+            out.push(code);
+    }
+    return out;
+}
+/**
+ * Whether a set accepts a code point with case ignored: whether it accepts
+ * the point or one of its case variants. A negated set is negated over the
+ * same question, so `[!a]` refuses `A` as well as `a`.
+ */
+export function acceptsIgnoringCase(set, point) {
+    if (point === SLASH)
+        return set.separator;
+    const variants = caseVariants(point);
+    let inside = false;
+    for (let i = 0; i < variants.length && !inside; i += 1)
+        inside = within(set.ranges, variants[i]);
+    return inside !== set.negated;
+}
+/**
+ * Characters a witness is spelled with when any of them will do, in order of
+ * preference. A witness is read by a person deciding whether two scopes really
+ * overlap, and `src/x.ts` reads better than `src/\u0000.ts`.
+ */
+const READABLE = [0x78, 0x61, 0x62, 0x30, 0x5f, 0x2d, 0x7e, 0x21, DOT, SLASH];
+/**
+ * Every code point at which the answer "which of these sets accept it" can
+ * change, readable ones first.
+ *
+ * Each set accepts a union of intervals, so the sets' memberships are constant
+ * between consecutive interval ends. The start of each interval and the point
+ * after its end therefore meet every distinct combination of answers, and
+ * trying them all decides every question a witness search can ask of one
+ * character. The separator and the dot are always included: path validity
+ * turns on them.
+ */
+export function boundaryPoints(sets) {
+    // 1, not 0: no path holds a NUL, so the least character worth trying is the next.
+    const points = [...READABLE, 1];
+    for (const set of sets) {
+        for (const [low, high] of set.ranges) {
+            points.push(low);
+            if (high < MAX_CODE_POINT)
+                points.push(high + 1);
+        }
+    }
+    const seen = new Set();
+    const out = [];
+    for (const point of points) {
+        if (seen.has(point))
+            continue;
+        seen.add(point);
+        out.push(point);
+    }
+    return out;
+}
+//# sourceMappingURL=charset.js.map

package/dist/vendor/spec-core/pattern/charset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charset.js","sourceRoot":"","sources":["../../../../src/vendor/spec-core/pattern/charset.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,122 @@
+/**
+ * Globs, in the three dialects the spec-* tools speak, compiled to one kind of
+ * automaton.
+ *
+ * The syntax is the part people type: `*`, `**`, `?`, `[abc]`, `[!a-z]`,
+ * `{a,b}`, and `\` to escape. What differs between the tools is not the
+ * syntax but what a pattern is matched against, and those differences are
+ * deliberate, so each has a name (docs/adr/0003-glob-dialects.md):
+ *
+ * - `path` - the whole repository-relative path, anchored at the root. A
+ *   pattern with no glob syntax names a file, a directory, or either, as the
+ *   caller says; `src/auth` may cover `src/auth/login.ts`.
+ * - `ripgrep` - as ripgrep's `-g`: a pattern with no `/` is matched against
+ *   the last segment at any depth, so `*.ts` matches `src/deep/a.ts`; one with
+ *   a `/` is matched against the whole path.
+ * - `gitignore` - as an exclusion list reads: a pattern matches a path or any
+ *   directory above it, so `tests` excludes everything under any `tests`; one
+ *   with a `/` other than a trailing one is anchored at the root, and a
+ *   leading `/` only anchors.
+ *
+ * Shared by all three:
+ *
+ * - `**` is a globstar only as a whole segment. `a/**\/b` matches `a/b` and
+ *   `a/x/y/b`; a trailing `/**` matches everything inside a directory and not
+ *   the directory itself. Two stars inside a name, `**.md`, are refused: the
+ *   tools read it three ways, and the quiet reading narrowed their scope.
+ * - `*`, `?` and classes never match `/`, and `*` matches a leading dot.
+ * - Case is the caller's decision, stated every time. A result must not
+ *   depend on the host it ran on.
+ * - A malformed pattern is an error, never a literal. An unclosed `[` or `{`,
+ *   an extended glob, a `..` - each is refused with a reason, because a typo
+ *   read as a literal is a scope that silently matches nothing. An extended
+ *   glob is a group holding a `|`, `+(a|b)`: without one, `C++(notes).md` is
+ *   a name with parentheses in it, as ripgrep and `.gitignore` read it.
+ */
+import { type Automaton, type Witness } from './automaton.js';
+export type GlobDialect = 'path' | 'ripgrep' | 'gitignore';
+/** How a `path` pattern with no glob syntax is read. */
+export type LiteralReading = 'file' | 'directory' | 'either';
+export interface GlobOptions {
+    readonly dialect: GlobDialect;
+    /** Whether `A` and `a` differ. No default: the caller decides, every time. */
+    readonly caseSensitive: boolean;
+    /**
+     * `path` dialect only: how a pattern with no glob syntax is read - as a
+     * file, as a directory and everything beneath it, or as either. A function
+     * is asked per literal path, for a caller that knows the tree. `either` when
+     * unset. A trailing `/` always means a directory.
+     */
+    readonly literal?: LiteralReading | ((path: string) => LiteralReading) | undefined;
+    /**
+     * `escape` (the default): `\` escapes the next character, and a `\` before a
+     * letter or digit is refused as a Windows separator typed by mistake.
+     * `separator`: every `\` is a `/`, for patterns typed on a Windows shell.
+     */
+    readonly backslash?: 'escape' | 'separator' | undefined;
+}
+export interface Glob {
+    readonly source: string;
+    readonly dialect: GlobDialect;
+    readonly caseSensitive: boolean;
+    /**
+     * The directories a walk must enter to find every match: one per
+     * alternative, the leading literal segments. `''` for an alternative that
+     * can match at any depth.
+     */
+    readonly bases: readonly string[];
+    readonly automaton: Automaton;
+    /** Whether a canonical path - POSIX, no `.`, no empty or trailing segment - matches. */
+    match(path: string): boolean;
+}
+export type GlobParse = {
+    readonly ok: true;
+    readonly glob: Glob;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+export declare class GlobError extends Error {
+    readonly source: string;
+    constructor(source: string, reason: string);
+}
+/** More alternatives than this is a pattern nobody meant. */
+export declare const MAX_ALTERNATIVES = 256;
+/** Whether a string uses glob syntax at all. */
+export declare function isGlobSyntax(source: string): boolean;
+/** Parses and compiles a glob, or says why it cannot. */
+export declare function parseGlob(source: string, options: GlobOptions): GlobParse;
+/** Parses and compiles a glob, throwing {@link GlobError} when it cannot. */
+export declare function compileGlob(source: string, options: GlobOptions): Glob;
+/**
+ * A shortest path every glob in `include` matches and no glob in `exclude`
+ * does: the file two scopes would both write, less what either protects.
+ * `none` is a proof that there is no such path. Case-sensitive globs only.
+ */
+export declare function globWitness(include: readonly Glob[], exclude?: readonly Glob[], budget?: number): Witness;
+/**
+ * Whether every path `inner` matches is matched by one of `outer`: `true`,
+ * `false`, or `undecided` when the search met its budget.
+ */
+export declare function globCovers(outer: readonly Glob[], inner: Glob, budget?: number): boolean | 'undecided';
+export interface GlobList {
+    /** Whether a path is in: the last entry that matches it decides, and a `!` entry takes it out. */
+    match(path: string): boolean;
+    readonly entries: readonly {
+        readonly negated: boolean;
+        readonly glob: Glob;
+    }[];
+}
+export type GlobListParse = {
+    readonly ok: true;
+    readonly list: GlobList;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * A list of patterns read the way a `.gitignore` reads: in order, each entry
+ * deciding the paths it matches, a leading `!` taking them back out.
+ */
+export declare function parseGlobList(patterns: readonly string[], options: GlobOptions): GlobListParse;
+//# sourceMappingURL=glob.d.ts.map