@lionlang/core 0.1.0 → 0.2.0

package/dist/{evaluate-D7ODMrbg.mjs → evaluate-BJOG7kaS.mjs}

@@ -1,9 +1,8 @@
-import { JsonPrimitiveSchema } from "./schemas/json-primitive.mjs";
 import { LionArrayExpressionSchema, LionExpressionSchema, LionRecordExpressionSchema } from "./schemas/lion-expression.mjs";
+import { BeginFormSchema, CondFormSchema, CondFormWithElseSchema, CondFormWithoutElseSchema, DefineFormSchema, EvalFormSchema, FunctionCallFormSchema, LambdaFormSchema, LionFunctionValueSchema, MatchFormSchema, MatchPatternSchema, QuoteFormSchema } from "./schemas/evaluation.mjs";
 import { ArgumentMismatchError, InvalidFunctionCallError } from "./errors/evaluation.mjs";
 import { makeEnvironment, setGlobalBinding } from "./evaluation/environment.mjs";
-import { BeginFormSchema, CondFormSchema, CondFormWithElseSchema, CondFormWithoutElseSchema, DefineFormSchema, EvalFormSchema, FunctionCallFormSchema, LambdaFormSchema, LionFunctionValueSchema, MatchFormSchema, MatchPatternSchema, QuoteFormSchema } from "./schemas/evaluation.mjs";
-import { LionEnvironmentService, getService } from "./services/evaluation.mjs";
+import { LionEnvironmentService } from "./services/evaluation.mjs";
 import { evaluateQuote } from "./evaluation/special-forms/quote.mjs";
 import { evaluatePrimitive } from "./evaluation/base-forms/primitive.mjs";
 import { Array, Effect, Match, Option, Record, Schema, pipe } from "effect";
@@ -22,10 +21,10 @@ const evaluateCond = (expression) => pipe(Match.value(expression), Match.when(Sc
 })), Match.exhaustive);
 //#endregion
 //#region src/evaluation/special-forms/define.ts
-const evaluateDefine = ([_, id, expr]) => pipe(Effect.Do, Effect.bind("environment", () => getService(LionEnvironmentService)), Effect.bind("value", () => evaluate(expr)), Effect.flatMap(({ environment, value }) => pipe(setGlobalBinding(environment, id, value), Effect.map(() => value))));
+const evaluateDefine = ([_, id, expr]) => pipe(Effect.Do, Effect.bind("environment", () => Effect.service(LionEnvironmentService)), Effect.bind("value", () => evaluate(expr)), Effect.flatMap(({ environment, value }) => pipe(setGlobalBinding(environment, id, value), Effect.map(() => value))));
 //#endregion
 //#region src/evaluation/special-forms/eval.ts
-const evaluateEval = ([_, args]) => pipe(evaluate(args), Effect.flatMap(Schema.decodeUnknown(LionExpressionSchema)), Effect.flatMap(evaluate));
+const evaluateEval = ([_, args]) => pipe(evaluate(args), Effect.flatMap(Schema.decodeUnknownEffect(LionExpressionSchema)), Effect.flatMap(evaluate));
 //#endregion
 //#region src/evaluation/special-forms/function.ts
 const evaluateFunctionCall = (functionCallExpression) => pipe(Effect.all(Array.map(functionCallExpression, evaluate)), Effect.map(Array.unprepend), Effect.flatMap(([head, tail]) => pipe(Match.value(head), Match.when(Schema.is(LionFunctionValueSchema), (fn) => {
@@ -35,7 +34,7 @@ const evaluateFunctionCall = (functionCallExpression) => pipe(Effect.all(Array.m
 //#endregion
 //#region src/evaluation/special-forms/lambda.ts
 const evaluateLambda = ([_, parameters, bodyExpression]) => Effect.gen(function* () {
-	const enclosedEnvironment = yield* getService(LionEnvironmentService);
+	const enclosedEnvironment = yield* LionEnvironmentService;
 	return Effect.fn(function* (...args) {
 		if (args.length < parameters.length) return yield* new ArgumentMismatchError();
 		const environment = yield* makeEnvironment(Record.fromEntries(Array.zip(parameters, args)), enclosedEnvironment);
@@ -44,41 +43,45 @@ const evaluateLambda = ([_, parameters, bodyExpression]) => Effect.gen(function*
 });
 //#endregion
 //#region src/evaluation/special-forms/match.ts
-const MatchPredicateRecordSchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.suspend(() => MatchPredicateSchema)
-});
-const MatchPredicateSchema = Schema.Union(MatchPredicateRecordSchema, LionFunctionValueSchema);
-const AnyRecordSchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.Any
-});
-const evaluatePredicate = (value, predicate) => pipe(Match.value(predicate), Match.when(Schema.is(MatchPredicateRecordSchema), (record) => Effect.gen(function* () {
-	if (!Schema.is(AnyRecordSchema)(value)) return false;
-	if (!Record.keys(record).every((key) => Record.has(value, key))) return false;
-	let result = true;
-	for (const [recordKey, recordValue] of Record.toEntries(record)) {
-		const recordValueResult = yield* evaluatePredicate(value[recordKey], recordValue);
-		result = result && recordValueResult;
+const MatchPredicateRecordSchema = Schema.Record(Schema.String, Schema.suspend(() => MatchPredicateSchema));
+const MatchPredicateSchema = Schema.Union([MatchPredicateRecordSchema, LionFunctionValueSchema]);
+const AnyRecordSchema = Schema.Record(Schema.String, Schema.Any);
+const evaluatePredicate = (value, predicate) => {
+	if (Schema.is(MatchPredicateRecordSchema)(predicate)) return Effect.gen(function* () {
+		if (!Schema.is(AnyRecordSchema)(value)) return false;
+		if (!Record.keys(predicate).every((key) => Record.has(value, key))) return false;
+		for (const [key, nestedPredicate] of Record.toEntries(predicate)) if (!(yield* evaluatePredicate(value[key], nestedPredicate))) return false;
+		return true;
+	});
+	return predicate(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Boolean)), Effect.catch(() => Effect.succeed(false)));
+};
+const evaluateMatchPatterns = (value, patternExprs) => Effect.gen(function* () {
+	const patternExpr = patternExprs[0];
+	if (patternExpr === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("Match expression requires a fallback function"));
+	if (Schema.is(MatchPatternSchema)(patternExpr)) {
+		const [predicateExpr, functionExpr] = patternExpr;
+		const predicate = yield* evaluate(predicateExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(MatchPredicateSchema)));
+		const fn = yield* evaluate(functionExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema)));
+		return (yield* evaluatePredicate(value, predicate)) ? yield* fn(value) : yield* evaluateMatchPatterns(value, patternExprs.slice(1));
 	}
-	return result;
-})), Match.when(Schema.is(LionFunctionValueSchema), (predicateFn) => pipe(predicateFn(value), Effect.flatMap(Schema.decodeUnknown(Schema.Boolean)), Effect.catchAll(() => Effect.succeed(false)))), Match.orElseAbsurd);
-const evaluateMatchPatterns = (value, patternExprs) => pipe(Array.head(patternExprs), Option.getOrThrow, Match.value, Match.when(Schema.is(MatchPatternSchema), ([predicateExpr, fnExpr]) => pipe(Effect.Do, Effect.bind("predicate", () => evaluate(predicateExpr)), Effect.bind("fn", () => pipe(evaluate(fnExpr), Effect.flatMap(Schema.decodeUnknown(LionFunctionValueSchema)))), Effect.flatMap(({ predicate, fn }) => pipe(Schema.decodeUnknown(MatchPredicateSchema)(predicate), Effect.flatMap((predicate) => evaluatePredicate(value, predicate)), Effect.if({
-	onTrue: () => fn(value),
-	onFalse: () => pipe(Array.tail(patternExprs), Option.getOrThrow, (tail) => evaluateMatchPatterns(value, tail))
-}))))), Match.when(Schema.is(LionExpressionSchema), (fallbackFn) => pipe(evaluate(fallbackFn), Effect.flatMap(Schema.decodeUnknown(LionFunctionValueSchema)), Effect.flatMap((fallbackFn) => fallbackFn(value)))), Match.exhaustive);
-const evaluateMatch = ([_, valueExpr, ...patternExprs]) => pipe(evaluate(valueExpr), Effect.flatMap((value) => evaluateMatchPatterns(value, patternExprs)));
+	return yield* (yield* evaluate(patternExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))))(value);
+});
+const evaluateMatch = ([_, valueExpression, ...patternExpressions]) => evaluate(valueExpression).pipe(Effect.flatMap((value) => evaluateMatchPatterns(value, patternExpressions)));
 //#endregion
 //#region src/evaluation/base-forms/array.ts
