@lionlang/core 0.1.0

package/dist/lion-expression-6Y3itx9l.d.mts

@@ -0,0 +1,16 @@
+import { n as JsonPrimitiveType } from "./json-primitive-DUaaoNff.mjs";
+import { Schema } from "effect";
+
+//#region src/schemas/lion-expression.d.ts
+type AssumedExpressionType = JsonPrimitiveType | readonly AssumedExpressionType[] | {
+  readonly [key: string]: AssumedExpressionType;
+};
+declare const LionArrayExpressionSchema: Schema.Array$<Schema.suspend<AssumedExpressionType, AssumedExpressionType, never>>;
+type LionArrayExpressionType = typeof LionArrayExpressionSchema.Type;
+declare const LionRecordExpressionSchema: Schema.Record$<Schema.filter<Schema.filter<typeof Schema.String>>, Schema.suspend<AssumedExpressionType, AssumedExpressionType, never>>;
+type LionRecordExpressionType = typeof LionRecordExpressionSchema.Type;
+declare const LionExpressionSchema: Schema.Union<[Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean, typeof Schema.Null]>, Schema.Array$<Schema.suspend<AssumedExpressionType, AssumedExpressionType, never>>, Schema.Record$<Schema.filter<Schema.filter<typeof Schema.String>>, Schema.suspend<AssumedExpressionType, AssumedExpressionType, never>>]>;
+type LionExpressionType = typeof LionExpressionSchema.Type;
+//#endregion
+export { LionExpressionType as a, LionExpressionSchema as i, LionArrayExpressionSchema as n, LionRecordExpressionSchema as o, LionArrayExpressionType as r, LionRecordExpressionType as s, AssumedExpressionType as t };
+//# sourceMappingURL=lion-expression-6Y3itx9l.d.mts.map

package/dist/lion-expression-6Y3itx9l.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lion-expression-6Y3itx9l.d.mts","names":[],"sources":["../src/schemas/lion-expression.ts"],"mappings":";;;;KAOY,qBAAA,GACR,iBAAA,YACS,qBAAA;EAAA,UACG,GAAA,WAAc,qBAAA;AAAA;AAAA,cAEjB,yBAAA,EAAyB,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,OAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAM1B,uBAAA,UAAiC,yBAAA,CAA0B,IAAA;AAAA,cAK1D,0BAAA,EAA0B,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,QAAA,MAAA,CAAA,MAAA,IAAA,MAAA,CAAA,OAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAU3B,wBAAA,UAAkC,0BAAA,CAA2B,IAAA;AAAA,cAG5D,oBAAA,EAAoB,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,KAAA,SAAA,MAAA,CAAA,MAAA,SAAA,MAAA,CAAA,MAAA,SAAA,MAAA,CAAA,OAAA,SAAA,MAAA,CAAA,IAAA,IAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,OAAA,CAAA,qBAAA,EAAA,qBAAA,WAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,QAAA,MAAA,CAAA,MAAA,IAAA,MAAA,CAAA,OAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAMrB,kBAAA,UAA4B,oBAAA,CAAqB,IAAA"}

package/dist/modules/array.d.mts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import * as _$effect_ParseResult0 from "effect/ParseResult";
+
+//#region src/modules/array.d.ts
+declare const module: {
+  symbol: symbol;
+  make: (...args: unknown[]) => Effect.Effect<unknown[], never, never>;
+  head: (u: unknown) => Effect.Effect<any, _$effect_ParseResult0.ParseError, never>;
+  tail: (u: unknown) => Effect.Effect<any[], _$effect_ParseResult0.ParseError, never>;
+  length: (u: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+  concat: (a: unknown, b: unknown) => Effect.Effect<any[], _$effect_ParseResult0.ParseError, never>;
+  "includes?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  map: (a: unknown, b: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
+  "flat-map": (a: unknown, b: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
+  reduce: (a: unknown, b: unknown, c: unknown) => Effect.Effect<any, _$effect_ParseResult0.ParseError, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=array.d.mts.map

package/dist/modules/array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.mts","names":[],"sources":["../../src/modules/array.ts"],"mappings":";;;;cAGa,MAAA;;gCAGc,MAAA,CAAA,MAAA;2CAAA,qBAAA,CAAA,UAAA"}

package/dist/modules/array.mjs

@@ -0,0 +1,23 @@
+import { decode } from "./lib/shared.mjs";
+import { Array, Effect, Option, Schema, flow, pipe } from "effect";
+//#region src/modules/array.ts
+const module = {
+	symbol: Symbol("array"),
+	make: (...args) => Effect.succeed(args),
+	head: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.head), Effect.map(Option.getOrThrow)),
+	tail: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.tail), Effect.map(Option.getOrThrow)),
+	length: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.length)),
+	concat: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Array(Schema.Any))), Effect.map(Array.flatten)),
+	"includes?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.map(([list, item]) => Array.contains(list, item))),
+	map: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.flatMap(([list, fn]) => Effect.all(Array.map(list, fn)))),
+	"flat-map": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.flatMap(([list, fn]) => pipe(Array.map(list, fn), Effect.all, Effect.map(Array.flatten)))),
+	reduce: flow((a, b, c) => [
+		a,
+		b,
+		c
+	], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any, Schema.Any)), Effect.flatMap(([list, initial, fn]) => Array.reduce(list, Effect.succeed(initial), (accEffect, item) => Effect.flatMap(accEffect, (acc) => fn(acc, item)))))
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=array.mjs.map

