Fix card height inconsistency

TODO: Is CardLayout, card-layout, cardLayout etc., best names possiuble?

Fix card expansion panel heights not being equal. This is due to
limitations in CSS flex view.

Heights of all cards are `100%` which gives them uniform loook on same
row with all equal heights. However, their heights are set to `auto`
when of the cards are open. In that case, their sizes are no longer
equal in same row, cards with longer text/titles keeping more space.
This is because when a card is open, its expansion panel grows in its
own DOM element, increasing the height of the card.
at same height on each line, their heights change completely when one of

Heights gets fucked up when card is collapsing, this is big fix, fix this.

Supporting changes:

- Move card expander to its own component `CardExpansionPanel`.
- Introduce `UseCardLayout` hook to do calculations instead of CSS to
  circumvent limitations in CSS flex view.

.github/workflows/checks.quality.yaml

@@ -74,28 +74,3 @@ jobs:
       -
         name: Analyzing the code with pylint
         run: npm run lint:pylint
-
-  validate-collection-files:
-    runs-on: ${{ matrix.os }}-latest
-    strategy:
-      matrix:
-        os: [ macos, ubuntu, windows ]
-      fail-fast: false # Still interested to see results from other combinations
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v4
-      -
-        name: Setup node
-        uses: ./.github/actions/setup-node
-      -
-        name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-      -
-        name: Install dependencies
-        run: python3 -m pip install -r ./scripts/validate-collections-yaml/requirements.txt
-      -
-        name: Validate
-        run: python3 ./scripts/validate-collections-yaml

.gitignore

@@ -14,7 +14,3 @@ node_modules
 
 # macOS
 .DS_Store
-
-# Python
-__pycache__
-.venv

.vscode/extensions.json

@@ -5,10 +5,8 @@
     "wengerk.highlight-bad-chars",      // Highlights bad chars.
     "wayou.vscode-todo-highlight",      // Highlights TODO.
     "wix.vscode-import-cost",           // Shows in KB how much a require include in code.
-    // Markdown
+    // Documentation
     "davidanson.vscode-markdownlint",   // Lints markdown.
-    // YAML
-    "redhat.vscode-yaml",               // Lints YAML files, validates against schema.
     // TypeScript / JavaScript
     "dbaeumer.vscode-eslint",           // Lints JavaScript/TypeScript.
     "pmneo.tsimporter",                 // Provides better auto-complete for TypeScripts imports.

README.md

@@ -186,7 +186,3 @@ Check [architecture.md](./docs/architecture.md) for an overview of design and ho
 Security is a top priority at privacy.sexy.
 An extensive commitment to security verification ensures this priority.
 For any security concerns or vulnerabilities, please consult the [Security Policy](./SECURITY.md).
