Refactor code to comply with ESLint rules

Major refactoring using ESLint with rules from AirBnb and Vue.

Enable most of the ESLint rules and do necessary linting in the code.
Also add more information for rules that are disabled to describe what
they are and why they are disabled.

Allow logging (`console.log`) in test files, and in development mode
(e.g. when working with `npm run serve`), but disable it when
environment is production (as pre-configured by Vue). Also add flag
(`--mode production`) in `lint:eslint` command so production linting is
executed earlier in lifecycle.

Disable rules that requires a separate work. Such as ESLint rules that
are broken in TypeScript: no-useless-constructor (eslint/eslint#14118)
and no-shadow (eslint/eslint#13014).

src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts

@@ -1,62 +1,63 @@
-import { ExpressionPosition } from './ExpressionPosition';
-import { IExpression } from './IExpression';
+import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { IReadOnlyFunctionCallArgumentCollection } from '../../Function/Call/Argument/IFunctionCallArgumentCollection';
 import { IReadOnlyFunctionParameterCollection } from '../../Function/Parameter/IFunctionParameterCollection';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { FunctionCallArgumentCollection } from '../../Function/Call/Argument/FunctionCallArgumentCollection';
-import { IExpressionEvaluationContext } from './ExpressionEvaluationContext';
-import { ExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { IExpression } from './IExpression';
+import { ExpressionPosition } from './ExpressionPosition';
+import { ExpressionEvaluationContext, IExpressionEvaluationContext } from './ExpressionEvaluationContext';
 
 export type ExpressionEvaluator = (context: IExpressionEvaluationContext) => string;
 export class Expression implements IExpression {
-    constructor(
-        public readonly position: ExpressionPosition,
-        public readonly evaluator: ExpressionEvaluator,
-        public readonly parameters: IReadOnlyFunctionParameterCollection = new FunctionParameterCollection()) {
-        if (!position) {
-            throw new Error('undefined position');
-        }
-        if (!evaluator) {
-            throw new Error('undefined evaluator');
-        }
+  constructor(
+    public readonly position: ExpressionPosition,
+    public readonly evaluator: ExpressionEvaluator,
+    public readonly parameters
+      : IReadOnlyFunctionParameterCollection = new FunctionParameterCollection(),
+  ) {
+    if (!position) {
+      throw new Error('undefined position');
     }
-    public evaluate(context: IExpressionEvaluationContext): string {
-        if (!context) {
-            throw new Error('undefined context');
-        }
-        validateThatAllRequiredParametersAreSatisfied(this.parameters, context.args);
-        const args = filterUnusedArguments(this.parameters, context.args);
-        context = new ExpressionEvaluationContext(args, context.pipelineCompiler);
-        return this.evaluator(context);
+    if (!evaluator) {
+      throw new Error('undefined evaluator');
     }
+  }
+
+  public evaluate(context: IExpressionEvaluationContext): string {
+    if (!context) {
+      throw new Error('undefined context');
+    }
+    validateThatAllRequiredParametersAreSatisfied(this.parameters, context.args);
+    const args = filterUnusedArguments(this.parameters, context.args);
+    const filteredContext = new ExpressionEvaluationContext(args, context.pipelineCompiler);
+    return this.evaluator(filteredContext);
+  }
 }
 
 function validateThatAllRequiredParametersAreSatisfied(
-    parameters: IReadOnlyFunctionParameterCollection,
-    args: IReadOnlyFunctionCallArgumentCollection,
+  parameters: IReadOnlyFunctionParameterCollection,
+  args: IReadOnlyFunctionCallArgumentCollection,
 ) {
-    const requiredParameterNames = parameters
-        .all
-        .filter((parameter) => !parameter.isOptional)
-        .map((parameter) => parameter.name);
-    const missingParameterNames = requiredParameterNames
-        .filter((parameterName) => !args.hasArgument(parameterName));
-    if (missingParameterNames.length) {
-        throw new Error(
-            `argument values are provided for required parameters: "${missingParameterNames.join('", "')}"`);
-    }
+  const requiredParameterNames = parameters
+    .all
+    .filter((parameter) => !parameter.isOptional)
+    .map((parameter) => parameter.name);
+  const missingParameterNames = requiredParameterNames
+    .filter((parameterName) => !args.hasArgument(parameterName));
+  if (missingParameterNames.length) {
+    throw new Error(
+      `argument values are provided for required parameters: "${missingParameterNames.join('", "')}"`,
+    );
+  }
 }
 
 function filterUnusedArguments(
-    parameters: IReadOnlyFunctionParameterCollection,
-    allFunctionArgs: IReadOnlyFunctionCallArgumentCollection): IReadOnlyFunctionCallArgumentCollection {
-    const specificCallArgs = new FunctionCallArgumentCollection();
-    for (const parameter of parameters.all) {
-        if (parameter.isOptional && !allFunctionArgs.hasArgument(parameter.name)) {
-            continue; // Optional parameter is not necessarily provided
-        }
-        const arg = allFunctionArgs.getArgument(parameter.name);
-        specificCallArgs.addArgument(arg);
-    }
-    return specificCallArgs;
+  parameters: IReadOnlyFunctionParameterCollection,
+  allFunctionArgs: IReadOnlyFunctionCallArgumentCollection,
+): IReadOnlyFunctionCallArgumentCollection {
+  const specificCallArgs = new FunctionCallArgumentCollection();
+  parameters.all
+    .filter((parameter) => allFunctionArgs.hasArgument(parameter.name))
+    .map((parameter) => allFunctionArgs.getArgument(parameter.name))
+    .forEach((argument) => specificCallArgs.addArgument(argument));
+  return specificCallArgs;
 }

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts

@@ -3,16 +3,17 @@ import { IPipelineCompiler } from '../Pipes/IPipelineCompiler';
 import { PipelineCompiler } from '../Pipes/PipelineCompiler';
 
 export interface IExpressionEvaluationContext {
-    readonly args: IReadOnlyFunctionCallArgumentCollection;
-    readonly pipelineCompiler: IPipelineCompiler;
+  readonly args: IReadOnlyFunctionCallArgumentCollection;
+  readonly pipelineCompiler: IPipelineCompiler;
 }
 
 export class ExpressionEvaluationContext implements IExpressionEvaluationContext {
-    constructor(
-        public readonly args: IReadOnlyFunctionCallArgumentCollection,
-        public readonly pipelineCompiler: IPipelineCompiler = new PipelineCompiler()) {
-        if (!args) {
-            throw new Error('undefined args, send empty collection instead');
-        }
+  constructor(
+    public readonly args: IReadOnlyFunctionCallArgumentCollection,
+    public readonly pipelineCompiler: IPipelineCompiler = new PipelineCompiler(),
+  ) {
+    if (!args) {
+      throw new Error('undefined args, send empty collection instead');
     }
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.ts

@@ -1,15 +1,16 @@
 export class ExpressionPosition {
-    constructor(
-        public readonly start: number,
-        public readonly end: number) {
-        if (start === end) {
-            throw new Error(`no length (start = end = ${start})`);
-        }
-        if (start > end) {
-            throw Error(`start (${start}) after end (${end})`);
-        }
-        if (start < 0) {
-            throw Error(`negative start position: ${start}`);
-        }
+  constructor(
+    public readonly start: number,
+    public readonly end: number,
+  ) {
+    if (start === end) {
+      throw new Error(`no length (start = end = ${start})`);
     }
+    if (start > end) {
+      throw Error(`start (${start}) after end (${end})`);
+    }
+    if (start < 0) {
+      throw Error(`negative start position: ${start}`);
+    }
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Expression/IExpression.ts

@@ -1,9 +1,9 @@
-import { ExpressionPosition } from './ExpressionPosition';
 import { IReadOnlyFunctionParameterCollection } from '../../Function/Parameter/IFunctionParameterCollection';
+import { ExpressionPosition } from './ExpressionPosition';
 import { IExpressionEvaluationContext } from './ExpressionEvaluationContext';
 
 export interface IExpression {
-    readonly position: ExpressionPosition;
-    readonly parameters: IReadOnlyFunctionParameterCollection;
-    evaluate(context: IExpressionEvaluationContext): string;
+  readonly position: ExpressionPosition;
+  readonly parameters: IReadOnlyFunctionParameterCollection;
+  evaluate(context: IExpressionEvaluationContext): string;
 }

src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts

@@ -1,81 +1,86 @@
+import { IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
 import { IExpressionsCompiler } from './IExpressionsCompiler';
 import { IExpression } from './Expression/IExpression';
 import { IExpressionParser } from './Parser/IExpressionParser';
 import { CompositeExpressionParser } from './Parser/CompositeExpressionParser';
-import { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
-import { ExpressionEvaluationContext } from './Expression/ExpressionEvaluationContext';
-import { IExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 
 export class ExpressionsCompiler implements IExpressionsCompiler {
-    public constructor(
-        private readonly extractor: IExpressionParser = new CompositeExpressionParser()) { }
-    public compileExpressions(
-        code: string | undefined,
-        args: IReadOnlyFunctionCallArgumentCollection): string {
-        if (!args) {
-            throw new Error('undefined args, send empty collection instead');
-        }
-        if (!code) {
-            return code;
-        }
-        const expressions = this.extractor.findExpressions(code);
-        ensureParamsUsedInCodeHasArgsProvided(expressions, args);
-        const context = new ExpressionEvaluationContext(args);
-        const compiledCode = compileExpressions(expressions, code, context);
-        return compiledCode;
+  public constructor(
+    private readonly extractor: IExpressionParser = new CompositeExpressionParser(),
+  ) { }
+
+  public compileExpressions(
+    code: string | undefined,
+    args: IReadOnlyFunctionCallArgumentCollection,
+  ): string {
+    if (!args) {
+      throw new Error('undefined args, send empty collection instead');
     }
+    if (!code) {
+      return code;
+    }
+    const expressions = this.extractor.findExpressions(code);
+    ensureParamsUsedInCodeHasArgsProvided(expressions, args);
+    const context = new ExpressionEvaluationContext(args);
+    const compiledCode = compileExpressions(expressions, code, context);
+    return compiledCode;
+  }
 }
 
 function compileExpressions(
-    expressions: readonly IExpression[],
-    code: string,
-    context: IExpressionEvaluationContext) {
-    let compiledCode = '';
-    const sortedExpressions = expressions
-        .slice() // copy the array to not mutate the parameter
-        .sort((a, b) => b.position.start - a.position.start);
-    let index = 0;
-    while (index !== code.length) {
-        const nextExpression = sortedExpressions.pop();
-        if (nextExpression) {
-            compiledCode += code.substring(index, nextExpression.position.start);
-            const expressionCode = nextExpression.evaluate(context);
-            compiledCode += expressionCode;
-            index = nextExpression.position.end;
-        } else {
-            compiledCode += code.substring(index, code.length);
-            break;
-        }
+  expressions: readonly IExpression[],
+  code: string,
+  context: IExpressionEvaluationContext,
+) {
+  let compiledCode = '';
+  const sortedExpressions = expressions
+    .slice() // copy the array to not mutate the parameter
+    .sort((a, b) => b.position.start - a.position.start);
+  let index = 0;
+  while (index !== code.length) {
+    const nextExpression = sortedExpressions.pop();
+    if (nextExpression) {
+      compiledCode += code.substring(index, nextExpression.position.start);
+      const expressionCode = nextExpression.evaluate(context);
+      compiledCode += expressionCode;
+      index = nextExpression.position.end;
+    } else {
+      compiledCode += code.substring(index, code.length);
+      break;
     }
-    return compiledCode;
+  }
+  return compiledCode;
 }
 
 function extractRequiredParameterNames(
-    expressions: readonly IExpression[]): string[] {
-    const usedParameterNames = expressions
-        .map((e) => e.parameters.all
-            .filter((p) => !p.isOptional)
-            .map((p) => p.name))
-        .filter((p) => p)
-        .flat();
-    const uniqueParameterNames = Array.from(new Set(usedParameterNames));
-    return uniqueParameterNames;
+  expressions: readonly IExpression[],
+): string[] {
+  const usedParameterNames = expressions
+    .map((e) => e.parameters.all
+      .filter((p) => !p.isOptional)
+      .map((p) => p.name))
+    .filter((p) => p)
+    .flat();
+  const uniqueParameterNames = Array.from(new Set(usedParameterNames));
+  return uniqueParameterNames;
 }
 
 function ensureParamsUsedInCodeHasArgsProvided(
-    expressions: readonly IExpression[],
-    providedArgs: IReadOnlyFunctionCallArgumentCollection): void {
-    const usedParameterNames = extractRequiredParameterNames(expressions);
-    if (!usedParameterNames?.length) {
-        return;
-    }
-    const notProvidedParameters = usedParameterNames
-        .filter((parameterName) => !providedArgs.hasArgument(parameterName));
-    if (notProvidedParameters.length) {
-        throw new Error(`parameter value(s) not provided for: ${printList(notProvidedParameters)} but used in code`);
-    }
+  expressions: readonly IExpression[],
+  providedArgs: IReadOnlyFunctionCallArgumentCollection,
+): void {
+  const usedParameterNames = extractRequiredParameterNames(expressions);
+  if (!usedParameterNames?.length) {
+    return;
+  }
+  const notProvidedParameters = usedParameterNames
+    .filter((parameterName) => !providedArgs.hasArgument(parameterName));
+  if (notProvidedParameters.length) {
+    throw new Error(`parameter value(s) not provided for: ${printList(notProvidedParameters)} but used in code`);
+  }
 }
 
 function printList(list: readonly string[]): string {
-    return `"${list.join('", "')}"`;
+  return `"${list.join('", "')}"`;
 }

src/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler.ts

@@ -1,7 +1,7 @@
 import { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
 
 export interface IExpressionsCompiler {
-    compileExpressions(
-        code: string | undefined,
-        args: IReadOnlyFunctionCallArgumentCollection): string;
+  compileExpressions(
+    code: string | undefined,
+    args: IReadOnlyFunctionCallArgumentCollection): string;
 }

src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts

@@ -1,27 +1,28 @@
 import { IExpression } from '../Expression/IExpression';
-import { IExpressionParser } from './IExpressionParser';
 import { ParameterSubstitutionParser } from '../SyntaxParsers/ParameterSubstitutionParser';
 import { WithParser } from '../SyntaxParsers/WithParser';
+import { IExpressionParser } from './IExpressionParser';
 
 const Parsers = [
-    new ParameterSubstitutionParser(),
-    new WithParser(),
+  new ParameterSubstitutionParser(),
+  new WithParser(),
 ];
 
 export class CompositeExpressionParser implements IExpressionParser {
-    public constructor(private readonly leafs: readonly IExpressionParser[] = Parsers) {
-        if (leafs.some((leaf) => !leaf)) {
-            throw new Error('undefined leaf');
-        }
+  public constructor(private readonly leafs: readonly IExpressionParser[] = Parsers) {
+    if (leafs.some((leaf) => !leaf)) {
+      throw new Error('undefined leaf');
     }
-    public findExpressions(code: string): IExpression[] {
-        const expressions = new Array<IExpression>();
-        for (const parser of this.leafs) {
-            const newExpressions = parser.findExpressions(code);
-            if (newExpressions && newExpressions.length) {
-                expressions.push(...newExpressions);
-            }
-        }
-        return expressions;
+  }
+
+  public findExpressions(code: string): IExpression[] {
+    const expressions = new Array<IExpression>();
+    for (const parser of this.leafs) {
+      const newExpressions = parser.findExpressions(code);
+      if (newExpressions && newExpressions.length) {
+        expressions.push(...newExpressions);
+      }
     }
+    return expressions;
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser.ts

@@ -1,5 +1,5 @@
 import { IExpression } from '../Expression/IExpression';
 
 export interface IExpressionParser {
-    findExpressions(code: string): IExpression[];
+  findExpressions(code: string): IExpression[];
 }

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.ts

@@ -1,59 +1,60 @@
 export class ExpressionRegexBuilder {
-    private readonly parts = new Array<string>();
+  private readonly parts = new Array<string>();
 
-    public expectCharacters(characters: string) {
-        return this.addRawRegex(
-            characters
-                .replaceAll('$', '\\$')
-                .replaceAll('.', '\\.'),
-        );
-    }
+  public expectCharacters(characters: string) {
+    return this.addRawRegex(
+      characters
+        .replaceAll('$', '\\$')
+        .replaceAll('.', '\\.'),
+    );
+  }
 
-    public expectOneOrMoreWhitespaces() {
-        return this
-            .addRawRegex('\\s+');
-    }
+  public expectOneOrMoreWhitespaces() {
+    return this
+      .addRawRegex('\\s+');
+  }
 
-    public matchPipeline() {
-        return this
-            .expectZeroOrMoreWhitespaces()
-            .addRawRegex('(\\|\\s*.+?)?');
-    }
+  public matchPipeline() {
+    return this
+      .expectZeroOrMoreWhitespaces()
+      .addRawRegex('(\\|\\s*.+?)?');
+  }
 
-    public matchUntilFirstWhitespace() {
-        return this
-            .addRawRegex('([^|\\s]+)');
-    }
+  public matchUntilFirstWhitespace() {
+    return this
+      .addRawRegex('([^|\\s]+)');
+  }
 
-    public matchAnythingExceptSurroundingWhitespaces() {
-        return this
-            .expectZeroOrMoreWhitespaces()
-            .addRawRegex('(.+?)')
-            .expectZeroOrMoreWhitespaces();
-    }
+  public matchAnythingExceptSurroundingWhitespaces() {
+    return this
+      .expectZeroOrMoreWhitespaces()
+      .addRawRegex('(.+?)')
+      .expectZeroOrMoreWhitespaces();
+  }
 
-    public expectExpressionStart() {
-        return this
-            .expectCharacters('{{')
-            .expectZeroOrMoreWhitespaces();
-    }
+  public expectExpressionStart() {
+    return this
+      .expectCharacters('{{')
+      .expectZeroOrMoreWhitespaces();
+  }
 
-    public expectExpressionEnd() {
-        return this
-            .expectZeroOrMoreWhitespaces()
-            .expectCharacters('}}');
-    }
+  public expectExpressionEnd() {
+    return this
+      .expectZeroOrMoreWhitespaces()
+      .expectCharacters('}}');
+  }
 
-    public buildRegExp(): RegExp {
-        return new RegExp(this.parts.join(''), 'g');
-    }
+  public buildRegExp(): RegExp {
+    return new RegExp(this.parts.join(''), 'g');
+  }
 
-    private expectZeroOrMoreWhitespaces() {
-        return this
-            .addRawRegex('\\s*');
-    }
-    private addRawRegex(regex: string) {
-        this.parts.push(regex);
-        return this;
-    }
+  private expectZeroOrMoreWhitespaces() {
+    return this
+      .addRawRegex('\\s*');
+  }
+
+  private addRawRegex(regex: string) {
+    this.parts.push(regex);
+    return this;
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts

@@ -6,46 +6,47 @@ import { IFunctionParameter } from '../../../Function/Parameter/IFunctionParamet
 import { FunctionParameterCollection } from '../../../Function/Parameter/FunctionParameterCollection';
 
 export abstract class RegexParser implements IExpressionParser {
-    protected abstract readonly regex: RegExp;
+  protected abstract readonly regex: RegExp;
 
-    public findExpressions(code: string): IExpression[] {
-        return Array.from(this.findRegexExpressions(code));
+  public findExpressions(code: string): IExpression[] {
+    return Array.from(this.findRegexExpressions(code));
+  }
+
+  protected abstract buildExpression(match: RegExpMatchArray): IPrimitiveExpression;
+
+  private* findRegexExpressions(code: string): Iterable<IExpression> {
+    if (!code) {
+      throw new Error('undefined code');
     }
-
-    protected abstract buildExpression(match: RegExpMatchArray): IPrimitiveExpression;
-
-    private* findRegexExpressions(code: string): Iterable<IExpression> {
-        if (!code) {
-            throw new Error('undefined code');
-        }
-        const matches = Array.from(code.matchAll(this.regex));
-        for (const match of matches) {
-            const startPos = match.index;
-            const endPos = startPos + match[0].length;
-            let position: ExpressionPosition;
-            try {
-                position = new ExpressionPosition(startPos, endPos);
-            } catch (error) {
-                throw new Error(`[${this.constructor.name}] invalid script position: ${error.message}\nRegex ${this.regex}\nCode: ${code}`);
-            }
-            const primitiveExpression = this.buildExpression(match);
-            const parameters = getParameters(primitiveExpression);
-            const expression = new Expression(position, primitiveExpression.evaluator, parameters);
-            yield expression;
-        }
+    const matches = Array.from(code.matchAll(this.regex));
+    for (const match of matches) {
+      const startPos = match.index;
+      const endPos = startPos + match[0].length;
+      let position: ExpressionPosition;
+      try {
+        position = new ExpressionPosition(startPos, endPos);
+      } catch (error) {
+        throw new Error(`[${this.constructor.name}] invalid script position: ${error.message}\nRegex ${this.regex}\nCode: ${code}`);
+      }
+      const primitiveExpression = this.buildExpression(match);
+      const parameters = getParameters(primitiveExpression);
+      const expression = new Expression(position, primitiveExpression.evaluator, parameters);
+      yield expression;
     }
+  }
 }
 
 export interface IPrimitiveExpression {
-    evaluator: ExpressionEvaluator;
-    parameters?: readonly IFunctionParameter[];
+  evaluator: ExpressionEvaluator;
+  parameters?: readonly IFunctionParameter[];
 }
 
 function getParameters(
-    expression: IPrimitiveExpression): FunctionParameterCollection {
-    const parameters  = new FunctionParameterCollection();
-    for (const parameter of expression.parameters || []) {
-        parameters.addParameter(parameter);
-    }
-    return parameters;
+  expression: IPrimitiveExpression,
+): FunctionParameterCollection {
+  const parameters = new FunctionParameterCollection();
+  for (const parameter of expression.parameters || []) {
+    parameters.addParameter(parameter);
+  }
+  return parameters;
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/IPipe.ts

@@ -1,4 +1,4 @@
 export interface IPipe {
-    readonly name: string;
-    apply(input: string): string;
+  readonly name: string;
+  apply(input: string): string;
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler.ts

@@ -1,3 +1,3 @@
 export interface IPipelineCompiler {
-    compile(value: string, pipeline: string): string;
+  compile(value: string, pipeline: string): string;
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts

@@ -1,27 +1,30 @@
 import { IPipe } from '../IPipe';
 
 export class EscapeDoubleQuotes implements IPipe {
-    public readonly name: string = 'escapeDoubleQuotes';
-    public apply(raw: string): string {
-        return raw?.replaceAll('"', '"^""');
-        /*
-            "^"" is the most robust and stable choice.
-            Other options:
-                ""
-                    Breaks, because it is fundamentally unsupported
-                """"
-                    Does not work with consecutive double quotes.
-                    E.g. PowerShell -Command "$name='aq'; Write-Host """"Disabled `""""$name`"""""""";"
-                    Works when using: PowerShell -Command "$name='aq'; Write-Host "^""Disabled `"^""$name`"^"" "^"";"
-                \"
-                    May break as they are interpreted by cmd.exe as metacharacters breaking the command
-                    E.g. PowerShell -Command "Write-Host 'Hello \"w&orld\"'" does not work due to unescaped "&"
-                    Works when using: PowerShell -Command "Write-Host 'Hello "^""w&orld"^""'"
-                \""
-                    Normalizes interior whitespace
-                    E.g. PowerShell -Command "\""a&  c\"".length", outputs 4 and discards one of two whitespaces
-                    Works when using "^"": PowerShell -Command ""^""a&  c"^"".length"
-            A good explanation: https://stackoverflow.com/a/31413730
-        */
-    }
+  public readonly name: string = 'escapeDoubleQuotes';
+
+  public apply(raw: string): string {
+    return raw?.replaceAll('"', '"^""');
+    /* eslint-disable max-len */
+    /*
+      "^"" is the most robust and stable choice.
+      Other options:
+        ""
+          Breaks, because it is fundamentally unsupported
+        """"
+          Does not work with consecutive double quotes.
+          E.g. `PowerShell -Command "$name='aq'; Write-Host """"Disabled `""""$name`"""""""";"`
+          Works when using: `PowerShell -Command "$name='aq'; Write-Host "^""Disabled `"^""$name`"^"" "^"";"`
+        \"
+          May break as they are interpreted by cmd.exe as metacharacters breaking the command
+          E.g. `PowerShell -Command "Write-Host 'Hello \"w&orld\"'"` does not work due to unescaped "&"
+          Works when using: `PowerShell -Command "Write-Host 'Hello "^""w&orld"^""'"`
+        \""
+          Normalizes interior whitespace
+          E.g. `PowerShell -Command "\""a&  c\"".length"`, outputs 4 and discards one of two whitespaces
+          Works when using "^"": `PowerShell -Command ""^""a&  c"^"".length"`
+      A good explanation: https://stackoverflow.com/a/31413730
+    */
+    /* eslint-enable max-len */
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts

@@ -1,155 +1,166 @@
 import { IPipe } from '../IPipe';
 
 export class InlinePowerShell implements IPipe {
-    public readonly name: string = 'inlinePowerShell';
-    public apply(code: string): string {
-        if (!code || !hasLines(code)) {
-            return code;
-        }
-        code = inlineComments(code);
-        code = mergeLinesWithBacktick(code);
-        code = mergeHereStrings(code);
-        const lines = getLines(code)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0);
-        return lines
-            .join('; ');
+  public readonly name: string = 'inlinePowerShell';
+
+  public apply(code: string): string {
+    if (!code || !hasLines(code)) {
+      return code;
     }
+    const processor = new Array<(data: string) => string>(...[ // for broken ESlint "indent"
+      inlineComments,
+      mergeLinesWithBacktick,
+      mergeHereStrings,
+      mergeNewLines,
+    ]).reduce((a, b) => (data) => b(a(data)));
+    const newCode = processor(code);
+    return newCode;
+  }
 }
 
 function hasLines(text: string) {
-    return text.includes('\n') || text.includes('\r');
+  return text.includes('\n') || text.includes('\r');
 }
 
 /*
-    Line comments using "#" are replaced with inline comment syntax <# comment.. #>
-    Otherwise single # comments out rest of the code
+  Line comments using "#" are replaced with inline comment syntax <# comment.. #>
+  Otherwise single # comments out rest of the code
 */
 function inlineComments(code: string): string {
-    const makeInlineComment = (comment: string) => {
-        const value = comment?.trim();
-        if (!value) {
-            return '<##>';
-        }
-        return `<# ${value} #>`;
-    };
-    return code.replaceAll(/<#.*?#>|#(.*)/g, (match, captureComment) => {
-        if (captureComment === undefined) {
+  const makeInlineComment = (comment: string) => {
+    const value = comment?.trim();
+    if (!value) {
+      return '<##>';
+    }
+    return `<# ${value} #>`;
+  };
+  return code.replaceAll(/<#.*?#>|#(.*)/g, (match, captureComment) => {
+    if (captureComment === undefined) {
+      return match;
+    }
+    return makeInlineComment(captureComment);
+  });
+  /*
+    Other alternatives considered:
+    --------------------------
+    /#(?<!<#)(?![<>])(.*)$/gm
+    -------------------------
+      ✅ Simple, yet matches and captures only what's necessary
+      ❌ Fails to match some cases
+        ❌ `Write-Host "hi" # Comment ending line inline comment but not one #>`
+        ❌ `Write-Host "hi" <#Comment starting like inline comment start but not one`
+        ❌ `Write-Host "hi" #>Comment starting like inline comment end but not one`
+      ❌ Uses lookbehind
+        Safari does not yet support lookbehind and syntax, leading application to not
+        load and throw "Invalid regular expression: invalid group specifier name"
+        https://caniuse.com/js-regexp-lookbehind
+      ⏩ Usage
+        return code.replaceAll(/#(?<!<#)(?![<>])(.*)$/gm, (match, captureComment) => {
+          return makeInlineComment(captureComment)
+        });
+    ----------------
+    /<#.*?#>|#(.*)/g
+    ----------------
+      ✅ Simple yet affective
+      ❌ Matches all comments, but only captures dash comments
+      ❌ Fails to match some cases
+        ❌ `Write-Host "hi" # Comment ending line inline comment but not one #>`
+        ❌ `Write-Host "hi" <#Comment starting like inline comment start but not one`
+      ⏩ Usage
+        return code.replaceAll(/<#.*?#>|#(.*)/g, (match, captureComment) => {
+          if (captureComment === undefined) {
             return match;
-        }
-        return makeInlineComment(captureComment);
-    });
-    /*
-        Other alternatives considered:
-            --------------------------
-            /#(?<!<#)(?![<>])(.*)$/gm
-            -------------------------
-                ✅ Simple, yet matches and captures only what's necessary
-                ❌ Fails to match some cases
-                    ❌ `Write-Host "hi" # Comment ending line inline comment but not one #>`
-                    ❌ `Write-Host "hi" <#Comment starting like inline comment start but not one`
-                    ❌ `Write-Host "hi" #>Comment starting like inline comment end but not one`
-                ❌ Uses lookbehind
-                    Safari does not yet support lookbehind and syntax, leading application to not
-                    load and throw "Invalid regular expression: invalid group specifier name"
-                    https://caniuse.com/js-regexp-lookbehind
-                ⏩ Usage
-                    return code.replaceAll(/#(?<!<#)(?![<>])(.*)$/gm, (match, captureComment) => {
-                        return makeInlineComment(captureComment)
-                    });
-            ----------------
-            /<#.*?#>|#(.*)/g
-            ----------------
-                ✅ Simple yet affective
-                ❌ Matches all comments, but only captures dash comments
-                ❌ Fails to match some cases
-                    ❌ `Write-Host "hi" # Comment ending line inline comment but not one #>`
-                    ❌ `Write-Host "hi" <#Comment starting like inline comment start but not one`
-                ⏩ Usage
-                    return code.replaceAll(/<#.*?#>|#(.*)/g, (match, captureComment) => {
-                        if (captureComment === undefined) {
-                            return match;
-                        }
-                        return makeInlineComment(captureComment);
-                    });
-            ------------------------------------
-            /(^(?:<#.*?#>|[^#])*)(?:(#)(.*))?/gm
-            ------------------------------------
-                ✅ Covers all cases
-                ❌ Matches every line, three capture groups are used to build result
-                ⏩ Usage
-                    return code.replaceAll(/(^(?:<#.*?#>|[^#])*)(?:(#)(.*))?/gm,
-                        (match, captureLeft, captureDash, captureComment) => {
-                            if (!captureDash) {
-                                return match;
-                            }
-                            return captureLeft + makeInlineComment(captureComment);
-                        });
+          }
+          return makeInlineComment(captureComment);
+        });
+    ------------------------------------
+    /(^(?:<#.*?#>|[^#])*)(?:(#)(.*))?/gm
+    ------------------------------------
+      ✅ Covers all cases
+      ❌ Matches every line, three capture groups are used to build result
+      ⏩ Usage
+        return code.replaceAll(/(^(?:<#.*?#>|[^#])*)(?:(#)(.*))?/gm,
+          (match, captureLeft, captureDash, captureComment) => {
+            if (!captureDash) {
+              return match;
+            }
+            return captureLeft + makeInlineComment(captureComment);
+          });
     */
 }
 
-function getLines(code: string): string [] {
-    return (code?.split(/\r\n|\r|\n/) || []);
+function getLines(code: string): string[] {
+  return (code?.split(/\r\n|\r|\n/) || []);
 }
 
 /*
-    Merges inline here-strings to a single lined string with Windows line terminator (\r\n)
-    https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules#here-strings
+  Merges inline here-strings to a single lined string with Windows line terminator (\r\n)
+  https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules#here-strings
 */
 function mergeHereStrings(code: string) {
-    const regex = /@(['"])\s*(?:\r\n|\r|\n)((.|\n|\r)+?)(\r\n|\r|\n)\1@/g;
-    return code.replaceAll(regex, (_$, quotes, scope) => {
-        const newString = getHereStringHandler(quotes);
-        const escaped = scope.replaceAll(quotes, newString.escapedQuotes);
-        const lines = getLines(escaped);
-        const inlined = lines.join(newString.separator);
-        const quoted = `${newString.quotesAround}${inlined}${newString.quotesAround}`;
-        return quoted;
-    });
+  const regex = /@(['"])\s*(?:\r\n|\r|\n)((.|\n|\r)+?)(\r\n|\r|\n)\1@/g;
+  return code.replaceAll(regex, (_$, quotes, scope) => {
+    const newString = getHereStringHandler(quotes);
+    const escaped = scope.replaceAll(quotes, newString.escapedQuotes);
+    const lines = getLines(escaped);
+    const inlined = lines.join(newString.separator);
+    const quoted = `${newString.quotesAround}${inlined}${newString.quotesAround}`;
+    return quoted;
+  });
 }
 interface IInlinedHereString {
-    readonly quotesAround: string;
-    readonly escapedQuotes: string;
-    readonly separator: string;
+  readonly quotesAround: string;
+  readonly escapedQuotes: string;
+  readonly separator: string;
 }
-// We handle @' and @" differently so single quotes are interpreted literally and doubles are expandable
 function getHereStringHandler(quotes: string): IInlinedHereString {
-    const expandableNewLine = '`r`n';
-    switch (quotes) {
-        case '\'':
-            return {
-                quotesAround: '\'',
-                escapedQuotes: '\'\'',
-                separator: `\'+"${expandableNewLine}"+\'`,
-            };
-        case '"':
-            return {
-                quotesAround: '"',
-                escapedQuotes: '`"',
-                separator: expandableNewLine,
-            };
-        default:
-            throw new Error(`expected quotes: ${quotes}`);
-    }
+  /*
+    We handle @' and @" differently.
+    Single quotes are interpreted literally and doubles are expandable.
+  */
+  const expandableNewLine = '`r`n';
+  switch (quotes) {
+    case '\'':
+      return {
+        quotesAround: '\'',
+        escapedQuotes: '\'\'',
+        separator: `'+"${expandableNewLine}"+'`,
+      };
+    case '"':
+      return {
+        quotesAround: '"',
+        escapedQuotes: '`"',
+        separator: expandableNewLine,
+      };
+    default:
+      throw new Error(`expected quotes: ${quotes}`);
+  }
 }
 
 /*
-    Input ->
-        Get-Service * `
-            Sort-Object StartType `
-            Format-Table Name, ServiceType, Status -AutoSize
-    Output ->
-        Get-Service * | Sort-Object StartType | Format-Table -AutoSize
+  Input ->
+      Get-Service * `
+          Sort-Object StartType `
+          Format-Table Name, ServiceType, Status -AutoSize
+  Output ->
+      Get-Service * | Sort-Object StartType | Format-Table -AutoSize
 */
 function mergeLinesWithBacktick(code: string) {
-    /*
-        The regex actually wraps any whitespace character after backtick and before newline
-        However, this is not always the case for PowerShell.
-        I see two behaviors:
-            1. If inside string, it's accepted (inside " or ')
-            2. If part of a command, PowerShell throws "An empty pipe element is not allowed"
-        However we don't need to be so robust and handle this complexity (yet), so for easier regex
-        we wrap it anyway
-    */
-    return code.replaceAll(/ +`\s*(?:\r\n|\r|\n)\s*/g, ' ');
+  /*
+    The regex actually wraps any whitespace character after backtick and before newline
+    However, this is not always the case for PowerShell.
+    I see two behaviors:
+        1. If inside string, it's accepted (inside " or ')
+        2. If part of a command, PowerShell throws "An empty pipe element is not allowed"
+    However we don't need to be so robust and handle this complexity (yet), so for easier regex
+    we wrap it anyway
+  */
+  return code.replaceAll(/ +`\s*(?:\r\n|\r|\n)\s*/g, ' ');
+}
+
+function mergeNewLines(code: string) {
+  return getLines(code)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .join('; ');
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.ts

@@ -3,45 +3,48 @@ import { InlinePowerShell } from './PipeDefinitions/InlinePowerShell';
 import { EscapeDoubleQuotes } from './PipeDefinitions/EscapeDoubleQuotes';
 
 const RegisteredPipes = [
-    new EscapeDoubleQuotes(),
-    new InlinePowerShell(),
+  new EscapeDoubleQuotes(),
+  new InlinePowerShell(),
 ];
 
 export interface IPipeFactory {
-    get(pipeName: string): IPipe;
+  get(pipeName: string): IPipe;
 }
 
 export class PipeFactory implements IPipeFactory {
-    private readonly pipes = new Map<string, IPipe>();
-    constructor(pipes: readonly IPipe[] = RegisteredPipes) {
-        if (pipes.some((pipe) => !pipe)) {
-            throw new Error('undefined pipe in list');
-        }
-        for (const pipe of pipes) {
-            this.registerPipe(pipe);
-        }
+  private readonly pipes = new Map<string, IPipe>();
+
+  constructor(pipes: readonly IPipe[] = RegisteredPipes) {
+    if (pipes.some((pipe) => !pipe)) {
+      throw new Error('undefined pipe in list');
     }
-    public get(pipeName: string): IPipe {
-        validatePipeName(pipeName);
-        if (!this.pipes.has(pipeName)) {
-            throw new Error(`Unknown pipe: "${pipeName}"`);
-        }
-        return this.pipes.get(pipeName);
+    for (const pipe of pipes) {
+      this.registerPipe(pipe);
     }
-    private registerPipe(pipe: IPipe): void {
-        validatePipeName(pipe.name);
-        if (this.pipes.has(pipe.name)) {
-            throw new Error(`Pipe name must be unique: "${pipe.name}"`);
-        }
-        this.pipes.set(pipe.name, pipe);
+  }
+
+  public get(pipeName: string): IPipe {
+    validatePipeName(pipeName);
+    if (!this.pipes.has(pipeName)) {
+      throw new Error(`Unknown pipe: "${pipeName}"`);
     }
+    return this.pipes.get(pipeName);
+  }
+
+  private registerPipe(pipe: IPipe): void {
+    validatePipeName(pipe.name);
+    if (this.pipes.has(pipe.name)) {
+      throw new Error(`Pipe name must be unique: "${pipe.name}"`);
+    }
+    this.pipes.set(pipe.name, pipe);
+  }
 }
 
 function validatePipeName(name: string) {
-    if (!name) {
-        throw new Error('empty pipe name');
-    }
-    if (!/^[a-z][A-Za-z]*$/.test(name)) {
-        throw new Error(`Pipe name should be camelCase: "${name}"`);
-    }
+  if (!name) {
+    throw new Error('empty pipe name');
+  }
+  if (!/^[a-z][A-Za-z]*$/.test(name)) {
+    throw new Error(`Pipe name should be camelCase: "${name}"`);
+  }
 }

src/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts

@@ -2,30 +2,32 @@ import { IPipeFactory, PipeFactory } from './PipeFactory';
 import { IPipelineCompiler } from './IPipelineCompiler';
 
 export class PipelineCompiler implements IPipelineCompiler {
-    constructor(private readonly factory: IPipeFactory = new PipeFactory()) { }
-    public compile(value: string, pipeline: string): string {
-        ensureValidArguments(value, pipeline);
-        const pipeNames = extractPipeNames(pipeline);
-        const pipes = pipeNames.map((pipeName) => this.factory.get(pipeName));
-        for (const pipe of pipes) {
-            value = pipe.apply(value);
-        }
-        return value;
+  constructor(private readonly factory: IPipeFactory = new PipeFactory()) { }
+
+  public compile(value: string, pipeline: string): string {
+    ensureValidArguments(value, pipeline);
+    const pipeNames = extractPipeNames(pipeline);
+    const pipes = pipeNames.map((pipeName) => this.factory.get(pipeName));
+    let valueInCompilation = value;
+    for (const pipe of pipes) {
+      valueInCompilation = pipe.apply(valueInCompilation);
     }
+    return valueInCompilation;
+  }
 }
 
 function extractPipeNames(pipeline: string): string[] {
-    return pipeline
-        .trim()
-        .split('|')
-        .slice(1)
-        .map((p) => p.trim());
+  return pipeline
+    .trim()
+    .split('|')
+    .slice(1)
+    .map((p) => p.trim());
 }
 
 function ensureValidArguments(value: string, pipeline: string) {
-    if (!value) { throw new Error('undefined value'); }
-    if (!pipeline) { throw new Error('undefined pipeline'); }
-    if (!pipeline.trimStart().startsWith('|')) {
-        throw new Error('pipeline does not start with pipe');
-    }
+  if (!value) { throw new Error('undefined value'); }
+  if (!pipeline) { throw new Error('undefined pipeline'); }
+  if (!pipeline.trimStart().startsWith('|')) {
+    throw new Error('pipeline does not start with pipe');
+  }
 }

src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts

@@ -1,28 +1,28 @@
-import { RegexParser, IPrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { RegexParser, IPrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 
 export class ParameterSubstitutionParser extends RegexParser {
-    protected readonly regex = new ExpressionRegexBuilder()
-        .expectExpressionStart()
-        .expectCharacters('$')
-        .matchUntilFirstWhitespace()    // First match: Parameter name
-        .matchPipeline()                // Second match: Pipeline
-        .expectExpressionEnd()
-        .buildRegExp();
+  protected readonly regex = new ExpressionRegexBuilder()
+    .expectExpressionStart()
+    .expectCharacters('$')
+    .matchUntilFirstWhitespace() // First match: Parameter name
+    .matchPipeline() // Second match: Pipeline
+    .expectExpressionEnd()
+    .buildRegExp();
 
-    protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
-        const parameterName = match[1];
-        const pipeline = match[2];
-        return {
-            parameters: [ new FunctionParameter(parameterName, false) ],
-            evaluator: (context) => {
-                const argumentValue = context.args.getArgument(parameterName).argumentValue;
-                if (!pipeline) {
-                    return argumentValue;
-                }
-                return context.pipelineCompiler.compile(argumentValue, pipeline);
-            },
-        };
-    }
+  protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
+    const parameterName = match[1];
+    const pipeline = match[2];
+    return {
+      parameters: [new FunctionParameter(parameterName, false)],
+      evaluator: (context) => {
+        const { argumentValue } = context.args.getArgument(parameterName);
+        if (!pipeline) {
+          return argumentValue;
+        }
+        return context.pipelineCompiler.compile(argumentValue, pipeline);
+      },
+    };
+  }
 }

src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts

@@ -1,58 +1,59 @@
-import { RegexParser, IPrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { RegexParser, IPrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 
 export class WithParser extends RegexParser {
-    protected readonly regex = new ExpressionRegexBuilder()
-        // {{ with $parameterName }}
-        .expectExpressionStart()
-        .expectCharacters('with')
-        .expectOneOrMoreWhitespaces()
-        .expectCharacters('$')
-        .matchUntilFirstWhitespace()                    // First match: parameter name
-        .expectExpressionEnd()
-        // ...
-        .matchAnythingExceptSurroundingWhitespaces()    // Second match: Scope text
-        // {{ end }}
-        .expectExpressionStart()
-        .expectCharacters('end')
-        .expectExpressionEnd()
-        .buildRegExp();
-
-    protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
-        const parameterName = match[1];
-        const scopeText = match[2];
-        return {
-            parameters: [ new FunctionParameter(parameterName, true) ],
-            evaluator: (context) => {
-                const argumentValue = context.args.hasArgument(parameterName) ?
-                    context.args.getArgument(parameterName).argumentValue
-                    : undefined;
-                if (!argumentValue) {
-                    return '';
-                }
-                return replaceEachScopeSubstitution(scopeText, (pipeline) => {
-                    if (!pipeline) {
-                        return argumentValue;
-                    }
-                    return context.pipelineCompiler.compile(argumentValue, pipeline);
-                });
-            },
-        };
-    }
-}
-
-const ScopeSubstitutionRegEx = new ExpressionRegexBuilder()
-    // {{ . | pipeName }}
+  protected readonly regex = new ExpressionRegexBuilder()
+  // {{ with $parameterName }}
     .expectExpressionStart()
-    .expectCharacters('.')
-    .matchPipeline()    // First match: pipeline
+    .expectCharacters('with')
+    .expectOneOrMoreWhitespaces()
+    .expectCharacters('$')
+    .matchUntilFirstWhitespace() // First match: parameter name
+    .expectExpressionEnd()
+  // ...
+    .matchAnythingExceptSurroundingWhitespaces() // Second match: Scope text
+  // {{ end }}
+    .expectExpressionStart()
+    .expectCharacters('end')
     .expectExpressionEnd()
     .buildRegExp();
 
-function replaceEachScopeSubstitution(scopeText: string, replacer: (pipeline: string) => string) {
-    // Not using /{{\s*.\s*(?:(\|\s*[^{}]*?)\s*)?}}/g for not matching brackets, but let pipeline compiler fail on those
-    return scopeText.replaceAll(ScopeSubstitutionRegEx, (_$, match1 ) => {
-        return replacer(match1);
-    });
+  protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
+    const parameterName = match[1];
+    const scopeText = match[2];
+    return {
+      parameters: [new FunctionParameter(parameterName, true)],
+      evaluator: (context) => {
+        const argumentValue = context.args.hasArgument(parameterName)
+          ? context.args.getArgument(parameterName).argumentValue
+          : undefined;
+        if (!argumentValue) {
+          return '';
+        }
+        return replaceEachScopeSubstitution(scopeText, (pipeline) => {
+          if (!pipeline) {
+            return argumentValue;
+          }
+          return context.pipelineCompiler.compile(argumentValue, pipeline);
+        });
+      },
+    };
+  }
+}
+
+const ScopeSubstitutionRegEx = new ExpressionRegexBuilder()
+// {{ . | pipeName }}
+  .expectExpressionStart()
+  .expectCharacters('.')
+  .matchPipeline() // First match: pipeline
+  .expectExpressionEnd()
+  .buildRegExp();
+
+function replaceEachScopeSubstitution(scopeText: string, replacer: (pipeline: string) => string) {
+  // Not using /{{\s*.\s*(?:(\|\s*[^{}]*?)\s*)?}}/g for not matching brackets,
+  // but instead letting the pipeline compiler to fail on those.
+  return scopeText.replaceAll(ScopeSubstitutionRegEx, (_$, match1) => {
+    return replacer(match1);
+  });
 }

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts

@@ -1,13 +1,14 @@
-import { IFunctionCallArgument } from './IFunctionCallArgument';
 import { ensureValidParameterName } from '../../Shared/ParameterNameValidator';
+import { IFunctionCallArgument } from './IFunctionCallArgument';
 
 export class FunctionCallArgument implements IFunctionCallArgument {
-    constructor(
-        public readonly parameterName: string,
-        public readonly argumentValue: string) {
-        ensureValidParameterName(parameterName);
-        if (!argumentValue) {
-            throw new Error(`undefined argument value for "${parameterName}"`);
-        }
+  constructor(
+    public readonly parameterName: string,
+    public readonly argumentValue: string,
+  ) {
+    ensureValidParameterName(parameterName);
+    if (!argumentValue) {
+      throw new Error(`undefined argument value for "${parameterName}"`);
     }
+  }
 }

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts

@@ -2,33 +2,37 @@ import { IFunctionCallArgument } from './IFunctionCallArgument';
 import { IFunctionCallArgumentCollection } from './IFunctionCallArgumentCollection';
 
 export class FunctionCallArgumentCollection implements IFunctionCallArgumentCollection {
-    private readonly arguments = new Map<string, IFunctionCallArgument>();
-    public addArgument(argument: IFunctionCallArgument): void {
-        if (!argument) {
-            throw new Error('undefined argument');
-        }
-        if (this.hasArgument(argument.parameterName)) {
-            throw new Error(`argument value for parameter ${argument.parameterName} is already provided`);
-        }
-        this.arguments.set(argument.parameterName, argument);
+  private readonly arguments = new Map<string, IFunctionCallArgument>();
+
+  public addArgument(argument: IFunctionCallArgument): void {
+    if (!argument) {
+      throw new Error('undefined argument');
     }
-    public getAllParameterNames(): string[] {
-        return Array.from(this.arguments.keys());
+    if (this.hasArgument(argument.parameterName)) {
+      throw new Error(`argument value for parameter ${argument.parameterName} is already provided`);
     }
-    public hasArgument(parameterName: string): boolean {
-        if (!parameterName) {
-            throw new Error('undefined parameter name');
-        }
-        return this.arguments.has(parameterName);
+    this.arguments.set(argument.parameterName, argument);
+  }
+
+  public getAllParameterNames(): string[] {
+    return Array.from(this.arguments.keys());
+  }
+
+  public hasArgument(parameterName: string): boolean {
+    if (!parameterName) {
+      throw new Error('undefined parameter name');
     }
-    public getArgument(parameterName: string): IFunctionCallArgument {
-        if (!parameterName) {
-            throw new Error('undefined parameter name');
-        }
-        const arg = this.arguments.get(parameterName);
-        if (!arg) {
-            throw new Error(`parameter does not exist: ${parameterName}`);
-        }
-        return arg;
+    return this.arguments.has(parameterName);
+  }
+
+  public getArgument(parameterName: string): IFunctionCallArgument {
+    if (!parameterName) {
+      throw new Error('undefined parameter name');
     }
+    const arg = this.arguments.get(parameterName);
+    if (!arg) {
+      throw new Error(`parameter does not exist: ${parameterName}`);
+    }
+    return arg;
+  }
 }

src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument.ts

@@ -1,4 +1,4 @@
 export interface IFunctionCallArgument {
-    readonly parameterName: string;
-    readonly argumentValue: string;
+  readonly parameterName: string;
+  readonly argumentValue: string;
 }

src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection.ts

@@ -1,11 +1,11 @@
 import { IFunctionCallArgument } from './IFunctionCallArgument';
 
 export interface IReadOnlyFunctionCallArgumentCollection {
-    getArgument(parameterName: string): IFunctionCallArgument;
-    getAllParameterNames(): string[];
-    hasArgument(parameterName: string): boolean;
+  getArgument(parameterName: string): IFunctionCallArgument;
+  getAllParameterNames(): string[];
+  hasArgument(parameterName: string): boolean;
 }
 
 export interface IFunctionCallArgumentCollection extends IReadOnlyFunctionCallArgumentCollection {
-    addArgument(argument: IFunctionCallArgument): void;
+  addArgument(argument: IFunctionCallArgument): void;
 }

src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts

@@ -1,139 +1,149 @@
 import { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
-import { ICompiledCode } from './ICompiledCode';
+import { IFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/IFunctionCall';
+import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
 import { ISharedFunctionCollection } from '../../ISharedFunctionCollection';
-import { IFunctionCallCompiler } from './IFunctionCallCompiler';
 import { IExpressionsCompiler } from '../../../Expressions/IExpressionsCompiler';
 import { ExpressionsCompiler } from '../../../Expressions/ExpressionsCompiler';
 import { ISharedFunction, IFunctionCode } from '../../ISharedFunction';
-import { IFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/IFunctionCall';
 import { FunctionCall } from '../FunctionCall';
 import { FunctionCallArgumentCollection } from '../Argument/FunctionCallArgumentCollection';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { IFunctionCallCompiler } from './IFunctionCallCompiler';
+import { ICompiledCode } from './ICompiledCode';
 
 export class FunctionCallCompiler implements IFunctionCallCompiler {
-    public static readonly instance: IFunctionCallCompiler = new FunctionCallCompiler();
+  public static readonly instance: IFunctionCallCompiler = new FunctionCallCompiler();
 
-    protected constructor(
-        private readonly expressionsCompiler: IExpressionsCompiler = new ExpressionsCompiler()) {
-    }
+  protected constructor(
+    private readonly expressionsCompiler: IExpressionsCompiler = new ExpressionsCompiler(),
+  ) {
+  }
 
-    public compileCall(
-        calls: IFunctionCall[],
-        functions: ISharedFunctionCollection): ICompiledCode {
-        if (!functions) { throw new Error('undefined functions'); }
-        if (!calls) { throw new Error('undefined calls'); }
-        if (calls.some((f) => !f)) { throw new Error('undefined function call'); }
-        const context: ICompilationContext = {
-            allFunctions: functions,
-            callSequence: calls,
-            expressionsCompiler: this.expressionsCompiler,
-        };
-        const code = compileCallSequence(context);
-        return code;
-    }
+  public compileCall(
+    calls: IFunctionCall[],
+    functions: ISharedFunctionCollection,
+  ): ICompiledCode {
+    if (!functions) { throw new Error('undefined functions'); }
+    if (!calls) { throw new Error('undefined calls'); }
+    if (calls.some((f) => !f)) { throw new Error('undefined function call'); }
+    const context: ICompilationContext = {
+      allFunctions: functions,
+      callSequence: calls,
+      expressionsCompiler: this.expressionsCompiler,
+    };
+    const code = compileCallSequence(context);
+    return code;
+  }
 }
 
 interface ICompilationContext {
-    allFunctions: ISharedFunctionCollection;
-    callSequence: readonly IFunctionCall[];
-    expressionsCompiler: IExpressionsCompiler;
+  allFunctions: ISharedFunctionCollection;
+  callSequence: readonly IFunctionCall[];
+  expressionsCompiler: IExpressionsCompiler;
 }
 
 interface ICompiledFunctionCall {
-    readonly code: string;
-    readonly revertCode: string;
+  readonly code: string;
+  readonly revertCode: string;
 }
 
 function compileCallSequence(context: ICompilationContext): ICompiledFunctionCall {
-    const compiledFunctions = new Array<ICompiledFunctionCall>();
-    for (const call of context.callSequence) {
-        const compiledCode = compileSingleCall(call, context);
-        compiledFunctions.push(...compiledCode);
-    }
-    return {
-        code: merge(compiledFunctions.map((f) => f.code)),
-        revertCode: merge(compiledFunctions.map((f) => f.revertCode)),
-    };
+  const compiledFunctions = new Array<ICompiledFunctionCall>();
+  for (const call of context.callSequence) {
+    const compiledCode = compileSingleCall(call, context);
+    compiledFunctions.push(...compiledCode);
+  }
+  return {
+    code: merge(compiledFunctions.map((f) => f.code)),
+    revertCode: merge(compiledFunctions.map((f) => f.revertCode)),
+  };
 }
 
-function compileSingleCall(call: IFunctionCall, context: ICompilationContext): ICompiledFunctionCall[] {
-    const func = context.allFunctions.getFunctionByName(call.functionName);
-    ensureThatCallArgumentsExistInParameterDefinition(func, call.args);
-    if (func.body.code) { // Function with inline code
-        const compiledCode = compileCode(func.body.code, call.args, context.expressionsCompiler);
-        return [ compiledCode ];
-    } else { // Function with inner calls
-        return func.body.calls
-            .map((innerCall) => {
-                const compiledArgs = compileArgs(innerCall.args, call.args, context.expressionsCompiler);
-                const compiledCall = new FunctionCall(innerCall.functionName, compiledArgs);
-                return compileSingleCall(compiledCall, context);
-            })
-            .flat();
-    }
+function compileSingleCall(
+  call: IFunctionCall,
+  context: ICompilationContext,
+): ICompiledFunctionCall[] {
+  const func = context.allFunctions.getFunctionByName(call.functionName);
+  ensureThatCallArgumentsExistInParameterDefinition(func, call.args);
+  if (func.body.code) { // Function with inline code
+    const compiledCode = compileCode(func.body.code, call.args, context.expressionsCompiler);
+    return [compiledCode];
+  }
+  // Function with inner calls
+  return func.body.calls
+    .map((innerCall) => {
+      const compiledArgs = compileArgs(innerCall.args, call.args, context.expressionsCompiler);
+      const compiledCall = new FunctionCall(innerCall.functionName, compiledArgs);
+      return compileSingleCall(compiledCall, context);
+    })
+    .flat();
 }
 
 function compileCode(
-    code: IFunctionCode,
-    args: IReadOnlyFunctionCallArgumentCollection,
-    compiler: IExpressionsCompiler): ICompiledFunctionCall {
-    return {
-        code: compiler.compileExpressions(code.do, args),
-        revertCode: compiler.compileExpressions(code.revert, args),
-    };
+  code: IFunctionCode,
+  args: IReadOnlyFunctionCallArgumentCollection,
+  compiler: IExpressionsCompiler,
+): ICompiledFunctionCall {
+  return {
+    code: compiler.compileExpressions(code.do, args),
+    revertCode: compiler.compileExpressions(code.revert, args),
+  };
 }
 
 function compileArgs(
-    argsToCompile: IReadOnlyFunctionCallArgumentCollection,
-    args: IReadOnlyFunctionCallArgumentCollection,
-    compiler: IExpressionsCompiler,
-    ): IReadOnlyFunctionCallArgumentCollection {
-    const compiledArgs = new FunctionCallArgumentCollection();
-    for (const parameterName of argsToCompile.getAllParameterNames()) {
-        const argumentValue = argsToCompile.getArgument(parameterName).argumentValue;
-        const compiledValue = compiler.compileExpressions(argumentValue, args);
-        const newArgument = new FunctionCallArgument(parameterName, compiledValue);
-        compiledArgs.addArgument(newArgument);
-    }
-    return compiledArgs;
+  argsToCompile: IReadOnlyFunctionCallArgumentCollection,
+  args: IReadOnlyFunctionCallArgumentCollection,
+  compiler: IExpressionsCompiler,
+): IReadOnlyFunctionCallArgumentCollection {
+  const compiledArgs = new FunctionCallArgumentCollection();
+  for (const parameterName of argsToCompile.getAllParameterNames()) {
+    const { argumentValue } = argsToCompile.getArgument(parameterName);
+    const compiledValue = compiler.compileExpressions(argumentValue, args);
+    const newArgument = new FunctionCallArgument(parameterName, compiledValue);
+    compiledArgs.addArgument(newArgument);
+  }
+  return compiledArgs;
 }
 
 function merge(codeParts: readonly string[]): string {
-    return codeParts
-        .filter((part) => part?.length > 0)
-        .join('\n');
+  return codeParts
+    .filter((part) => part?.length > 0)
+    .join('\n');
 }
 
 function ensureThatCallArgumentsExistInParameterDefinition(
-    func: ISharedFunction,
-    args: IReadOnlyFunctionCallArgumentCollection): void {
-    const callArgumentNames = args.getAllParameterNames();
-    const functionParameterNames = func.parameters.all.map((param) => param.name) || [];
-    const unexpectedParameters = findUnexpectedParameters(callArgumentNames, functionParameterNames);
-    throwIfNotEmpty(func.name, unexpectedParameters, functionParameterNames);
+  func: ISharedFunction,
+  args: IReadOnlyFunctionCallArgumentCollection,
+): void {
+  const callArgumentNames = args.getAllParameterNames();
+  const functionParameterNames = func.parameters.all.map((param) => param.name) || [];
+  const unexpectedParameters = findUnexpectedParameters(callArgumentNames, functionParameterNames);
+  throwIfNotEmpty(func.name, unexpectedParameters, functionParameterNames);
 }
 
 function findUnexpectedParameters(
-    callArgumentNames: string[],
-    functionParameterNames: string[]): string[] {
-    if (!callArgumentNames.length && !functionParameterNames.length) {
-        return [];
-    }
-    return callArgumentNames
-        .filter((callParam) => !functionParameterNames.includes(callParam));
+  callArgumentNames: string[],
+  functionParameterNames: string[],
+): string[] {
+  if (!callArgumentNames.length && !functionParameterNames.length) {
+    return [];
+  }
+  return callArgumentNames
+    .filter((callParam) => !functionParameterNames.includes(callParam));
 }
 
 function throwIfNotEmpty(
-    functionName: string,
-    unexpectedParameters: string[],
-    expectedParameters: string[]) {
-    if (!unexpectedParameters.length) {
-        return;
-    }
-    throw new Error(
-        `Function "${functionName}" has unexpected parameter(s) provided: ` +
-        `"${unexpectedParameters.join('", "')}"` +
-        '. Expected parameter(s): ' +
-        (expectedParameters.length ? `"${expectedParameters.join('", "')}"` : 'none'),
-    );
+  functionName: string,
+  unexpectedParameters: string[],
+  expectedParameters: string[],
+) {
+  if (!unexpectedParameters.length) {
+    return;
+  }
+  throw new Error(
+    // eslint-disable-next-line prefer-template
+    `Function "${functionName}" has unexpected parameter(s) provided: `
+      + `"${unexpectedParameters.join('", "')}"`
+      + '. Expected parameter(s): '
+      + (expectedParameters.length ? `"${expectedParameters.join('", "')}"` : 'none'),
+  );
 }

src/application/Parser/Script/Compiler/Function/Call/Compiler/ICompiledCode.ts

@@ -1,4 +1,4 @@
 export interface ICompiledCode {
-    readonly code: string;
-    readonly revertCode?: string;
+  readonly code: string;
+  readonly revertCode?: string;
 }

src/application/Parser/Script/Compiler/Function/Call/Compiler/IFunctionCallCompiler.ts

@@ -1,9 +1,9 @@
-import { ICompiledCode } from './ICompiledCode';
 import { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
 import { IFunctionCall } from '../IFunctionCall';
+import { ICompiledCode } from './ICompiledCode';
 
 export interface IFunctionCallCompiler {
-    compileCall(
-        calls: IFunctionCall[],
-        functions: ISharedFunctionCollection): ICompiledCode;
+  compileCall(
+    calls: IFunctionCall[],
+    functions: ISharedFunctionCollection): ICompiledCode;
 }

src/application/Parser/Script/Compiler/Function/Call/FunctionCall.ts

@@ -2,14 +2,15 @@ import { IReadOnlyFunctionCallArgumentCollection } from './Argument/IFunctionCal
 import { IFunctionCall } from './IFunctionCall';
 
 export class FunctionCall implements IFunctionCall {
-    constructor(
-        public readonly functionName: string,
-        public readonly args: IReadOnlyFunctionCallArgumentCollection) {
-        if (!functionName) {
-            throw new Error('empty function name in function call');
-        }
-        if (!args) {
-            throw new Error('undefined args');
-        }
+  constructor(
+    public readonly functionName: string,
+    public readonly args: IReadOnlyFunctionCallArgumentCollection,
+  ) {
+    if (!functionName) {
+      throw new Error('empty function name in function call');
     }
+    if (!args) {
+      throw new Error('undefined args');
+    }
+  }
 }

src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts

@@ -5,31 +5,31 @@ import { FunctionCallArgument } from './Argument/FunctionCallArgument';
 import { FunctionCall } from './FunctionCall';
 
 export function parseFunctionCalls(calls: FunctionCallsData): IFunctionCall[] {
-    if (!calls) {
-        throw new Error('undefined call data');
-    }
-    const sequence = getCallSequence(calls);
-    return sequence.map((call) => parseFunctionCall(call));
+  if (calls === undefined) {
+    throw new Error('undefined call data');
+  }
+  const sequence = getCallSequence(calls);
+  return sequence.map((call) => parseFunctionCall(call));
 }
 
 function getCallSequence(calls: FunctionCallsData): FunctionCallData[] {
-    if (typeof calls !== 'object') {
-        throw new Error('called function(s) must be an object');
-    }
-    if (calls instanceof Array) {
-        return calls as FunctionCallData[];
-    }
-    return [ calls as FunctionCallData ];
+  if (typeof calls !== 'object') {
+    throw new Error('called function(s) must be an object');
+  }
+  if (calls instanceof Array) {
+    return calls as FunctionCallData[];
+  }
+  return [calls as FunctionCallData];
 }
 
 function parseFunctionCall(call: FunctionCallData): IFunctionCall {
-    if (!call) {
-        throw new Error(`undefined function call`);
-    }
-    const args = new FunctionCallArgumentCollection();
-    for (const parameterName of Object.keys(call.parameters || {})) {
-        const arg = new FunctionCallArgument(parameterName, call.parameters[parameterName]);
-        args.addArgument(arg);
-    }
-    return new FunctionCall(call.function, args);
+  if (!call) {
+    throw new Error('undefined function call');
+  }
+  const args = new FunctionCallArgumentCollection();
+  for (const parameterName of Object.keys(call.parameters || {})) {
+    const arg = new FunctionCallArgument(parameterName, call.parameters[parameterName]);
+    args.addArgument(arg);
+  }
+  return new FunctionCall(call.function, args);
 }

src/application/Parser/Script/Compiler/Function/Call/IFunctionCall.ts

@@ -1,6 +1,6 @@
 import { IReadOnlyFunctionCallArgumentCollection } from './Argument/IFunctionCallArgumentCollection';
 
 export interface IFunctionCall {
-    readonly functionName: string;
-    readonly args: IReadOnlyFunctionCallArgumentCollection;
+  readonly functionName: string;
+  readonly args: IReadOnlyFunctionCallArgumentCollection;
 }

src/application/Parser/Script/Compiler/Function/ISharedFunction.ts

@@ -1,24 +1,24 @@
 import { IReadOnlyFunctionParameterCollection } from './Parameter/IFunctionParameterCollection';
-import { IFunctionCall } from '../Function/Call/IFunctionCall';
+import { IFunctionCall } from './Call/IFunctionCall';
 
 export interface ISharedFunction {
-    readonly name: string;
-    readonly parameters: IReadOnlyFunctionParameterCollection;
-    readonly body: ISharedFunctionBody;
+  readonly name: string;
+  readonly parameters: IReadOnlyFunctionParameterCollection;
+  readonly body: ISharedFunctionBody;
 }
 
 export interface ISharedFunctionBody {
-    readonly type: FunctionBodyType;
-    readonly code: IFunctionCode;
-    readonly calls: readonly IFunctionCall[];
+  readonly type: FunctionBodyType;
+  readonly code: IFunctionCode;
+  readonly calls: readonly IFunctionCall[];
 }
 
 export enum FunctionBodyType {
-    Code,
-    Calls,
+  Code,
+  Calls,
 }
 
 export interface IFunctionCode {
-    readonly do: string;
-    readonly revert?: string;
+  readonly do: string;
+  readonly revert?: string;
 }

src/application/Parser/Script/Compiler/Function/ISharedFunctionCollection.ts

@@ -1,5 +1,5 @@
 import { ISharedFunction } from './ISharedFunction';
 
 export interface ISharedFunctionCollection {
-    getFunctionByName(name: string): ISharedFunction;
+  getFunctionByName(name: string): ISharedFunction;
 }

src/application/Parser/Script/Compiler/Function/ISharedFunctionsParser.ts

@@ -2,5 +2,5 @@ import { FunctionData } from 'js-yaml-loader!@/*';
 import { ISharedFunctionCollection } from './ISharedFunctionCollection';
 
 export interface ISharedFunctionsParser {
-    parseFunctions(functions: readonly FunctionData[]): ISharedFunctionCollection;
+  parseFunctions(functions: readonly FunctionData[]): ISharedFunctionCollection;
 }

src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.ts

@@ -1,10 +1,11 @@
-import { IFunctionParameter } from './IFunctionParameter';
 import { ensureValidParameterName } from '../Shared/ParameterNameValidator';
+import { IFunctionParameter } from './IFunctionParameter';
 
 export class FunctionParameter implements IFunctionParameter {
-    constructor(
-        public readonly name: string,
-        public readonly isOptional: boolean) {
-        ensureValidParameterName(name);
-    }
+  constructor(
+    public readonly name: string,
+    public readonly isOptional: boolean,
+  ) {
+    ensureValidParameterName(name);
+  }
 }

src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts

@@ -2,25 +2,27 @@ import { IFunctionParameterCollection } from './IFunctionParameterCollection';
 import { IFunctionParameter } from './IFunctionParameter';
 
 export class FunctionParameterCollection implements IFunctionParameterCollection {
-    private parameters = new Array<IFunctionParameter>();
+  private parameters = new Array<IFunctionParameter>();
 
-    public get all(): readonly IFunctionParameter[] {
-        return this.parameters;
-    }
-    public addParameter(parameter: IFunctionParameter) {
-        this.ensureValidParameter(parameter);
-        this.parameters.push(parameter);
-    }
+  public get all(): readonly IFunctionParameter[] {
+    return this.parameters;
+  }
 
-    private includesName(name: string) {
-        return this.parameters.find((existingParameter) => existingParameter.name === name);
+  public addParameter(parameter: IFunctionParameter) {
+    this.ensureValidParameter(parameter);
+    this.parameters.push(parameter);
+  }
+
+  private includesName(name: string) {
+    return this.parameters.find((existingParameter) => existingParameter.name === name);
+  }
+
+  private ensureValidParameter(parameter: IFunctionParameter) {
+    if (!parameter) {
+      throw new Error('undefined parameter');
     }
-    private ensureValidParameter(parameter: IFunctionParameter) {
-        if (!parameter) {
-            throw new Error('undefined parameter');
-        }
-        if (this.includesName(parameter.name)) {
-            throw new Error(`duplicate parameter name: "${parameter.name}"`);
-        }
+    if (this.includesName(parameter.name)) {
+      throw new Error(`duplicate parameter name: "${parameter.name}"`);
     }
+  }
 }

src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameter.ts

@@ -1,4 +1,4 @@
 export interface IFunctionParameter {
-    readonly name: string;
-    readonly isOptional: boolean;
+  readonly name: string;
+  readonly isOptional: boolean;
 }

src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection.ts

@@ -1,9 +1,9 @@
 import { IFunctionParameter } from './IFunctionParameter';
 
 export interface IReadOnlyFunctionParameterCollection {
-    readonly all: readonly IFunctionParameter[];
+  readonly all: readonly IFunctionParameter[];
 }
 
 export interface IFunctionParameterCollection extends IReadOnlyFunctionParameterCollection {
-    addParameter(parameter: IFunctionParameter): void;
+  addParameter(parameter: IFunctionParameter): void;
 }

src/application/Parser/Script/Compiler/Function/Shared/ParameterNameValidator.ts

@@ -1,8 +1,8 @@
 export function ensureValidParameterName(parameterName: string) {
-    if (!parameterName) {
-        throw new Error('undefined parameter name');
-    }
-    if (!parameterName.match(/^[0-9a-zA-Z]+$/)) {
-        throw new Error(`parameter name must be alphanumeric but it was "${parameterName}"`);
-    }
+  if (!parameterName) {
+    throw new Error('undefined parameter name');
+  }
+  if (!parameterName.match(/^[0-9a-zA-Z]+$/)) {
+    throw new Error(`parameter name must be alphanumeric but it was "${parameterName}"`);
+  }
 }

src/application/Parser/Script/Compiler/Function/SharedFunction.ts

@@ -1,49 +1,54 @@
-import { IFunctionCall } from '../Function/Call/IFunctionCall';
-import { FunctionBodyType, IFunctionCode, ISharedFunction, ISharedFunctionBody } from './ISharedFunction';
+import { IFunctionCall } from './Call/IFunctionCall';
+import {
+  FunctionBodyType, IFunctionCode, ISharedFunction, ISharedFunctionBody,
+} from './ISharedFunction';
 import { IReadOnlyFunctionParameterCollection } from './Parameter/IFunctionParameterCollection';
 
 export function createCallerFunction(
-    name: string,
-    parameters: IReadOnlyFunctionParameterCollection,
-    callSequence: readonly IFunctionCall[]): ISharedFunction {
-    if (!callSequence) {
-        throw new Error(`undefined call sequence in function "${name}"`);
-    }
-    if (!callSequence.length) {
-        throw new Error(`empty call sequence in function "${name}"`);
-    }
-    return new SharedFunction(name, parameters, callSequence, FunctionBodyType.Calls);
+  name: string,
+  parameters: IReadOnlyFunctionParameterCollection,
+  callSequence: readonly IFunctionCall[],
+): ISharedFunction {
+  if (!callSequence) {
+    throw new Error(`undefined call sequence in function "${name}"`);
+  }
+  if (!callSequence.length) {
+    throw new Error(`empty call sequence in function "${name}"`);
+  }
+  return new SharedFunction(name, parameters, callSequence, FunctionBodyType.Calls);
 }
 
 export function createFunctionWithInlineCode(
-    name: string,
-    parameters: IReadOnlyFunctionParameterCollection,
-    code: string,
-    revertCode?: string): ISharedFunction {
-    if (!code) {
-        throw new Error(`undefined code in function "${name}"`);
-    }
-    const content: IFunctionCode = {
-        do: code,
-        revert: revertCode,
-    };
-    return new SharedFunction(name, parameters, content, FunctionBodyType.Code);
+  name: string,
+  parameters: IReadOnlyFunctionParameterCollection,
+  code: string,
+  revertCode?: string,
+): ISharedFunction {
+  if (!code) {
+    throw new Error(`undefined code in function "${name}"`);
+  }
+  const content: IFunctionCode = {
+    do: code,
+    revert: revertCode,
+  };
+  return new SharedFunction(name, parameters, content, FunctionBodyType.Code);
 }
 
 class SharedFunction implements ISharedFunction {
-    public readonly body: ISharedFunctionBody;
-    constructor(
-        public readonly name: string,
-        public readonly parameters: IReadOnlyFunctionParameterCollection,
-        content: IFunctionCode | readonly IFunctionCall[],
-        bodyType: FunctionBodyType,
-        ) {
-        if (!name) { throw new Error('undefined function name'); }
-        if (!parameters) { throw new Error(`undefined parameters`); }
-        this.body = {
-            type: bodyType,
-            code: bodyType === FunctionBodyType.Code ? content as IFunctionCode : undefined,
-            calls: bodyType === FunctionBodyType.Calls ? content as readonly IFunctionCall[] : undefined,
-        };
-    }
+  public readonly body: ISharedFunctionBody;
+
+  constructor(
+    public readonly name: string,
+    public readonly parameters: IReadOnlyFunctionParameterCollection,
+    content: IFunctionCode | readonly IFunctionCall[],
+    bodyType: FunctionBodyType,
+  ) {
+    if (!name) { throw new Error('undefined function name'); }
+    if (!parameters) { throw new Error('undefined parameters'); }
+    this.body = {
+      type: bodyType,
+      code: bodyType === FunctionBodyType.Code ? content as IFunctionCode : undefined,
+      calls: bodyType === FunctionBodyType.Calls ? content as readonly IFunctionCall[] : undefined,
+    };
+  }
 }

src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts

@@ -2,26 +2,26 @@ import { ISharedFunction } from './ISharedFunction';
 import { ISharedFunctionCollection } from './ISharedFunctionCollection';
 
 export class SharedFunctionCollection implements ISharedFunctionCollection {
-    private readonly functionsByName = new Map<string, ISharedFunction>();
+  private readonly functionsByName = new Map<string, ISharedFunction>();
 
-    public addFunction(func: ISharedFunction): void {
-        if (!func) { throw new Error('undefined function'); }
-        if (this.has(func.name)) {
-            throw new Error(`function with name ${func.name} already exists`);
-        }
-        this.functionsByName.set(func.name, func);
+  public addFunction(func: ISharedFunction): void {
+    if (!func) { throw new Error('undefined function'); }
+    if (this.has(func.name)) {
+      throw new Error(`function with name ${func.name} already exists`);
     }
+    this.functionsByName.set(func.name, func);
+  }
 
-    public getFunctionByName(name: string): ISharedFunction {
-        if (!name) { throw Error('undefined function name'); }
-        const func = this.functionsByName.get(name);
-        if (!func) {
-            throw new Error(`called function is not defined "${name}"`);
-        }
-        return func;
+  public getFunctionByName(name: string): ISharedFunction {
+    if (!name) { throw Error('undefined function name'); }
+    const func = this.functionsByName.get(name);
+    if (!func) {
+      throw new Error(`called function is not defined "${name}"`);
     }
+    return func;
+  }
 
-    private has(functionName: string) {
-        return this.functionsByName.has(functionName);
-    }
+  private has(functionName: string) {
+    return this.functionsByName.has(functionName);
+  }
 }

src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts

@@ -10,131 +10,132 @@ import { ISharedFunction } from './ISharedFunction';
 import { parseFunctionCalls } from './Call/FunctionCallParser';
 
 export class SharedFunctionsParser implements ISharedFunctionsParser {
-    public static readonly instance: ISharedFunctionsParser = new SharedFunctionsParser();
-    public parseFunctions(
-        functions: readonly FunctionData[]): ISharedFunctionCollection {
-        const collection = new SharedFunctionCollection();
-        if (!functions || !functions.length) {
-            return collection;
-        }
-        ensureValidFunctions(functions);
-        for (const func of functions) {
-            const sharedFunction = parseFunction(func);
-            collection.addFunction(sharedFunction);
-        }
-        return collection;
+  public static readonly instance: ISharedFunctionsParser = new SharedFunctionsParser();
+
+  public parseFunctions(
+    functions: readonly FunctionData[],
+  ): ISharedFunctionCollection {
+    const collection = new SharedFunctionCollection();
+    if (!functions || !functions.length) {
+      return collection;
     }
+    ensureValidFunctions(functions);
+    for (const func of functions) {
+      const sharedFunction = parseFunction(func);
+      collection.addFunction(sharedFunction);
+    }
+    return collection;
+  }
 }
 
 function parseFunction(data: FunctionData): ISharedFunction {
-    const name = data.name;
-    const parameters = parseParameters(data);
-    if (hasCode(data)) {
-        return createFunctionWithInlineCode(name, parameters, data.code, data.revertCode);
-    } else { // has call
-        const calls = parseFunctionCalls(data.call);
-        return createCallerFunction(name, parameters, calls);
-    }
+  const { name } = data;
+  const parameters = parseParameters(data);
+  if (hasCode(data)) {
+    return createFunctionWithInlineCode(name, parameters, data.code, data.revertCode);
+  }
+  // Has call
+  const calls = parseFunctionCalls(data.call);
+  return createCallerFunction(name, parameters, calls);
 }
 
 function parseParameters(data: FunctionData): IReadOnlyFunctionParameterCollection {
-    const parameters = new FunctionParameterCollection();
-    if (!data.parameters) {
-        return parameters;
-    }
-    for (const parameterData of data.parameters) {
-        const isOptional = parameterData.optional || false;
-        try {
-            const parameter = new FunctionParameter(parameterData.name, isOptional);
-            parameters.addParameter(parameter);
-        } catch (err) {
-            throw new Error(`"${data.name}": ${err.message}`);
-        }
-    }
+  const parameters = new FunctionParameterCollection();
+  if (!data.parameters) {
     return parameters;
+  }
+  for (const parameterData of data.parameters) {
+    const isOptional = parameterData.optional || false;
+    try {
+      const parameter = new FunctionParameter(parameterData.name, isOptional);
+      parameters.addParameter(parameter);
+    } catch (err) {
+      throw new Error(`"${data.name}": ${err.message}`);
+    }
+  }
+  return parameters;
 }
 
 function hasCode(data: FunctionData): boolean {
-    return Boolean(data.code);
+  return Boolean(data.code);
 }
 
 function hasCall(data: FunctionData): boolean {
-    return Boolean(data.call);
+  return Boolean(data.call);
 }
 
 function ensureValidFunctions(functions: readonly FunctionData[]) {
-    ensureNoUndefinedItem(functions);
-    ensureNoDuplicatesInFunctionNames(functions);
-    ensureNoDuplicateCode(functions);
-    ensureEitherCallOrCodeIsDefined(functions);
-    ensureExpectedParametersType(functions);
+  ensureNoUndefinedItem(functions);
+  ensureNoDuplicatesInFunctionNames(functions);
+  ensureNoDuplicateCode(functions);
+  ensureEitherCallOrCodeIsDefined(functions);
+  ensureExpectedParametersType(functions);
 }
 
 function printList(list: readonly string[]): string {
-    return `"${list.join('","')}"`;
+  return `"${list.join('","')}"`;
 }
 
 function ensureEitherCallOrCodeIsDefined(holders: readonly InstructionHolder[]) {
-    // Ensure functions do not define both call and code
-    const withBothCallAndCode = holders.filter((holder) => hasCode(holder) && hasCall(holder));
-    if (withBothCallAndCode.length) {
-        throw new Error(`both "code" and "call" are defined in ${printNames(withBothCallAndCode)}`);
-    }
-    // Ensure functions have either code or call
-    const hasEitherCodeOrCall = holders.filter((holder) => !hasCode(holder) && !hasCall(holder));
-    if (hasEitherCodeOrCall.length) {
-        throw new Error(`neither "code" or "call" is defined in ${printNames(hasEitherCodeOrCall)}`);
-    }
+  // Ensure functions do not define both call and code
+  const withBothCallAndCode = holders.filter((holder) => hasCode(holder) && hasCall(holder));
+  if (withBothCallAndCode.length) {
+    throw new Error(`both "code" and "call" are defined in ${printNames(withBothCallAndCode)}`);
+  }
+  // Ensure functions have either code or call
+  const hasEitherCodeOrCall = holders.filter((holder) => !hasCode(holder) && !hasCall(holder));
+  if (hasEitherCodeOrCall.length) {
+    throw new Error(`neither "code" or "call" is defined in ${printNames(hasEitherCodeOrCall)}`);
+  }
 }
 
 function ensureExpectedParametersType(functions: readonly FunctionData[]) {
-    const unexpectedFunctions = functions
-        .filter((func) => func.parameters && !isArrayOfObjects(func.parameters));
-    if (unexpectedFunctions.length) {
-        const errorMessage = `parameters must be an array of objects in function(s) ${printNames(unexpectedFunctions)}`;
-        throw new Error(errorMessage);
-    }
+  const unexpectedFunctions = functions
+    .filter((func) => func.parameters && !isArrayOfObjects(func.parameters));
+  if (unexpectedFunctions.length) {
+    const errorMessage = `parameters must be an array of objects in function(s) ${printNames(unexpectedFunctions)}`;
+    throw new Error(errorMessage);
+  }
 }
 
-function isArrayOfObjects(value: any): boolean {
-    return Array.isArray(value)
-        && value.every((item) => typeof item === 'object');
+function isArrayOfObjects(value: unknown): boolean {
+  return Array.isArray(value)
+    && value.every((item) => typeof item === 'object');
 }
 
 function printNames(holders: readonly InstructionHolder[]) {
-    return printList(holders.map((holder) => holder.name));
+  return printList(holders.map((holder) => holder.name));
 }
 
 function ensureNoDuplicatesInFunctionNames(functions: readonly FunctionData[]) {
-    const duplicateFunctionNames = getDuplicates(functions
-        .map((func) => func.name.toLowerCase()));
-    if (duplicateFunctionNames.length) {
-        throw new Error(`duplicate function name: ${printList(duplicateFunctionNames)}`);
-    }
+  const duplicateFunctionNames = getDuplicates(functions
+    .map((func) => func.name.toLowerCase()));
+  if (duplicateFunctionNames.length) {
+    throw new Error(`duplicate function name: ${printList(duplicateFunctionNames)}`);
+  }
 }
 
 function ensureNoUndefinedItem(functions: readonly FunctionData[]) {
-    if (functions.some((func) => !func)) {
-        throw new Error(`some functions are undefined`);
-    }
+  if (functions.some((func) => !func)) {
+    throw new Error('some functions are undefined');
+  }
 }
 
 function ensureNoDuplicateCode(functions: readonly FunctionData[]) {
-    const duplicateCodes = getDuplicates(functions
-        .map((func) => func.code)
-        .filter((code) => code),
-    );
-    if (duplicateCodes.length > 0) {
-        throw new Error(`duplicate "code" in functions: ${printList(duplicateCodes)}`);
-    }
-    const duplicateRevertCodes = getDuplicates(functions
-        .filter((func) => func.revertCode)
-        .map((func) => func.revertCode));
-    if (duplicateRevertCodes.length > 0) {
-        throw new Error(`duplicate "revertCode" in functions: ${printList(duplicateRevertCodes)}`);
-    }
+  const duplicateCodes = getDuplicates(functions
+    .map((func) => func.code)
+    .filter((code) => code));
+  if (duplicateCodes.length > 0) {
+    throw new Error(`duplicate "code" in functions: ${printList(duplicateCodes)}`);
+  }
+  const duplicateRevertCodes = getDuplicates(functions
+    .filter((func) => func.revertCode)
+    .map((func) => func.revertCode));
+  if (duplicateRevertCodes.length > 0) {
+    throw new Error(`duplicate "revertCode" in functions: ${printList(duplicateRevertCodes)}`);
+  }
 }
 
 function getDuplicates(texts: readonly string[]): string[] {
-    return texts.filter((item, index) => texts.indexOf(item) !== index);
+  return texts.filter((item, index) => texts.indexOf(item) !== index);
 }

src/application/Parser/Script/Compiler/IScriptCompiler.ts

@@ -1,7 +1,7 @@
-import { IScriptCode } from '@/domain/IScriptCode';
 import { ScriptData } from 'js-yaml-loader!@/*';
+import { IScriptCode } from '@/domain/IScriptCode';
 
 export interface IScriptCompiler {
-    canCompile(script: ScriptData): boolean;
-    compile(script: ScriptData): IScriptCode;
+  canCompile(script: ScriptData): boolean;
+  compile(script: ScriptData): IScriptCode;
 }

src/application/Parser/Script/Compiler/ScriptCompiler.ts

@@ -1,7 +1,6 @@
-import { IScriptCode } from '@/domain/IScriptCode';
-import { ScriptCode } from '@/domain/ScriptCode';
-import { ILanguageSyntax } from '@/domain/ScriptCode';
 import { FunctionData, ScriptData } from 'js-yaml-loader!@/*';
+import { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode, ILanguageSyntax } from '@/domain/ScriptCode';
 import { IScriptCompiler } from './IScriptCompiler';
 import { ISharedFunctionCollection } from './Function/ISharedFunctionCollection';
 import { IFunctionCallCompiler } from './Function/Call/Compiler/IFunctionCallCompiler';
@@ -11,34 +10,38 @@ import { SharedFunctionsParser } from './Function/SharedFunctionsParser';
 import { parseFunctionCalls } from './Function/Call/FunctionCallParser';
 
 export class ScriptCompiler implements IScriptCompiler {
-    private readonly functions: ISharedFunctionCollection;
-    constructor(
-        functions: readonly FunctionData[] | undefined,
-        private readonly syntax: ILanguageSyntax,
-        sharedFunctionsParser: ISharedFunctionsParser = SharedFunctionsParser.instance,
-        private readonly callCompiler: IFunctionCallCompiler = FunctionCallCompiler.instance,
-        ) {
-        if (!syntax) { throw new Error('undefined syntax'); }
-        this.functions = sharedFunctionsParser.parseFunctions(functions);
+  private readonly functions: ISharedFunctionCollection;
+
+  constructor(
+    functions: readonly FunctionData[] | undefined,
+    private readonly syntax: ILanguageSyntax,
+    private readonly callCompiler: IFunctionCallCompiler = FunctionCallCompiler.instance,
+    sharedFunctionsParser: ISharedFunctionsParser = SharedFunctionsParser.instance,
+  ) {
+    if (!syntax) { throw new Error('undefined syntax'); }
+    this.functions = sharedFunctionsParser.parseFunctions(functions);
+  }
+
+  public canCompile(script: ScriptData): boolean {
+    if (!script) { throw new Error('undefined script'); }
+    if (!script.call) {
+      return false;
     }
-    public canCompile(script: ScriptData): boolean {
-        if (!script) { throw new Error('undefined script'); }
-        if (!script.call) {
-            return false;
-        }
-        return true;
-    }
-    public compile(script: ScriptData): IScriptCode {
-        if (!script) { throw new Error('undefined script'); }
-        try {
-            const calls = parseFunctionCalls(script.call);
-            const compiledCode = this.callCompiler.compileCall(calls, this.functions);
-            return new ScriptCode(
-                compiledCode.code,
-                compiledCode.revertCode,
-                this.syntax);
-        } catch (error) {
-            throw Error(`Script "${script.name}" ${error.message}`);
-        }
+    return true;
+  }
+
+  public compile(script: ScriptData): IScriptCode {
+    if (!script) { throw new Error('undefined script'); }
+    try {
+      const calls = parseFunctionCalls(script.call);
+      const compiledCode = this.callCompiler.compileCall(calls, this.functions);
+      return new ScriptCode(
+        compiledCode.code,
+        compiledCode.revertCode,
+        this.syntax,
+      );
+    } catch (error) {
+      throw Error(`Script "${script.name}" ${error.message}`);
     }
+  }
 }