package/dist/modules/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":["Arr"],"sources":["../../src/modules/array.ts"],"sourcesContent":["import { Array as Arr, Effect, flow, Option, pipe, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"array\"),\n\n  make: (...args: unknown[]) => Effect.succeed(args),\n\n  head: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.head),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  tail: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.tail),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  length: flow(decode(Schema.Array(Schema.Any)), Effect.map(Arr.length)),\n\n  concat: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Array(Schema.Any))),\n    Effect.map(Arr.flatten)\n  ),\n\n  \"includes?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.map(([list, item]) => Arr.contains(list, item))\n  ),\n\n  map: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.flatMap(([list, fn]) =>\n      Effect.all(Arr.map(list, fn) as Effect.Effect<unknown>[])\n    )\n  ),\n\n  \"flat-map\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.flatMap(([list, fn]) =>\n      pipe(\n        Arr.map(list, fn) as Effect.Effect<unknown[]>[],\n        Effect.all,\n        Effect.map(Arr.flatten)\n      )\n    )\n  ),\n\n  reduce: flow(\n    (a: unknown, b: unknown, c: unknown) => [a, b, c],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any, Schema.Any)),\n    Effect.flatMap(([list, initial, fn]) =>\n      Arr.reduce(list, Effect.succeed(initial), (accEffect, item) =>\n        Effect.flatMap(accEffect, (acc) =>\n          (fn as (acc: unknown, item: unknown) => Effect.Effect<unknown>)(\n            acc,\n            item\n          )\n        )\n      )\n    )\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,QAAQ;CAEvB,OAAO,GAAG,SAAoB,OAAO,QAAQ,KAAK;CAElD,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,QAAQ,KAAK,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAAE,OAAO,IAAIA,MAAI,OAAO,CAAC;CAEtE,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,MAAM,OAAO,IAAI,CAAC,CAAC,EACxE,OAAO,IAAIA,MAAI,QAAQ,CACxB;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,KAAK,CAAC,MAAM,UAAUA,MAAI,SAAS,MAAM,KAAK,CAAC,CACvD;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,SAAS,CAAC,MAAM,QACrB,OAAO,IAAIA,MAAI,IAAI,MAAM,GAAG,CAA6B,CAC1D,CACF;CAED,YAAY,MACT,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,SAAS,CAAC,MAAM,QACrB,KACEA,MAAI,IAAI,MAAM,GAAG,EACjB,OAAO,KACP,OAAO,IAAIA,MAAI,QAAQ,CACxB,CACF,CACF;CAED,QAAQ,MACL,GAAY,GAAY,MAAe;EAAC;EAAG;EAAG;EAAE,EACjD,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,KAAK,OAAO,IAAI,CAAC,EACtE,OAAO,SAAS,CAAC,MAAM,SAAS,QAC9BA,MAAI,OAAO,MAAM,OAAO,QAAQ,QAAQ,GAAG,WAAW,SACpD,OAAO,QAAQ,YAAY,QACxB,GACC,KACA,KACD,CACF,CACF,CACF,CACF;CACF"}

package/dist/modules/boolean.d.mts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import * as _$effect_ParseResult0 from "effect/ParseResult";
+
+//#region src/modules/boolean.d.ts
+declare const module: {
+  symbol: symbol;
+  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  not: (u: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  and: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  or: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  xor: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  nand: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  nor: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=boolean.d.mts.map

package/dist/modules/boolean.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.mts","names":[],"sources":["../../src/modules/boolean.ts"],"mappings":";;;;cAGa,MAAA;;gEAwCZ,qBAAA,CAAA,UAAA"}

package/dist/modules/boolean.mjs

@@ -0,0 +1,17 @@
+import { decode } from "./lib/shared.mjs";
+import { Boolean, Effect, Schema, flow } from "effect";
+//#region src/modules/boolean.ts
+const module = {
+	symbol: Symbol("boolean"),
+	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => a === b)),
+	not: flow(decode(Schema.Boolean), Effect.map(Boolean.not)),
+	and: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.and(a, b))),
+	or: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.or(a, b))),
+	xor: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.xor(a, b))),
+	nand: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.nand(a, b))),
+	nor: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.nor(a, b)))
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=boolean.mjs.map