-
-## Supporters
-
-[![Supporters appreciation banner showing the supporters](https://undergroundwires.dev/img/supporters.jpg)](https://undergroundwires.dev/supporters)

docs/application.md

@@ -41,5 +41,5 @@ Application layer compiles templating syntax during parsing to create the end sc
 
 The steps to extend the templating syntax:
 
-1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more.
-2. Register your in [CompositeExpressionParser](./../src/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts).
+1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more.
+2. Register your in [CompositeExpressionParser](./../src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts).

docs/collection-files.md

@@ -1,11 +1,11 @@
 # Collection files
 
 privacy.sexy is a data-driven application that reads YAML files.
-This document details the structure and syntax of the YAML files located in [`application/collections`](./../src/application/collections/), which form the backbone of the application's data model. The YAML schema [`.schema.yaml`](./../src/application/collections/.schema.yaml) is provided to provide better IDE support and be used in automated validations.
+This document details the structure and syntax of the YAML files located in [`application/collections`](./../src/application/collections/), which form the backbone of the application's data model.
 
 Related documentation:
 
-- 📖 [`Collections README`](./../src/application/collections/README.md) includes references to code as documentation.
+- 📖 [`collection.yaml.d.ts`](./../src/application/collections/collection.yaml.d.ts) outlines code types.
 - 📖 [Script Guidelines](./script-guidelines.md) provide guidance on script creation including best-practices.
 
 ## Objects
@@ -28,20 +28,11 @@ Related documentation:
 - `scripting:` ***[`ScriptingDefinition`](#scriptingdefinition)*** **(required)**
   - Sets the scripting language for all inline code used within the collection.
 
-### Executables
-
-An Executable is a logical entity that can
-
-- execute once compiled,
-- include a `docs` property for documentation.
-
-It's either [Category](#category) or a [Script](#script).
-
-#### `Category`
+### `Category`
 
 Represents a logical group of scripts and subcategories.
 
-##### `Category` syntax
+#### `Category` syntax
 
 - `category:` *`string`*  **(required)**
   - Name of the category.
@@ -52,7 +43,7 @@ Represents a logical group of scripts and subcategories.
 - `docs`: *`string`* | `[`*`string`*`, ... ]`
   - Markdown-formatted documentation related to the category.
 
-#### `Script`
+### `Script`
 
 Represents an individual tweak.
 
@@ -67,7 +58,7 @@ Types (like [functions](#function)):
 
 📖 For detailed guidelines, see [Script Guidelines](./script-guidelines.md).
 
-##### `Script` syntax
+#### `Script` syntax
 
 - `name`: *`string`* **(required)**
   - Script name.

docs/development.md

@@ -80,10 +80,8 @@ See [ci-cd.md](./ci-cd.md) for more information.
 - [**`npm run install-deps [-- <options>]`**](../scripts/npm-install.js):
   - Manages NPM dependency installation, it offers capabilities like doing a fresh install, retries on network errors, and other features.
   - For example, you can run `npm run install-deps -- --fresh` to do clean installation of dependencies.
-- [**`python3 ./scripts/configure_vscode.py`**](../scripts/configure_vscode.py):
+- [**`python ./scripts/configure_vscode.py`**](../scripts/configure_vscode.py):
   - Optimizes Visual Studio Code settings and installs essential extensions, enhancing the development environment.
-- [**`python3 ./scripts/validate-collections-yaml`**](../scripts/validate-collections-yaml/README.md):
-  - Validates the syntax and structure of collection YAML files.
 
 #### Automation scripts
 

package-lock.json

@@ -6,7 +6,7 @@
   "packages": {
     "": {
       "name": "privacy.sexy",
-      "version": "0.13.4",
+      "version": "0.13.3",
       "hasInstallScript": true,
       "dependencies": {
         "@floating-ui/vue": "^1.0.6",
@@ -34,7 +34,7 @@
         "@vue/test-utils": "^2.4.5",
         "autoprefixer": "^10.4.19",
         "cypress": "^13.7.3",
-        "electron": "^31.0.2",
+        "electron": "^29.3.0",
         "electron-builder": "^24.13.3",
         "electron-devtools-installer": "^3.2.0",
         "electron-vite": "^2.1.0",
@@ -6645,12 +6645,11 @@
       }
     },
     "node_modules/electron": {
-      "version": "31.0.2",
-      "resolved": "https://registry.npmjs.org/electron/-/electron-31.0.2.tgz",
-      "integrity": "sha512-55efQ5yfLN+AQHcFC00AXQqtxC3iAGaxX2GQ3EDbFJ0ca9GHNOdSXkcrdBElLleiDrR2hpXNkQxN1bDn0oxe6w==",
+      "version": "29.3.0",
+      "resolved": "https://registry.npmjs.org/electron/-/electron-29.3.0.tgz",
+      "integrity": "sha512-ZxFKm0/v48GSoBuO3DdnMlCYXefEUKUHLMsKxyXY4nZGgzbBKpF/X8haZa2paNj23CLfsCKBOtfc2vsEQiOOsA==",
       "dev": true,
       "hasInstallScript": true,
-      "license": "MIT",
       "dependencies": {
         "@electron/get": "^2.0.0",
         "@types/node": "^20.9.0",
@@ -22339,9 +22338,9 @@
       }
     },
     "electron": {
-      "version": "31.0.2",
-      "resolved": "https://registry.npmjs.org/electron/-/electron-31.0.2.tgz",
-      "integrity": "sha512-55efQ5yfLN+AQHcFC00AXQqtxC3iAGaxX2GQ3EDbFJ0ca9GHNOdSXkcrdBElLleiDrR2hpXNkQxN1bDn0oxe6w==",
+      "version": "29.3.0",
+      "resolved": "https://registry.npmjs.org/electron/-/electron-29.3.0.tgz",
+      "integrity": "sha512-ZxFKm0/v48GSoBuO3DdnMlCYXefEUKUHLMsKxyXY4nZGgzbBKpF/X8haZa2paNj23CLfsCKBOtfc2vsEQiOOsA==",
       "dev": true,
       "requires": {
         "@electron/get": "^2.0.0",

package.json

@@ -59,7 +59,7 @@
     "@vue/test-utils": "^2.4.5",
     "autoprefixer": "^10.4.19",
     "cypress": "^13.7.3",
-    "electron": "^31.0.2",
+    "electron": "^29.3.0",
     "electron-builder": "^24.13.3",
     "electron-devtools-installer": "^3.2.0",
     "electron-vite": "^2.1.0",

scripts/configure_vscode.py

@@ -58,10 +58,6 @@ def add_or_update_settings() -> None:
     # Details: # pylint: disable-next=line-too-long
     #   - https://archive.ph/2024.01.06-003914/https://github.com/microsoft/vscode/issues/179274, https://web.archive.org/web/20240106003915/https://github.com/microsoft/vscode/issues/179274
 
-    # Disable telemetry
-    configure_setting_key('redhat.telemetry.enabled', False)
-    configure_setting_key('gitlens.telemetry.enabled', False)
-
 def configure_setting_key(configuration_key: str, desired_value: Any) -> None:
     try:
         with open(VSCODE_SETTINGS_JSON_FILE, 'r+', encoding='utf-8') as file:

scripts/validate-collections-yaml/README.md

@@ -1,51 +0,0 @@
-# validate-collections-yaml
-
-This script validates YAML collection files against a predefined schema to ensure their integrity.
-
-## Prerequisites
-
-- Python 3.x installed on your system.
-
-## Running in a Virtual Environment (Recommended)
-
-Using a virtual environment isolates dependencies and prevents conflicts.
-
-1. **Create a virtual environment:**
-
-   ```bash
-   python3 -m venv ./scripts/validate-collections-yaml/.venv
-   ```
-
-2. **Activate the virtual environment:**
-
-   ```bash
-   source ./scripts/validate-collections-yaml/.venv/bin/activate
-   ```
-
-3. **Install dependencies:**
-
-   ```bash
-   python3 -m pip install -r ./scripts/validate-collections-yaml/requirements.txt
-   ```
-
-4. **Run the script:**
-
-   ```bash
-   python3 ./scripts/validate-collections-yaml
-   ```
-
-## Running Globally
-
-Running the script globally is less recommended due to potential dependency conflicts.
-
-1. **Install dependencies:**
-
-   ```bash
-   python3 -m pip install -r ./scripts/validate-collections-yaml/requirements.txt
-   ```
-
-2. **Run the script:**
-
-   ```bash
-   python3 ./scripts/validate-collections-yaml
-   ```

scripts/validate-collections-yaml/__main__.py

@@ -1,62 +0,0 @@
-"""
-Description:
-  This script validates collection YAML files against the expected schema.
-
-Usage:
-  python3 ./scripts/validate-collections-yaml
-
-Notes:
-  This script requires the `jsonschema` and `pyyaml` packages (see requirements.txt).
-"""
-# pylint: disable=missing-function-docstring
-from os import path
-import sys
-from glob import glob
-from typing import List
-from jsonschema import exceptions, validate # pylint: disable=import-error
-import yaml # pylint: disable=import-error
-
-SCHEMA_FILE_PATH = './src/application/collections/.schema.yaml'
-COLLECTIONS_GLOB_PATTERN = './src/application/collections/*.yaml'
-
-def main() -> None:
-    schema_yaml = read_file(SCHEMA_FILE_PATH)
-    schema_json = convert_yaml_to_json(schema_yaml)
-    collection_file_paths = find_collection_files(COLLECTIONS_GLOB_PATTERN)
-    print(f'Found {len(collection_file_paths)} YAML files to validate.')
-
-    total_invalid_files = 0
-    for collection_file_path in collection_file_paths:
-        file_name = path.basename(collection_file_path)
-        print(f'Validating {file_name}...')
-        collection_yaml = read_file(collection_file_path)
-        collection_json = convert_yaml_to_json(collection_yaml)
-        try:
-            validate(instance=collection_json, schema=schema_json)
-            print(f'Success: {file_name} is valid.')
-        except exceptions.ValidationError as err:
-            print(f'Error: Validation failed for {file_name}.', file=sys.stderr)
-            print(str(err), file=sys.stderr)
-            total_invalid_files += 1
-
-    if total_invalid_files > 0:
-        print(f'Validation complete with {total_invalid_files} invalid files.', file=sys.stderr)
-        sys.exit(1)
-    else:
-        print('Validation complete. All files are valid.')
-        sys.exit(0)
-
-def read_file(file_path: str) -> str:
-    with open(file_path, 'r', encoding='utf-8') as file:
-        return file.read()
-
-def find_collection_files(glob_pattern: str) -> List[str]:
-    files = glob(glob_pattern)
-    filtered_files = [f for f in files if not path.basename(f).startswith('.')]
-    return filtered_files
-
-def convert_yaml_to_json(yaml_content: str) -> dict:
-    return yaml.safe_load(yaml_content)
-
-if __name__ == '__main__':
-    main()

scripts/validate-collections-yaml/requirements.txt

@@ -1,6 +0,0 @@
-attrs==23.2.0
-jsonschema==4.22.0
-jsonschema-specifications==2023.12.1
-PyYAML==6.0.1
-referencing==0.35.1
-rpds-py==0.18.1

src/application/Common/Enum.ts

@@ -5,13 +5,13 @@ export type EnumType = number | string;
 export type EnumVariable<T extends EnumType, TEnumValue extends EnumType>
   = { [key in T]: TEnumValue };
 
-export interface EnumParser<TEnum> {
+export interface IEnumParser<TEnum> {
   parseEnum(value: string, propertyName: string): TEnum;
 }
 
 export function createEnumParser<T extends EnumType, TEnumValue extends EnumType>(
   enumVariable: EnumVariable<T, TEnumValue>,
-): EnumParser<TEnumValue> {
+): IEnumParser<TEnumValue> {
   return {
     parseEnum: (value, propertyName) => parseEnumValue(value, propertyName, enumVariable),
   };

src/application/Context/State/Code/Event/CodeChangedEvent.ts

@@ -1,4 +1,4 @@
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 import type { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
 import type { ICodeChangedEvent } from './ICodeChangedEvent';
@@ -6,13 +6,13 @@ import type { ICodeChangedEvent } from './ICodeChangedEvent';
 export class CodeChangedEvent implements ICodeChangedEvent {
   public readonly code: string;
 
-  public readonly addedScripts: ReadonlyArray<Script>;
+  public readonly addedScripts: ReadonlyArray<IScript>;
 
-  public readonly removedScripts: ReadonlyArray<Script>;
+  public readonly removedScripts: ReadonlyArray<IScript>;
 
-  public readonly changedScripts: ReadonlyArray<Script>;
+  public readonly changedScripts: ReadonlyArray<IScript>;
 
-  private readonly scripts: Map<Script, ICodePosition>;
+  private readonly scripts: Map<IScript, ICodePosition>;
 
   constructor(
     code: string,
@@ -25,7 +25,7 @@ export class CodeChangedEvent implements ICodeChangedEvent {
     this.addedScripts = selectIfNotExists(newScripts, oldScripts);
     this.removedScripts = selectIfNotExists(oldScripts, newScripts);
     this.changedScripts = getChangedScripts(oldScripts, newScripts);
-    this.scripts = new Map<Script, ICodePosition>();
+    this.scripts = new Map<IScript, ICodePosition>();
     scripts.forEach((position, selection) => {
       this.scripts.set(selection.script, position);
     });
@@ -35,7 +35,7 @@ export class CodeChangedEvent implements ICodeChangedEvent {
     return this.scripts.size === 0;
   }
 
-  public getScriptPositionInCode(script: Script): ICodePosition {
+  public getScriptPositionInCode(script: IScript): ICodePosition {
     return this.getPositionById(script.id);
   }
 
@@ -65,7 +65,7 @@ function ensureAllPositionsExist(script: string, positions: ReadonlyArray<ICodeP
 function getChangedScripts(
   oldScripts: ReadonlyArray<SelectedScript>,
   newScripts: ReadonlyArray<SelectedScript>,
-): ReadonlyArray<Script> {
+): ReadonlyArray<IScript> {
   return newScripts
     .filter((newScript) => oldScripts.find((oldScript) => oldScript.id === newScript.id
       && oldScript.revert !== newScript.revert))

src/application/Context/State/Code/Event/ICodeChangedEvent.ts

@@ -1,11 +1,11 @@
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 import type { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
 
 export interface ICodeChangedEvent {
   readonly code: string;
-  readonly addedScripts: ReadonlyArray<Script>;
-  readonly removedScripts: ReadonlyArray<Script>;
-  readonly changedScripts: ReadonlyArray<Script>;
+  readonly addedScripts: ReadonlyArray<IScript>;
+  readonly removedScripts: ReadonlyArray<IScript>;
+  readonly changedScripts: ReadonlyArray<IScript>;
   isEmpty(): boolean;
-  getScriptPositionInCode(script: Script): ICodePosition;
+  getScriptPositionInCode(script: IScript): ICodePosition;
 }

src/application/Context/State/Filter/Result/AppliedFilterResult.ts

@@ -1,11 +1,11 @@
-import type { Script } from '@/domain/Executables/Script/Script';
-import type { Category } from '@/domain/Executables/Category/Category';
+import type { IScript } from '@/domain/IScript';
+import type { ICategory } from '@/domain/ICategory';
 import type { FilterResult } from './FilterResult';
 
 export class AppliedFilterResult implements FilterResult {
   constructor(
-    public readonly scriptMatches: ReadonlyArray<Script>,
-    public readonly categoryMatches: ReadonlyArray<Category>,
+    public readonly scriptMatches: ReadonlyArray<IScript>,
+    public readonly categoryMatches: ReadonlyArray<ICategory>,
     public readonly query: string,
   ) {
     if (!query) { throw new Error('Query is empty or undefined'); }

src/application/Context/State/Filter/Result/FilterResult.ts

@@ -1,9 +1,8 @@
-import type { Category } from '@/domain/Executables/Category/Category';
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript, ICategory } from '@/domain/ICategory';
 
 export interface FilterResult {
-  readonly categoryMatches: ReadonlyArray<Category>;
-  readonly scriptMatches: ReadonlyArray<Script>;
+  readonly categoryMatches: ReadonlyArray<ICategory>;
+  readonly scriptMatches: ReadonlyArray<IScript>;
   readonly query: string;
   hasAnyMatches(): boolean;
 }

src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts

@@ -1,8 +1,7 @@
-import type { Category } from '@/domain/Executables/Category/Category';
-import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
-import type { Documentable } from '@/domain/Executables/Documentable';
+import type { ICategory, IScript } from '@/domain/ICategory';
+import type { IScriptCode } from '@/domain/IScriptCode';
+import type { IDocumentable } from '@/domain/IDocumentable';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
-import type { Script } from '@/domain/Executables/Script/Script';
 import { AppliedFilterResult } from '../Result/AppliedFilterResult';
 import type { FilterStrategy } from './FilterStrategy';
 import type { FilterResult } from '../Result/FilterResult';
@@ -25,7 +24,7 @@ export class LinearFilterStrategy implements FilterStrategy {
 }
 
 function matchesCategory(
-  category: Category,
+  category: ICategory,
   filterLowercase: string,
 ): boolean {
   return matchesAny(
@@ -35,7 +34,7 @@ function matchesCategory(
 }
 
 function matchesScript(
-  script: Script,
+  script: IScript,
   filterLowercase: string,
 ): boolean {
   return matchesAny(
@@ -59,7 +58,7 @@ function matchName(
 }
 
 function matchCode(
-  code: ScriptCode,
+  code: IScriptCode,
   filterLowercase: string,
 ): boolean {
   if (code.execute.toLowerCase().includes(filterLowercase)) {
@@ -72,7 +71,7 @@ function matchCode(
 }
 
 function matchDocumentation(
-  documentable: Documentable,
+  documentable: IDocumentable,
   filterLowercase: string,
 ): boolean {
   return documentable.docs.some(

src/application/Context/State/Selection/Category/CategorySelection.ts

@@ -1,9 +1,9 @@
-import type { Category } from '@/domain/Executables/Category/Category';
+import type { ICategory } from '@/domain/ICategory';
 import type { CategorySelectionChangeCommand } from './CategorySelectionChange';
 
 export interface ReadonlyCategorySelection {
-  areAllScriptsSelected(category: Category): boolean;
-  isAnyScriptSelected(category: Category): boolean;
+  areAllScriptsSelected(category: ICategory): boolean;
+  isAnyScriptSelected(category: ICategory): boolean;
 }
 
 export interface CategorySelection extends ReadonlyCategorySelection {

src/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.ts

@@ -1,4 +1,4 @@
-import type { Category } from '@/domain/Executables/Category/Category';
+import type { ICategory } from '@/domain/ICategory';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import type { CategorySelectionChange, CategorySelectionChangeCommand } from './CategorySelectionChange';
 import type { CategorySelection } from './CategorySelection';
@@ -13,7 +13,7 @@ export class ScriptToCategorySelectionMapper implements CategorySelection {
 
   }
 
-  public areAllScriptsSelected(category: Category): boolean {
+  public areAllScriptsSelected(category: ICategory): boolean {
     const { selectedScripts } = this.scriptSelection;
     if (selectedScripts.length === 0) {
       return false;
@@ -27,7 +27,7 @@ export class ScriptToCategorySelectionMapper implements CategorySelection {
     );
   }
 
-  public isAnyScriptSelected(category: Category): boolean {
+  public isAnyScriptSelected(category: ICategory): boolean {
     const { selectedScripts } = this.scriptSelection;
     if (selectedScripts.length === 0) {
       return false;

src/application/Context/State/Selection/Script/DebouncedScriptSelection.ts

@@ -1,5 +1,5 @@
 import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 import { EventSource } from '@/infrastructure/Events/EventSource';
 import type { ReadonlyRepository, Repository } from '@/application/Repository/Repository';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
@@ -80,7 +80,7 @@ export class DebouncedScriptSelection implements ScriptSelection {
     });
   }
 
-  public selectOnly(scripts: readonly Script[]): void {
+  public selectOnly(scripts: readonly IScript[]): void {
     assertNonEmptyScriptSelection(scripts);
     this.processChanges({
       changes: [
@@ -145,7 +145,7 @@ export class DebouncedScriptSelection implements ScriptSelection {
   }
 }
 
-function assertNonEmptyScriptSelection(selectedItems: readonly Script[]) {
+function assertNonEmptyScriptSelection(selectedItems: readonly IScript[]) {
   if (selectedItems.length === 0) {
     throw new Error('Provided script array is empty. To deselect all scripts, please use the deselectAll() method instead.');
   }
@@ -153,7 +153,7 @@ function assertNonEmptyScriptSelection(selectedItems: readonly Script[]) {
 
 function getScriptIdsToBeSelected(
   existingItems: ReadonlyRepository<string, SelectedScript>,
-  desiredScripts: readonly Script[],
+  desiredScripts: readonly IScript[],
 ): string[] {
   return desiredScripts
     .filter((script) => !existingItems.exists(script.id))
@@ -162,7 +162,7 @@ function getScriptIdsToBeSelected(
 
 function getScriptIdsToBeDeselected(
   existingItems: ReadonlyRepository<string, SelectedScript>,
-  desiredScripts: readonly Script[],
+  desiredScripts: readonly IScript[],
 ): string[] {
   return existingItems
     .getItems()

src/application/Context/State/Selection/Script/ScriptSelection.ts

@@ -1,5 +1,5 @@
 import type { IEventSource } from '@/infrastructure/Events/IEventSource';
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 import type { SelectedScript } from './SelectedScript';
 import type { ScriptSelectionChangeCommand } from './ScriptSelectionChange';
 
@@ -10,7 +10,7 @@ export interface ReadonlyScriptSelection {
 }
 
 export interface ScriptSelection extends ReadonlyScriptSelection {
-  selectOnly(scripts: readonly Script[]): void;
+  selectOnly(scripts: readonly IScript[]): void;
   selectAll(): void;
   deselectAll(): void;
   processChanges(action: ScriptSelectionChangeCommand): void;

src/application/Context/State/Selection/Script/SelectedScript.ts

@@ -1,9 +1,9 @@
 import type { IEntity } from '@/infrastructure/Entity/IEntity';
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 
-type ScriptId = Script['id'];
+type ScriptId = IScript['id'];
 
 export interface SelectedScript extends IEntity<ScriptId> {
-  readonly script: Script;
+  readonly script: IScript;
   readonly revert: boolean;
 }

src/application/Context/State/Selection/Script/UserSelectedScript.ts

@@ -1,12 +1,12 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import type { Script } from '@/domain/Executables/Script/Script';
+import type { IScript } from '@/domain/IScript';
 import type { SelectedScript } from './SelectedScript';
 
 type SelectedScriptId = SelectedScript['id'];
 
 export class UserSelectedScript extends BaseEntity<SelectedScriptId> {
   constructor(
-    public readonly script: Script,
+    public readonly script: IScript,
     public readonly revert: boolean,
   ) {
     super(script.id);

src/application/Parser/ApplicationParser.ts

@@ -1,48 +1,40 @@
 import type { CollectionData } from '@/application/collections/';
 import type { IApplication } from '@/domain/IApplication';
+import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import WindowsData from '@/application/collections/windows.yaml';
 import MacOsData from '@/application/collections/macos.yaml';
 import LinuxData from '@/application/collections/linux.yaml';
-import { parseProjectDetails, type ProjectDetailsParser } from '@/application/Parser/ProjectDetailsParser';
+import { parseProjectDetails } from '@/application/Parser/ProjectDetailsParser';
 import { Application } from '@/domain/Application';
-import { parseCategoryCollection, type CategoryCollectionParser } from './CategoryCollectionParser';
-import { createTypeValidator, type TypeValidator } from './Common/TypeValidator';
+import type { IAppMetadata } from '@/infrastructure/EnvironmentVariables/IAppMetadata';
+import { EnvironmentVariablesFactory } from '@/infrastructure/EnvironmentVariables/EnvironmentVariablesFactory';
+import { parseCategoryCollection } from './CategoryCollectionParser';
 
 export function parseApplication(
-  collectionsData: readonly CollectionData[] = PreParsedCollections,
-  utilities: ApplicationParserUtilities = DefaultUtilities,
+  categoryParser = parseCategoryCollection,
+  projectDetailsParser = parseProjectDetails,
+  metadata: IAppMetadata = EnvironmentVariablesFactory.Current.instance,
+  collectionsData = PreParsedCollections,
 ): IApplication {
-  validateCollectionsData(collectionsData, utilities.validator);
-  const projectDetails = utilities.parseProjectDetails();
+  validateCollectionsData(collectionsData);
+  const projectDetails = projectDetailsParser(metadata);
   const collections = collectionsData.map(
-    (collection) => utilities.parseCategoryCollection(collection, projectDetails),
+    (collection) => categoryParser(collection, projectDetails),
   );
   const app = new Application(projectDetails, collections);
   return app;
 }
 
-const PreParsedCollections: readonly CollectionData[] = [
+export type CategoryCollectionParserType
+    = (file: CollectionData, projectDetails: ProjectDetails) => ICategoryCollection;
+
+const PreParsedCollections: readonly CollectionData [] = [
   WindowsData, MacOsData, LinuxData,
 ];
 
-function validateCollectionsData(
-  collections: readonly CollectionData[],
-  validator: TypeValidator,
-) {
-  validator.assertNonEmptyCollection({
-    value: collections,
-    valueName: 'collections',
-  });
+function validateCollectionsData(collections: readonly CollectionData[]) {
+  if (!collections.length) {
+    throw new Error('missing collections');
+  }
 }
-
-interface ApplicationParserUtilities {
-  readonly parseCategoryCollection: CategoryCollectionParser;
-  readonly validator: TypeValidator;
-  readonly parseProjectDetails: ProjectDetailsParser;
-}
-
-const DefaultUtilities: ApplicationParserUtilities = {
-  parseCategoryCollection,
-  parseProjectDetails,
-  validator: createTypeValidator(),
-};

src/application/Parser/CategoryCollectionParser.ts

@@ -3,73 +3,32 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { CategoryCollection } from '@/domain/CategoryCollection';
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
-import { createEnumParser, type EnumParser } from '../Common/Enum';
-import { parseCategory, type CategoryParser } from './Executable/CategoryParser';
-import { parseScriptingDefinition, type ScriptingDefinitionParser } from './ScriptingDefinition/ScriptingDefinitionParser';
-import { createTypeValidator, type TypeValidator } from './Common/TypeValidator';
-import { createCollectionUtilities, type CategoryCollectionSpecificUtilitiesFactory } from './Executable/CategoryCollectionSpecificUtilities';
+import { createEnumParser } from '../Common/Enum';
+import { parseCategory } from './CategoryParser';
+import { CategoryCollectionParseContext } from './Script/CategoryCollectionParseContext';
+import { ScriptingDefinitionParser } from './ScriptingDefinition/ScriptingDefinitionParser';
 
-export const parseCategoryCollection: CategoryCollectionParser = (
-  content,
-  projectDetails,
-  utilities: CategoryCollectionParserUtilities = DefaultUtilities,
-) => {
-  validateCollection(content, utilities.validator);
-  const scripting = utilities.parseScriptingDefinition(content.scripting, projectDetails);
-  const collectionUtilities = utilities.createUtilities(content.functions, scripting);
-  const categories = content.actions.map(
-    (action) => utilities.parseCategory(action, collectionUtilities),
-  );
-  const os = utilities.osParser.parseEnum(content.os, 'os');
-  const collection = utilities.createCategoryCollection({
-    os, actions: categories, scripting,
-  });
-  return collection;
-};
-
-export type CategoryCollectionFactory = (
-  ...parameters: ConstructorParameters<typeof CategoryCollection>
-) => ICategoryCollection;
-
-export interface CategoryCollectionParser {
-  (
-    content: CollectionData,
-    projectDetails: ProjectDetails,
-    utilities?: CategoryCollectionParserUtilities,
-  ): ICategoryCollection;
-}
-
-function validateCollection(
+export function parseCategoryCollection(
   content: CollectionData,
-  validator: TypeValidator,
-): void {
-  validator.assertObject({
-    value: content,
-    valueName: 'collection',
-    allowedProperties: [
-      'os', 'scripting', 'actions', 'functions',
-    ],
-  });
-  validator.assertNonEmptyCollection({
-    value: content.actions,
-    valueName: '"actions" in collection',
-  });
+  projectDetails: ProjectDetails,
+  osParser = createEnumParser(OperatingSystem),
+): ICategoryCollection {
+  validate(content);
+  const scripting = new ScriptingDefinitionParser()
+    .parse(content.scripting, projectDetails);
+  const context = new CategoryCollectionParseContext(content.functions, scripting);
+  const categories = content.actions.map((action) => parseCategory(action, context));
+  const os = osParser.parseEnum(content.os, 'os');
+  const collection = new CategoryCollection(
+    os,
+    categories,
+    scripting,
+  );
+  return collection;
 }
 
-interface CategoryCollectionParserUtilities {
-  readonly osParser: EnumParser<OperatingSystem>;
-  readonly validator: TypeValidator;
-  readonly parseScriptingDefinition: ScriptingDefinitionParser;
-  readonly createUtilities: CategoryCollectionSpecificUtilitiesFactory;
-  readonly parseCategory: CategoryParser;
-  readonly createCategoryCollection: CategoryCollectionFactory;
+function validate(content: CollectionData): void {
+  if (!content.actions.length) {
+    throw new Error('content does not define any action');
+  }
 }
-
-const DefaultUtilities: CategoryCollectionParserUtilities = {
-  osParser: createEnumParser(OperatingSystem),
-  validator: createTypeValidator(),
-  parseScriptingDefinition,
-  createUtilities: createCollectionUtilities,
-  parseCategory,
-  createCategoryCollection: (...args) => new CategoryCollection(...args),
-};

src/application/Parser/CategoryParser.ts

@@ -0,0 +1,171 @@
+import type {
+  CategoryData, ScriptData, CategoryOrScriptData,
+} from '@/application/collections/';
+import { Script } from '@/domain/Script';
+import { Category } from '@/domain/Category';
+import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
+import type { ICategory } from '@/domain/ICategory';
+import { parseDocs, type DocsParser } from './DocumentationParser';
+import { parseScript, type ScriptParser } from './Script/ScriptParser';
+import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from './NodeValidation/NodeDataValidator';
+import { NodeDataType } from './NodeValidation/NodeDataType';
+import type { ICategoryCollectionParseContext } from './Script/ICategoryCollectionParseContext';
+
+let categoryIdCounter = 0;
+
+export function parseCategory(
+  category: CategoryData,
+  context: ICategoryCollectionParseContext,
+  utilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
+): Category {
+  return parseCategoryRecursively({
+    categoryData: category,
+    context,
+    utilities,
+  });
+}
+
+interface CategoryParseContext {
+  readonly categoryData: CategoryData;
+  readonly context: ICategoryCollectionParseContext;
+  readonly parentCategory?: CategoryData;
+  readonly utilities: CategoryParserUtilities;
+}
+
+function parseCategoryRecursively(
+  context: CategoryParseContext,
+): Category | never {
+  const validator = ensureValidCategory(context);
+  const children: CategoryChildren = {
+    subcategories: new Array<Category>(),
+    subscripts: new Array<Script>(),
+  };
+  for (const data of context.categoryData.children) {
+    parseNode({
+      nodeData: data,
+      children,
+      parent: context.categoryData,
+      utilities: context.utilities,
+      context: context.context,
+    });
+  }
+  try {
+    return context.utilities.createCategory({
+      id: categoryIdCounter++,
+      name: context.categoryData.category,
+      docs: context.utilities.parseDocs(context.categoryData),
+      subcategories: children.subcategories,
+      scripts: children.subscripts,
+    });
+  } catch (error) {
+    throw context.utilities.wrapError(
+      error,
+      validator.createContextualErrorMessage('Failed to parse category.'),
+    );
+  }
+}
+
+function ensureValidCategory(
+  context: CategoryParseContext,
+): NodeDataValidator {
+  const category = context.categoryData;
+  const validator: NodeDataValidator = context.utilities.createValidator({
+    type: NodeDataType.Category,
+    selfNode: context.categoryData,
+    parentNode: context.parentCategory,
+  });
+  validator.assertDefined(category);
+  validator.assertValidName(category.category);
+  validator.assert(
+    () => Boolean(category.children) && category.children.length > 0,
+    `"${category.category}" has no children.`,
+  );
+  return validator;
+}
+
+interface CategoryChildren {
+  readonly subcategories: Category[];
+  readonly subscripts: Script[];
+}
+
+interface NodeParseContext {
+  readonly nodeData: CategoryOrScriptData;
+  readonly children: CategoryChildren;
+  readonly parent: CategoryData;
+  readonly context: ICategoryCollectionParseContext;
+
+  readonly utilities: CategoryParserUtilities;
+}
+
+function parseNode(context: NodeParseContext) {
+  const validator: NodeDataValidator = context.utilities.createValidator({
+    selfNode: context.nodeData,
+    parentNode: context.parent,
+  });
+  validator.assertDefined(context.nodeData);
+  validator.assert(
+    () => isCategory(context.nodeData) || isScript(context.nodeData),
+    'Node is neither a category or a script.',
+  );
+  if (isCategory(context.nodeData)) {
+    const subCategory = parseCategoryRecursively({
+      categoryData: context.nodeData,
+      context: context.context,
+      parentCategory: context.parent,
+      utilities: context.utilities,
+    });
+    context.children.subcategories.push(subCategory);
+  } else { // A script
+    const script = context.utilities.parseScript(context.nodeData, context.context);
+    context.children.subscripts.push(script);
+  }
+}
+
+function isScript(data: CategoryOrScriptData): data is ScriptData {
+  return hasCode(data) || hasCall(data);
+}
+
+function isCategory(data: CategoryOrScriptData): data is CategoryData {
+  return hasProperty(data, 'category');
+}
+
+function hasCode(data: unknown): boolean {
+  return hasProperty(data, 'code');
+}
+
+function hasCall(data: unknown) {
+  return hasProperty(data, 'call');
+}
+
+function hasProperty(
+  object: unknown,
+  propertyName: string,
+): object is NonNullable<object> {
+  if (typeof object !== 'object') {
+    return false;
+  }
+  if (object === null) { // `typeof object` is `null`
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(object, propertyName);
+}
+
+export type CategoryFactory = (
+  ...parameters: ConstructorParameters<typeof Category>
+) => ICategory;
+
+interface CategoryParserUtilities {
+  readonly createCategory: CategoryFactory;
+  readonly wrapError: ErrorWithContextWrapper;
+  readonly createValidator: NodeDataValidatorFactory;
+  readonly parseScript: ScriptParser;
+  readonly parseDocs: DocsParser;
+}
+
+const DefaultCategoryParserUtilities: CategoryParserUtilities = {
+  createCategory: (...parameters) => new Category(...parameters),
+  wrapError: wrapErrorWithAdditionalContext,
+  createValidator: createNodeDataValidator,
+  parseScript,
+  parseDocs,
+};

src/application/Parser/Common/TypeValidator.ts

@@ -1,131 +0,0 @@
-import type { PropertyKeys } from '@/TypeHelpers';
-import {
-  isNullOrUndefined, isArray, isPlainObject, isString,
-} from '@/TypeHelpers';
-
-export interface TypeValidator {
-  assertObject<T>(assertion: ObjectAssertion<T>): void;
-  assertNonEmptyCollection(assertion: NonEmptyCollectionAssertion): void;
-  assertNonEmptyString(assertion: NonEmptyStringAssertion): void;
-}
-
-export interface NonEmptyCollectionAssertion {
-  readonly value: unknown;
-  readonly valueName: string;
-}
-
-export interface RegexValidationRule {
-  readonly expectedMatch: RegExp;
-  readonly errorMessage: string;
-}
-
-export interface NonEmptyStringAssertion {
-  readonly value: unknown;
-  readonly valueName: string;
-  readonly rule?: RegexValidationRule;
-}
-
-export interface ObjectAssertion<T> {
-  readonly value: T | unknown;
-  readonly valueName: string;
-  readonly allowedProperties?: readonly PropertyKeys<T>[];
-}
-
-export function createTypeValidator(): TypeValidator {
-  return {
-    assertObject: (assertion) => {
-      assertDefined(assertion.value, assertion.valueName);
-      assertPlainObject(assertion.value, assertion.valueName);
-      assertNoEmptyProperties(assertion.value, assertion.valueName);
-      if (assertion.allowedProperties !== undefined) {
-        const allowedProperties = assertion.allowedProperties.map((p) => p as string);
-        assertAllowedProperties(assertion.value, assertion.valueName, allowedProperties);
-      }
-    },
-    assertNonEmptyCollection: (assertion) => {
-      assertDefined(assertion.value, assertion.valueName);
-      assertArray(assertion.value, assertion.valueName);
-      assertNonEmpty(assertion.value, assertion.valueName);
-    },
-    assertNonEmptyString: (assertion) => {
-      assertDefined(assertion.value, assertion.valueName);
-      assertString(assertion.value, assertion.valueName);
-      if (assertion.value.length === 0) {
-        throw new Error(`'${assertion.valueName}' is missing.`);
-      }
-      if (assertion.rule) {
-        if (!assertion.value.match(assertion.rule.expectedMatch)) {
-          throw new Error(assertion.rule.errorMessage);
-        }
-      }
-    },
-  };
-}
-
-function assertDefined<T>(
-  value: T,
-  valueName: string,
-): asserts value is NonNullable<T> {
-  if (isNullOrUndefined(value)) {
-    throw new Error(`'${valueName}' is missing.`);
-  }
-}
-
-function assertPlainObject(
-  value: unknown,
-  valueName: string,
-): asserts value is object {
-  if (!isPlainObject(value)) {
-    throw new Error(`'${valueName}' is not an object.`);
-  }
-}
-
-function assertNoEmptyProperties(
-  value: object,
-  valueName: string,
-): void {
-  if (Object.keys(value).length === 0) {
-    throw new Error(`'${valueName}' is an empty object without properties.`);
-  }
-}
-
-function assertAllowedProperties(
-  value: object,
-  valueName: string,
-  allowedProperties: readonly string[],
-): void {
-  const properties = Object.keys(value).map((p) => p as string);
-  const disallowedProperties = properties.filter(
-    (prop) => !allowedProperties.map((p) => p as string).includes(prop),
-  );
-  if (disallowedProperties.length > 0) {
-    throw new Error(`'${valueName}' has disallowed properties: ${disallowedProperties.join(', ')}.`);
-  }
-}
-
-function assertArray(
-  value: unknown,
-  valueName: string,
-): asserts value is Array<unknown> {
-  if (!isArray(value)) {
-    throw new Error(`'${valueName}' should be of type 'array', but is of type '${typeof value}'.`);
-  }
-}
-
-function assertString(
-  value: unknown,
-  valueName: string,
-): asserts value is string {
-  if (!isString(value)) {
-    throw new Error(`'${valueName}' should be of type 'string', but is of type '${typeof value}'.`);
-  }
-}
-
-function assertNonEmpty(
-  value: Array<unknown>,
-  valueName: string,
-): void {
-  if (value.length === 0) {
-    throw new Error(`'${valueName}' cannot be an empty array.`);
-  }
-}

src/application/Parser/DocumentationParser.ts

@@ -50,5 +50,5 @@ class DocumentationContainer {
 }
 
 function throwInvalidType(): never {
-  throw new Error('docs field (documentation) must be a single string or an array of strings.');
+  throw new Error('docs field (documentation) must be an array of strings');
 }

src/application/Parser/Executable/CategoryCollectionSpecificUtilities.ts

@@ -1,35 +0,0 @@
-import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
-import type { FunctionData } from '@/application/collections/';
-import { ScriptCompiler } from './Script/Compiler/ScriptCompiler';
-import { SyntaxFactory } from './Script/Validation/Syntax/SyntaxFactory';
-import type { IScriptCompiler } from './Script/Compiler/IScriptCompiler';
-import type { ILanguageSyntax } from './Script/Validation/Syntax/ILanguageSyntax';
-import type { ISyntaxFactory } from './Script/Validation/Syntax/ISyntaxFactory';
-
-export interface CategoryCollectionSpecificUtilities {
-  readonly compiler: IScriptCompiler;
-  readonly syntax: ILanguageSyntax;
-}
-
-export const createCollectionUtilities: CategoryCollectionSpecificUtilitiesFactory = (
-  functionsData: ReadonlyArray<FunctionData> | undefined,
-  scripting: IScriptingDefinition,
-  syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
-) => {
-  const syntax = syntaxFactory.create(scripting.language);
-  return {
-    compiler: new ScriptCompiler({
-      functions: functionsData ?? [],
-      syntax,
-    }),
-    syntax,
-  };
-};
-
-export interface CategoryCollectionSpecificUtilitiesFactory {
-  (
-    functionsData: ReadonlyArray<FunctionData> | undefined,
-    scripting: IScriptingDefinition,
-    syntaxFactory?: ISyntaxFactory,
-  ): CategoryCollectionSpecificUtilities;
-}

src/application/Parser/Executable/CategoryParser.ts

@@ -1,187 +0,0 @@
-import type {
-  CategoryData, ScriptData, ExecutableData,
-} from '@/application/collections/';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
-import type { Category } from '@/domain/Executables/Category/Category';
-import { CollectionCategory } from '@/domain/Executables/Category/CollectionCategory';
-import type { Script } from '@/domain/Executables/Script/Script';
-import { parseDocs, type DocsParser } from './DocumentationParser';
-import { parseScript, type ScriptParser } from './Script/ScriptParser';
-import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from './Validation/ExecutableValidator';
-import { ExecutableType } from './Validation/ExecutableType';
-import type { CategoryCollectionSpecificUtilities } from './CategoryCollectionSpecificUtilities';
-
-let categoryIdCounter = 0;
-
-export const parseCategory: CategoryParser = (
-  category: CategoryData,
-  collectionUtilities: CategoryCollectionSpecificUtilities,
-  categoryUtilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
-) => {
-  return parseCategoryRecursively({
-    categoryData: category,
-    collectionUtilities,
-    categoryUtilities,
-  });
-};
-
-export interface CategoryParser {
-  (
-    category: CategoryData,
-    collectionUtilities: CategoryCollectionSpecificUtilities,
-    categoryUtilities?: CategoryParserUtilities,
-  ): Category;
-}
-
-interface CategoryParseContext {
-  readonly categoryData: CategoryData;
-  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
-  readonly parentCategory?: CategoryData;
-  readonly categoryUtilities: CategoryParserUtilities;
-}
-
-function parseCategoryRecursively(
-  context: CategoryParseContext,
-): Category | never {
-  const validator = ensureValidCategory(context);
-  const children: CategoryChildren = {
-    subcategories: new Array<Category>(),
-    subscripts: new Array<Script>(),
-  };
-  for (const data of context.categoryData.children) {
-    parseUnknownExecutable({
-      data,
-      children,
-      parent: context.categoryData,
-      categoryUtilities: context.categoryUtilities,
-      collectionUtilities: context.collectionUtilities,
-    });
-  }
-  try {
-    return context.categoryUtilities.createCategory({
-      id: categoryIdCounter++,
-      name: context.categoryData.category,
-      docs: context.categoryUtilities.parseDocs(context.categoryData),
-      subcategories: children.subcategories,
-      scripts: children.subscripts,
-    });
-  } catch (error) {
-    throw context.categoryUtilities.wrapError(
-      error,
-      validator.createContextualErrorMessage('Failed to parse category.'),
-    );
-  }
-}
-
-function ensureValidCategory(
-  context: CategoryParseContext,
-): ExecutableValidator {
-  const category = context.categoryData;
-  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
-    type: ExecutableType.Category,
-    self: context.categoryData,
-    parentCategory: context.parentCategory,
-  });
-  validator.assertType((v) => v.assertObject({
-    value: category,
-    valueName: category.category ?? 'category',
-    allowedProperties: [
-      'docs', 'children', 'category',
-    ],
-  }));
-  validator.assertValidName(category.category);
-  validator.assertType((v) => v.assertNonEmptyCollection({
-    value: category.children,
-    valueName: category.category,
-  }));
-  return validator;
-}
-
-interface CategoryChildren {
-  readonly subcategories: Category[];
-  readonly subscripts: Script[];
-}
-
-interface ExecutableParseContext {
-  readonly data: ExecutableData;
-  readonly children: CategoryChildren;
-  readonly parent: CategoryData;
-  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
-  readonly categoryUtilities: CategoryParserUtilities;
-}
-
-function parseUnknownExecutable(context: ExecutableParseContext) {
-  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
-    self: context.data,
-    parentCategory: context.parent,
-  });
-  validator.assertType((v) => v.assertObject({
-    value: context.data,
-    valueName: 'Executable',
-  }));
-  validator.assert(
-    () => isCategory(context.data) || isScript(context.data),
-    'Executable is neither a category or a script.',
-  );
-  if (isCategory(context.data)) {
-    const subCategory = parseCategoryRecursively({
-      categoryData: context.data,
-      collectionUtilities: context.collectionUtilities,
-      parentCategory: context.parent,
-      categoryUtilities: context.categoryUtilities,
-    });
-    context.children.subcategories.push(subCategory);
-  } else { // A script
-    const script = context.categoryUtilities.parseScript(context.data, context.collectionUtilities);
-    context.children.subscripts.push(script);
-  }
-}
-
-function isScript(data: ExecutableData): data is ScriptData {
-  return hasCode(data) || hasCall(data);
-}
-
-function isCategory(data: ExecutableData): data is CategoryData {
-  return hasProperty(data, 'category');
-}
-
-function hasCode(data: unknown): boolean {
-  return hasProperty(data, 'code');
-}
-
-function hasCall(data: unknown) {
-  return hasProperty(data, 'call');
-}
-
-function hasProperty(
-  object: unknown,
-  propertyName: string,
-): object is NonNullable<object> {
-  if (typeof object !== 'object') {
-    return false;
-  }
-  if (object === null) { // `typeof object` is `null`
-    return false;
-  }
-  return Object.prototype.hasOwnProperty.call(object, propertyName);
-}
-
-export type CategoryFactory = (
-  ...parameters: ConstructorParameters<typeof CollectionCategory>
-) => Category;
-
-interface CategoryParserUtilities {
-  readonly createCategory: CategoryFactory;
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: ExecutableValidatorFactory;
-  readonly parseScript: ScriptParser;
-  readonly parseDocs: DocsParser;
-}
-
-const DefaultCategoryParserUtilities: CategoryParserUtilities = {
-  createCategory: (...parameters) => new CollectionCategory(...parameters),
-  wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createExecutableDataValidator,
-  parseScript,
-  parseDocs,
-};

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

@@ -1,41 +0,0 @@
-import { createTypeValidator, type TypeValidator } from '@/application/Parser/Common/TypeValidator';
-import { validateParameterName, type ParameterNameValidator } from '@/application/Parser/Executable/Script/Compiler/Function/Shared/ParameterNameValidator';
-
-export interface FunctionCallArgument {
-  readonly parameterName: string;
-  readonly argumentValue: string;
-}
-
-export interface FunctionCallArgumentFactory {
-  (
-    parameterName: string,
-    argumentValue: string,
-    utilities?: FunctionCallArgumentFactoryUtilities,
-  ): FunctionCallArgument;
-}
-
-export const createFunctionCallArgument: FunctionCallArgumentFactory = (
-  parameterName: string,
-  argumentValue: string,
-  utilities: FunctionCallArgumentFactoryUtilities = DefaultUtilities,
-): FunctionCallArgument => {
-  utilities.validateParameterName(parameterName);
-  utilities.typeValidator.assertNonEmptyString({
-    value: argumentValue,
-    valueName: `Missing argument value for the parameter "${parameterName}".`,
-  });
-  return {
-    parameterName,
-    argumentValue,
-  };
-};
-
-interface FunctionCallArgumentFactoryUtilities {
-  readonly typeValidator: TypeValidator;
-  readonly validateParameterName: ParameterNameValidator;
-}
-
-const DefaultUtilities: FunctionCallArgumentFactoryUtilities = {
-  typeValidator: createTypeValidator(),
-  validateParameterName,
-};

src/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallsParser.ts

@@ -1,80 +0,0 @@
-import type {
-  FunctionCallData,
-  FunctionCallsData,
-  FunctionCallParametersData,
-} from '@/application/collections/';
-import { isArray, isPlainObject } from '@/TypeHelpers';
-import { createTypeValidator, type TypeValidator } from '@/application/Parser/Common/TypeValidator';
-import { FunctionCallArgumentCollection } from './Argument/FunctionCallArgumentCollection';
-import { ParsedFunctionCall } from './ParsedFunctionCall';
-import { createFunctionCallArgument, type FunctionCallArgumentFactory } from './Argument/FunctionCallArgument';
-import type { FunctionCall } from './FunctionCall';
-
-export interface FunctionCallsParser {
-  (
-    calls: FunctionCallsData,
-    utilities?: FunctionCallParsingUtilities,
-  ): FunctionCall[];
-}
-
-interface FunctionCallParsingUtilities {
-  readonly typeValidator: TypeValidator;
-  readonly createCallArgument: FunctionCallArgumentFactory;
-}
-
-const DefaultUtilities: FunctionCallParsingUtilities = {
-  typeValidator: createTypeValidator(),
-  createCallArgument: createFunctionCallArgument,
-};
-
-export const parseFunctionCalls: FunctionCallsParser = (
-  calls,
-  utilities = DefaultUtilities,
-) => {
-  const sequence = getCallSequence(calls, utilities.typeValidator);
-  return sequence.map((call) => parseFunctionCall(call, utilities));
-};
-
-function getCallSequence(calls: FunctionCallsData, validator: TypeValidator): FunctionCallData[] {
-  if (!isPlainObject(calls) && !isArray(calls)) {
-    throw new Error('called function(s) must be an object or array');
-  }
-  if (isArray(calls)) {
-    validator.assertNonEmptyCollection({
-      value: calls,
-      valueName: 'function call sequence',
-    });
-    return calls as FunctionCallData[];
-  }
-  const singleCall = calls as FunctionCallData;
-  return [singleCall];
-}
-
-function parseFunctionCall(
-  call: FunctionCallData,
-  utilities: FunctionCallParsingUtilities,
-): FunctionCall {
-  utilities.typeValidator.assertObject({
-    value: call,
-    valueName: 'function call',
-    allowedProperties: ['function', 'parameters'],
-  });
-  const callArgs = parseArgs(call.parameters, utilities.createCallArgument);
-  return new ParsedFunctionCall(call.function, callArgs);
-}
-
-function parseArgs(
-  parameters: FunctionCallParametersData | undefined,
-  createArgument: FunctionCallArgumentFactory,
-): FunctionCallArgumentCollection {
-  const parametersMap = parameters ?? {};
-  return Object.keys(parametersMap)
-    .map((parameterName) => {
-      const argumentValue = parametersMap[parameterName];
-      return createArgument(parameterName, argumentValue);
-    })
-    .reduce((args, arg) => {
-      args.addArgument(arg);
-      return args;
-    }, new FunctionCallArgumentCollection());
-}

src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterParser.ts

@@ -1,21 +0,0 @@
-import type { ParameterDefinitionData } from '@/application/collections/';
-import { validateParameterName, type ParameterNameValidator } from '../Shared/ParameterNameValidator';
-import type { FunctionParameter } from './FunctionParameter';
-
-export interface FunctionParameterParser {
-  (
-    data: ParameterDefinitionData,
-    validator?: ParameterNameValidator,
-  ): FunctionParameter;
-}
-
-export const parseFunctionParameter: FunctionParameterParser = (
-  data,
-  validator = validateParameterName,
-) => {
-  validator(data.name);
-  return {
-    name: data.name,
-    isOptional: data.optional || false,
-  };
-};

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

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

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

@@ -1,22 +0,0 @@
-import { createTypeValidator, type TypeValidator } from '@/application/Parser/Common/TypeValidator';
-
-export interface ParameterNameValidator {
-  (
-    parameterName: string,
-    typeValidator?: TypeValidator,
-  ): void;
-}
-
-export const validateParameterName = (
-  parameterName: string,
-  typeValidator = createTypeValidator(),
-) => {
-  typeValidator.assertNonEmptyString({
-    value: parameterName,
-    valueName: 'parameter name',
-    rule: {
-      expectedMatch: /^[0-9a-zA-Z]+$/,
-      errorMessage: `parameter name must be alphanumeric but it was "${parameterName}".`,
-    },
-  });
-};

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

@@ -1,87 +0,0 @@
-import type { FunctionData, ScriptData, CallInstruction } from '@/application/collections/';
-import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
-import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
-import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
-import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
-import { createScriptCode, type ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
-import { FunctionCallSequenceCompiler } from './Function/Call/Compiler/FunctionCallSequenceCompiler';
-import { parseFunctionCalls } from './Function/Call/FunctionCallsParser';
-import { parseSharedFunctions, type SharedFunctionsParser } from './Function/SharedFunctionsParser';
-import type { CompiledCode } from './Function/Call/Compiler/CompiledCode';
-import type { IScriptCompiler } from './IScriptCompiler';
-import type { ISharedFunctionCollection } from './Function/ISharedFunctionCollection';
-import type { FunctionCallCompiler } from './Function/Call/Compiler/FunctionCallCompiler';
-
-interface ScriptCompilerUtilities {
-  readonly sharedFunctionsParser: SharedFunctionsParser;
-  readonly callCompiler: FunctionCallCompiler;
-  readonly codeValidator: ICodeValidator;
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly scriptCodeFactory: ScriptCodeFactory;
-}
-
-const DefaultUtilities: ScriptCompilerUtilities = {
-  sharedFunctionsParser: parseSharedFunctions,
-  callCompiler: FunctionCallSequenceCompiler.instance,
-  codeValidator: CodeValidator.instance,
-  wrapError: wrapErrorWithAdditionalContext,
-  scriptCodeFactory: createScriptCode,
-};
-
-interface CategoryCollectionDataContext {
-  readonly functions: readonly FunctionData[];
-  readonly syntax: ILanguageSyntax;
-}
-
-export class ScriptCompiler implements IScriptCompiler {
-  private readonly functions: ISharedFunctionCollection;
-
-  constructor(
-    categoryContext: CategoryCollectionDataContext,
-    private readonly utilities: ScriptCompilerUtilities = DefaultUtilities,
-  ) {
-    this.functions = this.utilities.sharedFunctionsParser(
-      categoryContext.functions,
-      categoryContext.syntax,
-    );
-  }
-
-  public canCompile(script: ScriptData): boolean {
-    return hasCall(script);
-  }
-
-  public compile(script: ScriptData): ScriptCode {
-    try {
-      if (!hasCall(script)) {
-        throw new Error('Script does include any calls.');
-      }
-      const calls = parseFunctionCalls(script.call);
-      const compiledCode = this.utilities.callCompiler.compileFunctionCalls(calls, this.functions);
-      validateCompiledCode(compiledCode, this.utilities.codeValidator);
-      return this.utilities.scriptCodeFactory(
-        compiledCode.code,
-        compiledCode.revertCode,
-      );
-    } catch (error) {
-      throw this.utilities.wrapError(error, `Failed to compile script: ${script.name}`);
-    }
-  }
-}
-
-function validateCompiledCode(compiledCode: CompiledCode, validator: ICodeValidator): void {
-  [compiledCode.code, compiledCode.revertCode]
-    .filter((code): code is string => Boolean(code))
-    .map((code) => code as string)
-    .forEach(
-      (code) => validator.throwIfInvalid(
-        code,
-        [new NoEmptyLines()],
-      ),
-    );
-}
-
-function hasCall(data: ScriptData): data is ScriptData & CallInstruction {
-  return (data as CallInstruction).call !== undefined;
-}

src/application/Parser/Executable/Script/ScriptParser.ts

@@ -1,151 +0,0 @@
-import type { ScriptData, CodeScriptData, CallScriptData } from '@/application/collections/';
-import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
-import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
-import { CollectionScript } from '@/domain/Executables/Script/CollectionScript';
-import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
-import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
-import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
-import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
-import { createScriptCode } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
-import type { Script } from '@/domain/Executables/Script/Script';
-import { createEnumParser, type EnumParser } from '@/application/Common/Enum';
-import { parseDocs, type DocsParser } from '../DocumentationParser';
-import { ExecutableType } from '../Validation/ExecutableType';
-import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from '../Validation/ExecutableValidator';
-import { CodeValidator } from './Validation/CodeValidator';
-import { NoDuplicatedLines } from './Validation/Rules/NoDuplicatedLines';
-import type { CategoryCollectionSpecificUtilities } from '../CategoryCollectionSpecificUtilities';
-
-export interface ScriptParser {
-  (
-    data: ScriptData,
-    collectionUtilities: CategoryCollectionSpecificUtilities,
-    scriptUtilities?: ScriptParserUtilities,
-  ): Script;
-}
-
-export const parseScript: ScriptParser = (
-  data,
-  collectionUtilities,
-  scriptUtilities = DefaultUtilities,
-) => {
-  const validator = scriptUtilities.createValidator({
-    type: ExecutableType.Script,
-    self: data,
-  });
-  validateScript(data, validator);
-  try {
-    const script = scriptUtilities.createScript({
-      name: data.name,
-      code: parseCode(
-        data,
-        collectionUtilities,
-        scriptUtilities.codeValidator,
-        scriptUtilities.createCode,
-      ),
-      docs: scriptUtilities.parseDocs(data),
-      level: parseLevel(data.recommend, scriptUtilities.levelParser),
-    });
-    return script;
-  } catch (error) {
-    throw scriptUtilities.wrapError(
-      error,
-      validator.createContextualErrorMessage('Failed to parse script.'),
-    );
-  }
-};
-
-function parseLevel(
-  level: string | undefined,
-  parser: EnumParser<RecommendationLevel>,
-): RecommendationLevel | undefined {
-  if (!level) {
-    return undefined;
-  }
-  return parser.parseEnum(level, 'level');
-}
-
-function parseCode(
-  script: ScriptData,
-  collectionUtilities: CategoryCollectionSpecificUtilities,
-  codeValidator: ICodeValidator,
-  createCode: ScriptCodeFactory,
-): ScriptCode {
-  if (collectionUtilities.compiler.canCompile(script)) {
-    return collectionUtilities.compiler.compile(script);
-  }
-  const codeScript = script as CodeScriptData; // Must be inline code if it cannot be compiled
-  const code = createCode(codeScript.code, codeScript.revertCode);
-  validateHardcodedCodeWithoutCalls(code, codeValidator, collectionUtilities.syntax);
-  return code;
-}
-
-function validateHardcodedCodeWithoutCalls(
-  scriptCode: ScriptCode,
-  validator: ICodeValidator,
-  syntax: ILanguageSyntax,
-) {
-  [scriptCode.execute, scriptCode.revert]
-    .filter((code): code is string => Boolean(code))
-    .forEach(
-      (code) => validator.throwIfInvalid(
-        code,
-        [new NoEmptyLines(), new NoDuplicatedLines(syntax)],
-      ),
-    );
-}
-
-function validateScript(
-  script: ScriptData,
-  validator: ExecutableValidator,
-): asserts script is NonNullable<ScriptData> {
-  validator.assertType((v) => v.assertObject<CallScriptData & CodeScriptData>({
-    value: script,
-    valueName: script.name ?? 'script',
-    allowedProperties: [
-      'name', 'recommend', 'code', 'revertCode', 'call', 'docs',
-    ],
-  }));
-  validator.assertValidName(script.name);
-  validator.assert(
-    () => Boolean((script as CodeScriptData).code || (script as CallScriptData).call),
-    'Neither "call" or "code" is defined.',
-  );
-  validator.assert(
-    () => !((script as CodeScriptData).code && (script as CallScriptData).call),
-    'Both "call" and "code" are defined.',
-  );
-  validator.assert(
-    () => !((script as CodeScriptData).revertCode && (script as CallScriptData).call),
-    'Both "call" and "revertCode" are defined.',
-  );
-}
-
-interface ScriptParserUtilities {
-  readonly levelParser: EnumParser<RecommendationLevel>;
-  readonly createScript: ScriptFactory;
-  readonly codeValidator: ICodeValidator;
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: ExecutableValidatorFactory;
-  readonly createCode: ScriptCodeFactory;
-  readonly parseDocs: DocsParser;
-}
-
-export type ScriptFactory = (
-  ...parameters: ConstructorParameters<typeof CollectionScript>
-) => Script;
-
-const createScript: ScriptFactory = (...parameters) => {
-  return new CollectionScript(...parameters);
-};
-
-const DefaultUtilities: ScriptParserUtilities = {
-  levelParser: createEnumParser(RecommendationLevel),
-  createScript,
-  codeValidator: CodeValidator.instance,
-  wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createExecutableDataValidator,
-  createCode: createScriptCode,
-  parseDocs,
-};

src/application/Parser/Executable/Validation/ExecutableErrorContext.ts

@@ -1,24 +0,0 @@
-import type { CategoryData, ScriptData, ExecutableData } from '@/application/collections/';
-import { ExecutableType } from './ExecutableType';
-
-export type ExecutableErrorContext = {
-  readonly parentCategory?: CategoryData;
-} & (CategoryErrorContext | ScriptErrorContext | UnknownExecutableErrorContext);
-
-export type CategoryErrorContext = {
-  readonly type: ExecutableType.Category;
-  readonly self: CategoryData;
-  readonly parentCategory?: CategoryData;
-};
-
-export type ScriptErrorContext = {
-  readonly type: ExecutableType.Script;
-  readonly self: ScriptData;
-  readonly parentCategory?: CategoryData;
-};
-
-export type UnknownExecutableErrorContext = {
-  readonly type?: undefined;
-  readonly self: ExecutableData;
-  readonly parentCategory?: CategoryData;
-};

src/application/Parser/Executable/Validation/ExecutableErrorContextMessage.ts

@@ -1,43 +0,0 @@
-import type { ExecutableData } from '@/application/collections/';
-import { ExecutableType } from './ExecutableType';
-import type { ExecutableErrorContext } from './ExecutableErrorContext';
-
-export interface ExecutableContextErrorMessageCreator {
-  (
-    errorMessage: string,
-    context: ExecutableErrorContext,
-  ): string;
-}
-
-export const createExecutableContextErrorMessage: ExecutableContextErrorMessageCreator = (
-  errorMessage,
-  context,
-) => {
-  let message = '';
-  if (context.type !== undefined) {
-    message += `${ExecutableType[context.type]}: `;
-  }
-  message += errorMessage;
-  message += `\n\n${getErrorContextDetails(context)}`;
-  return message;
-};
-
-function getErrorContextDetails(context: ExecutableErrorContext): string {
-  let output = `Executable: ${formatExecutable(context.self)}`;
-  if (context.parentCategory) {
-    output += `\n\nParent category: ${formatExecutable(context.parentCategory)}`;
-  }
-  return output;
-}
-
-function formatExecutable(executable: ExecutableData): string {
-  if (!executable) {
-    return 'Executable data is missing.';
-  }
-  const maxLength = 1000;
-  let output = JSON.stringify(executable, undefined, 2);
-  if (output.length > maxLength) {
-    output = `${output.substring(0, maxLength)}\n... [Rest of the executable trimmed]`;
-  }
-  return output;
-}

src/application/Parser/Executable/Validation/ExecutableType.ts

@@ -1,4 +0,0 @@
-export enum ExecutableType {
-  Script,
-  Category,
-}

src/application/Parser/Executable/Validation/ExecutableValidator.ts

@@ -1,69 +0,0 @@
-import { isString } from '@/TypeHelpers';
-import { createTypeValidator, type TypeValidator } from '../../Common/TypeValidator';
-import { type ExecutableErrorContext } from './ExecutableErrorContext';
-import { createExecutableContextErrorMessage, type ExecutableContextErrorMessageCreator } from './ExecutableErrorContextMessage';
-
-export interface ExecutableValidatorFactory {
-  (context: ExecutableErrorContext): ExecutableValidator;
-}
-
-type AssertTypeFunction = (validator: TypeValidator) => void;
-
-export interface ExecutableValidator {
-  assertValidName(nameValue: string): void;
-  assertType(assert: AssertTypeFunction): void;
-  assert(
-    validationPredicate: () => boolean,
-    errorMessage: string,
-  ): asserts validationPredicate is (() => true);
-  createContextualErrorMessage(errorMessage: string): string;
-}
-
-export const createExecutableDataValidator
-: ExecutableValidatorFactory = (context) => new ContextualExecutableValidator(context);
-
-export class ContextualExecutableValidator implements ExecutableValidator {
-  constructor(
-    private readonly context: ExecutableErrorContext,
-    private readonly createErrorMessage
-    : ExecutableContextErrorMessageCreator = createExecutableContextErrorMessage,
-    private readonly validator: TypeValidator = createTypeValidator(),
-  ) {
-
-  }
-
-  public assertValidName(nameValue: string): void {
-    this.assert(() => Boolean(nameValue), 'missing name');
-    this.assert(
-      () => isString(nameValue),
-      `Name (${JSON.stringify(nameValue)}) is not a string but ${typeof nameValue}.`,
-    );
-  }
-
-  public assertType(assert: AssertTypeFunction): void {
-    try {
-      assert(this.validator);
-    } catch (error) {
-      this.throw(error.message);
-    }
-  }
-
-  public assert(
-    validationPredicate: () => boolean,
-    errorMessage: string,
-  ): asserts validationPredicate is (() => true) {
-    if (!validationPredicate()) {
-      this.throw(errorMessage);
-    }
-  }
-
-  public createContextualErrorMessage(errorMessage: string): string {
-    return this.createErrorMessage(errorMessage, this.context);
-  }
-
-  private throw(errorMessage: string): never {
-    throw new Error(
-      this.createContextualErrorMessage(errorMessage),
-    );
-  }
-}

src/application/Parser/NodeValidation/NodeData.ts

@@ -0,0 +1,3 @@
+import type { ScriptData, CategoryData } from '@/application/collections/';
+
+export type NodeData = CategoryData | ScriptData;

src/application/Parser/NodeValidation/NodeDataErrorContext.ts

@@ -0,0 +1,25 @@
+import type { CategoryData, ScriptData } from '@/application/collections/';
+import { NodeDataType } from './NodeDataType';
+import type { NodeData } from './NodeData';
+
+export type NodeDataErrorContext = {
+  readonly parentNode?: CategoryData;
+} & (CategoryNodeErrorContext | ScriptNodeErrorContext | UnknownNodeErrorContext);
+
+export type CategoryNodeErrorContext = {
+  readonly type: NodeDataType.Category;
+  readonly selfNode: CategoryData;
+  readonly parentNode?: CategoryData;
+};
+
+export type ScriptNodeErrorContext = {
+  readonly type: NodeDataType.Script;
+  readonly selfNode: ScriptData;
+  readonly parentNode?: CategoryData;
+};
+
+export type UnknownNodeErrorContext = {
+  readonly type?: undefined;
+  readonly selfNode: NodeData;
+  readonly parentNode?: CategoryData;
+};

src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts

@@ -0,0 +1,35 @@
+import { NodeDataType } from './NodeDataType';
+import type { NodeDataErrorContext } from './NodeDataErrorContext';
+import type { NodeData } from './NodeData';
+
+export interface NodeContextErrorMessageCreator {
+  (
+    errorMessage: string,
+    context: NodeDataErrorContext,
+  ): string;
+}
+
+export const createNodeContextErrorMessage: NodeContextErrorMessageCreator = (
+  errorMessage,
+  context,
+) => {
+  let message = '';
+  if (context.type !== undefined) {
+    message += `${NodeDataType[context.type]}: `;
+  }
+  message += errorMessage;
+  message += `\n${getErrorContextDetails(context)}`;
+  return message;
+};
+
+function getErrorContextDetails(context: NodeDataErrorContext): string {
+  let output = `Self: ${printNodeDataAsJson(context.selfNode)}`;
+  if (context.parentNode) {
+    output += `\nParent: ${printNodeDataAsJson(context.parentNode)}`;
+  }
+  return output;
+}
+
+function printNodeDataAsJson(node: NodeData): string {
+  return JSON.stringify(node, undefined, 2);
+}

src/application/Parser/NodeValidation/NodeDataType.ts

@@ -0,0 +1,4 @@
+export enum NodeDataType {
+  Script,
+  Category,
+}

src/application/Parser/NodeValidation/NodeDataValidator.ts

@@ -0,0 +1,69 @@
+import { isString } from '@/TypeHelpers';
+import { type NodeDataErrorContext } from './NodeDataErrorContext';
+import { createNodeContextErrorMessage, type NodeContextErrorMessageCreator } from './NodeDataErrorContextMessage';
+import type { NodeData } from './NodeData';
+
+export interface NodeDataValidatorFactory {
+  (context: NodeDataErrorContext): NodeDataValidator;
+}
+
+export interface NodeDataValidator {
+  assertValidName(nameValue: string): void;
+  assertDefined(
+    node: NodeData | undefined,
+  ): asserts node is NonNullable<NodeData> & void;
+  assert(
+    validationPredicate: () => boolean,
+    errorMessage: string,
+  ): asserts validationPredicate is (() => true);
+  createContextualErrorMessage(errorMessage: string): string;
+}
+
+export const createNodeDataValidator
+: NodeDataValidatorFactory = (context) => new ContextualNodeDataValidator(context);
+
+export class ContextualNodeDataValidator implements NodeDataValidator {
+  constructor(
+    private readonly context: NodeDataErrorContext,
+    private readonly createErrorMessage
+    : NodeContextErrorMessageCreator = createNodeContextErrorMessage,
+  ) {
+
+  }
+
+  public assertValidName(nameValue: string): void {
+    this.assert(() => Boolean(nameValue), 'missing name');
+    this.assert(
+      () => isString(nameValue),
+      `Name (${JSON.stringify(nameValue)}) is not a string but ${typeof nameValue}.`,
+    );
+  }
+
+  public assertDefined(
+    node: NodeData,
+  ): asserts node is NonNullable<NodeData> {
+    this.assert(
+      () => node !== undefined && node !== null && Object.keys(node).length > 0,
+      'missing node data',
+    );
+  }
+
+  public assert(
+    validationPredicate: () => boolean,
+    errorMessage: string,
+  ): asserts validationPredicate is (() => true) {
+    if (!validationPredicate()) {
+      this.throw(errorMessage);
+    }
+  }
+
+  public createContextualErrorMessage(errorMessage: string): string {
+    return this.createErrorMessage(errorMessage, this.context);
+  }
+
+  private throw(errorMessage: string): never {
+    throw new Error(
+      this.createContextualErrorMessage(errorMessage),
+    );
+  }
+}

src/application/Parser/ProjectDetailsParser.ts

@@ -24,10 +24,6 @@ parseProjectDetails(
   );
 }
 
-export interface ProjectDetailsParser {
-  (): ProjectDetails;
-}
-
 export type ProjectDetailsFactory = (
   ...args: ConstructorArguments<typeof GitHubProjectDetails>
 ) => ProjectDetails;

src/application/Parser/Script/CategoryCollectionParseContext.ts

@@ -0,0 +1,23 @@
+import type { FunctionData } from '@/application/collections/';
+import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import { ScriptCompiler } from './Compiler/ScriptCompiler';
+import { SyntaxFactory } from './Validation/Syntax/SyntaxFactory';
+import type { ILanguageSyntax } from './Validation/Syntax/ILanguageSyntax';
+import type { IScriptCompiler } from './Compiler/IScriptCompiler';
+import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
+import type { ISyntaxFactory } from './Validation/Syntax/ISyntaxFactory';
+
+export class CategoryCollectionParseContext implements ICategoryCollectionParseContext {
+  public readonly compiler: IScriptCompiler;
+
+  public readonly syntax: ILanguageSyntax;
+
+  constructor(
+    functionsData: ReadonlyArray<FunctionData> | undefined,
+    scripting: IScriptingDefinition,
+    syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
+  ) {
+    this.syntax = syntaxFactory.create(scripting.language);
+    this.compiler = new ScriptCompiler(functionsData ?? [], this.syntax);
+  }
+}

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

@@ -1,4 +1,4 @@
-import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { FunctionCallArgumentCollection } from '../../Function/Call/Argument/FunctionCallArgumentCollection';
 import { ExpressionEvaluationContext, type IExpressionEvaluationContext } from './ExpressionEvaluationContext';
 import { ExpressionPosition } from './ExpressionPosition';

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

@@ -1,4 +1,4 @@
-import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 import { CompositeExpressionParser } from './Parser/CompositeExpressionParser';
 import type { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
 import type { IExpressionsCompiler } from './IExpressionsCompiler';

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

@@ -1,10 +1,10 @@
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
+import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { Expression, type ExpressionEvaluator } from '../../Expression/Expression';
 import { createPositionFromRegexFullMatch, type ExpressionPositionFactory } from '../../Expression/ExpressionPositionFactory';
 import { createFunctionParameterCollection, type FunctionParameterCollectionFactory } from '../../../Function/Parameter/FunctionParameterCollectionFactory';
 import type { IExpressionParser } from '../IExpressionParser';
 import type { IExpression } from '../../Expression/IExpression';
-import type { FunctionParameter } from '../../../Function/Parameter/FunctionParameter';
+import type { IFunctionParameter } from '../../../Function/Parameter/IFunctionParameter';
 import type { IFunctionParameterCollection, IReadOnlyFunctionParameterCollection } from '../../../Function/Parameter/IFunctionParameterCollection';
 
 export interface RegexParserUtilities {
@@ -110,7 +110,7 @@ function createParameters(
 
 export interface PrimitiveExpression {
   readonly evaluator: ExpressionEvaluator;
-  readonly parameters?: readonly FunctionParameter[];
+  readonly parameters?: readonly IFunctionParameter[];
 }
 
 export interface ExpressionFactory {

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

@@ -1,3 +1,4 @@
+import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
 import { RegexParser, type PrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 
@@ -15,10 +16,7 @@ export class ParameterSubstitutionParser extends RegexParser {
     const parameterName = match[1];
     const pipeline = match[2];
     return {
-      parameters: [{
-        name: parameterName,
-        isOptional: false,
-      }],
+      parameters: [new FunctionParameter(parameterName, false)],
       evaluator: (context) => {
         const { argumentValue } = context.args.getArgument(parameterName);
         if (!pipeline) {

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

@@ -1,6 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
-import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
-import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
 import { ExpressionPosition } from '../Expression/ExpressionPosition';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 import { createPositionFromRegexFullMatch } from '../Expression/ExpressionPositionFactory';
@@ -83,10 +84,7 @@ class WithStatementBuilder {
 
   public buildExpression(endExpressionPosition: ExpressionPosition, input: string): IExpression {
     const parameters = new FunctionParameterCollection();
-    parameters.addParameter({
-      name: this.parameterName,
-      isOptional: true,
-    });
+    parameters.addParameter(new FunctionParameter(this.parameterName, true));
     const position = new ExpressionPosition(
       this.startExpressionPosition.start,
       endExpressionPosition.end,

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

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

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

@@ -1,10 +1,10 @@
-import type { FunctionCallArgument } from './FunctionCallArgument';
+import type { IFunctionCallArgument } from './IFunctionCallArgument';
 import type { IFunctionCallArgumentCollection } from './IFunctionCallArgumentCollection';
 
 export class FunctionCallArgumentCollection implements IFunctionCallArgumentCollection {
-  private readonly arguments = new Map<string, FunctionCallArgument>();
+  private readonly arguments = new Map<string, IFunctionCallArgument>();
 
-  public addArgument(argument: FunctionCallArgument): void {
+  public addArgument(argument: IFunctionCallArgument): void {
     if (this.hasArgument(argument.parameterName)) {
       throw new Error(`argument value for parameter ${argument.parameterName} is already provided`);
     }
@@ -22,7 +22,7 @@ export class FunctionCallArgumentCollection implements IFunctionCallArgumentColl
     return this.arguments.has(parameterName);
   }
 
-  public getArgument(parameterName: string): FunctionCallArgument {
+  public getArgument(parameterName: string): IFunctionCallArgument {
     if (!parameterName) {
       throw new Error('missing parameter name');
     }

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
 import type { FunctionCall } from '../FunctionCall';
 import type { SingleCallCompiler } from './SingleCall/SingleCallCompiler';
 

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

@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
 import type { CompiledCode } from './CompiledCode';
 import type { FunctionCall } from '../FunctionCall';
 

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

@@ -1,4 +1,4 @@
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import { NewlineCodeSegmentMerger } from './CodeSegmentJoin/NewlineCodeSegmentMerger';
 import { AdaptiveFunctionCallCompiler } from './SingleCall/AdaptiveFunctionCallCompiler';
 import type { ISharedFunctionCollection } from '../../ISharedFunctionCollection';

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts

@@ -1,5 +1,5 @@
-import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import type { CompiledCode } from '../CompiledCode';
 import type { FunctionCallCompilationContext } from '../FunctionCallCompilationContext';
 

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts

@@ -1,5 +1,5 @@
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 
 export interface ArgumentCompiler {
   createCompiledNestedCall(

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts

@@ -1,16 +1,20 @@
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
-import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import { ParsedFunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
-import { createFunctionCallArgument, type FunctionCallArgument, type FunctionCallArgumentFactory } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import { ParsedFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall';
+import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import type { ArgumentCompiler } from './ArgumentCompiler';
 
 export class NestedFunctionArgumentCompiler implements ArgumentCompiler {
-  constructor(private readonly utilities: ArgumentCompilationUtilities = DefaultUtilities) { }
+  constructor(
+    private readonly expressionsCompiler: IExpressionsCompiler = new ExpressionsCompiler(),
+    private readonly wrapError: ErrorWithContextWrapper
+    = wrapErrorWithAdditionalContext,
+  ) { }
 
   public createCompiledNestedCall(
     nestedFunction: FunctionCall,
@@ -21,7 +25,10 @@ export class NestedFunctionArgumentCompiler implements ArgumentCompiler {
       nestedFunction,
       parentFunction.args,
       context,
-      this.utilities,
+      {
+        expressionsCompiler: this.expressionsCompiler,
+        wrapError: this.wrapError,
+      },
     );
     const compiledCall = new ParsedFunctionCall(nestedFunction.functionName, compiledArgs);
     return compiledCall;
@@ -31,7 +38,6 @@ export class NestedFunctionArgumentCompiler implements ArgumentCompiler {
 interface ArgumentCompilationUtilities {
   readonly expressionsCompiler: IExpressionsCompiler,
   readonly wrapError: ErrorWithContextWrapper;
-  readonly createCallArgument: FunctionCallArgumentFactory;
 }
 
 function compileNestedFunctionArguments(
@@ -72,7 +78,7 @@ function compileNestedFunctionArguments(
     .map(({
       parameterName,
       compiledArgumentValue,
-    }) => utilities.createCallArgument(parameterName, compiledArgumentValue));
+    }) => new FunctionCallArgument(parameterName, compiledArgumentValue));
   return buildArgumentCollectionFromArguments(compiledArguments);
 }
 
@@ -112,9 +118,3 @@ function buildArgumentCollectionFromArguments(
     return compiledArgs;
   }, new FunctionCallArgumentCollection());
 }
-
-const DefaultUtilities: ArgumentCompilationUtilities = {
-  expressionsCompiler: new ExpressionsCompiler(),
-  wrapError: wrapErrorWithAdditionalContext,
-  createCallArgument: createFunctionCallArgument,
-};

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts

@@ -1,8 +1,8 @@
-import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
-import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
-import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
 
 export class InlineFunctionCallCompiler implements SingleCallCompilerStrategy {

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts

@@ -1,11 +1,11 @@
 import {
   type CallFunctionBody, FunctionBodyType,
   type ISharedFunction,
-} from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/Common/ContextualError';
+} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { NestedFunctionArgumentCompiler } from './Argument/NestedFunctionArgumentCompiler';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
 import type { ArgumentCompiler } from './Argument/ArgumentCompiler';

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

@@ -0,0 +1,39 @@
+import type { FunctionCallData, FunctionCallsData, FunctionCallParametersData } from '@/application/collections/';
+import { isArray, isPlainObject } from '@/TypeHelpers';
+import { FunctionCallArgumentCollection } from './Argument/FunctionCallArgumentCollection';
+import { FunctionCallArgument } from './Argument/FunctionCallArgument';
+import { ParsedFunctionCall } from './ParsedFunctionCall';
+import type { FunctionCall } from './FunctionCall';
+
+export function parseFunctionCalls(calls: FunctionCallsData): FunctionCall[] {
+  const sequence = getCallSequence(calls);
+  return sequence.map((call) => parseFunctionCall(call));
+}
+
+function getCallSequence(calls: FunctionCallsData): FunctionCallData[] {
+  if (!isPlainObject(calls) && !isArray(calls)) {
+    throw new Error('called function(s) must be an object or array');
+  }
+  if (isArray(calls)) {
+    return calls as FunctionCallData[];
+  }
+  const singleCall = calls as FunctionCallData;
+  return [singleCall];
+}
+
+function parseFunctionCall(call: FunctionCallData): FunctionCall {
+  const callArgs = parseArgs(call.parameters);
+  return new ParsedFunctionCall(call.function, callArgs);
+}
+
+function parseArgs(
+  parameters: FunctionCallParametersData | undefined,
+): FunctionCallArgumentCollection {
+  const parametersMap = parameters ?? {};
+  return Object.keys(parametersMap)
+    .map((parameterName) => new FunctionCallArgument(parameterName, parametersMap[parameterName]))
+    .reduce((args, arg) => {
+      args.addArgument(arg);
+      return args;
+    }, new FunctionCallArgumentCollection());
+}

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

@@ -0,0 +1,10 @@
+import type { FunctionData } from '@/application/collections/';
+import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ISharedFunctionCollection } from './ISharedFunctionCollection';
+
+export interface ISharedFunctionsParser {
+  parseFunctions(
+    functions: readonly FunctionData[],
+    syntax: ILanguageSyntax,
+  ): ISharedFunctionCollection;
+}

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

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

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

@@ -1,14 +1,14 @@
 import type { IFunctionParameterCollection } from './IFunctionParameterCollection';
-import type { FunctionParameter } from './FunctionParameter';
+import type { IFunctionParameter } from './IFunctionParameter';
 
 export class FunctionParameterCollection implements IFunctionParameterCollection {
-  private parameters = new Array<FunctionParameter>();
+  private parameters = new Array<IFunctionParameter>();
 
-  public get all(): readonly FunctionParameter[] {
+  public get all(): readonly IFunctionParameter[] {
     return this.parameters;
   }
 
-  public addParameter(parameter: FunctionParameter) {
+  public addParameter(parameter: IFunctionParameter) {
     this.ensureValidParameter(parameter);
     this.parameters.push(parameter);
   }
@@ -17,7 +17,7 @@ export class FunctionParameterCollection implements IFunctionParameterCollection
     return this.parameters.find((existingParameter) => existingParameter.name === name);
   }
 
-  private ensureValidParameter(parameter: FunctionParameter) {
+  private ensureValidParameter(parameter: IFunctionParameter) {
     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 FunctionParameter {
+export interface IFunctionParameter {
   readonly name: string;
   readonly isOptional: boolean;
 }

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

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

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

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