@vitessce/all 2.0.3 → 3.0.1

package/dist/index.js

@@ -0,0 +1,12 @@
+import { f, P, h, d, V, z } from "./index-f48f3f08.js";
+import "react";
+import "@vitessce/vit-s";
+import "react-dom";
+export {
+  f as PluginCoordinationType,
+  P as PluginFileType,
+  h as PluginJointFileType,
+  d as PluginViewType,
+  V as Vitessce,
+  z
+};

package/dist/{jpeg.c8011e3a.mjs → jpeg-7f0b1b2c.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import { B as BaseDecoder } from "./index-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";

package/dist/{lerc.ccda5eb2.mjs → lerc-f7557585.js}

@@ -1,5 +1,5 @@
-import { i as inflate_1 } from "./pako.esm.4b234125.mjs";
-import { B as BaseDecoder, L as LercParameters, a as LercAddCompression } from "./index.7dac8670.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-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";
@@ -364,6 +364,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;
@@ -574,6 +576,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;
@@ -1384,6 +1387,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,
@@ -1403,6 +1409,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
@@ -1690,14 +1697,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);
@@ -1775,6 +1816,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;
@@ -1816,6 +1858,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.";
@@ -1847,14 +1908,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;
@@ -1907,7 +1977,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.39876143.mjs → lzw-4d26ee71.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import { B as BaseDecoder } from "./index-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";

package/dist/{packbits.9e95d117.mjs → packbits-08efb7ce.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import { B as BaseDecoder } from "./index-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";

package/dist/{pako.esm.4b234125.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.0279d74b.mjs → raw-3c2d82ff.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import { B as BaseDecoder } from "./index-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";

package/dist/{webimage.5ac7ce95.mjs → webimage-a7dde8d2.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import { B as BaseDecoder } from "./index-f48f3f08.js";
 import "react";
 import "@vitessce/vit-s";
 import "react-dom";

package/dist-tsc/Vitessce.d.ts

@@ -0,0 +1,2 @@
+export declare function Vitessce(props: any): import("react/jsx-runtime.js").JSX.Element;
+//# sourceMappingURL=Vitessce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Vitessce.d.ts","sourceRoot":"","sources":["../src/Vitessce.tsx"],"names":[],"mappings":"AAgBA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,8CA8DlC"}

package/dist-tsc/Vitessce.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable max-len */
+import { useMemo } from 'react';
+import { VitS, logConfig, } from '@vitessce/vit-s';
+import { upgradeAndParse, } from '@vitessce/schemas';
+import { baseViewTypes, baseFileTypes, baseJointFileTypes, baseCoordinationTypes, } from './base-plugins.js';
+export function Vitessce(props) {
+    const { config, onConfigUpgrade, pluginViewTypes: pluginViewTypesProp, pluginFileTypes: pluginFileTypesProp, pluginCoordinationTypes: pluginCoordinationTypesProp, pluginJointFileTypes: pluginJointFileTypesProp, } = props;
+    // If config.uid exists, then use it for hook dependencies to detect changes
+    // (controlled component case). If not, then use the config object itself
+    // and assume the un-controlled component case.
+    const configKey = config?.uid || config;
+    const configVersion = config?.version;
+    const [configOrWarning, success] = useMemo(() => {
+        try {
+            logConfig(config, 'pre-upgrade view config');
+            const validConfig = upgradeAndParse(config, onConfigUpgrade);
+            return [validConfig, true];
+        }
+        catch (e) {
+            console.error(e);
+            return [
+                {
+                    title: 'Config validation or upgrade failed.',
+                    unformatted: e.message,
+                },
+                false,
+            ];
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [configKey, configVersion]);
+    const mergedPluginViewTypes = useMemo(() => ([
+        ...baseViewTypes, ...(pluginViewTypesProp || []),
+    ]), [pluginViewTypesProp]);
+    const mergedPluginFileTypes = useMemo(() => ([
+        ...baseFileTypes, ...(pluginFileTypesProp || []),
+    ]), [pluginFileTypesProp]);
+    const mergedPluginJointFileTypes = useMemo(() => ([
+        ...baseJointFileTypes, ...(pluginJointFileTypesProp || []),
+    ]), [pluginJointFileTypesProp]);
+    const mergedPluginCoordinationTypes = useMemo(() => ([
+        ...baseCoordinationTypes, ...(pluginCoordinationTypesProp || []),
+    ]), [pluginCoordinationTypesProp]);
+    return (_jsx(VitS, { ...props, config: configOrWarning, viewTypes: mergedPluginViewTypes, fileTypes: mergedPluginFileTypes, jointFileTypes: mergedPluginJointFileTypes, coordinationTypes: mergedPluginCoordinationTypes, warning: (success ? null : configOrWarning) }));
+}