desmost 0.8.2 → 0.9.1

package/src/magic/incantation.ts

@@ -1,5 +1,7 @@
 import Json5 from "json5";
+import dedent from "dedent";
 
+import type { DesmostOptions } from "../options";
 import { UnrecoverableError, type Unrecoverable } from "../errors";
 
 
@@ -21,17 +23,17 @@ export abstract class Incantation<
 >
 {
 	/** Short user-facing description of what the incantation does. */
-	public abstract readonly description: string
+	abstract readonly description: string
 
 	/** The raw text sequence that matches this incantation, such as `viewport` or `hidden`. */
-	public abstract readonly identifier: string
+	abstract readonly identifier: string
 
 	/** An alternative `.identifier`, strictly for localisation purposes only. */
-	public readonly alias?: string
+	readonly alias?: string
 
 
 	/** Apply this incantation's effect to `target`, using the provided `data` if required. */
-	public abstract apply(
+	abstract apply(
 		target: Effect extends GLOBAL ? Desmos.Calculator : Desmos.ExpressionState,
 		data?: unknown,
 	): void
@@ -45,7 +47,7 @@ export abstract class Incantation<
 		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}`
+				`/${this.identifier} can only applied to ${required === "expression" ? "latex" : required} blocks, but target block has type: ${actual}`
 			);
 		}
 	}
@@ -61,10 +63,10 @@ export abstract class ArgIncantation<
 	extends Incantation<Effect>
 {
 	/** Does this incantation always require an argument to be passed? */
-	public readonly requires_arg: boolean = true
+	readonly requires_arg: boolean = true
 
 	/** What type of argument does this incantation accept? */
-	public abstract readonly arg_type: Incantation.ArgType
+	abstract readonly arg_type: Incantation.ArgType
 
 
 	/**
@@ -75,14 +77,18 @@ export abstract class ArgIncantation<
 	 * ## Notes
 	 * 
 	 * Child incantation classes should override this method, though the defaults should cover most cases (except `ArgType.ENUM`).
+	 * 
+	 * Validity checks for missing or invalid values, incorrect types, and unknown fields should be performed here, so that `.apply()` can assume the data it receives is guaranteed to be valid.
 	 */
-	public evaluate_arg(raw: string): Unrecoverable<unknown>
+	evaluate_arg(raw: string, options: DesmostOptions): 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.STRING:
+				return (options.dedent_text) ? dedent(raw): raw.trim();
+			
 			case Incantation.ArgType.OBJECT: {
 				try {
 					return Json5.parse(`{${raw}}`);
@@ -94,9 +100,53 @@ export abstract class ArgIncantation<
 			}
 		}
 	}
+
+	protected require_nonempty(
+		arg: object,
+		msg?: string,
+		info?: UnrecoverableError.Info,
+	): Unrecoverable<void>
+	{
+		if (Object.entries(arg).length === 0) {
+			throw new UnrecoverableError.MissingInput(
+				msg ?? `/${this.identifier} received an empty argument {}`,
+				info,
+			);
+		}
+	}
+
+	protected require_known(
+		arg: object,
+		valid_fields: string[],
+		info?: UnrecoverableError.Info,
+	): Unrecoverable<void>
+	{
+		// TODO accumulate
+		for (let field of Object.keys(arg)) {
+			if (!valid_fields.includes(field)) {
+				throw new UnrecoverableError.InvalidArgument(
+					`/${this.identifier} received invalid field: ${field}`,
+					{
+						hint: `Valid fields are [${valid_fields.join(", ")}]`,
+						...info,
+					}
+				);
+			}
+		}
+	}
 }
 
 
+/** An incantation that affects the entire Desmos calculator state, like `/desmos` or `/viewport`. */
+export type GLOBAL = Incantation.Effect.GLOBAL;
+
+/** An incantation that affects only the expression immediately following it, like `/hide` or `/slider`. */
+export type LOCAL = Incantation.Effect.LOCAL;
+
+/** An incantation that produces an expression, like `/latex` or `/text`. */
+export type EXPR = Incantation.Effect.EXPR;
+
+
 export namespace Incantation
 {
 	/** The kind of effect an incantation produces - it either modifies only one block, or modifies the calculator as a whole. */
@@ -128,16 +178,3 @@ export namespace Incantation
 		OBJECT = "Object",
 	}
 }
-
-
-// == ALIASES == //
-
-/** An incantation that affects the entire Desmos calculator state, like `/desmos` or `/viewport`. */
-export type GLOBAL = Incantation.Effect.GLOBAL;
-
-/** An incantation that affects only the expression immediately following it, like `/hide` or `/slider`. */
-export type LOCAL = Incantation.Effect.LOCAL;
-
-/** An incantation that produces an expression, like `/latex` or `/text`. */
-export type EXPR = Incantation.Effect.EXPR;
-

package/src/magic/local/anim.ts

@@ -11,7 +11,6 @@ export class AnimIncantation extends Incantation<LOCAL>
 	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

@@ -1,13 +1,14 @@
 import { Incantation, ArgIncantation, type LOCAL } from "../incantation";
-import { UnrecoverableError } from "../../errors";
 
 import { DesmosColour } from "../../desmos";
+import { UnrecoverableError } from "../../errors";
+import type { DesmostOptions } from "../../options";
 
 
 export class ColourIncantation extends ArgIncantation<LOCAL>
 {
 	override readonly description
-		= ""
+		= "Change the colour of a rendered expression, such as a line, region, polygon, etc."
 
 	override readonly identifier   = "color"
 	override readonly alias        = "colour"
@@ -20,7 +21,7 @@ export class ColourIncantation extends ArgIncantation<LOCAL>
 		target.color = data;
 	}
 
-	override evaluate_arg(data: string): DesmosColour
+	override evaluate_arg(data: string, options: DesmostOptions): DesmosColour
 	{
 		switch (data.trim().toUpperCase()) {
 			case "RED":    return DesmosColour.RED;

package/src/magic/local/label.ts

@@ -1,15 +1,24 @@
-import { UnrecoverableError } from "../../errors";
 import { Incantation, ArgIncantation, type LOCAL } from "../incantation";
 
+import { UnrecoverableError } from "../../errors";
+import type { DesmostOptions } from "../../options";
+
 
 interface LabelOptions
 {
 	text: string;
 	show?: boolean;
-	size?: number | keyof typeof Desmos.LabelSizes;
-	pos?: keyof typeof Desmos.LabelOrientations;
+	size?: number;
+	pos?: "ABOVE" | "BELOW" | "LEFT" | "RIGHT" | "ABOVE_LEFT" | "ABOVE_RIGHT" | "BELOW_LEFT" | "BELOW_RIGHT";
 }
 
+const VALID_FIELDS = ["text", "show", "size", "pos"];
+
+const VALID_POSITIONS = [
+	"ABOVE", "BELOW", "LEFT", "RIGHT",
+	"ABOVE_LEFT", "ABOVE_RIGHT", "BELOW_LEFT", "BELOW_RIGHT",
+];
+
 
 export class LabelIncantation extends ArgIncantation<LOCAL>
 {
@@ -25,36 +34,57 @@ export class LabelIncantation extends ArgIncantation<LOCAL>
 		super.require_expr_type(target.type, "expression");
 		target.label = data.text;
 		target.showLabel = data.show ?? true;
-		// @ts-expect-error: outdated types TODO check
+		// @ts-expect-error: outdated types
 		if (data.size != undefined) target.labelSize = data.size;
+		// @ts-expect-error: outdated types
 		if (data.pos  != undefined) target.labelOrientation = data.pos;
 	}
 
-	override evaluate_arg(raw: string): LabelOptions
+	override evaluate_arg(raw: string, options: DesmostOptions): LabelOptions
 	{
-		let out = super.evaluate_arg(raw) as LabelOptions;
+		let out = super.evaluate_arg(raw, options) as LabelOptions;
+
+		if (options.check_args) {
+			super.require_nonempty(out, `/label received empty argument`, {
+				hint: `You can provide [${VALID_FIELDS.join(", ")}]`,
+				flagged_by: "check_args",
+			});
 
-		if (!("text" in out)) {
-			throw new UnrecoverableError.InvalidArgument(
-				`/label requires a \`text\` argument, such as: \`/label{ text: "sup world!" }\``
-			);
+			if (!("text" in out)) {
+				throw new UnrecoverableError.MissingInput(
+					`/label is missing label text`,
+					{
+						hint: `Provide text for the label: \`/label{text: "sup world!"}\``,
+						flagged_by: "check_args",
+					}
+				);
+			}
+
+			super.require_known(out, VALID_FIELDS);
 		}
 
 		if (typeof out.pos != "undefined") {
-			let pos = out.pos.trim().toUpperCase();
-
-			switch (pos) {
-				case "ABOVE":
-				case "BELOW":
-				case "LEFT":
-				case "RIGHT":
-					out.pos = pos;
-					break;
-				
-				default:
+			let pos = out.pos.trim().toUpperCase().replaceAll("-", "_");
+
+			if (VALID_POSITIONS.includes(pos)) {
+				// @ts-expect-error: validated
+				out.pos = pos;
+			}
+			else {
+				// @ts-expect-error: indexing
+				let orientation = Desmos.LabelOrientations[pos];
+
+				if (options.check_args && orientation == undefined) {
 					throw new UnrecoverableError.InvalidArgument(
-						`/label: Invalid label position: ${pos}`
+						`/label received invalid label position: ${pos}`,
+						{
+							hint: `Valid label positions are ${VALID_POSITIONS.join(", ")}`,
+							flagged_by: "check_args"
+						}
 					);
+				}
+				
+				out.pos = orientation;
 			}
 		}
 

package/src/magic/local/line.ts

@@ -1,13 +1,18 @@
 import { Incantation, ArgIncantation, type LOCAL } from "../incantation";
 
+import type { DesmostOptions } from "../../options";
+import { type Unrecoverable } from "../../errors";
+
 
 interface LineOptions
 {
-	style?:   keyof typeof Desmos.Styles;  // TODO allow raw enum
+	style?:   keyof typeof Desmos.Styles;
 	width?:   number;
 	opacity?: number;
 }
 
+const VALID_FIELDS = ["style", "width", "opacity"];
+
 
 export class LineIncantation extends ArgIncantation<LOCAL>
 {
@@ -22,8 +27,20 @@ export class LineIncantation extends ArgIncantation<LOCAL>
 	{
 		super.require_expr_type(target.type, "expression");
 		
-		if (data.style != undefined)   target.lineStyle   = data.style;
-		if (data.width != undefined)   target.lineWidth   = data.width;
+		if (data.style   != undefined) target.lineStyle   = data.style;
+		if (data.width   != undefined) target.lineWidth   = data.width;
 		if (data.opacity != undefined) target.lineOpacity = data.opacity;
 	}
+
+	override evaluate_arg(raw: string, options: DesmostOptions): Unrecoverable<LineOptions>
+	{
+		let out = super.evaluate_arg(raw, options) as LineOptions;
+
+		if (options.check_args) {
+			super.require_nonempty(out);
+			super.require_known(out, VALID_FIELDS);
+		}
+
+		return out;
+	}
 }

package/src/magic/local/slider.ts

@@ -3,8 +3,8 @@ import { Incantation, ArgIncantation, type LOCAL } from "../incantation";
 
 interface SliderBounds
 {
-	min?:  number | string;
-	max?:  number | string;
+	min:   number | string;
+	max:   number | string;
 	step?: number | string;
 }
 
@@ -21,7 +21,6 @@ export class SliderIncantation extends ArgIncantation<LOCAL>
 	override apply(target: Desmos.ExpressionState, data: SliderBounds)
 	{
 		super.require_expr_type(target.type, "expression");
-		// @ts-expect-error: outdated types
 		target.sliderBounds = data;
 	}
 }