-const evaluateArray = (expression) => pipe(Match.value(expression), Match.when(Array.isEmptyReadonlyArray, Effect.succeed), Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)), Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)), Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)), Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)), Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)), Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)), Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)), Match.when(Schema.is(FunctionCallFormSchema), (_) => evaluateFunctionCall(_)), Match.orElse(() => Effect.fail(new InvalidFunctionCallError({ expression }))));
+const evaluateArray = (expression) => pipe(Match.value(expression), Match.when(Array.isReadonlyArrayEmpty, Effect.succeed), Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)), Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)), Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)), Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)), Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)), Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)), Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)), Match.when(Schema.is(FunctionCallFormSchema), (_) => evaluateFunctionCall(_)), Match.orElse(() => Effect.fail(new InvalidFunctionCallError({ expression }))));
 //#endregion
 //#region src/evaluation/base-forms/record.ts
 const evaluateRecord = (expression) => pipe(expression, Record.map(evaluate), Effect.all);
 //#endregion
 //#region src/evaluation/evaluate.ts
-const evaluate = (expression) => pipe(Match.value(expression), Match.when(Schema.is(LionArrayExpressionSchema), (_) => evaluateArray(_)), Match.when(Schema.is(LionRecordExpressionSchema), (_) => evaluateRecord(_)), Match.when(Schema.is(JsonPrimitiveSchema), (_) => evaluatePrimitive(_)), Match.exhaustive);
-const run = (expression, environment) => pipe(Schema.decodeUnknown(LionExpressionSchema)(expression), Effect.flatMap(evaluate), Effect.provideServiceEffect(LionEnvironmentService, makeEnvironment(environment)));
+const evaluate = (expression) => {
+	if (Schema.is(LionArrayExpressionSchema)(expression)) return evaluateArray(expression);
+	if (Schema.is(LionRecordExpressionSchema)(expression)) return evaluateRecord(expression);
+	return evaluatePrimitive(expression);
+};
+const run = (expression, environment) => pipe(Schema.decodeUnknownEffect(LionExpressionSchema)(expression), Effect.flatMap(evaluate), Effect.provideServiceEffect(LionEnvironmentService, makeEnvironment(environment)));
 //#endregion
 export { evaluateMatch as a, evaluateEval as c, evaluateBegin as d, evaluateArray as i, evaluateDefine as l, run as n, evaluateLambda as o, evaluateRecord as r, evaluateFunctionCall as s, evaluate as t, evaluateCond as u };
 
-//# sourceMappingURL=evaluate-D7ODMrbg.mjs.map
+//# sourceMappingURL=evaluate-BJOG7kaS.mjs.map

