@lightningjs/renderer 2.0.0 → 2.1.1

package/src/core/CoreNode.ts

@@ -45,6 +45,7 @@ import {
   type RectWithValid,
   createBound,
   boundInsideBound,
+  boundLargeThanBound,
 } from './lib/utils.js';
 import { Matrix3d } from './lib/Matrix3d.js';
 import { RenderCoords } from './lib/RenderCoords.js';
@@ -178,6 +179,11 @@ export enum UpdateType {
    */
   ParentRenderTexture = 4096,
 
+  /**
+   * Render Bounds update
+   */
+  RenderBounds = 8192,
+
   /**
    * None
    */
@@ -693,6 +699,7 @@ export class CoreNode extends EventEmitter {
   readonly props: CoreNodeProps;
 
   public updateType = UpdateType.All;
+  public childUpdateType = UpdateType.None;
 
   public globalTransform?: Matrix3d;
   public scaleRotateTransform?: Matrix3d;
@@ -738,6 +745,10 @@ export class CoreNode extends EventEmitter {
     this.rtt = props.rtt;
 
     this.updateScaleRotateTransform();
+
+    this.setUpdateType(
+      UpdateType.Local | UpdateType.RenderBounds | UpdateType.RenderState,
+    );
   }
 
   //#region Textures
@@ -838,7 +849,7 @@ export class CoreNode extends EventEmitter {
     // If we're updating this node at all, we need to inform the parent
     // (and all ancestors) that their children need updating as well
     const parent = this.props.parent;
-    if (parent && !(parent.updateType & UpdateType.Children)) {
+    if (parent !== null && !(parent.updateType & UpdateType.Children)) {
       parent.setUpdateType(UpdateType.Children);
     }
     // If node is part of RTT texture
@@ -948,7 +959,6 @@ export class CoreNode extends EventEmitter {
     }
 
     const parent = this.props.parent;
-    let childUpdateType = UpdateType.None;
 
     if (this.updateType & UpdateType.ParentRenderTexture) {
       let p = this.parent;
@@ -988,16 +998,41 @@ export class CoreNode extends EventEmitter {
 
       this.calculateRenderCoords();
       this.updateBoundingRect();
-      this.setUpdateType(
-        UpdateType.Clipping | UpdateType.RenderState | UpdateType.Children,
-      );
-      childUpdateType |= UpdateType.Global;
+
+      this.setUpdateType(UpdateType.RenderState | UpdateType.Children);
+
+      if (this.clipping === true) {
+        this.setUpdateType(UpdateType.Clipping);
+      }
+
+      this.childUpdateType |= UpdateType.Global;
+    }
+
+    if (this.updateType & UpdateType.RenderBounds) {
+      this.createRenderBounds();
+      this.setUpdateType(UpdateType.RenderState);
+      this.setUpdateType(UpdateType.Children);
+    }
+
+    if (this.updateType & UpdateType.RenderState) {
+      this.updateRenderState();
+      this.setUpdateType(UpdateType.IsRenderable);
+    }
+
+    if (this.updateType & UpdateType.IsRenderable) {
+      this.updateIsRenderable();
+    }
+
+    if (this.renderState === CoreNodeRenderState.OutOfBounds) {
+      return;
     }
 
     if (this.updateType & UpdateType.Clipping) {
       this.calculateClippingRect(parentClippingRect);
       this.setUpdateType(UpdateType.Children);
-      childUpdateType |= UpdateType.Clipping;
+
+      this.childUpdateType |= UpdateType.Clipping;
+      this.childUpdateType |= UpdateType.RenderBounds;
     }
 
     if (this.updateType & UpdateType.WorldAlpha) {
@@ -1011,7 +1046,7 @@ export class CoreNode extends EventEmitter {
           UpdateType.PremultipliedColors |
           UpdateType.IsRenderable,
       );
-      childUpdateType |= UpdateType.WorldAlpha;
+      this.childUpdateType |= UpdateType.WorldAlpha;
     }
 
     if (this.updateType & UpdateType.PremultipliedColors) {
@@ -1050,17 +1085,8 @@ export class CoreNode extends EventEmitter {
       }
     }
 
-    if (this.updateType & UpdateType.RenderState) {
-      this.updateRenderState(parentClippingRect);
-      this.setUpdateType(UpdateType.IsRenderable);
-    }
-
-    if (this.updateType & UpdateType.IsRenderable) {
-      this.updateIsRenderable();
-    }
-
     // No need to update zIndex if there is no parent
-    if (parent && this.updateType & UpdateType.CalculatedZIndex) {
+    if (parent !== null && this.updateType & UpdateType.CalculatedZIndex) {
       this.calculateZIndex();
       // Tell parent to re-sort children
       parent.setUpdateType(UpdateType.ZIndexSortedChildren);
@@ -1068,18 +1094,23 @@ export class CoreNode extends EventEmitter {
 
     if (
       this.updateType & UpdateType.Children &&
-      this.children.length &&
-      !this.rtt
+      this.children.length > 0 &&
+      this.rtt === false
     ) {
-      this.children.forEach((child) => {
-        // Trigger the depenedent update types on the child
-        child.setUpdateType(childUpdateType);
-        // If child has no updates, skip
+      for (let i = 0; i < this.children.length; i++) {
+        const child = this.children[i];
+        if (child === undefined) {
+          continue;
+        }
+
+        child.setUpdateType(this.childUpdateType);
+
         if (child.updateType === 0) {
-          return;
+          continue;
         }
+
         child.update(delta, this.clippingRect);
-      });
+      }
     }
 
     // Sorting children MUST happen after children have been updated so
@@ -1091,6 +1122,7 @@ export class CoreNode extends EventEmitter {
 
     // reset update type
     this.updateType = 0;
+    this.childUpdateType = 0;
   }
 
   //check if CoreNode is renderable based on props
@@ -1151,39 +1183,112 @@ export class CoreNode extends EventEmitter {
     return false;
   }
 
-  checkRenderBounds(parentClippingRect: RectWithValid): CoreNodeRenderState {
+  checkRenderBounds(): CoreNodeRenderState {
     assertTruthy(this.renderBound);
-    const rectW = parentClippingRect.width || this.stage.root.width;
-    const rectH = parentClippingRect.height || this.stage.root.height;
-    this.strictBound = createBound(
-      parentClippingRect.x,
-      parentClippingRect.y,
-      parentClippingRect.x + rectW,
-      parentClippingRect.y + rectH,
-      this.strictBound,
-    );
+    assertTruthy(this.strictBound);
+    assertTruthy(this.preloadBound);
 
     if (boundInsideBound(this.renderBound, this.strictBound)) {
       return CoreNodeRenderState.InViewport;
     }
 
+    if (boundInsideBound(this.renderBound, this.preloadBound)) {
+      return CoreNodeRenderState.InBounds;
+    }
+
+    // check if we're larger then our parent, we're definitely in the viewport
+    if (boundLargeThanBound(this.renderBound, this.strictBound)) {
+      return CoreNodeRenderState.InViewport;
+    }
+
+    // check if we dont have dimensions, take our parent's render state
+    if (
+      this.parent !== null &&
+      (this.props.width === 0 || this.props.height === 0)
+    ) {
+      return this.parent.renderState;
+    }
+
+    return CoreNodeRenderState.OutOfBounds;
+  }
+
+  createPreloadBounds(strictBound: Bound): Bound {
     const renderM = this.stage.boundsMargin;
-    this.preloadBound = createBound(
-      this.strictBound.x1 - renderM[3],
-      this.strictBound.y1 - renderM[0],
-      this.strictBound.x2 + renderM[1],
-      this.strictBound.y2 + renderM[2],
+    return createBound(
+      strictBound.x1 - renderM[3],
+      strictBound.y1 - renderM[0],
+      strictBound.x2 + renderM[1],
+      strictBound.y2 + renderM[2],
       this.preloadBound,
     );
+  }
 
-    if (boundInsideBound(this.renderBound, this.preloadBound)) {
-      return CoreNodeRenderState.InBounds;
+  updateBoundingRect() {
+    const { renderCoords, globalTransform: transform } = this;
+    assertTruthy(transform);
+    assertTruthy(renderCoords);
+
+    const { tb, tc } = transform;
+    const { x1, y1, x3, y3 } = renderCoords;
+    if (tb === 0 || tc === 0) {
+      this.renderBound = createBound(x1, y1, x3, y3, this.renderBound);
+    } else {
+      const { x2, x4, y2, y4 } = renderCoords;
+      this.renderBound = createBound(
+        Math.min(x1, x2, x3, x4),
+        Math.min(y1, y2, y3, y4),
+        Math.max(x1, x2, x3, x4),
+        Math.max(y1, y2, y3, y4),
+        this.renderBound,
+      );
     }
-    return CoreNodeRenderState.OutOfBounds;
   }
 
-  updateRenderState(parentClippingRect: RectWithValid) {
-    const renderState = this.checkRenderBounds(parentClippingRect);
+  createRenderBounds(): void {
+    assertTruthy(this.stage);
+
+    // no clipping, use parent's bounds
+    if (this.clipping === false) {
+      if (this.parent !== null) {
+        this.strictBound =
+          this.parent.strictBound ??
+          createBound(0, 0, this.stage.root.width, this.stage.root.height);
+
+        this.preloadBound =
+          this.parent.preloadBound ??
+          this.createPreloadBounds(this.strictBound);
+        return;
+      } else {
+        this.strictBound = createBound(
+          0,
+          0,
+          this.stage.root.width,
+          this.stage.root.height,
+        );
+
+        this.preloadBound = this.createPreloadBounds(this.strictBound);
+        return;
+      }
+    }
+
+    // clipping is enabled create our own bounds
+    const { x, y, width, height } = this.props;
+    const { tx, ty } = this.globalTransform || {};
+    const _x = tx ?? x;
+    const _y = ty ?? y;
+    this.strictBound = createBound(
+      _x,
+      _y,
+      _x + width,
+      _y + height,
+      this.strictBound,
+    );
+
+    this.preloadBound = this.createPreloadBounds(this.strictBound);
+  }
+
+  updateRenderState() {
+    const renderState = this.checkRenderBounds();
 
     if (renderState === this.renderState) {
       return;
@@ -1265,26 +1370,6 @@ export class CoreNode extends EventEmitter {
     }
   }
 
-  updateBoundingRect() {
-    const { renderCoords, globalTransform: transform } = this;
-    assertTruthy(transform);
-    assertTruthy(renderCoords);
-
-    const { tb, tc } = transform;
-    const { x1, y1, x3, y3 } = renderCoords;
-    if (tb === 0 || tc === 0) {
-      this.renderBound = createBound(x1, y1, x3, y3, this.renderBound);
-    } else {
-      const { x2, x4, y2, y4 } = renderCoords;
-      this.renderBound = createBound(
-        Math.min(x1, x2, x3, x4),
-        Math.min(y1, y2, y3, y4),
-        Math.max(x1, x2, x3, x4),
-        Math.max(y1, y2, y3, y4),
-        this.renderBound,
-      );
-    }
-  }
   /**
    * This function calculates the clipping rectangle for a node.
    *
@@ -1300,7 +1385,7 @@ export class CoreNode extends EventEmitter {
 
     const isRotated = gt.tb !== 0 || gt.tc !== 0;
 
-    if (clipping && !isRotated) {
+    if (clipping === true && isRotated === false) {
       clippingRect.x = gt.tx;
       clippingRect.y = gt.ty;
       clippingRect.width = this.width * gt.ta;
@@ -1310,10 +1395,10 @@ export class CoreNode extends EventEmitter {
       clippingRect.valid = false;
     }
 
-    if (parentClippingRect.valid && clippingRect.valid) {
+    if (parentClippingRect.valid === true && clippingRect.valid === true) {
       // Intersect parent clipping rect with node clipping rect
       intersectRect(parentClippingRect, clippingRect, clippingRect);
-    } else if (parentClippingRect.valid) {
+    } else if (parentClippingRect.valid === true) {
       // Copy parent clipping rect
       copyRect(parentClippingRect, clippingRect);
       clippingRect.valid = true;
@@ -1642,7 +1727,12 @@ export class CoreNode extends EventEmitter {
 
   set alpha(value: number) {
     this.props.alpha = value;
-    this.setUpdateType(UpdateType.PremultipliedColors | UpdateType.WorldAlpha);
+    this.setUpdateType(
+      UpdateType.PremultipliedColors |
+        UpdateType.WorldAlpha |
+        UpdateType.Children,
+    );
+    this.childUpdateType |= UpdateType.Global;
   }
 
   get autosize(): boolean {
@@ -1659,7 +1749,10 @@ export class CoreNode extends EventEmitter {
 
   set clipping(value: boolean) {
     this.props.clipping = value;
-    this.setUpdateType(UpdateType.Clipping);
+    this.setUpdateType(
+      UpdateType.Clipping | UpdateType.RenderBounds | UpdateType.Children,
+    );
+    this.childUpdateType |= UpdateType.Global | UpdateType.Clipping;
   }
 
   get color(): number {
@@ -1825,6 +1918,9 @@ export class CoreNode extends EventEmitter {
       }
     }
     this.updateScaleRotateTransform();
+
+    // fetch render bounds from parent
+    this.setUpdateType(UpdateType.RenderBounds | UpdateType.Children);
   }
 
   get preventCleanup(): boolean {

package/src/core/Stage.ts

@@ -381,20 +381,20 @@ export class Stage {
   }
 
   addQuads(node: CoreNode) {
-    assertTruthy(this.renderer && node.globalTransform);
+    assertTruthy(this.renderer);
 
-    if (node.isRenderable) {
+    if (node.isRenderable === true) {
       node.renderQuads(this.renderer);
     }
 
     for (let i = 0; i < node.children.length; i++) {
       const child = node.children[i];
 
-      if (!child) {
+      if (child === undefined) {
         continue;
       }
 
-      if (child?.worldAlpha === 0) {
+      if (child.worldAlpha === 0) {
         continue;
       }
 

package/src/core/lib/utils.ts

@@ -244,6 +244,15 @@ export function boundInsideBound(bound1: Bound, bound2: Bound) {
   );
 }
 
+export function boundLargeThanBound(bound1: Bound, bound2: Bound) {
+  return (
+    bound1.x1 < bound2.x1 &&
+    bound1.x2 > bound2.x2 &&
+    bound1.y1 < bound2.y1 &&
+    bound1.y2 > bound2.y2
+  );
+}
+
 export function isBoundPositive(bound: Bound): boolean {
   return bound.x1 < bound.x2 && bound.y1 < bound.y2;
 }

package/src/core/renderers/canvas/CanvasCoreTexture.ts

@@ -131,7 +131,10 @@ export class CanvasCoreTexture extends CoreContextTexture {
       if (ctx) ctx.putImageData(data, 0, 0);
       this.image = canvas;
       return { width: data.width, height: data.height };
-    } else if (data instanceof ImageBitmap) {
+    } else if (
+      typeof ImageBitmap !== 'undefined' &&
+      data instanceof ImageBitmap
+    ) {
       this.image = data;
       return { width: data.width, height: data.height };
     }

package/src/core/renderers/webgl/WebGlCoreCtxTexture.ts

@@ -134,7 +134,8 @@ export class WebGlCoreCtxTexture extends CoreContextTexture {
     // If textureData is null, the texture is empty (0, 0) and we don't need to
     // upload any data to the GPU.
     if (
-      textureData.data instanceof ImageBitmap ||
+      (typeof ImageBitmap !== 'undefined' &&
+        textureData.data instanceof ImageBitmap) ||
       textureData.data instanceof ImageData ||
       // not using typeof HTMLImageElement due to web worker
       isHTMLImageElement(textureData.data)

package/src/core/renderers/webgl/WebGlCoreRenderer.ts

@@ -254,13 +254,18 @@ export class WebGlCoreRenderer extends CoreRenderer {
 
     /**
      * If the shader props contain any automatic properties, update it with the
-     * current dimensions that will be used to render the quad.
+     * current dimensions and or alpha that will be used to render the quad.
      */
-    if (shaderProps && hasOwn(shaderProps, '$dimensions')) {
-      const dimensions = shaderProps.$dimensions as Dimensions;
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      dimensions.width = width;
-      dimensions.height = height;
+    if (shaderProps !== null) {
+      if (hasOwn(shaderProps, '$dimensions')) {
+        const dimensions = shaderProps.$dimensions as Dimensions;
+        dimensions.width = width;
+        dimensions.height = height;
+      }
+
+      if (hasOwn(shaderProps, '$alpha')) {
+        shaderProps.$alpha = alpha;
+      }
     }
 
     texture = texture ?? this.defaultTexture;

package/src/core/renderers/webgl/shaders/DynamicShader.ts

@@ -172,6 +172,7 @@ export class DynamicShader extends WebGlCoreShader {
     propsB: Required<DynamicShaderProps>,
   ): boolean {
     if (
+      propsA.$alpha !== propsB.$alpha ||
       propsA.$dimensions.width !== propsB.$dimensions.width ||
       propsA.$dimensions.height !== propsB.$dimensions.height ||
       propsA.effects.length !== propsB.effects.length

package/src/main-api/Renderer.ts

@@ -192,7 +192,7 @@ export interface RendererMainSettings {
    * in the renderer and allow inspection of the state of the nodes.
    *
    */
-  inspector: typeof Inspector | undefined;
+  inspector?: typeof Inspector | false;
 
   /**
    * Renderer Engine
@@ -330,7 +330,7 @@ export class RendererMain extends EventEmitter {
       numImageWorkers:
         settings.numImageWorkers !== undefined ? settings.numImageWorkers : 2,
       enableContextSpy: settings.enableContextSpy ?? false,
-      inspector: settings.inspector,
+      inspector: settings.inspector ?? false,
       renderEngine: settings.renderEngine,
       quadBufferSize: settings.quadBufferSize ?? 4 * 1024 * 1024,
       fontEngines: settings.fontEngines,

package/dist/exports/core-api.d.ts

@@ -1,74 +0,0 @@
-/**
- * Lightning 3 Renderer Core API
- *
- * @remarks
- * ```
- * import * from '@lightning/renderer/core';
- * ```
- *
- * The Core API is used by developers to extend the capabilities of the Renderer
- * by writing custom Shaders, Dynamic Shader Effects, Textures, Text Renderers,
- * etc.
- *
- * Custom capabilities as well as fonts can be loaded via Core Extensions.
- *
- * A core extension module is structured like so:
- * ```ts
- * import {
- *   CoreExtension,
- *   WebTrFontFace,
- *   SdfTrFontFace,
- *   type Stage
- * } from '@lightning/renderer/core';
- *
- * export default class MyCoreExtension extends CoreExtension {
- *   async run(stage: Stage) {
- *     stage.fontManager.addFontFace(
- *       new WebTrFontFace('Ubuntu', {}, '/fonts/Ubuntu-Regular.ttf'),
- *     );
- *
- *     stage.fontManager.addFontFace(
- *       new SdfTrFontFace(
- *         'Ubuntu',
- *         {},
- *         'msdf',
- *         stage,
- *         '/fonts/Ubuntu-Regular.msdf.png',
- *         '/fonts/Ubuntu-Regular.msdf.json',
- *       ),
- *     );
- *   }
- * }
- * ```
- *
- * And then imported and registered in the application's entry point
- * using the `@lightningjs/vite-plugin-import-chunk-url` plugin:
- * ```ts
- * import coreExtensionModuleUrl from './MyCoreExtension.js?importChunkUrl';
- *
- * // Set up driver, etc.
- *
- * // Initialize the Renderer
- * const renderer = new RendererMain(
- *   {
- *     // Other Renderer Config...
- *     coreExtensionModule: coreExtensionModuleUrl,
- *   },
- *   'app',
- *   driver,
- * );
- * ```
- *
- * @module
- */
-export * from '../src/core/renderers/webgl/WebGlCoreShader.js';
-export * from '../src/core/renderers/webgl/shaders/effects/ShaderEffect.js';
-export * from '../src/core/textures/Texture.js';
-export * from '../src/core/text-rendering/renderers/TextRenderer.js';
-export * from '../src/core/text-rendering/renderers/CanvasTextRenderer.js';
-export * from '../src/core/text-rendering/renderers/SdfTextRenderer/SdfTextRenderer.js';
-export * from '../src/core/text-rendering/font-face-types/TrFontFace.js';
-export * from '../src/core/text-rendering/font-face-types/WebTrFontFace.js';
-export * from '../src/core/text-rendering/font-face-types/SdfTrFontFace/SdfTrFontFace.js';
-export * from '../src/core/CoreExtension.js';
-export type * from '../src/core/Stage.js';

package/dist/exports/core-api.js

@@ -1,96 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Lightning 3 Renderer Core API
- *
- * @remarks
- * ```
- * import * from '@lightning/renderer/core';
- * ```
- *
- * The Core API is used by developers to extend the capabilities of the Renderer
- * by writing custom Shaders, Dynamic Shader Effects, Textures, Text Renderers,
- * etc.
- *
- * Custom capabilities as well as fonts can be loaded via Core Extensions.
- *
- * A core extension module is structured like so:
- * ```ts
- * import {
- *   CoreExtension,
- *   WebTrFontFace,
- *   SdfTrFontFace,
- *   type Stage
- * } from '@lightning/renderer/core';
- *
- * export default class MyCoreExtension extends CoreExtension {
- *   async run(stage: Stage) {
- *     stage.fontManager.addFontFace(
- *       new WebTrFontFace('Ubuntu', {}, '/fonts/Ubuntu-Regular.ttf'),
- *     );
- *
- *     stage.fontManager.addFontFace(
- *       new SdfTrFontFace(
- *         'Ubuntu',
- *         {},
- *         'msdf',
- *         stage,
- *         '/fonts/Ubuntu-Regular.msdf.png',
- *         '/fonts/Ubuntu-Regular.msdf.json',
- *       ),
- *     );
- *   }
- * }
- * ```
- *
- * And then imported and registered in the application's entry point
- * using the `@lightningjs/vite-plugin-import-chunk-url` plugin:
- * ```ts
- * import coreExtensionModuleUrl from './MyCoreExtension.js?importChunkUrl';
- *
- * // Set up driver, etc.
- *
- * // Initialize the Renderer
- * const renderer = new RendererMain(
- *   {
- *     // Other Renderer Config...
- *     coreExtensionModule: coreExtensionModuleUrl,
- *   },
- *   'app',
- *   driver,
- * );
- * ```
- *
- * @module
- */
-// Shaders
-export * from '../src/core/renderers/webgl/WebGlCoreShader.js';
-export * from '../src/core/renderers/webgl/shaders/effects/ShaderEffect.js';
-// Textures
-export * from '../src/core/textures/Texture.js';
-// Text Rendering & Fonts
-export * from '../src/core/text-rendering/renderers/TextRenderer.js';
-export * from '../src/core/text-rendering/renderers/CanvasTextRenderer.js';
-export * from '../src/core/text-rendering/renderers/SdfTextRenderer/SdfTextRenderer.js';
-export * from '../src/core/text-rendering/font-face-types/TrFontFace.js';
-export * from '../src/core/text-rendering/font-face-types/WebTrFontFace.js';
-export * from '../src/core/text-rendering/font-face-types/SdfTrFontFace/SdfTrFontFace.js';
-// Core Extensions
-export * from '../src/core/CoreExtension.js';
-//# sourceMappingURL=core-api.js.map

package/dist/exports/core-api.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-api.js","sourceRoot":"","sources":["../../exports/core-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,UAAU;AACV,cAAc,gDAAgD,CAAC;AAC/D,cAAc,6DAA6D,CAAC;AAE5E,WAAW;AACX,cAAc,iCAAiC,CAAC;AAEhD,yBAAyB;AACzB,cAAc,sDAAsD,CAAC;AACrE,cAAc,4DAA4D,CAAC;AAC3E,cAAc,yEAAyE,CAAC;AACxF,cAAc,0DAA0D,CAAC;AACzE,cAAc,6DAA6D,CAAC;AAC5E,cAAc,2EAA2E,CAAC;AAE1F,kBAAkB;AAClB,cAAc,8BAA8B,CAAC"}