Refactor to enforce strictNullChecks

This commit applies `strictNullChecks` to the entire codebase to improve
maintainability and type safety. Key changes include:

- Remove some explicit null-checks where unnecessary.
- Add necessary null-checks.
- Refactor static factory functions for a more functional approach.
- Improve some test names and contexts for better debugging.
- Add unit tests for any additional logic introduced.
- Refactor `createPositionFromRegexFullMatch` to its own function as the
  logic is reused.
- Prefer `find` prefix on functions that may return `undefined` and
  `get` prefix for those that always return a value.

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

@@ -1,7 +1,7 @@
 import { FunctionCall } from './Call/FunctionCall';
 
 import {
-  FunctionBodyType, IFunctionCode, ISharedFunction, ISharedFunctionBody,
+  FunctionBodyType, IFunctionCode, ISharedFunction, SharedFunctionBody,
 } from './ISharedFunction';
 import { IReadOnlyFunctionParameterCollection } from './Parameter/IFunctionParameterCollection';
 
@@ -10,7 +10,7 @@ export function createCallerFunction(
   parameters: IReadOnlyFunctionParameterCollection,
   callSequence: readonly FunctionCall[],
 ): ISharedFunction {
-  if (!callSequence || !callSequence.length) {
+  if (!callSequence.length) {
     throw new Error(`missing call sequence in function "${name}"`);
   }
   return new SharedFunction(name, parameters, callSequence, FunctionBodyType.Calls);
@@ -33,7 +33,7 @@ export function createFunctionWithInlineCode(
 }
 
 class SharedFunction implements ISharedFunction {
-  public readonly body: ISharedFunctionBody;
+  public readonly body: SharedFunctionBody;
 
   constructor(
     public readonly name: string,
@@ -42,11 +42,22 @@ class SharedFunction implements ISharedFunction {
     bodyType: FunctionBodyType,
   ) {
     if (!name) { throw new Error('missing function name'); }
-    if (!parameters) { throw new Error('missing parameters'); }
-    this.body = {
-      type: bodyType,
-      code: bodyType === FunctionBodyType.Code ? content as IFunctionCode : undefined,
-      calls: bodyType === FunctionBodyType.Calls ? content as readonly FunctionCall[] : undefined,
-    };
+
+    switch (bodyType) {
+      case FunctionBodyType.Code:
+        this.body = {
+          type: FunctionBodyType.Code,
+          code: content as IFunctionCode,
+        };
+        break;
+      case FunctionBodyType.Calls:
+        this.body = {
+          type: FunctionBodyType.Calls,
+          calls: content as readonly FunctionCall[],
+        };
+        break;
+      default:
+        throw new Error(`unknown body type: ${FunctionBodyType[bodyType]}`);
+    }
   }
 }