desmost 0.7.2 → 0.8.0

package/src/desmos.ts

@@ -4,10 +4,10 @@
 
 export enum DesmosColour
 {
-  RED    = "#c74440",
-  BLUE   = "#2d70b3",
-  GREEN  = "#388c46",
-  PURPLE = "#6042a6",
-  ORANGE = "#fa7e19",
-  BLACK  = "#000000",
+	RED    = "#c74440",
+	BLUE   = "#2d70b3",
+	GREEN  = "#388c46",
+	PURPLE = "#6042a6",
+	ORANGE = "#fa7e19",
+	BLACK  = "#000000",
 }

package/src/errors.ts

@@ -7,24 +7,24 @@ export class UnrecoverableError extends Error {}
 
 export namespace UnrecoverableError
 {
-  /** The parser unexpectedly reached the end of its entire input source code. */
-  export class UnexpectedEnd extends UnrecoverableError {}
+	/** The parser unexpectedly reached the end of its entire input source code. */
+	export class UnexpectedEnd extends UnrecoverableError {}
 
-  /** The parser did not receive input that it expected. */
-  export class MissingInput extends UnrecoverableError {}
+	/** The parser did not receive input that it expected. */
+	export class MissingInput extends UnrecoverableError {}
 
-  /** The parser received input that did not match what it expected. */
-  export class UnexpectedInput extends UnrecoverableError {}
+	/** The parser received input that did not match what it expected. */
+	export class UnexpectedInput extends UnrecoverableError {}
 
-  /** The parser received excess input that it did not expect. */
-  export class ExcessInput extends UnrecoverableError {}
+	/** The parser received excess input that it did not expect. */
+	export class ExcessInput extends UnrecoverableError {}
 
 
-  /** An incantation can't be applied here. */
-  export class IllegalIncantation extends UnrecoverableError {}
+	/** An incantation can't be applied here. */
+	export class IllegalIncantation extends UnrecoverableError {}
 
-  /** An incantation's argument couldn't be parsed. */
-  export class InvalidArgument extends UnrecoverableError {}
+	/** An incantation's argument couldn't be parsed. */
+	export class InvalidArgument extends UnrecoverableError {}
 }
 
 

package/src/index.internal.ts

@@ -2,3 +2,5 @@ export { fill_defaults } from "./compiler/options";
 export type { DesmostDebug } from "./compiler/compile";
 
 export { Ast } from "./parser";
+
+export { desmos_to_ast, ast_to_source } from "./decompiler/decompile";

package/src/index.ts

@@ -1 +1,2 @@
 export { compile, type DesmostOptions } from "./compiler";
+export { decompile } from "./decompiler";

package/src/magic/expr/index.ts

@@ -6,6 +6,6 @@ import { TextIncantation } from "./text";
 
 export const EXPR_INCANTATIONS: ArgIncantation<EXPR>[] =
 [
-  new LatexIncantation(),
-  new TextIncantation(),
+	new LatexIncantation(),
+	new TextIncantation(),
 ];

package/src/magic/expr/latex.ts

@@ -3,22 +3,22 @@ import { Incantation, ArgIncantation, type EXPR } from "../incantation";
 
 export class LatexIncantation extends ArgIncantation<EXPR>
 {
-  override readonly description
-    = "Produce a LaTeX expression. This allows the input to span multiple lines."
-  
-  override readonly identifier   = "latex"
-  override readonly requires_arg = true
-  override readonly arg_type     = Incantation.ArgType.LATEX
+	override readonly description
+		= "Produce a LaTeX expression. This allows the input to span multiple lines."
+	
+	override readonly identifier   = "latex"
+	override readonly requires_arg = true
+	override readonly arg_type     = Incantation.ArgType.LATEX
 
-  apply(target: Desmos.ExpressionState, data: string): void
-  {
-    target.type = "expression";
-    // @ts-expect-error: outdated types
-    target.latex = data === "" ? " " : data;
-  }
+	apply(target: Desmos.ExpressionState, data: string): void
+	{
+		target.type = "expression";
+		// @ts-expect-error: outdated types
+		target.latex = data === "" ? " " : data;
+	}
 
-  override evaluate_arg(data: string): string
-  {
-    return data;
-  }
+	override evaluate_arg(data: string): string
+	{
+		return data;
+	}
 }

package/src/magic/expr/text.ts

