@luma.gl/webgl 9.0.0-beta.3 → 9.0.0-beta.5

package/dist/classic/copy-and-blit.js

@@ -1,192 +1,191 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
 import { assert, Texture, Framebuffer } from '@luma.gl/core';
-import { getGLTypeFromTypedArray, getTypedArrayFromGLType } from "./typed-array-utils.js";
-import { glFormatToComponents, glTypeToBytes } from "./format-utils.js";
+import { GL } from '@luma.gl/constants';
+import { getGLTypeFromTypedArray, getTypedArrayFromGLType } from './typed-array-utils';
+import { glFormatToComponents, glTypeToBytes } from './format-utils';
+/**
+ * Copies data from a type  or a Texture object into ArrayBuffer object.
+ * App can provide targetPixelArray or have it auto allocated by this method
+ *  newly allocated by this method unless provided by app.
+ * @deprecated Use CommandEncoder.copyTextureToBuffer and Buffer.read
+ * @note Slow requires roundtrip to GPU
+ *
+ * @param source
+ * @param options
+ * @returns pixel array,
+ */
 export function readPixelsToArray(source, options) {
-  var _framebuffer$colorAtt;
-  const {
-    sourceX = 0,
-    sourceY = 0,
-    sourceFormat = 6408,
-    sourceAttachment = 36064
-  } = options || {};
-  let {
-    target = null,
-    sourceWidth,
-    sourceHeight,
-    sourceType
-  } = options || {};
-  const {
-    framebuffer,
-    deleteFramebuffer
-  } = getFramebuffer(source);
-  assert(framebuffer);
-  const {
-    gl,
-    handle
-  } = framebuffer;
-  sourceWidth = sourceWidth || framebuffer.width;
-  sourceHeight = sourceHeight || framebuffer.height;
-  const attachment = sourceAttachment - 36064;
-  sourceType = sourceType || ((_framebuffer$colorAtt = framebuffer.colorAttachments[attachment]) === null || _framebuffer$colorAtt === void 0 ? void 0 : _framebuffer$colorAtt.type) || 5121;
-  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
-  sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle = gl.bindFramebuffer(36160, handle);
-  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(36160, prevHandle || null);
-  if (deleteFramebuffer) {
-    framebuffer.destroy();
-  }
-  return target;
+    const { sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA, sourceAttachment = GL.COLOR_ATTACHMENT0 // TODO - support gl.readBuffer
+     } = options || {};
+    let { target = null, 
+    // following parameters are auto deduced if not provided
+    sourceWidth, sourceHeight, sourceType } = options || {};
+    const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
+    assert(framebuffer);
+    const { gl, handle } = framebuffer;
+    sourceWidth = sourceWidth || framebuffer.width;
+    sourceHeight = sourceHeight || framebuffer.height;
+    // TODO - Set and unset gl.readBuffer
+    // if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
+    //   sourceAttachment = GL.FRONT;
+    // }
+    const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;
+    // assert(attachments[sourceAttachment]);
+    // Deduce the type from color attachment if not provided.
+    sourceType =
+        sourceType ||
+            framebuffer.colorAttachments[attachment]?.type ||
+            GL.UNSIGNED_BYTE;
+    // Deduce type and allocated pixelArray if needed
+    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+    // Pixel array available, if necessary, deduce type from it.
+    sourceType = sourceType || getGLTypeFromTypedArray(target);
+    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+    // @ts-expect-error
+    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+    if (deleteFramebuffer) {
+        framebuffer.destroy();
+    }
+    return target;
 }