package/dist/modules/boolean.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.mjs","names":["Bool"],"sources":["../../src/modules/boolean.ts"],"sourcesContent":["import { Boolean as Bool, Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"boolean\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  not: flow(decode(Schema.Boolean), Effect.map(Bool.not)),\n\n  and: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.and(a, b))\n  ),\n\n  or: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.or(a, b))\n  ),\n\n  xor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.xor(a, b))\n  ),\n\n  nand: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.nand(a, b))\n  ),\n\n  nor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.nor(a, b))\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,UAAU;CAEzB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,KAAK,KAAK,OAAO,OAAO,QAAQ,EAAE,OAAO,IAAIA,QAAK,IAAI,CAAC;CAEvD,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,IAAI,MACD,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,GAAG,GAAG,EAAE,CAAC,CACtC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,MAAM,MACH,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,KAAK,GAAG,EAAE,CAAC,CACxC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CACF"}

package/dist/modules/console.d.mts

@@ -0,0 +1,10 @@
+import { Effect } from "effect";
+
+//#region src/modules/console.d.ts
+declare const module: {
+  log: (message: string) => Effect.Effect<string, never, never>;
+  "log-json": (message: unknown) => Effect.Effect<string, never, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=console.d.mts.map

package/dist/modules/console.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.mts","names":[],"sources":["../../src/modules/console.ts"],"mappings":";;;cAEa,MAAA;4BACU,MAAA,CAAA,MAAA;oCAGQ,MAAA,CAAA,MAAA;AAAA"}

package/dist/modules/console.mjs

@@ -0,0 +1,10 @@
+import { Console, Effect } from "effect";
+//#region src/modules/console.ts
+const module = {
+	log: (message) => Console.log(message).pipe(Effect.map(() => message)),
+	"log-json": (message) => Console.log(JSON.stringify(message, null, 2)).pipe(Effect.map(() => JSON.stringify(message, null, 2)))
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=console.mjs.map

package/dist/modules/console.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.mjs","names":[],"sources":["../../src/modules/console.ts"],"sourcesContent":["import { Console, Effect } from \"effect\";\n\nexport const module = {\n  log: (message: string) =>\n    Console.log(message).pipe(Effect.map(() => message)),\n  \n  \"log-json\": (message: unknown) =>\n    Console.log(JSON.stringify(message, null, 2)).pipe(\n      Effect.map(() => JSON.stringify(message, null, 2))\n    ),\n};\n"],"mappings":";;AAEA,MAAa,SAAS;CACpB,MAAM,YACJ,QAAQ,IAAI,QAAQ,CAAC,KAAK,OAAO,UAAU,QAAQ,CAAC;CAEtD,aAAa,YACX,QAAQ,IAAI,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CAAC,KAC5C,OAAO,UAAU,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CACnD;CACJ"}

package/dist/modules/func.d.mts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+
+//#region src/modules/func.d.ts
+declare const module: {
+  symbol: symbol;
+  bind: (fn: (...args: unknown[]) => unknown, obj: unknown, ...args: unknown[]) => Effect.Effect<(...args: unknown[]) => unknown, never, never>;
+  apply: (fn: (...args: unknown[]) => unknown, obj: unknown, ...args: unknown[]) => Effect.Effect<unknown, never, never>;
+  callback: (fn: unknown) => Effect.Effect<(...args: unknown[]) => any, never, never>;
+  partial: (fn: unknown, ...args: unknown[]) => Effect.Effect<(...moreArgs: unknown[]) => any, never, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=func.d.mts.map

package/dist/modules/func.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"func.d.mts","names":[],"sources":["../../src/modules/func.ts"],"mappings":";;;cAGa,MAAA;;iBAID,IAAA,yBAA2B,GAAA,cACvB,IAAA,gBACM,MAAA,CAAA,MAAA,KAAA,IAAA;kBAIV,IAAA,yBAA2B,GAAA,cACvB,IAAA,gBACM,MAAA,CAAA,MAAA;6BAGE,MAAA,CAAA,MAAA,KAAA,IAAA;4BAuCD,IAAA,gBAAoB,MAAA,CAAA,MAAA,KAAA,QAAA;AAAA"}

package/dist/modules/func.mjs

