@luma.gl/core 9.3.0-alpha.8 → 9.3.0

package/src/shadertypes/shader-types/shader-block-layout.ts

@@ -0,0 +1,340 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {PrimitiveDataType} from '../data-types/data-types';
+import type {CompositeShaderType, VariableShaderType} from './shader-types';
+import {alignTo} from '../data-types/decode-data-types';
+import {getVariableShaderTypeInfo, resolveVariableShaderTypeAlias} from './shader-type-decoder';
+
+/**
+ * Describes the packing for one flattened field in a shader block.
+ *
+ * Offsets, sizes, and strides are expressed in 32-bit words so the result can
+ * be consumed directly by typed-array writers.
+ */
+export type ShaderBlockLayoutEntry = {
+  /** Offset in 32-bit words from the start of the block. */
+  offset: number;
+  /** Occupied size in 32-bit words, excluding external array stride. */
+  size: number;
+  /** Number of logical scalar components in the declared value. */
+  components: number;
+  /** Number of matrix columns, or `1` for scalars and vectors. */
+  columns: number;
+  /** Number of rows in each column, or vector length for vectors. */
+  rows: number;
+  /** Distance between matrix columns in 32-bit words. */
+  columnStride: number;
+  /** Canonical shader type after alias resolution. */
+  shaderType: VariableShaderType;
+  /** Scalar data type used to write the value. */
+  type: PrimitiveDataType;
+};
+
+/**
+ * Options for {@link makeShaderBlockLayout}.
+ */
+export type ShaderBlockLayoutOptions = {
+  /**
+   * Packing rules to apply when building the layout.
+   *
+   * Defaults to `'std140'`.
+   */
+  layout?: 'std140' | 'wgsl-uniform' | 'wgsl-storage';
+};
+
+/**
+ * Immutable layout metadata for a uniform or storage-style shader block.
+ */
+export type ShaderBlockLayout = {
+  /** Packing rules used when this layout was created. */
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage';
+  /** Exact number of packed bytes required by the block. */
+  byteLength: number;
+  /** Original composite shader type declarations keyed by top-level field. */
+  uniformTypes: Record<string, CompositeShaderType>;
+  /** Flattened leaf field layouts keyed by field path. */
+  fields: Record<string, ShaderBlockLayoutEntry>;
+};
+
+/**
+ * Builds a deterministic shader-block layout from composite shader type declarations.
+ *
+ * The returned value is pure layout metadata. It records the packed field
+ * offsets and exact packed byte length, but it does not allocate buffers or
+ * serialize values.
+ */
+export function makeShaderBlockLayout(
+  uniformTypes: Readonly<Record<string, CompositeShaderType>>,
+  options: ShaderBlockLayoutOptions = {}
+): ShaderBlockLayout {
+  const copiedUniformTypes = {...uniformTypes};
+  const layout = options.layout ?? 'std140';
+  const fields: Record<string, ShaderBlockLayoutEntry> = {};
+
+  let size = 0;
+  for (const [key, uniformType] of Object.entries(copiedUniformTypes)) {
+    size = addToLayout(fields, key, uniformType, size, layout);
+  }
+
+  size = alignTo(size, getTypeAlignment(copiedUniformTypes, layout));
+
+  return {
+    layout,
+    byteLength: size * 4,
+    uniformTypes: copiedUniformTypes,
+    fields
+  };
+}
+
+/**
+ * Returns the layout metadata for a scalar, vector, or matrix leaf type.
+ *
+ * The result includes both the occupied size in 32-bit words and the alignment
+ * requirement that must be applied before placing the value in a shader block.
+ */
+export function getLeafLayoutInfo(
+  type: VariableShaderType,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): Omit<ShaderBlockLayoutEntry, 'offset'> & {alignment: 1 | 2 | 4} {
+  const resolvedType = resolveVariableShaderTypeAlias(type);
+  const decodedType = getVariableShaderTypeInfo(resolvedType);
+  const matrixMatch = /^mat(\d)x(\d)<.+>$/.exec(resolvedType);
+
+  if (matrixMatch) {
+    const columns = Number(matrixMatch[1]);
+    const rows = Number(matrixMatch[2]);
+    const columnInfo = getVectorLayoutInfo(
+      rows as 2 | 3 | 4,
+      resolvedType,
+      decodedType.type,
+      layout
+    );
+    const columnStride = getMatrixColumnStride(columnInfo.size, columnInfo.alignment, layout);
+
+    return {
+      alignment: columnInfo.alignment,
+      size: columns * columnStride,
+      components: columns * rows,
+      columns,
+      rows,
+      columnStride,
+      shaderType: resolvedType,
+      type: decodedType.type
+    };
+  }
+
+  const vectorMatch = /^vec(\d)<.+>$/.exec(resolvedType);
+  if (vectorMatch) {
+    return getVectorLayoutInfo(
+      Number(vectorMatch[1]) as 2 | 3 | 4,
+      resolvedType,
+      decodedType.type,
+      layout
+    );
+  }
+
+  return {
+    alignment: 1,
+    size: 1,
+    components: 1,
+    columns: 1,
+    rows: 1,
+    columnStride: 1,
+    shaderType: resolvedType,
+    type: decodedType.type
+  };
+}
+
+/**
+ * Type guard for composite struct declarations.
+ */
+export function isCompositeShaderTypeStruct(
+  value: CompositeShaderType
+): value is Record<string, CompositeShaderType> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+/**
+ * Recursively adds a composite type to the flattened field map.
+ *
+ * @returns The next free 32-bit-word offset after the inserted type.
+ */
+function addToLayout(
+  fields: Record<string, ShaderBlockLayoutEntry>,
+  name: string,
+  type: CompositeShaderType,
+  offset: number,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): number {
+  if (typeof type === 'string') {
+    const info = getLeafLayoutInfo(type, layout);
+    const alignedOffset = alignTo(offset, info.alignment);
+    fields[name] = {
+      offset: alignedOffset,
+      ...info
+    };
+    return alignedOffset + info.size;
+  }
+
+  if (Array.isArray(type)) {
+    if (Array.isArray(type[0])) {
+      throw new Error(`Nested arrays are not supported for ${name}`);
+    }
+
+    const elementType = type[0] as CompositeShaderType;
+    const length = type[1] as number;
+    const stride = getArrayStride(elementType, layout);
+    const arrayOffset = alignTo(offset, getTypeAlignment(type, layout));
+
+    for (let i = 0; i < length; i++) {
+      addToLayout(fields, `${name}[${i}]`, elementType, arrayOffset + i * stride, layout);
+    }
+    return arrayOffset + stride * length;
+  }
+
+  if (isCompositeShaderTypeStruct(type)) {
+    const structAlignment = getTypeAlignment(type, layout);
+    let structOffset = alignTo(offset, structAlignment);
+    for (const [memberName, memberType] of Object.entries(type)) {
+      structOffset = addToLayout(fields, `${name}.${memberName}`, memberType, structOffset, layout);
+    }
+    return alignTo(structOffset, structAlignment);
+  }
+
+  throw new Error(`Unsupported CompositeShaderType for ${name}`);
+}
+
+/**
+ * Returns the occupied size of a composite type in 32-bit words.
+ */
+function getTypeSize(
+  type: CompositeShaderType,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): number {
+  if (typeof type === 'string') {
+    return getLeafLayoutInfo(type, layout).size;
+  }
+
+  if (Array.isArray(type)) {
+    const elementType = type[0] as CompositeShaderType;
+    const length = type[1] as number;
+
+    if (Array.isArray(elementType)) {
+      throw new Error('Nested arrays are not supported');
+    }
+
+    return getArrayStride(elementType, layout) * length;
+  }
+
+  let size = 0;
+  for (const memberType of Object.values(type)) {
+    const compositeMemberType = memberType as CompositeShaderType;
+    size = alignTo(size, getTypeAlignment(compositeMemberType, layout));
+    size += getTypeSize(compositeMemberType, layout);
+  }
+
+  return alignTo(size, getTypeAlignment(type, layout));
+}
+
+/**
+ * Returns the required alignment of a composite type in 32-bit words.
+ */
+function getTypeAlignment(
+  type: CompositeShaderType,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): 1 | 2 | 4 {
+  if (typeof type === 'string') {
+    return getLeafLayoutInfo(type, layout).alignment;
+  }
+
+  if (Array.isArray(type)) {
+    const elementType = type[0] as CompositeShaderType;
+    const elementAlignment = getTypeAlignment(elementType, layout);
+    return uses16ByteArrayAlignment(layout)
+      ? (Math.max(elementAlignment, 4) as 1 | 2 | 4)
+      : elementAlignment;
+  }
+
+  let maxAlignment: 1 | 2 | 4 = 1;
+  for (const memberType of Object.values(type)) {
+    const memberAlignment = getTypeAlignment(memberType as CompositeShaderType, layout);
+    maxAlignment = Math.max(maxAlignment, memberAlignment) as 1 | 2 | 4;
+  }
+
+  return uses16ByteStructAlignment(layout)
+    ? (Math.max(maxAlignment, 4) as 1 | 2 | 4)
+    : maxAlignment;
+}
+
+/**
+ * Returns the layout metadata for a vector leaf type.
+ */
+function getVectorLayoutInfo(
+  components: 2 | 3 | 4,
+  shaderType: VariableShaderType,
+  type: PrimitiveDataType,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): Omit<ShaderBlockLayoutEntry, 'offset'> & {alignment: 1 | 2 | 4} {
+  return {
+    alignment: components === 2 ? 2 : 4,
+    size: components === 3 ? 3 : components,
+    components,
+    columns: 1,
+    rows: components,
+    columnStride: components === 3 ? 3 : components,
+    shaderType,
+    type
+  };
+}
+
+/**
+ * Returns the stride of an array element in 32-bit words.
+ *
+ * This includes any layout-specific padding between adjacent array elements.
+ */
+function getArrayStride(
+  elementType: CompositeShaderType,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): number {
+  const elementSize = getTypeSize(elementType, layout);
+  const elementAlignment = getTypeAlignment(elementType, layout);
+  return getArrayLikeStride(elementSize, elementAlignment, layout);
+}
+
+/**
+ * Returns the common stride rule shared by array-like elements in the target layout.
+ */
+function getArrayLikeStride(
+  size: number,
+  alignment: 1 | 2 | 4,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): number {
+  return alignTo(size, uses16ByteArrayAlignment(layout) ? 4 : alignment);
+}
+
+/**
+ * Returns the stride of a matrix column in 32-bit words.
+ */
+function getMatrixColumnStride(
+  size: number,
+  alignment: 1 | 2 | 4,
+  layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'
+): number {
+  return layout === 'std140' ? 4 : alignTo(size, alignment);
+}
+
+/**
+ * Returns `true` when arrays must be rounded up to 16-byte boundaries.
+ */
+function uses16ByteArrayAlignment(layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'): boolean {
+  return layout === 'std140' || layout === 'wgsl-uniform';
+}
+
+/**
+ * Returns `true` when structs must be rounded up to 16-byte boundaries.
+ */
+function uses16ByteStructAlignment(layout: 'std140' | 'wgsl-uniform' | 'wgsl-storage'): boolean {
+  return layout === 'std140' || layout === 'wgsl-uniform';
+}