+/**
+ * Copies data from a Framebuffer or a Texture object into a Buffer object.
+ * NOTE: doesn't wait for copy to be complete, it programs GPU to perform a DMA transffer.
+ * @deprecated Use CommandEncoder
+ * @param source
+ * @param options
+ */
 export function readPixelsToBuffer(source, options) {
-  const {
-    target,
-    sourceX = 0,
-    sourceY = 0,
-    sourceFormat = 6408,
-    targetByteOffset = 0
-  } = options || {};
-  let {
-    sourceWidth,
-    sourceHeight,
-    sourceType
-  } = options || {};
-  const {
-    framebuffer,
-    deleteFramebuffer
-  } = getFramebuffer(source);
-  assert(framebuffer);
-  sourceWidth = sourceWidth || framebuffer.width;
-  sourceHeight = sourceHeight || framebuffer.height;
-  const webglFramebuffer = framebuffer;
-  sourceType = sourceType || 5121;
-  let webglBufferTarget = target;
-  if (!webglBufferTarget) {
-    const components = glFormatToComponents(sourceFormat);
-    const byteCount = glTypeToBytes(sourceType);
-    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
-    webglBufferTarget = webglFramebuffer.device.createBuffer({
-      byteLength
+    const { target, sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA, targetByteOffset = 0 } = options || {};
+    // following parameters are auto deduced if not provided
+    let { sourceWidth, sourceHeight, sourceType } = options || {};
+    const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
+    assert(framebuffer);
+    sourceWidth = sourceWidth || framebuffer.width;
+    sourceHeight = sourceHeight || framebuffer.height;
+    // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature
+    const webglFramebuffer = framebuffer;
+    // deduce type if not available.
+    sourceType = sourceType || GL.UNSIGNED_BYTE;
+    let webglBufferTarget = target;
+    if (!webglBufferTarget) {
+        // Create new buffer with enough size
+        const components = glFormatToComponents(sourceFormat);
+        const byteCount = glTypeToBytes(sourceType);
+        const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+        webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength });
+    }
+    // TODO(donmccurdy): Do we have tests to confirm this is working?
+    const commandEncoder = source.device.createCommandEncoder();
+    commandEncoder.copyTextureToBuffer({
+        source: source,
+        width: sourceWidth,
+        height: sourceHeight,
+        origin: [sourceX, sourceY],
+        destination: webglBufferTarget,
+        byteOffset: targetByteOffset
     });
-  }
-  const commandEncoder = source.device.createCommandEncoder();
-  commandEncoder.copyTextureToBuffer({
-    source: source,
-    width: sourceWidth,
-    height: sourceHeight,
-    origin: [sourceX, sourceY],
-    destination: webglBufferTarget,
-    byteOffset: targetByteOffset
-  });
-  commandEncoder.destroy();
-  if (deleteFramebuffer) {
-    framebuffer.destroy();
-  }
-  return webglBufferTarget;
+    commandEncoder.destroy();
+    if (deleteFramebuffer) {
+        framebuffer.destroy();
+    }
+    return webglBufferTarget;
 }