@@ -3,18 +3,18 @@ import { Incantation, ArgIncantation, type EXPR } from "../incantation";
 
 export class TextIncantation extends ArgIncantation<EXPR>
 {
-  override readonly description
-    = "Produce a text expression (“Add Note” in the Desmos GUI)."
-  
-  override readonly identifier   = "text"
-  override readonly alias        = "note"
-  override readonly requires_arg = true
-  override readonly arg_type     = Incantation.ArgType.STRING
+	override readonly description
+		= "Produce a text expression (“Add Note” in the Desmos GUI)."
+	
+	override readonly identifier   = "text"
+	override readonly alias        = "note"
+	override readonly requires_arg = true
+	override readonly arg_type     = Incantation.ArgType.STRING
 
-  override apply(target: Desmos.ExpressionState, data: string)
-  {
-    target.type = "text";
-    // @ts-expect-error: outdated types
-    target.text = data;
-  }
+	override apply(target: Desmos.ExpressionState, data: string)
+	{
+		target.type = "text";
+		// @ts-expect-error: outdated types
+		target.text = data;
+	}
 }

package/src/magic/global/dark-mode.ts

@@ -3,15 +3,15 @@ import { Incantation, type GLOBAL } from "../incantation";
 
 export class DarkModeIncantation extends Incantation<GLOBAL>
 {
-  override readonly description
-    = "Enable dark mode for the calculator, which inverts all colours."
-  
-  override readonly identifier = "dark"
+	override readonly description
+		= "Enable dark mode for the calculator, which inverts all colours."
+	
+	override readonly identifier = "dark"
 
-  apply(target: Desmos.Calculator)
-  {
-    target.updateSettings({
-      invertedColors: true,
-    });
-  }
+	apply(target: Desmos.Calculator)
+	{
+		target.updateSettings({
+			invertedColors: true,
+		});
+	}
 }

package/src/magic/global/desmos.ts

@@ -3,20 +3,20 @@ import { Incantation, ArgIncantation, type GLOBAL } from "../incantation";
 
 export class DesmosIncantation extends ArgIncantation<GLOBAL>
 {
-  override readonly description
-    = "Set the configuration of the calculator via `Calculator.updateSettings()`."
-  
-  override readonly identifier   = "desmos"
-  override readonly requires_arg = false
-  override readonly arg_type     = Incantation.ArgType.OBJECT
+	override readonly description
+		= "Set the configuration of the calculator via `Calculator.updateSettings()`."
+	
+	override readonly identifier   = "desmos"
+	override readonly requires_arg = false
+	override readonly arg_type     = Incantation.ArgType.OBJECT
 
-  override apply(
-    target: Desmos.Calculator,
-    data?: Desmos.GraphConfiguration & Desmos.GraphSettings,
-  ): void
-  {
-    if (data != undefined) {
-      target.updateSettings(data);
-    }
-  }
+	override apply(
+		target: Desmos.Calculator,
+		data?: Desmos.GraphConfiguration & Desmos.GraphSettings,
+	): void
+	{
+		if (data != undefined) {
+			target.updateSettings(data);
+		}
+	}
 }

package/src/magic/global/index.ts

@@ -1,3 +1,8 @@
+export { DesmosIncantation } from "./desmos";
+export { ViewportIncantation } from "./viewport";
+export { DarkModeIncantation } from "./dark-mode";
+
+
 import { Incantation, type GLOBAL } from "../incantation";
 
 import { DesmosIncantation } from "./desmos";
@@ -7,7 +12,7 @@ import { DarkModeIncantation } from "./dark-mode";
 
 export const GLOBAL_INCANTATIONS: Incantation<GLOBAL>[] =
 [
-  new DesmosIncantation(),
-  new ViewportIncantation(),
-  new DarkModeIncantation(),
+	new DesmosIncantation(),
+	new ViewportIncantation(),
+	new DarkModeIncantation(),
 ];

package/src/magic/global/viewport.ts

