style: run prettier

src/interpreter/environment/create-sanitized-environment.ts

@@ -14,7 +14,7 @@ import {ProcessError} from "../error/policy-error/process-error/process-error.js
 import {isProcessSpawnChildOperation} from "../policy/process/is-process-spawn-child-operation.js";
 import type {ICreateSanitizedEnvironmentOptions} from "./i-create-sanitized-environment-options.js";
 import {isConsoleOperation} from "../policy/console/is-console-operation.js";
-import { EvaluationErrorIntent } from "../error/evaluation-error/evaluation-error-intent.js";
+import {EvaluationErrorIntent} from "../error/evaluation-error/evaluation-error-intent.js";
 
 /**
  * Creates an environment that provide hooks into policy checks
@@ -27,27 +27,27 @@ export function createSanitizedEnvironment({policy, env}: ICreateSanitizedEnviro
 		}
 
 		if (!policy.io.read && isIoRead(item)) {
-            return new EvaluationErrorIntent((node, options) => new IoError({...options, node, kind: "read"}));
+			return new EvaluationErrorIntent((node, options) => new IoError({...options, node, kind: "read"}));
 		}
 
 		if (!policy.io.write && isIoWrite(item)) {
-            return new EvaluationErrorIntent((node, options) => new IoError({...options, node, kind: "write"}));
+			return new EvaluationErrorIntent((node, options) => new IoError({...options, node, kind: "write"}));
 		}
 
 		if (!policy.process.exit && isProcessExitOperation(item)) {
-            return new EvaluationErrorIntent((node, options) => new ProcessError({...options, node, kind: "exit"}));
+			return new EvaluationErrorIntent((node, options) => new ProcessError({...options, node, kind: "exit"}));
 		}
 
 		if (!policy.process.exit && isProcessSpawnChildOperation(item)) {
-            return new EvaluationErrorIntent((node, options) => new ProcessError({...options, node, kind: "spawnChild"}));
+			return new EvaluationErrorIntent((node, options) => new ProcessError({...options, node, kind: "spawnChild"}));
 		}
 
 		if (!policy.network && isNetworkOperation(item)) {
-            return new EvaluationErrorIntent((node, options) => new NetworkError({...options, node, operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)}));
+			return new EvaluationErrorIntent((node, options) => new NetworkError({...options, node, operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)}));
 		}
 
 		if (policy.deterministic && isNonDeterministic(item)) {
-            return new EvaluationErrorIntent((node, options) => new NonDeterministicError({...options, node, operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)}));
+			return new EvaluationErrorIntent((node, options) => new NonDeterministicError({...options, node, operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)}));
 		}
 
 		return true;

src/interpreter/error/evaluation-error/evaluation-error.ts

@@ -1,6 +1,6 @@
 import type {IEvaluationErrorOptions} from "./i-evaluation-error-options.js";
 import type {TS} from "../../../type/ts.js";
-import type { LexicalEnvironment } from "../../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../../lexical-environment/lexical-environment.js";
 
 export type ThrowError = (error: EvaluationError) => EvaluationError;
 
@@ -22,6 +22,6 @@ export class EvaluationError extends Error {
 	}
 }
 
-export function isEvaluationError (item: unknown): item is EvaluationError {
+export function isEvaluationError(item: unknown): item is EvaluationError {
 	return typeof item === "object" && item != null && item instanceof EvaluationError;
-}
+}

src/interpreter/error/evaluation-error/i-evaluation-error-options.ts

@@ -1,5 +1,5 @@
 import type {TS} from "../../../type/ts.js";
-import type { LexicalEnvironment } from "../../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../../lexical-environment/lexical-environment.js";
 
 export interface IEvaluationErrorOptions {
 	node: TS.Node;

src/interpreter/error/not-callable-error/not-callable-error.ts

@@ -1,7 +1,7 @@
 import {EvaluationError} from "../evaluation-error/evaluation-error.js";
 import type {INotCallableErrorOptions} from "./i-not-callable-error-options.js";
 import type {Literal} from "../../literal/literal.js";
-import { stringifyLiteral} from "../../literal/literal.js";
+import {stringifyLiteral} from "../../literal/literal.js";
 
 /**
  * An Error that can be thrown when a value is attempted to be called, but isn't callable

src/interpreter/evaluate.ts

@@ -10,7 +10,7 @@ import {createStatementTraversalStack} from "./stack/traversal-stack/statement-t
 import {isExpression} from "./util/expression/is-expression.js";
 import type {Literal} from "./literal/literal.js";
 import {isStatement} from "./util/statement/is-statement.js";
-import type { Stack} from "./stack/stack.js";
+import type {Stack} from "./stack/stack.js";
 import {createStack} from "./stack/stack.js";
 import {isDeclaration} from "./util/declaration/is-declaration.js";
 import {UnexpectedNodeError} from "./error/unexpected-node-error/unexpected-node-error.js";
@@ -19,7 +19,7 @@ import {reportError} from "./util/reporting/report-error.js";
 import {createReportedErrorSet} from "./reporting/reported-error-set.js";
 import type {ReportingOptionsSanitized} from "./reporting/i-reporting-options.js";
 import type {EvaluationError, ThrowError} from "./error/evaluation-error/evaluation-error.js";
-import type { ICreateNodeEvaluatorOptions } from "./evaluator/node-evaluator/i-create-node-evaluator-options.js";
+import type {ICreateNodeEvaluatorOptions} from "./evaluator/node-evaluator/i-create-node-evaluator-options.js";
 /**
  * Will get a literal value for the given Expression, ExpressionStatement, or Declaration.
  */

