shell-dsl 0.0.35 → 0.0.37

package/dist/types/src/commands/index.d.ts

@@ -26,4 +26,5 @@ export { colon } from "./colon/colon.ts";
 export { cd } from "./cd/cd.ts";
 export { tr } from "./tr/tr.ts";
 export { cut } from "./cut/cut.ts";
+export { od } from "./od/od.ts";
 export declare const builtinCommands: Record<string, Command>;

package/dist/types/src/commands/od/od.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.ts";
+export declare const od: Command;

package/dist/types/src/index.d.ts

@@ -6,8 +6,8 @@ export { ShellError, LexError, ParseError } from "./errors.ts";
 export { Lexer, lex, tokenToString } from "./lexer/index.ts";
 export type { Token, RedirectMode } from "./lexer/index.ts";
 export { Parser, parse } from "./parser/index.ts";
-export type { ASTNode, Redirect, CommandNode, PipelineNode, AndNode, OrNode, SequenceNode, LiteralNode, VariableNode, SubstitutionNode, GlobNode, ConcatNode, IfNode, ForNode, WhileNode, UntilNode, CaseNode, CaseClause, ArithmeticNode, } from "./parser/index.ts";
-export { isCommandNode, isPipelineNode, isAndNode, isOrNode, isSequenceNode, isLiteralNode, isVariableNode, isSubstitutionNode, isGlobNode, isConcatNode, isIfNode, isForNode, isWhileNode, isUntilNode, isCaseNode, isArithmeticNode, } from "./parser/index.ts";
+export type { ASTNode, Redirect, CommandNode, PipelineNode, AndNode, OrNode, SequenceNode, WordNode, WordPart, TextPart, VariablePart, SubstitutionPart, ArithmeticPart, IfNode, ForNode, WhileNode, UntilNode, CaseNode, CaseClause, } from "./parser/index.ts";
+export { isWordNode, isCommandNode, isPipelineNode, isAndNode, isOrNode, isSequenceNode, isIfNode, isForNode, isWhileNode, isUntilNode, isCaseNode, } from "./parser/index.ts";
 export { Interpreter, type InterpreterOptions, BreakException, ContinueException } from "./interpreter/index.ts";
 export { createVirtualFS } from "./fs/index.ts";
 export { FileSystem, ReadOnlyFileSystem, WebFileSystem, createWebUnderlyingFS, type PathOps, type Permission, type PermissionRules, type UnderlyingFS, } from "./fs/index.ts";

package/dist/types/src/interpreter/interpreter.d.ts

