@vitessce/all 2.0.2 → 2.0.3

package/dist/lzw.39876143.mjs

@@ -0,0 +1,128 @@
+import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import "react";
+import "@vitessce/vit-s";
+import "react-dom";
+const MIN_BITS = 9;
+const CLEAR_CODE = 256;
+const EOI_CODE = 257;
+const MAX_BYTELENGTH = 12;
+function getByte(array, position, length) {
+  const d = position % 8;
+  const a = Math.floor(position / 8);
+  const de = 8 - d;
+  const ef = position + length - (a + 1) * 8;
+  let fg = 8 * (a + 2) - (position + length);
+  const dg = (a + 2) * 8 - position;
+  fg = Math.max(0, fg);
+  if (a >= array.length) {
+    console.warn("ran off the end of the buffer before finding EOI_CODE (end on input code)");
+    return EOI_CODE;
+  }
+  let chunk1 = array[a] & 2 ** (8 - d) - 1;
+  chunk1 <<= length - de;
+  let chunks = chunk1;
+  if (a + 1 < array.length) {
+    let chunk2 = array[a + 1] >>> fg;
+    chunk2 <<= Math.max(0, length - dg);
+    chunks += chunk2;
+  }
+  if (ef > 8 && a + 2 < array.length) {
+    const hi = (a + 3) * 8 - (position + length);
+    const chunk3 = array[a + 2] >>> hi;
+    chunks += chunk3;
+  }
+  return chunks;
+}
+function appendReversed(dest, source) {
+  for (let i = source.length - 1; i >= 0; i--) {
+    dest.push(source[i]);
+  }
+  return dest;
+}
+function decompress(input) {
+  const dictionaryIndex = new Uint16Array(4093);
+  const dictionaryChar = new Uint8Array(4093);
+  for (let i = 0; i <= 257; i++) {
+    dictionaryIndex[i] = 4096;
+    dictionaryChar[i] = i;
+  }
+  let dictionaryLength = 258;
+  let byteLength = MIN_BITS;
+  let position = 0;
+  function initDictionary() {
+    dictionaryLength = 258;
+    byteLength = MIN_BITS;
+  }
+  function getNext(array2) {
+    const byte = getByte(array2, position, byteLength);
+    position += byteLength;
+    return byte;
+  }
+  function addToDictionary(i, c) {
+    dictionaryChar[dictionaryLength] = c;
+    dictionaryIndex[dictionaryLength] = i;
+    dictionaryLength++;
+    return dictionaryLength - 1;
+  }
+  function getDictionaryReversed(n) {
+    const rev = [];
+    for (let i = n; i !== 4096; i = dictionaryIndex[i]) {
+      rev.push(dictionaryChar[i]);
+    }
+    return rev;
+  }
+  const result = [];
+  initDictionary();
+  const array = new Uint8Array(input);
+  let code = getNext(array);
+  let oldCode;
+  while (code !== EOI_CODE) {
+    if (code === CLEAR_CODE) {
+      initDictionary();
+      code = getNext(array);
+      while (code === CLEAR_CODE) {
+        code = getNext(array);
+      }
+      if (code === EOI_CODE) {
+        break;
+      } else if (code > CLEAR_CODE) {
+        throw new Error(`corrupted code at scanline ${code}`);
+      } else {
+        const val = getDictionaryReversed(code);
+        appendReversed(result, val);
+        oldCode = code;
+      }
+    } else if (code < dictionaryLength) {
+      const val = getDictionaryReversed(code);
+      appendReversed(result, val);
+      addToDictionary(oldCode, val[val.length - 1]);
+      oldCode = code;
+    } else {
+      const oldVal = getDictionaryReversed(oldCode);
+      if (!oldVal) {
+        throw new Error(`Bogus entry. Not in dictionary, ${oldCode} / ${dictionaryLength}, position: ${position}`);
+      }
+      appendReversed(result, oldVal);
+      result.push(oldVal[oldVal.length - 1]);
+      addToDictionary(oldCode, oldVal[oldVal.length - 1]);
+      oldCode = code;
+    }
+    if (dictionaryLength + 1 >= 2 ** byteLength) {
+      if (byteLength === MAX_BYTELENGTH) {
+        oldCode = void 0;
+      } else {
+        byteLength++;
+      }
+    }
+    code = getNext(array);
+  }
+  return new Uint8Array(result);
+}
+class LZWDecoder extends BaseDecoder {
+  decodeBlock(buffer) {
+    return decompress(buffer).buffer;
+  }
+}
+export {
+  LZWDecoder as default
+};

package/dist/packbits.9e95d117.mjs

@@ -0,0 +1,30 @@
+import { B as BaseDecoder } from "./index.7dac8670.mjs";
+import "react";
+import "@vitessce/vit-s";
+import "react-dom";
+class PackbitsDecoder extends BaseDecoder {
+  decodeBlock(buffer) {
+    const dataView = new DataView(buffer);
+    const out = [];
+    for (let i = 0; i < buffer.byteLength; ++i) {
+      let header = dataView.getInt8(i);
+      if (header < 0) {
+        const next = dataView.getUint8(i + 1);
+        header = -header;
+        for (let j = 0; j <= header; ++j) {
+          out.push(next);
+        }
+        i += 1;
+      } else {
+        for (let j = 0; j <= header; ++j) {
+          out.push(dataView.getUint8(i + j + 1));
+        }
+        i += header + 1;
+      }
+    }
+    return new Uint8Array(out).buffer;
+  }
+}
+export {
+  PackbitsDecoder as default
+};