replace deprecated github ::set-env command

move Microsoft.Appconnector to right category
fix errors when file already exists
2020-11-16 19:37:28 +01:00 · 2020-11-16 18:38:00 +01:00 · 2020-11-14 19:55:37 +01:00 · 2020-11-14 19:55:37 +01:00 · 2020-11-14 19:51:21 +01:00 · 2020-11-11 16:18:35 +01:00
52 changed files with 3533 additions and 1225 deletions
--- a/.github/workflows/deploy-site.yaml
+++ b/.github/workflows/deploy-site.yaml
@@ -23,7 +23,7 @@ jobs:
            --secret-access-key ${{secrets.AWS_DEPLOYMENT_USER_SECRET_ACCESS_KEY}} \
            --region us-east-1 \
          && \
-            echo "::set-env name=SESSION_NAME::${{github.actor}}-${{github.event_name}}-$(echo ${{github.sha}} | cut -c1-8)"
+            echo "SESSION_NAME=${{github.actor}}-${{github.event_name}}-$(echo ${{github.sha}} | cut -c1-8)" >> $GITHUB_ENV
        working-directory: aws
      -
        name: "Infrastructure: Deploy IAM stack"
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 node_modules
-/dist
+dist/
 .vs
 .vscode
 #Electron-builder output
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,34 @@
 # Changelog