@@ -42,7 +42,21 @@ export declare class Interpreter {
     private executeUntil;
     private executeCase;
     private matchCasePattern;
-    private evaluateNode;
+    private expandCommandWords;
+    private expandWordForCommand;
+    private expandWordScalar;
+    private expandWordFields;
+    private expandWordPart;
+    private executeSubstitution;
+    private getIFS;
+    private splitUnquotedExpansion;
+    private createExpandedField;
+    private appendSegment;
+    private expandPathname;
+    private hasUnquotedGlobMeta;
+    private fieldToString;
+    private fieldToGlobPattern;
+    private escapeLiteralGlobChars;
     private evaluateArithmetic;
     private parseArithmeticExpr;
     setCwd(cwd: string): void;

package/dist/types/src/parser/ast.d.ts

@@ -1,18 +1,43 @@
 export type RedirectMode = ">" | ">>" | "<" | "2>" | "2>>" | "&>" | "&>>" | "2>&1" | "1>&2";
+export interface TextPart {
+    type: "text";
+    value: string;
+    quoted: boolean;
+}
+export interface VariablePart {
+    type: "variable";
+    name: string;
+    quoted: boolean;
+}
+export interface SubstitutionPart {
+    type: "substitution";
+    command: ASTNode;
+    quoted: boolean;
+}
+export interface ArithmeticPart {
+    type: "arithmetic";
+    expression: string;
+    quoted: boolean;
+}
+export type WordPart = TextPart | VariablePart | SubstitutionPart | ArithmeticPart;
+export interface WordNode {
+    type: "word";
+    parts: WordPart[];
+}
 export interface Redirect {
     mode: RedirectMode;
-    target: ASTNode;
+    target: WordNode;
     heredocContent?: boolean;
 }
-export type ASTNode = CommandNode | PipelineNode | AndNode | OrNode | SequenceNode | LiteralNode | VariableNode | SubstitutionNode | GlobNode | ConcatNode | IfNode | ForNode | WhileNode | UntilNode | CaseNode | ArithmeticNode;
+export type ASTNode = CommandNode | PipelineNode | AndNode | OrNode | SequenceNode | IfNode | ForNode | WhileNode | UntilNode | CaseNode;
 export interface CommandNode {
     type: "command";
-    name: ASTNode;
-    args: ASTNode[];
+    name: WordNode;
+    args: WordNode[];
     redirects: Redirect[];
     assignments: Array<{
         name: string;
-        value: ASTNode;
+        value: WordNode;
     }>;
 }
 export interface PipelineNode {
@@ -33,26 +58,6 @@ export interface SequenceNode {
     type: "sequence";
     commands: ASTNode[];
 }
-export interface LiteralNode {
-    type: "literal";
-    value: string;
-}
-export interface VariableNode {
-    type: "variable";
-    name: string;
-}
-export interface SubstitutionNode {
-    type: "substitution";
-    command: ASTNode;
-}
-export interface GlobNode {
-    type: "glob";
-    pattern: string;
-}
-export interface ConcatNode {
-    type: "concat";
-    parts: ASTNode[];
-}
 export interface IfNode {
     type: "if";
     condition: ASTNode;
@@ -66,7 +71,7 @@ export interface IfNode {
 export interface ForNode {
     type: "for";
     variable: string;
-    items: ASTNode[];
+    items: WordNode[];
     body: ASTNode;
 }
 export interface WhileNode {
@@ -80,31 +85,22 @@ export interface UntilNode {
     body: ASTNode;
 }
 export interface CaseClause {
-    patterns: ASTNode[];
+    patterns: WordNode[];
     body: ASTNode;
 }
 export interface CaseNode {
     type: "case";
-    word: ASTNode;
+    word: WordNode;
     clauses: CaseClause[];
 }
-export interface ArithmeticNode {
-    type: "arithmetic";
-    expression: string;
-}
+export declare function isWordNode(node: ASTNode | WordNode): node is WordNode;
 export declare function isCommandNode(node: ASTNode): node is CommandNode;
 export declare function isPipelineNode(node: ASTNode): node is PipelineNode;
 export declare function isAndNode(node: ASTNode): node is AndNode;
 export declare function isOrNode(node: ASTNode): node is OrNode;
 export declare function isSequenceNode(node: ASTNode): node is SequenceNode;
-export declare function isLiteralNode(node: ASTNode): node is LiteralNode;
-export declare function isVariableNode(node: ASTNode): node is VariableNode;
-export declare function isSubstitutionNode(node: ASTNode): node is SubstitutionNode;
-export declare function isGlobNode(node: ASTNode): node is GlobNode;
-export declare function isConcatNode(node: ASTNode): node is ConcatNode;
 export declare function isIfNode(node: ASTNode): node is IfNode;
 export declare function isForNode(node: ASTNode): node is ForNode;
 export declare function isWhileNode(node: ASTNode): node is WhileNode;
 export declare function isUntilNode(node: ASTNode): node is UntilNode;
 export declare function isCaseNode(node: ASTNode): node is CaseNode;
-export declare function isArithmeticNode(node: ASTNode): node is ArithmeticNode;

package/dist/types/src/parser/index.d.ts

@@ -1,3 +1,3 @@
 export { Parser, parse } from "./parser.ts";
-export type { ASTNode, Redirect, RedirectMode, CommandNode, PipelineNode, AndNode, OrNode, SequenceNode, LiteralNode, VariableNode, SubstitutionNode, GlobNode, ConcatNode, IfNode, ForNode, WhileNode, UntilNode, CaseNode, CaseClause, ArithmeticNode, } from "./ast.ts";
-export { isCommandNode, isPipelineNode, isAndNode, isOrNode, isSequenceNode, isLiteralNode, isVariableNode, isSubstitutionNode, isGlobNode, isConcatNode, isIfNode, isForNode, isWhileNode, isUntilNode, isCaseNode, isArithmeticNode, } from "./ast.ts";
+export type { ASTNode, Redirect, RedirectMode, CommandNode, PipelineNode, AndNode, OrNode, SequenceNode, WordNode, WordPart, TextPart, VariablePart, SubstitutionPart, ArithmeticPart, IfNode, ForNode, WhileNode, UntilNode, CaseNode, CaseClause, } from "./ast.ts";
+export { isWordNode, isCommandNode, isPipelineNode, isAndNode, isOrNode, isSequenceNode, isIfNode, isForNode, isWhileNode, isUntilNode, isCaseNode, } from "./ast.ts";

package/dist/types/src/parser/parser.d.ts

@@ -19,12 +19,15 @@ export declare class Parser {
     private parseCasePattern;
     private parseCaseBody;
     private parseCompoundList;
+    private createNoopCommand;
+    private createTextWord;
     private isCompoundListTerminator;
     private checkKeyword;
     private expectKeyword;
     private parseCommand;
     private parseWordArg;
-    private tokenToNode;
+    private tokenToWord;
+    private tokenToWordParts;
     private parseDoubleQuoteParts;
     private parseHeredocContent;
     private parseRedirect;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "A sandboxed shell-style DSL for running scriptable command pipelines in-process without host OS access",
   "author": "ricsam <oss@ricsam.dev>",
   "license": "MIT",