desmost 0.7.3 → 0.8.1

package/src/compiler/compile.ts

@@ -7,9 +7,9 @@ import { DesmostParser, Ast } from "../parser";
 /** Debug diagnostics returned from `compile()`. */
 export interface DesmostDebug
 {
-  duration: number;
-  num_blocks: number;
-  ast: Ast[];
+	duration: number;
+	num_blocks: number;
+	ast: Ast[];
 }
 
 
@@ -31,134 +31,134 @@ export interface DesmostDebug
  * ```
  */
 export function compile(
-  /** The Desmos calculator instance to compile into. */
-  desmos: Desmos.Calculator,
+	/** The Desmos calculator instance to compile into. */
+	desmos: Desmos.Calculator,
 
-  /** The Desmost source code to compile. */
-  source: string,
+	/** The Desmost source code to compile. */
+	source: string,
 
-  /** Compilation options. */
-  options?: DesmostOptions,
+	/** Compilation options. */
+	options?: DesmostOptions,
 ): void | DesmostDebug
 {
-  if (desmos == undefined) {
-    console.error(`Desmost: No \`Desmos.Calculator\` instance provided, aborting compilation!`);
-    return;
-  }
-
-  if (source == undefined) {
-    console.error(`Desmost: No source code provided, aborting compilation!`);
-    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: outdated types
-          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"),
-    };
-
-    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!,
-    };
-  }
+	if (desmos == undefined) {
+		console.error(`Desmost: No \`Desmos.Calculator\` instance provided, aborting compilation!`);
+		return;
+	}
+
+	if (source == undefined) {
+		console.error(`Desmost: No source code provided, aborting compilation!`);
+		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: outdated types
+					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"),
+		};
+
+		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: ` ` });
-  }
+	for (let i = 0; i < count; i++) {
+		desmos.setExpression({ latex: ` ` });
+	}
 }

package/src/compiler/evaluate.ts

@@ -1,4 +1,4 @@
-import { format_error } from "./format";
+import { format_error, normalise_latex, prettify_latex } from "./format";
 import type { DesmostOptions } from "./options";
 
 import { Ast } from "../parser";
@@ -9,24 +9,24 @@ import { UnrecoverableError, type Unrecoverable } from "../errors";
  * Evaluate arguments (if any) to a global incantation `invocation`, then apply the incantation to `desmos`.
  */
 export function evaluate_global_incantation(
-  invocation: Ast.IncantationInvocation,
-  desmos: Desmos.Calculator,
-  options: Required<DesmostOptions>,
+	invocation: Ast.IncantationInvocation,
+	desmos: Desmos.Calculator,
+	options: Required<DesmostOptions>,
 ): Unrecoverable<void | string>
 {
-  let data = undefined;
-
-  if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
-    try {
-      data = invocation.incantation.evaluate_arg(invocation.arg_raw);
-    }
-    catch (e) {
-      let msg = evaluate_error(e as Error, desmos, options);
-      return msg;
-    }
-  }
-
-  invocation.incantation.apply(desmos, data);
+	let data = undefined;
+
+	if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
+		try {
+			data = invocation.incantation.evaluate_arg(invocation.arg_raw);
+		}
+		catch (e) {
+			let msg = evaluate_error(e as Error, desmos, options);
+			return msg;
+		}
+	}
+
+	invocation.incantation.apply(desmos, data);
 }
 
 
@@ -34,53 +34,53 @@ export function evaluate_global_incantation(
  * Evaluate arguments (if any) to local incantation invocations on `expr`, then add `expr` to `desmos`.
  */
 export function evaluate_expr(
-  expr: Ast.Expression,
-  desmos: Desmos.Calculator,
-  options: Required<DesmostOptions>,
+	expr: Ast.Expression,
+	desmos: Desmos.Calculator,
+	options: Required<DesmostOptions>,
 ): Unrecoverable<void | string>
 {
-  let errors: string[] = [];
-
-  for (let invocation of expr.incantations) {
-    if (invocation.kind === Ast.Kind.INVALID_INCANTATION) {
-      let msg = evaluate_error(invocation.error, desmos, { ...options, place_errors: "start" });
-      if (msg != undefined) {
-        errors.push(msg);
-      }
-      continue;
-    }
-
-    let data = undefined;
-
-    if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
-      try {
-        data = invocation.incantation.evaluate_arg(invocation.arg_raw);
-      }
-      catch (e) {
-        errors.push(format_error(e as Error, options));
-        if (invocation.incantation.requires_arg) continue;
-      }
-    }
-
-    invocation.incantation.apply(expr.data, data);
-  }
-  
-  if (errors.length > 0) {
-    desmos.setExpression({ type: "text", text: errors.join("\n\n") });
-  }
-
-  // @ts-expect-error: outdated types
-  if (expr.data.latex != undefined) {
-    // @ts-expect-error: outdated types
-    expr.data.latex = normalise_latex(expr.data.latex);
-
-    if (options.prettify) {
-      // @ts-expect-error: outdated types
-      expr.data.latex = prettify_latex(expr.data.latex);
-    }
-  }
-
-  desmos.setExpression(expr.data);
+	let errors: string[] = [];
+
+	for (let invocation of expr.incantations) {
+		if (invocation.kind === Ast.Kind.INVALID_INCANTATION) {
+			let msg = evaluate_error(invocation.error, desmos, { ...options, place_errors: "start" });
+			if (msg != undefined) {
+				errors.push(msg);
+			}
+			continue;
+		}
+
+		let data = undefined;
+
+		if ("arg_raw" in invocation && invocation.arg_raw != undefined) {
+			try {
+				data = invocation.incantation.evaluate_arg(invocation.arg_raw);
+			}
+			catch (e) {
+				errors.push(format_error(e as Error, options));
+				if (invocation.incantation.requires_arg) continue;
+			}
+		}
+
+		invocation.incantation.apply(expr.data, data);
+	}
+	
+	if (errors.length > 0) {
+		desmos.setExpression({ type: "text", text: errors.join("\n\n") });
+	}
+
+	// @ts-expect-error: outdated types
+	if (expr.data.latex != undefined) {
+		// @ts-expect-error: outdated types
+		expr.data.latex = normalise_latex(expr.data.latex);
+
+		if (options.prettify) {
+			// @ts-expect-error: outdated types
+			expr.data.latex = prettify_latex(expr.data.latex);
+		}
+	}
+
+	desmos.setExpression(expr.data);
 }
 
 