@@ -0,0 +1,28 @@
+import { LionEnvironmentService } from "../services/evaluation.mjs";
+import { Context, Effect, Match, Option, pipe } from "effect";
+//#region src/modules/func.ts
+const module = {
+	symbol: Symbol("func"),
+	bind: (fn, obj, ...args) => Effect.succeed(fn.bind(obj, ...args)),
+	apply: (fn, obj, ...args) => Effect.succeed(fn.apply(obj, args)),
+	callback: (fn) => pipe(Effect.context(), Effect.map((context) => Context.getOption(context, LionEnvironmentService)), Effect.map((environmentRef) => (...args) => {
+		if (typeof fn !== "function") return fn;
+		const result = fn(...args);
+		if (Effect.isEffect(result)) {
+			const callbackEffect = pipe(Match.value(environmentRef), Match.when(Option.isSome, ({ value }) => result.pipe(Effect.provideService(LionEnvironmentService, value))), Match.when(Option.isNone, () => result), Match.exhaustive);
+			return Effect.runPromise(callbackEffect).catch((e) => {
+				console.error(e);
+				throw e;
+			});
+		}
+		return result;
+	})),
+	partial: (fn, ...args) => Effect.succeed((...moreArgs) => {
+		if (typeof fn !== "function") return fn;
+		return fn(...args, ...moreArgs);
+	})
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=func.mjs.map

package/dist/modules/func.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"func.mjs","names":[],"sources":["../../src/modules/func.ts"],"sourcesContent":["import { Context, Effect, Match, Option, pipe } from \"effect\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\n\nexport const module = {\n  symbol: Symbol(\"func\"),\n\n  bind: (\n    fn: (...args: unknown[]) => unknown,\n    obj: unknown,\n    ...args: unknown[]\n  ) => Effect.succeed(fn.bind(obj, ...args)),\n\n  apply: (\n    fn: (...args: unknown[]) => unknown,\n    obj: unknown,\n    ...args: unknown[]\n  ) => Effect.succeed(fn.apply(obj, args)),\n\n  callback: (fn: unknown) =>\n    pipe(\n      Effect.context<never>(),\n      Effect.map((context) =>\n        Context.getOption(context, LionEnvironmentService)\n      ),\n      Effect.map((environmentRef) => (...args: unknown[]) => {\n        if (typeof fn !== \"function\") {\n          return fn;\n        }\n\n        const result = fn(...args);\n\n        if (Effect.isEffect(result)) {\n          const callbackEffect = pipe(\n            Match.value(environmentRef),\n            Match.when(\n              Option.isSome,\n              ({ value }) =>\n                result.pipe(\n                  Effect.provideService(LionEnvironmentService, value)\n                ) as Effect.Effect<unknown, unknown, never>\n            ),\n            Match.when(Option.isNone, () => result),\n            Match.exhaustive\n          );\n\n          return Effect.runPromise(\n            callbackEffect as Effect.Effect<unknown, unknown, never>\n          ).catch((e) => {\n            console.error(e);\n            throw e;\n          });\n        }\n\n        return result;\n      })\n    ),\n\n  partial: (fn: unknown, ...args: unknown[]) =>\n    Effect.succeed((...moreArgs: unknown[]) => {\n      if (typeof fn !== \"function\") {\n        return fn;\n      }\n\n      return fn(...args, ...moreArgs);\n    }),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,OAAO;CAEtB,OACE,IACA,KACA,GAAG,SACA,OAAO,QAAQ,GAAG,KAAK,KAAK,GAAG,KAAK,CAAC;CAE1C,QACE,IACA,KACA,GAAG,SACA,OAAO,QAAQ,GAAG,MAAM,KAAK,KAAK,CAAC;CAExC,WAAW,OACT,KACE,OAAO,SAAgB,EACvB,OAAO,KAAK,YACV,QAAQ,UAAU,SAAS,uBAAuB,CACnD,EACD,OAAO,KAAK,oBAAoB,GAAG,SAAoB;AACrD,MAAI,OAAO,OAAO,WAChB,QAAO;EAGT,MAAM,SAAS,GAAG,GAAG,KAAK;AAE1B,MAAI,OAAO,SAAS,OAAO,EAAE;GAC3B,MAAM,iBAAiB,KACrB,MAAM,MAAM,eAAe,EAC3B,MAAM,KACJ,OAAO,SACN,EAAE,YACD,OAAO,KACL,OAAO,eAAe,wBAAwB,MAAM,CACrD,CACJ,EACD,MAAM,KAAK,OAAO,cAAc,OAAO,EACvC,MAAM,WACP;AAED,UAAO,OAAO,WACZ,eACD,CAAC,OAAO,MAAM;AACb,YAAQ,MAAM,EAAE;AAChB,UAAM;KACN;;AAGJ,SAAO;GACP,CACH;CAEH,UAAU,IAAa,GAAG,SACxB,OAAO,SAAS,GAAG,aAAwB;AACzC,MAAI,OAAO,OAAO,WAChB,QAAO;AAGT,SAAO,GAAG,GAAG,MAAM,GAAG,SAAS;GAC/B;CACL"}

package/dist/modules/index.d.mts

@@ -0,0 +1,8 @@
+//#region src/modules/index.d.ts
+declare const namespaceEntries: (namespace: string, record: Record<string, unknown>) => Record<string, unknown>;
+declare const stdlib: {
+  [x: string]: unknown;
+};
+//#endregion
+export { namespaceEntries, stdlib };
+//# sourceMappingURL=index.d.mts.map

package/dist/modules/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/modules/index.ts"],"mappings":";cASa,gBAAA,GACX,SAAA,UACA,MAAA,EAAQ,MAAA,sBAAuB,MAAA;AAAA,cAYpB,MAAA;EAAA,CASZ,CAAA;AAAA"}

package/dist/modules/index.mjs

@@ -0,0 +1,31 @@
+import { module } from "./array.mjs";
+import { module as module$1 } from "./boolean.mjs";
+import { module as module$2 } from "./console.mjs";
+import { module as module$3 } from "./func.mjs";
+import { module as module$4 } from "./number.mjs";
+import { module as module$5 } from "./object.mjs";
+import { module as module$6 } from "./string.mjs";
+import { module as module$7 } from "./value.mjs";
+//#region src/modules/index.ts
+const namespaceEntries = (namespace, record) => {
+	const result = {};
+	for (const entry of Object.entries(record)) {
+		const [key, value] = entry;
+		result[`${namespace}/${key}`] = value;
+	}
+	return result;
+};
+const stdlib = {
+	...namespaceEntries("array", module),
+	...namespaceEntries("boolean", module$1),
+	...namespaceEntries("console", module$2),
+	...namespaceEntries("func", module$3),
+	...namespaceEntries("number", module$4),
+	...namespaceEntries("object", module$5),
+	...namespaceEntries("string", module$6),
+	...namespaceEntries("value", module$7)
+};
+//#endregion
+export { namespaceEntries, stdlib };
+
+//# sourceMappingURL=index.mjs.map

package/dist/modules/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["array","boolean","console","func","number","object","string","value"],"sources":["../../src/modules/index.ts"],"sourcesContent":["import { module as array } from \"./array.ts\";\nimport { module as boolean } from \"./boolean.ts\";\nimport { module as console } from \"./console.ts\";\nimport { module as func } from \"./func.ts\";\nimport { module as number } from \"./number.ts\";\nimport { module as object } from \"./object.ts\";\nimport { module as string } from \"./string.ts\";\nimport { module as value } from \"./value.ts\";\n\nexport const namespaceEntries = (\n  namespace: string,\n  record: Record<string, unknown>\n) => {\n  const result: Record<string, unknown> = {};\n\n  for (const entry of Object.entries(record)) {\n    const [key, value] = entry;\n    result[`${namespace}/${key}`] = value;\n  }\n\n  return result;\n};\n\nexport const stdlib = {\n  ...namespaceEntries(\"array\", array),\n  ...namespaceEntries(\"boolean\", boolean),\n  ...namespaceEntries(\"console\", console),\n  ...namespaceEntries(\"func\", func),\n  ...namespaceEntries(\"number\", number),\n  ...namespaceEntries(\"object\", object),\n  ...namespaceEntries(\"string\", string),\n  ...namespaceEntries(\"value\", value),\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,oBACX,WACA,WACG;CACH,MAAM,SAAkC,EAAE;AAE1C,MAAK,MAAM,SAAS,OAAO,QAAQ,OAAO,EAAE;EAC1C,MAAM,CAAC,KAAK,SAAS;AACrB,SAAO,GAAG,UAAU,GAAG,SAAS;;AAGlC,QAAO;;AAGT,MAAa,SAAS;CACpB,GAAG,iBAAiB,SAASA,OAAM;CACnC,GAAG,iBAAiB,WAAWC,SAAQ;CACvC,GAAG,iBAAiB,WAAWC,SAAQ;CACvC,GAAG,iBAAiB,QAAQC,SAAK;CACjC,GAAG,iBAAiB,UAAUC,SAAO;CACrC,GAAG,iBAAiB,UAAUC,SAAO;CACrC,GAAG,iBAAiB,UAAUC,SAAO;CACrC,GAAG,iBAAiB,SAASC,SAAM;CACpC"}

package/dist/modules/lib/shared.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Effect0 from "effect/Effect";
+
+//#region src/modules/lib/shared.d.ts
+declare const decode: <A, B, C>(s: Schema.Schema<A, B, C>) => (u: unknown) => _$effect_Effect0.Effect<A, _$effect_ParseResult0.ParseError, C>;
+//#endregion
+export { decode };
+//# sourceMappingURL=shared.d.mts.map

package/dist/modules/lib/shared.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.mts","names":[],"sources":["../../../src/modules/lib/shared.ts"],"mappings":";;;;;cAEa,MAAA,YAAmB,CAAA,EAAG,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,OACpD,CAAA,cAAU,gBAAA,CAAA,MAAA,CAAA,CAAA,EAAA,qBAAA,CAAA,UAAA,EAAA,CAAA"}

package/dist/modules/lib/shared.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/modules/lib/shared.ts
+const decode = (s) => (u) => Schema.decodeUnknown(s)(u);
+//#endregion
+export { decode };
+
+//# sourceMappingURL=shared.mjs.map

package/dist/modules/lib/shared.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.mjs","names":[],"sources":["../../../src/modules/lib/shared.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const decode = <A, B, C>(s: Schema.Schema<A, B, C>) =>\n  (u: unknown) => Schema.decodeUnknown(s)(u);\n"],"mappings":";;AAEA,MAAa,UAAmB,OAC7B,MAAe,OAAO,cAAc,EAAE,CAAC,EAAE"}

package/dist/modules/number.d.mts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import * as _$effect_ParseResult0 from "effect/ParseResult";
+
+//#region src/modules/number.d.ts
+declare const module: {
+  symbol: symbol;
+  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  lessThan: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  greaterThan: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  lessThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  greaterThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  add: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+  subtract: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+  multiply: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+  divide: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=number.d.mts.map

package/dist/modules/number.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.mts","names":[],"sources":["../../src/modules/number.ts"],"mappings":";;;;cAGa,MAAA;;gEAwDZ,qBAAA,CAAA,UAAA"}

package/dist/modules/number.mjs

@@ -0,0 +1,19 @@
+import { decode } from "./lib/shared.mjs";
+import { Effect, Schema, flow } from "effect";
+//#region src/modules/number.ts
+const module = {
+	symbol: Symbol("number"),
+	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a === b)),
+	lessThan: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a < b)),
+	greaterThan: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a > b)),
+	lessThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a <= b)),
+	greaterThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a >= b)),
+	add: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a + b)),
+	subtract: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a - b)),
+	multiply: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a * b)),
+	divide: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a / b))
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=number.mjs.map

