desmost 0.9.0 → 0.10.0

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,QAAiB,CAAC;AAGnC,wBAAiB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAK/D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAGxE;AAED,wBAAiB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAkB9E;AAGD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAGxE;AAGD,qBAAa,KAAK;IAGhB,SAAS,CAAC,KAAK,EAAE,MAAM;IACvB,SAAS,CAAC,IAAI,EAAE,MAAM;gBADZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM;IAItB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;CAMjD"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,QAAiB,CAAC;AAGnC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,eAAe,GAAG,IAAI,IAAI,MAAM,CAAC,UAAU,CAGhF;AAGD,wBAAiB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAK/D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAGxE;AAED,wBAAiB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAkB9E;AAGD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAGxE;AAGD,qBAAa,KAAK;IAEjB,gDAAgD;IAChD,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,gDAAgD;IAChD,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAG5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM;IAOb,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEA,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;CAMjD"}

package/dist/utils.js

@@ -1,4 +1,10 @@
 export const LINE = '—'.repeat(10);
+/**
+ * Is `expr` a Desmos LaTeX expression (as opposed to a note or table)?
+ */
+export function is_latex(expr) {
+    return (expr.type === undefined || expr.type === "expression");
+}
 export function* reversing(items) {
     for (let i = items.length - 1; i >= 0; i--) {
         yield items[i];
@@ -27,11 +33,16 @@ export function chars(s, start, stop) {
     return new Range(start ?? 0, stop ?? s.length).map(i => s[i]).toArray();
 }
 export class Range {
+    /** The lower bound of the range (inclusive). */
     start;
+    /** The upper bound of the range (exclusive). */
     stop;
     constructor(start, stop) {
-        this.start = start;
-        this.stop = stop;
+        this.start = Math.min(start, stop);
+        this.stop = Math.max(start, stop);
+    }
+    get length() {
+        return this.stop - this.start + 1;
     }
     *map(callback) {
         for (let n = this.start; n < this.stop; n++) {

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAGnC,MAAM,SAAS,CAAC,CAAC,SAAS,CAAI,KAAmB;IAEhD,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IAChB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,MAAM,CAAI,KAAkB;IAE3C,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,SAAS,CAAC,CAAC,OAAO,CAAI,KAAkB;IAE7C,IAAI,QAAQ,GAAG,IAAI,CAAC;IAEpB,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACvB,QAAQ,GAAG,IAAI,CAAC;YAChB,SAAS;QACV,CAAC;aACI,CAAC;YACL,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YACvB,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;IACF,CAAC;IAED,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACvB,OAAO,QAAQ,CAAC;IACjB,CAAC;AACF,CAAC;AAGD,MAAM,UAAU,KAAK,CAAC,CAAS,EAAE,KAAc,EAAE,IAAa;IAE7D,OAAO,IAAI,KAAK,CAAC,KAAK,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;AACzE,CAAC;AAGD,MAAM,OAAO,KAAK;IAGN;IACA;IAFX,YACW,KAAa,EACb,IAAY;QADZ,UAAK,GAAL,KAAK,CAAQ;QACb,SAAI,GAAJ,IAAI,CAAQ;IAEtB,CAAC;IAEF,CAAC,GAAG,CAAI,QAA0B;QAEjC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACF,CAAC;CACD"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAGnC;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,IAA4B;IAEpD,OAAO,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC;AAChE,CAAC;AAGD,MAAM,SAAS,CAAC,CAAC,SAAS,CAAI,KAAmB;IAEhD,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IAChB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,MAAM,CAAI,KAAkB;IAE3C,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,SAAS,CAAC,CAAC,OAAO,CAAI,KAAkB;IAE7C,IAAI,QAAQ,GAAG,IAAI,CAAC;IAEpB,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACvB,QAAQ,GAAG,IAAI,CAAC;YAChB,SAAS;QACV,CAAC;aACI,CAAC;YACL,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YACvB,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;IACF,CAAC;IAED,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACvB,OAAO,QAAQ,CAAC;IACjB,CAAC;AACF,CAAC;AAGD,MAAM,UAAU,KAAK,CAAC,CAAS,EAAE,KAAc,EAAE,IAAa;IAE7D,OAAO,IAAI,KAAK,CAAC,KAAK,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;AACzE,CAAC;AAGD,MAAM,OAAO,KAAK;IAEjB,gDAAgD;IAChC,KAAK,CAAS;IAE9B,gDAAgD;IAChC,IAAI,CAAS;IAE7B,YACC,KAAa,EACb,IAAY;QAGZ,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,GAAI,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,MAAM;QACT,OAAO,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,CAAC,GAAG,CAAI,QAA0B;QAEjC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACF,CAAC;CACD"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "desmost",
   "author": "Sup#2.0",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "MIT",
 
   "description": "A tiny DSL for compiling LaTeX to Desmos",
@@ -54,11 +54,12 @@
     "test":     "vitest run",
       "testw":  "vitest",
 
-    "check":    "npx oxlint src",
+    "check":    "npx tsc --noEmit -p tsconfig.build.json",
+    "lint":     "npx oxlint src",
 
     "doc":      "cd ../.autodoc && rake",
 
-    "prepublishOnly": "npm run test && npm run doc && npm run buildx"
+    "prepublishOnly": "nu build.nu pre-publish"
   },
 
   "dependencies":

package/src/compiler/compile.ts

@@ -1,16 +1,6 @@
-import { evaluate_global_incantation, evaluate_expr, evaluate_error } from "./evaluate";
+import { DesmostCompiler, type DesmostDebug } from "./compiler";
 
 import { type DesmostOptions, fill_defaults } from "../options";
-import { DesmostParser, Ast } from "../parser";
-
-
-/** Debug diagnostics returned from `compile()`. */
-export interface DesmostDebug
-{
-	duration: number;
-	num_blocks: number;
-	ast: Ast[];
-}
 
 
 /**
@@ -55,114 +45,11 @@ export function compile(
 		return;
 	}
 
-	let opts = fill_defaults(options);
-
-	if (opts.debug) {
-		var t_init = performance.now();
-		var num_blocks = 0;
-		var ast: Ast[] = [];
-	}
-
-	let parser = new DesmostParser(source, opts);
-
-	let errors: string[] = [];
-	
-	/* To aggregate errors at the start, we need a target to retroactively inject errors into */
-	if (opts.place_errors === "start") {
-		desmos.setExpression({ id: "deferred-start", latex: " " });  // FIXME check if ` ` needed
-	}
-
-	/* Keep track of whether we're still evaluating leading blank expressions, which might be ignored. */
-	let seen_non_blank = false;
-
-	/** The number of pending blank expressions to add. */
-	let pending_blanks: number = 0;
-
-	/* The compiler is lazy, parsing and evaluating one block at a time (as opposed to first parsing the entire AST). We don't need the whole AST, so this saves memory. */
-	/* NOTE: It also doesn't sacrifice performance, since `.setExpressions()` internally just calls `.setExpression()` in a loop anyway. Benchmarks in the frontend produce similar times for both, so there's no performance improvement. */
-	try {
-		while (true) {
-			let r = parser.parse_next();
-			if (r === null) break;
-
-			if (opts.debug) {
-				num_blocks!++;
-				ast!.push(r);
-			}
-
-			/** An error message to leave for aggregation later. */
-			let defer: string | void = undefined;
-			
-			switch (r.kind) {
-				case Ast.Kind.INCANTATION_INVOCATION:
-					defer = evaluate_global_incantation(r, desmos, opts);
-					break;
-
-				case Ast.Kind.EXPRESSION:
-					// @ts-expect-error: check type-narrows
-					if (r.data.latex === " ") {
-						if (opts.ignore_all_blanks) break;
-						if (!seen_non_blank && !opts.keep_leading_blanks) break;
-						pending_blanks++;
-						break;
-					}
-					else {
-						flush_pending_blanks(desmos, pending_blanks);
-						pending_blanks = 0;
-						
-						seen_non_blank = true;
-						defer = evaluate_expr(r, desmos, opts);
-						break;
-					}
-
-				case Ast.Kind.INVALID_INCANTATION:
-					defer = evaluate_error(r.error, desmos, opts);
-					break;
-			}
-
-			if (defer !== undefined) {
-				errors.push(defer);
-			}
-		}
-	}
-	catch (e) {
-		errors.push((e as Error).message);
-	}
-
-	if (opts.keep_trailing_blanks) {
-		flush_pending_blanks(desmos, pending_blanks);
-	}
-
-	if (errors.length > 0) {
-		let expr: Desmos.ExpressionState = {
-			type: "text",
-			text: errors.join("\n\n"),
-		};
+	let compiler = new DesmostCompiler(
+		desmos,
+		source,
+		fill_defaults(options),
+	);
 
-		switch (opts.place_errors) {
-			case "start":
-				desmos.setExpression({ ...expr, id: "deferred-start" });
-				break;
-			case "end":
-			case "inline":
-				desmos.setExpression(expr);
-				break;
-		}
-	}
-
-	if (opts.debug) {
-		return {
-			duration: performance.now() - t_init!,
-			num_blocks: num_blocks!,
-			ast: ast!,
-		};
-	}
-}
-
-
-function flush_pending_blanks(desmos: Desmos.Calculator, count: number)
-{
-	for (let i = 0; i < count; i++) {
-		desmos.setExpression({ latex: ` ` });
-	}
+	return compiler.compile();
 }

package/src/compiler/compiler.ts

@@ -0,0 +1,275 @@
+import dedent from "dedent";
+
+import { format_error, normalise_latex, prettify_latex } from "./format";
+
+import type { DesmostOptions } from "../options";
+import { DesmostError, type Fallible } from "../errors";
+import { DesmostParser, Ast } from "../parser";
+import { is_latex } from "../utils";
+
+
+/** Debug diagnostics returned from `compile()`. */
+export interface DesmostDebug
+{
+	duration: number;
+	num_blocks: number;
+	ast: Ast[];
+}
+
+
+export class DesmostCompiler
+{
+	private desmos: Desmos.Calculator
+
+	/** The source code to compile. */
+	private source: string
+
+	private options: DesmostOptions
+
+	private parser: DesmostParser
+
+	/** Accumulated errors awaiting evaluation. */
+	private errors: DesmostError[] = []
+
+	/**
+	 * Have we only seen blank lines so far?
+	 * 
+	 * This is used for excluding leading blanks.
+	 */
+	private seen_non_blank = false
+
+	/**
+	 * The number of pending blank expressions to add.
+	 * 
+	 * This is used to excluding trailing blanks.
+	 */
+	private pending_blanks: number = 0
+
+	private debug: DesmostDebug | null = null
+
+
+	/** Create a compiler for compiling `source` into `desmos`. */
+	constructor(
+		desmos: Desmos.Calculator,
+		source: string,
+		options: DesmostOptions,
+	)
+	{
+		this.desmos = desmos;
+		this.source = source;
+		this.options = options;
+		this.parser = new DesmostParser(this.source, this.options);
+	}
+
+
+	/**
+	 * Run the compiler to completion.
+	 */
+	public compile(): void | DesmostDebug
+	{
+		if (this.options.debug) {
+			this.debug = {
+				duration: performance.now(),
+				num_blocks: 0,
+				ast: [],
+			};
+		}
+
+		/* To aggregate errors at the start, we need a target to retroactively inject errors into */
+		if (this.options.place_errors === "start") {
+			this.desmos.setExpression({ id: "deferred", latex: " " });  // FIXME check if ` ` needed
+		}
+
+		/* The compiler is lazy, parsing and evaluating one block at a time (as opposed to first parsing the entire AST). We don't need the whole AST, so this saves memory. */
+		/* NOTE: It also doesn't sacrifice performance, since `.setExpressions()` internally just calls `.setExpression()` in a loop anyway. Benchmarks in the frontend produce similar times for both, so there's no performance improvement. */
+		try {
+			let done = false;
+
+			while (!done) {
+				done = this.compile_next();
+			}
+		}
+		catch (e) {
+			this.errors.push(e as Error);  // FIXME Should probably override as critical
+		}
+
+		if (this.options.keep_trailing_blanks) {
+			this.flush_pending_blanks();
+		}
+
+		/* NOTE: No need to check `options.place_errors`!
+
+			- If it's `start`, `id: deferred` will replace the placeholder at the start as required.
+			- If it's `end`, `id: deferred` won't exist so this expression will be appended as required.
+			- If it's `inline`, we shouldn't have any accumulated errors at all, but if we do, then the end is where they should be anyway.
+		*/
+		if (this.errors.length > 0) {
+			this.desmos.setExpression({
+				id: "deferred",
+				type: "text",
+				text: this.errors.map(err => format_error(err, this.options)).join("\n\n"),
+			});
+		} else {
+			this.desmos.removeExpression({ id: "deferred" });
+		}
+
+		if (this.options.debug) {
+			this.debug!.duration = performance.now() - this.debug!.duration;
+
+			return this.debug!;
+		}
+	}
+
+	/**
+	 * Compile only the next block, returning `true` if compilation has finished.
+	 */
+	compile_next(): Fallible<boolean>
+	{
+		let result = this.parser.parse_next();
+		if (result === undefined) return true;
+
+		let { blocks, errors } = result;
+
+		for (let block of blocks) {
+			this.compile_block(block);
+		}
+
+		for (let error of errors) {
+			this.evaluate_error(error);
+		}
+
+		return false;
+	}
+
+	compile_block(block: Ast): void
+	{
+		if (this.options.debug) {
+			this.debug!.num_blocks++;
+			this.debug!.ast.push(block);
+		}
+
+		switch (block.kind)
+		{
+			case Ast.Kind.INCANTATION_INVOCATION:
+				this.evaluate_global_incantation(block);
+				break;
+
+			case Ast.Kind.EXPRESSION:
+				// @ts-expect-error: check type-narrows
+				if (block.data.latex === " ") {
+					if (this.options.ignore_all_blanks) break;
+					if (!this.seen_non_blank && !this.options.keep_leading_blanks) break;
+
+					this.pending_blanks++;
+					break;
+				}
+				else {
+					this.flush_pending_blanks();
+					this.pending_blanks = 0;
+					this.seen_non_blank = true;
+
+					this.evaluate_expr(block);
+					break;
+				}
+		}
+	}
+
+
+	// == LOW-LEVEL == //
+
+	/**
+	 * Evaluate arguments (if any) to a global incantation `invocation`, then apply the incantation to `desmos`.
+	 */
+	evaluate_global_incantation(invocation: Ast.IncantationInvocation): Fallible<void>
+	{
+		let data = undefined;
+
+		if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
+			try {
+				data = invocation.incantation.evaluate_arg(invocation.arg_raw, this.options);
+				invocation.incantation.apply(this.desmos, data);
+			}
+			catch (e) {
+				this.evaluate_error(e as Error);
+			}
+		}
+	}
+
+
+	/**
+	 * Evaluate local incantation invocations on `expr`, then add `expr` to `desmos`.
+	 */
+	evaluate_expr(expr: Ast.Expression): Fallible<void>
+	{
+		for (let invocation of expr.incantations) {
+			let data = undefined;
+
+			if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
+				try {
+					data = invocation.incantation.evaluate_arg(invocation.arg_raw, this.options);
+				}
+				catch (e) {
+					this.evaluate_error(e as Error);
+					// if it needs the arg, then we can't press on
+					if (invocation.incantation.requires_arg) continue;
+				}
+			}
+
+			try {
+				invocation.incantation.apply(expr.data, data);
+			}
+			catch (e) {
+				this.evaluate_error(e as Error);
+			}
+		}
+
+		if (is_latex(expr.data)) {
+			expr.data.latex = normalise_latex(expr.data.latex!);
+
+			if (this.options.prettify) {
+				expr.data.latex = prettify_latex(expr.data.latex);
+			}
+		}
+		else if (expr.data.type === "text" && this.options.dedent_text) {
+			expr.data.text = dedent(expr.data.text ?? "");
+		}
+
+		this.desmos.setExpression(expr.data);
+	}
+
+	/**
+	 * Handle a `DesmostError`, respecting the user's options.
+	 */
+	evaluate_error(error: DesmostError): Fallible<void | string>
+	{
+		switch (this.options.errors) {
+			case "crash":
+				throw error;
+
+			case "suppress":
+				console.error(format_error(error, this.options));
+				break;
+
+			default: switch (this.options.place_errors) {
+				case "end":
+				case "start":
+					this.errors.push(error);
+					break;
+				
+				case "inline":
+					this.desmos.setExpression({
+						type: "text",
+						text: format_error(error, this.options),
+					});
+					break;
+			}
+		}
+	}
+
+	flush_pending_blanks(): void
+	{
+		for (let i = 0; i < this.pending_blanks; i++) {
+			this.desmos.setExpression({ latex: ` ` });
+		}
+	}
+}

package/src/compiler/format.ts

@@ -1,11 +1,11 @@
 import type { DesmostOptions } from "../options";
 
-import { UnrecoverableError } from "../errors";
+import { DesmostError } from "../errors";
 import { LINE } from "../utils";
 
 
 export function format_error(
-	e: UnrecoverableError,
+	e: DesmostError,
 	options: DesmostOptions,
 ): string
 {
@@ -15,12 +15,24 @@ export function format_error(
 	// TODO maybe include stack? (configurable?)
 	let display = `${prefix}${sep}${e.name}: ${e.message}`;
 
-	if (e.info != undefined && options.expand_errors) {
-		display += `\n${LINE}`;
+	if (e.data == undefined) {
+		return display;
+	}
+
+	if (e.data.show != undefined) {
+		display += `\n${LINE}\n`;
+		display += e.data.show.text;
+
+		if (e.data.show.span != undefined) {
+			display += `\n`;
+			display += ' '.repeat(e.data.show.span.start);
+			display += '^'.repeat(e.data.show.span.length);
+		}
+	}
 
-		if (e.info.hint != undefined)       display += `\nHint: ${e.info.hint}`;
-		if (e.info.note != undefined)       display += `\n${LINE}\nNote: ${e.info.note}`;
-		if (e.info.flagged_by != undefined) display += `\n${LINE}\nFlagged by: \`${e.info.flagged_by}\``;
+	if (options.expand_errors) {
+		if (e.data.hint  != undefined) display += `\n${LINE}\nHint: ${e.data.hint}`;
+		if (e.data.note  != undefined) display += `\n${LINE}\nNote: ${e.data.note}`;
 	}
 
 	return display;

package/src/decompiler/decompile.ts

@@ -1,7 +1,6 @@
 import { emit_global_incantation, emit_expression } from "./emit";
 import { extract_settings, extract_viewport, extract_expression } from "./extract";
 
-import { fill_defaults } from "../options";
 import { Ast } from "../parser";
 import type { DesmostOptions } from "../options";
 
@@ -35,18 +34,13 @@ export function decompile(
 	options?: Partial<DesmostOptions>,
 ): string
 {
-	let opts = fill_defaults(options);
 	return ast_to_source(desmos_to_ast(desmos, blank ?? desmos));
 }
 
 /**
  * Decompile `desmos` into a semi-structured AST.
  */
-export function desmos_to_ast(
-	desmos: Desmos.Calculator,
-	blank: Desmos.Calculator,
-	options: DesmostOptions,
-): SemiStructuredAst
+export function desmos_to_ast(desmos: Desmos.Calculator, blank: Desmos.Calculator): SemiStructuredAst
 {
 	return {
 		globals: [

package/src/decompiler/extract.ts

@@ -1,7 +1,7 @@
 import { stringify_json5, prettify_source } from "./format";
 
 import { Ast } from "../parser";
-import { is_latex } from "../desmos";
+import { is_latex } from "../utils";
 
 import { DesmosIncantation, ViewportIncantation } from "../magic/global";
 
@@ -19,6 +19,7 @@ export function extract_settings(
    let arg_raw = stringify_json5(
       desmos.settings,
       (k, v) => (
+            // @ts-expect-error: weird
             v === defaults[k]
          || k === "__observers"
          || k === "guid"
@@ -50,6 +51,7 @@ export function extract_viewport(
 
    let arg_raw = stringify_json5(
       { left, right, bottom, top },
+      /// @ts-expect-error: weird
       (k, v) => v === defaults[k] ? undefined : v,
       "  ",
    );

package/src/decompiler/format.ts

@@ -15,7 +15,6 @@ export const stringify_json5: (typeof JSON.stringify) = (
 export function prettify_source(source: string): string
 {
    source = source.replaceAll(/(?<=[^ ])=(?=[^ ])/g, " = ");
-   source = source.replaceAll(/\}\\/g, "} \\")
 
    return source;
 }

package/src/errors.ts

@@ -1,3 +1,6 @@
+import type { Range } from "./utils";
+
+
 /** The parser failed to parse something (usually during speculative parsing), which only results in internal backtracking. */
 export const NO_MATCH = Symbol("no-match");
 
@@ -10,51 +13,64 @@ export type NoMatch = typeof NO_MATCH & { readonly __brand?: unique symbol };
  * 
  * It's not *literally* unrecoverable in the sense that it will crash the compiler completely, but it means there are no further fallbacks to try.
  */
-export class UnrecoverableError extends Error
+export class DesmostError extends Error
 {
-	info?: UnrecoverableError.Info;
+	data?: DesmostError.Data;
+
+	constructor(msg: string | undefined, name: string) {
+		super(msg);
+      this.name = name;
+	}
 }
 
-export namespace UnrecoverableError
+export namespace DesmostError
 {
-	export interface Info
+	export interface Data
 	{
-		hint?: string,
-		note?: string,
-		flagged_by?: string,
+		msg?:   string
+		while?: string
+		hint?:  string
+		note?:  string
+		debug?: string
+
+		show?: {
+			text:  string
+			span?: Range
+		}
 	}
 
-	/** The parser unexpectedly reached the end of its entire input source code. */
-	export class UnexpectedEnd extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Unexpected End"; }
+	/** The parser unexpectedly reached the end of its source. */
+	export class UnexpectedEnd extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Unexpected End of Source"); }
 	}
 
 	/** The parser did not receive input that it expected. */
-	export class MissingInput extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Missing Input"; }
+	export class MissingInput extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Missing Input"); }
 	}
 
 	/** The parser received input that did not match what it expected. */
-	export class UnexpectedInput extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Unexpected Input"; }
+	export class UnexpectedInput extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Unexpected Input"); }
 	}
 
 	/** The parser received excess input that it did not expect. */
-	export class ExcessInput extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Excess Input"; }
+	export class ExcessInput extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Excess Input"); }
 	}
 
 	/** An incantation can't be applied here. */
-	export class IllegalIncantation extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Illegal Incantation"; }
+	export class IllegalIncantation extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Illegal Incantation"); }
 	}
 
-	/** An incantation's argument couldn't be parsed. */
-	export class InvalidArgument extends UnrecoverableError {
-		constructor(msg: string, override info?: Info) { super(msg); this.name = "Invalid Argument"; }
+	/** An incantation's argument is invalid - could be a parsing, evaluation or validation failure. */
+	export class InvalidArgument extends DesmostError {
+		constructor(override data: Data) { super(data.msg, "Invalid Argument"); }
 	}
 }
 
-
-/** Indicates that a function may throw an `UnrecoverableError`. */
-export type Unrecoverable<Result> = Result | Result & { readonly __brand?: unique symbol };
+/** Indicates that a function may throw a `DesmostError`. */
+export type Fallible<Result>
+	= Result
+	| Result & { readonly __brand?: unique symbol };