@@ -90,62 +90,30 @@ export function evaluate_expr(
  * If the user set `place_errors: start` or `place_errors: end`, this returns the formatted error message for deferred aggregation.
  */
 export function evaluate_error(
-  error: UnrecoverableError,
-  desmos: Desmos.Calculator,
-  options: Required<DesmostOptions>,
+	error: UnrecoverableError,
+	desmos: Desmos.Calculator,
+	options: Required<DesmostOptions>,
 ): Unrecoverable<void | string>
 {
-  switch (options.errors) {
-    case "crash":
-      throw error;
-
-    case "suppress":
-      console.error(error);
-      break;
-
-    default: switch (options.place_errors) {
-      case "end":
-      case "start":
-        return format_error(error, options);
-      
-      default:
-        desmos.setExpression({
-          type: "text",
-          text: format_error(error, options),
-        });
-        break;
-    }
-  }
-}
-
-
-/**
- * Remove line breaks from `latex` so Desmos can properly consume it.
- */
-function normalise_latex(latex: string): string
-{
-  latex = latex.replaceAll(/\s+/g, " ");
-  return latex;
-}
-
-
-/**
- * Prettify `latex` to render nicely in Desmos, reflecting how you would type directly into Desmos.
- * 
- * This includes:
- * 
- * - Replace `()`, `[]`, etc. with `\left(\right)`
- * - Replace `min()`, `max()`, etc. with `\operatorname{min}()`
- */
-function prettify_latex(latex: string): string
-{
-  latex = latex.replaceAll(/(?<!\\left)(\(|\[|\\\{)/g, "\\left$1");
-  latex = latex.replaceAll(/(?<!\\right)(\)|\]|\\\})/g, "\\right$1");
-
-  latex = latex.replaceAll(
-    /(?<=[^\w]|^)\\?(mean|median|count|total|repeat|join|sort|shuffle|unique|mod|ceil|floor|round|sign) ?(?=\(|\\left\()/g,
-    "\\operatorname{$1}"
-  );
-
-  return latex;
+	switch (options.errors) {
+		case "crash":
+			throw error;
+
+		case "suppress":
+			console.error(error);
+			break;
+
+		default: switch (options.place_errors) {
+			case "end":
+			case "start":
+				return format_error(error, options);
+			
+			default:
+				desmos.setExpression({
+					type: "text",
+					text: format_error(error, options),
+				});
+				break;
+		}
+	}
 }

package/src/compiler/format.ts

@@ -4,13 +4,46 @@ import { UnrecoverableError } from "../errors";
 
 
 export function format_error(
-  e: UnrecoverableError,
-  options: Required<DesmostOptions>,
+	e: UnrecoverableError,
+	options: Required<DesmostOptions>,
 ): string
 {
-  let prefix = options.error_prefix;
-  let sep = (prefix === "" || prefix.endsWith("\n")) ? "" : " ";
+	let prefix = options.error_prefix;
+	let sep = (prefix === "" || prefix.endsWith("\n")) ? "" : " ";
 
-  return `${prefix}${sep}${e.name}: ${e.message}`;
-  // TODO maybe include stack? (configurable?)
+	return `${prefix}${sep}${e.name}: ${e.message}`;
+	// TODO maybe include stack? (configurable?)
+}
+
+
+/**
+ * Remove line breaks from `latex` so Desmos can properly consume it.
+ */
+export function normalise_latex(latex: string): string
+{
+	latex = latex.replaceAll(/\s+/g, " ");
+	return latex;
+}
+
+
+/**
+ * Prettify `latex` to render nicely in Desmos, reflecting how you would type directly into Desmos.
+ * 
+ * This includes:
+ * 
+ * - Replace `()`, `[]`, etc. with `\left(\right)`
+ * - Replace `min()`, `max()`, etc. with `\operatorname{min}()`
+ */
+export function prettify_latex(latex: string): string
+{
+	latex = latex.replaceAll(/(?<!\\left)(\(|\[|\\\{)/g, "\\left$1");
+	latex = latex.replaceAll(/(?<!\\right)(\)|\]|\\\})/g, "\\right$1");
+	latex = latex.replaceAll(/(:|,)(?!\\ ) */g, "$1\\ ");
+
+	latex = latex.replaceAll(
+		/(?<=[^\w]|^)\\?(mean|median|count|total|repeat|join|sort|shuffle|unique|mod|ceil|floor|round|sign) ?(?=\(|\\left\()/g,
+		"\\operatorname{$1}"
+	);
+
+	return latex;
 }

package/src/compiler/index.ts

@@ -1,9 +1,2 @@
-/**
- * Implements the top-level logic of the Desmost compiler.
- */
-
-// public entry point
 export { compile } from "./compile";
-
-// compilation options
 export type { DesmostOptions } from "./options";