package/src/{compiler/options.ts → options.ts}

@@ -1,11 +1,30 @@
+import { LINE } from "./utils";
+import { compile } from "./compiler/compile";
+
+
 /**
  * Options to customise Desmost compilation.
  * 
- * To customise compilation, pass in a `DesmostOptions` object as the last argument to `compile()`:
+ * To customise compilation, pass in a `DesmostOptions` object as the last argument to {@linkcode compile()}:
  * 
  * ```ts
  * compile(calc, source, { errors: "crash" });
  * ```
+ * 
+ * ## Decompilation
+ * 
+ * The same options can also be applied to decompilation:
+ * 
+ * ```ts
+ * decompile(calc, blank, { prettify: false });
+ * ```
+ * 
+ * Here, this means “decompile into source code that would reproduce `calc`, *when compiled with these options*”. As an identity:
+ * 
+ * ```ts
+ * let options = { ... };
+ * compile(_, decompile(calc, _ options), options) == calc  // (value equality)
+ * ```
  */
 export interface DesmostOptions
 {
@@ -19,7 +38,7 @@ export interface DesmostOptions
 	 * 
 	 * - `suppress`: Silently fail on the frontend (if you wish to give the illusion that everything is fine).
 	 */
-	errors?: "surface" | "crash" | "suppress"
+	errors: "surface" | "crash" | "suppress"
 
 	/**
 	 * Where should errors be placed?
@@ -28,7 +47,7 @@ export interface DesmostOptions
 	 * - `end`: All aggregated at the end of the Desmos expressions list.
 	 * - `start`: All aggregated at the start of the Desmos expressions list.
 	 */
-	place_errors?: "inline" | "end" | "start"
+	place_errors: "inline" | "end" | "start"
 
 	/**
 	 * The prefix to prepend to error blocks.
@@ -37,42 +56,67 @@ export interface DesmostOptions
 	 * 
 	 * Provide a `""` blank string if you wish for no prefix to be added.
 	 */
-	error_prefix?: string
+	error_prefix: string
+
+	/**
+	 * Show all the available diagnostics for errors, including hints and debug information?
+	 * 
+	 * Defaults to `true`, meaning all output is shown.
+	 */
+	expand_errors: boolean
+
+	/**
+	 * Error if an incantation receives a `{}` object argument with unknown fields, or no fields at all?
+	 * 
+	 * For instance, `/label{position: LEFT}` is invalid; it should be `/label{pos: LEFT}`. With `check_args: false`, this silently no-ops.
+	 * 
+	 * Desmost doesn’t remove unknown fields, it just passes them directly to the Desmos API. If you know what you’re doing and a field you know exists isn’t supported by Desmos, you can disable this to avoid erroring.
+	 * 
+	 * Defaults to `true`, meaning arguments are checked. The Desmos API happily accepts and ignores invalid fields, so Desmost provides a safety net for you ;)
+	 */
+	check_args: boolean
 
 	/**
 	 * Prettify LaTeX output so it renders nicely in the Desmos editor?
 	 * 
 	 * Defaults to `true`, meaning LaTeX is prettified.
 	 */
-	prettify?: boolean
+	prettify: boolean
+
+	/**
+	 * Strip common indentation from `/text{}` blocks?
+	 * 
+	 * Defaults to `true`, meaning text is dedented.
+	 */
+	dedent_text: boolean
 
 	/**
 	 * Should `%` LaTeX comments be ignored, instead of turned into text expressions (notes)?
 	 * 
 	 * Defaults to `false`, meaning comments are kept.
 	 */
-	ignore_comments?: boolean
+	ignore_comments: boolean
 
 	/**
 	 * Should all line breaks be ignored, instead of kept as blank expressions?
 	 * 
 	 * Defaults to `false`, meaning all blank lines are kept.
 	 */
-	ignore_all_blanks?: boolean
+	ignore_all_blanks: boolean
 
 	/**
 	 * Should trailing blank lines at the start of the source be kept as blank expressions?
 	 * 
 	 * Defaults to `false`, meaning leading blank lines are ignored.
 	 */
-	keep_leading_blanks?: boolean
+	keep_leading_blanks: boolean
 
 	/**
 	 * Should trailing blank lines at the end of the source be kept as blank expressions?
 	 * 
 	 * Defaults to `false`, meaning trailing blank lines are ignored.
 	 */
-	keep_trailing_blanks?: boolean
+	keep_trailing_blanks: boolean
 
 	/**
 	 * Return debug diagnostics?
@@ -81,16 +125,19 @@ export interface DesmostOptions
 	 * 
 	 * Defaults to `false`, meaning `compile()` returns `void`.
 	 */
-	debug?: boolean
+	debug: boolean
 }
 
 