package/dist/evaluate-BJOG7kaS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-BJOG7kaS.mjs","names":["Arr","Arr","Arr","Arr","Arr"],"sources":["../src/evaluation/special-forms/begin.ts","../src/evaluation/special-forms/cond.ts","../src/evaluation/special-forms/define.ts","../src/evaluation/special-forms/eval.ts","../src/evaluation/special-forms/function.ts","../src/evaluation/special-forms/lambda.ts","../src/evaluation/special-forms/match.ts","../src/evaluation/base-forms/array.ts","../src/evaluation/base-forms/record.ts","../src/evaluation/evaluate.ts"],"sourcesContent":["import { Array as Arr, Effect, Option, pipe } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { BeginFormSchema } from \"@/schemas/evaluation\";\n\nexport const evaluateBegin = ([_, ...args]: typeof BeginFormSchema.Type) =>\n  pipe(\n    Arr.map(args, evaluate),\n    Effect.all,\n    Effect.map(Arr.last),\n    Effect.map(Option.getOrElse(() => []))\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport {\n  type CondFormSchema,\n  CondFormWithElseSchema,\n  CondFormWithoutElseSchema,\n} from \"@/schemas/evaluation\";\n\nexport const evaluateCond = (expression: typeof CondFormSchema.Type) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Schema.is(CondFormWithoutElseSchema), (exprWithoutElse) =>\n      Effect.gen(function* () {\n        const [_, ...cases] = exprWithoutElse;\n        for (const [condition, result] of cases) {\n          const conditionResult = yield* evaluate(condition);\n          if (conditionResult) {\n            return yield* evaluate(result);\n          }\n        }\n        return null;\n      })\n    ),\n    Match.when(Schema.is(CondFormWithElseSchema), (expression) =>\n      Effect.gen(function* () {\n        const [_, ...cases] = expression;\n        for (const [condition, result] of Arr.initNonEmpty(cases)) {\n          const conditionResult = yield* evaluate(condition);\n          if (conditionResult) {\n            return yield* evaluate(result);\n          }\n        }\n        const elseCase = Arr.lastNonEmpty(cases);\n        return yield* evaluate(elseCase);\n      })\n    ),\n    Match.exhaustive\n  );\n","import { Effect, pipe } from \"effect\";\nimport { setGlobalBinding } from \"@/evaluation/environment\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { DefineFormSchema } from \"@/schemas/evaluation\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\n\nexport const evaluateDefine = ([_, id, expr]: typeof DefineFormSchema.Type) =>\n  pipe(\n    Effect.Do,\n    Effect.bind(\"environment\", () => Effect.service(LionEnvironmentService)),\n    Effect.bind(\"value\", () => evaluate(expr)),\n    Effect.flatMap(({ environment, value }) =>\n      pipe(\n        setGlobalBinding(environment, id, value),\n        Effect.map(() => value)\n      )\n    )\n  );\n","import { Effect, pipe, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport type { EvalFormSchema } from \"@/schemas/evaluation\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport const evaluateEval = ([_, args]: typeof EvalFormSchema.Type) =>\n  pipe(\n    evaluate(args),\n    Effect.flatMap(Schema.decodeUnknownEffect(LionExpressionSchema)),\n    Effect.flatMap(evaluate)\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { InvalidFunctionCallError } from \"@/errors/evaluation\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport {\n  type FunctionCallFormSchema,\n  LionFunctionValueSchema,\n} from \"@/schemas/evaluation\";\n\nexport const evaluateFunctionCall = (\n  functionCallExpression: typeof FunctionCallFormSchema.Type\n) =>\n  pipe(\n    Effect.all(Arr.map(functionCallExpression, evaluate)),\n    Effect.map(Arr.unprepend),\n    Effect.flatMap(([head, tail]) =>\n      pipe(\n        Match.value(head),\n        Match.when(Schema.is(LionFunctionValueSchema), (fn) => {\n          const result = fn(...tail);\n          return Effect.isEffect(result) ? result : Effect.succeed(result);\n        }),\n        Match.orElse(() =>\n          Effect.fail(\n            new InvalidFunctionCallError({ expression: functionCallExpression })\n          )\n        )\n      )\n    )\n  );\n","import { Array as Arr, Effect, Record } from \"effect\";\nimport { ArgumentMismatchError } from \"@/errors/evaluation\";\nimport { makeEnvironment } from \"@/evaluation/environment\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { LambdaFormSchema } from \"@/schemas/evaluation\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\n\nexport const evaluateLambda = ([\n  _,\n  parameters,\n  bodyExpression,\n]: typeof LambdaFormSchema.Type) =>\n  Effect.gen(function* () {\n    const enclosedEnvironment = yield* LionEnvironmentService;\n    const lambda = Effect.fn(function* (...args: unknown[]) {\n      if (args.length < parameters.length) {\n        return yield* new ArgumentMismatchError();\n      }\n      const paramsEnvironment = Record.fromEntries(Arr.zip(parameters, args));\n      const environment = yield* makeEnvironment(\n        paramsEnvironment,\n        enclosedEnvironment\n      );\n      return yield* evaluate(bodyExpression).pipe(\n        Effect.provideService(LionEnvironmentService, environment)\n      );\n    });\n    return lambda;\n  });\n","import { Effect, Record, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport {\n  LionFunctionValueSchema,\n  type MatchFormSchema,\n  MatchPatternSchema,\n} from \"@/schemas/evaluation\";\nimport type { LionExpressionSchema } from \"@/schemas/lion-expression\";\nimport type { LionEnvironmentService } from \"@/services/evaluation\";\nimport type { EvaluateResult } from \"@/types/evaluation\";\n\n/*\n[\"match\", <value>, [<predicate>, <fn>], ..., <fallback-fn>]\n*/\n\ntype AssumedMatchPredicateType =\n  | { readonly [key: string]: AssumedMatchPredicateType }\n  | typeof LionFunctionValueSchema.Type;\n\nconst MatchPredicateRecordSchema = Schema.Record(\n  Schema.String,\n  Schema.suspend(\n    (): Schema.Codec<AssumedMatchPredicateType> => MatchPredicateSchema\n  )\n);\n\nconst MatchPredicateSchema = Schema.Union([\n  MatchPredicateRecordSchema,\n  LionFunctionValueSchema,\n]);\n\nconst AnyRecordSchema = Schema.Record(Schema.String, Schema.Any);\n\nconst evaluatePredicate = (\n  value: unknown,\n  predicate: typeof MatchPredicateSchema.Type\n): Effect.Effect<boolean, never, LionEnvironmentService> => {\n  if (Schema.is(MatchPredicateRecordSchema)(predicate)) {\n    return Effect.gen(function* () {\n      if (!Schema.is(AnyRecordSchema)(value)) {\n        return false;\n      }\n\n      if (!Record.keys(predicate).every((key) => Record.has(value, key))) {\n        return false;\n      }\n\n      for (const [key, nestedPredicate] of Record.toEntries(predicate)) {\n        if (!(yield* evaluatePredicate(value[key], nestedPredicate))) {\n          return false;\n        }\n      }\n      return true;\n    });\n  }\n\n  return predicate(value).pipe(\n    Effect.flatMap(Schema.decodeUnknownEffect(Schema.Boolean)),\n    Effect.catch(() => Effect.succeed(false))\n  );\n};\n\nconst evaluateMatchPatterns = (\n  value: unknown,\n  patternExprs: ReadonlyArray<\n    typeof MatchPatternSchema.Type | typeof LionExpressionSchema.Type\n  >\n): EvaluateResult =>\n  Effect.gen(function* () {\n    const patternExpr = patternExprs[0];\n    if (patternExpr === undefined) {\n      return yield* Effect.die(\n        new Error(\"Match expression requires a fallback function\")\n      );\n    }\n\n    if (Schema.is(MatchPatternSchema)(patternExpr)) {\n      const [predicateExpr, functionExpr] = patternExpr;\n      const predicate = yield* evaluate(predicateExpr).pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(MatchPredicateSchema))\n      );\n      const fn = yield* evaluate(functionExpr).pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))\n      );\n      return (yield* evaluatePredicate(value, predicate))\n        ? yield* fn(value)\n        : yield* evaluateMatchPatterns(value, patternExprs.slice(1));\n    }\n\n    const fallback = yield* evaluate(patternExpr).pipe(\n      Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))\n    );\n    return yield* fallback(value);\n  });\n\nexport const evaluateMatch = ([\n  _,\n  valueExpression,\n  ...patternExpressions\n]: typeof MatchFormSchema.Type) =>\n  evaluate(valueExpression).pipe(\n    Effect.flatMap((value) => evaluateMatchPatterns(value, patternExpressions))\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { InvalidFunctionCallError } from \"@/errors/evaluation\";\nimport { evaluateBegin } from \"@/evaluation/special-forms/begin.ts\";\nimport { evaluateCond } from \"@/evaluation/special-forms/cond.ts\";\nimport { evaluateDefine } from \"@/evaluation/special-forms/define.ts\";\nimport { evaluateEval } from \"@/evaluation/special-forms/eval.ts\";\nimport { evaluateFunctionCall } from \"@/evaluation/special-forms/function.ts\";\nimport { evaluateLambda } from \"@/evaluation/special-forms/lambda\";\nimport { evaluateMatch } from \"@/evaluation/special-forms/match\";\nimport { evaluateQuote } from \"@/evaluation/special-forms/quote.ts\";\nimport {\n  BeginFormSchema,\n  CondFormSchema,\n  DefineFormSchema,\n  EvalFormSchema,\n  FunctionCallFormSchema,\n  LambdaFormSchema,\n  MatchFormSchema,\n  QuoteFormSchema,\n} from \"@/schemas/evaluation.ts\";\nimport type { LionArrayExpressionType } from \"@/schemas/lion-expression.ts\";\n\nexport const evaluateArray = (expression: LionArrayExpressionType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Arr.isReadonlyArrayEmpty, Effect.succeed),\n    Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)),\n    Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)),\n    Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)),\n    Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)),\n    Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)),\n    Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)),\n    Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)),\n    Match.when(Schema.is(FunctionCallFormSchema), (_) =>\n      evaluateFunctionCall(_)\n    ),\n    Match.orElse(() =>\n      Effect.fail(new InvalidFunctionCallError({ expression }))\n    )\n  );\n","import { Effect, pipe, Record } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport type { LionRecordExpressionType } from \"@/schemas/lion-expression\";\n\nexport const evaluateRecord = (expression: LionRecordExpressionType) =>\n  pipe(expression, Record.map(evaluate), Effect.all);\n","import { Effect, pipe, Schema } from \"effect\";\nimport { evaluateArray } from \"@/evaluation/base-forms/array\";\nimport { evaluatePrimitive } from \"@/evaluation/base-forms/primitive\";\nimport { evaluateRecord } from \"@/evaluation/base-forms/record\";\nimport { makeEnvironment } from \"@/evaluation/environment\";\nimport {\n  LionArrayExpressionSchema,\n  LionExpressionSchema,\n  type LionExpressionType,\n  LionRecordExpressionSchema,\n} from \"@/schemas/lion-expression\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\nimport type { EvaluateResult } from \"@/types/evaluation\";\n\nexport const evaluate = (expression: LionExpressionType): EvaluateResult => {\n  if (Schema.is(LionArrayExpressionSchema)(expression)) {\n    return evaluateArray(expression);\n  }\n  if (Schema.is(LionRecordExpressionSchema)(expression)) {\n    return evaluateRecord(expression);\n  }\n  return evaluatePrimitive(expression);\n};\n\nexport const run = (\n  expression: unknown,\n  environment: Record<string, unknown>\n) =>\n  pipe(\n    Schema.decodeUnknownEffect(LionExpressionSchema)(expression),\n    Effect.flatMap(evaluate),\n    Effect.provideServiceEffect(\n      LionEnvironmentService,\n      makeEnvironment(environment)\n    )\n  );\n"],"mappings":"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"}

