node-pkware 2.0.0 → 3.0.0

package/src/helpers/stream.js

@@ -1,190 +0,0 @@
-const { Transform, Writable } = require('stream')
-const { promisify } = require('util')
-const ExpandingBuffer = require('./ExpandingBuffer.js')
-const { isFunction } = require('./functions.js')
-
-const emptyBuffer = Buffer.from([])
-
-class QuasiTransform {
-  constructor(handler) {
-    this.handler = handler
-  }
-
-  handle(chunk, encoding) {
-    return promisify(this.handler).call(this, chunk, encoding)
-  }
-}
-
-const splitAt = (index) => {
-  let cntr = 0
-
-  if (!Number.isInteger(index) || index < 0) {
-    return () => {
-      return null
-    }
-  }
-
-  return (chunk) => {
-    let left
-    let right
-    let isLeftDone = true
-
-    if (!Buffer.isBuffer(chunk)) {
-      return null
-    }
-
-    if (index <= cntr) {
-      // index ..... cntr ..... chunk.length
-      left = emptyBuffer
-      right = chunk
-    } else if (index >= cntr + chunk.length) {
-      // cntr ..... chunk.length ..... index
-      left = chunk
-      right = emptyBuffer
-      isLeftDone = index === cntr + chunk.length
-    } else {
-      // cntr ..... index ..... chunk.length
-      left = chunk.slice(0, index - cntr)
-      right = chunk.slice(index - cntr)
-    }
-
-    cntr += chunk.length
-
-    return [left, right, isLeftDone]
-  }
-}
-
-const transformIdentity = () => {
-  return function (chunk, encoding, callback) {
-    callback(null, chunk)
-  }
-}
-
-const transformEmpty = () => {
-  return function (chunk, encoding, callback) {
-    callback(null, emptyBuffer)
-  }
-}
-
-const through = (handler) => {
-  return new Transform({
-    transform: handler,
-  })
-}
-
-const transformSplitBy = (predicate, leftHandler, rightHandler) => {
-  let isFirstChunk = true
-  let wasLeftFlushCalled = false
-  const damChunkSize = 0x10000
-  const dam = new ExpandingBuffer()
-
-  const leftTransform = new QuasiTransform(leftHandler)
-  const rightTransform = new QuasiTransform(rightHandler)
-
-  return function (chunk, encoding, callback) {
-    const [left, right, isLeftDone] = predicate(chunk)
-
-    const _left = leftTransform.handle(left, encoding)
-    const _right = rightTransform.handle(right, encoding)
-
-    if (isFirstChunk) {
-      isFirstChunk = false
-      this._flush = (flushCallback) => {
-        if (!dam.isEmpty()) {
-          this.push(dam.read())
-        }
-
-        let leftFiller = Promise.resolve(emptyBuffer)
-        let rightFiller = Promise.resolve(emptyBuffer)
-
-        if (!wasLeftFlushCalled && isFunction(leftTransform._flush)) {
-          leftFiller = new Promise((resolve, reject) => {
-            leftTransform._flush((err, data) => {
-              if (err) {
-                reject(err)
-              } else {
-                resolve(data)
-              }
-            })
-          })
-        }
-
-        if (isFunction(rightTransform._flush)) {
-          rightFiller = new Promise((resolve, reject) => {
-            rightTransform._flush((err, data) => {
-              if (err) {
-                reject(err)
-              } else {
-                resolve(data)
-              }
-            })
-          })
-        }
-
-        Promise.all([leftFiller, rightFiller])
-          .then((buffers) => {
-            flushCallback(null, Buffer.concat(buffers))
-          })
-          .catch((err) => {
-            flushCallback(err)
-          })
-      }
-    }
-
-    let filler = Promise.resolve(emptyBuffer)
-    if (isLeftDone && !wasLeftFlushCalled && isFunction(leftTransform._flush)) {
-      wasLeftFlushCalled = true
-      filler = new Promise((resolve, reject) => {
-        leftTransform._flush((err, data) => {
-          if (err) {
-            reject(err)
-          } else {
-            resolve(data)
-          }
-        })
-      })
-    }
-
-    Promise.all([_left, filler, _right])
-      .then((buffers) => {
-        dam.append(Buffer.concat(buffers))
-        if (dam.size() > damChunkSize) {
-          const chunks = Math.floor(dam.size() / damChunkSize)
-          const data = Buffer.from(dam.read(0, chunks * damChunkSize))
-          dam.flushStart(chunks * damChunkSize)
-          for (let i = 0; i < chunks - 1; i++) {
-            this.push(data.slice(i * damChunkSize, i * damChunkSize + damChunkSize))
-          }
-          callback(null, data.slice((chunks - 1) * damChunkSize))
-        } else {
-          callback(null, emptyBuffer)
-        }
-      })
-      .catch((err) => {
-        callback(err)
-      })
-  }
-}
-
-const streamToBuffer = (done) => {
-  const buffer = new ExpandingBuffer()
-  return new Writable({
-    write(chunk, encoding, callback) {
-      buffer.append(chunk)
-      callback()
-    },
-    final(callback) {
-      done(buffer.getHeap())
-      callback()
-    },
-  })
-}
-
-module.exports = {
-  splitAt,
-  transformIdentity,
-  transformEmpty,
-  through,
-  transformSplitBy,
-  streamToBuffer,
-}