@@ -3,24 +3,31 @@ import { Incantation, ArgIncantation, type GLOBAL } from "../incantation";
 
 interface ViewportBounds
 {
-  left:   number; right: number;
-  bottom: number; top:   number;
+	left?:   number; right?: number;
+	bottom?: number; top?:   number;
 }
 
 
 export class ViewportIncantation extends ArgIncantation<GLOBAL>
 {
-  override readonly description
-    = "Set the bounds of the viewport via `Calculator.setMathBounds()`."
-  
-  override readonly identifier   = "viewport"
-  override readonly requires_arg = true
-  override readonly arg_type     = Incantation.ArgType.OBJECT
+	override readonly description
+		= "Set the bounds of the viewport via `Calculator.setMathBounds()`."
+	
+	override readonly identifier   = "viewport"
+	override readonly requires_arg = true
+	override readonly arg_type     = Incantation.ArgType.OBJECT
 
-  apply(target: Desmos.Calculator, data: ViewportBounds)
-  {
-    // FIXME broken?
-    // TODO validate bounds
-    target.setMathBounds(data);
-  }
+	apply(target: Desmos.Calculator, data: ViewportBounds)
+	{
+		let existing = target.graphpaperBounds.mathCoordinates;
+
+		let {
+			left   = existing.left,
+			right  = existing.right,
+			bottom = existing.bottom,
+			top    = existing.top,
+		} = data;
+
+		target.setMathBounds({ left, right, bottom, top });
+	}
 }

package/src/magic/incantation.ts

@@ -17,38 +17,38 @@ import { UnrecoverableError, type Unrecoverable } from "../errors";
  * Incantations that accept an argument derive from `ArgIncantation`.
  */
 export abstract class Incantation<
-  Effect extends Incantation.Effect = Incantation.Effect
+	Effect extends Incantation.Effect = Incantation.Effect
 >
 {
-  /** Short user-facing description of what the incantation does. */
-  public abstract readonly description: string
-
-  /** The raw text sequence that matches this incantation, such as `viewport` or `hidden`. */
-  public abstract readonly identifier: string
-
-  /** An alternative `.identifier`, strictly for localisation purposes only. */
-  public readonly alias?: string
-
-
-  /** Apply this incantation's effect to `target`, using the provided `data` if required. */
-  public abstract apply(
-    target: Effect extends GLOBAL ? Desmos.Calculator : Desmos.ExpressionState,
-    data?: unknown,
-  ): void
-
-  /** Error if the `actual` type of the given expression is not `required`. */
-  protected require_expr_type<T extends Desmos.ExpressionState["type"]>(
-    actual: unknown,
-    required: T,
-  ): asserts actual is T
-  {
-    if ((actual ?? "expression") !== required)
-    {
-      throw new UnrecoverableError.IllegalIncantation(
-        `/${this.identifier} can only applied to ${required === "expression" ? "latex" : required} expressions, but target block has type: ${actual}`
-      );
-    }
-  }
+	/** Short user-facing description of what the incantation does. */
+	public abstract readonly description: string
+
+	/** The raw text sequence that matches this incantation, such as `viewport` or `hidden`. */
+	public abstract readonly identifier: string
+
+	/** An alternative `.identifier`, strictly for localisation purposes only. */
+	public readonly alias?: string
+
+
+	/** Apply this incantation's effect to `target`, using the provided `data` if required. */
+	public abstract apply(
+		target: Effect extends GLOBAL ? Desmos.Calculator : Desmos.ExpressionState,
+		data?: unknown,
+	): void
+
+	/** Error if the `actual` type of the given expression is not `required`. */
+	protected require_expr_type<T extends Desmos.ExpressionState["type"]>(
+		actual: unknown,
+		required: T,
+	): asserts actual is T
+	{
+		if ((actual ?? "expression") !== required)
+		{
+			throw new UnrecoverableError.IllegalIncantation(
+				`/${this.identifier} can only applied to ${required === "expression" ? "latex" : required} expressions, but target block has type: ${actual}`
+			);
+		}
+	}
 }
 
 
@@ -56,77 +56,77 @@ export abstract class Incantation<
  * An incantation that accepts an argument.
  */
 export abstract class ArgIncantation<
-  Effect extends Incantation.Effect = Incantation.Effect
+	Effect extends Incantation.Effect = Incantation.Effect
 >