package/dist/evaluation/base-forms/array.d.mts

@@ -1,11 +1,10 @@
-import { r as LionArrayExpressionType } from "../../lion-expression-6Y3itx9l.mjs";
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { r as LionArrayExpressionType } from "../../lion-expression-DMR7Psmu.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/base-forms/array.d.ts
-declare const evaluateArray: (expression: LionArrayExpressionType) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateArray: (expression: LionArrayExpressionType) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateArray };
 //# sourceMappingURL=array.d.mts.map

package/dist/evaluation/base-forms/array.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/array.ts"],"mappings":";;;;;;;cAsBa,aAAA,GAAiB,UAAA,EAAY,uBAAA,KAAuB,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"array.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/array.ts"],"mappings":";;;;;;cAsBa,aAAA,GAAiB,UAAA,EAAY,uBAAA,KAAuB,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/base-forms/array.mjs

@@ -1,2 +1,2 @@
-import { i as evaluateArray } from "../../evaluate-D7ODMrbg.mjs";
+import { i as evaluateArray } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateArray };

package/dist/evaluation/base-forms/primitive.d.mts

@@ -1,5 +1,5 @@
-import { n as JsonPrimitiveType } from "../../json-primitive-DUaaoNff.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as JsonPrimitiveType } from "../../json-primitive-gcv9Q1E4.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { Effect } from "effect";
 
 //#region src/evaluation/base-forms/primitive.d.ts

package/dist/evaluation/base-forms/primitive.mjs

@@ -1,9 +1,9 @@
 import { getBinding } from "../environment.mjs";
-import { LionEnvironmentService, getService } from "../../services/evaluation.mjs";
+import { LionEnvironmentService } from "../../services/evaluation.mjs";
 import { Effect, Match, Option, String, pipe } from "effect";
 //#region src/evaluation/base-forms/primitive.ts
 const evaluatePrimitive = (expression) => pipe(Match.value(expression), Match.when(String.isString, evaluateReference), Match.orElse(Effect.succeed));
-const evaluateReference = (name) => pipe(getService(LionEnvironmentService), Effect.flatMap((environment) => getBinding(environment, name)), Effect.map(Option.getOrElse(() => name)));
+const evaluateReference = (name) => pipe(Effect.service(LionEnvironmentService), Effect.flatMap((environment) => getBinding(environment, name)), Effect.map(Option.getOrElse(() => name)));
 //#endregion
 export { evaluatePrimitive, evaluateReference };
 

