@vitessce/gl 2.0.3 → 3.0.1

package/dist/index.js

@@ -0,0 +1,33 @@
+import { f as distEs6 } from "./index-d34ff949.js";
+import { n, m, A, q, p, o, i, C, k, D, G, e, H, c, M, j, l, d, P, S, h, T, s, b, r, v } from "./index-d34ff949.js";
+import "react";
+const SELECTION_TYPE = distEs6.SELECTION_TYPE;
+export {
+  n as AXIS_FONT_FAMILY,
+  m as AXIS_LABEL_TEXT_SIZE,
+  A as AXIS_MARGIN,
+  q as AXIS_MAX_SIZE,
+  p as AXIS_MIN_SIZE,
+  o as AXIS_PADDING,
+  i as BitmaskLayer,
+  C as COLOR_BAR_SIZE,
+  k as DATA_TEXTURE_SIZE,
+  D as DEFAULT_GL_OPTIONS,
+  G as GLSL_COLORMAPS,
+  e as GLSL_COLORMAP_DEFAULT,
+  H as HeatmapBitmapLayer,
+  c as HeatmapCompositeTextLayer,
+  M as MAX_ROW_AGG,
+  j as MIN_ROW_AGG,
+  l as PIXELATED_TEXTURE_PARAMETERS,
+  d as PaddedExpressionHeatmapBitmapLayer,
+  P as PixelatedBitmapLayer,
+  SELECTION_TYPE,
+  S as ScaledExpressionExtension,
+  h as SelectionExtension,
+  T as TILE_SIZE,
+  s as deck,
+  b as getSelectionLayers,
+  r as luma,
+  v as viv
+};