-export const DEFAULT_OPTIONS =
+export const DEFAULT_OPTIONS: DesmostOptions =
 {
    errors: "surface",
    place_errors: "inline",
-   error_prefix: "[DESMOST ERROR]\n",
+   error_prefix: `[DESMOST ERROR]\n${LINE}\n`,
+	expand_errors: true,
    prettify: true,
+	dedent_text: true,
+	check_args: false,
    ignore_comments: false,
    ignore_all_blanks: false,
    keep_leading_blanks: false,
@@ -102,10 +149,10 @@ export const DEFAULT_OPTIONS =
 /**
  * Fill in `options` with Desmost's defaults to produce a complete `DesmostOptions` config.
  */
-export function fill_defaults(options: Partial<DesmostOptions> | undefined): Required<DesmostOptions>
+export function fill_defaults(options: Partial<DesmostOptions> | undefined): DesmostOptions
 {
    return {
       ...DEFAULT_OPTIONS,
       ...options,
-   } as Required<DesmostOptions>;
+   };
 }

package/src/parser/desmost-parser.ts

@@ -1,7 +1,7 @@
 import { GenericParser } from "./generic-parser";
 import { Ast } from "./ast";
 
-import type { DesmostOptions } from "../compiler";
+import type { DesmostOptions } from "../options";
 import { NO_MATCH, UnrecoverableError } from "../errors";
 import type { NoMatch, Unrecoverable } from "../errors";
 import * as utils from "../utils";
