@cogitator-ai/wasm-tools 0.5.10 → 0.6.0

package/dist/temp/compression.js

@@ -1,738 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugins/compression.ts
-var compression_exports = {};
-__export(compression_exports, {
-  compression: () => compression
-});
-module.exports = __toCommonJS(compression_exports);
-var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function base64Encode(bytes) {
-  let result = "";
-  const len = bytes.length;
-  for (let i = 0; i < len; i += 3) {
-    const b1 = bytes[i];
-    const b2 = i + 1 < len ? bytes[i + 1] : 0;
-    const b3 = i + 2 < len ? bytes[i + 2] : 0;
-    result += BASE64_CHARS[b1 >> 2];
-    result += BASE64_CHARS[(b1 & 3) << 4 | b2 >> 4];
-    result += i + 1 < len ? BASE64_CHARS[(b2 & 15) << 2 | b3 >> 6] : "=";
-    result += i + 2 < len ? BASE64_CHARS[b3 & 63] : "=";
-  }
-  return result;
-}
-function base64Decode(str) {
-  const cleanStr = str.replace(/[^A-Za-z0-9+/]/g, "");
-  const len = cleanStr.length;
-  const outputLen = Math.floor(len * 3 / 4) - (str.endsWith("==") ? 2 : str.endsWith("=") ? 1 : 0);
-  const bytes = new Uint8Array(outputLen);
-  const lookup = {};
-  for (let i = 0; i < BASE64_CHARS.length; i++) {
-    lookup[BASE64_CHARS[i]] = i;
-  }
-  let byteIdx = 0;
-  for (let i = 0; i < len; i += 4) {
-    const b1 = lookup[cleanStr[i]] ?? 0;
-    const b2 = lookup[cleanStr[i + 1]] ?? 0;
-    const b3 = lookup[cleanStr[i + 2]] ?? 0;
-    const b4 = lookup[cleanStr[i + 3]] ?? 0;
-    bytes[byteIdx++] = b1 << 2 | b2 >> 4;
-    if (byteIdx < outputLen) bytes[byteIdx++] = (b2 & 15) << 4 | b3 >> 2;
-    if (byteIdx < outputLen) bytes[byteIdx++] = (b3 & 3) << 6 | b4;
-  }
-  return bytes;
-}
-function utf8Encode(str) {
-  const bytes = [];
-  for (let i = 0; i < str.length; i++) {
-    let c = str.charCodeAt(i);
-    if (c < 128) {
-      bytes.push(c);
-    } else if (c < 2048) {
-      bytes.push(192 | c >> 6);
-      bytes.push(128 | c & 63);
-    } else if (c >= 55296 && c < 56320 && i + 1 < str.length) {
-      const c2 = str.charCodeAt(++i);
-      c = 65536 + ((c & 1023) << 10) + (c2 & 1023);
-      bytes.push(240 | c >> 18);
-      bytes.push(128 | c >> 12 & 63);
-      bytes.push(128 | c >> 6 & 63);
-      bytes.push(128 | c & 63);
-    } else {
-      bytes.push(224 | c >> 12);
-      bytes.push(128 | c >> 6 & 63);
-      bytes.push(128 | c & 63);
-    }
-  }
-  return new Uint8Array(bytes);
-}
-function utf8Decode(bytes) {
-  let result = "";
-  let i = 0;
-  while (i < bytes.length) {
-    const b = bytes[i++];
-    if (b < 128) {
-      result += String.fromCharCode(b);
-    } else if (b < 224) {
-      result += String.fromCharCode((b & 31) << 6 | bytes[i++] & 63);
-    } else if (b < 240) {
-      result += String.fromCharCode(
-        (b & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63
-      );
-    } else {
-      const cp = (b & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
-      result += String.fromCodePoint(cp);
-    }
-  }
-  return result;
-}
-function deflateRaw(data, level = 6) {
-  const output = [];
-  const len = data.length;
-  if (level === 0 || len < 10) {
-    let pos2 = 0;
-    while (pos2 < len) {
-      const blockLen = Math.min(65535, len - pos2);
-      const isLast = pos2 + blockLen >= len;
-      output.push(isLast ? 1 : 0);
-      output.push(blockLen & 255);
-      output.push(blockLen >> 8 & 255);
-      output.push(~blockLen & 255);
-      output.push(~blockLen >> 8 & 255);
-      for (let i = 0; i < blockLen; i++) {
-        output.push(data[pos2 + i]);
-      }
-      pos2 += blockLen;
-    }
-    return new Uint8Array(output);
-  }
-  const windowSize = 32768;
-  const hashTable = /* @__PURE__ */ new Map();
-  const getHash = (pos2) => {
-    if (pos2 + 2 >= len) return 0;
-    return (data[pos2] << 16 | data[pos2 + 1] << 8 | data[pos2 + 2]) >>> 0;
-  };
-  const findMatch = (pos2) => {
-    if (pos2 + 2 >= len) return null;
-    const hash = getHash(pos2);
-    const candidates = hashTable.get(hash) || [];
-    let bestDist = 0;
-    let bestLen = 0;
-    for (let i = candidates.length - 1; i >= 0 && i >= candidates.length - 16; i--) {
-      const candPos = candidates[i];
-      const dist = pos2 - candPos;
-      if (dist > windowSize || dist <= 0) continue;
-      let matchLen = 0;
-      while (matchLen < 258 && pos2 + matchLen < len && data[candPos + matchLen] === data[pos2 + matchLen]) {
-        matchLen++;
-      }
-      if (matchLen >= 3 && matchLen > bestLen) {
-        bestDist = dist;
-        bestLen = matchLen;
-      }
-    }
-    if (bestLen >= 3) {
-      return { distance: bestDist, length: bestLen };
-    }
-    return null;
-  };
-  const LITLEN_BASE = [
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    9,
-    10,
-    11,
-    13,
-    15,
-    17,
-    19,
-    23,
-    27,
-    31,
-    35,
-    43,
-    51,
-    59,
-    67,
-    83,
-    99,
-    115,
-    131,
-    163,
-    195,
-    227,
-    258
-  ];
-  const LITLEN_EXTRA = [
-    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 DIST_BASE = [
-    1,
-    2,
-    3,
-    4,
-    5,
-    7,
-    9,
-    13,
-    17,
-    25,
-    33,
-    49,
-    65,
-    97,
-    129,
-    193,
-    257,
-    385,
-    513,
-    769,
-    1025,
-    1537,
-    2049,
-    3073,
-    4097,
-    6145,
-    8193,
-    12289,
-    16385,
-    24577
-  ];
-  const DIST_EXTRA = [
-    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 tokens = [];
-  let pos = 0;
-  while (pos < len) {
-    const match = level > 3 ? findMatch(pos) : null;
-    const hash = getHash(pos);
-    if (!hashTable.has(hash)) {
-      hashTable.set(hash, []);
-    }
-    hashTable.get(hash).push(pos);
-    if (hashTable.get(hash).length > 64) {
-      hashTable.get(hash).shift();
-    }
-    if (match && match.length >= 3) {
-      tokens.push({ type: "match", length: match.length, distance: match.distance });
-      for (let i = 1; i < match.length; i++) {
-        const h = getHash(pos + i);
-        if (!hashTable.has(h)) hashTable.set(h, []);
-        hashTable.get(h).push(pos + i);
-      }
-      pos += match.length;
-    } else {
-      tokens.push({ type: "literal", value: data[pos] });
-      pos++;
-    }
-  }
-  let bitBuf = 0;
-  let bitCount = 0;
-  const writeBits = (value, bits) => {
-    bitBuf |= value << bitCount;
-    bitCount += bits;
-    while (bitCount >= 8) {
-      output.push(bitBuf & 255);
-      bitBuf >>= 8;
-      bitCount -= 8;
-    }
-  };
-  const writeFixedLitLen = (code) => {
-    if (code <= 143) {
-      writeBits(reverseBits(48 + code, 8), 8);
-    } else if (code <= 255) {
-      writeBits(reverseBits(400 + code - 144, 9), 9);
-    } else if (code === 256) {
-      writeBits(reverseBits(0, 7), 7);
-    } else if (code <= 279) {
-      writeBits(reverseBits(code - 256, 7), 7);
-    } else {
-      writeBits(reverseBits(192 + code - 280, 8), 8);
-    }
-  };
-  const findLengthCode = (length) => {
-    for (let i = LITLEN_BASE.length - 1; i >= 0; i--) {
-      if (length >= LITLEN_BASE[i]) return i;
-    }
-    return 0;
-  };
-  const findDistCode = (dist) => {
-    for (let i = DIST_BASE.length - 1; i >= 0; i--) {
-      if (dist >= DIST_BASE[i]) return i;
-    }
-    return 0;
-  };
-  writeBits(1, 1);
-  writeBits(1, 2);
-  for (const token of tokens) {
-    if (token.type === "literal") {
-      writeFixedLitLen(token.value);
-    } else {
-      const lenIdx = findLengthCode(token.length);
-      const lenCode = 257 + lenIdx;
-      writeFixedLitLen(lenCode);
-      if (LITLEN_EXTRA[lenIdx] > 0) {
-        writeBits(token.length - LITLEN_BASE[lenIdx], LITLEN_EXTRA[lenIdx]);
-      }
-      const distIdx = findDistCode(token.distance);
-      writeBits(reverseBits(distIdx, 5), 5);
-      if (DIST_EXTRA[distIdx] > 0) {
-        writeBits(token.distance - DIST_BASE[distIdx], DIST_EXTRA[distIdx]);
-      }
-    }
-  }
-  writeFixedLitLen(256);
-  if (bitCount > 0) {
-    output.push(bitBuf & 255);
-  }
-  return new Uint8Array(output);
-}
-function reverseBits(value, bits) {
-  let result = 0;
-  for (let i = 0; i < bits; i++) {
-    result = result << 1 | value >> i & 1;
-  }
-  return result;
-}
-function inflateRaw(data) {
-  const output = [];
-  let pos = 0;
-  let bitBuf = 0;
-  let bitCount = 0;
-  const readBits = (n) => {
-    while (bitCount < n) {
-      if (pos >= data.length) throw new Error("Unexpected end of data");
-      bitBuf |= data[pos++] << bitCount;
-      bitCount += 8;
-    }
-    const result = bitBuf & (1 << n) - 1;
-    bitBuf >>= n;
-    bitCount -= n;
-    return result;
-  };
-  const LITLEN_BASE = [
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    9,
-    10,
-    11,
-    13,
-    15,
-    17,
-    19,
-    23,
-    27,
-    31,
-    35,
-    43,
-    51,
-    59,
-    67,
-    83,
-    99,
-    115,
-    131,
-    163,
-    195,
-    227,
-    258
-  ];
-  const LITLEN_EXTRA = [
-    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 DIST_BASE = [
-    1,
-    2,
-    3,
-    4,
-    5,
-    7,
-    9,
-    13,
-    17,
-    25,
-    33,
-    49,
-    65,
-    97,
-    129,
-    193,
-    257,
-    385,
-    513,
-    769,
-    1025,
-    1537,
-    2049,
-    3073,
-    4097,
-    6145,
-    8193,
-    12289,
-    16385,
-    24577
-  ];
-  const DIST_EXTRA = [
-    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
-  ];
-  let bfinal = 0;
-  while (!bfinal) {
-    bfinal = readBits(1);
-    const btype = readBits(2);
-    if (btype === 0) {
-      bitBuf = 0;
-      bitCount = 0;
-      const len = data[pos] | data[pos + 1] << 8;
-      pos += 4;
-      for (let i = 0; i < len; i++) {
-        output.push(data[pos++]);
-      }
-    } else if (btype === 1 || btype === 2) {
-      let litlenCodes;
-      let distCodes;
-      if (btype === 1) {
-        litlenCodes = [];
-        for (let i = 0; i <= 143; i++) litlenCodes[i] = 8;
-        for (let i = 144; i <= 255; i++) litlenCodes[i] = 9;
-        for (let i = 256; i <= 279; i++) litlenCodes[i] = 7;
-        for (let i = 280; i <= 287; i++) litlenCodes[i] = 8;
-        distCodes = new Array(32).fill(5);
-      } else {
-        const hlit = readBits(5) + 257;
-        const hdist = readBits(5) + 1;
-        const hclen = readBits(4) + 4;
-        const clenOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
-        const clenLens = new Array(19).fill(0);
-        for (let i = 0; i < hclen; i++) {
-          clenLens[clenOrder[i]] = readBits(3);
-        }
-        const clenTree = buildHuffmanTree(clenLens);
-        const allLens = [];
-        while (allLens.length < hlit + hdist) {
-          const sym = decodeSymbol(clenTree, readBits.bind(null, 1));
-          if (sym < 16) {
-            allLens.push(sym);
-          } else if (sym === 16) {
-            const repeat = readBits(2) + 3;
-            const last = allLens[allLens.length - 1] || 0;
-            for (let i = 0; i < repeat; i++) allLens.push(last);
-          } else if (sym === 17) {
-            const repeat = readBits(3) + 3;
-            for (let i = 0; i < repeat; i++) allLens.push(0);
-          } else if (sym === 18) {
-            const repeat = readBits(7) + 11;
-            for (let i = 0; i < repeat; i++) allLens.push(0);
-          }
-        }
-        litlenCodes = allLens.slice(0, hlit);
-        distCodes = allLens.slice(hlit);
-      }
-      const litlenTree = buildHuffmanTree(litlenCodes);
-      const distTree = buildHuffmanTree(distCodes);
-      while (true) {
-        const sym = decodeSymbol(litlenTree, () => readBits(1));
-        if (sym < 256) {
-          output.push(sym);
-        } else if (sym === 256) {
-          break;
-        } else {
-          const lenIdx = sym - 257;
-          const length = LITLEN_BASE[lenIdx] + readBits(LITLEN_EXTRA[lenIdx]);
-          const distSym = decodeSymbol(distTree, () => readBits(1));
-          const distance = DIST_BASE[distSym] + readBits(DIST_EXTRA[distSym]);
-          const start = output.length - distance;
-          for (let i = 0; i < length; i++) {
-            output.push(output[start + i]);
-          }
-        }
-      }
-    } else {
-      throw new Error("Invalid block type");
-    }
-  }
-  return new Uint8Array(output);
-}
-function buildHuffmanTree(codeLens) {
-  const maxLen = Math.max(...codeLens, 1);
-  const blCount = new Array(maxLen + 1).fill(0);
-  for (const len of codeLens) {
-    if (len > 0) blCount[len]++;
-  }
-  const nextCode = new Array(maxLen + 1).fill(0);
-  let code = 0;
-  for (let bits = 1; bits <= maxLen; bits++) {
-    code = code + blCount[bits - 1] << 1;
-    nextCode[bits] = code;
-  }
-  const root = {};
-  for (let sym = 0; sym < codeLens.length; sym++) {
-    const len = codeLens[sym];
-    if (len === 0) continue;
-    const codeVal = nextCode[len]++;
-    let node = root;
-    for (let i = len - 1; i >= 0; i--) {
-      const bit = codeVal >> i & 1;
-      if (bit === 0) {
-        if (!node.left) node.left = {};
-        node = node.left;
-      } else {
-        if (!node.right) node.right = {};
-        node = node.right;
-      }
-    }
-    node.symbol = sym;
-  }
-  return root;
-}
-function decodeSymbol(tree, readBit) {
-  let node = tree;
-  while (node.symbol === void 0) {
-    const bit = readBit();
-    node = bit === 0 ? node.left : node.right;
-    if (!node) throw new Error("Invalid huffman code");
-  }
-  return node.symbol;
-}
-function crc32(data) {
-  let crc = 4294967295;
-  for (const byte of data) {
-    crc ^= byte;
-    for (let j = 0; j < 8; j++) {
-      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
-    }
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
-function gzipCompress(data, level) {
-  const deflated = deflateRaw(data, level);
-  const crc = crc32(data);
-  const output = new Uint8Array(10 + deflated.length + 8);
-  output[0] = 31;
-  output[1] = 139;
-  output[2] = 8;
-  output[3] = 0;
-  output[4] = output[5] = output[6] = output[7] = 0;
-  output[8] = level >= 9 ? 2 : level <= 1 ? 4 : 0;
-  output[9] = 255;
-  output.set(deflated, 10);
-  const pos = 10 + deflated.length;
-  output[pos] = crc & 255;
-  output[pos + 1] = crc >> 8 & 255;
-  output[pos + 2] = crc >> 16 & 255;
-  output[pos + 3] = crc >> 24 & 255;
-  output[pos + 4] = data.length & 255;
-  output[pos + 5] = data.length >> 8 & 255;
-  output[pos + 6] = data.length >> 16 & 255;
-  output[pos + 7] = data.length >> 24 & 255;
-  return output;
-}
-function gzipDecompress(data) {
-  if (data[0] !== 31 || data[1] !== 139) {
-    throw new Error("Invalid gzip header");
-  }
-  if (data[2] !== 8) {
-    throw new Error("Unsupported compression method");
-  }
-  const flags = data[3];
-  let pos = 10;
-  if (flags & 4) {
-    const xlen = data[pos] | data[pos + 1] << 8;
-    pos += 2 + xlen;
-  }
-  if (flags & 8) {
-    while (data[pos++] !== 0) ;
-  }
-  if (flags & 16) {
-    while (data[pos++] !== 0) ;
-  }
-  if (flags & 2) {
-    pos += 2;
-  }
-  const deflatedData = data.slice(pos, data.length - 8);
-  return inflateRaw(deflatedData);
-}
-function compression() {
-  try {
-    const inputStr = Host.inputString();
-    const input = JSON.parse(inputStr);
-    const inputEncoding = input.inputEncoding ?? "utf8";
-    const outputEncoding = input.outputEncoding ?? "base64";
-    const level = input.level ?? 6;
-    let inputBytes;
-    if (inputEncoding === "base64") {
-      inputBytes = base64Decode(input.data);
-    } else {
-      inputBytes = utf8Encode(input.data);
-    }
-    let resultBytes;
-    if (input.operation === "compress") {
-      resultBytes = gzipCompress(inputBytes, level);
-    } else {
-      resultBytes = gzipDecompress(inputBytes);
-    }
-    let result;
-    if (outputEncoding === "base64") {
-      result = base64Encode(resultBytes);
-    } else {
-      result = utf8Decode(resultBytes);
-    }
-    const denominator = input.operation === "compress" ? inputBytes.length : resultBytes.length;
-    const ratio = denominator > 0 ? (input.operation === "compress" ? resultBytes.length : inputBytes.length) / denominator : 0;
-    const output = {
-      result,
-      originalSize: inputBytes.length,
-      resultSize: resultBytes.length,
-      ratio: Math.round(ratio * 100) / 100
-    };
-    Host.outputString(JSON.stringify(output));
-    return 0;
-  } catch (error) {
-    const output = {
-      result: "",
-      originalSize: 0,
-      resultSize: 0,
-      error: error instanceof Error ? error.message : String(error)
-    };
-    Host.outputString(JSON.stringify(output));
-    return 1;
-  }
-}