+/**
+ * Copy a rectangle from a Framebuffer or Texture object into a texture (at an offset)
+ * @deprecated Use CommandEncoder
+ */
+// eslint-disable-next-line complexity, max-statements
 export function copyToTexture(source, target, options) {
-  const {
-    sourceX = 0,
-    sourceY = 0,
-    targetMipmaplevel = 0,
-    targetInternalFormat = 6408
-  } = options || {};
-  let {
-    targetX,
-    targetY,
-    targetZ,
-    width,
-    height
-  } = options || {};
-  const {
-    framebuffer,
-    deleteFramebuffer
-  } = getFramebuffer(source);
-  assert(framebuffer);
-  const webglFramebuffer = framebuffer;
-  const {
-    device,
-    handle
-  } = webglFramebuffer;
-  const isSubCopy = typeof targetX !== 'undefined' || typeof targetY !== 'undefined' || typeof targetZ !== 'undefined';
-  targetX = targetX || 0;
-  targetY = targetY || 0;
-  targetZ = targetZ || 0;
-  const prevHandle = device.gl.bindFramebuffer(36160, handle);
-  assert(target);
-  let texture = null;
-  let textureTarget;
-  if (target instanceof Texture) {
-    texture = target;
-    width = Number.isFinite(width) ? width : texture.width;
-    height = Number.isFinite(height) ? height : texture.height;
-    texture.bind(0);
-    textureTarget = texture.target;
-  } else {
-    textureTarget = target;
-  }
-  if (!isSubCopy) {
-    device.gl.copyTexImage2D(textureTarget, targetMipmaplevel, targetInternalFormat, sourceX, sourceY, width, height, 0);
-  } else {
-    switch (textureTarget) {
-      case 3553:
-      case 34067:
-        device.gl.copyTexSubImage2D(textureTarget, targetMipmaplevel, targetX, targetY, sourceX, sourceY, width, height);
-        break;
-      case 35866:
-      case 32879:
-        device.assertWebGL2();
-        device.gl2.copyTexSubImage3D(textureTarget, targetMipmaplevel, targetX, targetY, targetZ, sourceX, sourceY, width, height);
-        break;
-      default:
+    const { sourceX = 0, sourceY = 0, 
+    // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
+    targetMipmaplevel = 0, targetInternalFormat = GL.RGBA } = options || {};
+    let { targetX, targetY, targetZ, width, // defaults to target width
+    height // defaults to target height
+     } = options || {};
+    const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
+    assert(framebuffer);
+    const webglFramebuffer = framebuffer;
+    const { device, handle } = webglFramebuffer;
+    const isSubCopy = typeof targetX !== 'undefined' ||
+        typeof targetY !== 'undefined' ||
+        typeof targetZ !== 'undefined';
+    targetX = targetX || 0;
+    targetY = targetY || 0;
+    targetZ = targetZ || 0;
+    const prevHandle = device.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    // TODO - support gl.readBuffer (WebGL2 only)
+    // const prevBuffer = gl.readBuffer(attachment);
+    assert(target);
+    let texture = null;
+    let textureTarget;
+    if (target instanceof Texture) {
+        texture = target;
+        width = Number.isFinite(width) ? width : texture.width;
+        height = Number.isFinite(height) ? height : texture.height;
+        texture.bind(0);
+        textureTarget = texture.target;
+    }
+    else {
+        textureTarget = target;
+    }
+    if (!isSubCopy) {
+        device.gl.copyTexImage2D(textureTarget, targetMipmaplevel, targetInternalFormat, sourceX, sourceY, width, height, 0 /* border must be 0 */);
+    }
+    else {
+        switch (textureTarget) {
+            case GL.TEXTURE_2D:
+            case GL.TEXTURE_CUBE_MAP:
+                device.gl.copyTexSubImage2D(textureTarget, targetMipmaplevel, targetX, targetY, sourceX, sourceY, width, height);
+                break;
+            case GL.TEXTURE_2D_ARRAY:
+            case GL.TEXTURE_3D:
+                device.gl.copyTexSubImage3D(textureTarget, targetMipmaplevel, targetX, targetY, targetZ, sourceX, sourceY, width, height);
+                break;
+            default:
+        }
     }
-  }
-  if (texture) {
-    texture.unbind();
-  }
-  device.gl.bindFramebuffer(36160, prevHandle || null);
-  if (deleteFramebuffer) {
-    framebuffer.destroy();
-  }
-  return texture;
+    if (texture) {
+        texture.unbind();
+    }
+    // @ts-expect-error
+    device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+    if (deleteFramebuffer) {
+        framebuffer.destroy();
+    }
+    return texture;
 }
 function getFramebuffer(source) {
-  if (!(source instanceof Framebuffer)) {
-    return {
-      framebuffer: toFramebuffer(source),
-      deleteFramebuffer: true
-    };
-  }
-  return {
-    framebuffer: source,
-    deleteFramebuffer: false
-  };
+    if (!(source instanceof Framebuffer)) {
+        return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
+    }
+    return { framebuffer: source, deleteFramebuffer: false };
 }
+/**
+ * Wraps a given texture into a framebuffer object, that can be further used
+ * to read data from the texture object.
+ */
 export function toFramebuffer(texture, props) {
-  const {
-    device,
-    width,
-    height,
-    id
-  } = texture;
-  const framebuffer = device.createFramebuffer({
-    ...props,
-    id: `framebuffer-for-${id}`,
-    width,
-    height,
-    colorAttachments: [texture]
-  });
-  return framebuffer;
+    const { device, width, height, id } = texture;
+    const framebuffer = device.createFramebuffer({
+        ...props,
+        id: `framebuffer-for-${id}`,
+        width,
+        height,
+        colorAttachments: [texture]
+    });
+    return framebuffer;
 }
 function getPixelArray(pixelArray, type, format, width, height) {
-  if (pixelArray) {
-    return pixelArray;
-  }
-  type = type || 5121;
-  const ArrayType = getTypedArrayFromGLType(type, {
-    clamped: false
-  });
-  const components = glFormatToComponents(format);
-  return new ArrayType(width * height * components);
+    if (pixelArray) {
+        return pixelArray;
+    }
+    // Allocate pixel array if not already available, using supplied type
+    type = type || GL.UNSIGNED_BYTE;
+    const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
+    const components = glFormatToComponents(format);
+    // TODO - check for composite type (components = 1).
+    return new ArrayType(width * height * components);
 }
-//# sourceMappingURL=copy-and-blit.js.map

package/dist/classic/format-utils.d.ts

@@ -1,3 +1,3 @@
-export declare function glFormatToComponents(format: any): 2 | 0 | 1 | 4 | 3;
-export declare function glTypeToBytes(type: any): 2 | 0 | 1 | 4;
+export declare function glFormatToComponents(format: any): 0 | 1 | 4 | 2 | 3;
+export declare function glTypeToBytes(type: any): 0 | 1 | 4 | 2;
 //# sourceMappingURL=format-utils.d.ts.map

package/dist/classic/format-utils.js

@@ -1,37 +1,43 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
 import { assert } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+// Returns number of components in a specific readPixels WebGL format
 export function glFormatToComponents(format) {
-  switch (format) {
-    case 6406:
-    case 33326:
-    case 6403:
-      return 1;
-    case 33328:
-    case 33319:
-      return 2;
-    case 6407:
-    case 34837:
-      return 3;
-    case 6408:
-    case 34836:
-      return 4;
-    default:
-      assert(false);
-      return 0;
-  }
+    switch (format) {
+        case GL.ALPHA:
+        case GL.R32F:
+        case GL.RED:
+            return 1;
+        case GL.RG32F:
+        case GL.RG:
+            return 2;
+        case GL.RGB:
+        case GL.RGB32F:
+            return 3;
+        case GL.RGBA:
+        case GL.RGBA32F:
+            return 4;
+        // TODO: Add support for additional WebGL2 formats
+        default:
+            assert(false);
+            return 0;
+    }
 }
+// Return byte count for given readPixels WebGL type
 export function glTypeToBytes(type) {
-  switch (type) {
-    case 5121:
-      return 1;
-    case 33635:
-    case 32819:
-    case 32820:
-      return 2;
-    case 5126:
-      return 4;
-    default:
-      assert(false);
-      return 0;
-  }
+    switch (type) {
+        case GL.UNSIGNED_BYTE:
+            return 1;
+        case GL.UNSIGNED_SHORT_5_6_5:
+        case GL.UNSIGNED_SHORT_4_4_4_4:
+        case GL.UNSIGNED_SHORT_5_5_5_1:
+            return 2;
+        case GL.FLOAT:
+            return 4;
+        // TODO: Add support for additional WebGL2 types
+        default:
+            assert(false);
+            return 0;
+    }
 }
-//# sourceMappingURL=format-utils.js.map

package/dist/classic/typed-array-utils.js

@@ -1,91 +1,105 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+import { GL } from '@luma.gl/constants';
 const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
+/**
+ * Converts TYPED ARRAYS to corresponding GL constant
+ * Used to auto deduce gl parameter types
+ * @deprecated Use getDataTypeFromTypedArray
+ * @param arrayOrType
+ * @returns
+ */
 export function getGLTypeFromTypedArray(arrayOrType) {
-  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-  switch (type) {
-    case Float32Array:
-      return 5126;
-    case Uint16Array:
-      return 5123;
-    case Uint32Array:
-      return 5125;
-    case Uint8Array:
-      return 5121;
-    case Uint8ClampedArray:
-      return 5121;
-    case Int8Array:
-      return 5120;
-    case Int16Array:
-      return 5122;
-    case Int32Array:
-      return 5124;
-    default:
-      throw new Error(ERR_TYPE_DEDUCTION);
-  }
+    // If typed array, look up constructor
+    const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    switch (type) {
+        case Float32Array:
+            return GL.FLOAT;
+        case Uint16Array:
+            return GL.UNSIGNED_SHORT;
+        case Uint32Array:
+            return GL.UNSIGNED_INT;
+        case Uint8Array:
+            return GL.UNSIGNED_BYTE;
+        case Uint8ClampedArray:
+            return GL.UNSIGNED_BYTE;
+        case Int8Array:
+            return GL.BYTE;
+        case Int16Array:
+            return GL.SHORT;
+        case Int32Array:
+            return GL.INT;
+        default:
+            throw new Error(ERR_TYPE_DEDUCTION);
+    }
 }
+/**
+ * Converts GL constant to corresponding TYPED ARRAY
+ * Used to auto deduce gl parameter types
+ * @deprecated Use getTypedArrayFromDataType
+ * @param glType
+ * @param param1
+ * @returns
+ */
+// eslint-disable-next-line complexity
 export function getTypedArrayFromGLType(glType, options) {
-  const {
-    clamped = true
-  } = options || {};
-  switch (glType) {
-    case 5126:
-      return Float32Array;
-    case 5123:
-    case 33635:
-    case 32819:
-    case 32820:
-      return Uint16Array;
-    case 5125:
-      return Uint32Array;
-    case 5121:
-      return clamped ? Uint8ClampedArray : Uint8Array;
-    case 5120:
-      return Int8Array;
-    case 5122:
-      return Int16Array;
-    case 5124:
-      return Int32Array;
-    default:
-      throw new Error('Failed to deduce typed array type from GL constant');
-  }
+    const { clamped = true } = options || {};
+    // Sorted in some order of likelihood to reduce amount of comparisons
+    switch (glType) {
+        case GL.FLOAT:
+            return Float32Array;
+        case GL.UNSIGNED_SHORT:
+        case GL.UNSIGNED_SHORT_5_6_5:
+        case GL.UNSIGNED_SHORT_4_4_4_4:
+        case GL.UNSIGNED_SHORT_5_5_5_1:
+            return Uint16Array;
+        case GL.UNSIGNED_INT:
+            return Uint32Array;
+        case GL.UNSIGNED_BYTE:
+            return clamped ? Uint8ClampedArray : Uint8Array;
+        case GL.BYTE:
+            return Int8Array;
+        case GL.SHORT:
+            return Int16Array;
+        case GL.INT:
+            return Int32Array;
+        default:
+            throw new Error('Failed to deduce typed array type from GL constant');
+    }
 }
+/**
+ * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)
+ * https: *stackoverflow.com/questions/41969562/
+ * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels
+ * @param param0
+ */
 export function flipRows(options) {
-  const {
-    data,
-    width,
-    height,
-    bytesPerPixel = 4,
-    temp
-  } = options;
-  const bytesPerRow = width * bytesPerPixel;
-  const tempBuffer = temp || new Uint8Array(bytesPerRow);
-  for (let y = 0; y < height / 2; ++y) {
-    const topOffset = y * bytesPerRow;
-    const bottomOffset = (height - y - 1) * bytesPerRow;
-    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
-    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
-    data.set(tempBuffer, bottomOffset);
-  }
+    const { data, width, height, bytesPerPixel = 4, temp } = options;
+    const bytesPerRow = width * bytesPerPixel;
+    // make a temp buffer to hold one row
+    const tempBuffer = temp || new Uint8Array(bytesPerRow);
+    for (let y = 0; y < height / 2; ++y) {
+        const topOffset = y * bytesPerRow;
+        const bottomOffset = (height - y - 1) * bytesPerRow;
+        // make copy of a row on the top half
+        tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
+        // copy a row from the bottom half to the top
+        data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
+        // copy the copy of the top half row to the bottom half
+        data.set(tempBuffer, bottomOffset);
+    }
 }
 export function scalePixels(options) {
-  const {
-    data,
-    width,
-    height
-  } = options;
-  const newWidth = Math.round(width / 2);
-  const newHeight = Math.round(height / 2);
-  const newData = new Uint8Array(newWidth * newHeight * 4);
-  for (let y = 0; y < newHeight; y++) {
-    for (let x = 0; x < newWidth; x++) {
-      for (let c = 0; c < 4; c++) {
-        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
-      }
+    const { data, width, height } = options;
+    const newWidth = Math.round(width / 2);
+    const newHeight = Math.round(height / 2);
+    const newData = new Uint8Array(newWidth * newHeight * 4);
+    for (let y = 0; y < newHeight; y++) {
+        for (let x = 0; x < newWidth; x++) {
+            for (let c = 0; c < 4; c++) {
+                newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
+            }
+        }
     }
-  }
-  return {
-    data: newData,
-    width: newWidth,
-    height: newHeight
-  };
+    return { data: newData, width: newWidth, height: newHeight };
 }
-//# sourceMappingURL=typed-array-utils.js.map

package/dist/context/{polyfill → context}/context-data.d.ts

@@ -9,5 +9,6 @@ export interface WebGLContextData {
  * Gets luma.gl specific state from a context
  * @returns context state
  */
-export declare function getContextData(gl: WebGLRenderingContext): WebGLContextData;
+export declare function getContextData(gl: WebGL2RenderingContext): WebGLContextData;
+export declare function initializeExtensions(gl: WebGL2RenderingContext): void;
 //# sourceMappingURL=context-data.d.ts.map

package/dist/context/context/context-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-data.d.ts","sourceRoot":"","sources":["../../../src/context/context/context-data.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,sBAAsB,GAAG,gBAAgB,CAc3E;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAYrE"}