package/dist/{jpeg.060c9bc0.mjs → jpeg-a66190dc.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.9aaafdeb.mjs";
+import { B as BaseDecoder } from "./index-d34ff949.js";
 import "react";
 const dctZigZag = new Int32Array([
   0,

package/dist/{lerc.62b02b29.mjs → lerc-21af7ec8.js}

@@ -1,5 +1,5 @@
-import { i as inflate_1 } from "./pako.esm.0e57f323.mjs";
-import { B as BaseDecoder, L as LercParameters, a as LercAddCompression } from "./index.9aaafdeb.mjs";
+import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder, L as LercParameters, a as LercAddCompression } from "./index-d34ff949.js";
 import "react";
 var LercDecode = { exports: {} };
 (function(module) {
@@ -362,6 +362,8 @@ var LercDecode = { exports: {} };
     }();
     var Lerc2Decode = function() {
       var BitStuffer = {
+        //methods ending with 2 are for the new byte order used by Lerc2.3 and above.
+        //originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons.
         unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
           var bitMask = (1 << bitsPerPixel) - 1;
           var i = 0, o;
@@ -572,6 +574,7 @@ var LercDecode = { exports: {} };
       };
       var Lerc2Helpers = {
         HUFFMAN_LUT_BITS_MAX: 12,
+        //use 2^12 lut, treat it like constant
         computeChecksumFletcher32: function(input) {
           var sum1 = 65535, sum2 = 65535;
           var len = input.length;
@@ -1382,6 +1385,9 @@ var LercDecode = { exports: {} };
             data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(data.pixels.resultPixels, numPixels, numDims, OutPixelTypeArray);
           }
         },
+        /*****************
+        *  private methods (helper methods)
+        *****************/
         formatFileInfo: function(data) {
           return {
             "fileIdentifierString": data.headerInfo.fileIdentifierString,
@@ -1401,6 +1407,7 @@ var LercDecode = { exports: {} };
             "pixels": {
               "numBlocksX": data.pixels.numBlocksX,
               "numBlocksY": data.pixels.numBlocksY,
+              //"numBytes": data.pixels.numBytes,
               "maxValue": data.headerInfo.zMax,
               "minValue": data.headerInfo.zMin,
               "noDataValue": data.noDataValue
@@ -1688,14 +1695,48 @@ var LercDecode = { exports: {} };
         this.right = right;
       };
       var Lerc2Decode2 = {
+        /*
+        * ********removed options compared to LERC1. We can bring some of them back if needed.
+         * removed pixel type. LERC2 is typed and doesn't require user to give pixel type
+         * changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly.
+         * removed returnMask. mask is used by LERC2 internally and is cost free. In case of user input mask, it's returned as well and has neglible cost.
+         * removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc,
+         *       user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now.
+         *       We can add it back later if their's a clear requirement.
+         * removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient)
+         * removed computeUsedBitDepths.
+         *
+         *
+         * response changes compared to LERC1
+         * 1. encodedMaskData is not available
+         * 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range)
+         * 3. maskData is always available
+        */
+        /*****************
+        *  public properties
+        ******************/
+        //HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable
+        /*****************
+        *  public methods
+        *****************/
+        /**
+         * Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata.
+         *
+         * @param {ArrayBuffer} input The LERC input byte stream
+         * @param {object} [options] options Decoding options
+         * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position
+         * @param {boolean} [options.returnFileInfo] If true, the return value will have a fileInfo property that contains metadata obtained from the LERC headers and the decoding process
+         * @param {boolean} [options.returnPixelInterleavedDims]  If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
+         */
         decode: function(input, options) {
           options = options || {};
           var noDataValue = options.noDataValue;
           var i = 0, data = {};
           data.ptr = options.inputOffset || 0;
           data.pixels = {};
-          if (!Lerc2Helpers.readHeaderInfo(input, data))
-            ;
+          if (!Lerc2Helpers.readHeaderInfo(input, data)) {
+            return;
+          }
           var headerInfo = data.headerInfo;
           var fileVersion = headerInfo.fileVersion;
           var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
@@ -1773,6 +1814,7 @@ var LercDecode = { exports: {} };
               maxValues: headerInfo.maxValues
             },
             maskData: data.pixels.resultMask
+            //noDataValue: noDataValue
           };
           if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
             var mask = data.pixels.resultMask;
@@ -1814,6 +1856,25 @@ var LercDecode = { exports: {} };
       return b[0] === 1;
     }();
     var Lerc2 = {
+      /************wrapper**********************************************/
+      /**
+       * A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types.
+       *
+       * @alias module:Lerc
+       * @param {ArrayBuffer} input The LERC input byte stream
+       * @param {object} [options] The decoding options below are optional.
+       * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position.
+       * @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32.
+       * @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value.
+       * @param {boolean} [options.returnPixelInterleavedDims] (nDim LERC2 only) If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
+       * @returns {{width, height, pixels, pixelType, mask, statistics}}
+         * @property {number} width Width of decoded image.
+         * @property {number} height Height of decoded image.
+         * @property {array} pixels [band1, band2, …] Each band is a typed array of width*height.
+         * @property {string} pixelType The type of pixels represented in the output.
+         * @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid.
+         * @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values
+      **/
       decode: function(encodedData, options) {
         if (!isPlatformLittleEndian) {
           throw "Big endian system is not supported.";
@@ -1845,14 +1906,23 @@ var LercDecode = { exports: {} };
         while (inputOffset < eof) {
           var result = lerc.decode(encodedData, {
             inputOffset,
+            //for both lerc1 and lerc2
             encodedMaskData,
+            //lerc1 only
             maskData,
+            //lerc2 only
             returnMask: iPlane === 0 ? true : false,
+            //lerc1 only
             returnEncodedMask: iPlane === 0 ? true : false,
+            //lerc1 only
             returnFileInfo: true,
+            //for both lerc1 and lerc2
             returnPixelInterleavedDims: options.returnPixelInterleavedDims,
+            //for ndim lerc2 only
             pixelType: options.pixelType || null,
+            //lerc1 only
             noDataValue: options.noDataValue || null
+            //lerc1 only
           });
           inputOffset = result.fileInfo.eofOffset;
           maskData = result.maskData;
@@ -1905,7 +1975,8 @@ var LercDecode = { exports: {} };
     }
   })();
 })(LercDecode);
-const Lerc = LercDecode.exports;
+var LercDecodeExports = LercDecode.exports;
+const Lerc = /* @__PURE__ */ getDefaultExportFromCjs(LercDecodeExports);
 class LercDecoder extends BaseDecoder {
   constructor(fileDirectory) {
     super();

package/dist/{lzw.19cdd4de.mjs → lzw-76194936.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.9aaafdeb.mjs";
+import { B as BaseDecoder } from "./index-d34ff949.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits.03fc75de.mjs → packbits-bf7850c4.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.9aaafdeb.mjs";
+import { B as BaseDecoder } from "./index-d34ff949.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{pako.esm.0e57f323.mjs → pako.esm-68f84e2a.js}

@@ -27,9 +27,18 @@ const END_BLOCK = 256;
 const REP_3_6 = 16;
 const REPZ_3_10 = 17;
 const REPZ_11_138 = 18;
-const extra_lbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);
-const extra_dbits = new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
-const extra_blbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);
+const extra_lbits = (
+  /* extra bits for each length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0])
+);
+const extra_dbits = (
+  /* extra bits for each distance code */
+  new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13])
+);
+const extra_blbits = (
+  /* extra bits for each bit length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])
+);
 const bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
 const DIST_CODE_LEN = 512;
 const static_ltree = new Array((L_CODES$1 + 2) * 2);
@@ -79,7 +88,12 @@ const send_bits = (s, value, length) => {
   }
 };
 const send_code = (s, c, tree) => {
-  send_bits(s, tree[c * 2], tree[c * 2 + 1]);
+  send_bits(
+    s,
+    tree[c * 2],
+    tree[c * 2 + 1]
+    /*.Len*/
+  );
 };
 const bi_reverse = (code, len) => {
   let res = 0;
@@ -368,19 +382,44 @@ const build_tree = (s, desc) => {
   }
   node = elems;
   do {
-    n = s.heap[1];
-    s.heap[1] = s.heap[s.heap_len--];
-    pqdownheap(s, tree, 1);
-    m = s.heap[1];
+    n = s.heap[
+      1
+      /*SMALLEST*/
+    ];
+    s.heap[
+      1
+      /*SMALLEST*/
+    ] = s.heap[s.heap_len--];
+    pqdownheap(
+      s,
+      tree,
+      1
+      /*SMALLEST*/
+    );
+    m = s.heap[
+      1
+      /*SMALLEST*/
+    ];
     s.heap[--s.heap_max] = n;
     s.heap[--s.heap_max] = m;
     tree[node * 2] = tree[n * 2] + tree[m * 2];
     s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
     tree[n * 2 + 1] = tree[m * 2 + 1] = node;
-    s.heap[1] = node++;
-    pqdownheap(s, tree, 1);
+    s.heap[
+      1
+      /*SMALLEST*/
+    ] = node++;
+    pqdownheap(
+      s,
+      tree,
+      1
+      /*SMALLEST*/
+    );
   } while (s.heap_len >= 2);
-  s.heap[--s.heap_max] = s.heap[1];
+  s.heap[--s.heap_max] = s.heap[
+    1
+    /*SMALLEST*/
+  ];
   gen_bitlen(s, desc);
   gen_codes(tree, max_code, s.bl_count);
 };
@@ -640,16 +679,26 @@ const crc32 = (crc, buf, len, pos) => {
 var crc32_1 = crc32;
 var messages = {
   2: "need dictionary",
+  /* Z_NEED_DICT       2  */
   1: "stream end",
+  /* Z_STREAM_END      1  */
   0: "",
+  /* Z_OK              0  */
   "-1": "file error",
+  /* Z_ERRNO         (-1) */
   "-2": "stream error",
+  /* Z_STREAM_ERROR  (-2) */
   "-3": "data error",
+  /* Z_DATA_ERROR    (-3) */
   "-4": "insufficient memory",
+  /* Z_MEM_ERROR     (-4) */
   "-5": "buffer error",
+  /* Z_BUF_ERROR     (-5) */
   "-6": "incompatible version"
+  /* Z_VERSION_ERROR (-6) */
 };
 var constants$2 = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
   Z_NO_FLUSH: 0,
   Z_PARTIAL_FLUSH: 1,
   Z_SYNC_FLUSH: 2,
@@ -657,6 +706,9 @@ var constants$2 = {
   Z_FINISH: 4,
   Z_BLOCK: 5,
   Z_TREES: 6,
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
   Z_OK: 0,
   Z_STREAM_END: 1,
   Z_NEED_DICT: 2,
@@ -665,6 +717,8 @@ var constants$2 = {
   Z_DATA_ERROR: -3,
   Z_MEM_ERROR: -4,
   Z_BUF_ERROR: -5,
+  //Z_VERSION_ERROR: -6,
+  /* compression levels */
   Z_NO_COMPRESSION: 0,
   Z_BEST_SPEED: 1,
   Z_BEST_COMPRESSION: 9,
@@ -674,10 +728,14 @@ var constants$2 = {
   Z_RLE: 3,
   Z_FIXED: 4,
   Z_DEFAULT_STRATEGY: 0,
+  /* Possible values of the data_type field (though see inflate()) */
   Z_BINARY: 0,
   Z_TEXT: 1,
+  //Z_ASCII:                1, // = Z_TEXT (deprecated)
   Z_UNKNOWN: 2,
+  /* The deflate compression method */
   Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
 };
 const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;
 const {
@@ -1195,16 +1253,27 @@ function Config(good_length, max_lazy, nice_length, max_chain, func) {
   this.func = func;
 }
 const configuration_table = [
+  /*      good lazy nice chain */
   new Config(0, 0, 0, 0, deflate_stored),
+  /* 0 store only */
   new Config(4, 4, 8, 4, deflate_fast),
+  /* 1 max speed, no lazy matches */
   new Config(4, 5, 16, 8, deflate_fast),
+  /* 2 */
   new Config(4, 6, 32, 32, deflate_fast),
+  /* 3 */
   new Config(4, 4, 16, 16, deflate_slow),
+  /* 4 lazy matches */
   new Config(8, 16, 32, 32, deflate_slow),
+  /* 5 */
   new Config(8, 16, 128, 128, deflate_slow),
+  /* 6 */
   new Config(8, 32, 128, 256, deflate_slow),
+  /* 7 */
   new Config(32, 128, 258, 1024, deflate_slow),
+  /* 8 */
   new Config(32, 258, 258, 4096, deflate_slow)
+  /* 9 max compression */
 ];
 const lm_init = (s) => {
   s.window_size = 2 * s.w_size;
@@ -2247,6 +2316,7 @@ const CODES$1 = 0;
 const LENS$1 = 1;
 const DISTS$1 = 2;
 const lbase = new Uint16Array([
+  /* Length codes 257..285 base */
   3,
   4,
   5,
@@ -2280,6 +2350,7 @@ const lbase = new Uint16Array([
   0
 ]);
 const lext = new Uint8Array([
+  /* Length codes 257..285 extra */
   16,
   16,
   16,
@@ -2313,6 +2384,7 @@ const lext = new Uint8Array([
   78
 ]);
 const dbase = new Uint16Array([
+  /* Distance codes 0..29 base */
   1,
   2,
   3,
@@ -2347,6 +2419,7 @@ const dbase = new Uint16Array([
   0
 ]);
 const dext = new Uint8Array([
+  /* Distance codes 0..29 extra */
   16,
   16,
   16,
@@ -2799,7 +2872,10 @@ const inflate$2 = (strm, flush) => {
   const hbuf = new Uint8Array(4);
   let opts;
   let n;
-  const order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  const order = (
+    /* permutation of code lengths */
+    new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+  );
   if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
     return Z_STREAM_ERROR$1;
   }
@@ -2848,7 +2924,8 @@ const inflate$2 = (strm, flush) => {
           if (state.head) {
             state.head.done = false;
           }
-          if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
+          if (!(state.wrap & 1) || /* check if zlib header allowed */
+          (((hold & 255) << 8) + (hold >> 8)) % 31) {
             strm.msg = "incorrect header check";
             state.mode = BAD;
             break;
@@ -2988,8 +3065,11 @@ const inflate$2 = (strm, flush) => {
                 state.head.extra.set(
                   input.subarray(
                     next,
+                    // extra field is limited to 65536 bytes
+                    // - no need for additional size check
                     next + copy
                   ),
+                  /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                   len
                 );
               }
@@ -3604,7 +3684,8 @@ const inflate$2 = (strm, flush) => {
             strm.total_out += _out;
             state.total += _out;
             if (_out) {
-              strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
+              strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/
+              state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
             }
             _out = left;
             if ((state.flags ? hold : zswap32(hold)) !== state.check) {
@@ -3664,7 +3745,8 @@ const inflate$2 = (strm, flush) => {
   strm.total_out += _out;
   state.total += _out;
   if (state.wrap && _out) {
-    strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
+    strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+    state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
   }
   strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
   if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) {

package/dist/{raw.739ce163.mjs → raw-05d82ade.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.9aaafdeb.mjs";
+import { B as BaseDecoder } from "./index-d34ff949.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage.4e868fb9.mjs → webimage-1ceac06a.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.9aaafdeb.mjs";
+import { B as BaseDecoder } from "./index-d34ff949.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/BitmaskLayer.d.ts

@@ -0,0 +1,74 @@
+declare const BitmaskLayer_base: new (...props: import(".pnpm/@vivjs+types@0.13.7/node_modules/@vivjs/types").Viv<{
+    contrastLimits: number[][];
+    channelsVisible: boolean[];
+    dtype: string;
+    domain?: number[] | undefined;
+    id?: string | undefined;
+    onHover?: Function | undefined;
+    onClick?: Function | undefined;
+    modelMatrix?: Object | undefined;
+    interpolation?: number | undefined;
+}, string[]>[]) => any;
+/**
+ * A BitmapLayer that performs aggregation in the fragment shader,
+ * and renders its texture from a Uint8Array rather than an ImageData.
+ */
+declare class BitmaskLayer extends BitmaskLayer_base {
+    [x: string]: any;
+    getShaders(): {
+        fs: string;
+        vs: string;
+        modules: any[];
+        defines: {
+            COLORMAP_FUNC: any;
+        };
+    };
+    updateState({ props, oldProps, changeFlags }: {
+        props: any;
+        oldProps: any;
+        changeFlags: any;
+    }): void;
+    setColorTexture(): void;
+    draw(opts: any): void;
+    /**
+     * This function creates textures from the data
+     */
+    dataToTexture(data: any, width: any, height: any): any;
+}
+declare namespace BitmaskLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default BitmaskLayer;
+declare namespace defaultProps {
+    namespace hoveredCell {
+        const type: string;
+        const value: null;
+        const compare: boolean;
+    }
+    namespace cellColorData {
+        const type_1: string;
+        export { type_1 as type };
+        const value_1: null;
+        export { value_1 as value };
+        const compare_1: number;
+        export { compare_1 as compare };
+    }
+    namespace colormap {
+        const type_2: string;
+        export { type_2 as type };
+        export { GLSL_COLORMAP_DEFAULT as value };
+        const compare_2: boolean;
+        export { compare_2 as compare };
+    }
+    namespace expressionData {
+        const type_3: string;
+        export { type_3 as type };
+        const value_2: null;
+        export { value_2 as value };
+        const compare_3: number;
+        export { compare_3 as compare };
+    }
+}
+import { GLSL_COLORMAP_DEFAULT } from "./constants.js";
+//# sourceMappingURL=BitmaskLayer.d.ts.map

package/dist-tsc/BitmaskLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitmaskLayer.d.ts","sourceRoot":"","sources":["../src/BitmaskLayer.js"],"names":[],"mappings":";;;;;;;;;;;AAgCA;;;GAGG;AACH;;IAEE;;;;;;;MAYC;IAED;;;;aA4BC;IAED,wBA0BC;IAED,sBAmCC;IAED;;OAEG;IACH,uDAqBC;CACF"}