@alloy-js/core 0.20.0-dev.4 → 0.20.0-dev.6

package/dist/src/symbols/output-symbol.js

@@ -1,11 +1,9 @@
-import { reactive, ReactiveFlags, shallowReactive, track, TrackOpTypes, trigger, TriggerOpTypes, watch } from "@vue/reactivity";
+import { isRef, reactive, ReactiveFlags, shallowReactive, track, TrackOpTypes, trigger, TriggerOpTypes, watch } from "@vue/reactivity";
 import { useBinder } from "../context/binder.js";
-import { useMemberScope } from "../context/member-scope.js";
-import { useScope } from "../context/scope.js";
-import { isRefkey, refkey } from "../refkey.js";
-import { formatScopeName, formatSymbol, formatSymbolName, trace, traceEffect, TracePhase } from "../tracer.js";
-import { OutputScopeFlags, OutputSymbolFlags } from "./flags.js";
-import { OutputScope } from "./output-scope.js";
+import { inspect } from "../inspect.js";
+import { untrack } from "../reactivity.js";
+import { formatSymbol, formatSymbolName, trace, traceEffect, TracePhase } from "../tracer.js";
+import { OutputMemberSpace } from "./output-space.js";
 let symbolCount = 0;
 
 /**
@@ -19,11 +17,25 @@ let symbolCount = 0;
  * you can observe changes to their properties in a reactive context.
  */
 export class OutputSymbol {
+  static memberSpaces = [];
   #originalName;
+  /**
+   * Read only. The requested name of this symbol. The symbol's actual name may
+   * be different depending on naming policy or conflicts with other symbols.
+   *
+   * @readonly
+   */
   get originalName() {
     return this.#originalName;
   }
+
+  // this field is set by calling the name accessor.
   #name;
+  /**
+   * The name of this symbol.
+   *
+   * @reactive
+   */
   get name() {
     track(this, TrackOpTypes.GET, "name");
     return this.#name;
@@ -33,63 +45,117 @@ export class OutputSymbol {
     if (old === name) {
       return;
     }
-    this.#name = name;
+    this.#name = this.#namePolicy && !this.#ignoreNamePolicy ? this.#namePolicy(name) : name;
     trigger(this, TriggerOpTypes.SET, "name", name, old);
   }
   #id;
+  /**
+   * The unique id of this symbol.
+   *
+   * @readonly
+   */
   get id() {
     return this.#id;
   }
-  #flags;
-  get flags() {
-    track(this, TrackOpTypes.GET, "flags");
-    return this.#flags;
+  #ignoreNamePolicy = false;
+  /**
+   * Whether the name of this symbol bypasses the active name policy. When true,
+   * the name of this symbol will be fixed, though it may conflict with other
+   * symbols which are also ignoring the name policy.
+   *
+   * @readonly
+   */
+  get ignoreNamePolicy() {
+    return this.#ignoreNamePolicy;
   }
-  set flags(flags) {
-    const old = this.#flags;
-    if (old === flags) {
-      return;
-    }
-    this.#flags = flags;
-    trigger(this, TriggerOpTypes.SET, "flags", flags, old);
-    this.#createInstanceMemberScope();
-    this.#createStaticMemberScope();
+  #ignoreNameConflict = false;
+
+  /**
+   * Whether the name of this symbol bypasses the active name conflict
+   * resolution. When true, the name of this symbol will be fixed, though it may
+   * conflict with other symbols which are also ignoring name conflict
+   * resolution.
+   */
+  get ignoreNameConflict() {
+    return this.#ignoreNameConflict;
   }
-  #scope;
+  #memberSpaces = shallowReactive({});
+  /**
+   * The member spaces of this symbol.
+   *
+   * @readonly
+   */
+  get memberSpaces() {
+    return Object.values(this.#memberSpaces);
+  }
+
+  /**
+   * Get the member space for the given key.
+   */
+  memberSpaceFor(spaceKey) {
+    return this.#memberSpaces[spaceKey];
+  }
+
+  /**
+   * The scope this symbol is in. When this symbol is a member symbol, this will
+   * return undefined.
+   *
+   * @readonly
+   */
   get scope() {
-    track(this, TrackOpTypes.GET, "scope");
-    return this.#scope;
+    if (this.isMemberSymbol) {
+      return undefined;
+    }
+    if (this.spaces.length === 0) {
+      return undefined;
+    }
+    return this.spaces[0].scope;
   }
-  set scope(scope) {
-    const old = this.#scope;
-    if (old === scope) {
+  #spaces;
+  /**
+   * The declaration or member spaces this symbol belongs to.
+   *
+   * @reactive
+   */
+  get spaces() {
+    track(this, TrackOpTypes.GET, "spaces");
+    return this.#spaces;
+  }
+  set spaces(spaces) {
+    const old = this.#spaces;
+    if (old === spaces) {
       return;
     }
-    this.#handleNewScope(scope, old);
-    this.#scope = scope;
-    trigger(this, TriggerOpTypes.SET, "scope", scope, old);
+    const spacesArray = spaces === undefined ? [] : Array.isArray(spaces) ? spaces : [spaces];
+    this.#handleNewSpaces(spacesArray, old);
+    this.#spaces = spacesArray;
+    trigger(this, TriggerOpTypes.SET, "spaces", spaces, old);
   }
-  #handleNewScope(newScope, oldScope) {
-    if (oldScope) {
+  #handleNewSpaces(newSpaces, oldSpaces) {
+    if (oldSpaces) {
       // ensure when changing scope that this symbol only belongs to one of them
-      oldScope.symbols.delete(this);
+      oldSpaces.forEach(oldSpace => oldSpace.delete(this));
     }
-    if (!newScope) {
-      return;
-    }
-    newScope.symbols.add(this);
-    if (newScope.flags & OutputScopeFlags.InstanceMemberScope) {
-      this.flags |= OutputSymbolFlags.InstanceMember;
-    }
-    if (newScope.flags & OutputScopeFlags.StaticMemberScope) {
-      this.flags |= OutputSymbolFlags.StaticMember;
+    if (newSpaces) {
+      newSpaces.forEach(newSpace => newSpace.add(this));
     }
   }
   #binder;
+  /**
+   * The binder that is tracking this symbol.
+   *
+   * @readonly
+   */
   get binder() {
     return this.#binder;
   }
   #refkeys;
+
+  /**
+   * The refkeys for this symbol.
+   *
+   * @reactive
+   */
   get refkeys() {
     track(this, TrackOpTypes.GET, "refkeys");
     return this.#refkeys;
@@ -102,169 +168,250 @@ export class OutputSymbol {
     this.#refkeys = shallowReactive(Array.isArray(refkeys) ? refkeys : [refkeys]);
     trigger(this, TriggerOpTypes.SET, "refkeys", this.#refkeys, old);
   }
-  #instanceMemberScope;
-  get instanceMemberScope() {
-    track(this, TrackOpTypes.GET, "instanceMemberScope");
-    return this.#instanceMemberScope;
-  }
   #aliasTarget;
+  /**
+   * The symbol that this symbol is an alias for.
+   *
+   * @readonly
+   */
   get aliasTarget() {
     return this.#aliasTarget;
   }
-  #createInstanceMemberScope() {
-    if (this.#instanceMemberScope || !(this.#flags & OutputSymbolFlags.InstanceMemberContainer)) {
-      return;
+
+  /**
+   * If this symbol is an alias for another symbol, return the the aliased symbol. Otherwise, return this symbol.
+   */
+  dealias() {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.dealias();
     }
-    this.#instanceMemberScope = new OutputScope(`${this.name} instance members`, {
-      binder: this.#binder,
-      owner: this,
-      flags: OutputScopeFlags.InstanceMemberScope
-    });
-    trigger(this, TriggerOpTypes.SET, "instanceMemberScope", this.#instanceMemberScope, undefined);
+    return this;
   }
 
   /**
-   * Create an output scope to hold member symbols. By default this just creates
-   * an OutputScope, but can be subclassed to build scope subtypes when needed.
+   * Whether this symbol is an alias for another symbol.
+   *
+   * @readonly
    */
-  createMemberScope(name, options) {
-    return new OutputScope(name, {
-      binder: this.#binder,
-      owner: options.owner,
-      flags: options.flags
-    });
-  }
-  #staticMemberScope;
-  get staticMemberScope() {
-    track(this, TrackOpTypes.GET, "staticMemberScope");
-    return this.#staticMemberScope;
-  }
-  #createStaticMemberScope() {
-    if (this.#staticMemberScope || !(this.#flags & OutputSymbolFlags.StaticMemberContainer)) {
-      return;
-    }
-    this.#staticMemberScope = new OutputScope(`${this.name} static members`, {
-      binder: this.#binder,
-      owner: this,
-      flags: OutputScopeFlags.StaticMemberScope
-    });
-    trigger(this, TriggerOpTypes.SET, "staticMemberScope", this.#staticMemberScope, undefined);
+  get isAlias() {
+    return !!this.#aliasTarget;
   }
   #metadata;
+  /**
+   * An arbitrary bag of metadata for this symbol. This property is read only,
+   * but the metadata is a reactive object.
+   *
+   * @readonly
+   */
   get metadata() {
     return this.#metadata;
   }
+  copyToSpace(space) {
+    const copy = this.copy();
+    copy.spaces = space;
+    return copy;
+  }
+
+  /**
+   * Whether this symbol is a member of another symbol.
+   *
+   * @readonly
+   */
+  get isMemberSymbol() {
+    return this.spaces[0] instanceof OutputMemberSpace;
+  }
+
+  /**
+   * When this is a member symbol, this returns the symbol that this is symbol
+   * is a member of.
+   */
+  get ownerSymbol() {
+    if (!this.isMemberSymbol) {
+      return undefined;
+    }
+    return this.spaces[0].symbol;
+  }
+  #isTransient;
 
   /**
-   * Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
-   * proxy.
+   * Whether this symbol is a transient symbol. Transient symbols cannot be
+   * referenced and are meant to be combined with other symbols.
+   *
+   * @readonly
    */
+  get isTransient() {
+    if (this.#isTransient) {
+      return true;
+    }
+    if (this.ownerSymbol) {
+      return this.ownerSymbol.isTransient;
+    }
+    return false;
+  }
+  #movedTo;
+  /**
+   * The symbol that this symbol's members have been moved to.
+   *
+   * @readonly
+   * @reactive
+   */
+  get movedTo() {
+    track(this, TrackOpTypes.GET, "movedTo");
+    return this.#movedTo;
+  }
+  #setMovedTo(value) {
+    this.#movedTo = value;
+    trigger(this, TriggerOpTypes.SET, "movedTo");
+  }
+
+  /**
+   * Whether this symbol's members have been moved to another symbol.
+   *
+   * @reactive
+   */
+  get isMoved() {
+    return this.movedTo !== undefined;
+  }
+  #type;
+
+  /**
+   * The symbol which defines the type of this symbol. The type symbol provides
+   * information about the value this symbol contains, such as what members it
+   * has.
+   *
+   * @reactive
+   */
+  get type() {
+    track(this, TrackOpTypes.GET, "type");
+    return this.#type;
+  }
+  set type(value) {
+    if (isRef(value)) {
+      watch(value, newValue => {
+        const old = this.#type;
+        this.#type = newValue && newValue.dealias();
+        trigger(this, TriggerOpTypes.SET, "type", newValue, old);
+      });
+    } else {
+      const old = this.#type;
+      this.#type = value && value.dealias();
+      trigger(this, TriggerOpTypes.SET, "type", value, old);
+    }
+  }
+
+  /**
+   * Whether this symbol has its symbol representing its type available.
+   *
+   * @readonly
+   * @reactive
+   */
+  get hasTypeSymbol() {
+    return this.type !== undefined;
+  }
+  #isTyped = false;
+
+  /**
+   * Whether this symbol's members are provided by a type symbol. The
+   * `typeSymbol` property is this symbol. It may not be available yet, so check
+   * `hasTypeSymbol`.
+   */
+  get isTyped() {
+    return this.#isTyped;
+  }
+  #namePolicy;
+  get namePolicy() {
+    return this.#namePolicy;
+  }
+
+  // Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
+  // proxy.
   [ReactiveFlags.SKIP] = true;
-  constructor(name, options = {}) {
+  constructor(name, spaces, options = {}) {
     this.#binder = options.binder ?? useBinder();
-    this.#name = name;
-    this.#originalName = name;
+    this.#namePolicy = options.namePolicy;
+    if (typeof name === "string") {
+      this.#ignoreNameConflict = !!options.ignoreNameConflict;
+      this.#ignoreNamePolicy = !!options.ignoreNamePolicy;
+      this.name = name;
+      this.#originalName = name;
+      this.#refkeys = shallowReactive(this.#normalizeRefkeyOption(options.refkeys));
+    } else {
+      this.#ignoreNameConflict = name.options.ignoreNameConflict ?? !!options.ignoreNameConflict;
+      this.#ignoreNamePolicy = name.options.ignoreNamePolicy ?? !!options.ignoreNamePolicy;
+      this.name = name.name;
+      this.#originalName = name.name;
+      this.#refkeys = shallowReactive([name, ...this.#normalizeRefkeyOption(options.refkeys)]);
+    }
     this.#id = symbolCount++;
-    this.#flags = options.flags ?? OutputSymbolFlags.None;
-    this.#scope = options.scope ?? this.#defaultScope();
+    this.#spaces = Array.isArray(spaces) ? spaces : spaces === undefined ? [] : [spaces];
     this.#aliasTarget = options.aliasTarget;
-    if (this.#aliasTarget) {
-      this.#flags |= OutputSymbolFlags.Alias;
-      this.#flags &= ~(OutputSymbolFlags.MemberContainer | OutputSymbolFlags.Member);
-    }
-    this.#refkeys = shallowReactive(Array.isArray(options.refkeys) ? options.refkeys : isRefkey(options.refkeys) ? [options.refkeys] : []);
     this.#metadata = reactive(options.metadata ?? {});
-    this.#createInstanceMemberScope();
-    this.#createStaticMemberScope();
-    this.#handleNewScope(this.#scope);
+    this.#isTransient = !!options.transient;
+    this.#isTyped = !!options.type;
+    this.type = options.type;
+    this.#handleNewSpaces(this.#spaces);
+    const constructor = this.constructor;
+    this.#memberSpaces = Object.fromEntries(constructor.memberSpaces.map(spaceKey => [spaceKey, new OutputMemberSpace(this, spaceKey, this.#binder)]));
     trace(TracePhase.symbol.create, () => `${formatSymbol(this)}`);
     traceEffect(TracePhase.symbol.update, () => {
       return `${formatSymbol(this)}`;
     });
     this.#binder?.notifySymbolCreated(this);
   }
+  #normalizeRefkeyOption(refkeys) {
+    if (refkeys === undefined) {
+      return [];
+    } else if (Array.isArray(refkeys)) {
+      return refkeys;
+    } else {
+      return [refkeys];
+    }
+  }
   delete() {
     trace(TracePhase.symbol.delete, () => `${formatSymbolName(this)}`);
-    if (this.#scope) {
-      this.#scope.symbols.delete(this);
+    if (this.#spaces) {
+      this.#spaces.forEach(space => space.delete(this));
     }
     this.#binder?.notifySymbolDeleted(this);
   }
 
   /**
-   * Takes the instance members or static members on this symbol and creates
-   * corresponding static members on the target symbol. Instance or static
-   * members of instantiated symbols are copied. The refkey of any instantiated
-   * symbols are set to a composite refkey of the target symbol's refkey and the
-   * instantiated symbol's refkey.
+   * Move member symbols from this transient symbol to the target symbol. This is reactive -
+   * whenever a member is added to this symbol, it will be moved to the target
+   * symbol.
    */
-  instantiateTo(targetSymbol) {
+  moveMembersTo(targetSymbol) {
     if (this.#aliasTarget) {
-      return this.#aliasTarget.instantiateTo(targetSymbol);
+      return this.#aliasTarget.moveMembersTo(targetSymbol);
     }
-    trace(TracePhase.symbol.instantiate, () => {
-      return `${formatSymbolName(this)} -> ${formatSymbolName(targetSymbol)}`;
-    });
-    const from = this.#instanceMemberScope ?? this.#staticMemberScope;
-    if (from) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.#createStaticMemberScope();
-      targetSymbol.#staticMemberScope.copySymbolsFrom(from, {
-        onAdd: symbol => {
-          const clone = symbol.copyToScope(targetSymbol.#staticMemberScope, targetSymbol);
-          clone.#flags &= ~OutputSymbolFlags.InstanceMember;
-          clone.#flags |= OutputSymbolFlags.StaticMember;
-          return clone;
-        }
-      });
+    if (!this.isTransient) {
+      throw new Error("Can only move members from transient symbols");
     }
-  }
-  #instantiationRk(base, member) {
-    const instantiationRks = [];
-    for (const baseRk of base.refkeys) {
-      for (const targetRk of member.refkeys) {
-        instantiationRks.push(refkey(baseRk, targetRk));
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = targetSymbol.memberSpaceFor(sourceSpace.key);
+      if (!targetSpace) {
+        throw new Error("Target symbol doesn't have member space " + sourceSpace.key);
       }
+      sourceSpace.moveTo(targetSpace);
     }
-    return instantiationRks;
-  }
-
-  /**
-   * Copy member symbols from the target symbol into the target symbol. The
-   * copied symbols have their refkey set to
-   * `refkey(targetSymbol.refkey, this.refkey)`.
-   */
-  copyTo(targetSymbol) {
-    if (this.#aliasTarget) {
-      return this.#aliasTarget.copyTo(targetSymbol);
-    }
-    if (this.staticMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.staticMemberScope.copySymbolsFrom(this.staticMemberScope);
-    }
-    if (this.instanceMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
-      targetSymbol.instanceMemberScope.copySymbolsFrom(this.instanceMemberScope);
-    }
+    this.#setMovedTo(targetSymbol);
   }
 
   /**
-   * Move member symbols from this transient symbol to the target symbol.
+   * Copy the members of this symbol to the target symbol. This is reactive -
+   * whenever a member is added to this symbol, it will be copied to the target
+   * symbol.
    */
-  moveTo(targetSymbol) {
+  copyMembersTo(targetSymbol) {
     if (this.#aliasTarget) {
-      return this.#aliasTarget.moveTo(targetSymbol);
-    }
-    if (!(this.flags & OutputSymbolFlags.Transient)) {
-      throw new Error("Can only move members from transient symbols");
-    }
-    if (this.staticMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.staticMemberScope.moveSymbolsFrom(this.staticMemberScope);
+      return this.#aliasTarget.copyMembersTo(targetSymbol);
     }
-    if (this.instanceMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
-      targetSymbol.instanceMemberScope.moveSymbolsFrom(this.instanceMemberScope);
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = targetSymbol.memberSpaceFor(sourceSpace.key);
+      if (!targetSpace) {
+        throw new Error("Target symbol doesn't have member space " + sourceSpace.key);
+      }
+      sourceSpace.copyTo(targetSpace);
     }
   }
 
@@ -281,53 +428,26 @@ export class OutputSymbol {
    *
    * @param newScope - The scope to use for the copy.
    */
-  copyToScope(newScope, baseSymbol) {
-    if (this.#aliasTarget) {
-      return this.#aliasTarget.copyToScope(newScope, baseSymbol);
-    }
-    trace(TracePhase.symbol.clone, () => {
-      return `${formatSymbolName(this)} -> ${formatScopeName(newScope)}`;
-    });
-    const clone = new OutputSymbol(this.#name, {
-      binder: this.#binder,
-      scope: newScope,
-      flags: this.#flags,
-      refkeys: baseSymbol ? this.#instantiationRk(baseSymbol, this) : [],
-      metadata: this.#metadata
-    });
-    if (this.instanceMemberScope) {
-      clone.#instanceMemberScope = this.instanceMemberScope.clone({
-        owner: clone
-      });
-    }
-    if (this.staticMemberScope) {
-      clone.#staticMemberScope = this.staticMemberScope.clone({
-        owner: clone
-      });
-    }
-    watch(() => this.name, newName => clone.name = newName);
-    watch(() => this.flags, newFlags => clone.flags = newFlags);
-    return clone;
+
+  getCopyOptions() {
+    return {
+      binder: this.binder,
+      aliasTarget: this.aliasTarget,
+      metadata: this.metadata,
+      transient: this.isTransient
+    };
   }
-  #defaultScope() {
-    if ((this.#flags & OutputSymbolFlags.Member) === 0) {
-      return useScope();
-    } else {
-      const memberScope = useMemberScope();
-      if (!memberScope) {
-        throw new Error("Cannot declare member symbols without a member scope");
-      }
-      if (this.#flags & OutputSymbolFlags.InstanceMember) {
-        if (!memberScope.instanceMembers) {
-          throw new Error("Cannot declare instance member symbols without an instance member scope");
-        }
-        return memberScope.instanceMembers;
-      } else {
-        if (!memberScope.staticMembers) {
-          throw new Error("Cannot declare static member symbols without a static member scope");
-        }
-        return memberScope.staticMembers;
+  initializeCopy(copy) {
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = copy.memberSpaceFor(sourceSpace.key);
+      if (!targetSpace) {
+        throw new Error("Target doesn't have space " + sourceSpace.key);
       }
+      sourceSpace.copyTo(targetSpace);
     }
+    watch(() => this.name, newName => copy.name = newName);
+  }
+  [inspect.custom]() {
+    return untrack(() => `${this.constructor.name} "${this.name}"[${this.id}]`);
   }
 }

package/dist/src/symbols/symbol-flow.d.ts

@@ -9,5 +9,5 @@ export interface TakeSymbolsCallback {
 export declare function takeSymbols(cb?: (symbol: OutputSymbol) => void): import("@vue/reactivity").ShallowReactive<Set<OutputSymbol>>;
 export declare function emitSymbol(symbol: OutputSymbol | Ref<OutputSymbol | undefined>): void;
 export declare function moveTakenMembersTo(baseSymbol: OutputSymbol): void;
-export declare function instantiateTakenMembersTo(baseSymbol: OutputSymbol): void;
+export declare function instantiateTakenMembersTo(baseSymbol: OutputSymbol, toSpaceKey: string, fromSpaceKey: string): void;
 //# sourceMappingURL=symbol-flow.d.ts.map

package/dist/src/symbols/symbol-flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-flow.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAmB,MAAM,iBAAiB,CAAC;AAM9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,kBAAkB;IACjC,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,OAAO,EAAE,GAAG,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,gEAiB9D;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC,QA+CrD;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,YAAY,QAU1D;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,YAAY,QAEjE"}
+{"version":3,"file":"symbol-flow.d.ts","sourceRoot":"","sources":["../../../src/symbols/symbol-flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAmB,MAAM,iBAAiB,CAAC;AAM9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,kBAAkB;IACjC,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,OAAO,EAAE,GAAG,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,gEAiB9D;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC,QAiErD;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,YAAY,QAe1D;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,QAKrB"}