@jbrowse/jexl 3.2.0 → 4.0.0

package/src/evaluator/compile.ts

@@ -5,13 +5,16 @@
 
 import type { Grammar } from '../grammar.ts'
 import type { AstNode, AstNodeUnion, JexlValue } from '../types.ts'
-import type Evaluator from './Evaluator.ts'
+
+/** The variables an expression is evaluated against. */
+export type Context = Record<string, JexlValue>
 
 /**
- * An AST node lowered to a closure. Calling it with an Evaluator (which carries
- * the context and grammar) produces the node's value.
+ * An AST node lowered to a closure. Calling it with a context produces the
+ * node's value. The grammar is captured when the closure is built, so it is not
+ * a parameter.
  */
-export type CompiledNode = (ev: Evaluator) => JexlValue
+export type CompiledNode = (context: Context) => JexlValue
 
 /**
  * Writes a key that a plain assignment would mishandle. Storing to
@@ -20,11 +23,7 @@ export type CompiledNode = (ev: Evaluator) => JexlValue
  * re-pointed the target's prototype). Defining the property instead matches
  * what `JSON.parse('{"__proto__":1}')` produces: an ordinary own property.
  */
-function defineOwn(
-  target: Record<string, JexlValue>,
-  key: string,
-  value: JexlValue
-) {
+function defineOwn(target: Context, key: string, value: JexlValue) {
   Object.defineProperty(target, key, {
     value,
     writable: true,
@@ -33,11 +32,7 @@ function defineOwn(
   })
 }
 
-function assignOwn(
-  target: Record<string, JexlValue>,
-  key: string,
-  value: JexlValue
-) {
+function assignOwn(target: Context, key: string, value: JexlValue) {
   target[key] = value
 }
 
@@ -88,21 +83,17 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
     case 'Identifier': {
       const name = node.value
       if (!node.from) {
-        return node.relative
-          ? (ev) => ev._relContext[name]
-          : (ev) => ev._context[name]
+        return (ctx) => ctx[name]
       }
       const from = compileAst(node.from, grammar)
-      return (ev) => {
-        const context = from(ev)
-        if (context == null) {
+      return (ctx) => {
+        const subject = from(ctx)
+        if (subject == null) {
           return undefined
         }
         // an identifier chained off an array reads through its first element
-        const ctx = Array.isArray(context) ? context[0] : context
-        return ctx == null
-          ? undefined
-          : (ctx as Record<string, JexlValue>)[name]
+        const target = Array.isArray(subject) ? subject[0] : subject
+        return target == null ? undefined : (target as Context)[name]
       }
     }
 
@@ -119,18 +110,18 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       if (evalOnDemand) {
         // operands stay unevaluated behind an `eval` thunk, so operators such
         // as && and || can short-circuit
-        return (ev) =>
-          evalOnDemand({ eval: () => left(ev) }, { eval: () => right(ev) })
+        return (ctx) =>
+          evalOnDemand({ eval: () => left(ctx) }, { eval: () => right(ctx) })
       }
       const fn = op.eval
       if (!fn) {
-        return (ev) => {
-          left(ev)
-          right(ev)
+        return (ctx) => {
+          left(ctx)
+          right(ctx)
           return undefined
         }
       }
-      return (ev) => fn(left(ev), right(ev))
+      return (ctx) => fn(left(ctx), right(ctx))
     }
 
     case 'UnaryExpression': {
@@ -144,12 +135,12 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
             : undefined
       if (!fn) {
         // the operand is still evaluated for an unknown operator, as before
-        return (ev) => {
-          right(ev)
+        return (ctx) => {
+          right(ctx)
           return undefined
         }
       }
-      return (ev) => fn(right(ev))
+      return (ctx) => fn(right(ctx))
     }
 
     case 'ConditionalExpression': {
@@ -160,28 +151,22 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       const alternate = node.alternate
         ? compileAst(node.alternate, grammar)
         : undefined
-      return (ev) => {
-        const res = test(ev)
+      return (ctx) => {
+        const res = test(ctx)
         if (res) {
           // an omitted consequent ("a ?: b") yields the test result
-          return consequent ? consequent(ev) : res
+          return consequent ? consequent(ctx) : res
         }
-        return alternate ? alternate(ev) : undefined
+        return alternate ? alternate(ctx) : undefined
       }
     }
 
     case 'FilterExpression': {
-      if (node.relative) {
-        // thrown on evaluation rather than compilation, as before
-        return () => {
-          throw new Error('Relative filter expressions are not supported')
-        }
-      }
       const subject = compileAst(node.subject, grammar)
       const index = compileAst(node.expr, grammar)
-      return (ev) => {
-        const subjectVal = subject(ev)
-        const indexVal = index(ev)
+      return (ctx) => {
+        const subjectVal = subject(ctx)
+        const indexVal = index(ctx)
         if (subjectVal == null) {
           return undefined
         }
@@ -194,10 +179,10 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
     case 'ArrayLiteral': {
       const items = node.value.map((item) => compileAst(item, grammar))
       const len = items.length
-      return (ev) => {
+      return (ctx) => {
         const out: JexlValue[] = new Array(len)
         for (let i = 0; i < len; i++) {
-          out[i] = items[i]!(ev)
+          out[i] = items[i]!(ctx)
         }
         return out
       }
@@ -210,10 +195,10 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       const len = keys.length
       // resolved once, here, so the common case keeps its plain store
       const store = keys.includes('__proto__') ? defineOwn : assignOwn
-      return (ev) => {
+      return (ctx) => {
         const out: Record<string, JexlValue> = {}
         for (let i = 0; i < len; i++) {
-          store(out, keys[i]!, values[i]!(ev))
+          store(out, keys[i]!, values[i]!(ctx))
         }
         return out
       }
@@ -221,18 +206,18 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
 
     case 'TemplateLiteral': {
       // every part renders to a string, so these are narrower than CompiledNode
-      const parts = node.parts.map((part): ((ev: Evaluator) => string) => {
+      const parts = node.parts.map((part): ((ctx: Context) => string) => {
         if (part.type === 'static') {
           const { value } = part
           return () => value
         }
         const expr = compileAst(part.value, grammar)
-        return (ev) => stringify(expr(ev))
+        return (ctx) => stringify(expr(ctx))
       })
-      return (ev) => {
+      return (ctx) => {
         let out = ''
         for (const part of parts) {
-          out += part(ev)
+          out += part(ctx)
         }
         return out
       }
@@ -245,8 +230,8 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       // and `constructor` aren't callable as Jexl functions. Resolved per call
       // rather than baked in, since functions are routinely registered after
       // an expression has been compiled.
-      const lookup = (ev: Evaluator) => {
-        const { functions } = ev._grammar
+      const lookup = () => {
+        const { functions } = grammar
         if (!Object.hasOwn(functions, name)) {
           throw new Error(`Jexl Function ${name} is not defined.`)
         }
@@ -256,15 +241,15 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       // argument array and needs no spread
       switch (args.length) {
         case 0: {
-          return (ev) => lookup(ev)()
+          return () => lookup()()
         }
         case 1: {
           const [a0] = args as [CompiledNode]
-          return (ev) => lookup(ev)(a0(ev))
+          return (ctx) => lookup()(a0(ctx))
         }
         case 2: {
           const [a0, a1] = args as [CompiledNode, CompiledNode]
-          return (ev) => lookup(ev)(a0(ev), a1(ev))
+          return (ctx) => lookup()(a0(ctx), a1(ctx))
         }
         case 3: {
           const [a0, a1, a2] = args as [
@@ -272,16 +257,16 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
             CompiledNode,
             CompiledNode
           ]
-          return (ev) => lookup(ev)(a0(ev), a1(ev), a2(ev))
+          return (ctx) => lookup()(a0(ctx), a1(ctx), a2(ctx))
         }
         default: {
           const len = args.length
-          return (ev) => {
+          return (ctx) => {
             const vals: JexlValue[] = new Array(len)
             for (let i = 0; i < len; i++) {
-              vals[i] = args[i]!(ev)
+              vals[i] = args[i]!(ctx)
             }
-            return lookup(ev)(...vals)
+            return lookup()(...vals)
           }
         }
       }
@@ -290,10 +275,10 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
     case 'SequenceExpression': {
       const exprs = node.expressions.map((expr) => compileAst(expr, grammar))
       const len = exprs.length
-      return (ev) => {
+      return (ctx) => {
         let last: JexlValue
         for (let i = 0; i < len; i++) {
-          last = exprs[i]!(ev)
+          last = exprs[i]!(ctx)
         }
         return last
       }
@@ -303,9 +288,9 @@ export function compileAst(ast: AstNode, grammar: Grammar): CompiledNode {
       const name = node.left.value
       const right = compileAst(node.right!, grammar)
       const store = name === '__proto__' ? defineOwn : assignOwn
-      return (ev) => {
-        const value = right(ev)
-        store(ev._context, name, value)
+      return (ctx) => {
+        const value = right(ctx)
+        store(ctx, name, value)
         return value
       }
     }

package/src/grammar.ts

@@ -9,6 +9,21 @@ import type { JexlValue } from './types.ts'
 
 export type BinaryOpEval = (left: JexlValue, right: JexlValue) => JexlValue
 
+/**
+ * A function or operator implementation as its author writes it, for the
+ * registration methods on {@link Jexl} to accept.
+ *
+ * Jexl cannot check what a registered callback will be handed. The arguments
+ * are whatever the expression evaluated to, drawn from a context supplied at
+ * evaluation time, and that context routinely holds values jexl has no literal
+ * for — a host object with methods, a callback, a class instance. Requiring
+ * {@link JexlValue} parameters therefore rejected every callback actually
+ * written against such a value, since parameters are contravariant. The
+ * argument types are the caller's business; jexl only promises to pass along
+ * whatever the operands evaluated to.
+ */
+export type UncheckedFn = (...args: never[]) => unknown
+
 export type BinaryOpEvalOnDemand = (
   left: { eval: () => JexlValue },
   right: { eval: () => JexlValue }
@@ -27,10 +42,12 @@ export interface BinaryOp {
   unaryEval?: (right: JexlValue) => JexlValue
 }
 
+export type UnaryOpEval = (right: JexlValue) => JexlValue
+
 export interface UnaryOp {
   type: 'unaryOp'
   precedence: number
-  eval: (right: JexlValue) => JexlValue
+  eval: UnaryOpEval
 }
 
 /**
@@ -56,9 +73,12 @@ export interface SimpleElement {
 
 export type GrammarElement = BinaryOp | UnaryOp | SimpleElement
 
+/** A registered function, as jexl calls it once the operands are evaluated. */
+export type GrammarFn = (...args: JexlValue[]) => JexlValue
+
 export interface Grammar {
   elements: Record<string, GrammarElement>
-  functions: Record<string, (...args: JexlValue[]) => JexlValue>
+  functions: Record<string, GrammarFn>
 }
 
 /**
@@ -211,7 +231,7 @@ export const getGrammar = (): Grammar => ({
 
   /**
    * A map of function names to javascript functions. A Jexl function
-   * takes zero ore more arguemnts:
+   * takes zero or more arguments:
    *
    *     - {*} ...args: A variable number of arguments passed to this function.
    *       All of these are pre-evaluated to their actual values before calling

package/src/parser/Parser.ts

@@ -32,7 +32,7 @@ const tokenHandlers: Record<
 /**
  * The Parser is a state machine that converts tokens from the {@link Lexer}
  * into an Abstract Syntax Tree (AST), capable of being evaluated in any
- * context by the {@link Evaluator}.  The Parser expects that all tokens
+ * context by {@link compileAst}.  The Parser expects that all tokens
  * provided to it are legal and typed properly according to the grammar, but
  * accepts that the tokens may still be in an invalid order or in some other
  * unparsable configuration that requires it to throw an Error.
@@ -52,13 +52,11 @@ class Parser {
   _state: string
   _tree: AstNode | null
   _exprStr: string
-  _relative: boolean
   _stopMap: Record<string, string>
   _cursor?: AstNode | null
   _subParser?: Parser
   _parentStop?: boolean
   _nextIdentEncapsulate?: boolean
-  _nextIdentRelative?: boolean
   _curObjKey?: string
   _sequenceExpressions?: AstNode[]
 
@@ -73,7 +71,6 @@ class Parser {
     this._state = 'expectOperand'
     this._tree = null
     this._exprStr = prefix || ''
-    this._relative = false
     this._stopMap = stopMap || {}
   }
 
@@ -143,7 +140,7 @@ class Parser {
   /**
    * Marks this Parser instance as completed and retrieves the full AST.
    * @returns {{}|null} a full expression tree, ready for evaluation by the
-   *      {@link Evaluator#eval} function, or null if no tokens were passed to
+   *      {@link compileAst} function, or null if no tokens were passed to
    *      the parser before complete was called
    * @throws {Error} if the parser is not in a state where it's legal to end
    *      the expression, indicating that the expression is incomplete
@@ -179,14 +176,6 @@ class Parser {
     return this._cursor ? this._tree : null
   }
 
-  /**
-   * Indicates whether the expression tree contains a relative path identifier.
-   * @returns {boolean} true if a relative identifier exists false otherwise.
-   */
-  isRelative() {
-    return this._relative
-  }
-
   /**
    * Ends a subexpression by completing the subParser and passing its result
    * to the subHandler configured in the current state.

package/src/parser/handlers.ts

@@ -64,7 +64,7 @@ export function arrayVal(this: Parser, ast: AstNode | null) {
 export function binaryOp(this: Parser, token: Token) {
   if (token.value === '=') {
     // `from` marks a member access such as `a.b`; only a bare name can be
-    // assigned to, since the Evaluator writes straight into the context
+    // assigned to, since the compiled closure writes straight into the context
     if (
       this._cursor?.type !== 'Identifier' ||
       (this._cursor as Identifier).from
@@ -90,9 +90,15 @@ export function binaryOp(this: Parser, token: Token) {
     if (!parentExpr.operator) {
       break
     }
-    if (
-      precedenceOf(this._grammar.elements[parentExpr.operator]) < precedence
-    ) {
+    // a prefix operator binds tighter than any binary one, so `-x ^ 2` groups
+    // as `(-x) ^ 2` — the same way `-2 ^ 2` already does, since the Lexer folds
+    // that sign into the literal. Looking `-` up in the grammar finds its
+    // binary precedence instead, which is lower than `^`'s and gave `-(x ^ 2)`
+    const parentPrecedence =
+      parent.type === 'UnaryExpression'
+        ? Infinity
+        : precedenceOf(this._grammar.elements[parentExpr.operator])
+    if (parentPrecedence < precedence) {
       break
     }
     this._cursor = parent
@@ -115,18 +121,20 @@ export function binaryOp(this: Parser, token: Token) {
  */
 export function dot(this: Parser) {
   const cursor = this._cursor
-  // the dot continues an identifier chain unless the cursor is an operator
-  // still waiting on its right-hand side, in which case it opens a relative
-  // path instead — as in the leading dot of `list[.price > 5]`
-  this._nextIdentEncapsulate =
-    !!cursor &&
-    cursor.type !== 'UnaryExpression' &&
-    (cursor.type !== 'BinaryExpression' || !!cursor.right)
-
-  this._nextIdentRelative = !this._nextIdentEncapsulate
-  if (this._nextIdentRelative) {
-    this._relative = true
+  // a dot continues an identifier chain. With nothing to continue — no cursor,
+  // or an operator still waiting on its right-hand side — it would instead open
+  // a relative path, the leading dot of `list[.price > 5]`. This fork removed
+  // array filtering expressions, which are the only construct that gives a
+  // relative path a root to resolve against, so it is rejected here rather than
+  // parsed into a tree that can only fail once it is evaluated.
+  if (
+    !cursor ||
+    cursor.type === 'UnaryExpression' ||
+    (cursor.type === 'BinaryExpression' && !cursor.right)
+  ) {
+    throw new Error(`Relative paths are not supported: ${this._exprStr}`)
   }
+  this._nextIdentEncapsulate = true
 }
 
 /**
@@ -138,7 +146,6 @@ export function filter(this: Parser, ast: AstNode | null) {
   const node: FilterExpression = {
     type: 'FilterExpression',
     expr: ast!,
-    relative: this._subParser!.isRelative(),
     subject: this._cursor!
   }
   this._placeBeforeCursor(node)
@@ -162,12 +169,11 @@ export function functionCall(this: Parser) {
     // there is nothing to look up in the function pool
     throw new Error(`Functions must be called by name: ${this._exprStr}`)
   }
-  const { from } = cursor as Identifier
+  const { from, value } = cursor as Identifier
   const node: FunctionCall = {
     type: 'FunctionCall',
-    name: (cursor as Identifier).value,
-    args: from ? [from] : [],
-    pool: 'functions'
+    name: value,
+    args: from ? [from] : []
   }
   this._placeBeforeCursor(node)
 }
@@ -186,10 +192,6 @@ export function identifier(this: Parser, token: Token) {
     this._placeBeforeCursor(node)
     this._nextIdentEncapsulate = false
   } else {
-    if (this._nextIdentRelative) {
-      node.relative = true
-      this._nextIdentRelative = false
-    }
     this._placeAtCursor(node)
   }
 }
@@ -274,7 +276,7 @@ export function objStart(this: Parser) {
 export function objVal(this: Parser, ast: AstNode | null) {
   // defined rather than assigned so that the key "__proto__" becomes an
   // ordinary entry of the node's key map instead of re-pointing its prototype,
-  // which dropped the entry before the Evaluator ever saw it
+  // which dropped the entry before it could be compiled
   Object.defineProperty(
     (this._cursor as ObjectLiteral).value,
     this._curObjKey!,
@@ -313,17 +315,32 @@ export function ternaryMid(this: Parser, ast: AstNode | null) {
 }
 
 /**
- * Handles the start of a new ternary expression by encapsulating the entire
- * AST in a ConditionalExpression node, and using the existing tree as the
- * test element.
+ * Handles the start of a new ternary expression by encapsulating the tree so
+ * far in a ConditionalExpression node, and using it as the test element.
+ *
+ * Every operator binds tighter than the conditional and so belongs in the test
+ * — except `=`, which binds looser. `x = a ? b : c` therefore assigns the
+ * conditional rather than testing the assignment, which had stored `a` in `x`.
  */
 export function ternaryStart(this: Parser) {
+  let assignment: AstNode | undefined
+  let test = this._tree!
+  while (test.type === 'AssignmentExpression' && test.right) {
+    assignment = test
+    test = test.right
+  }
+
   const node: ConditionalExpression = {
     type: 'ConditionalExpression',
-    test: this._tree!
+    test
+  }
+  if (assignment) {
+    assignment.right = node
+    this._setParent(node, assignment)
+  } else {
+    this._tree = node
   }
-  this._tree = node
-  this._cursor = this._tree
+  this._cursor = node
 }
 
 /**

package/src/parser/states.ts

@@ -97,10 +97,6 @@ export const states: States = {
       colon: { toState: 'objVal' }
     }
   },
-  postArgs: {
-    tokenTypes: afterOperand,
-    completable: true
-  },
   identifier: {
     tokenTypes: {
       ...afterOperand,
@@ -131,7 +127,9 @@ export const states: States = {
     subHandler: h.argVal,
     endStates: {
       comma: 'argVal',
-      closeParen: 'postArgs'
+      // a call's result is an ordinary operand: it can be operated on or
+      // drilled into, but not called again, since only a name can be called
+      closeParen: 'expectBinOp'
     }
   },
   objVal: {

package/src/types.ts

@@ -38,7 +38,6 @@ export interface Identifier extends AstNode {
   type: 'Identifier'
   value: string
   from?: AstNode
-  relative?: boolean
 }
 
 export interface BinaryExpression extends AstNode {
@@ -77,13 +76,11 @@ export interface FunctionCall extends AstNode {
   type: 'FunctionCall'
   name: string
   args: AstNode[]
-  pool: 'functions'
 }
 
 export interface FilterExpression extends AstNode {
   type: 'FilterExpression'
   expr: AstNode
-  relative: boolean
   subject: AstNode
 }
 

package/dist/evaluator/Evaluator.d.ts

@@ -1,37 +0,0 @@
-import type { Grammar } from '../grammar.ts';
-import type { AstNode, JexlValue } from '../types.ts';
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-declare class Evaluator {
-    _grammar: Grammar;
-    _context: Record<string, JexlValue>;
-    _relContext: Record<string, JexlValue>;
-    constructor(grammar: Grammar, context?: Record<string, JexlValue>, relativeContext?: Record<string, JexlValue>);
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast: AstNode): JexlValue;
-}
-export default Evaluator;

package/dist/evaluator/Evaluator.js

@@ -1,49 +0,0 @@
-"use strict";
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const compile_ts_1 = require("./compile.js");
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-class Evaluator {
-    _grammar;
-    _context;
-    _relContext;
-    constructor(grammar, context, relativeContext) {
-        this._grammar = grammar;
-        this._context = context || {};
-        this._relContext = relativeContext || this._context;
-    }
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast) {
-        return (0, compile_ts_1.compileAst)(ast, this._grammar)(this);
-    }
-}
-exports.default = Evaluator;
-//# sourceMappingURL=Evaluator.js.map

package/dist/evaluator/Evaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evaluator.js","sourceRoot":"","sources":["../../src/evaluator/Evaluator.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAEH,6CAAyC;AAKzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,SAAS;IACb,QAAQ,CAAS;IACjB,QAAQ,CAA2B;IACnC,WAAW,CAA2B;IAEtC,YACE,OAAgB,EAChB,OAAmC,EACnC,eAA2C;QAE3C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,IAAI,EAAE,CAAA;QAC7B,IAAI,CAAC,WAAW,GAAG,eAAe,IAAI,IAAI,CAAC,QAAQ,CAAA;IACrD,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,GAAY;QACf,OAAO,IAAA,uBAAU,EAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAA;IAC7C,CAAC;CACF;AAED,kBAAe,SAAS,CAAA"}