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

package/src/vendor/unbash/parts.ts

@@ -0,0 +1,96 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { Word, WordPart } from "./internal-types.ts";
+import { hasEmbeddedWordStructure, Lexer } from "./lexer.ts";
+import type { PartsResolver } from "./word.ts";
+import { createSubstitutionContext, type SubstitutionContext } from "./substitution-context.ts";
+import { hasGlobCharacters, parseGlobParts } from "./glob.ts";
+
+export const computeBareWordParts: PartsResolver = (_source, word) =>
+  hasGlobCharacters(word.text) ? parseGlobParts(word.text, 0, word.text.length, undefined, word.pos) : undefined;
+
+export function wordPartsResolver(context: SubstitutionContext): PartsResolver {
+  return (
+    context.wordParts ?? (context.wordParts = (source, word, depth) => computeWordParts(source, word, depth, context))
+  );
+}
+
+export function embeddedPartsResolver(context: SubstitutionContext): PartsResolver {
+  return (
+    context.embeddedParts ??
+    (context.embeddedParts = (source, word, depth) => computeEmbeddedWordParts(source, word, depth, context))
+  );
+}
+
+export function arrayPartsResolver(context: SubstitutionContext): PartsResolver {
+  return (
+    context.arrayParts ??
+    (context.arrayParts = (source, word, depth) => computeArrayElementParts(source, word, depth, context))
+  );
+}
+
+/**
+ * Compute the structural parts of a word by re-scanning the source.
+ * This is the "cold path" — only called when consumers actually need parts.
+ *
+ * Returns undefined for simple words (no quotes, expansions, or special structure).
+ */
+export function computeWordParts(
+  source: string,
+  word: Pick<Word, "pos" | "end">,
+  depth = 0,
+  context: SubstitutionContext = createSubstitutionContext(),
+): WordPart[] | undefined {
+  // Bound the re-lex to the word's span. A word inside a substitution script carries the
+  // whole original as its source, so an unbounded scan would overrun the word into an
+  // adjacent delimiter (e.g. a backtick or `)` immediately after it). For top-level words
+  // word.end is the natural boundary, so the bound is a no-op.
+  const lexer = new Lexer(source, word.pos, word.end, false, context);
+  lexer._nestingDepth = depth;
+  const parts = lexer.buildWordParts(word.pos);
+  return parts ?? undefined;
+}
+
+/** Compute structural parts for a word-like span that may contain shell operators or whitespace. */
+export function computeEmbeddedWordParts(
+  source: string,
+  word: Pick<Word, "pos" | "end">,
+  depth = 0,
+  context: SubstitutionContext,
+  arithmetic = false,
+): WordPart[] | undefined {
+  if (!hasEmbeddedWordStructure(source, word.pos, word.end)) return undefined;
+  const lexer = new Lexer(source, word.pos, word.end, false, context);
+  lexer._nestingDepth = depth;
+  const parts = lexer.buildEmbeddedWordParts(word.pos, arithmetic);
+  return parts ?? undefined;
+}
+
+export function computeArrayElementParts(
+  source: string,
+  word: Word,
+  depth = 0,
+  context: SubstitutionContext,
+): WordPart[] | undefined {
+  const lexer = new Lexer(source, word.pos, word.end, false, context);
+  lexer._nestingDepth = depth;
+  const parts = lexer.buildArrayElementParts(word.pos);
+  return parts ?? undefined;
+}
+
+/**
+ * Compute parts for an unquoted heredoc body.
+ * Heredoc bodies use different scanning rules than shell words: newlines are
+ * literal and single/double quotes have no special meaning.
+ */
+export function computeHereDocBodyParts(
+  source: string,
+  word: Pick<Word, "pos" | "end">,
+  depth = 0,
+  context: SubstitutionContext,
+): WordPart[] | undefined {
+  const lexer = new Lexer(source, word.pos, word.end, false, context);
+  lexer._nestingDepth = depth;
+  const parts = lexer.buildHereDocParts(word.pos, word.end);
+  return parts ?? undefined;
+}

package/src/vendor/unbash/substitution-context.ts

@@ -0,0 +1,20 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { PartsResolver } from "./word.ts";
+
+export interface SubstitutionContext {
+  boundaries: Map<number, number> | undefined;
+  wordParts: PartsResolver | undefined;
+  embeddedParts: PartsResolver | undefined;
+  arrayParts: PartsResolver | undefined;
+}
+
+// A nested script shares its parent's boundary cache, allocated on first use.
+export function createSubstitutionContext(parent?: SubstitutionContext): SubstitutionContext {
+  const boundaries = parent === undefined ? undefined : substitutionBoundaries(parent);
+  return { boundaries, wordParts: undefined, embeddedParts: undefined, arrayParts: undefined };
+}
+
+export function substitutionBoundaries(context: SubstitutionContext): Map<number, number> {
+  return context.boundaries ?? (context.boundaries = new Map());
+}

package/src/vendor/unbash/traversal.ts