-  extends Incantation<Effect>
+	extends Incantation<Effect>
 {
-  /** Does this incantation always require an argument to be passed? */
-  public readonly requires_arg: boolean = true
-
-  /** What type of argument does this incantation accept? */
-  public abstract readonly arg_type: Incantation.ArgType
-
-
-  /**
-   * Evaluate the argument provided to this incantation, throwing if an error is encountered.
-   * 
-   * For instance, for `/viewport{ left: -1, right: 1 }`, this returns the POJO `{ left: -1, right: 1 }`.
-   * 
-   * ## Notes
-   * 
-   * Child incantation classes should override this method, though the defaults should cover most cases (except `ArgType.ENUM`).
-   */
-  public evaluate_arg(raw: string): Unrecoverable<unknown>
-  {
-    switch (this.arg_type) {
-      case Incantation.ArgType.STRING: return raw;
-      case Incantation.ArgType.LATEX:  return raw;
-      case Incantation.ArgType.ENUM:   return raw;
-      
-      case Incantation.ArgType.OBJECT: {
-        try {
-          return Json5.parse(`{${raw}}`);
-        }
-        catch (e) {
-          // @ts-expect-error: fine
-          throw new UnrecoverableError.InvalidArgument(e.message);
-        }
-      }
-    }
-  }
+	/** Does this incantation always require an argument to be passed? */
+	public readonly requires_arg: boolean = true
+
+	/** What type of argument does this incantation accept? */
+	public abstract readonly arg_type: Incantation.ArgType
+
+
+	/**
+	 * Evaluate the argument provided to this incantation, throwing if an error is encountered.
+	 * 
+	 * For instance, for `/viewport{ left: -1, right: 1 }`, this returns the POJO `{ left: -1, right: 1 }`.
+	 * 
+	 * ## Notes
+	 * 
+	 * Child incantation classes should override this method, though the defaults should cover most cases (except `ArgType.ENUM`).
+	 */
+	public evaluate_arg(raw: string): Unrecoverable<unknown>
+	{
+		switch (this.arg_type) {
+			case Incantation.ArgType.STRING: return raw;
+			case Incantation.ArgType.LATEX:  return raw;
+			case Incantation.ArgType.ENUM:   return raw;
+			
+			case Incantation.ArgType.OBJECT: {
+				try {
+					return Json5.parse(`{${raw}}`);
+				}
+				catch (e) {
+					// @ts-expect-error: fine
+					throw new UnrecoverableError.InvalidArgument(e.message);
+				}
+			}
+		}
+	}
 }
 
 
 export namespace Incantation
 {
-  /** The kind of effect an incantation produces - it either modifies only one block, or modifies the calculator as a whole. */
-  export enum Effect
-  {
-    /** An incantation that affects the entire Desmos calculator state, like `/desmos` or `/viewport`. */
-    GLOBAL,
-
-    /** An incantation that affects only the expression immediately following it, like `/hide` or `/slider`. */
-    LOCAL,
-    
-    /** An incantation that produces an expression, like `/latex` or `/text`. */
-    EXPR,
-  }
-
-  /** The type of argument an incantation accepts, which affects how it is parsed. */
-  export enum ArgType
-  {
-    /** Any arbitrary user text content, where characters like `"` and `'` don't have semantic meaning and can be ignored. */
-    STRING = "String",
-
-    /** LaTeX, which should have balanced `{}` braces. */
-    LATEX = "LaTeX",
-
-    /** Specific value from an allowed set of values, which will map to an enum value in the Desmos API. */
-    ENUM = "Enum",
-
-    /** JavaScript object fields, where characters like `{}` and `"` all have semantic meaning, and must be balanced. */
-    OBJECT = "Object",
-  }
+	/** The kind of effect an incantation produces - it either modifies only one block, or modifies the calculator as a whole. */
+	export enum Effect
+	{
+		/** An incantation that affects the entire Desmos calculator state, like `/desmos` or `/viewport`. */
+		GLOBAL,
+
+		/** An incantation that affects only the expression immediately following it, like `/hide` or `/slider`. */
+		LOCAL,
+		
+		/** An incantation that produces an expression, like `/latex` or `/text`. */
+		EXPR,
+	}
+
+	/** The type of argument an incantation accepts, which affects how it is parsed. */
+	export enum ArgType
+	{
+		/** Any arbitrary user text content, where characters like `"` and `'` don't have semantic meaning and can be ignored. */
+		STRING = "String",
+
+		/** LaTeX, which should have balanced `{}` braces. */
+		LATEX = "LaTeX",
+
+		/** Specific value from an allowed set of values, which will map to an enum value in the Desmos API. */
+		ENUM = "Enum",
+
+		/** JavaScript object fields, where characters like `{}` and `"` all have semantic meaning, and must be balanced. */
+		OBJECT = "Object",
+	}
 }
 
 

package/src/magic/local/anim.ts

@@ -3,15 +3,15 @@ import { Incantation, type LOCAL } from "../incantation";
 
 export class AnimIncantation extends Incantation<LOCAL>
 {
-  override readonly description
-    = "Animate the slider of a block."
-  
-  override readonly identifier = "anim"
+	override readonly description
+		= "Animate the slider of a block."
+	
+	override readonly identifier = "anim"
 
-  override apply(target: Desmos.ExpressionState)
-  {
-    super.require_expr_type(target.type, "expression");
-    // @ts-expect-error: outdated types
-    target.playing = true;
-  }
+	override apply(target: Desmos.ExpressionState)
+	{
+		super.require_expr_type(target.type, "expression");
+		// @ts-expect-error: outdated types
+		target.playing = true;
+	}
 }