+## 0.8.0 (2020-11-01)
+
+* add support for different recommendation levels: strict and standard | [commit](https://github.com/undergroundwires/privacy.sexy/commit/14be3017c55ed5e0d9bdecb63fcc4e1131e79ab0)
+* Add GroupMe and Spotify removal option (#34) | [commit](https://github.com/undergroundwires/privacy.sexy/commit/3785c623f837b182d82fa383dfe7709722a67248)
+* switch places of download and copy buttons | [commit](https://github.com/undergroundwires/privacy.sexy/commit/50fb29038ae19b17ec006093db02cf1e568d53c3)
+* change "download" button to "save" on desktop | [commit](https://github.com/undergroundwires/privacy.sexy/commit/07fc555324d8bf4fa3594a9701daaa124a873153)
+* show icons on cards during indeterminate and fully selected states | [commit](https://github.com/undergroundwires/privacy.sexy/commit/1072505219edc47d82a91f148d1f310f32869fea)
+* add scripts to increase cryptography, enable camera notifications and remove todo app (#36) | [commit](https://github.com/undergroundwires/privacy.sexy/commit/4c68408f1ec339dc8d39c7ab044f825a7f7185cb)
+* update recommendations to be safer and consistent | [commit](https://github.com/undergroundwires/privacy.sexy/commit/d0019c2c9b1eea620e2e8e02b586903ce62b80e3)
+* rework disabling metadata retrieval | [commit](https://github.com/undergroundwires/privacy.sexy/commit/ac70b063b8a15bc528256185792939685be6b36f)
+* add all dist folders in gitignore because of files auto-generated by vscode | [commit](https://github.com/undergroundwires/privacy.sexy/commit/1a9db31c7778c3269a71c0bd9665827efda70a02)
+* add support for shared functions #41 | [commit](https://github.com/undergroundwires/privacy.sexy/commit/8ce06facbd54184402a4b1af3c7303e64db85b8a)
+* hide scrollbars on code area when not overflowing | [commit](https://github.com/undergroundwires/privacy.sexy/commit/fd28eaad061c75ea1aa7e0f0d60ea37a7e52f8c4)
+* update screenshot | [commit](https://github.com/undergroundwires/privacy.sexy/commit/cfedcd724cad7708b30c7390a7bca3b6313b6726)
+
+[compare](https://github.com/undergroundwires/privacy.sexy/compare/0.7.6...0.8.0)
+
+## 0.7.6 (2020-10-18)
+
+* add docs for default0 pointing to github discussion (#30) | [commit](https://github.com/undergroundwires/privacy.sexy/commit/a3fc3782efd346b4c99d2a0b40df2eb0229f5b36)
+* add robots.txt to explicitly allow indexing | [commit](https://github.com/undergroundwires/privacy.sexy/commit/4c2f74949b0758d33049bdfa4f0124a28958f8ea)
+* add more reversibility | [commit](https://github.com/undergroundwires/privacy.sexy/commit/19a092dd31fb3588277f1ab3120b409d98506752)
+* refactor to read more from package.json | [commit](https://github.com/undergroundwires/privacy.sexy/commit/784a67afff681bc19147d03c947de0e165d97e87)
+* simplify "why" section | [commit](https://github.com/undergroundwires/privacy.sexy/commit/77c3d2bbb8d13db86bb82ed0b5cbeaacfdea3db9)
+* update dependencies to latest | [commit](https://github.com/undergroundwires/privacy.sexy/commit/11e06131655398db08faeeacff62062e46e0dddd)
+* run tests on all operating systems: macos, ubuntu, windows | [commit](https://github.com/undergroundwires/privacy.sexy/commit/d9d7f62d81d4d8f95104d33211e82641884d711f)
+
+[compare](https://github.com/undergroundwires/privacy.sexy/compare/0.7.5...0.7.6)
+
 ## 0.7.5 (2020-09-14)

 * fix reverting (reinstalling) capabilities not working | [commit](https://github.com/undergroundwires/privacy.sexy/commit/939d838e3535bb1c9b00c8ea9dacb735ae41d700)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -25,12 +25,6 @@

 ## Guidelines

-### Extend scripts
-
- Create a [pull request](#Pull-Request-Process) for [application.yaml](./src/application/application.yaml)
- 🙏 For any new script, try to add `revertCode` that'll revert the changes caused by the script.
- See [typings](./src/application/application.yaml.d.ts) for documentation as code.
-
 ### Handle the state in presentation layer

 - There are two types of components:
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@
 ## Get started

 - Online version: [https://privacy.sexy](https://privacy.sexy)
-  - or download latest desktop version for [Windows](https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.5/privacy.sexy-Setup-0.7.5.exe), [Linux](https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.5/privacy.sexy-0.7.5.AppImage), [macOS](https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.5/privacy.sexy-0.7.5.dmg)
+  - or download latest desktop version for [Windows](https://github.com/undergroundwires/privacy.sexy/releases/download/0.8.0/privacy.sexy-Setup-0.8.0.exe), [Linux](https://github.com/undergroundwires/privacy.sexy/releases/download/0.8.0/privacy.sexy-0.8.0.AppImage), [macOS](https://github.com/undergroundwires/privacy.sexy/releases/download/0.8.0/privacy.sexy-0.8.0.dmg)
 - 💡 Come back regularly to apply latest version for stronger privacy and security.

 [![privacy.sexy application](img/screenshot.png)](https://privacy.sexy)
@@ -27,13 +27,14 @@
 - No need to run any compiled software that has access to your system, just run the generated scripts
 - Have full visibility into what the tweaks do as you enable them
 - Ability to revert (undo) applied scripts
+- Everything is transparent: both application and its infrastructure are open-source and automated
 - Easily extendable
- Everything is open-source and automated (both application and its infrastructure)

 ## Extend scripts

 - Fork it & add more scripts in [application.yaml](src/application/application.yaml) and send a pull request 👌
- 📖 More: [extend scripts | CONTRIBUTING.md](./CONTRIBUTING.md#extend-scripts)
+- 📖 If you're unsure about the syntax you can refer to the [application file | documentation](docs/application-file.md).
+- 🙏 For any new script, please add `revertCode` and `docs` values if possible.

 ## Commands

@@ -48,8 +49,8 @@
  - Development: `npm run serve` to compile & hot-reload for development.
  - Production: `npm run build` to prepare files for distribution.
  - Or run using Docker:
-    1. Build: `docker build -t undergroundwires/privacy.sexy:0.7.5 .`
-    2. Run: `docker run -it -p 8080:80 --rm --name privacy.sexy-0.7.5 undergroundwires/privacy.sexy:0.7.5`
+    1. Build: `docker build -t undergroundwires/privacy.sexy:0.8.0 .`
+    2. Run: `docker run -it -p 8080:80 --rm --name privacy.sexy-0.8.0 undergroundwires/privacy.sexy:0.8.0`

 ## Architecture

--- a/docs/application-file.md
+++ b/docs/application-file.md
@@ -0,0 +1,139 @@
+# Application file
+
+- privacy.sexy is a data-driven application where it reads the necessary OS-specific logic from [`application.yaml`](./../src/application/application.yaml)
+- 💡 Best practices
+  - If you repeat yourself, try to utilize [YAML-defined functions](#function)
+  - Always try to add documentation and a way to revert a tweak in [scripts](#script)
+- 📖 Types in code: [`application.d.ts`](./../src/application/application.yaml.d.ts)
+
+## Objects
+
+### `Application`
+
+- Application file simply defines different categories and their scripts in a tree structure.
+- Application file also allows defining common [function](#function)s to be used throughout the application if you'd like different scripts to share same code.
+
+#### `Application` syntax
+
+- `actions: [` ***[`Category`](#Category)*** `, ... ]` **(required)**
+  - Each [category](#category) is rendered as different cards in card presentation.
+  - ❗ Application must consist of at least one category.
+- `functions: [` ***[`Function`](#Function)*** `, ... ]`
+  - Functions are optionally defined to re-use the same code throughout different scripts.
+
+### `Category`
+
+- Category has a parent that has tree-like structure where it can have subcategories or subscripts.
+- It's a logical grouping of different scripts and other categories.
+
+#### `Category` syntax
+
+- `category:` *`string`*  (**required**)
+  - Name of the category
+  - ❗ Must be unique throughout the application
+- `children: [` ***[`Category`](#category)*** `|` [***`Script`***](#Script) `, ... ]`  (**required**)
+  - ❗ Category must consist of at least one subcategory or script.
+  - Children can be combination of scripts and subcategories.
+
+### `Script`
+
+- Script represents a single tweak.
+- A script must include either:
+  - A `code` and `revertCode`
+  - Or `call` to call YAML-defined functions
+- 🙏 For any new script, please add `revertCode` and `docs` values if possible.
+
+#### `Script` syntax
+
+- `name`: *`string`* (**required**)
+  - Name of the script
+  - ❗ Must be unique throughout the application
+  - E.g. `Disable targeted ads`
+- `code`: *`string`* (may be **required**)
+  - Batch file commands that will be executed
+  - 💡 If defined, best practice to also define `revertCode`
+  - ❗ If not defined `call` must be defined, do not define if `call` is defined.
+- `revertCode`: `string`
+  - Code that'll undo the change done by `code` property.
+  - E.g. let's say `code` sets an environment variable as `setx POWERSHELL_TELEMETRY_OPTOUT 1`
+    - then `revertCode` should be doing `setx POWERSHELL_TELEMETRY_OPTOUT 0`
+  - ❗ Do not define if `call` is defined.
+- `call`: ***[`FunctionCall`](#FunctionCall)*** | `[` ***[`FunctionCall`](#FunctionCall)*** `, ... ]` (may be **required**)
+  - A shared function or sequence of functions to call (called in order)
+  - ❗ If not defined `code` must be defined
+- `docs`: *`string`* | `[`*`string`*`, ... ]`
+  - Single documentation URL or list of URLs for those who wants to learn more about the script
+  - E.g. `https://docs.microsoft.com/en-us/windows-server/`
+- `recommend`: `"standard"` | `"strict"` | `undefined` (default)
+  - If not defined then the script will not be recommended
+  - If defined it can be either
+    - `standard`: Only non-breaking scripts without limiting OS functionality
+    - `strict`: Scripts that can break certain functionality in favor of privacy and security
+
+### `FunctionCall`
+
+- Describes a single call to a function by optionally providing values to its parameters.
+- 👀 See [parameter substitution](#parameter-substitution) for an example usage
+
+#### `FunctionCall` syntax
+
+- `function`: *`string`* (**required**)
+  - Name of the function to call.
+  - ❗ Function with same name must defined in `functions` property of [Application](#application)
+- `parameters`: `[ parameterName:` *`parameterValue`*`, ... ]`
+  - Defines key value dictionary for each parameter and its value
+  - E.g.
+
+    ```yaml
+      parameters:
+        userDefinedParameterName: parameterValue
+        # ...
+        appName: Microsoft.WindowsFeedbackHub
+    ```
+
+### `Function`
+
+- Functions allow re-usable code throughout the defined scripts.
+- Functions are templates compiled by privacy.sexy and uses special expressions.
+- Expressions are defined inside mustaches (double brackets, `{{` and `}}`)
+- 👀 See [parameter substitution](#parameter-substitution) for an example usage
+
+#### Parameter substitution
+
+A simple function example
+
+```yaml
+  function: EchoArgument
+  parameters: [ 'argument' ]
+  code: Hello {{ $argument }} !
+```
+
+It would print "Hello world" if it's called in a [script](#script) as following:
+
+```yaml
+  script: Echo script
+  call:
+    function: EchoArgument
+    parameters:
+      argument: World
+```
+
+#### `Function` syntax
+
+- `name`: *`string`* (**required**)
+  - Name of the function that scripts will use.
+  - Convention is to use camelCase, and be verbs.
+  - E.g. `uninstallStoreApp`
+  - ❗ Function names must be unique
+- `parameters`: `[` *`string`* `, ... ]`
+  - Name of the parameters that the function has.
+  - Parameter values are provided by a [Script](#script) through a [FunctionCall](#functioncall)
+  - Parameter names must be defined to be used in expressions such as [parameter substitution](#parameter-substitution)
+  - ❗ Parameter names must be unique
+ `code`: *`string`* (**required**)
+  - Batch file commands that will be executed
+  - 💡 If defined, best practice to also define `revertCode`
+- `revertCode`: *`string`*
+  - Code that'll undo the change done by `code` property.
+  - E.g. let's say `code` sets an environment variable as `setx POWERSHELL_TELEMETRY_OPTOUT 1`
+    - then `revertCode` should be doing `setx POWERSHELL_TELEMETRY_OPTOUT 0`
--- a/img/screenshot.png
+++ b/img/screenshot.png
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "privacy.sexy",
-  "version": "0.7.5",
+  "version": "0.8.0",
  "author": "undergroundwires",
  "description": "Enforce privacy & security best-practices on Windows, because privacy is sexy 🍑🍆",
  "homepage": "https://privacy.sexy",
--- a/src/application/Parser/ApplicationParser.ts
+++ b/src/application/Parser/ApplicationParser.ts
@@ -4,14 +4,16 @@ import { IApplication } from '@/domain/IApplication';
 import { IProjectInformation } from '@/domain/IProjectInformation';
 import { ApplicationYaml } from 'js-yaml-loader!./../application.yaml';
 import { parseCategory } from './CategoryParser';
-import { ProjectInformation } from '../../domain/ProjectInformation';
+import { ProjectInformation } from '@/domain/ProjectInformation';
+import { ScriptCompiler } from './Compiler/ScriptCompiler';


 export function parseApplication(content: ApplicationYaml, env: NodeJS.ProcessEnv = process.env): IApplication {
    validate(content);
+    const compiler = new ScriptCompiler(content.functions);
    const categories = new Array<Category>();
    for (const action of content.actions) {
-        const category = parseCategory(action);
+        const category = parseCategory(action, compiler);
        categories.push(category);
    }
    const info = readAppInformation(env);
@@ -21,7 +23,7 @@ export function parseApplication(content: ApplicationYaml, env: NodeJS.ProcessEn
    return app;
 }

-function readAppInformation(environment): IProjectInformation {
+function readAppInformation(environment: NodeJS.ProcessEnv): IProjectInformation {
    return new ProjectInformation(
        environment.VUE_APP_NAME,
        environment.VUE_APP_VERSION,
--- a/src/application/Parser/CategoryParser.ts
+++ b/src/application/Parser/CategoryParser.ts
@@ -3,6 +3,7 @@ import { Script } from '@/domain/Script';
 import { Category } from '@/domain/Category';
 import { parseDocUrls } from './DocumentationParser';
 import { parseScript } from './ScriptParser';
+import { IScriptCompiler } from './Compiler/IScriptCompiler';

 let categoryIdCounter: number = 0;

@@ -11,14 +12,17 @@ interface ICategoryChildren {
    subScripts: Script[];
 }

-export function parseCategory(category: YamlCategory): Category {
+export function parseCategory(category: YamlCategory, compiler: IScriptCompiler): Category {
+    if (!compiler) {
+        throw new Error('undefined compiler');
+    }
    ensureValid(category);
    const children: ICategoryChildren = {
        subCategories: new Array<Category>(),
        subScripts: new Array<Script>(),
    };
    for (const categoryOrScript of category.children) {
-        parseCategoryChild(categoryOrScript, children, category);
+        parseCategoryChild(categoryOrScript, children, category, compiler);
    }
    return new Category(
        /*id*/ categoryIdCounter++,
@@ -42,13 +46,16 @@ function ensureValid(category: YamlCategory) {
 }

 function parseCategoryChild(
-    categoryOrScript: any, children: ICategoryChildren, parent: YamlCategory) {
+    categoryOrScript: any,
+    children: ICategoryChildren,
+    parent: YamlCategory,
+    compiler: IScriptCompiler) {
    if (isCategory(categoryOrScript)) {
-        const subCategory = parseCategory(categoryOrScript as YamlCategory);
+        const subCategory = parseCategory(categoryOrScript as YamlCategory, compiler);
        children.subCategories.push(subCategory);
    } else if (isScript(categoryOrScript)) {
        const yamlScript = categoryOrScript as YamlScript;
-        const script = parseScript(yamlScript);
+        const script = parseScript(yamlScript, compiler);
        children.subScripts.push(script);
    } else {
        throw new Error(`Child element is neither a category or a script.
@@ -57,7 +64,8 @@ function parseCategoryChild(
 }

 function isScript(categoryOrScript: any): boolean {
-    return categoryOrScript.code && categoryOrScript.code.length > 0;
+    return (categoryOrScript.code && categoryOrScript.code.length > 0)
+        || categoryOrScript.call;
 }

 function isCategory(categoryOrScript: any): boolean {
--- a/src/application/Parser/Compiler/IScriptCompiler.ts
+++ b/src/application/Parser/Compiler/IScriptCompiler.ts
@@ -0,0 +1,7 @@
+import { IScriptCode } from '@/domain/IScriptCode';
+import { YamlScript } from 'js-yaml-loader!./application.yaml';
+
+export interface IScriptCompiler {
+    canCompile(script: YamlScript): boolean;
+    compile(script: YamlScript): IScriptCode;
+}
--- a/src/application/Parser/Compiler/ScriptCompiler.ts
+++ b/src/application/Parser/Compiler/ScriptCompiler.ts
@@ -0,0 +1,200 @@
+import { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode } from '@/domain/ScriptCode';
+import { YamlScript, YamlFunction, FunctionCall, ScriptFunctionCall, FunctionCallParameters } from 'js-yaml-loader!./application.yaml';
+import { IScriptCompiler } from './IScriptCompiler';
+
+interface ICompiledCode {
+    readonly code: string;
+    readonly revertCode: string;
+}
+
+export class ScriptCompiler implements IScriptCompiler {
+    constructor(private readonly functions: readonly YamlFunction[]) {
+        ensureValidFunctions(functions);
+    }
+    public canCompile(script: YamlScript): boolean {
+        if (!script.call) {
+            return false;
+        }
+        return true;
+    }
+    public compile(script: YamlScript): IScriptCode {
+        this.ensureCompilable(script.call);
+        const compiledCodes = new Array<ICompiledCode>();
+        const calls = getCallSequence(script.call);
+        calls.forEach((currentCall, currentCallIndex) => {
+            ensureValidCall(currentCall, script.name);
+            const commonFunction = this.getFunctionByName(currentCall.function);
+            let functionCode = compileCode(commonFunction, currentCall.parameters);
+            if (currentCallIndex !== calls.length - 1) {
+                functionCode = appendLine(functionCode);
+            }
+            compiledCodes.push(functionCode);
+        });
+        const scriptCode = merge(compiledCodes);
+        return new ScriptCode(script.name, scriptCode.code, scriptCode.revertCode);
+    }
+
+    private getFunctionByName(name: string): YamlFunction {
+        const func = this.functions.find((f) => f.name === name);
+        if (!func) {
+            throw new Error(`called function is not defined "${name}"`);
+        }
+        return func;
+    }
+
+    private ensureCompilable(call: ScriptFunctionCall) {
+        if (!this.functions || this.functions.length === 0) {
+            throw new Error('cannot compile without shared functions');
+        }
+        if (typeof call !== 'object') {
+            throw new Error('called function(s) must be an object');
+        }
+    }
+}
+
+function getDuplicates(texts: readonly string[]): string[] {
+    return texts.filter((item, index) => texts.indexOf(item) !== index);
+}
+
+function printList(list: readonly string[]): string {
+    return `"${list.join('","')}"`;
+}
+
+function ensureNoDuplicatesInFunctionNames(functions: readonly YamlFunction[]) {
+    const duplicateFunctionNames = getDuplicates(functions
+        .map((func) => func.name.toLowerCase()));
+    if (duplicateFunctionNames.length) {
+        throw new Error(`duplicate function name: ${printList(duplicateFunctionNames)}`);
+    }
+}
+
+function ensureNoDuplicatesInParameterNames(functions: readonly YamlFunction[]) {
+    const functionsWithParameters = functions
+        .filter((func) => func.parameters && func.parameters.length > 0);
+    for (const func of functionsWithParameters) {
+        const duplicateParameterNames = getDuplicates(func.parameters);
+        if (duplicateParameterNames.length) {
+            throw new Error(`"${func.name}": duplicate parameter name: ${printList(duplicateParameterNames)}`);
+        }
+    }
+}
+
+function ensureNoDuplicateCode(functions: readonly YamlFunction[]) {
+    const duplicateCodes = getDuplicates(functions.map((func) => func.code));
+    if (duplicateCodes.length > 0) {
+        throw new Error(`duplicate "code" in functions: ${printList(duplicateCodes)}`);
+    }
+    const duplicateRevertCodes = getDuplicates(functions
+        .filter((func) => func.revertCode)
+        .map((func) => func.revertCode));
+    if (duplicateRevertCodes.length > 0) {
+        throw new Error(`duplicate "revertCode" in functions: ${printList(duplicateRevertCodes)}`);
+    }
+}
+
+function ensureValidFunctions(functions: readonly YamlFunction[]) {
+    if (!functions) {
+        return;
+    }
+    ensureNoDuplicatesInFunctionNames(functions);
+    ensureNoDuplicatesInParameterNames(functions);
+    ensureNoDuplicateCode(functions);
+}
+
+function appendLine(code: ICompiledCode): ICompiledCode {
+    const appendLineIfNotEmpty = (str: string) => str ? `${str}\n` : str;
+    return {
+        code: appendLineIfNotEmpty(code.code),
+        revertCode: appendLineIfNotEmpty(code.revertCode),
+    };
+}
+
+function merge(codes: readonly ICompiledCode[]): ICompiledCode {
+    return {
+        code: codes.map((code) => code.code).join(''),
+        revertCode: codes.map((code) => code.revertCode).join(''),
+    };
+}
+
+function compileCode(func: YamlFunction, parameters: FunctionCallParameters): ICompiledCode {
+    return {
+        code: compileExpressions(func.code, parameters),
+        revertCode: compileExpressions(func.revertCode, parameters),
+    };
+}
+
+function compileExpressions(code: string, parameters: FunctionCallParameters): string {
+    let intermediateCode = compileToIL(code);
+    intermediateCode = substituteParameters(intermediateCode, parameters);
+    ensureNoExpressionLeft(intermediateCode);
+    return intermediateCode;
+}
+
+function substituteParameters(intermediateCode: string, parameters: FunctionCallParameters): string {
+    const parameterNames = getUniqueParameterNamesFromIL(intermediateCode);
+    if (parameterNames.length && !parameters) {
+        throw new Error(`no parameters defined, expected: ${printList(parameterNames)}`);
+    }
+    for (const parameterName of parameterNames) {
+        const parameterValue = parameters[parameterName];
+        intermediateCode = substituteParameter(intermediateCode, parameterName, parameterValue);
+    }
+    return intermediateCode;
+}
+
+function ensureValidCall(call: FunctionCall, scriptName: string) {
+    if (!call) {
+        throw new Error(`undefined function call in script "${scriptName}"`);
+    }
+    if (!call.function) {
+        throw new Error(`empty function name called in script "${scriptName}"`);
+    }
+}
+
+function getCallSequence(call: ScriptFunctionCall): FunctionCall[] {
+    if (call instanceof Array) {
+        return call as FunctionCall[];
+    }
+    return [ call as FunctionCall ];
+}
+
+function getDistinctValues(values: readonly string[]): string[] {
+    return values.filter((value, index, self) => {
+        return self.indexOf(value) === index;
+      });
+}
+
+// Trim each expression and put them inside "{{exp|}}" e.g. "{{ $hello }}" becomes "{{exp|$hello}}"
+function compileToIL(code: string) {
+    return code.replace(/\{\{([\s]*[^;\s\{]+[\s]*)\}\}/g, (_, match) => {
+        return `\{\{exp|${match.trim()}\}\}`;
+    });
+}
+
+// Parses all distinct usages of {{exp|$parameterName}}
+function getUniqueParameterNamesFromIL(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|\$([^;\s\{]+[\s]*)\}\}/g);
+    const allParameters = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueParameterNames = getDistinctValues(allParameters);
+    return uniqueParameterNames;
+}
+
+// substitutes {{exp|$parameterName}} to value of the parameter
+function substituteParameter(ilCode: string, parameterName: string, parameterValue: string) {
+    if (!parameterValue) {
+        throw Error(`parameter value is not provided for "${parameterName}" in function call`);
+    }
+    const pattern = `{{exp|$${parameterName}}}`;
+    return ilCode.split(pattern).join(parameterValue); // as .replaceAll() is not yet supported by TS
+}
+
+// finds all "{{exp|..}} left"
+function ensureNoExpressionLeft(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|(.*?)\}\}/g);
+    const allMatches = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueExpressions = getDistinctValues(allMatches);
+    if (uniqueExpressions.length > 0) {
+        throw new Error(`unknown expression: ${printList(uniqueExpressions)}`);
+    }
+}
--- a/src/application/Parser/ScriptParser.ts
+++ b/src/application/Parser/ScriptParser.ts
@@ -1,16 +1,61 @@
 import { Script } from '@/domain/Script';
 import { YamlScript } from 'js-yaml-loader!./application.yaml';
 import { parseDocUrls } from './DocumentationParser';
+import { RecommendationLevelNames, RecommendationLevel } from '@/domain/RecommendationLevel';
+import { IScriptCompiler } from './Compiler/IScriptCompiler';
+import { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode } from '@/domain/ScriptCode';

-export function parseScript(yamlScript: YamlScript): Script {
-    if (!yamlScript) {
-        throw new Error('script is null or undefined');
+export function parseScript(yamlScript: YamlScript, compiler: IScriptCompiler): Script {
+    validateScript(yamlScript);
+    if (!compiler) {
+        throw new Error('undefined compiler');
    }
    const script = new Script(
        /* name */              yamlScript.name,
-        /* code */              yamlScript.code,
-        /* revertCode */        yamlScript.revertCode,
+        /* code */              parseCode(yamlScript, compiler),
        /* docs */              parseDocUrls(yamlScript),
-        /* isRecommended */     yamlScript.recommend);
+        /* level */             getLevel(yamlScript.recommend));
    return script;
 }
+
+function getLevel(level: string): RecommendationLevel | undefined {
+    if (!level) {
+        return undefined;
+    }
+    if (typeof level !== 'string') {
+        throw new Error(`level must be a string but it was ${typeof level}`);
+    }
+    const typedLevel = RecommendationLevelNames
+        .find((l) => l.toLowerCase() === level.toLowerCase());
+    if (!typedLevel) {
+        throw new Error(`unknown level: \"${level}\"`);
+    }
+    return RecommendationLevel[typedLevel as keyof typeof RecommendationLevel];
+}
+
+function parseCode(yamlScript: YamlScript, compiler: IScriptCompiler): IScriptCode {
+    if (compiler.canCompile(yamlScript)) {
+        return compiler.compile(yamlScript);
+    }
+    return new ScriptCode(yamlScript.name, yamlScript.code, yamlScript.revertCode);
+}
+
+function ensureNotBothCallAndCode(yamlScript: YamlScript) {
+    if (yamlScript.code && yamlScript.call) {
+        throw new Error('cannot define both "call" and "code"');
+    }
+    if (yamlScript.revertCode && yamlScript.call) {
+        throw new Error('cannot define "revertCode" if "call" is defined');
+    }
+}
+
+function validateScript(yamlScript: YamlScript) {
+    if (!yamlScript) {
+        throw new Error('undefined script');
+    }
+    if (!yamlScript.code && !yamlScript.call) {
+        throw new Error('must define either "call" or "code"');
+    }
+    ensureNotBothCallAndCode(yamlScript);
+}
--- a/src/application/State/Code/Generation/UserScriptGenerator.ts
+++ b/src/application/State/Code/Generation/UserScriptGenerator.ts
@@ -63,6 +63,6 @@ function appendSelection(

 function appendCode(selection: SelectedScript, builder: CodeBuilder) {
    const name = selection.revert ? `${selection.script.name} (revert)` : selection.script.name;
-    const scriptCode = selection.revert ? selection.script.revertCode : selection.script.code;
+    const scriptCode = selection.revert ? selection.script.code.revert : selection.script.code.execute;
    builder.appendFunction(name, scriptCode);
 }
--- a/src/application/State/Filter/UserFilter.ts
+++ b/src/application/State/Filter/UserFilter.ts
@@ -23,7 +23,6 @@ export class UserFilter implements IUserFilter {
            (script) => isScriptAMatch(script, filterLowercase));
        const filteredCategories = this.application.getAllCategories().filter(
            (category) => category.name.toLowerCase().includes(filterLowercase));
-
        const matches = new FilterResult(
            filteredScripts,
            filteredCategories,
@@ -43,11 +42,11 @@ function isScriptAMatch(script: IScript, filterLowercase: string) {
    if (script.name.toLowerCase().includes(filterLowercase)) {
        return true;
    }
-    if (script.code.toLowerCase().includes(filterLowercase)) {
+    if (script.code.execute.toLowerCase().includes(filterLowercase)) {
        return true;
    }
-    if (script.revertCode) {
-        return script.revertCode.toLowerCase().includes(filterLowercase);
+    if (script.code.revert) {
+        return script.code.revert.toLowerCase().includes(filterLowercase);
    }
    return false;
 }
--- a/src/application/State/Selection/IUserSelection.ts
+++ b/src/application/State/Selection/IUserSelection.ts
@@ -1,11 +1,14 @@
 import { SelectedScript } from './SelectedScript';
 import { ISignal } from '@/infrastructure/Events/Signal';
 import { IScript } from '@/domain/IScript';
+import { ICategory } from '@/domain/ICategory';

 export interface IUserSelection {
    readonly changed: ISignal<ReadonlyArray<SelectedScript>>;
    readonly selectedScripts: ReadonlyArray<SelectedScript>;
    readonly totalSelected: number;
+    areAllSelected(category: ICategory): boolean;
+    isAnySelected(category: ICategory): boolean;
    removeAllInCategory(categoryId: number): void;
    addOrUpdateAllInCategory(categoryId: number, revert: boolean): void;
    addSelectedScript(scriptId: string, revert: boolean): void;
--- a/src/application/State/Selection/UserSelection.ts
+++ b/src/application/State/Selection/UserSelection.ts
@@ -1,5 +1,5 @@
 import { SelectedScript } from './SelectedScript';
-import { IApplication } from '@/domain/IApplication';
+import { IApplication, ICategory } from '@/domain/IApplication';
 import { IUserSelection } from './IUserSelection';
 import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
 import { IScript } from '@/domain/IScript';
@@ -21,6 +21,24 @@ export class UserSelection implements IUserSelection {
        }
    }

+    public areAllSelected(category: ICategory): boolean {
+        if (this.selectedScripts.length === 0) {
+            return false;
+        }
+        const scripts = category.getAllScriptsRecursively();
+        if (this.selectedScripts.length < scripts.length) {
+            return false;
+        }
+        return scripts.every((script) => this.selectedScripts.some((selected) => selected.id === script.id));
+    }
+
+    public isAnySelected(category: ICategory): boolean {
+        if (this.selectedScripts.length === 0) {
+            return false;
+        }
+        return this.selectedScripts.some((s) => category.includes(s.script));
+    }
+
    public removeAllInCategory(categoryId: number): void {
        const category = this.app.findCategory(categoryId);
        const scriptsToRemove = category.getAllScriptsRecursively()
--- a/src/application/application.yaml
+++ b/src/application/application.yaml
--- a/src/application/application.yaml.d.ts
+++ b/src/application/application.yaml.d.ts
@@ -1,16 +1,7 @@
 declare module 'js-yaml-loader!*' {
-    export type CategoryOrScript = YamlCategory | YamlScript;
-    export type DocumentationUrls = ReadonlyArray<string> | string;
-
-    export interface YamlDocumentable {
-        docs?: DocumentationUrls;
-    }
-
-    export interface YamlScript extends YamlDocumentable {
-        name: string;
-        code: string;
-        revertCode: string;
-        recommend: boolean;
+    export interface ApplicationYaml {
+        actions: ReadonlyArray<YamlCategory>;
+        functions: ReadonlyArray<YamlFunction> | undefined;
    }

    export interface YamlCategory extends YamlDocumentable {
@@ -18,8 +9,37 @@ declare module 'js-yaml-loader!*' {
        category: string;
    }

-    export interface ApplicationYaml {
-        actions: ReadonlyArray<YamlCategory>;
+    export type CategoryOrScript = YamlCategory | YamlScript;
+    export type DocumentationUrls = ReadonlyArray<string> | string;
+
+    export interface YamlDocumentable {
+        docs?: DocumentationUrls;
+    }
+
+    export interface YamlFunction {
+        name: string;
+        code: string;
+        revertCode?: string;
+        parameters?: readonly string[];
+    }
+
+    export interface FunctionCallParameters {
+        [index: string]: string;
+    }
+
+    export interface FunctionCall {
+        function: string;
+        parameters?: FunctionCallParameters;
+    }
+
+    export type ScriptFunctionCall = readonly FunctionCall[] | FunctionCall | undefined;
+
+    export interface YamlScript extends YamlDocumentable {
+        name: string;
+        code: string | undefined;
+        revertCode: string | undefined;
+        call: ScriptFunctionCall;
+        recommend: string | undefined;
    }

    const content: ApplicationYaml;
--- a/src/domain/Application.ts
+++ b/src/domain/Application.ts
@@ -3,12 +3,13 @@ import { ICategory } from './ICategory';
 import { IScript } from './IScript';
 import { IApplication } from './IApplication';
 import { IProjectInformation } from './IProjectInformation';
+import { RecommendationLevel, RecommendationLevelNames, RecommendationLevels } from './RecommendationLevel';

 export class Application implements IApplication {
-    public get totalScripts(): number { return this.flattened.allScripts.length; }
-    public get totalCategories(): number { return this.flattened.allCategories.length; }
+    public get totalScripts(): number { return this.queryable.allScripts.length; }
+    public get totalCategories(): number { return this.queryable.allCategories.length; }

-    private readonly flattened: IFlattenedApplication;
+    private readonly queryable: IQueryableApplication;

    constructor(
        public readonly info: IProjectInformation,
@@ -16,30 +17,36 @@ export class Application implements IApplication {
        if (!info) {
            throw new Error('info is undefined');
        }
-        this.flattened = flatten(actions);
-        ensureValid(this.flattened);
-        ensureNoDuplicates(this.flattened.allCategories);
-        ensureNoDuplicates(this.flattened.allScripts);
+        this.queryable = makeQueryable(actions);
+        ensureValid(this.queryable);
+        ensureNoDuplicates(this.queryable.allCategories);
+        ensureNoDuplicates(this.queryable.allScripts);
    }

    public findCategory(categoryId: number): ICategory | undefined {
-        return this.flattened.allCategories.find((category) => category.id === categoryId);
+        return this.queryable.allCategories.find((category) => category.id === categoryId);
    }

-    public getRecommendedScripts(): readonly IScript[] {
-        return this.flattened.allScripts.filter((script) => script.isRecommended);
+    public getScriptsByLevel(level: RecommendationLevel): readonly IScript[] {
+        if (isNaN(level)) {
+            throw new Error('undefined level');
+        }
+        if (!(level in RecommendationLevel)) {
+            throw new Error(`invalid level: ${level}`);
+        }
+        return this.queryable.scriptsByLevel.get(level);
    }

    public findScript(scriptId: string): IScript | undefined {
-        return this.flattened.allScripts.find((script) => script.id === scriptId);
+        return this.queryable.allScripts.find((script) => script.id === scriptId);
    }

    public getAllScripts(): IScript[] {
-        return this.flattened.allScripts;
+        return this.queryable.allScripts;
    }

    public getAllCategories(): ICategory[] {
-        return this.flattened.allCategories;
+        return this.queryable.allCategories;
    }
 }

@@ -61,55 +68,85 @@ function ensureNoDuplicates<TKey>(entities: ReadonlyArray<IEntity<TKey>>) {
    }
 }

-interface IFlattenedApplication {
+interface IQueryableApplication {
    allCategories: ICategory[];
    allScripts: IScript[];
+    scriptsByLevel: Map<RecommendationLevel, readonly IScript[]>;
 }

-function ensureValid(application: IFlattenedApplication) {
-    if (!application.allCategories || application.allCategories.length === 0) {
+function ensureValid(application: IQueryableApplication) {
+    ensureValidCategories(application.allCategories);
+    ensureValidScripts(application.allScripts);
+}
+
+function ensureValidCategories(allCategories: readonly ICategory[]) {
+    if (!allCategories || allCategories.length === 0) {
        throw new Error('Application must consist of at least one category');
    }
-    if (!application.allScripts || application.allScripts.length === 0) {
+}
+
+function ensureValidScripts(allScripts: readonly IScript[]) {
+    if (!allScripts || allScripts.length === 0) {
        throw new Error('Application must consist of at least one script');
    }
-    if (application.allScripts.filter((script) => script.isRecommended).length === 0) {
-        throw new Error('Application must consist of at least one recommended script');
+    for (const level of RecommendationLevels) {
+        if (allScripts.every((script) => script.level !== level)) {
+            throw new Error(`none of the scripts are recommended as ${RecommendationLevel[level]}`);
+        }
    }
 }

+function flattenApplication(categories: ReadonlyArray<ICategory>): [ICategory[], IScript[]] {
+    const allCategories = new Array<ICategory>();
+    const allScripts = new Array<IScript>();
+    flattenCategories(categories, allCategories, allScripts);
+    return [
+        allCategories,
+        allScripts,
+    ];
+}
+
 function flattenCategories(
    categories: ReadonlyArray<ICategory>,
-    flattened: IFlattenedApplication): IFlattenedApplication {
+    allCategories: ICategory[],
+    allScripts: IScript[]): IQueryableApplication {
    if (!categories || categories.length === 0) {
-        return flattened;
+        return;
    }
    for (const category of categories) {
-        flattened.allCategories.push(category);
-        flattened = flattenScripts(category.scripts, flattened);
-        flattened = flattenCategories(category.subCategories, flattened);
+        allCategories.push(category);
+        flattenScripts(category.scripts, allScripts);
+        flattenCategories(category.subCategories, allCategories, allScripts);
    }
-    return flattened;
 }

 function flattenScripts(
    scripts: ReadonlyArray<IScript>,
-    flattened: IFlattenedApplication): IFlattenedApplication {
+    allScripts: IScript[]): IScript[] {
    if (!scripts) {
-        return flattened;
+        return;
    }
    for (const script of scripts) {
-        flattened.allScripts.push(script);
+        allScripts.push(script);
    }
-    return flattened;
 }

-function flatten(
-    categories: ReadonlyArray<ICategory>): IFlattenedApplication {
-    let flattened: IFlattenedApplication = {
-        allCategories: new Array<ICategory>(),
-        allScripts: new Array<IScript>(),
+function makeQueryable(
+    actions: ReadonlyArray<ICategory>): IQueryableApplication {
+    const flattened = flattenApplication(actions);
+    return {
+        allCategories: flattened[0],
+        allScripts: flattened[1],
+        scriptsByLevel: groupByLevel(flattened[1]),
    };
-    flattened = flattenCategories(categories, flattened);
-    return flattened;
+}
+
+function groupByLevel(allScripts: readonly IScript[]): Map<RecommendationLevel, readonly IScript[]> {
+    const map = new Map<RecommendationLevel, readonly IScript[]>();
+    for (const levelName of RecommendationLevelNames) {
+        const level = RecommendationLevel[levelName];
+        const scripts = allScripts.filter((script) => script.level !== undefined && script.level <= level);
+        map.set(level, scripts);
+    }
+    return map;
 }
--- a/src/domain/Category.ts
+++ b/src/domain/Category.ts
@@ -15,6 +15,10 @@ export class Category extends BaseEntity<number> implements ICategory {
        validateCategory(this);
    }

+    public includes(script: IScript): boolean {
+        return this.getAllScriptsRecursively().some((childScript) => childScript.id === script.id);
+    }
+
    public getAllScriptsRecursively(): readonly IScript[] {
        return this.allSubScripts || (this.allSubScripts = parseScriptsRecursively(this));
    }
--- a/src/domain/IApplication.ts
+++ b/src/domain/IApplication.ts
@@ -1,6 +1,7 @@
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 import { IProjectInformation } from './IProjectInformation';
+import { RecommendationLevel } from './RecommendationLevel';

 export interface IApplication {
    readonly info: IProjectInformation;
@@ -8,7 +9,7 @@ export interface IApplication {
    readonly totalCategories: number;
    readonly actions: ReadonlyArray<ICategory>;

-    getRecommendedScripts(): ReadonlyArray<IScript>;
+    getScriptsByLevel(level: RecommendationLevel): ReadonlyArray<IScript>;
    findCategory(categoryId: number): ICategory | undefined;
    findScript(scriptId: string): IScript | undefined;
    getAllScripts(): ReadonlyArray<IScript>;
--- a/src/domain/ICategory.ts
+++ b/src/domain/ICategory.ts
@@ -7,6 +7,7 @@ export interface ICategory extends IEntity<number>, IDocumentable {
    readonly name: string;
    readonly subCategories?: ReadonlyArray<ICategory>;
    readonly scripts?: ReadonlyArray<IScript>;
+    includes(script: IScript): boolean;
    getAllScriptsRecursively(): ReadonlyArray<IScript>;
 }

--- a/src/domain/IScript.ts
+++ b/src/domain/IScript.ts
@@ -1,11 +1,12 @@
 import { IEntity } from '../infrastructure/Entity/IEntity';
 import { IDocumentable } from './IDocumentable';
+import { RecommendationLevel } from './RecommendationLevel';
+import { IScriptCode } from './IScriptCode';

 export interface IScript extends IEntity<string>, IDocumentable {
    readonly name: string;
-    readonly isRecommended: boolean;
+    readonly level?: RecommendationLevel;
    readonly documentationUrls: ReadonlyArray<string>;
-    readonly code: string;
-    readonly revertCode: string;
+    readonly code: IScriptCode;
    canRevert(): boolean;
 }
--- a/src/domain/IScriptCode.ts
+++ b/src/domain/IScriptCode.ts
@@ -0,0 +1,4 @@
+export interface IScriptCode {
+    readonly execute: string;
+    readonly revert: string;
+}
--- a/src/domain/RecommendationLevel.ts
+++ b/src/domain/RecommendationLevel.ts
@@ -0,0 +1,11 @@
+export enum RecommendationLevel {
+    Standard = 0,
+    Strict = 1,
+}
+
+export const RecommendationLevelNames = Object
+    .values(RecommendationLevel)
+    .filter((level) => typeof level === 'string') as string[];
+
+export const RecommendationLevels = RecommendationLevelNames
+    .map((level) => RecommendationLevel[level]) as RecommendationLevel[];
--- a/src/domain/Script.ts
+++ b/src/domain/Script.ts
@@ -1,60 +1,27 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { IScript } from './IScript';
+import { RecommendationLevel } from './RecommendationLevel';
+import { IScriptCode } from './IScriptCode';

 export class Script extends BaseEntity<string> implements IScript {
    constructor(
        public readonly name: string,
-        public readonly code: string,
-        public readonly revertCode: string,
+        public readonly code: IScriptCode,
        public readonly documentationUrls: ReadonlyArray<string>,
-        public readonly isRecommended: boolean) {
+        public readonly level?: RecommendationLevel) {
        super(name);
-        validateCode(name, code);
-        if (revertCode) {
-            validateCode(name, revertCode);
-            if (code === revertCode) {
-                throw new Error(`${name}: Code itself and its reverting code cannot be the same`);
-            }
+        if (!code) {
+            throw new Error(`undefined code (script: ${name})`);
        }
+        validateLevel(level);
    }
    public canRevert(): boolean {
-        return Boolean(this.revertCode);
+        return Boolean(this.code.revert);
    }
 }

-function validateCode(name: string, code: string): void {
-    if (!code || code.length === 0) {
-        throw new Error(`Code of ${name} is empty or null`);
-    }
-    ensureCodeHasUniqueLines(name, code);
-    ensureNoEmptyLines(name, code);
-}
-
-function ensureNoEmptyLines(name: string, code: string): void {
-    if (code.split('\n').some((line) => line.trim().length === 0)) {
-        throw Error(`Script has empty lines "${name}"`);
-    }
-}
-
-function mayBeUniqueLine(codeLine: string): boolean {
-    const trimmed = codeLine.trim();
-    if (trimmed === ')' || trimmed === '(') { // "(" and ")" are used often in batch code
-        return false;
-    }
-    if (codeLine.startsWith(':: ') || codeLine.startsWith('REM ')) { // Is comment?
-        return false;
-    }
-    return true;
-}
-
-function ensureCodeHasUniqueLines(name: string, code: string): void {
-    const lines = code.split('\n')
-        .filter((line) => mayBeUniqueLine(line));
-    if (lines.length === 0) {
-        return;
-    }
-    const duplicateLines = lines.filter((e, i, a) => a.indexOf(e) !== i);
-    if (duplicateLines.length !== 0) {
-        throw Error(`Duplicates detected in script "${name}":\n ${duplicateLines.join('\n')}`);
+function validateLevel(level?: RecommendationLevel) {
+    if (level !== undefined && !(level in RecommendationLevel)) {
+        throw new Error(`invalid level: ${level}`);
    }
 }
--- a/src/domain/ScriptCode.ts
+++ b/src/domain/ScriptCode.ts
@@ -0,0 +1,57 @@
+import { IScriptCode } from './IScriptCode';
+
+export class ScriptCode implements IScriptCode {
+    constructor(
+        scriptName: string,
+        public readonly execute: string,
+        public readonly revert: string) {
+        if (!scriptName) {
+            throw new Error('script name is undefined');
+        }
+        validateCode(scriptName, execute);
+        if (revert) {
+            scriptName = `${scriptName} (revert)`;
+            validateCode(scriptName, revert);
+            if (execute === revert) {
+                throw new Error(`${scriptName}: Code itself and its reverting code cannot be the same`);
+            }
+        }
+    }
+}
+
+function validateCode(name: string, code: string): void {
+    if (!code || code.length === 0) {
+        throw new Error(`code of ${name} is empty or undefined`);
+    }
+    ensureCodeHasUniqueLines(name, code);
+    ensureNoEmptyLines(name, code);
+}
+
+function ensureNoEmptyLines(name: string, code: string): void {
+    if (code.split('\n').some((line) => line.trim().length === 0)) {
+        throw Error(`Script has empty lines "${name}"`);
+    }
+}
+
+function ensureCodeHasUniqueLines(name: string, code: string): void {
+    const lines = code.split('\n')
+        .filter((line) => mayBeUniqueLine(line));
+    if (lines.length === 0) {
+        return;
+    }
+    const duplicateLines = lines.filter((e, i, a) => a.indexOf(e) !== i);
+    if (duplicateLines.length !== 0) {
+        throw Error(`Duplicates detected in script "${name}":\n ${duplicateLines.join('\n')}`);
+    }
+}
+
+function mayBeUniqueLine(codeLine: string): boolean {
+    const trimmed = codeLine.trim();
+    if (trimmed === ')' || trimmed === '(') { // "(" and ")" are used often in batch code
+        return false;
+    }
+    if (codeLine.startsWith(':: ') || codeLine.startsWith('REM ')) { // Is comment?
+        return false;
+    }
+    return true;
+}
--- a/src/presentation/Bootstrapping/Modules/IconBootstrapper.ts
+++ b/src/presentation/Bootstrapping/Modules/IconBootstrapper.ts
@@ -6,7 +6,8 @@ import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome';
 /** REGULAR ICONS (PREFIX: far) */
 import { faFolderOpen, faFolder, faSmile } from '@fortawesome/free-regular-svg-icons';
 /** SOLID ICONS (PREFIX: fas (default)) */
-import { faTimes, faFileDownload, faCopy, faSearch, faInfoCircle, faUserSecret, faDesktop, faTag, faGlobe } from '@fortawesome/free-solid-svg-icons';
+import { faTimes, faFileDownload, faCopy, faSearch, faInfoCircle, faUserSecret, faDesktop,
+    faTag, faGlobe, faSave, faBatteryFull, faBatteryHalf } from '@fortawesome/free-solid-svg-icons';


 export class IconBootstrapper implements IVueBootstrapper {
@@ -21,9 +22,10 @@ export class IconBootstrapper implements IVueBootstrapper {
            faFolderOpen,
            faFolder,
            faTimes,
-            faFileDownload,
+            faFileDownload, faSave,
            faCopy,
            faSearch,
+            faBatteryFull, faBatteryHalf,
            faInfoCircle);
        vue.component('font-awesome-icon', FontAwesomeIcon);
    }
--- a/src/presentation/Scripts/Cards/CardListItem.vue
+++ b/src/presentation/Scripts/Cards/CardListItem.vue
@@ -8,9 +8,17 @@
                    }"
          ref="cardElement">
        <div class="card__inner">
-          <span v-if="cardTitle && cardTitle.length > 0">{{cardTitle}}</span>
+          <span v-if="cardTitle && cardTitle.length > 0">
+            <span>{{cardTitle}}</span>
+          </span>
          <span v-else>Oh no 😢</span>
+          <!-- Expand icon -->
          <font-awesome-icon :icon="['far', isExpanded ? 'folder-open' : 'folder']" class="card__inner__expand-icon" />
+          <!-- Indeterminate and full states -->
+          <div class="card__inner__state-icons">
+            <font-awesome-icon v-if="isAnyChildSelected && !areAllChildrenSelected" :icon="['fa', 'battery-half']" />
+            <font-awesome-icon v-if="areAllChildrenSelected" :icon="['fa', 'battery-full']" />
+          </div>
        </div>
        <div class="card__expander" v-on:click.stop>
          <div class="card__expander__content">
@@ -36,17 +44,21 @@ import { StatefulVue } from '@/presentation/StatefulVue';
 export default class CardListItem extends StatefulVue {
  @Prop() public categoryId!: number;
  @Prop() public activeCategoryId!: number;
-  public cardTitle?: string = '';
-  public isExpanded: boolean = false;
+  public cardTitle = '';
+  public isExpanded = false;
+  public isAnyChildSelected = false;
+  public areAllChildrenSelected = false;

-  @Emit('selected')
+@Emit('selected')
  public onSelected(isExpanded: boolean) {
    this.isExpanded = isExpanded;
  }
+
  @Watch('activeCategoryId')
  public async onActiveCategoryChanged(value: |number) {
    this.isExpanded = value === this.categoryId;
  }
+
  @Watch('isExpanded')
  public async onExpansionChangedAsync(newValue: number, oldValue: number) {
    if (!oldValue && newValue) {
@@ -57,20 +69,23 @@ export default class CardListItem extends StatefulVue {
  }

  public async mounted() {
-    this.cardTitle = this.categoryId ? await this.getCardTitleAsync(this.categoryId) : undefined;
+    const state = await this.getCurrentStateAsync();
+    state.selection.changed.on(() => {
+      this.updateStateAsync(this.categoryId);
+    });
+    this.updateStateAsync(this.categoryId);
  }

  @Watch('categoryId')
-  public async onCategoryIdChanged(value: |number) {
-    this.cardTitle = value ? await this.getCardTitleAsync(value) : undefined;
-  }
-
-  private async getCardTitleAsync(categoryId: number): Promise<string | undefined> {
-      const state = await this.getCurrentStateAsync();
-      const category = state.app.findCategory(this.categoryId);
-      return category ? category.name : undefined;
+  public async updateStateAsync(value: |number) {
+    const state = await this.getCurrentStateAsync();
+    const category = !value ? undefined : state.app.findCategory(this.categoryId);
+    this.cardTitle = category ? category.name : undefined;
+    this.isAnyChildSelected = category ? state.selection.isAnySelected(category) : false;
+    this.areAllChildrenSelected = category ? state.selection.areAllSelected(category) : false;
  }
 }
+
 </script>

 <style scoped lang="scss">
@@ -93,7 +108,7 @@ $expanded-margin-top: 30px;
  @media screen and (max-width: $small-screen-width) {  width: 90%; }

  &__inner {  
-    padding: $card-padding;
+    padding: $card-padding $card-padding 0 $card-padding;
    position: relative;
    cursor: pointer;
    background-color: $gray;
@@ -115,13 +130,21 @@ $expanded-margin-top: 30px;
    &:after {
      transition: all 0.3s ease-in-out;
    }
+
+    &__state-icons {
+      height: $card-padding;
+      margin-right: -$card-padding;
+      padding-right: 10px;
+      display: flex;
+      justify-content: flex-end;
+    }
  
    &__expand-icon {
      width: 100%;
      margin-top: .25em;
+      vertical-align: middle;
    }
  }
-
  &__expander {
    transition: all 0.2s ease-in-out;
    position: relative;
--- a/src/presentation/Scripts/Selector/TheSelector.vue
+++ b/src/presentation/Scripts/Selector/TheSelector.vue
@@ -5,23 +5,37 @@
            <div class="part">
                <SelectableOption
                    label="None"
-                    :enabled="isNoneSelected"
-                    @click="selectNoneAsync()">
-                </SelectableOption>
+                    :enabled="this.currentSelection == SelectionState.None"
+                    @click="selectAsync(SelectionState.None)"
+                    v-tooltip="'Deselect all selected scripts. Good start to dive deeper into tweaks and select only what you want.'"
+                    />
            </div>
            <div class="part"> | </div>
            <div class="part">
                <SelectableOption
-                    label="Recommended"
-                    :enabled="isRecommendedSelected"
-                    @click="selectRecommendedAsync()" />
+                    label="Standard"
+                    :enabled="this.currentSelection == SelectionState.Standard"
+                    @click="selectAsync(SelectionState.Standard)"
+                    v-tooltip="'🛡️ Balanced for privacy and functionality. OS and applications will function normally.'"
+                    />
+                </div>
+            <div class="part"> | </div>
+            <div class="part">
+                <SelectableOption
+                    label="Strict"
+                    :enabled="this.currentSelection == SelectionState.Strict"
+                    @click="selectAsync(SelectionState.Strict)"
+                    v-tooltip="'🚫 Stronger privacy, disables risky functions that may leak your data. Double check selected tweaks!'"
+                    />
                </div>
            <div class="part"> | </div>
            <div class="part">
                    <SelectableOption
-                    label="All"
-                    :enabled="isAllSelected"
-                    @click="selectAllAsync()" />
+                        label="All"
+                        :enabled="this.currentSelection == SelectionState.All"
+                        @click="selectAsync(SelectionState.All)"
+                        v-tooltip="'🔒 Strongest privacy. Disables any functionality that may leak your data. ⚠️ Not recommended for inexperienced users'"
+                    />
            </div>
        </div>
    </div>
@@ -33,17 +47,24 @@ import { StatefulVue } from '@/presentation/StatefulVue';
 import SelectableOption from './SelectableOption.vue';
 import { IApplicationState } from '@/application/State/IApplicationState';
 import { IScript } from '@/domain/IScript';
-import { SelectedScript } from '../../../application/State/Selection/SelectedScript';
+import { SelectedScript } from '@/application/State/Selection/SelectedScript';
+import { RecommendationLevel } from '@/domain/RecommendationLevel';

+enum SelectionState {
+    Standard,
+    Strict,
+    All,
+    None,
+    Custom,
+}
@Component({
  components: {
    SelectableOption,
  },
 })
 export default class TheSelector extends StatefulVue {
-    public isAllSelected = false;
-    public isNoneSelected = false;
-    public isRecommendedSelected = false;
+    public SelectionState = SelectionState;
+    public currentSelection = SelectionState.None;

    public async mounted() {
        const state = await this.getCurrentStateAsync();
@@ -52,43 +73,73 @@ export default class TheSelector extends StatefulVue {
            this.updateSelections(state);
        });
    }
-
-    public async selectAllAsync(): Promise<void> {
-        if (this.isAllSelected) {
+    public async selectAsync(type: SelectionState): Promise<void> {
+        if (this.currentSelection === type) {
            return;
        }
        const state = await this.getCurrentStateAsync();
-        state.selection.selectAll();
-    }
-
-    public async selectRecommendedAsync(): Promise<void> {
-        if (this.isRecommendedSelected) {
-            return;
-        }
-        const state = await this.getCurrentStateAsync();
-        state.selection.selectOnly(state.app.getRecommendedScripts());
-    }
-
-    public async selectNoneAsync(): Promise<void> {
-        if (this.isNoneSelected) {
-            return;
-        }
-        const state = await this.getCurrentStateAsync();
-        state.selection.deselectAll();
+        selectType(state, type);
    }

    private updateSelections(state: IApplicationState) {
-        this.isNoneSelected = state.selection.totalSelected === 0;
-        this.isAllSelected = state.selection.totalSelected === state.app.totalScripts;
-        this.isRecommendedSelected = this.areAllRecommended(state.app.getRecommendedScripts(),
-            state.selection.selectedScripts);
+       this.currentSelection = getCurrentSelectionState(state);
    }
+}

-    private areAllRecommended(scripts: ReadonlyArray<IScript>, other: ReadonlyArray<SelectedScript>): boolean {
-        other = other.filter((selected) => !(selected).revert);
-        return (scripts.length === other.length) &&
-            scripts.every((script) => other.some((selected) => selected.id === script.id));
+interface ITypeSelector {
+    isSelected: (state: IApplicationState) => boolean;
+    select: (state: IApplicationState) => void;
+}
+
+const selectors = new Map<SelectionState, ITypeSelector>([
+    [SelectionState.None, {
+        select: (state) => state.selection.deselectAll(),
+        isSelected: (state) => state.selection.totalSelected === 0,
+    }],
+    [SelectionState.Standard, {
+        select: (state) => state.selection.selectOnly(state.app.getScriptsByLevel(RecommendationLevel.Standard)),
+        isSelected: (state) => hasAllSelectedLevelOf(RecommendationLevel.Standard, state),
+    }],
+    [SelectionState.Strict, {
+        select: (state) => state.selection.selectOnly(state.app.getScriptsByLevel(RecommendationLevel.Strict)),
+        isSelected: (state) => hasAllSelectedLevelOf(RecommendationLevel.Strict, state),
+    }],
+    [SelectionState.All, {
+        select: (state) => state.selection.selectAll(),
+        isSelected: (state) => state.selection.totalSelected === state.app.totalScripts,
+    }],
+]);
+
+function selectType(state: IApplicationState, type: SelectionState) {
+    const selector = selectors.get(type);
+    selector.select(state);
+}
+
+function getCurrentSelectionState(state: IApplicationState): SelectionState {
+    for (const [type, selector] of Array.from(selectors.entries())) {
+        if (selector.isSelected(state)) {
+            return type;
+        }
    }
+    return SelectionState.Custom;
+}
+
+function hasAllSelectedLevelOf(level: RecommendationLevel, state: IApplicationState) {
+    const scripts = state.app.getScriptsByLevel(level);
+    const selectedScripts = state.selection.selectedScripts;
+    return areAllSelected(scripts, selectedScripts);
+}
+
+function areAllSelected(
+    expectedScripts: ReadonlyArray<IScript>,
+    selection: ReadonlyArray<SelectedScript>): boolean {
+    selection = selection.filter((selected) => !selected.revert);
+    if (expectedScripts.length < selection.length) {
+        return false;
+    }
+    const selectedScriptIds = selection.map((script) => script.id).sort();
+    const expectedScriptIds = expectedScripts.map((script) => script.id).sort();
+    return selectedScriptIds.every((id, index) => id === expectedScriptIds[index]);
 }
 </script>

--- a/src/presentation/TheCodeArea.vue
+++ b/src/presentation/TheCodeArea.vue
@@ -17,7 +17,7 @@ const NothingChosenCode =
    .appendLine()
    .appendCommentLine('-- 🤔 How to use')
    .appendCommentLine(' 📙 Start by exploring different categories and choosing different tweaks.')
-    .appendCommentLine(' 📙 You can select "Recommended" on the top to select "safer" tweaks. Always double check!')
+    .appendCommentLine(' 📙 On top left, you can apply predefined selections for privacy level you\'d like.')
    .appendCommentLine(' 📙 After you choose any tweak, you can download or copy to execute your script.')
    .appendCommentLine(' 📙 Come back regularly to apply latest version for stronger privacy and security.')
    .appendLine()
@@ -113,6 +113,7 @@ function initializeEditor(theme: string, editorId: string): ace.Ace.Editor {
    width: 100%;
    max-height: 1000px;
    min-height: 200px;
+    overflow: auto;
    &__highlight {
      background-color:$accent;
      opacity: 0.2; // having procent fails in production (minified) build
--- a/src/presentation/TheCodeButtons.vue
+++ b/src/presentation/TheCodeButtons.vue
@@ -1,24 +1,27 @@
 <template>
    <div class="container" v-if="hasCode">
+        </IconButton>
+        <IconButton
+            :text="this.isDesktop ? 'Save' : 'Download'"
+            v-on:click="saveCodeAsync"
+            icon-prefix="fas" 
+            :icon-name="this.isDesktop ? 'save' : 'file-download'">
+        </IconButton>
        <IconButton
            text="Copy"
            v-on:click="copyCodeAsync"
            icon-prefix="fas" icon-name="copy">
        </IconButton>
-        <IconButton
-            text="Download"
-            v-on:click="saveCodeAsync"
-            icon-prefix="fas" icon-name="file-download">
-        </IconButton>
    </div>
 </template>

 <script lang="ts">
 import { Component } from 'vue-property-decorator';
 import { StatefulVue } from './StatefulVue';
-import { SaveFileDialog, FileType } from './../infrastructure/SaveFileDialog';
-import { Clipboard } from './../infrastructure/Clipboard';
+import { SaveFileDialog, FileType } from '@/infrastructure/SaveFileDialog';
+import { Clipboard } from '@/infrastructure/Clipboard';
 import IconButton from './IconButton.vue';
+import { Environment } from '@/application/Environment/Environment';

@Component({
  components: {
@@ -27,9 +30,11 @@ import IconButton from './IconButton.vue';
 })
 export default class TheCodeButtons extends StatefulVue {
  public hasCode = false;
+  public isDesktop = false;

  public async mounted() {
    const state = await this.getCurrentStateAsync();
+    this.isDesktop = Environment.CurrentEnvironment.isDesktop;
    this.hasCode = state.code.current && state.code.current.length > 0;
    state.code.changed.on((code) => {
      this.hasCode = code && code.code.length > 0;
--- a/tests/unit/application/Parser/ApplicationParser.spec.ts
+++ b/tests/unit/application/Parser/ApplicationParser.spec.ts
@@ -4,22 +4,42 @@ import { parseApplication } from '@/application/Parser/ApplicationParser';
 import 'mocha';
 import { expect } from 'chai';
 import { parseCategory } from '@/application/Parser/CategoryParser';
+import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { ScriptCompilerStub } from '../../stubs/ScriptCompilerStub';

 describe('ApplicationParser', () => {
    describe('parseApplication', () => {
        it('can parse current application file', () => {
-            expect(() => parseApplication(applicationFile)).to.not.throw();
+            // act
+            const act = () => parseApplication(applicationFile);
+            // assert
+            expect(act).to.not.throw();
        });
        it('throws when undefined', () => {
-            expect(() => parseApplication(undefined)).to.throw('application is null or undefined');
+            // arrange
+            const expectedError = 'application is null or undefined';
+            // act
+            const act = () => parseApplication(undefined);
+            // assert
+            expect(act).to.throw(expectedError);
        });
        it('throws when undefined actions', () => {
-            const sut: ApplicationYaml = { actions: undefined };
-            expect(() => parseApplication(sut)).to.throw('application does not define any action');
+            // arrange
+            const sut: ApplicationYaml = { actions: undefined, functions: undefined };
+            const expectedError = 'application does not define any action';
+            // act
+            const act = () => parseApplication(sut);
+            // assert
+            expect(act).to.throw(expectedError);
        });
        it('throws when has no actions', () => {
-            const sut: ApplicationYaml = { actions: [] };
-            expect(() => parseApplication(sut)).to.throw('application does not define any action');
+            // arrange
+            const sut: ApplicationYaml = { actions: [], functions: undefined };
+            const expectedError = 'application does not define any action';
+            // act
+            const act = () => parseApplication(sut);
+            // assert
+            expect(act).to.throw(expectedError);
        });
        describe('information', () => {
            it('returns expected repository version', () => {
@@ -27,7 +47,7 @@ describe('ApplicationParser', () => {
                const expected = 'expected-version';
                const env = getProcessEnvironmentStub();
                env.VUE_APP_VERSION = expected;
-                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ], functions: undefined };
                // act
                const actual = parseApplication(sut, env).info.version;
                // assert
@@ -38,7 +58,7 @@ describe('ApplicationParser', () => {
                const expected = 'https://expected-repository.url';
                const env = getProcessEnvironmentStub();
                env.VUE_APP_REPOSITORY_URL = expected;
-                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ], functions: undefined };
                // act
                const actual = parseApplication(sut, env).info.repositoryUrl;
                // assert
@@ -49,7 +69,7 @@ describe('ApplicationParser', () => {
                const expected = 'expected-app-name';
                const env = getProcessEnvironmentStub();
                env.VUE_APP_NAME = expected;
-                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ], functions: undefined };
                // act
                const actual = parseApplication(sut, env).info.name;
                // assert
@@ -60,7 +80,7 @@ describe('ApplicationParser', () => {
                const expected = 'https://expected.sexy';
                const env = getProcessEnvironmentStub();
                env.VUE_APP_HOMEPAGE_URL = expected;
-                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ], functions: undefined };
                // act
                const actual = parseApplication(sut, env).info.homepage;
                // assert
@@ -70,8 +90,9 @@ describe('ApplicationParser', () => {
        it('parses actions', () => {
            // arrange
            const actions = [ getTestCategory('test1'), getTestCategory('test2') ];
-            const expected = [ parseCategory(actions[0]), parseCategory(actions[1]) ];
-            const sut: ApplicationYaml = { actions };
+            const compiler = new ScriptCompilerStub();
+            const expected = [ parseCategory(actions[0], compiler), parseCategory(actions[1], compiler) ];
+            const sut: ApplicationYaml = { actions, functions: undefined };
            // act
            const actual = parseApplication(sut).actions;
            // assert
@@ -86,19 +107,23 @@ describe('ApplicationParser', () => {
    });
 });

-function getTestCategory(scriptName = 'testScript'): YamlCategory {
+function getTestCategory(scriptPrefix = 'testScript'): YamlCategory {
    return {
        category: 'category name',
-        children: [ getTestScript(scriptName) ],
+        children: [
+            getTestScript(`${scriptPrefix}-standard`, RecommendationLevel.Standard),
+            getTestScript(`${scriptPrefix}-strict`, RecommendationLevel.Strict),
+        ],
    };
 }

-function getTestScript(scriptName: string): YamlScript {
+function getTestScript(scriptName: string, level: RecommendationLevel = RecommendationLevel.Standard): YamlScript {
    return {
        name: scriptName,
        code: 'script code',
        revertCode: 'revert code',
-        recommend: true,
+        recommend: RecommendationLevel[level].toLowerCase(),
+        call: undefined,
    };
 }

--- a/tests/unit/application/Parser/CategoryParser.spec.ts
+++ b/tests/unit/application/Parser/CategoryParser.spec.ts
@@ -4,87 +4,150 @@ import { parseCategory } from '@/application/Parser/CategoryParser';
 import { YamlCategory, CategoryOrScript, YamlScript } from 'js-yaml-loader!./application.yaml';
 import { parseScript } from '@/application/Parser/ScriptParser';
 import { parseDocUrls } from '@/application/Parser/DocumentationParser';
+import { ScriptCompilerStub } from '../../stubs/ScriptCompilerStub';
+import { YamlScriptStub } from '../../stubs/YamlScriptStub';

 describe('CategoryParser', () => {
    describe('parseCategory', () => {
-
-        it('throws when undefined', () => {
-            expect(() => parseCategory(undefined)).to.throw('category is null or undefined');
+        describe('invalid category', () => {
+            it('throws when undefined', () => {
+                // arrange
+                const expectedMessage = 'category is null or undefined';
+                const category = undefined;
+                const compiler = new ScriptCompilerStub();
+                // act
+                const act = () => parseCategory(category, compiler);
+                // assert
+                expect(act).to.throw(expectedMessage);
+            });
+            it('throws when children are empty', () => {
+                // arrange
+                const expectedMessage = 'category has no children';
+                const category: YamlCategory = {
+                    category: 'test',
+                    children: [],
+                };
+                const compiler = new ScriptCompilerStub();
+                // act
+                const act = () => parseCategory(category, compiler);
+                // assert
+                expect(act).to.throw(expectedMessage);
+            });
+            it('throws when children are undefined', () => {
+                // arrange
+                const expectedMessage = 'category has no children';
+                const category: YamlCategory = {
+                    category: 'test',
+                    children: undefined,
+                };
+                const compiler = new ScriptCompilerStub();
+                // act
+                const act = () => parseCategory(category, compiler);
+                // assert
+                expect(act).to.throw(expectedMessage);
+            });
+            it('throws when name is empty or undefined', () => {
+                // arrange
+                const expectedMessage = 'category has no name';
+                const invalidNames = ['', undefined];
+                invalidNames.forEach((invalidName) => {
+                    const category: YamlCategory = {
+                        category: invalidName,
+                        children: getTestChildren(),
+                    };
+                    const compiler = new ScriptCompilerStub();
+                    // act
+                    const act = () => parseCategory(category, compiler);
+                    // assert
+                    expect(act).to.throw(expectedMessage);
+                });
+            });
        });
-
-        it('throws when children is empty', () => {
-            const category: YamlCategory = {
-                category: 'test',
-                children: [],
-            };
-            expect(() => parseCategory(category)).to.throw('category has no children');
+        it('throws when compiler is undefined', () => {
+            // arrange
+            const expectedError = 'undefined compiler';
+            const compiler = undefined;
+            const category = getValidCategory();
+            // act
+            const act = () => parseCategory(category, compiler);
+            // assert
+            expect(act).to.throw(expectedError);
        });
-
-        it('throws when children is undefined', () => {
-            const category: YamlCategory = {
-                category: 'test',
-                children: undefined,
-            };
-            expect(() => parseCategory(category)).to.throw('category has no children');
-        });
-
-        it('throws when name is empty', () => {
-            const category: YamlCategory = {
-                category: '',
-                children: getTestChildren(),
-            };
-            expect(() => parseCategory(category)).to.throw('category has no name');
-        });
-
-        it('throws when name is undefined', () => {
-            const category: YamlCategory = {
-                category: undefined,
-                children: getTestChildren(),
-            };
-            expect(() => parseCategory(category)).to.throw('category has no name');
-        });
-
        it('returns expected docs', () => {
            // arrange
            const url = 'https://privacy.sexy';
            const expected = parseDocUrls({ docs: url });
+            const compiler = new ScriptCompilerStub();
            const category: YamlCategory = {
                category: 'category name',
                children: getTestChildren(),
                docs: url,
            };
            // act
-            const actual = parseCategory(category).documentationUrls;
+            const actual = parseCategory(category, compiler).documentationUrls;
            // assert
            expect(actual).to.deep.equal(expected);
        });
-
-        it('returns expected scripts', () => {
-            // arrange
-            const script = getTestScript();
-            const expected = [ parseScript(script) ];
-            const category: YamlCategory = {
-                category: 'category name',
-                children: [ script ],
-            };
-            // act
-            const actual = parseCategory(category).scripts;
-            // assert
-            expect(actual).to.deep.equal(expected);
+        describe('parses expected subscript', () => {
+            it('single script with code', () => {
+                // arrange
+                const script = YamlScriptStub.createWithCode();
+                const compiler = new ScriptCompilerStub();
+                const expected = [ parseScript(script, compiler) ];
+                const category: YamlCategory = {
+                    category: 'category name',
+                    children: [ script ],
+                };
+                // act
+                const actual = parseCategory(category, compiler).scripts;
+                // assert
+                expect(actual).to.deep.equal(expected);
+            });
+            it('single script with function call', () => {
+                // arrange
+                const script = YamlScriptStub.createWithCall();
+                const compiler = new ScriptCompilerStub()
+                    .withCompileAbility(script);
+                const expected = [ parseScript(script, compiler) ];
+                const category: YamlCategory = {
+                    category: 'category name',
+                    children: [ script ],
+                };
+                // act
+                const actual = parseCategory(category, compiler).scripts;
+                // assert
+                expect(actual).to.deep.equal(expected);
+            });
+            it('multiple scripts with function call and code', () => {
+                // arrange
+                const callableScript = YamlScriptStub.createWithCall();
+                const scripts = [ callableScript, YamlScriptStub.createWithCode() ];
+                const compiler = new ScriptCompilerStub()
+                    .withCompileAbility(callableScript);
+                const expected = scripts.map((script) => parseScript(script, compiler));
+                const category: YamlCategory = {
+                    category: 'category name',
+                    children: scripts,
+                };
+                // act
+                const actual = parseCategory(category, compiler).scripts;
+                // assert
+                expect(actual).to.deep.equal(expected);
+            });
        });
-
        it('returns expected subcategories', () => {
            // arrange
            const expected: YamlCategory[]  = [ {
                category: 'test category',
-                children: [ getTestScript() ],
+                children: [ YamlScriptStub.createWithCode() ],
            }];
            const category: YamlCategory = {
                category: 'category name',
                children: expected,
            };
+            const compiler = new ScriptCompilerStub();
            // act
-            const actual = parseCategory(category).subCategories;
+            const actual = parseCategory(category, compiler).subCategories;
            // assert
            expect(actual).to.have.lengthOf(1);
            expect(actual[0].name).to.equal(expected[0].category);
@@ -93,17 +156,16 @@ describe('CategoryParser', () => {
    });
 });

-function getTestChildren(): ReadonlyArray<CategoryOrScript> {
-    return [
-        getTestScript(),
-    ];
-}
-
-function getTestScript(): YamlScript {
+function getValidCategory(): YamlCategory {
    return {
-        name: 'script name',
-        code: 'script code',
-        revertCode: 'revert code',
-        recommend: true,
+        category: 'category name',
+        children: getTestChildren(),
+        docs: undefined,
    };
 }
+
+function getTestChildren(): ReadonlyArray<CategoryOrScript> {
+    return [
+        YamlScriptStub.createWithCode(),
+    ];
+}
--- a/tests/unit/application/Parser/Compiler/ScriptCompiler.spec.ts
+++ b/tests/unit/application/Parser/Compiler/ScriptCompiler.spec.ts
@@ -0,0 +1,363 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ScriptCompiler } from '@/application/Parser/Compiler/ScriptCompiler';
+import { YamlScriptStub } from '../../../stubs/YamlScriptStub';
+import { YamlFunction, YamlScript, FunctionCall, ScriptFunctionCall, FunctionCallParameters } from 'js-yaml-loader!./application.yaml';
+import { IScriptCode } from '@/domain/IScriptCode';
+import { IScriptCompiler } from '@/application/Parser/Compiler/IScriptCompiler';
+
+describe('ScriptCompiler', () => {
+    describe('ctor', () => {
+        it('throws when functions have same names', () => {
+            // arrange
+            const expectedError = `duplicate function name: "same-func-name"`;
+            const functions: YamlFunction[] = [ {
+                name: 'same-func-name',
+                code: 'non-empty-code',
+            }, {
+                name: 'same-func-name',
+                code: 'non-empty-code-2',
+            }];
+            // act
+            const act = () => new ScriptCompiler(functions);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        it('throws when function parameters have same names', () => {
+            // arrange
+            const func: YamlFunction = {
+                name: 'function-name',
+                code: 'non-empty-code',
+                parameters: [ 'duplicate', 'duplicate' ],
+            };
+            const expectedError = `"${func.name}": duplicate parameter name: "duplicate"`;
+            // act
+            const act = () => new ScriptCompiler([func]);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        describe('throws when when function have duplicate code', () => {
+            it('code', () => {
+                // arrange
+                const expectedError = `duplicate "code" in functions: "duplicate-code"`;
+                const functions: YamlFunction[] = [ {
+                    name: 'func-1',
+                    code: 'duplicate-code',
+                }, {
+                    name: 'func-2',
+                    code: 'duplicate-code',
+                }];
+                // act
+                const act = () => new ScriptCompiler(functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('revertCode', () => {
+                // arrange
+                const expectedError = `duplicate "revertCode" in functions: "duplicate-revert-code"`;
+                const functions: YamlFunction[] = [ {
+                    name: 'func-1',
+                    code: 'code-1',
+                    revertCode: 'duplicate-revert-code',
+                }, {
+                    name: 'func-2',
+                    code: 'code-2',
+                    revertCode: 'duplicate-revert-code',
+                }];
+                // act
+                const act = () => new ScriptCompiler(functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+    });
+    describe('canCompile', () => {
+        it('returns true if "call" is defined', () => {
+            // arrange
+            const sut = new ScriptCompiler([]);
+            const script = YamlScriptStub.createWithCall();
+            // act
+            const actual = sut.canCompile(script);
+            // assert
+            expect(actual).to.equal(true);
+        });
+        it('returns false if "call" is undefined', () => {
+            // arrange
+            const sut = new ScriptCompiler([]);
+            const script = YamlScriptStub.createWithCode();
+            // act
+            const actual = sut.canCompile(script);
+            // assert
+            expect(actual).to.equal(false);
+        });
+    });
+    describe('compile', () => {
+        describe('invalid state', () => {
+            it('throws if functions are empty', () => {
+                // arrange
+                const expectedError = 'cannot compile without shared functions';
+                const functions = [];
+                const sut = new ScriptCompiler(functions);
+                const script = YamlScriptStub.createWithCall();
+                // act
+                const act = () => sut.compile(script);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws if call is not an object', () => {
+                // arrange
+                const expectedError = 'called function(s) must be an object';
+                const invalidValues = [undefined, 'string', 33];
+                const sut = new ScriptCompiler(createFunctions());
+                invalidValues.forEach((invalidValue) => {
+                    const script = YamlScriptStub.createWithoutCallOrCodes() // because call ctor overwrites "undefined"
+                        .withCall(invalidValue as any);
+                    // act
+                    const act = () => sut.compile(script);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+            });
+            describe('invalid function reference', () => {
+                it('throws if function does not exist', () => {
+                    // arrange
+                    const sut = new ScriptCompiler(createFunctions());
+                    const nonExistingFunctionName = 'non-existing-func';
+                    const expectedError = `called function is not defined "${nonExistingFunctionName}"`;
+                    const call: ScriptFunctionCall = { function: nonExistingFunctionName };
+                    const script = YamlScriptStub.createWithCall(call);
+                    // act
+                    const act = () => sut.compile(script);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+                it('throws if function is undefined', () => {
+                    // arrange
+                    const existingFunctionName = 'existing-func';
+                    const sut = new ScriptCompiler(createFunctions(existingFunctionName));
+                    const call: ScriptFunctionCall = [
+                        { function: existingFunctionName },
+                        undefined,
+                    ];
+                    const script = YamlScriptStub.createWithCall(call);
+                    const expectedError = `undefined function call in script "${script.name}"`;
+                    // act
+                    const act = () => sut.compile(script);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+                it('throws if function name is not given', () => {
+                    // arrange
+                    const existingFunctionName = 'existing-func';
+                    const sut = new ScriptCompiler(createFunctions(existingFunctionName));
+                    const call: FunctionCall[] = [
+                        { function: existingFunctionName },
+                        { function: undefined }];
+                    const script = YamlScriptStub.createWithCall(call);
+                    const expectedError = `empty function name called in script "${script.name}"`;
+                    // act
+                    const act = () => sut.compile(script);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+            });
+        });
+        describe('builds code as expected', () => {
+            it('builds single call as expected', () => {
+                // arrange
+                const functionName = 'testSharedFunction';
+                const expected: IScriptCode = {
+                    execute: 'expected-code',
+                    revert: 'expected-revert-code',
+                };
+                const func: YamlFunction = {
+                    name: functionName,
+                    parameters: [],
+                    code: expected.execute,
+                    revertCode: expected.revert,
+                };
+                const sut = new ScriptCompiler([func]);
+                const call: FunctionCall = { function: functionName };
+                const script = YamlScriptStub.createWithCall(call);
+                // act
+                const actual = sut.compile(script);
+                // assert
+                expect(actual).to.deep.equal(expected);
+            });
+            it('builds call sequence as expected', () => {
+                // arrange
+                const firstFunction: YamlFunction = {
+                    name: 'first-function-name',
+                    parameters: [],
+                    code: 'first-function-code',
+                    revertCode: 'first-function-revert-code',
+                };
+                const secondFunction: YamlFunction = {
+                    name: 'second-function-name',
+                    parameters: [],
+                    code: 'second-function-code',
+                    revertCode: 'second-function-revert-code',
+                };
+                const expected: IScriptCode = {
+                    execute: 'first-function-code\nsecond-function-code',
+                    revert: 'first-function-revert-code\nsecond-function-revert-code',
+                };
+                const sut = new ScriptCompiler([firstFunction, secondFunction]);
+                const call: FunctionCall[] = [
+                    { function: firstFunction.name },
+                    { function: secondFunction.name },
+                ];
+                const script = YamlScriptStub.createWithCall(call);
+                // act
+                const actual = sut.compile(script);
+                // assert
+                expect(actual).to.deep.equal(expected);
+            });
+        });
+        describe('parameter substitution', () => {
+            describe('substitutes by ignoring whitespaces inside mustaches', () => {
+                // arrange
+                const mustacheVariations = [
+                    'Hello {{ $test }}!',
+                    'Hello {{$test }}!',
+                    'Hello {{ $test}}!',
+                    'Hello {{$test}}!'];
+                mustacheVariations.forEach((variation) => {
+                    it(variation, () => {
+                        // arrange
+                        const env = new TestEnvironment({
+                            code: variation,
+                            parameters: {
+                                test: 'world',
+                            },
+                        });
+                        const expected = env.expect('Hello world!');
+                        // act
+                        const actual = env.sut.compile(env.script);
+                        // assert
+                        expect(actual).to.deep.equal(expected);
+                    });
+                });
+            });
+            describe('substitutes as expected', () => {
+                it('with different parameters', () => {
+                    // arrange
+                    const env = new TestEnvironment({
+                        code: 'He{{ $firstParameter }} {{ $secondParameter }}!',
+                        parameters: {
+                            firstParameter: 'llo',
+                            secondParameter: 'world',
+                        },
+                    });
+                    const expected = env.expect('Hello world!');
+                    // act
+                    const actual = env.sut.compile(env.script);
+                    // assert
+                    expect(actual).to.deep.equal(expected);
+                });
+                it('with same parameter repeated', () => {
+                    // arrange
+                    const env = new TestEnvironment({
+                        code: '{{ $parameter }} {{ $parameter }}!',
+                        parameters: {
+                            parameter: 'Hodor',
+                        },
+                    });
+                    const expected = env.expect('Hodor Hodor!');
+                    // act
+                    const actual = env.sut.compile(env.script);
+                    // assert
+                    expect(actual).to.deep.equal(expected);
+                });
+            });
+            it('throws when parameters is undefined', () => {
+                // arrange
+                const env = new TestEnvironment({
+                    code: '{{ $parameter }} {{ $parameter }}!',
+                });
+                const expectedError = 'no parameters defined, expected: "parameter"';
+                // act
+                const act = () => env.sut.compile(env.script);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when parameter value is not provided', () => {
+                // arrange
+                const env = new TestEnvironment({
+                    code: '{{ $parameter }} {{ $parameter }}!',
+                    parameters: {
+                        parameter: undefined,
+                    },
+                });
+                const expectedError = 'parameter value is not provided for "parameter" in function call';
+                // act
+                const act = () => env.sut.compile(env.script);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws on unknown expressions', () => {
+                // arrange
+                const env = new TestEnvironment({
+                    code: '{{ each }}',
+                    parameters: {
+                        parameter: undefined,
+                    },
+                });
+                const expectedError = 'unknown expression: "each"';
+                // act
+                const act = () => env.sut.compile(env.script);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+    });
+});
+
+interface ITestCase {
+    code: string;
+    parameters?: FunctionCallParameters;
+}
+
+class TestEnvironment {
+    public readonly sut: IScriptCompiler;
+    public readonly script: YamlScript;
+    constructor(testCase: ITestCase) {
+        const functionName = 'testFunction';
+        const func: YamlFunction = {
+            name: functionName,
+            parameters: testCase.parameters ? Object.keys(testCase.parameters) : undefined,
+            code: this.getCode(testCase.code, 'execute'),
+            revertCode: this.getCode(testCase.code, 'revert'),
+        };
+        this.sut = new ScriptCompiler([func]);
+        const call: FunctionCall = {
+            function: functionName,
+            parameters: testCase.parameters,
+        };
+        this.script = YamlScriptStub.createWithCall(call);
+    }
+    public expect(code: string): IScriptCode {
+        return {
+            execute: this.getCode(code, 'execute'),
+            revert: this.getCode(code, 'revert'),
+        };
+    }
+    private getCode(text: string, type: 'execute' | 'revert'): string {
+        return `${text} (${type})`;
+    }
+}
+
+function createFunctions(...names: string[]): YamlFunction[] {
+    if (!names || names.length === 0) {
+        names = ['test-function'];
+    }
+    return names.map((functionName) => {
+        const func: YamlFunction = {
+            name: functionName,
+            parameters: [],
+            code: `REM test-code (${functionName})`,
+            revertCode: `REM test-revert-code (${functionName})`,
+        };
+        return func;
+    });
+}
--- a/tests/unit/application/Parser/ScriptParser.spec.ts
+++ b/tests/unit/application/Parser/ScriptParser.spec.ts
@@ -1,28 +1,198 @@
-import { YamlScript } from 'js-yaml-loader!./application.yaml';
 import 'mocha';
 import { expect } from 'chai';
 import { parseScript } from '@/application/Parser/ScriptParser';
 import { parseDocUrls } from '@/application/Parser/DocumentationParser';
+import { RecommendationLevelNames, RecommendationLevel } from '@/domain/RecommendationLevel';
+import { ScriptCode } from '@/domain/ScriptCode';
+import { ScriptCompilerStub } from '../../stubs/ScriptCompilerStub';
+import { YamlScriptStub } from '../../stubs/YamlScriptStub';

 describe('ScriptParser', () => {
    describe('parseScript', () => {
-        it('parseScript parses as expected', () => {
+        it('parses name as expected', () => {
            // arrange
-            const expected: YamlScript = {
-                name: 'expected name',
-                code: 'expected code',
-                revertCode: 'expected revert code',
-                docs: ['hello.com'],
-                recommend: true,
-            };
+            const expected = 'test-expected-name';
+            const script = YamlScriptStub.createWithCode()
+                .withName(expected);
+            const compiler = new ScriptCompilerStub();
            // act
-            const actual = parseScript(expected);
+            const actual = parseScript(script, compiler);
            // assert
-            expect(actual.name).to.equal(expected.name);
-            expect(actual.code).to.equal(expected.code);
-            expect(actual.revertCode).to.equal(expected.revertCode);
-            expect(actual.documentationUrls).to.deep.equal(parseDocUrls(expected));
-            expect(actual.isRecommended).to.equal(expected.recommend);
+            expect(actual.name).to.equal(expected);
+        });
+        it('parses docs as expected', () => {
+            // arrange
+            const docs = [ 'https://expected-doc1.com', 'https://expected-doc2.com' ];
+            const script = YamlScriptStub.createWithCode()
+                .withDocs(docs);
+            const compiler = new ScriptCompilerStub();
+            const expected = parseDocUrls(script);
+            // act
+            const actual = parseScript(script, compiler);
+            // assert
+            expect(actual.documentationUrls).to.deep.equal(expected);
+        });
+        describe('invalid script', () => {
+            it('throws when script is undefined', () => {
+                // arrange
+                const expectedError = 'undefined script';
+                const compiler = new ScriptCompilerStub();
+                const script = undefined;
+                // act
+                const act = () => parseScript(script, compiler);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when both function call and code are defined', () => {
+                // arrange
+                const expectedError = 'cannot define both "call" and "code"';
+                const compiler = new ScriptCompilerStub();
+                const script = YamlScriptStub
+                    .createWithCall()
+                    .withCode('code');
+                // act
+                const act = () => parseScript(script, compiler);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when both function call and revertCode are defined', () => {
+                // arrange
+                const expectedError = 'cannot define "revertCode" if "call" is defined';
+                const compiler = new ScriptCompilerStub();
+                const script = YamlScriptStub
+                    .createWithCall()
+                    .withRevertCode('revert-code');
+                // act
+                const act = () => parseScript(script, compiler);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when neither call or revertCode are defined', () => {
+                // arrange
+                const expectedError = 'must define either "call" or "code"';
+                const compiler = new ScriptCompilerStub();
+                const script = YamlScriptStub.createWithoutCallOrCodes();
+                // act
+                const act = () => parseScript(script, compiler);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+        describe('level', () => {
+            it('accepts undefined level', () => {
+                const undefinedLevels: string[] = [ '', undefined ];
+                undefinedLevels.forEach((undefinedLevel) => {
+                    // arrange
+                    const compiler = new ScriptCompilerStub();
+                    const script = YamlScriptStub.createWithCode();
+                    script.recommend = undefinedLevel;
+                    // act
+                    const actual = parseScript(script, compiler);
+                    // assert
+                    expect(actual.level).to.equal(undefined);
+                });
+            });
+            it('throws on unknown level', () => {
+                // arrange
+                const unknownLevel = 'boi';
+                const compiler = new ScriptCompilerStub();
+                const script = YamlScriptStub.createWithCode();
+                script.recommend = unknownLevel;
+                // act
+                const act = () => parseScript(script, compiler);
+                // assert
+                expect(act).to.throw(`unknown level: "${unknownLevel}"`);
+            });
+            it('throws on non-string type', () => {
+                const nonStringTypes: any[] = [ 5, true ];
+                nonStringTypes.forEach((nonStringType) => {
+                    // arrange
+                    const script = YamlScriptStub.createWithCode();
+                    const compiler = new ScriptCompilerStub();
+                    script.recommend = nonStringType;
+                    // act
+                    const act = () => parseScript(script, compiler);
+                    // assert
+                    expect(act).to.throw(`level must be a string but it was ${typeof nonStringType}`);
+                });
+            });
+            describe('parses level as expected', () => {
+                for (const levelText of RecommendationLevelNames) {
+                    it(levelText, () => {
+                        // arrange
+                        const expectedLevel = RecommendationLevel[levelText];
+                        const script = YamlScriptStub.createWithCode();
+                        const compiler = new ScriptCompilerStub();
+                        script.recommend = levelText;
+                        // act
+                        const actual = parseScript(script, compiler);
+                        // assert
+                        expect(actual.level).to.equal(expectedLevel);
+                    });
+                }
+            });
+            it('parses level case insensitive', () => {
+                // arrange
+                const script = YamlScriptStub.createWithCode();
+                const compiler = new ScriptCompilerStub();
+                const expected = RecommendationLevel.Standard;
+                script.recommend = RecommendationLevel[expected].toUpperCase();
+                // act
+                const actual = parseScript(script, compiler);
+                // assert
+                expect(actual.level).to.equal(expected);
+            });
+        });
+        describe('code', () => {
+            it('parses code as expected', () => {
+                // arrange
+                const expected = 'expected-code';
+                const script = YamlScriptStub
+                    .createWithCode()
+                    .withCode(expected);
+                const compiler = new ScriptCompilerStub();
+                // act
+                const parsed = parseScript(script, compiler);
+                // assert
+                const actual = parsed.code.execute;
+                expect(actual).to.equal(expected);
+            });
+            it('parses revertCode as expected', () => {
+                // arrange
+                const expected = 'expected-revert-code';
+                const script = YamlScriptStub
+                    .createWithCode()
+                    .withRevertCode(expected);
+                const compiler = new ScriptCompilerStub();
+                // act
+                const parsed = parseScript(script, compiler);
+                // assert
+                const actual = parsed.code.revert;
+                expect(actual).to.equal(expected);
+            });
+            describe('compiler', () => {
+                it('throws when compiler is not defined', () => {
+                    // arrange
+                    const script = YamlScriptStub.createWithCode();
+                    const compiler = undefined;
+                    // act
+                    const act = () => parseScript(script, compiler);
+                    // assert
+                    expect(act).to.throw('undefined compiler');
+                });
+                it('gets code from compiler', () => {
+                    // arrange
+                    const expected = new ScriptCode('test-script', 'code', 'revert-code');
+                    const script = YamlScriptStub.createWithCode();
+                    const compiler = new ScriptCompilerStub()
+                        .withCompileAbility(script, expected);
+                    // act
+                    const parsed = parseScript(script, compiler);
+                    // assert
+                    const actual = parsed.code;
+                    expect(actual).to.equal(expected);
+                });
+            });
        });
    });
 });
--- a/tests/unit/application/State/Filter/UserFilter.spec.ts
+++ b/tests/unit/application/State/Filter/UserFilter.spec.ts
@@ -18,10 +18,11 @@ describe('UserFilter', () => {
            // assert
            expect(isCalled).to.be.equal(true);
        });
-        it('currentFilter is undefined', () => {
+        it('sets currentFilter to undefined', () => {
            // arrange
            const sut = new UserFilter(new ApplicationStub());
            // act
+            sut.setFilter('non-important');
            sut.removeFilter();
            // assert
            expect(sut.currentFilter).to.be.equal(undefined);
@@ -51,68 +52,69 @@ describe('UserFilter', () => {
            expect(actual.hasAnyMatches()).be.equal(false);
            expect(actual.query).to.equal(nonMatchingFilter);
        });
-        describe('signals when script matches', () => {
-            it('code matches', () => {
-                // arrange
-                const code = 'HELLO world';
-                const filter = 'Hello WoRLD';
-                let actual: IFilterResult;
-                const script = new ScriptStub('id').withCode(code);
-                const category = new CategoryStub(33).withScript(script);
-                const sut = new UserFilter(new ApplicationStub()
-                    .withAction(category));
-                sut.filtered.on((filterResult) => actual = filterResult);
-                // act
-                sut.setFilter(filter);
-                // assert
-                expect(actual.hasAnyMatches()).be.equal(true);
-                expect(actual.categoryMatches).to.have.lengthOf(0);
-                expect(actual.scriptMatches).to.have.lengthOf(1);
-                expect(actual.scriptMatches[0]).to.deep.equal(script);
-                expect(actual.query).to.equal(filter);
-                expect(sut.currentFilter).to.deep.equal(actual);
+        describe('signals when matches', () => {
+            describe('signals when script matches', () => {
+                it('code matches', () => {
+                    // arrange
+                    const code = 'HELLO world';
+                    const filter = 'Hello WoRLD';
+                    let actual: IFilterResult;
+                    const script = new ScriptStub('id').withCode(code);
+                    const category = new CategoryStub(33).withScript(script);
+                    const sut = new UserFilter(new ApplicationStub()
+                        .withAction(category));
+                    sut.filtered.on((filterResult) => actual = filterResult);
+                    // act
+                    sut.setFilter(filter);
+                    // assert
+                    expect(actual.hasAnyMatches()).be.equal(true);
+                    expect(actual.categoryMatches).to.have.lengthOf(0);
+                    expect(actual.scriptMatches).to.have.lengthOf(1);
+                    expect(actual.scriptMatches[0]).to.deep.equal(script);
+                    expect(actual.query).to.equal(filter);
+                    expect(sut.currentFilter).to.deep.equal(actual);
+                });
+                it('revertCode matches', () => {
+                    // arrange
+                    const revertCode = 'HELLO world';
+                    const filter = 'Hello WoRLD';
+                    let actual: IFilterResult;
+                    const script = new ScriptStub('id').withRevertCode(revertCode);
+                    const category = new CategoryStub(33).withScript(script);
+                    const sut = new UserFilter(new ApplicationStub()
+                        .withAction(category));
+                    sut.filtered.on((filterResult) => actual = filterResult);
+                    // act
+                    sut.setFilter(filter);
+                    // assert
+                    expect(actual.hasAnyMatches()).be.equal(true);
+                    expect(actual.categoryMatches).to.have.lengthOf(0);
+                    expect(actual.scriptMatches).to.have.lengthOf(1);
+                    expect(actual.scriptMatches[0]).to.deep.equal(script);
+                    expect(actual.query).to.equal(filter);
+                    expect(sut.currentFilter).to.deep.equal(actual);
+                });
+                it('name matches', () => {
+                    // arrange
+                    const name = 'HELLO world';
+                    const filter = 'Hello WoRLD';
+                    let actual: IFilterResult;
+                    const script = new ScriptStub('id').withName(name);
+                    const category = new CategoryStub(33).withScript(script);
+                    const sut = new UserFilter(new ApplicationStub()
+                        .withAction(category));
+                    sut.filtered.on((filterResult) => actual = filterResult);
+                    // act
+                    sut.setFilter(filter);
+                    // assert
+                    expect(actual.hasAnyMatches()).be.equal(true);
+                    expect(actual.categoryMatches).to.have.lengthOf(0);
+                    expect(actual.scriptMatches).to.have.lengthOf(1);
+                    expect(actual.scriptMatches[0]).to.deep.equal(script);
+                    expect(actual.query).to.equal(filter);
+                    expect(sut.currentFilter).to.deep.equal(actual);
+                });
            });
-            it('revertCode matches', () => {
-                // arrange
-                const revertCode = 'HELLO world';
-                const filter = 'Hello WoRLD';
-                let actual: IFilterResult;
-                const script = new ScriptStub('id').withRevertCode(revertCode);
-                const category = new CategoryStub(33).withScript(script);
-                const sut = new UserFilter(new ApplicationStub()
-                    .withAction(category));
-                sut.filtered.on((filterResult) => actual = filterResult);
-                // act
-                sut.setFilter(filter);
-                // assert
-                expect(actual.hasAnyMatches()).be.equal(true);
-                expect(actual.categoryMatches).to.have.lengthOf(0);
-                expect(actual.scriptMatches).to.have.lengthOf(1);
-                expect(actual.scriptMatches[0]).to.deep.equal(script);
-                expect(actual.query).to.equal(filter);
-                expect(sut.currentFilter).to.deep.equal(actual);
-            });
-            it('name matches', () => {
-                // arrange
-                const name = 'HELLO world';
-                const filter = 'Hello WoRLD';
-                let actual: IFilterResult;
-                const script = new ScriptStub('id').withName(name);
-                const category = new CategoryStub(33).withScript(script);
-                const sut = new UserFilter(new ApplicationStub()
-                    .withAction(category));
-                sut.filtered.on((filterResult) => actual = filterResult);
-                // act
-                sut.setFilter(filter);
-                // assert
-                expect(actual.hasAnyMatches()).be.equal(true);
-                expect(actual.categoryMatches).to.have.lengthOf(0);
-                expect(actual.scriptMatches).to.have.lengthOf(1);
-                expect(actual.scriptMatches[0]).to.deep.equal(script);
-                expect(actual.query).to.equal(filter);
-                expect(sut.currentFilter).to.deep.equal(actual);
-            });
-
            it('signals when category matches', () => {
                // arrange
                const categoryName = 'HELLO world';
--- a/tests/unit/application/State/Selection/UserSelection.spec.ts
+++ b/tests/unit/application/State/Selection/UserSelection.spec.ts
@@ -292,4 +292,92 @@ describe('UserSelection', () => {
            expect(actual).to.equal(true);
        });
    });
+    describe('category state', () => {
+        describe('when no scripts are selected', () => {
+            // arrange
+            const category = new CategoryStub(1)
+                .withScriptIds('non-selected-script-1', 'non-selected-script-2');
+            const app = new ApplicationStub().withAction(category);
+            const sut = new UserSelection(app, [ ]);
+            it('areAllSelected returns false', () => {
+                // act
+                const actual = sut.areAllSelected(category);
+                // assert
+                expect(actual).to.equal(false);
+            });
+            it('isAnySelected returns false', () => {
+                // act
+                const actual = sut.isAnySelected(category);
+                // assert
+                expect(actual).to.equal(false);
+            });
+        });
+        describe('when no subscript exists in selected scripts', () => {
+            // arrange
+            const category = new CategoryStub(1)
+                .withScriptIds('non-selected-script-1', 'non-selected-script-2');
+            const selectedScript = new ScriptStub('selected');
+            const app = new ApplicationStub()
+                .withAction(category)
+                .withAction(new CategoryStub(22).withScript(selectedScript));
+            const sut = new UserSelection(app, [ new SelectedScript(selectedScript, false) ]);
+            it('areAllSelected returns false', () => {
+                // act
+                const actual = sut.areAllSelected(category);
+                // assert
+                expect(actual).to.equal(false);
+            });
+            it('isAnySelected returns false', () => {
+                // act
+                const actual = sut.isAnySelected(category);
+                // assert
+                expect(actual).to.equal(false);
+            });
+        });
+        describe('when one of the scripts are selected', () => {
+            // arrange
+            const selectedScript = new ScriptStub('selected');
+            const category = new CategoryStub(1)
+                .withScriptIds('non-selected-script-1', 'non-selected-script-2')
+                .withCategory(new CategoryStub(12).withScript(selectedScript));
+            const app = new ApplicationStub().withAction(category);
+            const sut = new UserSelection(app, [ new SelectedScript(selectedScript, false) ]);
+            it('areAllSelected returns false', () => {
+                // act
+                const actual = sut.areAllSelected(category);
+                // assert
+                expect(actual).to.equal(false);
+            });
+            it('isAnySelected returns true', () => {
+                // act
+                const actual = sut.isAnySelected(category);
+                // assert
+                expect(actual).to.equal(true);
+            });
+        });
+        describe('when all scripts are selected', () => {
+            // arrange
+            const firstSelectedScript = new ScriptStub('selected1');
+            const secondSelectedScript = new ScriptStub('selected2');
+            const category = new CategoryStub(1)
+                .withScript(firstSelectedScript)
+                .withCategory(new CategoryStub(12).withScript(secondSelectedScript));
+            const app = new ApplicationStub().withAction(category);
+            const sut = new UserSelection(app,
+                [ firstSelectedScript, secondSelectedScript ].map((s) => new SelectedScript(s, false)));
+            it('areAllSelected returns true', () => {
+                // act
+                const actual = sut.areAllSelected(category);
+                // assert
+                expect(actual).to.equal(true);
+            });
+            it('isAnySelected returns true', () => {
+                // act
+                const actual = sut.isAnySelected(category);
+                // assert
+                expect(actual).to.equal(true);
+            });
+        });
+
+    });
 });
--- a/tests/unit/domain/Application.spec.ts
+++ b/tests/unit/domain/Application.spec.ts
@@ -5,25 +5,79 @@ import 'mocha';
 import { expect } from 'chai';
 import { ProjectInformation } from '@/domain/ProjectInformation';
 import { IProjectInformation } from '@/domain/IProjectInformation';
+import { RecommendationLevel, RecommendationLevels } from '@/domain/RecommendationLevel';

 describe('Application', () => {
-    it('getRecommendedScripts returns as expected', () => {
-        // arrange
-        const expected =  [
-            new ScriptStub('S3').withIsRecommended(true),
-            new ScriptStub('S4').withIsRecommended(true),
-        ];
-        const sut = new Application(createInformation(), [
-            new CategoryStub(3).withScripts(expected[0], new ScriptStub('S1').withIsRecommended(false)),
-            new CategoryStub(2).withScripts(expected[1], new ScriptStub('S2').withIsRecommended(false)),
-        ]);
-        // act
-        const actual = sut.getRecommendedScripts();
-        // assert
-        expect(expected[0]).to.deep.equal(actual[0]);
-        expect(expected[1]).to.deep.equal(actual[1]);
+    describe('getScriptsByLevel', () => {
+        it('filters out scripts without levels', () => {
+            // arrange
+            const scriptsWithLevels = RecommendationLevels.map((level, index) =>
+                new ScriptStub(`Script${index}`).withLevel(level),
+            );
+            const toIgnore = new ScriptStub('script-to-ignore').withLevel(undefined);
+            for (const currentLevel of RecommendationLevels) {
+                const category = new CategoryStub(0)
+                    .withScripts(...scriptsWithLevels)
+                    .withScript(toIgnore);
+                const sut = new Application(createInformation(), [category]);
+                // act
+                const actual = sut.getScriptsByLevel(currentLevel);
+                // assert
+                expect(actual).to.not.include(toIgnore);
+            }
+        });
+        it(`${RecommendationLevel[RecommendationLevel.Standard]} filters ${RecommendationLevel[RecommendationLevel.Strict]}`, () => {
+            // arrange
+            const level = RecommendationLevel.Standard;
+            const expected = [
+                new ScriptStub('S1').withLevel(level),
+                new ScriptStub('S2').withLevel(level),
+            ];
+            const sut = new Application(createInformation(), [
+                new CategoryStub(3).withScripts(...expected,
+                    new ScriptStub('S3').withLevel(RecommendationLevel.Strict)),
+            ]);
+            // act
+            const actual = sut.getScriptsByLevel(level);
+            // assert
+            expect(expected).to.deep.equal(actual);
+        });
+        it(`${RecommendationLevel[RecommendationLevel.Strict]} includes ${RecommendationLevel[RecommendationLevel.Standard]}`, () => {
+            // arrange
+            const level = RecommendationLevel.Strict;
+            const expected = [
+                new ScriptStub('S1').withLevel(RecommendationLevel.Standard),
+                new ScriptStub('S2').withLevel(RecommendationLevel.Strict),
+            ];
+            const sut = new Application(createInformation(), [
+                new CategoryStub(3).withScripts(...expected),
+            ]);
+            // act
+            const actual = sut.getScriptsByLevel(level);
+            // assert
+            expect(expected).to.deep.equal(actual);
+        });
+        it('throws when level is undefined', () => {
+            // arrange
+            const sut = new Application(createInformation(), [ getCategoryForValidApplication() ]);
+            // act
+            const act = () => sut.getScriptsByLevel(undefined);
+            // assert
+            expect(act).to.throw('undefined level');
+        });
+        it('throws when level is out of range', () => {
+            // arrange
+            const invalidValue = 66;
+            const sut = new Application(createInformation(), [
+                getCategoryForValidApplication(),
+            ]);
+            // act
+            const act = () => sut.getScriptsByLevel(invalidValue);
+            // assert
+            expect(act).to.throw(`invalid level: ${invalidValue}`);
+        });
    });
-    describe('parameter validation', () => {
+    describe('ctor', () => {
        it('cannot construct without categories', () => {
            // arrange
            const categories = [];
@@ -43,20 +97,24 @@ describe('Application', () => {
            // assert
            expect(construct).to.throw('Application must consist of at least one script');
        });
-        it('cannot construct without any recommended scripts', () => {
-            // arrange
-            const categories = [
-                new CategoryStub(3).withScripts(new ScriptStub('S1').withIsRecommended(false)),
-                new CategoryStub(2).withScripts(new ScriptStub('S2').withIsRecommended(false)),
-            ];
-            // act
-            function construct() { return new Application(createInformation(), categories); }
-            // assert
-            expect(construct).to.throw('Application must consist of at least one recommended script');
+        describe('cannot construct without any recommended scripts', () => {
+            for (const missingLevel of RecommendationLevels) {
+                // arrange
+                const expectedError = `none of the scripts are recommended as ${RecommendationLevel[missingLevel]}`;
+                const otherLevels = RecommendationLevels.filter((level) => level !== missingLevel);
+                const categories = otherLevels.map((level, index) =>
+                    new CategoryStub(index).withScript(new ScriptStub(`Script${index}`).withLevel(level)),
+                );
+                // act
+                const construct = () => new Application(createInformation(), categories);
+                // assert
+                expect(construct).to.throw(expectedError);
+            }
        });
        it('cannot construct without information', () => {
            // arrange
-            const categories = [new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true))];
+            const categories = [ new CategoryStub(1).withScripts(
+                new ScriptStub('S1').withLevel(RecommendationLevel.Standard))];
            const information = undefined;
            // act
            function construct() { return new Application(information, categories); }
@@ -64,42 +122,57 @@ describe('Application', () => {
            expect(construct).to.throw('info is undefined');
        });
    });
-    it('totalScripts counts right', () => {
-        // arrange
-        const categories = [
-            new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true)),
-            new CategoryStub(2).withScripts(new ScriptStub('S2'), new ScriptStub('S3')),
-            new CategoryStub(3).withCategories(new CategoryStub(4).withScripts(new ScriptStub('S4'))),
-        ];
-        // act
-        const sut = new Application(createInformation(), categories);
-        // assert
-        expect(sut.totalScripts).to.equal(4);
+    describe('totalScripts', () => {
+        it('returns total of initial scripts', () => {
+            // arrange
+            const categories = [
+                new CategoryStub(1).withScripts(
+                    new ScriptStub('S1').withLevel(RecommendationLevel.Standard)),
+                new CategoryStub(2).withScripts(
+                    new ScriptStub('S2'),
+                    new ScriptStub('S3').withLevel(RecommendationLevel.Strict)),
+                new CategoryStub(3).withCategories(
+                    new CategoryStub(4).withScripts(new ScriptStub('S4'))),
+            ];
+            // act
+            const sut = new Application(createInformation(), categories);
+            // assert
+            expect(sut.totalScripts).to.equal(4);
+        });
    });
-    it('totalCategories counts right', () => {
-        // arrange
-        const categories = [
-            new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true)),
-            new CategoryStub(2).withScripts(new ScriptStub('S2'), new ScriptStub('S3')),
-            new CategoryStub(3).withCategories(new CategoryStub(4).withScripts(new ScriptStub('S4'))),
-        ];
-        // act
-        const sut = new Application(createInformation(), categories);
-        // assert
-        expect(sut.totalCategories).to.equal(4);
+    describe('totalCategories', () => {
+        it('returns total of initial categories', () => {
+            // arrange
+            const categories = [
+                new CategoryStub(1).withScripts(new ScriptStub('S1').withLevel(RecommendationLevel.Strict)),
+                new CategoryStub(2).withScripts(new ScriptStub('S2'), new ScriptStub('S3')),
+                new CategoryStub(3).withCategories(new CategoryStub(4).withScripts(new ScriptStub('S4'))),
+            ];
+            // act
+            const sut = new Application(createInformation(), categories);
+            // assert
+            expect(sut.totalCategories).to.equal(4);
+        });
    });
-    it('sets information as expected', () => {
-        // arrange
-        const expected = createInformation();
-        // act
-        const sut = new Application(
-            expected,
-            [new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true))]);
-        // assert
-        expect(sut.info).to.deep.equal(expected);
+    describe('info', () => {
+        it('returns initial information', () => {
+            // arrange
+            const expected = createInformation();
+            // act
+            const sut = new Application(
+                expected, [ getCategoryForValidApplication() ]);
+            // assert
+            expect(sut.info).to.deep.equal(expected);
+        });
    });
 });

+function getCategoryForValidApplication() {
+    return new CategoryStub(1).withScripts(
+        new ScriptStub('S1').withLevel(RecommendationLevel.Standard),
+        new ScriptStub('S2').withLevel(RecommendationLevel.Strict));
+}
+
 function createInformation(): IProjectInformation {
    return new ProjectInformation('name', 'repo', '0.1.0', 'homepage');
 }
--- a/tests/unit/domain/Category.spec.ts
+++ b/tests/unit/domain/Category.spec.ts
@@ -86,4 +86,41 @@ describe('Category', () => {
            expect(actualIds).to.have.deep.members(expectedScriptIds);
        });
    });
+    describe('includes', () => {
+        it('return false when does not include', () => {
+            // assert
+            const script = new ScriptStub('3');
+            const sut = new Category(0, 'category', [], [new CategoryStub(33).withScriptIds('1', '2')], []);
+            // act
+            const actual = sut.includes(script);
+            // assert
+            expect(actual).to.equal(false);
+        });
+        it('return true when includes as subscript', () => {
+            // assert
+            const script = new ScriptStub('3');
+            const sut = new Category(0, 'category', [], [
+                new CategoryStub(33).withScript(script).withScriptIds('non-related'),
+            ], []);
+            // act
+            const actual = sut.includes(script);
+            // assert
+            expect(actual).to.equal(true);
+        });
+        it('return true when includes as nested category script', () => {
+            // assert
+            const script = new ScriptStub('3');
+            const sut = new Category(11, 'category', [],
+                [
+                    new CategoryStub(22)
+                        .withScriptIds('non-relatedd')
+                        .withCategory(new CategoryStub(33).withScript(script)),
+                ],
+            []);
+            // act
+            const actual = sut.includes(script);
+            // assert
+            expect(actual).to.equal(true);
+        });
+    });
 });
--- a/tests/unit/domain/RecommendationLevel.ts
+++ b/tests/unit/domain/RecommendationLevel.ts
@@ -0,0 +1,17 @@
+import 'mocha';
+import { expect } from 'chai';
+import { RecommendationLevelNames, RecommendationLevel } from '@/domain/RecommendationLevel';
+
+describe('RecommendationLevel', () => {
+    describe('RecommendationLevelNames', () => {
+        // arrange
+        const expected = [
+            RecommendationLevel[RecommendationLevel.Strict],
+            RecommendationLevel[RecommendationLevel.Standard],
+        ];
+        // act
+        const actual = RecommendationLevelNames;
+        // assert
+        expect(actual).to.have.deep.members(expected);
+    });
+});
--- a/tests/unit/domain/Script.spec.ts
+++ b/tests/unit/domain/Script.spec.ts
@@ -1,46 +1,149 @@
 import 'mocha';
 import { expect } from 'chai';
 import { Script } from '@/domain/Script';
+import { RecommendationLevel, RecommendationLevels } from '@/domain/RecommendationLevel';
+import { ScriptCode } from '@/domain/ScriptCode';
+import { IScriptCode } from '@/domain/IScriptCode';

 describe('Script', () => {
    describe('ctor', () => {
-        describe('code', () => {
-            it('cannot construct with duplicate lines', () => {
-                const code = 'duplicate\nduplicate\ntest\nduplicate';
-                expect(() => createWithCode(code)).to.throw();
+        describe('scriptCode', () => {
+            it('sets as expected', () => {
+                // arrange
+                const name = 'test-script';
+                const expected = new ScriptCode(name, 'expected-execute', 'expected-revert');
+                const sut = new ScriptBuilder()
+                    .withCode(expected)
+                    .build();
+                // act
+                const actual = sut.code;
+                // assert
+                expect(actual).to.deep.equal(expected);
            });
-            it('cannot construct with empty lines', () => {
-                const code = 'duplicate\n\n\ntest\nduplicate';
-                expect(() => createWithCode(code)).to.throw();
-            });
-        });
-        describe('revertCode', () => {
-            it('cannot construct with duplicate lines', () => {
-                const code = 'duplicate\nduplicate\ntest\nduplicate';
-                expect(() => createWithCode('REM', code)).to.throw();
-            });
-            it('cannot construct with empty lines', () => {
-                const code = 'duplicate\n\n\ntest\nduplicate';
-                expect(() => createWithCode('REM', code)).to.throw();
-            });
-            it('cannot construct with when same as code', () => {
-                const code = 'REM';
-                expect(() => createWithCode(code, code)).to.throw();
+            it('throws if undefined', () => {
+                // arrange
+                const name = 'script-name';
+                const expectedError = `undefined code (script: ${name})`;
+                const code: IScriptCode = undefined;
+                // act
+                const construct = () => new ScriptBuilder()
+                    .withName(name)
+                    .withCode(code)
+                    .build();
+                // assert
+                expect(construct).to.throw(expectedError);
            });
        });
        describe('canRevert', () => {
            it('returns false without revert code', () => {
-                const sut = createWithCode('code');
-                expect(sut.canRevert()).to.equal(false);
+                // arrange
+                const sut = new ScriptBuilder()
+                    .withCodes('code')
+                    .build();
+                // act
+                const actual = sut.canRevert();
+                // assert
+                expect(actual).to.equal(false);
            });
            it('returns true with revert code', () => {
-                const sut = createWithCode('code', 'non empty revert code');
-                expect(sut.canRevert()).to.equal(true);
+                // arrange
+                const sut = new ScriptBuilder()
+                    .withCodes('code', 'non empty revert code')
+                    .build();
+                // act
+                const actual = sut.canRevert();
+                // assert
+                expect(actual).to.equal(true);
+            });
+        });
+        describe('level', () => {
+            it('cannot construct with invalid wrong value', () => {
+                // arrange
+                const invalidValue: RecommendationLevel = 55;
+                const expectedError = 'invalid level';
+                // act
+                const construct = () => new ScriptBuilder()
+                    .withRecommendationLevel(invalidValue)
+                    .build();
+                // assert
+                expect(construct).to.throw(expectedError);
+            });
+            it('sets undefined as expected', () => {
+                // arrange
+                const expected = undefined;
+                // act
+                const sut = new ScriptBuilder()
+                    .withRecommendationLevel(expected)
+                    .build();
+                // assert
+                expect(sut.level).to.equal(expected);
+            });
+            it('sets as expected', () => {
+                // arrange
+                for (const expected of RecommendationLevels) {
+                    // act
+                    const sut = new ScriptBuilder()
+                        .withRecommendationLevel(expected)
+                        .build();
+                    // assert
+                    const actual = sut.level;
+                    expect(actual).to.equal(expected);
+                }
+            });
+        });
+        describe('documentationUrls', () => {
+            it('sets as expected', () => {
+                // arrange
+                const expected = [ 'doc1', 'doc2 '];
+                // act
+                const sut = new ScriptBuilder()
+                    .withDocumentationUrls(expected)
+                    .build();
+                const actual = sut.documentationUrls;
+                // assert
+                expect(actual).to.equal(expected);
            });
        });
    });
 });

-function createWithCode(code: string, revertCode?: string): Script {
-    return new Script('name', code, revertCode, [], false);
+class ScriptBuilder {
+    private name = 'test-script';
+    private code: IScriptCode = new ScriptCode(this.name, 'code', 'revert-code');
+    private level = RecommendationLevel.Standard;
+    private documentationUrls: readonly string[] = undefined;
+
+    public withCodes(code: string, revertCode = ''): ScriptBuilder {
+        this.code = new ScriptCode(this.name, code, revertCode);
+        return this;
+    }
+
+    public withCode(code: IScriptCode): ScriptBuilder {
+        this.code = code;
+        return this;
+    }
+
+    public withName(name: string): ScriptBuilder {
+        this.name = name;
+        return this;
+    }
+
+    public withRecommendationLevel(level: RecommendationLevel): ScriptBuilder {
+        this.level = level;
+        return this;
+    }
+
+    public withDocumentationUrls(urls: readonly string[]): ScriptBuilder {
+        this.documentationUrls = urls;
+        return this;
+    }
+
+    public build(): Script {
+        return new Script(
+            this.name,
+            this.code,
+            this.documentationUrls,
+            this.level,
+        );
+    }
 }
--- a/tests/unit/domain/ScriptCode.spec.ts
+++ b/tests/unit/domain/ScriptCode.spec.ts
@@ -0,0 +1,93 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ScriptCode } from '@/domain/ScriptCode';
+
+describe('ScriptCode', () => {
+    describe('scriptName', () => {
+        it('throws if undefined', () => {
+            // arrange
+            const expectedError = 'name is undefined';
+            const name = undefined;
+            // act
+            const act = () => new ScriptCode(name, 'non-empty-code', '');
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+    });
+    describe('code', () => {
+        it('cannot construct with duplicate lines', () => {
+            // arrange
+            const code = 'duplicate\nduplicate\ntest\nduplicate';
+            // act
+            const act = () => createSut(code);
+            // assert
+            expect(act).to.throw();
+        });
+        it('cannot construct with empty lines', () => {
+            // arrange
+            const code = 'line1\n\n\nline2';
+            // act
+            const act = () => createSut(code);
+            // assert
+            expect(act).to.throw();
+        });
+        it('cannot construct with empty or undefined values', () => {
+            // arrange
+            const name = 'test-code';
+            const errorMessage = `code of ${name} is empty or undefined`;
+            const invalidValues = [ '', undefined ];
+            invalidValues.forEach((invalidValue) => {
+                // act
+                const act = () => new ScriptCode(name, invalidValue, '');
+                // assert
+                expect(act).to.throw(errorMessage);
+            });
+        });
+        it('sets as expected', () => {
+            // arrange
+            const expected = 'expected-revert';
+            // act
+            const sut = createSut(expected);
+            // assert
+            expect(sut.execute).to.equal(expected);
+        });
+    });
+    describe('revert', () => {
+        it('cannot construct with duplicate lines', () => {
+            // arrange
+            const code = 'duplicate\nduplicate\ntest\nduplicate';
+            // act
+            const act = () => createSut('REM', code);
+            // assert
+            expect(act).to.throw();
+        });
+        it('cannot construct with empty lines', () => {
+            // arrange
+            const code = 'line1\n\n\nline2';
+            // act
+            const act = () => createSut('REM', code);
+            // assert
+            expect(act).to.throw();
+        });
+        it('cannot construct with when same as code', () => {
+            // arrange
+            const code = 'REM';
+            // act
+            const act = () => createSut(code, code);
+            // assert
+            expect(act).to.throw();
+        });
+        it('sets as expected', () => {
+            // arrange
+            const expected = 'expected-revert';
+            // act
+            const sut = createSut('abc', expected);
+            // assert
+            expect(sut.revert).to.equal(expected);
+        });
+    });
+});
+
+function createSut(code: string, revert = ''): ScriptCode {
+    return new ScriptCode('test-code', code, revert);
+}
--- a/tests/unit/presentation/Scripts/ScriptsTree/ScriptNodeParser.spec.ts
+++ b/tests/unit/presentation/Scripts/ScriptsTree/ScriptNodeParser.spec.ts
@@ -3,11 +3,11 @@ import { expect } from 'chai';
 import { getScriptNodeId, getScriptId, getCategoryNodeId, getCategoryId } from '@/presentation/Scripts/ScriptsTree/ScriptNodeParser';
 import { CategoryStub } from '../../../stubs/CategoryStub';
 import { ScriptStub } from '../../../stubs/ScriptStub';
-import { parseSingleCategory, parseAllCategories } from '../../../../../src/presentation/Scripts/ScriptsTree/ScriptNodeParser';
+import { parseSingleCategory, parseAllCategories } from '@/presentation/Scripts/ScriptsTree/ScriptNodeParser';
 import { ApplicationStub } from '../../../stubs/ApplicationStub';
-import { INode, NodeType } from '../../../../../src/presentation/Scripts/ScriptsTree/SelectableTree/Node/INode';
-import { IScript } from '../../../../../src/domain/IScript';
-import { ICategory } from '../../../../../src/domain/ICategory';
+import { INode, NodeType } from '@/presentation/Scripts/ScriptsTree/SelectableTree/Node/INode';
+import { IScript } from '@/domain/IScript';
+import { ICategory } from '@/domain/ICategory';

 describe('ScriptNodeParser', () => {
    it('can convert script id and back', () => {
@@ -80,7 +80,7 @@ describe('ScriptNodeParser', () => {

 function isReversible(category: ICategory): boolean {
    if (category.scripts) {
-        return category.scripts.every((s) => s.revertCode);
+        return category.scripts.every((s) => s.canRevert());
    }
    return category.subCategories.every((c) => isReversible(c));
 }
@@ -100,8 +100,8 @@ function expectSameCategory(node: INode, category: ICategory): void {
    }
    function getErrorMessage(field: string) {
        return  `Unexpected node field: ${field}.\n` +
-                `\nActual node:\n${JSON.stringify(node, null, 2)}` +
-                `\nExpected category:\n${JSON.stringify(category, null, 2)}`;
+                `\nActual node:\n${print(node)}` +
+                `\nExpected category:\n${print(category)}`;
    }
 }

@@ -110,11 +110,15 @@ function expectSameScript(node: INode, script: IScript): void {
    expect(node.id).to.equal(getScriptNodeId(script), getErrorMessage('id'));
    expect(node.documentationUrls).to.equal(script.documentationUrls, getErrorMessage('documentationUrls'));
    expect(node.text).to.equal(script.name, getErrorMessage('name'));
-    expect(node.isReversible).to.equal(!!script.revertCode, getErrorMessage('revertCode'));
+    expect(node.isReversible).to.equal(script.canRevert(), getErrorMessage('canRevert'));
    expect(node.children).to.equal(undefined);
    function getErrorMessage(field: string) {
        return  `Unexpected node field: ${field}.` +
-                `\nActual node:\n${JSON.stringify(node, null, 2)}\n` +
-                `\nExpected script:\n${JSON.stringify(script, null, 2)}`;
+                `\nActual node:\n${print(node)}\n` +
+                `\nExpected script:\n${print(script)}`;
    }
 }
+
+function print(object: any) {
+    return JSON.stringify(object, null, 2);
+}
--- a/tests/unit/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/NodeWrapper/NodeStateUpdater.spec.ts
+++ b/tests/unit/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/NodeWrapper/NodeStateUpdater.spec.ts
@@ -4,199 +4,200 @@ import { ILiquorTreeNode } from 'liquor-tree';
 import { NodeType } from '@/presentation/Scripts/ScriptsTree/SelectableTree/Node/INode';
 import { getNewState } from '@/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/NodeWrapper/NodeStateUpdater';

-describe('getNewState', () => {
-    describe('checked', () => {
-        describe('script node', () => {
-            it('true when selected', () => {
-                // arrange
-                const node = getScriptNode();
-                const selectedScriptNodeIds = [ 'a', 'b', node.id, 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.checked).to.equal(true);
+describe('NodeStateUpdater', () => {
+    describe('getNewState', () => {
+        describe('checked', () => {
+            describe('script node', () => {
+                it('true when selected', () => {
+                    // arrange
+                    const node = getScriptNode();
+                    const selectedScriptNodeIds = [ 'a', 'b', node.id, 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.checked).to.equal(true);
+                });
+                it('false when unselected', () => {
+                    // arrange
+                    const node = getScriptNode();
+                    const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.checked).to.equal(false);
+                });
            });
-            it('false when unselected', () => {
-                // arrange
-                const node = getScriptNode();
-                const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.checked).to.equal(false);
+            describe('category node', () => {
+                it('true when every child selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {   id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {   id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.checked).to.equal(true);
+                });
+                it('false when none of the children is selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {   id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {   id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'none', 'of', 'them', 'are', 'selected' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.checked).to.equal(false);
+                });
+                it('false when some of the children is selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {
+                                id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {
+                                id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'a', 'c', 'unrelated' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.checked).to.equal(false);
+                });
            });
        });
-        describe('category node', () => {
-            it('true when every child selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {   id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {   id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.checked).to.equal(true);
+        describe('indeterminate', () => {
+            describe('script node', () => {
+                it('false when selected', () => {
+                    // arrange
+                    const node = getScriptNode();
+                    const selectedScriptNodeIds = [ 'a', 'b', node.id, 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.indeterminate).to.equal(false);
+                });
+                it('false when not selected', () => {
+                    // arrange
+                    const node = getScriptNode();
+                    const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.indeterminate).to.equal(false);
+                });
            });
-            it('false when none of the children is selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {   id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {   id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'none', 'of', 'them', 'are', 'selected' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.checked).to.equal(false);
-            });
-            it('false when some of the children is selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {
-                            id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {
-                            id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'a', 'c', 'unrelated' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.checked).to.equal(false);
-            });
-        });
-    });
-    describe('indeterminate', () => {
-        describe('script node', () => {
-            it('false when selected', () => {
-                // arrange
-                const node = getScriptNode();
-                const selectedScriptNodeIds = [ 'a', 'b', node.id, 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.indeterminate).to.equal(false);
-            });
-            it('false when not selected', () => {
-                // arrange
-                const node = getScriptNode();
-                const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.indeterminate).to.equal(false);
-            });
-        });
-        describe('category node', () => {
-            it('false when all children are selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {   id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {   id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.indeterminate).to.equal(false);
-            });
-            it('true when all some are selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {   id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {   id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'a' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.indeterminate).to.equal(true);
-            });
-            it('false when no children are selected', () => {
-                // arrange
-                const node = {
-                    id: '1',
-                    data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                    children: [
-                        {   id: '2',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('a'), getScriptNode('b') ],
-                        },
-                        {   id: '3',
-                            data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
-                            children: [ getScriptNode('c') ],
-                        },
-                    ],
-                };
-                const selectedScriptNodeIds = [ 'none', 'of', 'them', 'are', 'selected' ];
-                // act
-                const state = getNewState(node, selectedScriptNodeIds);
-                // assert
-                expect(state.indeterminate).to.equal(false);
+            describe('category node', () => {
+                it('false when all children are selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {   id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {   id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'a', 'b', 'c' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.indeterminate).to.equal(false);
+                });
+                it('true when all some are selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {   id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {   id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'a' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.indeterminate).to.equal(true);
+                });
+                it('false when no children are selected', () => {
+                    // arrange
+                    const node = {
+                        id: '1',
+                        data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                        children: [
+                            {   id: '2',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('a'), getScriptNode('b') ],
+                            },
+                            {   id: '3',
+                                data: { type: NodeType.Category, documentationUrls: [], isReversible: false },
+                                children: [ getScriptNode('c') ],
+                            },
+                        ],
+                    };
+                    const selectedScriptNodeIds = [ 'none', 'of', 'them', 'are', 'selected' ];
+                    // act
+                    const state = getNewState(node, selectedScriptNodeIds);
+                    // assert
+                    expect(state.indeterminate).to.equal(false);
+                });
            });
        });
    });
+    function getScriptNode(scriptNodeId: string = 'script'): ILiquorTreeNode {
+        return {
+            id: scriptNodeId,
+            data: {
+                type: NodeType.Script,
+                documentationUrls: [],
+                isReversible: false,
+            },
+            children: [],
+        };
+    }
 });
-
-function getScriptNode(scriptNodeId: string = 'script'): ILiquorTreeNode {
-    return {
-        id: scriptNodeId,
-        data: {
-            type: NodeType.Script,
-            documentationUrls: [],
-            isReversible: false,
-        },
-        children: [],
-    };
-}
--- a/tests/unit/presentation/Scripts/ScriptsTree/SelectableTree/Node/Reverter/ScriptReverter.spec.ts
+++ b/tests/unit/presentation/Scripts/ScriptsTree/SelectableTree/Node/Reverter/ScriptReverter.spec.ts
@@ -4,7 +4,7 @@ import { ScriptReverter } from '@/presentation/Scripts/ScriptsTree/SelectableTre
 import { SelectedScriptStub } from '../../../../../../stubs/SelectedScriptStub';
 import { getScriptNodeId } from '@/presentation/Scripts/ScriptsTree/ScriptNodeParser';
 import { ScriptStub } from '../../../../../../stubs/ScriptStub';
-import { UserSelection } from '../../../../../../../../src/application/State/Selection/UserSelection';
+import { UserSelection } from '@/application/State/Selection/UserSelection';
 import { SelectedScript } from '@/application/State/Selection/SelectedScript';
 import { ApplicationStub } from '../../../../../../stubs/ApplicationStub';
 import { CategoryStub } from '../../../../../../stubs/CategoryStub';
--- a/tests/unit/stubs/ApplicationStub.ts
+++ b/tests/unit/stubs/ApplicationStub.ts
@@ -15,8 +15,8 @@ export class ApplicationStub implements IApplication {
        return this.getAllCategories().find(
            (category) => category.id === categoryId);
    }
-    public getRecommendedScripts(): readonly IScript[] {
-        throw new Error('Method not implemented: getRecommendedScripts');
+    public getScriptsByLevel(): readonly IScript[] {
+        throw new Error('Method not implemented: getScriptsByLevel');
    }
    public findScript(scriptId: string): IScript {
        return this.getAllScripts().find((script) => scriptId === script.id);
--- a/tests/unit/stubs/CategoryStub.ts
+++ b/tests/unit/stubs/CategoryStub.ts
@@ -12,6 +12,10 @@ export class CategoryStub extends BaseEntity<number> implements ICategory  {
        super(id);
    }

+    public includes(script: IScript): boolean {
+        return this.getAllScriptsRecursively().some((s) => s.id === script.id);
+    }
+
    public getAllScriptsRecursively(): readonly IScript[] {
        return [
            ...this.scripts,
--- a/tests/unit/stubs/ScriptCompilerStub.ts
+++ b/tests/unit/stubs/ScriptCompilerStub.ts
@@ -0,0 +1,18 @@
+import { IScriptCompiler } from '@/application/Parser/Compiler/IScriptCompiler';
+import { IScriptCode } from '@/domain/IScriptCode';
+import { YamlScript } from 'js-yaml-loader!./application.yaml';
+
+export class ScriptCompilerStub implements IScriptCompiler {
+    public compilables = new Map<YamlScript, IScriptCode>();
+    public canCompile(script: YamlScript): boolean {
+        return this.compilables.has(script);
+    }
+    public compile(script: YamlScript): IScriptCode {
+        return this.compilables.get(script);
+    }
+    public withCompileAbility(script: YamlScript, result?: IScriptCode): ScriptCompilerStub {
+        this.compilables.set(script, result ||
+            { execute: `compiled code of ${script.name}`, revert: `compiled revert code of ${script.name}` });
+        return this;
+    }
+}
--- a/tests/unit/stubs/ScriptStub.ts
+++ b/tests/unit/stubs/ScriptStub.ts
@@ -1,34 +1,41 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { IScript } from '@/domain/IScript';
+import { RecommendationLevel } from '@/domain/RecommendationLevel';

 export class ScriptStub extends BaseEntity<string> implements IScript {
    public name = `name${this.id}`;
-    public code = `REM code${this.id}`;
-    public revertCode = `REM revertCode${this.id}`;
+    public code = {
+        execute: `REM execute-code (${this.id})`,
+        revert: `REM revert-code (${this.id})`,
+    };
    public readonly documentationUrls = new Array<string>();
-    public isRecommended = true;
+    public level = RecommendationLevel.Standard;

    constructor(public readonly id: string) {
        super(id);
    }
+
    public canRevert(): boolean {
-        return Boolean(this.revertCode);
+        return Boolean(this.code.revert);
    }

-    public withIsRecommended(value: boolean): ScriptStub {
-        this.isRecommended = value;
+    public withLevel(value: RecommendationLevel): ScriptStub {
+        this.level = value;
        return this;
    }
+
    public withCode(value: string): ScriptStub {
-        this.code = value;
+        this.code.execute = value;
        return this;
    }
+
    public withName(name: string): ScriptStub {
        this.name = name;
        return this;
    }
+
    public withRevertCode(revertCode: string): ScriptStub {
-        this.revertCode = revertCode;
+        this.code.revert = revertCode;
        return this;
    }
 }
--- a/tests/unit/stubs/YamlScriptStub.ts
+++ b/tests/unit/stubs/YamlScriptStub.ts
@@ -0,0 +1,61 @@
+import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { ScriptFunctionCall, YamlScript } from 'js-yaml-loader!./application.yaml';
+
+export class YamlScriptStub implements YamlScript {
+    public static createWithCode(): YamlScriptStub {
+        return new YamlScriptStub()
+            .withCode('stub-code')
+            .withRevertCode('stub-revert-code');
+    }
+    public static createWithCall(call?: ScriptFunctionCall): YamlScriptStub {
+        let instance = new YamlScriptStub();
+        if (call) {
+            instance = instance.withCall(call);
+        } else {
+            instance = instance.withMockCall();
+        }
+        return instance;
+    }
+    public static createWithoutCallOrCodes(): YamlScriptStub {
+        return new YamlScriptStub();
+    }
+
+    public name = 'valid-name';
+    public code = undefined;
+    public revertCode = undefined;
+    public call = undefined;
+    public recommend = RecommendationLevel[RecommendationLevel.Standard].toLowerCase();
+    public docs = ['hello.com'];
+
+    private constructor() { }
+
+    public withName(name: string): YamlScriptStub {
+        this.name = name;
+        return this;
+    }
+
+    public withDocs(docs: string[]): YamlScriptStub {
+        this.docs = docs;
+        return this;
+    }
+
+    public withCode(code: string): YamlScriptStub {
+        this.code = code;
+        return this;
+    }
+
+    public withRevertCode(revertCode: string): YamlScriptStub {
+        this.revertCode = revertCode;
+        return this;
+    }
+
+    public withMockCall(): YamlScriptStub {
+        this.call = { function: 'func', parameters: [] };
+        return this;
+    }
+
+    public withCall(call: ScriptFunctionCall): YamlScriptStub {
+        this.call = call;
+        return this;
+    }
+}
Author	SHA1	Message	Date
undergroundwires	ab7d617886	replace deprecated github ::set-env command	2020-11-16 19:37:28 +01:00
undergroundwires	b247b12c3f	move Microsoft.Appconnector to right category	2020-11-16 18:38:00 +01:00
undergroundwires	c26bc209eb	fix errors when file already exists	2020-11-14 19:55:37 +01:00
undergroundwires	ad1872e7cd	fix not being able to rename paths including brackets	2020-11-14 19:55:37 +01:00
undergroundwires	29c7704e0b	unrecommend some system apps and document more	2020-11-14 19:51:21 +01:00
undergroundwires	e41e40c5bf	fix wrong app names caused by wrong Microsoft docs	2020-11-11 16:18:35 +01:00
undergroundwires	31e08d231d	fix not being able to uninstall system apps	2020-11-10 17:15:53 +01:00
undergroundwires	45b8dd972b	refactor unused imports	2020-11-08 15:33:31 +01:00
undergroundwires	4e72673373	fix reinstalling store apps by searching appx for all users	2020-11-07 14:03:08 +01:00
undergroundwires	92c3dd9232	fix clearing jump lists causing os to break and user pin removal #37	2020-11-07 14:01:02 +01:00
undergroundwires	2c5ab3ea7d	fix reinstalling store apps by searching appx for all users	2020-11-06 18:31:01 +01:00
undergroundwires	ffa279f3df	refactor removing bloatware to use functions #41	2020-11-05 20:27:18 +01:00
undergroundwires-bot	89dddfbb23	⬆️ bump everywhere to 0.8.0	2020-11-01 18:00:39 +00:00
undergroundwires	cfedcd724c	update screenshot	2020-11-01 18:55:40 +01:00
undergroundwires	fd28eaad06	hide scrollbars on code area when not overflowing	2020-11-01 18:49:27 +01:00
undergroundwires	8ce06facbd	add support for shared functions #41	2020-11-01 18:36:55 +01:00
undergroundwires	1a9db31c77	add all dist folders in gitignore because of files auto-generated by vscode	2020-11-01 01:53:27 +01:00
undergroundwires	ac70b063b8	rework disabling metadata retrieval	2020-10-28 22:32:05 +01:00
undergroundwires	d0019c2c9b	update recommendations to be safer and consistent	2020-10-27 16:41:56 +01:00
sopla4ever	4c68408f1e	add scripts to increase cryptography, enable camera notifications and remove todo app (#36 ) Co-authored-by: undergroundwires <undergroundwires@users.noreply.github.com>	2020-10-26 11:52:48 +01:00
undergroundwires	1072505219	show icons on cards during indeterminate and fully selected states	2020-10-25 12:55:40 +01:00
undergroundwires	07fc555324	change "download" button to "save" on desktop	2020-10-23 17:11:44 +01:00
undergroundwires	50fb29038a	switch places of download and copy buttons	2020-10-22 17:02:38 +01:00
Charles Zwicker	3785c623f8	Add GroupMe and Spotify removal option (#34 ) Co-authored-by: undergroundwires <undergroundwires@users.noreply.github.com> Co-authored-by: Charles Zwicker <czwicker54@gmail.com>	2020-10-20 16:51:30 +02:00
undergroundwires	14be3017c5	add support for different recommendation levels: strict and standard	2020-10-19 15:12:03 +01:00
undergroundwires-bot	978bab0b81	⬆️ bump everywhere to 0.7.6	2020-10-17 22:58:06 +00:00