package/src/helpers/testing.js

@@ -1,80 +0,0 @@
-// const { EOL } = require('os')
-// const fs = require('fs')
-const assert = require('assert')
-const { compare, report } = require('binary-comparator')
-
-/*
-const isPromise = promise => {
-  return typeof promise === 'object' && promise.constructor.name === 'Promise'
-}
-
-const toConsole = () => {
-  return (chunk, encoding, callback) => {
-    process.stdout.write(chunk)
-    process.stdout.write(Buffer.from(EOL))
-    callback(null, chunk)
-  }
-}
-
-const readToBuffer = (fileName, chunkSizeInBytes = 1024) => {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    fs.createReadStream(fileName, { highWaterMark: chunkSizeInBytes })
-      .on('error', reject)
-      .on('data', chunk => {
-        chunks.push(chunk)
-      })
-      .on('end', function () {
-        resolve(Buffer.concat(chunks))
-      })
-  })
-}
-*/
-
-// source: https://stackoverflow.com/a/43197340/1806628
-const isClass = (obj) => {
-  const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class'
-  if (obj.prototype === undefined) {
-    return isCtorClass
-  }
-  const isPrototypeCtorClass =
-    obj.prototype.constructor &&
-    obj.prototype.constructor.toString &&
-    obj.prototype.constructor.toString().substring(0, 5) === 'class'
-  return isCtorClass || isPrototypeCtorClass
-}
-
-// https://stackoverflow.com/a/48845122/1806628
-const bufferToString = (buffer, limit = 20) => {
-  const ellipsisNecessary = buffer.length > limit
-  let hexString = buffer.slice(0, limit).toString('hex')
-  hexString = hexString.length > 2 ? hexString.match(/../g).join(' ') : hexString
-  return `<Buffer ${hexString}${ellipsisNecessary ? '...' : ''}>`
-}
-
-const buffersShouldEqual = (expected, result, offset = 0, displayAsHex = false) => {
-  if (!Buffer.isBuffer(expected)) {
-    throw new Error('expected is not a Buffer')
-  }
-
-  if (!Buffer.isBuffer(result)) {
-    throw new Error('result is not a Buffer')
-  }
-
-  const diff = report(expected, result, compare(expected, result, offset), displayAsHex)
-  assert.ok(expected.equals(result), diff)
-}
-
-const transformToABC = () => {
-  let cntr = 0
-  return function (chunk, encoding, callback) {
-    callback(null, Buffer.from([65 + (cntr++ % 26)]))
-  }
-}
-
-module.exports = {
-  isClass,
-  buffersShouldEqual,
-  bufferToString,
-  transformToABC,
-}