src/interpreter/evaluator/evaluate-arrow-function-expression.ts

@@ -1,5 +1,5 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
-import type { LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {getFromLexicalEnvironment, pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {Literal} from "../literal/literal.js";

src/interpreter/evaluator/evaluate-block.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
-import { pathInLexicalEnvironmentEquals} from "../lexical-environment/lexical-environment.js";
+import {pathInLexicalEnvironmentEquals} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import {BREAK_SYMBOL} from "../util/break/break-symbol.js";
 import {CONTINUE_SYMBOL} from "../util/continue/continue-symbol.js";

src/interpreter/evaluator/evaluate-call-expression.ts

@@ -1,5 +1,5 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
-import type { Literal} from "../literal/literal.js";
+import type {Literal} from "../literal/literal.js";
 import {isLazyCall} from "../literal/literal.js";
 import {NotCallableError} from "../error/not-callable-error/not-callable-error.js";
 import {getFromLexicalEnvironment} from "../lexical-environment/lexical-environment.js";

src/interpreter/evaluator/evaluate-constructor-declaration.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
-import { pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import {pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {IndexLiteral, Literal} from "../literal/literal.js";
 import {evaluateParameterDeclarations} from "./evaluate-parameter-declarations.js";

src/interpreter/evaluator/evaluate-decorator.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {IndexLiteral} from "../literal/literal.js";
-import { stringifyLiteral} from "../literal/literal.js";
+import {stringifyLiteral} from "../literal/literal.js";
 import {NotCallableError} from "../error/not-callable-error/not-callable-error.js";
 import type {TS} from "../../type/ts.js";
 import {__decorate, __param} from "../util/tslib/tslib-util.js";

src/interpreter/evaluator/evaluate-element-access-expression.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {IndexLiteral, IndexLiteralKey, LazyCall, Literal} from "../literal/literal.js";
-import { LAZY_CALL_FLAG, LiteralFlagKind} from "../literal/literal.js";
+import {LAZY_CALL_FLAG, LiteralFlagKind} from "../literal/literal.js";
 import {isBindCallApply} from "../util/function/is-bind-call-apply.js";
 import type {TS} from "../../type/ts.js";
 import {maybeThrow} from "../error/evaluation-error/evaluation-error-intent.js";

src/interpreter/evaluator/evaluate-function-declaration.ts

@@ -1,5 +1,5 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
-import type { LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {getFromLexicalEnvironment, pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {Literal} from "../literal/literal.js";

src/interpreter/evaluator/evaluate-function-expression.ts

@@ -1,5 +1,5 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
-import type { LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {getFromLexicalEnvironment, pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {Literal} from "../literal/literal.js";

src/interpreter/evaluator/evaluate-get-accessor-declaration.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
-import { pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import {pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {IndexLiteral, IndexLiteralKey, Literal} from "../literal/literal.js";
 import {THIS_SYMBOL} from "../util/this/this-symbol.js";

src/interpreter/evaluator/evaluate-method-declaration.ts

@@ -1,5 +1,5 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
-import type { LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {getFromLexicalEnvironment, pathInLexicalEnvironmentEquals, setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {IndexLiteral, IndexLiteralKey, Literal} from "../literal/literal.js";

src/interpreter/evaluator/evaluate-property-access-expression.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {IndexLiteral, LazyCall, Literal} from "../literal/literal.js";
-import { LAZY_CALL_FLAG, LiteralFlagKind} from "../literal/literal.js";
+import {LAZY_CALL_FLAG, LiteralFlagKind} from "../literal/literal.js";
 import {isBindCallApply} from "../util/function/is-bind-call-apply.js";
 import type {TS} from "../../type/ts.js";
 import {maybeThrow} from "../error/evaluation-error/evaluation-error-intent.js";

src/interpreter/evaluator/evaluate-property-declaration.ts

@@ -2,7 +2,7 @@ import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {IndexLiteral, IndexLiteralKey} from "../literal/literal.js";
 import {inStaticContext} from "../util/static/in-static-context.js";
 import type {TS} from "../../type/ts.js";
-import { canHaveDecorators, getDecorators } from "../util/node/modifier-util.js";
+import {canHaveDecorators, getDecorators} from "../util/node/modifier-util.js";
 
 /**
  * Evaluates, or attempts to evaluate, a PropertyDeclaration, before applying it on the given parent

src/interpreter/evaluator/evaluate-set-accessor-declaration.ts

@@ -1,6 +1,6 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {LexicalEnvironment} from "../lexical-environment/lexical-environment.js";
-import { setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
+import {setInLexicalEnvironment} from "../lexical-environment/lexical-environment.js";
 import {cloneLexicalEnvironment} from "../lexical-environment/clone-lexical-environment.js";
 import type {IndexLiteral, IndexLiteralKey, Literal} from "../literal/literal.js";
 import {THIS_SYMBOL} from "../util/this/this-symbol.js";

src/interpreter/evaluator/evaluate-spread-assignment.ts

@@ -7,10 +7,10 @@ import type {TS} from "../../type/ts.js";
  */
 export function evaluateSpreadAssignment({node, evaluate, ...options}: EvaluatorOptions<TS.SpreadAssignment>, parent: IndexLiteral): void {
 	const entries = evaluate.expression(node.expression, options) as IndexLiteral;
-	
+
 	if (options.getCurrentError() != null) {
 		return;
 	}
-	
+
 	Object.assign(parent, entries);
 }

src/interpreter/evaluator/evaluate-throw-statement.ts

@@ -1,14 +1,14 @@
 import type {EvaluatorOptions} from "./evaluator-options.js";
 import type {TS} from "../../type/ts.js";
-import type { EvaluationError } from "../error/evaluation-error/evaluation-error.js";
+import type {EvaluationError} from "../error/evaluation-error/evaluation-error.js";
 
 /**
  * Evaluates, or attempts to evaluate, a ThrowStatement
  */
-export function evaluateThrowStatement({node, evaluate, ...options}: EvaluatorOptions<TS.ThrowStatement>): void|EvaluationError {
+export function evaluateThrowStatement({node, evaluate, ...options}: EvaluatorOptions<TS.ThrowStatement>): void | EvaluationError {
 	const {getCurrentError, throwError} = options;
 	const result = evaluate.expression(node.expression, options) as EvaluationError;
-	
+
 	if (getCurrentError() != null) {
 		return;
 	}

src/interpreter/evaluator/evaluate-variable-declaration.ts

@@ -27,10 +27,10 @@ export function evaluateVariableDeclaration(options: EvaluatorOptions<TS.Variabl
 
 	// Evaluate the binding name
 	evaluate.nodeWithArgument(node.name, initializerResult, options);
-	
+
 	if (getCurrentError() != null) {
 		return;
 	}
-	
+
 	stack.push(initializerResult);
 }

src/interpreter/evaluator/evaluator-options.ts

@@ -12,9 +12,8 @@ export interface NextEvaluatorOptions {
 	environment: LexicalEnvironment;
 	moduleOverrides?: Record<string, unknown>;
 	throwError: ThrowError;
-	getCurrentError (): EvaluationError|undefined;
+	getCurrentError(): EvaluationError | undefined;
 	statementTraversalStack: StatementTraversalStack;
-
 }
 
 export interface EvaluatorOptions<T extends TS.Node | TS.NodeArray<TS.Node>> extends NextEvaluatorOptions {

src/interpreter/evaluator/node-evaluator/create-node-evaluator.ts

@@ -10,8 +10,8 @@ import {evaluateNodeWithValue} from "../evaluate-node-with-value.js";
 import {createStatementTraversalStack} from "../../stack/traversal-stack/statement-traversal-stack.js";
 import type {TS} from "../../../type/ts.js";
 import type {EvaluationError} from "../../error/evaluation-error/evaluation-error.js";
-import { isEvaluationError} from "../../error/evaluation-error/evaluation-error.js";
-import type { Literal } from "../../literal/literal.js";
+import {isEvaluationError} from "../../error/evaluation-error/evaluation-error.js";
+import type {Literal} from "../../literal/literal.js";
 
 /**
  * Creates a Node Evaluator
@@ -50,7 +50,6 @@ export function createNodeEvaluator(options: ICreateNodeEvaluatorOptions): NodeE
 	};
 
 	const evaluate: NodeEvaluator = {
-
 		statement: (node, nextOptions): void => {
 			const combinedNextOptions = {...nextOptions, statementTraversalStack: createStatementTraversalStack()};
 			const prequalifyResult = prequalifyNextNode(node, combinedNextOptions);
@@ -73,14 +72,14 @@ export function createNodeEvaluator(options: ICreateNodeEvaluatorOptions): NodeE
 			}
 			return evaluateNodeWithArgument(getEvaluatorOptions(node, nextOptions), arg);
 		},
-		expression: (node, nextOptions): Literal|EvaluationError => {
+		expression: (node, nextOptions): Literal | EvaluationError => {
 			const prequalifyResult = prequalifyNextNode(node, nextOptions);
 			if (isEvaluationError(prequalifyResult)) {
 				return prequalifyResult;
 			}
 			return evaluateExpression(getEvaluatorOptions(node, nextOptions));
 		},
-		nodeWithValue: (node, nextOptions): Literal|EvaluationError => {
+		nodeWithValue: (node, nextOptions): Literal | EvaluationError => {
 			const prequalifyResult = prequalifyNextNode(node, nextOptions);
 			if (isEvaluationError(prequalifyResult)) {
 				return prequalifyResult;

src/interpreter/evaluator/node-evaluator/i-create-node-evaluator-options.ts

@@ -3,9 +3,9 @@ import type {Stack} from "../../stack/stack.js";
 import type {EvaluatePolicySanitized} from "../../policy/evaluate-policy.js";
 import type {ReportingOptionsSanitized} from "../../reporting/i-reporting-options.js";
 import type {TS} from "../../../type/ts.js";
-import type { EvaluationError, ThrowError } from "../../error/evaluation-error/evaluation-error.js";
-import type { LexicalEnvironment } from "../../lexical-environment/lexical-environment.js";
-import type { StatementTraversalStack } from "../../stack/traversal-stack/statement-traversal-stack.js";
+import type {EvaluationError, ThrowError} from "../../error/evaluation-error/evaluation-error.js";
+import type {LexicalEnvironment} from "../../lexical-environment/lexical-environment.js";
+import type {StatementTraversalStack} from "../../stack/traversal-stack/statement-traversal-stack.js";
 
 export interface ICreateNodeEvaluatorOptions {
 	typeChecker?: TS.TypeChecker;
@@ -18,5 +18,5 @@ export interface ICreateNodeEvaluatorOptions {
 	statementTraversalStack: StatementTraversalStack;
 	environment: LexicalEnvironment;
 	throwError: ThrowError;
-	getCurrentError (): EvaluationError|undefined;
+	getCurrentError(): EvaluationError | undefined;
 }

src/interpreter/evaluator/node-evaluator/node-evaluator.ts

@@ -1,15 +1,15 @@
 import type {Literal} from "../../literal/literal.js";
 import type {TS} from "../../../type/ts.js";
-import type { NextEvaluatorOptions } from "../evaluator-options.js";
-import type { EvaluationError } from "../../error/evaluation-error/evaluation-error.js";
+import type {NextEvaluatorOptions} from "../evaluator-options.js";
+import type {EvaluationError} from "../../error/evaluation-error/evaluation-error.js";
 
 export type NodeWithValue = TS.PropertyName;
 
 export type StatementEvaluator = (node: TS.Statement, nextOptions: NextEvaluatorOptions) => void;
 export type DeclarationEvaluator = (node: TS.Declaration, nextOptions: NextEvaluatorOptions) => void;
 export type NodeEvaluatorWithArgument = (node: TS.Node, arg: Literal, nextOptions: NextEvaluatorOptions) => void;
-export type ExpressionEvaluator = (node: TS.Expression | TS.PrivateIdentifier, nextOptions: NextEvaluatorOptions) => Literal|EvaluationError;
-export type NodeWithValueEvaluator = (node: NodeWithValue, nextOptions: NextEvaluatorOptions) => Literal|EvaluationError;
+export type ExpressionEvaluator = (node: TS.Expression | TS.PrivateIdentifier, nextOptions: NextEvaluatorOptions) => Literal | EvaluationError;
+export type NodeWithValueEvaluator = (node: NodeWithValue, nextOptions: NextEvaluatorOptions) => Literal | EvaluationError;
 
 export interface NodeEvaluator {
 	statement: StatementEvaluator;

src/interpreter/lexical-environment/clone-lexical-environment.ts

@@ -1,4 +1,4 @@
-import type { TS } from "../../type/ts.js";
+import type {TS} from "../../type/ts.js";
 import type {LexicalEnvironment} from "./lexical-environment.js";
 
 /**
@@ -7,7 +7,7 @@ import type {LexicalEnvironment} from "./lexical-environment.js";
 export function cloneLexicalEnvironment(environment: LexicalEnvironment, startingNode: TS.Node): LexicalEnvironment {
 	return {
 		parentEnv: environment,
-		startingNode,		
+		startingNode,
 		env: {}
 	};
 }

src/interpreter/lexical-environment/i-create-lexical-environment-options.ts

@@ -1,6 +1,6 @@
 import type {IEnvironment} from "../environment/i-environment.js";
 import type {EvaluatePolicySanitized} from "../policy/evaluate-policy.js";
-import type { TS } from "../../type/ts.js";
+import type {TS} from "../../type/ts.js";
 
 export interface ICreateLexicalEnvironmentOptions {
 	startingNode: TS.Node;