package/src/shadertypes/shader-types/shader-types.ts

@@ -59,7 +59,7 @@ export type ArrayShaderType = readonly [type: CompositeShaderType, length: numbe
 export type AttributeShaderTypeAlias = keyof AttributeShaderTypeAliasMap;
 
 /** @note work around for lack of type narrowing in conditional generics */
-// prettier-ignore
+// biome-ignore format: preserve layout
 type AttributeShaderTypeAliasMap = {
   vec2f: 'vec2<f32>';
   vec3f: 'vec3<f32>';
@@ -79,7 +79,7 @@ type AttributeShaderTypeAliasMap = {
 export type VariableShaderTypeAlias = keyof VariableShaderTypeAliasMap;
 
 /** @note work around for lack of type narrowing in conditional generics */
-// prettier-ignore
+// biome-ignore format: preserve layout
 type VariableShaderTypeAliasMap = {
   // Vector aliases
   vec2f: 'vec2<f32>';
@@ -149,7 +149,7 @@ export type VariableShaderTypeT<T extends VariableShaderType | keyof VariableSha
 
 // HELPER TYPES
 
-// prettier-ignore
+// biome-ignore format: preserve layout
 type TypeOfAliasSuffix<T extends string> =
   T extends 'f' ? 'f32' :
   T extends 'i' ? 'i32' :
@@ -157,14 +157,14 @@ type TypeOfAliasSuffix<T extends string> =
   T extends 'h' ? 'f16' :
   never;
 
-// prettier-ignore
+// biome-ignore format: preserve layout
 export type AttributeShaderTypeAliasT<T extends AttributeShaderTypeAlias> =
   T extends `vec2${infer S}` ? `vec2<${TypeOfAliasSuffix<S>}>` :
   T extends `vec3${infer S}` ? `vec3<${TypeOfAliasSuffix<S>}>` :
   T extends `vec4${infer S}` ? `vec4<${TypeOfAliasSuffix<S>}>` :
   never;
 
-// prettier-ignore
+// biome-ignore format: preserve layout
 export type VariableShaderTypeAliasT<T extends VariableShaderTypeAlias> =
   T extends `vec2${infer S}` ? `vec2<${TypeOfAliasSuffix<S>}>` :
   T extends `vec3${infer S}` ? `vec3<${TypeOfAliasSuffix<S>}>` :

package/src/shadertypes/texture-types/texture-format-decoder.ts

@@ -18,7 +18,7 @@ import {getTextureFormatDefinition} from './texture-format-table';
 const RGB_FORMAT_REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
 const COLOR_FORMAT_PREFIXES = ['rgb', 'rgba', 'bgra'];
 const DEPTH_FORMAT_PREFIXES = ['depth', 'stencil'];
-// prettier-ignore
+// biome-ignore format: preserve layout
 const COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
   'bc1', 'bc2', 'bc3', 'bc4', 'bc5', 'bc6', 'bc7', 'etc1', 'etc2', 'eac', 'atc', 'astc', 'pvrtc'
 ];

package/src/shadertypes/texture-types/texture-format-table.ts

@@ -68,7 +68,7 @@ export function getTextureFormatTable(): Readonly<Record<TextureFormat, TextureF
   return TEXTURE_FORMAT_TABLE;
 }
 
-// prettier-ignore
+// biome-ignore format: preserve layout
 const TEXTURE_FORMAT_COLOR_DEPTH_TABLE: Readonly<Record<TextureFormatColorUncompressed | TextureFormatDepthStencil, TextureFormatDefinition>> = {
   // 8-bit formats
   'r8unorm': {},
@@ -153,7 +153,7 @@ const TEXTURE_FORMAT_COLOR_DEPTH_TABLE: Readonly<Record<TextureFormatColorUncomp
   'depth32float-stencil8': {attachment: 'depth-stencil', bitsPerChannel: [32, 8, 0, 0], packed: true},
 };
 
-// prettier-ignore
+// biome-ignore format: preserve layout
 const TEXTURE_FORMAT_COMPRESSED_TABLE: Readonly<Record<TextureFormatCompressed, TextureFormatDefinition>> = {
 
   // BC compressed formats: check device.features.has("texture-compression-bc");

package/src/shadertypes/vertex-types/vertex-format-decoder.ts

@@ -49,7 +49,7 @@ export class VertexFormatDecoder {
       : signedDataType;
 
     switch (dataType) {
-      // TODO - Special cases for WebGL (not supported on WebGPU), overrides the check below
+      // Special cases for WebGL-only x3 formats that WebGPU does not support.
       case 'unorm8':
         if (components === 1) {
           return 'unorm8';
@@ -60,14 +60,58 @@ export class VertexFormatDecoder {
         return `${dataType}x${components}`;
 
       case 'snorm8':
+        if (components === 1) {
+          return 'snorm8';
+        }
+        if (components === 3) {
+          return 'snorm8x3-webgl';
+        }
+        return `${dataType}x${components}`;
+
       case 'uint8':
       case 'sint8':
-      // WebGPU 8 bit formats must be aligned to 16 bit boundaries');
-      // fall through
+        // WebGPU 8 bit formats must be aligned to 16 bit boundaries.
+        if (components === 1 || components === 3) {
+          throw new Error(`size: ${components}`);
+        }
+        return `${dataType}x${components}`;
+
       case 'uint16':
+        if (components === 1) {
+          return 'uint16';
+        }
+        if (components === 3) {
+          return 'uint16x3-webgl';
+        }
+        return `${dataType}x${components}`;
+
       case 'sint16':
+        if (components === 1) {
+          return 'sint16';
+        }
+        if (components === 3) {
+          return 'sint16x3-webgl';
+        }
+        return `${dataType}x${components}`;
+
       case 'unorm16':
+        if (components === 1) {
+          return 'unorm16';
+        }
+        if (components === 3) {
+          return 'unorm16x3-webgl';
+        }
+        return `${dataType}x${components}`;
+
       case 'snorm16':
+        if (components === 1) {
+          return 'snorm16';
+        }
+        if (components === 3) {
+          return 'snorm16x3-webgl';
+        }
+        return `${dataType}x${components}`;
+
       case 'float16':
         // WebGPU 16 bit formats must be aligned to 32 bit boundaries
         if (components === 1 || components === 3) {

package/src/shadertypes/vertex-types/vertex-formats.ts

@@ -39,12 +39,16 @@ export type VertexFormat =
   | 'unorm16' // Chrome 133+
   | 'snorm16' // Chrome 133+
   | 'uint16x2'
+  | 'uint16x3-webgl' // Not in WebGPU
   | 'uint16x4'
   | 'sint16x2'
+  | 'sint16x3-webgl' // Not in WebGPU
   | 'sint16x4'
   | 'unorm16x2'
+  | 'unorm16x3-webgl' // Not in WebGPU
   | 'unorm16x4'
   | 'snorm16x2'
+  | 'snorm16x3-webgl' // Not in WebGPU
   | 'snorm16x4'
   // 32 bit integers
   | 'uint32'
@@ -143,10 +147,10 @@ type VertexFormatUnorm8 =
   | 'unorm8x4-bgra'
   | 'unorm10-10-10-2';
 type VertexFormatSnorm8 = 'snorm8' | 'snorm8x2' | 'snorm8x3-webgl' | 'snorm8x4';
-type VertexFormatUint16 = 'uint16' | 'uint16x2' | 'uint16x4';
-type VertexFormatSint16 = 'sint16' | 'sint16x2' | 'sint16x4';
-type VertexFormatUnorm16 = 'unorm16' | 'unorm16x2' | 'unorm16x4';
-type VertexFormatSnorm16 = 'snorm16' | 'snorm16x2' | 'snorm16x4';
+type VertexFormatUint16 = 'uint16' | 'uint16x2' | 'uint16x3-webgl' | 'uint16x4';
+type VertexFormatSint16 = 'sint16' | 'sint16x2' | 'sint16x3-webgl' | 'sint16x4';
+type VertexFormatUnorm16 = 'unorm16' | 'unorm16x2' | 'unorm16x3-webgl' | 'unorm16x4';
+type VertexFormatSnorm16 = 'snorm16' | 'snorm16x2' | 'snorm16x3-webgl' | 'snorm16x4';
 type VertexFormatUint32 = 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4';
 type VertexFormatSint32 = 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4';
 type VertexFormatFloat16 = 'float16' | 'float16x2' | 'float16x4';
@@ -165,7 +169,16 @@ type VertexFormat2Components =
   | 'sint32x2'
   | 'float16x2'
   | 'float32x2';
-type VertexFormat3Components = 'unorm8x3-webgl' | 'uint32x3' | 'sint32x3' | 'float32x3';
+type VertexFormat3Components =
+  | 'unorm8x3-webgl'
+  | 'snorm8x3-webgl'
+  | 'uint16x3-webgl'
+  | 'sint16x3-webgl'
+  | 'unorm16x3-webgl'
+  | 'snorm16x3-webgl'
+  | 'uint32x3'
+  | 'sint32x3'
+  | 'float32x3';
 type VertexFormat4Components =
   | 'uint8x4'
   | 'sint8x4'

package/dist/portable/uniform-buffer-layout.d.ts

@@ -1,42 +0,0 @@
-import type { PrimitiveDataType } from "../shadertypes/data-types/data-types.js";
-import type { CompositeShaderType, VariableShaderType } from "../shadertypes/shader-types/shader-types.js";
-import type { CompositeUniformValue, UniformValue } from "../adapter/types/uniforms.js";
-type UniformLayoutEntry = {
-    offset: number;
-    size: number;
-    components: number;
-    columns: number;
-    rows: number;
-    shaderType: VariableShaderType;
-    type: PrimitiveDataType;
-};
-export type UniformValues = Record<string, CompositeUniformValue>;
-/**
- * Std140 layout for uniform buffers
- * Supports manual listing of uniforms
- */
-export declare class UniformBufferLayout {
-    readonly layout: Record<string, UniformLayoutEntry>;
-    readonly uniformTypes: Record<string, CompositeShaderType>;
-    /** number of bytes needed for buffer allocation */
-    readonly byteLength: number;
-    /** Create a new UniformBufferLayout given a map of attributes. */
-    constructor(uniformTypes: Readonly<Record<string, CompositeShaderType>>);
-    /** Does this layout have a field with specified name */
-    has(name: string): boolean;
-    /** Get offset and size for a field with specified name */
-    get(name: string): {
-        offset: number;
-        size: number;
-    } | undefined;
-    /** Flatten nested uniform values into leaf-path values understood by UniformBlock. */
-    getFlatUniformValues(uniformValues: Readonly<UniformValues>): Record<string, UniformValue>;
-    /** Get the data for the complete buffer */
-    getData(uniformValues: Readonly<UniformValues>): Uint8Array;
-    private _addToLayout;
-    private _flattenCompositeValue;
-    private _flattenPackedArray;
-    private _writeLeafValue;
-}
-export {};
-//# sourceMappingURL=uniform-buffer-layout.d.ts.map

package/dist/portable/uniform-buffer-layout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uniform-buffer-layout.d.ts","sourceRoot":"","sources":["../../src/portable/uniform-buffer-layout.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,iBAAiB,EAAC,gDAA6C;AAC5E,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EACnB,oDAAiD;AAOlD,OAAO,KAAK,EAAC,qBAAqB,EAAE,YAAY,EAAC,qCAAkC;AAKnF,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,kBAAkB,CAAC;IAC/B,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAQlE;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAM;IACzD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAE3D,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,kEAAkE;gBACtD,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAavE,wDAAwD;IACxD,GAAG,CAAC,IAAI,EAAE,MAAM;IAIhB,0DAA0D;IAC1D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAAG,SAAS;IAK7D,sFAAsF;IACtF,oBAAoB,CAAC,aAAa,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;IAe1F,2CAA2C;IAC3C,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,UAAU;IAmB3D,OAAO,CAAC,YAAY;IAsCpB,OAAO,CAAC,sBAAsB;IAgE9B,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,eAAe;CAoCxB"}