package/src/implode.js

@@ -1,364 +0,0 @@
-const { has, repeat, clone, last, clamp } = require('ramda')
-const ExpandingBuffer = require('./helpers/ExpandingBuffer.js')
-const { toHex, getLowestNBits, nBitsOfOnes, isFunction } = require('./helpers/functions.js')
-const { ExpectedFunctionError, InvalidDictionarySizeError, InvalidCompressionTypeError } = require('./errors.js')
-const {
-  ChBitsAsc,
-  ChCodeAsc,
-  LONGEST_ALLOWED_REPETITION,
-  DICTIONARY_SIZE_LARGE,
-  DICTIONARY_SIZE_MEDIUM,
-  DICTIONARY_SIZE_SMALL,
-  COMPRESSION_BINARY,
-  COMPRESSION_ASCII,
-  ExLenBits,
-  LenBits,
-  LenCode,
-  DistCode,
-  DistBits,
-} = require('./constants.js')
-
-const setup = (state) => {
-  state.nChBits = repeat(0, 0x306)
-  state.nChCodes = repeat(0, 0x306)
-
-  switch (state.dictionarySizeBits) {
-    case DICTIONARY_SIZE_LARGE:
-      state.dictionarySizeMask = nBitsOfOnes(6)
-      break
-    case DICTIONARY_SIZE_MEDIUM:
-      state.dictionarySizeMask = nBitsOfOnes(5)
-      break
-    case DICTIONARY_SIZE_SMALL:
-      state.dictionarySizeMask = nBitsOfOnes(4)
-      break
-    default:
-      throw new InvalidDictionarySizeError()
-  }
-
-  switch (state.compressionType) {
-    case COMPRESSION_BINARY:
-      for (let nChCode = 0, nCount = 0; nCount < 0x100; nCount++) {
-        state.nChBits[nCount] = 9
-        state.nChCodes[nCount] = nChCode
-        nChCode = getLowestNBits(16, nChCode) + 2
-      }
-      break
-    case COMPRESSION_ASCII:
-      for (let nCount = 0; nCount < 0x100; nCount++) {
-        state.nChBits[nCount] = ChBitsAsc[nCount] + 1
-        state.nChCodes[nCount] = ChCodeAsc[nCount] * 2
-      }
-      break
-    default:
-      throw new InvalidCompressionTypeError()
-  }
-
-  let nCount = 0x100
-  for (let i = 0; i < 0x10; i++) {
-    for (let nCount2 = 0; nCount2 < 1 << ExLenBits[i]; nCount2++) {
-      state.nChBits[nCount] = ExLenBits[i] + LenBits[i] + 1
-      state.nChCodes[nCount] = (nCount2 << (LenBits[i] + 1)) | (LenCode[i] * 2) | 1
-      nCount++
-    }
-  }
-
-  state.outputBuffer.append(Buffer.from([state.compressionType, state.dictionarySizeBits, 0]))
-  state.outBits = 0
-}
-
-const outputBits = (state, nBits, bitBuffer) => {
-  if (nBits > 8) {
-    outputBits(state, 8, bitBuffer)
-    bitBuffer = bitBuffer >> 8
-    nBits = nBits - 8
-  }
-
-  const outBits = state.outBits
-
-  // in the original code bitBuffer is long, but is cast to char
-  const lastBytes = state.outputBuffer.read(state.outputBuffer.size() - 1, 1)
-  state.outputBuffer.dropEnd(1)
-  state.outputBuffer.append(Buffer.from([lastBytes | getLowestNBits(8, bitBuffer << outBits)]))
-
-  state.outBits = state.outBits + nBits
-
-  if (state.outBits > 8) {
-    bitBuffer = bitBuffer >> (8 - outBits)
-    state.outputBuffer.append(Buffer.from([getLowestNBits(8, bitBuffer)]))
-    state.outBits = getLowestNBits(3, state.outBits)
-  } else {
-    state.outBits = getLowestNBits(3, state.outBits)
-    if (state.outBits === 0) {
-      state.outputBuffer.append(Buffer.from([0]))
-    }
-  }
-}
-
-// ---------------------------------
-
-const getSizeOfMatching = (inputBytes, a, b) => {
-  const limit = clamp(2, LONGEST_ALLOWED_REPETITION, b - a)
-
-  for (let i = 2; i <= limit; i++) {
-    if (inputBytes[a + i] !== inputBytes[b + i]) {
-      return i
-    }
-  }
-
-  return limit
-}
-
-// TODO: make sure that we find the most recent one, which in turn allows
-// us to store backward length in less amount of bits
-// currently the code goes from the furthest point
-const findRepetitions = (inputBytes, endOfLastMatch, cursor) => {
-  const notEnoughBytes = inputBytes.length - cursor < 2
-  const tooClose = cursor === endOfLastMatch || cursor - endOfLastMatch < 2
-  if (notEnoughBytes || tooClose) {
-    return { size: 0, distance: 0 }
-  }
-
-  const haystack = inputBytes.slice(endOfLastMatch, cursor)
-  const needle = inputBytes.slice(cursor, cursor + 2)
-
-  const matchIndex = haystack.indexOf(needle)
-  if (matchIndex !== -1) {
-    const distance = cursor - endOfLastMatch - matchIndex
-    return {
-      distance: distance - 1,
-      size: distance > 2 ? getSizeOfMatching(inputBytes, endOfLastMatch + matchIndex, cursor) : 2,
-    }
-  }
-
-  return { size: 0, distance: 0 }
-}
-
-// this function can return:
-//   false - not flushable
-//   true - flushable
-//   null - flushable, but there might be a better repetition
-const isRepetitionFlushable = (size, distance, startIndex, inputBufferSize) => {
-  if (size === 0) {
-    return false
-  }
-
-  // If we found repetition of 2 bytes, that is 0x100 or fuhrter back,
-  // don't bother. Storing the distance of 0x100 bytes would actually
-  // take more space than storing the 2 bytes as-is.
-  if (size === 2 && distance >= 0x100) {
-    return false
-  }
-
-  if (size >= 8 || startIndex + 1 >= inputBufferSize) {
-    return true
-  }
-
-  return null
-}
-
-// ---------------------------------
-
-// repetitions are at least 2 bytes long,
-// so the initial 2 bytes can be moved to the output as is
-const handleFirstTwoBytes = (state) => {
-  if (state.handledFirstTwoBytes) {
-    return
-  }
-
-  if (state.inputBuffer.size() < 3) {
-    return
-  }
-
-  const [byte1, byte2] = state.inputBuffer.read(0, 2)
-  outputBits(state, state.nChBits[byte1], state.nChCodes[byte1])
-  outputBits(state, state.nChBits[byte2], state.nChCodes[byte2])
-
-  state.handledFirstTwoBytes = true
-  state.startIndex += 2
-}
-
-const processChunkData = (state, verbose = false) => {
-  if (!has('dictionarySizeMask', state)) {
-    setup(state)
-  }
-
-  if (!state.inputBuffer.isEmpty()) {
-    state.startIndex = 0
-
-    handleFirstTwoBytes(state)
-
-    // -------------------------------
-
-    /* eslint-disable prefer-const */
-
-    let endOfLastMatch = 0 // used when searching for longer repetitions later
-    while (state.startIndex < state.inputBuffer.size()) {
-      let { size, distance } = findRepetitions(state.inputBuffer.read(endOfLastMatch), endOfLastMatch, state.startIndex)
-
-      let isFlushable = isRepetitionFlushable(size, distance, state.startIndex, state.inputBuffer.size())
-
-      if (isFlushable === false) {
-        const byte = state.inputBuffer.read(state.startIndex, 1)
-        outputBits(state, state.nChBits[byte], state.nChCodes[byte])
-        state.startIndex += 1
-      } else {
-        if (isFlushable === null) {
-          /*
-          // Try to find better repetition 1 byte later.
-          // stormlib/implode.c L517
-          let cursor = state.startIndex
-          let newSize = size
-          let newDistance = distance
-          let currentSize
-          let currentDistance
-          while (newSize <= currentSize && isRepetitionFlushable(newSize, newDistance, state.startIndex, state.inputBuffer.size())) {
-            currentSize = newSize
-            currentDistance = newDistance
-            const reps = findRepetitions(state.inputBuffer.read(endOfLastMatch), endOfLastMatch, ++cursor)
-            newSize = reps.size
-            newDistance = reps.distance
-          }
-          size = newSize
-          distance = currentDistance
-          */
-        }
-
-        const byte = size + 0xfe
-        outputBits(state, state.nChBits[byte], state.nChCodes[byte])
-        if (size === 2) {
-          const byte = distance >> 2
-          outputBits(state, state.distBits[byte], state.distCodes[byte])
-          outputBits(state, 2, distance & 3)
-        } else {
-          const byte = distance >> state.dictionarySizeBits
-          outputBits(state, state.distBits[byte], state.distCodes[byte])
-          outputBits(state, state.dictionarySizeBits, state.dictionarySizeMask & distance)
-        }
-
-        state.startIndex += size
-      }
-
-      /*
-      state.inputBuffer.dropStart(endOfLastMatch)
-      state.startIndex -= endOfLastMatch
-      endOfLastMatch = 0
-      */
-
-      if (state.dictionarySizeBits === DICTIONARY_SIZE_SMALL && state.startIndex >= 0x400) {
-        state.inputBuffer.dropStart(0x400)
-        state.startIndex -= 0x400
-      } else if (state.dictionarySizeBits === DICTIONARY_SIZE_MEDIUM && state.startIndex >= 0x800) {
-        state.inputBuffer.dropStart(0x800)
-        state.startIndex -= 0x800
-      } else if (state.dictionarySizeBits === DICTIONARY_SIZE_LARGE && state.startIndex >= 0x1000) {
-        state.inputBuffer.dropStart(0x1000)
-        state.startIndex -= 0x1000
-      }
-    }
-
-    /* eslint-enable prefer-const */
-
-    // -------------------------------
-
-    state.inputBuffer.dropStart(state.inputBuffer.size())
-  }
-
-  if (state.streamEnded) {
-    // Write the termination literal
-    outputBits(state, last(state.nChBits), last(state.nChCodes))
-  }
-}
-
-const implode = (compressionType, dictionarySizeBits, config = {}) => {
-  const { verbose = false, inputBufferSize = 0x0, outputBufferSize = 0x0 } = config
-
-  const handler = function (chunk, encoding, callback) {
-    if (!isFunction(callback)) {
-      // can't call callback to pass in data or errors, so we throw up
-      throw new ExpectedFunctionError()
-    }
-
-    const state = handler._state
-
-    try {
-      state.inputBuffer.append(chunk)
-      if (state.isFirstChunk) {
-        state.isFirstChunk = false
-        this._flush = state.onInputFinished
-      }
-
-      if (verbose) {
-        console.log(`implode: reading ${toHex(chunk.length)} bytes from chunk #${state.stats.chunkCounter++}`)
-      }
-
-      processChunkData(state, verbose)
-
-      const blockSize = 0x800
-      if (state.outputBuffer.size() > blockSize) {
-        const numberOfBytes = (Math.floor(state.outputBuffer.size() / blockSize) - 1) * blockSize
-        const output = Buffer.from(state.outputBuffer.read(0, numberOfBytes))
-        state.outputBuffer.flushStart(numberOfBytes)
-
-        if (state.outBits === 0) {
-          // set last byte to 0
-          state.outputBuffer.dropEnd(1)
-          state.outputBuffer.append(Buffer.from([0]))
-        }
-
-        callback(null, output)
-      } else {
-        callback(null, Buffer.from([]))
-      }
-    } catch (e) {
-      callback(e)
-    }
-  }
-
-  handler._state = {
-    isFirstChunk: true,
-    streamEnded: false,
-    compressionType,
-    dictionarySizeBits,
-    distCodes: clone(DistCode),
-    distBits: clone(DistBits),
-    startIndex: 0,
-    inputBuffer: new ExpandingBuffer(inputBufferSize),
-    outputBuffer: new ExpandingBuffer(outputBufferSize),
-    handledFirstTwoBytes: false,
-    onInputFinished: (callback) => {
-      const state = handler._state
-      state.streamEnded = true
-      try {
-        processChunkData(state, verbose)
-
-        if (verbose) {
-          console.log('---------------')
-          console.log('implode: total number of chunks read:', state.stats.chunkCounter)
-          console.log('implode: inputBuffer heap size', toHex(state.inputBuffer.heapSize()))
-          console.log('implode: outputBuffer heap size', toHex(state.outputBuffer.heapSize()))
-        }
-
-        callback(null, state.outputBuffer.read())
-      } catch (e) {
-        callback(e)
-      }
-    },
-    stats: {
-      chunkCounter: 0,
-    },
-  }
-
-  return handler
-}
-
-module.exports = {
-  setup,
-  outputBits,
-  getSizeOfMatching,
-  findRepetitions,
-  isRepetitionFlushable,
-  handleFirstTwoBytes,
-  processChunkData,
-  implode,
-}