package/dist/modules/number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.mjs","names":[],"sources":["../../src/modules/number.ts"],"sourcesContent":["import { Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"number\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  lessThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a < b)\n  ),\n\n  greaterThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a > b)\n  ),\n\n  lessThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a <= b)\n  ),\n\n  greaterThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a >= b)\n  ),\n\n  add: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a + b)\n  ),\n\n  subtract: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a - b)\n  ),\n\n  multiply: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a * b)\n  ),\n\n  divide: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a / b)\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,SAAS;CAExB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,mBAAmB,MAChB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,sBAAsB,MACnB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CACF"}

package/dist/modules/object.d.mts

@@ -0,0 +1,86 @@
+import { Effect, Schema } from "effect";
+import * as _$effect_ParseResult0 from "effect/ParseResult";
+
+//#region src/modules/object.d.ts
+declare const NotAnObjectError_base: Schema.TaggedErrorClass<NotAnObjectError, "NotAnObjectError", {
+  readonly _tag: Schema.tag<"NotAnObjectError">;
+} & {
+  actual: typeof Schema.Unknown;
+}>;
+declare class NotAnObjectError extends NotAnObjectError_base {}
+declare const KeyNotFoundError_base: Schema.TaggedErrorClass<KeyNotFoundError, "KeyNotFoundError", {
+  readonly _tag: Schema.tag<"KeyNotFoundError">;
+} & {
+  key: typeof Schema.String;
+}>;
+declare class KeyNotFoundError extends KeyNotFoundError_base {}
+declare const NotAFunctionError_base: Schema.TaggedErrorClass<NotAFunctionError, "NotAFunctionError", {
+  readonly _tag: Schema.tag<"NotAFunctionError">;
+} & {
+  key: typeof Schema.String;
+  actual: typeof Schema.Unknown;
+}>;
+declare class NotAFunctionError extends NotAFunctionError_base {}
+declare const NotAConstructorError_base: Schema.TaggedErrorClass<NotAConstructorError, "NotAConstructorError", {
+  readonly _tag: Schema.tag<"NotAConstructorError">;
+} & {
+  actual: typeof Schema.Unknown;
+}>;
+declare class NotAConstructorError extends NotAConstructorError_base {}
+declare const PathTraversalError_base: Schema.TaggedErrorClass<PathTraversalError, "PathTraversalError", {
+  readonly _tag: Schema.tag<"PathTraversalError">;
+} & {
+  path: typeof Schema.String;
+  key: typeof Schema.String;
+  current: typeof Schema.Unknown;
+}>;
+declare class PathTraversalError extends PathTraversalError_base {}
+declare const EmptyPathError_base: Schema.TaggedErrorClass<EmptyPathError, "EmptyPathError", {
+  readonly _tag: Schema.tag<"EmptyPathError">;
+} & {
+  path: typeof Schema.String;
+}>;
+declare class EmptyPathError extends EmptyPathError_base {}
+declare const MethodNotFoundError_base: Schema.TaggedErrorClass<MethodNotFoundError, "MethodNotFoundError", {
+  readonly _tag: Schema.tag<"MethodNotFoundError">;
+} & {
+  path: typeof Schema.String;
+  methodKey: typeof Schema.String;
+  actual: typeof Schema.Unknown;
+}>;
+declare class MethodNotFoundError extends MethodNotFoundError_base {}
+declare const IndexOutOfBoundsError_base: Schema.TaggedErrorClass<IndexOutOfBoundsError, "IndexOutOfBoundsError", {
+  readonly _tag: Schema.tag<"IndexOutOfBoundsError">;
+} & {
+  index: typeof Schema.Number;
+  length: typeof Schema.Number;
+}>;
+declare class IndexOutOfBoundsError extends IndexOutOfBoundsError_base {}
+declare const NotAnArrayError_base: Schema.TaggedErrorClass<NotAnArrayError, "NotAnArrayError", {
+  readonly _tag: Schema.tag<"NotAnArrayError">;
+} & {
+  actual: typeof Schema.Unknown;
+}>;
+declare class NotAnArrayError extends NotAnArrayError_base {}
+declare const InvalidPathError_base: Schema.TaggedErrorClass<InvalidPathError, "InvalidPathError", {
+  readonly _tag: Schema.tag<"InvalidPathError">;
+} & {
+  path: typeof Schema.Unknown;
+}>;
+declare class InvalidPathError extends InvalidPathError_base {}
+declare const module: {
+  symbol: symbol;
+  get: (obj: unknown, key: string) => Effect.Effect<unknown, NotAnObjectError, never>;
+  "get-path": (obj: unknown, path: string) => Effect.Effect<unknown, NotAnObjectError | InvalidPathError | PathTraversalError | NotAnArrayError | IndexOutOfBoundsError | KeyNotFoundError, never>;
+  "json-stringify": (obj: unknown, replacer: Parameters<typeof JSON.stringify>[1], space: number) => Effect.Effect<string, NotAnObjectError, never>;
+  keys: (obj: unknown) => Effect.Effect<string[], _$effect_ParseResult0.ParseError, never>;
+  values: (obj: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
+  new: (classRef: unknown, ...args: unknown[]) => Effect.Effect<unknown, NotAConstructorError, never>;
+  "get-method": (obj: unknown, key: unknown) => Effect.Effect<any, NotAnObjectError | NotAFunctionError, never>;
+  "call-method": (obj: unknown, key: unknown, ...args: unknown[]) => Effect.Effect<any, NotAFunctionError, never>;
+  "get-method-path": (obj: unknown, path: string) => Effect.Effect<(...args: unknown[]) => unknown, NotAnObjectError | InvalidPathError | PathTraversalError | EmptyPathError | MethodNotFoundError, never>;
+  "call-method-path": (obj: unknown, path: string, ...args: unknown[]) => Effect.Effect<unknown, NotAnObjectError | InvalidPathError | PathTraversalError | EmptyPathError | MethodNotFoundError, never>;
+};
+//#endregion
+export { module };
+//# sourceMappingURL=object.d.mts.map

package/dist/modules/object.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.mts","names":[],"sources":["../../src/modules/object.ts"],"mappings":";;;;cAAsD,qBAAA;;;;;cAEhD,gBAAA,SAAyB,qBAAA;AAAA,cAEkB,qBAAA;;;;;cAE3C,gBAAA,SAAyB,qBAAA;AAAA,cAEc,sBAAA;;;;;;cAEvC,iBAAA,SAA0B,sBAAA;AAAA,cAEsC,yBAAA;;;;;cAEhE,oBAAA,SAA6B,yBAAA;AAAA,cAEkB,uBAAA;;;;;;;cAE/C,kBAAA,SAA2B,uBAAA;AAAA,cAM/B,mBAAA;;;;;cAEI,cAAA,SAAuB,mBAAA;AAAA,cAEe,wBAAA;;;;;;;cAEtC,mBAAA,SAA4B,wBAAA;AAAA,cAMhC,0BAAA;;;;;;cAEI,qBAAA,SAA8B,0BAAA;AAAA,cAKlC,oBAAA;;;;;cAEI,eAAA,SAAwB,oBAAA;AAAA,cAEkB,qBAAA;;;;;cAE1C,gBAAA,SAAyB,qBAAA;AAAA,cAkGlB,MAAA;;sBAGO,GAAA,aAAa,MAAA,CAAA,MAAA,UAAA,gBAAA;6BAQN,IAAA,aAAc,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA;mCAyBzB,QAAA,EACF,UAAA,QAAkB,IAAA,CAAK,SAAA,MAAa,KAAA,aACjC,MAAA,CAAA,MAAA,SAAA,gBAAA;kDAAA,qBAAA,CAAA,UAAA;;8BAyBU,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,oBAAA;+BAUlB,GAAA,cAAc,MAAA,CAAA,MAAA,MAAA,gBAAA,GAAA,iBAAA;gCAgBb,GAAA,cAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,MAAA,iBAAA;oCAY9B,IAAA,aAAc,MAAA,CAAA,MAAA,KAAA,IAAA,yBA9Hf,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;qCA6IE,IAAA,aAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;AAAA"}

package/dist/modules/object.mjs

@@ -0,0 +1,154 @@
+import { Effect, Record, Schema, flow } from "effect";
+//#region src/modules/object.ts
+var NotAnObjectError = class extends Schema.TaggedError("NotAnObjectError")("NotAnObjectError", { actual: Schema.Unknown }) {};
+var KeyNotFoundError = class extends Schema.TaggedError("KeyNotFoundError")("KeyNotFoundError", { key: Schema.String }) {};
+var NotAFunctionError = class extends Schema.TaggedError("NotAFunctionError")("NotAFunctionError", {
+	key: Schema.String,
+	actual: Schema.Unknown
+}) {};
+var NotAConstructorError = class extends Schema.TaggedError("NotAConstructorError")("NotAConstructorError", { actual: Schema.Unknown }) {};
+var PathTraversalError = class extends Schema.TaggedError("PathTraversalError")("PathTraversalError", {
+	path: Schema.String,
+	key: Schema.String,
+	current: Schema.Unknown
+}) {};
+var EmptyPathError = class extends Schema.TaggedError("EmptyPathError")("EmptyPathError", { path: Schema.String }) {};
+var MethodNotFoundError = class extends Schema.TaggedError("MethodNotFoundError")("MethodNotFoundError", {
+	path: Schema.String,
+	methodKey: Schema.String,
+	actual: Schema.Unknown
+}) {};
+var IndexOutOfBoundsError = class extends Schema.TaggedError("IndexOutOfBoundsError")("IndexOutOfBoundsError", {
+	index: Schema.Number,
+	length: Schema.Number
+}) {};
+var NotAnArrayError = class extends Schema.TaggedError("NotAnArrayError")("NotAnArrayError", { actual: Schema.Unknown }) {};
+var InvalidPathError = class extends Schema.TaggedError("InvalidPathError")("InvalidPathError", { path: Schema.Unknown }) {};
+const NUMERIC_KEY_REGEX = /^\d+$/;
+const isNumericKey = (key) => NUMERIC_KEY_REGEX.test(key);
+const getValueAtKey = (current, key) => {
+	if (Array.isArray(current) && isNumericKey(key)) return current[Number.parseInt(key, 10)];
+	return current[key];
+};
+const validateKeyExists = (current, key) => Effect.gen(function* () {
+	if (!Array.isArray(current) && isNumericKey(key)) return yield* new NotAnArrayError({ actual: current });
+	const index = isNumericKey(key) ? Number.parseInt(key, 10) : -1;
+	if (Array.isArray(current) && index >= 0) {
+		if (index >= current.length) return yield* new IndexOutOfBoundsError({
+			index,
+			length: current.length
+		});
+	} else if (!(key in current)) return yield* new KeyNotFoundError({ key });
+});
+const traversePath = (obj, path, keys) => Effect.gen(function* () {
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (key === void 0) return yield* new PathTraversalError({
+			path,
+			key: String(i),
+			current
+		});
+		if (typeof current !== "object" || current === null) return yield* new PathTraversalError({
+			path,
+			key: String(key),
+			current
+		});
+		if (!(key in current)) return yield* new PathTraversalError({
+			path,
+			key: String(key),
+			current
+		});
+		current = getValueAtKey(current, key);
+	}
+	return current;
+});
+const getMethodFromObject = (obj, methodKey, path) => Effect.gen(function* () {
+	if (methodKey === void 0 || methodKey === "") return yield* new EmptyPathError({ path });
+	if (typeof obj !== "object" || obj === null) return yield* new PathTraversalError({
+		path,
+		key: String(methodKey),
+		current: obj
+	});
+	const method = obj[methodKey];
+	if (typeof method !== "function") return yield* new MethodNotFoundError({
+		path,
+		methodKey: String(methodKey),
+		actual: method
+	});
+	return method;
+});
+const module = {
+	symbol: Symbol("object"),
+	get: (obj, key) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		return obj[key];
+	}),
+	"get-path": (obj, path) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		if (typeof path !== "string") return yield* new InvalidPathError({ path });
+		const keys = path.split(".");
+		let current = obj;
+		for (const key of keys) {
+			if (typeof current !== "object" || current === null) return yield* new PathTraversalError({
+				path,
+				key: String(key),
+				current
+			});
+			yield* validateKeyExists(current, key);
+			current = getValueAtKey(current, key);
+		}
+		return current;
+	}),
+	"json-stringify": (obj, replacer, space) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		return JSON.stringify(obj, replacer, space);
+	}),
+	keys: flow((obj) => obj, Schema.decodeUnknown(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})), Effect.map(Record.keys)),
+	values: flow((obj) => obj, Schema.decodeUnknown(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})), Effect.map(Record.values)),
+	"new": (classRef, ...args) => Effect.gen(function* () {
+		if (typeof classRef !== "function") return yield* new NotAConstructorError({ actual: classRef });
+		return new classRef(...args);
+	}),
+	"get-method": (obj, key) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		const method = obj[key];
+		if (typeof method !== "function") return yield* new NotAFunctionError({
+			key,
+			actual: method
+		});
+		return method.bind(obj);
+	}),
+	"call-method": (obj, key, ...args) => Effect.gen(function* () {
+		const method = obj[key];
+		if (typeof method !== "function") return yield* new NotAFunctionError({
+			key,
+			actual: method
+		});
+		return method.apply(obj, args);
+	}),
+	"get-method-path": (obj, path) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		if (typeof path !== "string") return yield* new InvalidPathError({ path });
+		const keys = path.split(".");
+		const targetObj = yield* traversePath(obj, path, keys);
+		return (yield* getMethodFromObject(targetObj, keys.at(-1) ?? "", path)).bind(targetObj);
+	}),
+	"call-method-path": (obj, path, ...args) => Effect.gen(function* () {
+		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
+		if (typeof path !== "string") return yield* new InvalidPathError({ path });
+		const keys = path.split(".");
+		const targetObj = yield* traversePath(obj, path, keys);
+		return (yield* getMethodFromObject(targetObj, keys.at(-1) ?? "", path)).apply(targetObj, args);
+	})
+};
+//#endregion
+export { module };
+
+//# sourceMappingURL=object.mjs.map