package/dist/evaluation/base-forms/primitive.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"primitive.mjs","names":["Str"],"sources":["../../../src/evaluation/base-forms/primitive.ts"],"sourcesContent":["import { Effect, Match, Option, pipe, String as Str } from \"effect\";\nimport { getBinding } from \"@/evaluation/environment\";\nimport type { JsonPrimitiveType } from \"@/schemas/json-primitive\";\nimport { getService, LionEnvironmentService } from \"@/services/evaluation.ts\";\n\nexport const evaluatePrimitive = (expression: JsonPrimitiveType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Str.isString, evaluateReference),\n    Match.orElse(Effect.succeed)\n  );\n\nexport const evaluateReference = (name: string) =>\n  pipe(\n    getService(LionEnvironmentService),\n    Effect.flatMap((environment) => getBinding(environment, name)),\n    Effect.map(Option.getOrElse(() => name))\n  );\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,eAChC,KACE,MAAM,MAAM,WAAW,EACvB,MAAM,KAAKA,OAAI,UAAU,kBAAkB,EAC3C,MAAM,OAAO,OAAO,QAAQ,CAC7B;AAEH,MAAa,qBAAqB,SAChC,KACE,WAAW,uBAAuB,EAClC,OAAO,SAAS,gBAAgB,WAAW,aAAa,KAAK,CAAC,EAC9D,OAAO,IAAI,OAAO,gBAAgB,KAAK,CAAC,CACzC"}
+{"version":3,"file":"primitive.mjs","names":["Str"],"sources":["../../../src/evaluation/base-forms/primitive.ts"],"sourcesContent":["import { Effect, Match, Option, pipe, String as Str } from \"effect\";\nimport { getBinding } from \"@/evaluation/environment\";\nimport type { JsonPrimitiveType } from \"@/schemas/json-primitive\";\nimport { LionEnvironmentService } from \"@/services/evaluation.ts\";\n\nexport const evaluatePrimitive = (expression: JsonPrimitiveType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Str.isString, evaluateReference),\n    Match.orElse(Effect.succeed)\n  );\n\nexport const evaluateReference = (name: string) =>\n  pipe(\n    Effect.service(LionEnvironmentService),\n    Effect.flatMap((environment) => getBinding(environment, name)),\n    Effect.map(Option.getOrElse(() => name))\n  );\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,eAChC,KACE,MAAM,MAAM,WAAW,EACvB,MAAM,KAAKA,OAAI,UAAU,kBAAkB,EAC3C,MAAM,OAAO,OAAO,QAAQ,CAC7B;AAEH,MAAa,qBAAqB,SAChC,KACE,OAAO,QAAQ,uBAAuB,EACtC,OAAO,SAAS,gBAAgB,WAAW,aAAa,KAAK,CAAC,EAC9D,OAAO,IAAI,OAAO,gBAAgB,KAAK,CAAC,CACzC"}

package/dist/evaluation/base-forms/record.d.mts

@@ -1,13 +1,13 @@
-import { s as LionRecordExpressionType } from "../../lion-expression-6Y3itx9l.mjs";
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { s as LionRecordExpressionType } from "../../lion-expression-DMR7Psmu.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/evaluation/base-forms/record.d.ts
 declare const evaluateRecord: (expression: LionRecordExpressionType) => Effect.Effect<{
   [x: string]: unknown;
-}, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+}, _$effect_Schema0.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateRecord };
 //# sourceMappingURL=record.d.mts.map

package/dist/evaluation/base-forms/record.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/record.ts"],"mappings":";;;;;;;cAIa,cAAA,GAAkB,UAAA,EAAY,wBAAA,KAAwB,MAAA,CAAA,MAAA;EAAA;GAAA,qBAAA"}
+{"version":3,"file":"record.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/record.ts"],"mappings":";;;;;;;cAIa,cAAA,GAAkB,UAAA,EAAY,wBAAA,KAAwB,MAAA,CAAA,MAAA;EAAA;GAAA,gBAAA,CAAA,WAAA"}

package/dist/evaluation/base-forms/record.mjs

@@ -1,2 +1,2 @@
-import { r as evaluateRecord } from "../../evaluate-D7ODMrbg.mjs";
+import { r as evaluateRecord } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateRecord };

package/dist/evaluation/environment.d.mts

@@ -1,4 +1,4 @@
-import { a as ToplevelEnvironment, r as InnerEnvironment, t as Environment } from "../environment-k2Uf6VVc.mjs";
+import { a as ToplevelEnvironment, r as InnerEnvironment, t as Environment } from "../environment-BQw8BPXl.mjs";
 import { Effect, Option } from "effect";
 
 //#region src/evaluation/environment.d.ts

package/dist/evaluation/environment.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.mts","names":[],"sources":["../../src/evaluation/environment.ts"],"mappings":";;;;iBASgB,eAAA,CACd,QAAA,EAAU,MAAA,oBACT,MAAA,CAAO,MAAA,CAAO,mBAAA;AAAA,iBAED,eAAA,CACd,QAAA,EAAU,MAAA,mBACV,MAAA,EAAQ,WAAA,GACP,MAAA,CAAO,MAAA,CAAO,gBAAA;AAAA,cAeJ,UAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,aACC,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA;AAAA,cAqBX,eAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAOJ,gBAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA"}
+{"version":3,"file":"environment.d.mts","names":[],"sources":["../../src/evaluation/environment.ts"],"mappings":";;;;iBAWgB,eAAA,CACd,QAAA,EAAU,MAAA,oBACT,MAAA,CAAO,MAAA,CAAO,mBAAA;AAAA,iBAED,eAAA,CACd,QAAA,EAAU,MAAA,mBACV,MAAA,EAAQ,WAAA,GACP,MAAA,CAAO,MAAA,CAAO,gBAAA;AAAA,cAeJ,UAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,aACC,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA;AAAA,cAcX,eAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAOJ,gBAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA"}

package/dist/evaluation/environment.mjs

@@ -1,18 +1,21 @@
-import { InnerEnvironmentSchema, ToplevelEnvironmentSchema } from "../schemas/environment.mjs";
-import { Effect, Match, Option, Record, Ref, Schema, pipe } from "effect";
+import { Effect, Option, Record, Ref, pipe } from "effect";
 //#region src/evaluation/environment.ts
+const isInnerEnvironment = (environment) => "parent" in environment;
 function makeEnvironment(bindings, parent) {
 	return Ref.make(bindings).pipe(Effect.map((bindingsRef) => typeof parent === "undefined" ? { bindingsRef } : {
 		bindingsRef,
 		parent
 	}));
 }
-const getBinding = (environment, name) => pipe(Match.value(environment), Match.when(Schema.is(InnerEnvironmentSchema), ({ bindingsRef, parent }) => pipe(Ref.get(bindingsRef), Effect.map(Record.get(name)), Effect.flatMap(Option.match({
-	onSome: (binding) => Effect.succeed(Option.some(binding)),
-	onNone: () => getBinding(parent, name)
-})))), Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) => pipe(Ref.get(bindingsRef), Effect.map(Record.get(name)))), Match.exhaustive);
+const getBinding = (environment, name) => Effect.gen(function* () {
+	const binding = yield* pipe(Ref.get(environment.bindingsRef), Effect.map(Record.get(name)));
+	if (Option.isSome(binding)) return binding;
+	return isInnerEnvironment(environment) ? yield* getBinding(environment.parent, name) : Option.none();
+});
 const setLocalBinding = (environment, name, value) => pipe(environment.bindingsRef, Ref.update(Record.set(name, value)), Effect.as(environment));
-const setGlobalBinding = (environment, name, value) => pipe(Match.value(environment), Match.when(Schema.is(InnerEnvironmentSchema), ({ parent }) => setGlobalBinding(parent, name, value)), Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) => Ref.update(bindingsRef, Record.set(name, value))), Match.exhaustive, Effect.map(() => environment));
+const setGlobalBinding = (environment, name, value) => {
+	return (isInnerEnvironment(environment) ? setGlobalBinding(environment.parent, name, value) : Ref.update(environment.bindingsRef, Record.set(name, value))).pipe(Effect.as(environment));
+};
 //#endregion
 export { getBinding, makeEnvironment, setGlobalBinding, setLocalBinding };
 