@@ -0,0 +1,182 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { SyntaxNode } from "./types.ts";
+
+export function forEachChild(node: SyntaxNode, callback: (child: SyntaxNode) => void): void {
+  switch (node.type) {
+    case "Script":
+    case "CompoundList":
+    case "AndOr":
+      for (const command of node.commands) callback(command);
+      return;
+    case "Statement":
+      callback(node.command);
+      return;
+    case "Command":
+      for (const child of node.prefix) callback(child);
+      if (node.name) callback(node.name);
+      for (const child of node.suffix) callback(child);
+      return;
+    case "Pipeline":
+      for (const prefix of node.prefixes) callback(prefix);
+      for (const command of node.commands) callback(command);
+      return;
+    case "Redirected":
+      callback(node.command);
+      for (const redirect of node.redirects) callback(redirect);
+      return;
+    case "If":
+      callback(node.clause);
+      callback(node.then);
+      for (const branch of node.elif) callback(branch);
+      if (node.else) callback(node.else);
+      return;
+    case "Elif":
+      callback(node.clause);
+      callback(node.then);
+      return;
+    case "For":
+    case "Select":
+      callback(node.name);
+      if (node.wordlist) for (const word of node.wordlist) callback(word);
+      callback(node.body);
+      return;
+    case "While":
+      callback(node.clause);
+      callback(node.body);
+      return;
+    case "Function":
+    case "Coproc":
+      if (node.name) callback(node.name);
+      callback(node.body);
+      return;
+    case "Subshell":
+    case "BraceGroup":
+      callback(node.body);
+      return;
+    case "Case":
+      callback(node.word);
+      for (const item of node.items) callback(item);
+      return;
+    case "CaseItem":
+      for (const pattern of node.pattern) callback(pattern);
+      callback(node.body);
+      return;
+    case "ArithmeticFor": {
+      const initialize = node.initialize;
+      if (initialize) callback(initialize);
+      const test = node.test;
+      if (test) callback(test);
+      const update = node.update;
+      if (update) callback(update);
+      callback(node.body);
+      return;
+    }
+    case "Word":
+    case "Glob":
+    case "ArithmeticWord":
+    case "HereDocBody":
+    case "BraceExpansion":
+    case "ExtendedGlob": {
+      const parts = node.parts;
+      if (parts) for (const part of parts) callback(part);
+      return;
+    }
+    case "DoubleQuoted":
+    case "LocaleString":
+      for (const part of node.parts) callback(part);
+      return;
+    case "ParameterExpansion":
+      if (node.index) callback(node.index);
+      if (node.operation) callback(node.operation);
+      return;
+    case "Default":
+    case "Remove":
+    case "Transform":
+      callback(node.operand);
+      return;
+    case "CaseModification":
+      if (node.operand) callback(node.operand);
+      return;
+    case "Replace":
+      callback(node.pattern);
+      callback(node.replacement);
+      return;
+    case "Slice":
+      callback(node.offset);
+      if (node.length) callback(node.length);
+      return;
+    case "Assignment": {
+      const index = node.index;
+      if (index) callback(index);
+      callback(node.value);
+      return;
+    }
+    case "ArrayValue":
+      for (const element of node.elements) callback(element);
+      return;
+    case "Redirect":
+    case "HereString":
+      if (node.descriptor) callback(node.descriptor);
+      if (node.target) callback(node.target);
+      return;
+    case "HereDoc":
+      if (node.descriptor) callback(node.descriptor);
+      if (node.delimiter) callback(node.delimiter);
+      callback(node.body);
+      return;
+    case "CommandExpansion":
+    case "ProcessSubstitution":
+    case "ArithmeticCommandExpansion": {
+      const script = node.script;
+      if (script) callback(script);
+      return;
+    }
+    case "ArithmeticExpansion":
+    case "ArithmeticCommand":
+    case "ArithmeticGroup":
+    case "TestCommand":
+    case "TestGroup": {
+      const expression = node.expression;
+      if (expression) callback(expression);
+      return;
+    }
+    case "ArithmeticBinary":
+    case "TestBinary":
+      callback(node.left);
+      callback(node.right);
+      return;
+    case "ArithmeticUnary":
+    case "TestUnary":
+      callback(node.operand);
+      return;
+    case "ArithmeticTernary":
+      callback(node.test);
+      callback(node.consequent);
+      callback(node.alternate);
+      return;
+    case "TestLogical":
+      for (const operand of node.operands) callback(operand);
+      return;
+    case "TestNot":
+      for (const negation of node.negations) callback(negation);
+      callback(node.operand);
+      return;
+    case "Literal":
+    case "SingleQuoted":
+    case "AnsiCQuoted":
+    case "SimpleExpansion":
+    case "Names":
+    case "Unknown":
+    case "FileDescriptor":
+    case "FileDescriptorVariable":
+    case "HereDocDelimiter":
+    case "Time":
+    case "Negation":
+      return;
+    default: {
+      const exhaustive: never = node;
+      throw new TypeError(`Unexpected syntax node: ${exhaustive}`);
+    }
+  }
+}