@@ -468,20 +468,26 @@ export class DesmostParser extends GenericParser
 		}
 
 		/* NOTE: Cut in by 1 on both sides to exclude {} braces */
-		let out = utils.chars(this.source, init + 1, this.i - 1);
+		let raw = utils.chars(this.source, init + 1, this.i - 1);
 		
 		for (let [i, j] of utils.reversing(utils.paired(indices_to_insert_quotes))) {
 			i -= init + 1;
 			j -= init + 1;
 
-			let value = out.slice(i, j).join("");
+			let value = raw.slice(i, j).join("");
 			if (["true", "false", "null", "undefined"].includes(value)) continue;
 			
-			out.splice(j, 0, `"`);
-			out.splice(i, 0, `"`);
+			raw.splice(j, 0, `"`);
+			raw.splice(i, 0, `"`);
 		}
 
-		return out.join("").trim();
+		let out = raw.join("");
+
+		if (arg_type !== Incantation.ArgType.STRING) {
+			out = out.trim();
+		}
+
+		return out;
 	}
 }
 

package/src/parser/generic-parser.ts

@@ -48,14 +48,6 @@ export class GenericParser
 		return this.source.at(this.i);
 	}
 
-	/**
-	 * Get the character *after* the current one that the parser points at.
-	 */
-	protected next(): string | undefined
-	{
-		return this.source.at(this.i + 1);
-	}
-
 	/**
 	 * Peek a snippet of the upcoming source text.
 	 * 
@@ -64,7 +56,11 @@ export class GenericParser
 	public preview(idx?: number): string
 	{
 		idx ??= this.i;
-		return this.source.slice(idx, idx + 20) + "...";
+
+		return (
+			this.source.slice(idx, idx + 20).replaceAll("\n", " ")
+			+ (idx + 20 >= this.length ? "⏎" : "...")
+		);
 	}
 
 	/**
@@ -140,7 +136,7 @@ export class GenericParser
 
 		while (this.current === raw[ii]) {
 			let r = this.try_advance();
-			if (r === NO_MATCH) return NO_MATCH;
+			if (r === NO_MATCH) return NO_MATCH;  // FIXME?
 
 			ii++;
 			if (ii === raw.length) return;
@@ -167,14 +163,18 @@ export class GenericParser
 	/**
 	 * Consume 0 or more whitespace characters.
 	 * 
-	 * Same as `.consume_spaces()`, but allows newlines.
+	 * Same as `.consume_spaces()`, but allows tabs and newlines.
 	 */
 	protected consume_whitespace(): void
 	{
 		/* NOTE: Callers should be able to assume this is safe to call even when at end of input, since it should just match 0 characters */
 		if (this.i >= this.length) return;
 
-		while (this.current === " " || this.current === "\n") {
+		while (
+			this.current === " "
+			|| this.current === "\n"
+			|| this.current === "\t"
+		) {
 			this.advance();
 		}
 	}

package/src/parser/readme.md

@@ -11,6 +11,8 @@ The parser is split into `DesmostParser` and `GenericParser`.
 
 The parser is stateful, tracking its current position in the source text with its `.i` field.
 
+`parse_next()` is the only method consumers need to be aware of, the rest is implementation detail. Would love to make them `private`, unfortunately we need them public for unit testing ;)
+
 
 ## Backtracking
 