package/dist/evaluation/environment.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"environment.mjs","names":[],"sources":["../../src/evaluation/environment.ts"],"sourcesContent":["import { Effect, Match, Option, pipe, Record, Ref, Schema } from \"effect\";\nimport {\n  type Environment,\n  type InnerEnvironment,\n  InnerEnvironmentSchema,\n  type ToplevelEnvironment,\n  ToplevelEnvironmentSchema,\n} from \"@/schemas/environment\";\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>\n): Effect.Effect<ToplevelEnvironment>;\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>,\n  parent: Environment\n): Effect.Effect<InnerEnvironment>;\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>,\n  parent?: Environment\n) {\n  return Ref.make(bindings).pipe(\n    Effect.map((bindingsRef) =>\n      typeof parent === \"undefined\"\n        ? ({ bindingsRef } as ToplevelEnvironment)\n        : ({ bindingsRef, parent } as InnerEnvironment)\n    )\n  );\n}\n\nexport const getBinding = (\n  environment: Environment,\n  name: string\n): Effect.Effect<Option.Option<unknown>> =>\n  pipe(\n    Match.value(environment),\n    Match.when(Schema.is(InnerEnvironmentSchema), ({ bindingsRef, parent }) =>\n      pipe(\n        Ref.get(bindingsRef),\n        Effect.map(Record.get(name)),\n        Effect.flatMap(\n          Option.match({\n            onSome: (binding) => Effect.succeed(Option.some(binding)),\n            onNone: () => getBinding(parent, name),\n          })\n        )\n      )\n    ),\n    Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) =>\n      pipe(Ref.get(bindingsRef), Effect.map(Record.get(name)))\n    ),\n    Match.exhaustive\n  );\n\nexport const setLocalBinding = (\n  environment: Environment,\n  name: string,\n  value: unknown\n): Effect.Effect<Environment> =>\n  pipe(\n    environment.bindingsRef,\n    Ref.update(Record.set(name, value)),\n    Effect.as(environment)\n  );\n\nexport const setGlobalBinding = (\n  environment: Environment,\n  name: string,\n  value: unknown\n): Effect.Effect<Environment> =>\n  pipe(\n    Match.value(environment),\n    Match.when(Schema.is(InnerEnvironmentSchema), ({ parent }) =>\n      setGlobalBinding(parent, name, value)\n    ),\n    Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) =>\n      Ref.update(bindingsRef, Record.set(name, value))\n    ),\n    Match.exhaustive,\n    Effect.map(() => environment)\n  );\n"],"mappings":";;;AAkBA,SAAgB,gBACd,UACA,QACA;AACA,QAAO,IAAI,KAAK,SAAS,CAAC,KACxB,OAAO,KAAK,gBACV,OAAO,WAAW,cACb,EAAE,aAAa,GACf;EAAE;EAAa;EAAQ,CAC7B,CACF;;AAGH,MAAa,cACX,aACA,SAEA,KACE,MAAM,MAAM,YAAY,EACxB,MAAM,KAAK,OAAO,GAAG,uBAAuB,GAAG,EAAE,aAAa,aAC5D,KACE,IAAI,IAAI,YAAY,EACpB,OAAO,IAAI,OAAO,IAAI,KAAK,CAAC,EAC5B,OAAO,QACL,OAAO,MAAM;CACX,SAAS,YAAY,OAAO,QAAQ,OAAO,KAAK,QAAQ,CAAC;CACzD,cAAc,WAAW,QAAQ,KAAK;CACvC,CAAC,CACH,CACF,CACF,EACD,MAAM,KAAK,OAAO,GAAG,0BAA0B,GAAG,EAAE,kBAClD,KAAK,IAAI,IAAI,YAAY,EAAE,OAAO,IAAI,OAAO,IAAI,KAAK,CAAC,CAAC,CACzD,EACD,MAAM,WACP;AAEH,MAAa,mBACX,aACA,MACA,UAEA,KACE,YAAY,aACZ,IAAI,OAAO,OAAO,IAAI,MAAM,MAAM,CAAC,EACnC,OAAO,GAAG,YAAY,CACvB;AAEH,MAAa,oBACX,aACA,MACA,UAEA,KACE,MAAM,MAAM,YAAY,EACxB,MAAM,KAAK,OAAO,GAAG,uBAAuB,GAAG,EAAE,aAC/C,iBAAiB,QAAQ,MAAM,MAAM,CACtC,EACD,MAAM,KAAK,OAAO,GAAG,0BAA0B,GAAG,EAAE,kBAClD,IAAI,OAAO,aAAa,OAAO,IAAI,MAAM,MAAM,CAAC,CACjD,EACD,MAAM,YACN,OAAO,UAAU,YAAY,CAC9B"}
+{"version":3,"file":"environment.mjs","names":[],"sources":["../../src/evaluation/environment.ts"],"sourcesContent":["import { Effect, Option, pipe, Record, Ref } from \"effect\";\nimport type {\n  Environment,\n  InnerEnvironment,\n  ToplevelEnvironment,\n} from \"@/schemas/environment\";\n\nconst isInnerEnvironment = (\n  environment: Environment\n): environment is InnerEnvironment => \"parent\" in environment;\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>\n): Effect.Effect<ToplevelEnvironment>;\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>,\n  parent: Environment\n): Effect.Effect<InnerEnvironment>;\n\nexport function makeEnvironment(\n  bindings: Record<string, unknown>,\n  parent?: Environment\n) {\n  return Ref.make(bindings).pipe(\n    Effect.map((bindingsRef) =>\n      typeof parent === \"undefined\"\n        ? ({ bindingsRef } as ToplevelEnvironment)\n        : ({ bindingsRef, parent } as InnerEnvironment)\n    )\n  );\n}\n\nexport const getBinding = (\n  environment: Environment,\n  name: string\n): Effect.Effect<Option.Option<unknown>> =>\n  Effect.gen(function* () {\n    const binding = yield* pipe(\n      Ref.get(environment.bindingsRef),\n      Effect.map(Record.get(name))\n    );\n    if (Option.isSome(binding)) {\n      return binding;\n    }\n    return isInnerEnvironment(environment)\n      ? yield* getBinding(environment.parent, name)\n      : Option.none();\n  });\n\nexport const setLocalBinding = (\n  environment: Environment,\n  name: string,\n  value: unknown\n): Effect.Effect<Environment> =>\n  pipe(\n    environment.bindingsRef,\n    Ref.update(Record.set(name, value)),\n    Effect.as(environment)\n  );\n\nexport const setGlobalBinding = (\n  environment: Environment,\n  name: string,\n  value: unknown\n): Effect.Effect<Environment> => {\n  const update = isInnerEnvironment(environment)\n    ? setGlobalBinding(environment.parent, name, value)\n    : Ref.update(environment.bindingsRef, Record.set(name, value));\n  return update.pipe(Effect.as(environment));\n};\n"],"mappings":";;AAOA,MAAM,sBACJ,gBACoC,YAAY;AAWlD,SAAgB,gBACd,UACA,QACA;AACA,QAAO,IAAI,KAAK,SAAS,CAAC,KACxB,OAAO,KAAK,gBACV,OAAO,WAAW,cACb,EAAE,aAAa,GACf;EAAE;EAAa;EAAQ,CAC7B,CACF;;AAGH,MAAa,cACX,aACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,KACrB,IAAI,IAAI,YAAY,YAAY,EAChC,OAAO,IAAI,OAAO,IAAI,KAAK,CAAC,CAC7B;AACD,KAAI,OAAO,OAAO,QAAQ,CACxB,QAAO;AAET,QAAO,mBAAmB,YAAY,GAClC,OAAO,WAAW,YAAY,QAAQ,KAAK,GAC3C,OAAO,MAAM;EACjB;AAEJ,MAAa,mBACX,aACA,MACA,UAEA,KACE,YAAY,aACZ,IAAI,OAAO,OAAO,IAAI,MAAM,MAAM,CAAC,EACnC,OAAO,GAAG,YAAY,CACvB;AAEH,MAAa,oBACX,aACA,MACA,UAC+B;AAI/B,SAHe,mBAAmB,YAAY,GAC1C,iBAAiB,YAAY,QAAQ,MAAM,MAAM,GACjD,IAAI,OAAO,YAAY,aAAa,OAAO,IAAI,MAAM,MAAM,CAAC,EAClD,KAAK,OAAO,GAAG,YAAY,CAAC"}

