@ykdz/template 0.0.35 → 0.0.37

package/node_modules/unbash/dist/chars.js

@@ -0,0 +1,41 @@
+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;

package/node_modules/unbash/dist/command.d.ts

@@ -0,0 +1,14 @@
+import type { Command, CommandArgument, Redirection, Word } from "./internal-types.ts";
+export declare class CommandImpl implements Command {
+    #private;
+    type: "Command";
+    pos: number;
+    end: number;
+    name: Word | undefined;
+    prefix: Command["prefix"];
+    suffix: Command["suffix"];
+    constructor(pos: number, end: number, name: Word | undefined, prefix: Command["prefix"], suffix: Command["suffix"]);
+    get args(): CommandArgument[];
+    get redirects(): Redirection[];
+    toJSON(): Omit<Command, "args" | "redirects">;
+}

package/node_modules/unbash/dist/command.js

@@ -0,0 +1,41 @@
+const isArgument = (item) => item.type === "Word" || item.type === "Assignment";
+export class CommandImpl {
+    type = "Command";
+    pos;
+    end;
+    name;
+    prefix;
+    suffix;
+    #args;
+    #redirects;
+    constructor(pos, end, name, prefix, suffix) {
+        this.pos = pos;
+        this.end = end;
+        this.name = name;
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+    get args() {
+        if (this.#args === undefined) {
+            const suffix = this.suffix;
+            this.#args = suffix.every(isArgument) ? suffix : suffix.filter(isArgument);
+        }
+        return this.#args;
+    }
+    get redirects() {
+        if (this.#redirects === undefined) {
+            const redirects = [];
+            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() {
+        return { type: this.type, pos: this.pos, end: this.end, name: this.name, prefix: this.prefix, suffix: this.suffix };
+    }
+}

package/node_modules/unbash/dist/heredoc.d.ts

@@ -0,0 +1,18 @@
+import type { HereDocBody, WordPart } from "./internal-types.ts";
+export declare class HereDocBodyImpl implements HereDocBody {
+    #private;
+    static _resolveParts: (source: string, body: HereDocBody, depth: number) => WordPart[] | undefined;
+    type: "HereDocBody";
+    pos: number;
+    end: number;
+    text: string;
+    constructor(source: string, pos: number, quoted: boolean, depth: number);
+    get parts(): WordPart[] | undefined;
+    toJSON(): {
+        type: "HereDocBody";
+        pos: number;
+        end: number;
+        text: string;
+        parts: WordPart[] | undefined;
+    };
+}

package/node_modules/unbash/dist/heredoc.js

@@ -0,0 +1,25 @@
+export class HereDocBodyImpl {
+    static _resolveParts;
+    type = "HereDocBody";
+    pos;
+    end;
+    text = "";
+    #source;
+    #depth;
+    #parts;
+    constructor(source, pos, quoted, depth) {
+        this.pos = pos;
+        this.end = pos;
+        this.#source = source;
+        this.#depth = depth;
+        this.#parts = quoted ? undefined : null;
+    }
+    get parts() {
+        if (this.#parts === null)
+            this.#parts = HereDocBodyImpl._resolveParts(this.#source, this, this.#depth);
+        return this.#parts;
+    }
+    toJSON() {
+        return { type: this.type, pos: this.pos, end: this.end, text: this.text, parts: this.parts };
+    }
+}

package/node_modules/unbash/dist/internal-types.d.ts

@@ -0,0 +1,87 @@
+import type * as Public from "./types.ts";
+type Mutable<T> = {
+    -readonly [K in keyof T]: Mutable<T[K]>;
+};
+export type Word = Mutable<Public.Word>;
+export type LiteralPart = Mutable<Public.LiteralPart>;
+export type SingleQuotedPart = Mutable<Public.SingleQuotedPart>;
+export type DoubleQuotedPart = Mutable<Public.DoubleQuotedPart>;
+export type AnsiCQuotedPart = Mutable<Public.AnsiCQuotedPart>;
+export type LocaleStringPart = Mutable<Public.LocaleStringPart>;
+export type SimpleExpansionPart = Mutable<Public.SimpleExpansionPart>;
+export type ParameterExpansionPart = Mutable<Public.ParameterExpansionPart>;
+export type ParameterDefaultOperation = Mutable<Public.ParameterDefaultOperation>;
+export type ParameterRemoveOperation = Mutable<Public.ParameterRemoveOperation>;
+export type ParameterReplaceOperation = Mutable<Public.ParameterReplaceOperation>;
+export type ParameterSliceOperation = Mutable<Public.ParameterSliceOperation>;
+export type ParameterCaseOperation = Mutable<Public.ParameterCaseOperation>;
+export type ParameterTransformOperation = Mutable<Public.ParameterTransformOperation>;
+export type ParameterNamesOperation = Mutable<Public.ParameterNamesOperation>;
+export type ParameterUnknownOperation = Mutable<Public.ParameterUnknownOperation>;
+export type ParameterOperation = Mutable<Public.ParameterOperation>;
+export type CommandExpansionPart = Mutable<Public.CommandExpansionPart>;
+export type ArithmeticExpansionPart = Mutable<Public.ArithmeticExpansionPart>;
+export type ProcessSubstitutionPart = Mutable<Public.ProcessSubstitutionPart>;
+export type ExtGlobOperator = Public.ExtGlobOperator;
+export type ExtendedGlobPart = Mutable<Public.ExtendedGlobPart>;
+export type BraceExpansionPart = Mutable<Public.BraceExpansionPart>;
+export type ArithmeticExpression = Mutable<Public.ArithmeticExpression>;
+export type ArithmeticBinary = Mutable<Public.ArithmeticBinary>;
+export type ArithmeticUnary = Mutable<Public.ArithmeticUnary>;
+export type ArithmeticTernary = Mutable<Public.ArithmeticTernary>;
+export type ArithmeticGroup = Mutable<Public.ArithmeticGroup>;
+export type ArithmeticWord = Mutable<Public.ArithmeticWord>;
+export type ArithmeticCommandExpansion = Mutable<Public.ArithmeticCommandExpansion>;
+export type DoubleQuotedChild = Mutable<Public.DoubleQuotedChild>;
+export type WordPart = Mutable<Public.WordPart>;
+export type Assignment = Mutable<Public.Assignment>;
+export type ArrayValue = Mutable<Public.ArrayValue>;
+export type AssignmentPrefix = Mutable<Public.AssignmentPrefix>;
+export type CommandArgument = Mutable<Public.CommandArgument>;
+export type RedirectOperator = Public.RedirectOperator;
+export type Redirection = Mutable<Public.Redirection>;
+export type RedirectDescriptor = Mutable<Public.RedirectDescriptor>;
+export type Redirect = Mutable<Public.Redirect>;
+export type HereString = Mutable<Public.HereString>;
+export type HereDoc = Mutable<Public.HereDoc>;
+export type HereDocDelimiter = Mutable<Public.HereDocDelimiter>;
+export type HereDocBody = Mutable<Public.HereDocBody>;
+export type Command = Mutable<Public.Command>;
+export type Redirected = Mutable<Public.Redirected>;
+export type CompoundCommand = Mutable<Public.CompoundCommand>;
+export type PipeOperator = Public.PipeOperator;
+export type CommandNode = Mutable<Public.CommandNode>;
+export type PipelineNode = Mutable<Public.PipelineNode>;
+export type Pipeline = Mutable<Public.Pipeline>;
+export type Time = Mutable<Public.Time>;
+export type Negation = Mutable<Public.Negation>;
+export type LogicalOperator = Public.LogicalOperator;
+export type AndOr = Mutable<Public.AndOr>;
+export type If = Mutable<Public.If>;
+export type For = Mutable<Public.For>;
+export type WhileKind = Public.WhileKind;
+export type While = Mutable<Public.While>;
+export type Function = Mutable<Public.Function>;
+export type Subshell = Mutable<Public.Subshell>;
+export type BraceGroup = Mutable<Public.BraceGroup>;
+export type CompoundList = Mutable<Public.CompoundList>;
+export type Case = Mutable<Public.Case>;
+export type CaseTerminator = Public.CaseTerminator;
+export type CaseItem = Mutable<Public.CaseItem>;
+export type Select = Mutable<Public.Select>;
+export type Coproc = Mutable<Public.Coproc>;
+export type ArithmeticFor = Mutable<Public.ArithmeticFor>;
+export type TestExpression = Mutable<Public.TestExpression>;
+export type TestUnaryExpression = Mutable<Public.TestUnaryExpression>;
+export type TestBinaryExpression = Mutable<Public.TestBinaryExpression>;
+export type TestLogicalExpression = Mutable<Public.TestLogicalExpression>;
+export type TestNotExpression = Mutable<Public.TestNotExpression>;
+export type TestGroupExpression = Mutable<Public.TestGroupExpression>;
+export type TestCommand = Mutable<Public.TestCommand>;
+export type ArithmeticCommand = Mutable<Public.ArithmeticCommand>;
+export type Statement = Mutable<Public.Statement>;
+export type SyntaxNode = Mutable<Public.SyntaxNode>;
+export type Script = Mutable<Public.Script>;
+export type ParsedScript = Mutable<Public.ParsedScript>;
+export type ParseError = Mutable<Public.ParseError>;
+export {};

package/node_modules/unbash/dist/internal-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/unbash/dist/lexer.d.ts

@@ -0,0 +1,202 @@
+import type { ArithmeticCommandExpansion, CommandExpansionPart, HereDoc, ParseError, ProcessSubstitutionPart, WordPart } from "./internal-types.ts";
+export declare const MAX_SYNTAX_NESTING = 256;
+export declare const Token: {
+    readonly Word: 0;
+    readonly Assignment: 1;
+    readonly Semi: 2;
+    readonly Newline: 3;
+    readonly Pipe: 4;
+    readonly And: 5;
+    readonly Or: 6;
+    readonly Amp: 7;
+    readonly LParen: 8;
+    readonly RParen: 9;
+    readonly LBrace: 10;
+    readonly RBrace: 11;
+    readonly Bang: 12;
+    readonly If: 13;
+    readonly Then: 14;
+    readonly Else: 15;
+    readonly Elif: 16;
+    readonly Fi: 17;
+    readonly Do: 18;
+    readonly Done: 19;
+    readonly For: 20;
+    readonly While: 21;
+    readonly Until: 22;
+    readonly In: 23;
+    readonly Case: 24;
+    readonly Esac: 25;
+    readonly Function: 26;
+    readonly DoubleSemi: 27;
+    readonly SemiAmp: 28;
+    readonly DoubleSemiAmp: 29;
+    readonly Select: 30;
+    readonly DblLBracket: 31;
+    readonly DblRBracket: 32;
+    readonly EOF: 33;
+    readonly ArithCmd: 34;
+    readonly Coproc: 35;
+    readonly Redirect: 36;
+};
+export type Token = (typeof Token)[keyof typeof Token];
+export declare class TokenValue {
+    token: Token;
+    _value: string | null;
+    _owner: Lexer | null;
+    pos: number;
+    end: number;
+    fileDescriptor: number | undefined;
+    variableName: string | undefined;
+    descriptorEnd: number;
+    delimiterQuoted: boolean;
+    content: string | undefined;
+    targetPos: number;
+    targetEnd: number;
+    assignmentOperatorPos: number;
+    raw: boolean;
+    keywordEligible: boolean;
+    constructor(owner?: Lexer | null);
+    get value(): string;
+    set value(v: string);
+    reset(): void;
+    copyFrom(other: TokenValue): void;
+}
+export declare function requiresFunctionKeyword(name: string): boolean;
+export declare function skipLineContinuations(source: string, pos: number, end: number): number;
+export declare function hasEmbeddedWordStructure(source: string, start: number, end: number): boolean;
+type DeferredCommandExpansion = [
+    CommandExpansionPart | ProcessSubstitutionPart | ArithmeticCommandExpansion,
+    number,
+    string,
+    number | undefined,
+    boolean
+];
+export declare const LexContext: {
+    readonly Normal: 0;
+    readonly CommandStart: 1;
+    readonly TestMode: 2;
+    readonly CommandPrefix: 3;
+    readonly Declaration: 4;
+    readonly ArrayElement: 5;
+};
+export type LexContext = (typeof LexContext)[keyof typeof LexContext];
+export declare class Lexer {
+    private src;
+    private srcEnd;
+    private parenBoundary;
+    private pos;
+    private current;
+    private nextState;
+    private hasPeek;
+    private pendingHereDocs;
+    private collectedExpansions;
+    _errors: ParseError[] | null;
+    _buildParts: boolean;
+    _buildValue: boolean;
+    _nestingDepth: number;
+    constructor(src: string, start?: number, end?: number, parenBoundary?: boolean);
+    getSource(): string;
+    get errors(): ParseError[];
+    getCollectedExpansions(): DeferredCommandExpansion[];
+    private collect;
+    getPos(): number;
+    /** Materialize a word token's value: raw spans slice directly, others re-lex the span. */
+    _tokenValue(pos: number, end: number, raw: boolean): string;
+    private wordValueOf;
+    /** Find the closing bracket for a shell subscript, ignoring brackets inside nested shell syntax. */
+    findClosingBracket(start: number, end?: number): number;
+    /** Find the closing bracket of `$[ … ]`, which unlike a subscript does not recurse into `${ }`. */
+    private findClosingArithmeticBracket;
+    /** Find the closing brace for a parameter expansion, ignoring braces inside nested shell syntax. */
+    findClosingBrace(start: number, end?: number): number;
+    /** Find the closing parenthesis for a shell substitution using the command-aware scanner. */
+    findClosingParenthesis(start: number, end?: number): number;
+    /** Find the end of one arithmetic expansion using the canonical lexer scanner. */
+    findArithmeticExpansionEnd(start: number, end?: number): number;
+    /** Find the end of one shell-expanded arithmetic word using the canonical lexer scanners. */
+    findArithmeticWordEnd(start: number, end?: number): number;
+    private scanArithmeticWordEnd;
+    private findClosingShellDelimiter;
+    skipSubshellBody(): number;
+    skipCompoundBody(closeToken: Token): number;
+    skipTestGroup(): number;
+    private skipTestCommandBody;
+    /** Set position and scan a word, building parts. Used by computeWordParts. */
+    buildWordParts(startPos: number): WordPart[] | null;
+    /** Scan a bounded word-like span without treating shell operators or whitespace as terminators. */
+    buildEmbeddedWordParts(startPos: number): WordPart[] | null;
+    buildArrayElementParts(startPos: number): WordPart[] | null;
+    /** Scan a heredoc body for expansions, building parts. Spaces/newlines are literal. */
+    buildHereDocParts(bodyPos: number, bodyEnd: number): WordPart[] | null;
+    registerHereDocTarget(target: HereDoc): void;
+    readTestRegexWord(): TokenValue;
+    readCStyleForExprs(): [string, string, string, number, number, number];
+    peek(ctx?: LexContext): TokenValue;
+    peekFollow(closers: Uint8Array): TokenValue;
+    next(ctx?: LexContext): TokenValue;
+    unshift(tok: TokenValue): void;
+    private readNext;
+    private tryReadOperator;
+    private readRedirection;
+    private readRedirectTargetText;
+    private redirectToken;
+    private readProcessSubstitution;
+    private readHereDocDelimiter;
+    private consumePendingHereDocs;
+    private hereDocClosingPos;
+    private hereDocClosingEnd;
+    private matchHereDocDelimiter;
+    private logicalLineEnd;
+    private skipHereDocBody;
+    private _wordText;
+    private _wordRaw;
+    private _wordQuoted;
+    private _wordHasExpansions;
+    private _wordKeywordEligible;
+    private _wordIsAssignment;
+    private _wordAssignmentOperatorPos;
+    _wordParts: WordPart[] | null;
+    private _resultText;
+    private _resultIsRaw;
+    private _resultHasExpansion;
+    private _resultPart;
+    private _unbalanced;
+    private _notArithmetic;
+    private _arithUnterminated;
+    private _dqText;
+    private _dqHasExpansions;
+    private _dqParts;
+    private _dqEnd;
+    private _hereDelim;
+    private _hereQuoted;
+    private readWord;
+    private isRedirectVariable;
+    private readArrayElement;
+    private classifyWord;
+    private readWordText;
+    private readInnerWordText;
+    private parseSubFieldWord;
+    private skipSQ;
+    private skipAnsiCQuoted;
+    private skipDQ;
+    private skipSpacesAndTabs;
+    private readDoubleQuoted;
+    private readDollar;
+    private scanArithmeticBody;
+    private readArithmeticExpansion;
+    private buildArithmeticExpression;
+    private readArithmeticCommand;
+    private readCommandSubstitution;
+    private readBraceCommandSubstitution;
+    private readValueSubstitution;
+    private readBraceSubstitution;
+    private readBacktickExpansion;
+    private readParameterExpansion;
+    private parseParamInner;
+    private findNestedShellEnd;
+    private scanParamName;
+    private readAnsiCQuoted;
+    private extractBalanced;
+}
+export {};