@cplieger/deadset-ts 8.0.0-dev.12 → 8.0.0-dev.13

package/src/vendor/unbash/assignment.ts

@@ -0,0 +1,163 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import { Lexer, LexContext, Token } from "./lexer.ts";
+import { skipLineContinuations } from "./chars.ts";
+import { arrayPartsResolver, computeBareWordParts, embeddedPartsResolver, wordPartsResolver } from "./parts.ts";
+import type { ArrayValue, Assignment, Word } from "./internal-types.ts";
+import { WordImpl } from "./word.ts";
+import type { SubstitutionContext } from "./substitution-context.ts";
+
+class ArrayValueImpl implements ArrayValue {
+  type = "ArrayValue" as const;
+  pos: number;
+  end: number;
+  #source: string;
+  #depth: number;
+  #context: SubstitutionContext;
+  #elements: Word[] | undefined;
+
+  constructor(source: string, pos: number, end: number, depth: number, context: SubstitutionContext) {
+    this.pos = pos;
+    this.end = end;
+    this.#source = source;
+    this.#depth = depth;
+    this.#context = context;
+  }
+
+  get elements(): Word[] {
+    if (this.#elements) return this.#elements;
+    const lexer = new Lexer(this.#source, this.pos + 1, this.end - 1, false, this.#context);
+    lexer._nestingDepth = this.#depth;
+    const elements: Word[] = [];
+    while (lexer.peek(LexContext.ArrayElement).token !== Token.EOF) {
+      const token = lexer.next(LexContext.ArrayElement);
+      if (token.token !== Token.Word && token.token !== Token.Assignment) continue;
+      const text = token.raw ? token.value : this.#source.slice(token.pos, token.end);
+      const indexed = text.charCodeAt(0) === 91;
+      const context = lexer.getSubstitutionContext();
+      const source = !indexed && token.raw && token.keywordEligible ? undefined : this.#source;
+      const resolver =
+        source === undefined
+          ? computeBareWordParts
+          : indexed
+            ? arrayPartsResolver(context)
+            : wordPartsResolver(context);
+      elements.push(new WordImpl(text, token.pos, token.end, source, resolver, this.#depth));
+    }
+    this.#elements = elements;
+    return elements;
+  }
+
+  toJSON(): ArrayValue {
+    return { type: this.type, pos: this.pos, end: this.end, elements: this.elements };
+  }
+}
+
+export class AssignmentImpl implements Assignment {
+  type = "Assignment" as const;
+  pos: number;
+  end: number;
+  text: string;
+  #source: string;
+  #depth: number;
+  #context: SubstitutionContext;
+  #operatorPos: number;
+  #name: string | null = null;
+  #append: boolean | undefined;
+  #index: Word | undefined;
+  #value: Word | ArrayValue | null = null;
+
+  constructor(
+    text: string,
+    pos: number,
+    end: number,
+    source: string,
+    operatorPos: number,
+    depth: number,
+    context: SubstitutionContext,
+  ) {
+    this.pos = pos;
+    this.end = end;
+    this.text = text;
+    this.#source = source;
+    this.#operatorPos = operatorPos;
+    this.#depth = depth;
+    this.#context = context;
+  }
+
+  get name(): string {
+    return this.#name ?? this.resolveTarget();
+  }
+
+  get append(): boolean | undefined {
+    if (this.#name === null) this.resolveTarget();
+    return this.#append;
+  }
+
+  get index(): Word | undefined {
+    if (this.#name === null) this.resolveTarget();
+    return this.#index;
+  }
+
+  get value(): Word | ArrayValue {
+    if (this.#value !== null) return this.#value;
+    const start = this.#operatorPos + 1;
+    const arrayStart = skipLineContinuations(this.#source, start, this.end);
+    this.#value =
+      this.#source.charCodeAt(arrayStart) === 40 && this.#source.charCodeAt(this.end - 1) === 41
+        ? new ArrayValueImpl(this.#source, arrayStart, this.end, this.#depth, this.#context)
+        : new WordImpl(
+            this.#source.slice(start, this.end),
+            start,
+            this.end,
+            this.#source,
+            wordPartsResolver(this.#context),
+            this.#depth,
+          );
+    return this.#value;
+  }
+
+  private resolveTarget(): string {
+    const equal = this.#operatorPos - this.pos;
+    let nameEnd = equal;
+    let appendPos = equal;
+    while (appendPos >= 2 && this.text.charCodeAt(appendPos - 2) === 92 && this.text.charCodeAt(appendPos - 1) === 10)
+      appendPos -= 2;
+    if (this.text.charCodeAt(appendPos - 1) === 43) {
+      this.#append = true;
+      nameEnd = appendPos - 1;
+    }
+    const bracket = this.text.indexOf("[");
+    if (bracket > 0 && bracket < nameEnd) {
+      const close = this.text.lastIndexOf("]", equal);
+      if (close > bracket) {
+        const start = this.pos + bracket + 1;
+        const end = this.pos + close;
+        this.#index = new WordImpl(
+          this.#source.slice(start, end),
+          start,
+          end,
+          this.#source,
+          embeddedPartsResolver(this.#context),
+          this.#depth,
+        );
+        nameEnd = bracket;
+      }
+    }
+    const name = this.text.slice(0, nameEnd);
+    return (this.#name = name.includes("\\\n") ? name.split("\\\n").join("") : name);
+  }
+
+  toJSON(): Assignment {
+    return {
+      type: this.type,
+      pos: this.pos,
+      end: this.end,
+      text: this.text,
+      name: this.name,
+      append: this.append,
+      index: this.index,
+      value: this.value,
+    };
+  }
+}

package/src/vendor/unbash/chars.ts

@@ -0,0 +1,48 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+export const CH_TAB = 9;
+export const CH_NL = 10;
+export const CH_SPACE = 32;
+export const CH_BANG = 33;
+export const CH_DQUOTE = 34;
+export const CH_HASH = 35;
+export const CH_DOLLAR = 36;
+export const CH_PERCENT = 37;
+export const CH_AMP = 38;
+export const CH_SQUOTE = 39;
+export const CH_LPAREN = 40;
+export const CH_RPAREN = 41;
+export const CH_STAR = 42;
+export const CH_PLUS = 43;
+export const CH_COMMA = 44;
+export const CH_DASH = 45;
+export const CH_DOT = 46;
+export const CH_SLASH = 47;
+export const CH_0 = 48;
+export const CH_9 = 57;
+export const CH_COLON = 58;
+export const CH_SEMI = 59;
+export const CH_LT = 60;
+export const CH_EQ = 61;
+export const CH_GT = 62;
+export const CH_QUESTION = 63;
+export const CH_AT = 64;
+export const CH_A = 65;
+export const CH_Z = 90;
+export const CH_LBRACKET = 91;
+export const CH_BACKSLASH = 92;
+export const CH_RBRACKET = 93;
+export const CH_CARET = 94;
+export const CH_UNDERSCORE = 95;
+export const CH_BACKTICK = 96;
+export const CH_a = 97;
+export const CH_z = 122;
+export const CH_LBRACE = 123;
+export const CH_PIPE = 124;
+export const CH_RBRACE = 125;
+export const CH_TILDE = 126;
+
+export function skipLineContinuations(source: string, pos: number, end: number): number {
+  while (pos + 1 < end && source.charCodeAt(pos) === CH_BACKSLASH && source.charCodeAt(pos + 1) === CH_NL) pos += 2;
+  return pos;
+}

package/src/vendor/unbash/command.ts

@@ -0,0 +1,47 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { Command, CommandArgument, Redirection, Word } from "./internal-types.ts";
+
+const isArgument = (item: CommandArgument | Redirection): item is CommandArgument =>
+  item.type === "Word" || item.type === "Assignment";
+
+export class CommandImpl implements Command {
+  type = "Command" as const;
+  pos: number;
+  end: number;
+  name: Word | undefined;
+  prefix: Command["prefix"];
+  suffix: Command["suffix"];
+  #args: CommandArgument[] | undefined;
+  #redirects: Redirection[] | undefined;
+
+  constructor(pos: number, end: number, name: Word | undefined, prefix: Command["prefix"], suffix: Command["suffix"]) {
+    this.pos = pos;
+    this.end = end;
+    this.name = name;
+    this.prefix = prefix;
+    this.suffix = suffix;
+  }
+
+  get args(): CommandArgument[] {
+    if (this.#args === undefined) {
+      const suffix = this.suffix;
+      this.#args = suffix.every(isArgument) ? suffix : suffix.filter(isArgument);
+    }
+    return this.#args;
+  }
+
+  get redirects(): Redirection[] {
+    if (this.#redirects === undefined) {
+      const redirects: Redirection[] = [];
+      for (const item of this.prefix) if (item.type !== "Assignment") redirects.push(item);
+      for (const item of this.suffix) if (!isArgument(item)) redirects.push(item);
+      this.#redirects = redirects;
+    }
+    return this.#redirects;
+  }
+
+  toJSON(): Omit<Command, "args" | "redirects"> {
+    return { type: this.type, pos: this.pos, end: this.end, name: this.name, prefix: this.prefix, suffix: this.suffix };
+  }
+}

package/src/vendor/unbash/expansion.ts

@@ -0,0 +1,144 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type {
+  ArithmeticExpression,
+  ArithmeticExpansionPart,
+  ParsedScript,
+  ProcessSubstitutionPart,
+} from "./internal-types.ts";
+import type { parseRegion } from "./parser.ts";
+import type { parseArithmeticWithParts } from "./arithmetic-parts.ts";
+import type { SubstitutionContext } from "./substitution-context.ts";
+
+type ScriptExpansionType = "CommandExpansion" | "ProcessSubstitution" | "ArithmeticCommandExpansion";
+
+// Where a deferred script parses: in place over [start, end) of `source`, so every node is born
+// with absolute pos/end and nested substitutions compose by re-lexing the original on demand. A
+// decoded backtick body is its own source: its positions index that string, so it parses with no
+// shared context and the script carries the string as `source`.
+export interface ScriptWindow {
+  readonly source: string;
+  readonly start: number;
+  readonly end: number;
+  readonly depth: number;
+  readonly parenBoundary: boolean;
+  readonly context: SubstitutionContext | undefined;
+}
+
+// The window is held only until the script resolves; a part constructed without one has no script.
+export class ScriptExpansionImpl<T extends ScriptExpansionType> {
+  static _resolveScript: typeof parseRegion;
+
+  type: T;
+  pos: number;
+  end: number;
+  text: string;
+  #window: ScriptWindow | undefined;
+  #script: ParsedScript | undefined = undefined;
+
+  constructor(type: T, pos: number, end: number, text: string, window?: ScriptWindow) {
+    this.type = type;
+    this.pos = pos;
+    this.end = end;
+    this.text = text;
+    this.#window = window;
+  }
+
+  get script(): ParsedScript | undefined {
+    const window = this.#window;
+    if (window !== undefined) {
+      const script = ScriptExpansionImpl._resolveScript(
+        window.source,
+        window.start,
+        window.end,
+        window.depth,
+        window.parenBoundary,
+        window.context,
+      );
+      if (window.context === undefined) script.source = window.source;
+      this.script = script;
+    }
+    return this.#script;
+  }
+
+  set script(script: ParsedScript | undefined) {
+    this.#script = script;
+    this.#window = undefined;
+  }
+
+  toJSON(): { type: T; pos: number; end: number; text: string; script: ParsedScript | undefined } {
+    return { type: this.type, pos: this.pos, end: this.end, text: this.text, script: this.script };
+  }
+}
+
+export class ProcessSubstitutionImpl extends ScriptExpansionImpl<"ProcessSubstitution"> {
+  operator: "<" | ">";
+
+  constructor(pos: number, end: number, text: string, operator: "<" | ">", window: ScriptWindow | undefined) {
+    super("ProcessSubstitution", pos, end, text, window);
+    this.operator = operator;
+  }
+
+  toJSON(): ProcessSubstitutionPart {
+    return {
+      type: this.type,
+      pos: this.pos,
+      end: this.end,
+      text: this.text,
+      operator: this.operator,
+      script: this.script,
+    };
+  }
+}
+
+// Where a deferred arithmetic expression parses: `body` is the expression text at `offset` in
+// `source`, which embedded words and substitutions re-lex in place.
+export interface ArithmeticWindow {
+  readonly source: string;
+  readonly body: string;
+  readonly offset: number;
+  readonly depth: number;
+  readonly context: SubstitutionContext;
+}
+
+export class ArithmeticExpansionImpl implements ArithmeticExpansionPart {
+  static _resolveExpression: typeof parseArithmeticWithParts;
+
+  type = "ArithmeticExpansion" as const;
+  pos: number;
+  end: number;
+  text: string;
+  #window: ArithmeticWindow | undefined;
+  #expression: ArithmeticExpression | undefined = undefined;
+
+  constructor(pos: number, end: number, text: string, window: ArithmeticWindow) {
+    this.pos = pos;
+    this.end = end;
+    this.text = text;
+    this.#window = window;
+  }
+
+  get expression(): ArithmeticExpression | undefined {
+    const window = this.#window;
+    if (window !== undefined) {
+      this.expression = ArithmeticExpansionImpl._resolveExpression(
+        window.body,
+        window.offset,
+        window.source,
+        window.depth,
+        window.context,
+        window.depth + 1,
+      );
+    }
+    return this.#expression;
+  }
+
+  set expression(expression: ArithmeticExpression | undefined) {
+    this.#expression = expression;
+    this.#window = undefined;
+  }
+
+  toJSON(): ArithmeticExpansionPart {
+    return { type: this.type, pos: this.pos, end: this.end, text: this.text, expression: this.expression };
+  }
+}

package/src/vendor/unbash/glob.ts

@@ -0,0 +1,284 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { GlobPart, WordPart } from "./internal-types.ts";
+import { unescapeBareValue, wordPartsValue } from "./word-value.ts";
+import {
+  CH_BACKSLASH,
+  CH_BANG,
+  CH_CARET,
+  CH_COLON,
+  CH_DASH,
+  CH_DOT,
+  CH_EQ,
+  CH_LBRACKET,
+  CH_LPAREN,
+  CH_NL,
+  CH_QUESTION,
+  CH_RBRACKET,
+  CH_STAR,
+  skipLineContinuations,
+} from "./chars.ts";
+
+export function hasGlobCharacters(text: string): boolean {
+  return /[*?[]/.test(text);
+}
+
+const bracketSyntax = new Uint8Array(128);
+bracketSyntax[CH_BANG] = 1;
+bracketSyntax[CH_CARET] = 1;
+bracketSyntax[CH_LBRACKET] = 1;
+bracketSyntax[CH_RBRACKET] = 1;
+bracketSyntax[CH_COLON] = 1;
+bracketSyntax[CH_DOT] = 1;
+bracketSyntax[CH_EQ] = 1;
+bracketSyntax[CH_DASH] = 1;
+bracketSyntax[CH_BACKSLASH] = 1;
+
+// Bracket extents follow Bash's matcher (lib/glob/sm_loop.c, BRACKMATCH and PARSE_SUBBRACKET on
+// the path where no member matches): `[:name:]` and `[=c=]` end at the first `:]` or `=]` unless a
+// raw `]` comes first, `[.sym.]` ends at the first `.]` even past a `]`, a class or equivalence
+// never starts a range, and a `-` range end consumes one member, be it an escape, a plain `[` or a
+// collating symbol (also behind an escaped `[`). Quoted and expanded parts are single opaque
+// members; Bash additionally lets quoted `]`, `:`, `=`, `.` and `[` take part in symbol and range
+// scanning after re-escaping them, which this scan leaves out.
+function bracketEnds(
+  source: string,
+  start: number,
+  end: number,
+  parts: WordPart[] | null | undefined,
+  offset: number,
+): Map<number, number> | null {
+  let close = end - 1;
+  while (close > start && source.charCodeAt(close) !== CH_RBRACKET) close--;
+  if (close === start) return null;
+
+  // Tokens: each special character, and runs of plain members (continuations vanish, quoted or
+  // expanded parts are plain). Only specials change an extent, so a run acts as one member except
+  // as a range end, which consumes just its first member.
+  const positions: number[] = [];
+  const kinds: number[] = [];
+  const members: number[] = [];
+  let partIndex = 0;
+  let symbols = false;
+  for (let pos = start; pos < end; pos++) {
+    while (parts && partIndex < parts.length && parts[partIndex].end <= pos + offset) partIndex++;
+    const part = parts?.[partIndex];
+    const tokenPos = pos;
+    let kind = 0;
+    if (part && part.pos <= pos + offset && part.type !== "Literal") {
+      pos = part.end - offset - 1;
+    } else {
+      kind = source.charCodeAt(pos);
+      if (kind === CH_BACKSLASH && pos + 1 < end && source.charCodeAt(pos + 1) === CH_NL) {
+        pos++;
+        continue;
+      }
+      if (kind >= 128 || !bracketSyntax[kind]) kind = 0;
+    }
+    const last = kinds.length - 1;
+    if (kind === 0 && last >= 0 && kinds[last] === 0) {
+      members[last]++;
+      continue;
+    }
+    if (last >= 0 && kinds[last] === CH_LBRACKET && (kind === CH_COLON || kind === CH_EQ || kind === CH_DOT)) {
+      symbols = true;
+    }
+    positions.push(tokenPos);
+    kinds.push(kind);
+    members.push(1);
+  }
+  const count = kinds.length;
+
+  // PARSE_SUBBRACKET memoized per opener: symbolEnd[t] is the token after the `X]` closing the
+  // symbol that `[X` opens at token t, or -1. One right-to-left pass tracks the nearest raw `]`
+  // and the nearest `:]`, `=]` and `.]` beyond the opener. Escaped characters are separate tokens,
+  // so a `\]` still stops a `:` or `=` scan as it does in Bash.
+  let symbolEnd: Int32Array | undefined;
+  if (symbols) {
+    symbolEnd = new Int32Array(count).fill(-1);
+    let close = -1;
+    let colon = -1;
+    let eq = -1;
+    let dot = -1;
+    for (let i = count - 1; i >= 0; i--) {
+      // The scan for the opener at i starts two tokens in, so fold token i + 2 in first.
+      const kind = kinds[i + 2];
+      if (kind === CH_RBRACKET) close = i + 2;
+      else if (kinds[i + 3] === CH_RBRACKET) {
+        if (kind === CH_COLON) colon = i + 2;
+        else if (kind === CH_EQ) eq = i + 2;
+        else if (kind === CH_DOT) dot = i + 2;
+      }
+      if (kinds[i] !== CH_LBRACKET) continue;
+      const type = kinds[i + 1];
+      const found = type === CH_COLON ? colon : type === CH_EQ ? eq : type === CH_DOT ? dot : -1;
+      if (found !== -1 && (type === CH_DOT || close === -1 || close > found)) symbolEnd[i] = found + 2;
+    }
+  }
+  const subBracket = (open: number): number => (symbolEnd === undefined ? -1 : symbolEnd[open]);
+
+  // endFrom[t]: the token after the `]` closing a bracket whose next member starts at token t, or
+  // -1 when the pattern runs out and the opening `[` stays literal.
+  const endFrom = new Int32Array(count + 2).fill(-1);
+  const resume = (next: number, range: boolean): number => {
+    if (next >= count) return -1;
+    if (range && kinds[next] === CH_DASH && next + 1 < count && kinds[next + 1] !== CH_RBRACKET) {
+      let last = next + 1;
+      if (kinds[last] === CH_BACKSLASH) {
+        if (last + 1 >= count) return -1;
+        last++;
+      }
+      let after = last + 1;
+      if (kinds[last] === CH_LBRACKET && kinds[last + 1] === CH_DOT) {
+        const symbol = subBracket(last);
+        if (symbol !== -1) after = symbol;
+      } else if (kinds[last] === 0 && members[last] > 1) {
+        // The run's later members stay members, and its last one may start the next range.
+        return endFrom[last];
+      }
+      if (after >= count) return -1;
+      return kinds[after] === CH_RBRACKET ? after + 1 : endFrom[after];
+    }
+    return kinds[next] === CH_RBRACKET ? next + 1 : endFrom[next];
+  };
+  for (let t = count - 1; t >= 0; t--) {
+    const kind = kinds[t];
+    let after = t + 1;
+    let range = true;
+    if (kind === CH_BACKSLASH) {
+      if (t + 1 >= count) continue;
+      after = t + 2;
+    } else if (kind === CH_LBRACKET) {
+      const type = kinds[t + 1];
+      if (type === CH_COLON || type === CH_EQ || type === CH_DOT) {
+        const symbol = subBracket(t);
+        if (symbol !== -1) {
+          after = symbol;
+          range = type === CH_DOT;
+        }
+      }
+    }
+    endFrom[t] = resume(after, range);
+  }
+
+  const ends = new Map<number, number>();
+  for (let t = 0; t < count; t++) {
+    if (kinds[t] !== CH_LBRACKET) continue;
+    let first = t + 1;
+    if (kinds[first] === CH_BANG || kinds[first] === CH_CARET) first++;
+    if (first >= count) continue;
+    const close = kinds[first] === CH_RBRACKET ? resume(first + 1, true) : endFrom[first];
+    if (close !== -1) ends.set(positions[t], positions[close - 1] + 1);
+  }
+  return ends;
+}
+
+function appendRange(
+  source: string,
+  start: number,
+  end: number,
+  parts: WordPart[] | null | undefined,
+  index: number,
+  offset: number,
+  result: WordPart[],
+): number {
+  while (start < end) {
+    while (parts && index < parts.length && parts[index].end <= start + offset) index++;
+    const part = parts?.[index];
+    if (part && part.pos === start + offset && part.end <= end + offset) {
+      result.push(part);
+      start = part.end - offset;
+      index++;
+      continue;
+    }
+    const stop = part ? Math.min(end, (part.pos > start + offset ? part.pos : part.end) - offset) : end;
+    const text = source.slice(start, stop);
+    result.push({ type: "Literal", pos: start + offset, end: stop + offset, text, value: unescapeBareValue(text) });
+    start = stop;
+  }
+  return index;
+}
+
+export function parseGlobParts(
+  source: string,
+  start: number,
+  end: number,
+  parts: WordPart[] | null | undefined,
+  offset = 0,
+): WordPart[] | undefined {
+  let result: WordPart[] | undefined;
+  let brackets: Map<number, number> | null | undefined;
+  let partIndex = 0;
+  let emittedIndex = 0;
+  let literalStart = start;
+  for (let pos = start; pos < end; pos++) {
+    while (parts && partIndex < parts.length && parts[partIndex].end <= pos + offset) partIndex++;
+    const part = parts?.[partIndex];
+    if (part && part.pos <= pos + offset && part.type !== "Literal") {
+      pos = part.end - offset - 1;
+      continue;
+    }
+    const character = source.charCodeAt(pos);
+    if (character === CH_BACKSLASH) {
+      pos++;
+      continue;
+    }
+
+    let globEnd: number;
+    if (character === CH_STAR || character === CH_QUESTION) {
+      const limit = part ? Math.min(end, part.end - offset) : end;
+      // Embedded-word scans can leave extglob operators inside Literal parts.
+      const next = skipLineContinuations(source, pos + 1, limit);
+      if (next < limit && source.charCodeAt(next) === CH_LPAREN) continue;
+      globEnd = pos + 1;
+      if (character === CH_STAR) {
+        while (globEnd < limit && source.charCodeAt(globEnd) === CH_STAR) {
+          const next = skipLineContinuations(source, globEnd + 1, limit);
+          if (next < limit && source.charCodeAt(next) === CH_LPAREN) break;
+          globEnd++;
+        }
+      }
+    } else if (character === CH_LBRACKET) {
+      if (brackets === undefined) brackets = bracketEnds(source, pos, end, parts, offset);
+      const close = brackets?.get(pos);
+      if (close === undefined) continue;
+      globEnd = close;
+    } else {
+      continue;
+    }
+
+    if (!result) result = [];
+    emittedIndex = appendRange(source, literalStart, pos, parts, emittedIndex, offset, result);
+    const text = source.slice(pos, globEnd);
+    let glob: GlobPart;
+    if (character === CH_LBRACKET) {
+      const interior: WordPart[] = [];
+      emittedIndex = appendRange(source, pos + 1, globEnd - 1, parts, emittedIndex, offset, interior);
+      glob = {
+        type: "Glob",
+        kind: "bracket",
+        pos: pos + offset,
+        end: globEnd + offset,
+        text,
+        value: "[" + wordPartsValue(interior) + "]",
+        parts: interior,
+      };
+    } else {
+      glob = {
+        type: "Glob",
+        kind: character === CH_STAR ? "star" : "question",
+        pos: pos + offset,
+        end: globEnd + offset,
+        text,
+        value: text,
+        parts: undefined,
+      };
+    }
+    result.push(glob);
+    literalStart = globEnd;
+    pos = globEnd - 1;
+  }
+  if (!result) return parts ?? undefined;
+  appendRange(source, literalStart, end, parts, emittedIndex, offset, result);
+  return result;
+}