package/dist/evaluation/evaluate.d.mts

@@ -1,12 +1,11 @@
-import { a as LionExpressionType } from "../lion-expression-6Y3itx9l.mjs";
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-AblffSQw.mjs";
-import { t as EvaluateResult } from "../evaluation-uwZSKxIf.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { a as LionExpressionType } from "../lion-expression-DMR7Psmu.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-B6K0DbPS.mjs";
+import { t as EvaluateResult } from "../evaluation-Dwo4KN_D.mjs";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/evaluate.d.ts
 declare const evaluate: (expression: LionExpressionType) => EvaluateResult;
-declare const run: (expression: unknown, environment: Record<string, unknown>) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, never>;
+declare const run: (expression: unknown, environment: Record<string, unknown>) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, never>;
 //#endregion
 export { evaluate, run };
 //# sourceMappingURL=evaluate.d.mts.map

package/dist/evaluation/evaluate.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"evaluate.d.mts","names":[],"sources":["../../src/evaluation/evaluate.ts"],"mappings":";;;;;;;cAea,QAAA,GAAY,UAAA,EAAY,kBAAA,KAAqB,cAAA;AAAA,cAS7C,GAAA,GACX,UAAA,WACA,WAAA,EAAa,MAAA,sBAAuB,MAAA,CAAA,MAAA,UAAjB,qBAAA,GAAiB,wBAAA,GAAA,qBAAA,CAAA,UAAA"}
+{"version":3,"file":"evaluate.d.mts","names":[],"sources":["../../src/evaluation/evaluate.ts"],"mappings":";;;;;;cAca,QAAA,GAAY,UAAA,EAAY,kBAAA,KAAqB,cAAA;AAAA,cAU7C,GAAA,GACX,UAAA,WACA,WAAA,EAAa,MAAA,sBAAuB,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA"}

package/dist/evaluation/evaluate.mjs

@@ -1,2 +1,2 @@
-import { n as run, t as evaluate } from "../evaluate-D7ODMrbg.mjs";
+import { n as run, t as evaluate } from "../evaluate-BJOG7kaS.mjs";
 export { evaluate, run };

package/dist/evaluation/special-forms/begin.d.mts

@@ -1,11 +1,11 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { BeginFormSchema } from "../../schemas/evaluation.mjs";
 import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/evaluation/special-forms/begin.d.ts
-declare const evaluateBegin: ([_, ...args]: typeof BeginFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateBegin: ([_, ...args]: typeof BeginFormSchema.Type) => Effect.Effect<unknown, _$effect_Schema0.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateBegin };
 //# sourceMappingURL=begin.d.mts.map

package/dist/evaluation/special-forms/begin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"begin.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/begin.ts"],"mappings":";;;;;;;cAIa,aAAA,IAAiB,CAAA,KAAA,IAAA,UAAqB,eAAA,CAAgB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"begin.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/begin.ts"],"mappings":";;;;;;;cAIa,aAAA,IAAiB,CAAA,KAAA,IAAA,UAAqB,eAAA,CAAgB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,gBAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/begin.mjs

@@ -1,2 +1,2 @@
-import { d as evaluateBegin } from "../../evaluate-D7ODMrbg.mjs";
+import { d as evaluateBegin } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateBegin };

package/dist/evaluation/special-forms/cond.d.mts

@@ -1,11 +1,10 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { CondFormSchema } from "../../schemas/evaluation.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/special-forms/cond.d.ts
-declare const evaluateCond: (expression: typeof CondFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateCond: (expression: typeof CondFormSchema.Type) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateCond };
 //# sourceMappingURL=cond.d.mts.map

package/dist/evaluation/special-forms/cond.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cond.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/cond.ts"],"mappings":";;;;;;;cAQa,YAAA,GAAgB,UAAA,SAAmB,cAAA,CAAe,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"cond.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/cond.ts"],"mappings":";;;;;;cAQa,YAAA,GAAgB,UAAA,SAAmB,cAAA,CAAe,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/cond.mjs

@@ -1,2 +1,2 @@
-import { u as evaluateCond } from "../../evaluate-D7ODMrbg.mjs";
+import { u as evaluateCond } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateCond };

package/dist/evaluation/special-forms/define.d.mts

@@ -1,11 +1,11 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { DefineFormSchema } from "../../schemas/evaluation.mjs";
 import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/evaluation/special-forms/define.d.ts
-declare const evaluateDefine: ([_, id, expr]: typeof DefineFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateDefine: ([_, id, expr]: typeof DefineFormSchema.Type) => Effect.Effect<unknown, _$effect_Schema0.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateDefine };
 //# sourceMappingURL=define.d.mts.map

package/dist/evaluation/special-forms/define.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"define.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/define.ts"],"mappings":";;;;;;;cAMa,cAAA,IAAkB,CAAA,EAAA,EAAA,EAAA,IAAA,UAAsB,gBAAA,CAAiB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"define.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/define.ts"],"mappings":";;;;;;;cAMa,cAAA,IAAkB,CAAA,EAAA,EAAA,EAAA,IAAA,UAAsB,gBAAA,CAAiB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,gBAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/define.mjs

@@ -1,2 +1,2 @@
-import { l as evaluateDefine } from "../../evaluate-D7ODMrbg.mjs";
+import { l as evaluateDefine } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateDefine };

package/dist/evaluation/special-forms/eval.d.mts