package/src/magic/local/colour.ts

@@ -6,33 +6,33 @@ import { DesmosColour } from "../../desmos";
 
 export class ColourIncantation extends ArgIncantation<LOCAL>
 {
-  override readonly description
-    = ""
+	override readonly description
+		= ""
 
-  override readonly identifier   = "color"
-  override readonly alias        = "colour"
-  override readonly requires_arg = true
-  override readonly arg_type     = Incantation.ArgType.ENUM
+	override readonly identifier   = "color"
+	override readonly alias        = "colour"
+	override readonly requires_arg = true
+	override readonly arg_type     = Incantation.ArgType.ENUM
 
-  override apply(target: Desmos.ExpressionState, data: DesmosColour)
-  {
-    super.require_expr_type(target.type, "expression");
-    target.color = data;
-  }
+	override apply(target: Desmos.ExpressionState, data: DesmosColour)
+	{
+		super.require_expr_type(target.type, "expression");
+		target.color = data;
+	}
 
-  override evaluate_arg(data: string): DesmosColour
-  {
-    switch (data.trim().toUpperCase()) {
-      case "RED":    return DesmosColour.RED;
-      case "BLUE":   return DesmosColour.BLUE;
-      case "GREEN":  return DesmosColour.GREEN;
-      case "PURPLE": return DesmosColour.PURPLE;
-      case "ORANGE": return DesmosColour.ORANGE;
-      case "BLACK":  return DesmosColour.BLACK;
-      default:
-        throw new UnrecoverableError(
-          `Invalid colour: \`${data}\``
-        );
-    }
-  }
+	override evaluate_arg(data: string): DesmosColour
+	{
+		switch (data.trim().toUpperCase()) {
+			case "RED":    return DesmosColour.RED;
+			case "BLUE":   return DesmosColour.BLUE;
+			case "GREEN":  return DesmosColour.GREEN;
+			case "PURPLE": return DesmosColour.PURPLE;
+			case "ORANGE": return DesmosColour.ORANGE;
+			case "BLACK":  return DesmosColour.BLACK;
+			default:
+				throw new UnrecoverableError(
+					`Invalid colour: \`${data}\``
+				);
+		}
+	}
 }

package/src/magic/local/dashed.ts

@@ -3,14 +3,14 @@ import { Incantation, type LOCAL } from "../incantation";
 
 export class DashedIncantation extends Incantation<LOCAL>
 {
-  override readonly description
-    = "Render a block as a dashed line."
-  
-  override readonly identifier = "dashed"
+	override readonly description
+		= "Render a block as a dashed line."
+	
+	override readonly identifier = "dashed"
 
-  override apply(target: Desmos.ExpressionState)
-  {
-    super.require_expr_type(target.type, "expression");
-    target.lineStyle = Desmos.Styles.DASHED;
-  }
+	override apply(target: Desmos.ExpressionState)
+	{
+		super.require_expr_type(target.type, "expression");
+		target.lineStyle = Desmos.Styles.DASHED;
+	}
 }

package/src/magic/local/fill.ts

@@ -3,22 +3,22 @@ import { Incantation, ArgIncantation, type LOCAL } from "../incantation";
 
 interface FillOptions
 {
-  opacity: number;
+	opacity: number;
 }
 
 
 export class FillIncantation extends ArgIncantation<LOCAL>
 {
-  override readonly description
-    = "Change fill styles for a rendered block."
-  
-  override readonly identifier   = "fill"
-  override readonly requires_arg = true
-  override readonly arg_type     = Incantation.ArgType.OBJECT
+	override readonly description
+		= "Change fill styles for a rendered block."
+	
+	override readonly identifier   = "fill"
+	override readonly requires_arg = true
+	override readonly arg_type     = Incantation.ArgType.OBJECT
 
-  override apply(target: Desmos.ExpressionState, data: FillOptions)
-  {
-    super.require_expr_type(target.type, "expression");
-    target.fillOpacity = data.opacity;
-  }
+	override apply(target: Desmos.ExpressionState, data: FillOptions)
+	{
+		super.require_expr_type(target.type, "expression");
+		target.fillOpacity = data.opacity;
+	}
 }