package/src/utils.ts

@@ -1,3 +1,6 @@
+export const LINE = '—'.repeat(10);
+
+
 export function* reversing<T>(items: ArrayLike<T>): Generator<T>
 {
 	for (let i = items.length - 1; i >= 0; i--) {

package/svelte/desmost.svelte

@@ -141,9 +141,11 @@ onMount(() =>
       inject(el_desmos, source.textContent);
     }
     else {
-      let observer = new IntersectionObserver(() => {
-        inject(el_desmos, source.textContent);
-        observer.disconnect();
+      let observer = new IntersectionObserver(([entry]) => {
+        if (entry.isIntersecting) {
+          inject(el_desmos, source.textContent);
+          observer.disconnect();
+        }
       });
       observer.observe(el_desmos);
       lazy_observers.push(observer);

package/dist/compiler/options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/compiler/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAE9B;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,UAAU,CAAA;IAEzC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAA;IAEzC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IAEzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAE3B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAE7B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAE9B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAGD,eAAO,MAAM,eAAe;;;;;;;;;;CAW3B,CAAC;AAGF;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,GAAG,QAAQ,CAAC,cAAc,CAAC,CAMpG"}

package/dist/compiler/options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/compiler/options.ts"],"names":[],"mappings":"AAuFA,MAAM,CAAC,MAAM,eAAe,GAC5B;IACG,MAAM,EAAE,SAAS;IACjB,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,mBAAmB;IACjC,QAAQ,EAAE,IAAI;IACd,eAAe,EAAE,KAAK;IACtB,iBAAiB,EAAE,KAAK;IACxB,mBAAmB,EAAE,KAAK;IAC1B,oBAAoB,EAAE,KAAK;IAC3B,KAAK,EAAE,KAAK;CACd,CAAC;AAGF;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAA4C;IAEvE,OAAO;QACJ,GAAG,eAAe;QAClB,GAAG,OAAO;KACgB,CAAC;AACjC,CAAC"}