@@ -1,11 +1,10 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { EvalFormSchema } from "../../schemas/evaluation.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/special-forms/eval.d.ts
-declare const evaluateEval: ([_, args]: typeof EvalFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateEval: ([_, args]: typeof EvalFormSchema.Type) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateEval };
 //# sourceMappingURL=eval.d.mts.map

package/dist/evaluation/special-forms/eval.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eval.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/eval.ts"],"mappings":";;;;;;;cAKa,YAAA,IAAgB,CAAA,EAAA,IAAA,UAAkB,cAAA,CAAe,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"eval.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/eval.ts"],"mappings":";;;;;;cAKa,YAAA,IAAgB,CAAA,EAAA,IAAA,UAAkB,cAAA,CAAe,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/eval.mjs

@@ -1,2 +1,2 @@
-import { c as evaluateEval } from "../../evaluate-D7ODMrbg.mjs";
+import { c as evaluateEval } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateEval };

package/dist/evaluation/special-forms/function.d.mts

@@ -1,11 +1,10 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { FunctionCallFormSchema } from "../../schemas/evaluation.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/special-forms/function.d.ts
-declare const evaluateFunctionCall: (functionCallExpression: typeof FunctionCallFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateFunctionCall: (functionCallExpression: typeof FunctionCallFormSchema.Type) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateFunctionCall };
 //# sourceMappingURL=function.d.mts.map

package/dist/evaluation/special-forms/function.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"function.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/function.ts"],"mappings":";;;;;;;cAQa,oBAAA,GACX,sBAAA,SAA+B,sBAAA,CAAuB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"function.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/function.ts"],"mappings":";;;;;;cAQa,oBAAA,GACX,sBAAA,SAA+B,sBAAA,CAAuB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/function.mjs

@@ -1,2 +1,2 @@
-import { s as evaluateFunctionCall } from "../../evaluate-D7ODMrbg.mjs";
+import { s as evaluateFunctionCall } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateFunctionCall };

package/dist/evaluation/special-forms/lambda.d.mts

@@ -1,11 +1,11 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { LambdaFormSchema } from "../../schemas/evaluation.mjs";
 import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/evaluation/special-forms/lambda.d.ts
-declare const evaluateLambda: ([_, parameters, bodyExpression]: typeof LambdaFormSchema.Type) => Effect.Effect<(...args: unknown[]) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, never>, never, LionEnvironmentService>;
+declare const evaluateLambda: ([_, parameters, bodyExpression]: typeof LambdaFormSchema.Type) => Effect.Effect<(...args: unknown[]) => Effect.Effect<unknown, _$effect_Schema0.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, never>, never, LionEnvironmentService>;
 //#endregion
 export { evaluateLambda };
 //# sourceMappingURL=lambda.d.mts.map

package/dist/evaluation/special-forms/lambda.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"lambda.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/lambda.ts"],"mappings":";;;;;;;cAOa,cAAA,IAAkB,CAAA,EAAA,UAAA,EAAA,cAAA,UAIrB,gBAAA,CAAiB,IAAA,KAAI,MAAA,CAAA,MAAA,KAAA,IAAA,gBAAA,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,iBAAA,sBAAA"}
+{"version":3,"file":"lambda.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/lambda.ts"],"mappings":";;;;;;;cAOa,cAAA,IAAkB,CAAA,EAAA,UAAA,EAAA,cAAA,UAIrB,gBAAA,CAAiB,IAAA,KAAI,MAAA,CAAA,MAAA,KAAA,IAAA,gBAAA,MAAA,CAAA,MAAA,UAAA,gBAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,iBAAA,sBAAA"}

package/dist/evaluation/special-forms/lambda.mjs

@@ -1,2 +1,2 @@
-import { o as evaluateLambda } from "../../evaluate-D7ODMrbg.mjs";
+import { o as evaluateLambda } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateLambda };

package/dist/evaluation/special-forms/match.d.mts

@@ -1,11 +1,10 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { MatchFormSchema } from "../../schemas/evaluation.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/special-forms/match.d.ts
-declare const evaluateMatch: ([_, valueExpr, ...patternExprs]: typeof MatchFormSchema.Type) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateMatch: ([_, valueExpression, ...patternExpressions]: typeof MatchFormSchema.Type) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateMatch };
 //# sourceMappingURL=match.d.mts.map

package/dist/evaluation/special-forms/match.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"match.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/match.ts"],"mappings":";;;;;;;cAgIa,aAAA,IAAiB,CAAA,EAAA,SAAA,KAAA,YAAA,UAIpB,eAAA,CAAgB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"match.d.mts","names":[],"sources":["../../../src/evaluation/special-forms/match.ts"],"mappings":";;;;;;cA+Fa,aAAA,IAAiB,CAAA,EAAA,eAAA,KAAA,kBAAA,UAIpB,eAAA,CAAgB,IAAA,KAAI,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/special-forms/match.mjs

@@ -1,2 +1,2 @@
-import { a as evaluateMatch } from "../../evaluate-D7ODMrbg.mjs";
+import { a as evaluateMatch } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateMatch };

package/dist/evaluation/special-forms/quote.d.mts

@@ -1,4 +1,4 @@
-import { t as AssumedExpressionType } from "../../lion-expression-6Y3itx9l.mjs";
+import { t as AssumedExpressionType } from "../../lion-expression-DMR7Psmu.mjs";
 import { QuoteFormSchema } from "../../schemas/evaluation.mjs";
 import { Effect } from "effect";
 

package/dist/evaluation-B6K0DbPS.d.mts

@@ -0,0 +1,14 @@
+import { t as AssumedExpressionType } from "./lion-expression-DMR7Psmu.mjs";
+import { Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/errors/evaluation.d.ts
+declare const ArgumentMismatchError_base: Schema.Class<ArgumentMismatchError, Schema.TaggedStruct<"ArgumentMismatchError", {}>, _$effect_Cause0.YieldableError>;
+declare class ArgumentMismatchError extends ArgumentMismatchError_base {}
+declare const InvalidFunctionCallError_base: Schema.Class<InvalidFunctionCallError, Schema.TaggedStruct<"InvalidFunctionCallError", {
+  readonly expression: Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>, Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>]>;
+}>, _$effect_Cause0.YieldableError>;
+declare class InvalidFunctionCallError extends InvalidFunctionCallError_base {}
+//#endregion
+export { InvalidFunctionCallError as n, ArgumentMismatchError as t };
+//# sourceMappingURL=evaluation-B6K0DbPS.d.mts.map

package/dist/evaluation-B6K0DbPS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-B6K0DbPS.d.mts","names":[],"sources":["../src/errors/evaluation.ts"],"mappings":";;;;;cAAgC,0BAAA;cAGnB,qBAAA,SAA8B,0BAAA;AAAA,cAGvC,6BAAA;;;cAES,wBAAA,SAAiC,6BAAA"}