package/src/index.js

@@ -1,18 +0,0 @@
-const { implode } = require('./implode.js')
-const { explode } = require('./explode.js')
-const constants = require('./constants.js')
-const errors = require('./errors.js')
-const stream = require('./helpers/stream.js')
-
-const compress = implode
-const decompress = explode
-
-module.exports = {
-  implode,
-  compress,
-  explode,
-  decompress,
-  constants,
-  errors,
-  stream,
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "noEmit": true,
-    "skipLibCheck": true,
-    "target": "esnext",
-    "moduleResolution": "node",
-    "allowJs": true,
-    "noImplicitAny": false,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "incremental": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules"]
-}

package/types/constants.d.ts

@@ -1,41 +0,0 @@
-export const COMPRESSION_BINARY: 0
-export const COMPRESSION_ASCII: 1
-export const DICTIONARY_SIZE_SMALL: 4
-export const DICTIONARY_SIZE_MEDIUM: 5
-export const DICTIONARY_SIZE_LARGE: 6
-export const LONGEST_ALLOWED_REPETITION: 0x204
-
-export const PKDCL_OK: 'OK'
-export const PKDCL_STREAM_END: 'All data from the input stream is read'
-export const PKDCL_NEED_DICT: 'Need more data (dictionary)'
-export const PKDCL_CONTINUE: 'Continue (internal flag)'
-export const PKDCL_GET_INPUT: 'Get input (internal flag)'
-
-export const LITERAL_END_STREAM: 0x305
-export const LITERAL_STREAM_ABORTED: 0x306
-
-export const DistCode: number[]
-export const DistBits: number[]
-export const LenBits: number[]
-export const LenCode: number[]
-export const ExLenBits: number[]
-export const LenBase: number[]
-export const ChBitsAsc: number[]
-export const ChCodeAsc: number[]
-
-// Additional types
-
-/**
- * Compression types for implode
- */
-export type CompressionType = typeof COMPRESSION_BINARY | typeof COMPRESSION_ASCII
-/**
- * Dictionary sizes for implode, determines how well the file get compressed.
- *
- * Small dictionary size means less memory to lookback in data for repetitions, meaning it will be less effective, the file stays larger, less compressed.
- * On the other hand, large compression allows more lookback allowing more effective compression, thus generating smaller, more compressed files.
- */
-export type DictionarySizeBits =
-  | typeof DICTIONARY_SIZE_SMALL
-  | typeof DICTIONARY_SIZE_MEDIUM
-  | typeof DICTIONARY_SIZE_LARGE