node-pkware 1.0.1 → 2.0.0

package/README.md

@@ -34,13 +34,13 @@ Calling either explode or implode with the `-v` or `--version` flag will display
 
 `implode test/files/fast.fts.unpacked --output=C:/fast.fts --binary --large --offset=1816`
 
-`explode test/files/fast.fts --auto-detect --debug --output=E:/fast.fts.unpacked`
+`explode test/files/fast.fts --auto-detect --verbose --output=E:/fast.fts.unpacked`
 
-`explode test/files/fast.fts --auto-detect --debug --output=E:/fast.fts.unpacked --offset=2000`
+`explode test/files/fast.fts --auto-detect --verbose --output=E:/fast.fts.unpacked --offset=2000`
 
 ### piping also works
 
-**Don't use --debug when piping, because debug messages will be outputted to where the decompressed data is being outputted!**
+**Don't use --verbose when piping, because verbose messages will be outputted to where the decompressed data is being outputted!**
 
 `cat c:/arx/level8.llf | explode > c:/arx/level8.llf.unpacked`
 
@@ -66,7 +66,7 @@ Takes an optional config object, which has the following properties:
 
 ```js
 {
-  debug: boolean, // whether the code should display debug messages on the console or not (default = false)
+  verbose: boolean, // whether the code should display extra debug messages on the console or not (default = false)
   inputBufferSize: int, // the starting size of the input buffer, may expand later as needed. Not having to expand may have performance impact (default 0)
   outputBufferSize: int // same as inputBufferSize, but for the outputBuffer (default 0)
 }
@@ -80,7 +80,7 @@ Takes an optional config object, which has the following properties:
 
 ```js
 {
-  debug: boolean, // whether the code should display debug messages on the console or not (default = false)
+  verbose: boolean, // whether the code should display extra debug messages on the console or not (default = false)
   inputBufferSize: int, // the starting size of the input buffer, may expand later as needed. Not having to expand may have performance impact (default 0)
   outputBufferSize: int // same as inputBufferSize, but for the outputBuffer (default 0)
 }
@@ -148,9 +148,9 @@ const { through, streamToBuffer } = stream
 Readable.from(buffer) // buffer is of type Buffer with compressed data
   .pipe(through(explode()))
   .pipe(
-    streamToBuffer(decompressedData => {
+    streamToBuffer((decompressedData) => {
       // decompressedData holds the decompressed buffer
-    })
+    }),
   )
 ```
 
@@ -190,18 +190,18 @@ const { explode, stream } = require('node-pkware')
 const { through } = stream
 
 fs.createReadStream(`path-to-compressed-file`)
-  .on('error', err => {
+  .on('error', (err) => {
     console.error('readstream error')
   })
   .pipe(
-    through(explode()).on('error', err => {
+    through(explode()).on('error', (err) => {
       console.error('explode error')
-    })
+    }),
   )
   .pipe(
-    fs.createWriteStream(`path-to-write-decompressed-data`).on('error', err => {
+    fs.createWriteStream(`path-to-write-decompressed-data`).on('error', (err) => {
       console.error('writestream error')
-    })
+    }),
   )
 ```
 

package/bin/explode.js

@@ -8,10 +8,10 @@ const { explode } = require('../src/explode.js')
 
 const args = minimist(process.argv.slice(2), {
   string: ['output', 'offset', 'input-buffer-size', 'output-buffer-size'],
-  boolean: ['version', 'drop-before-offset', 'debug'],
+  boolean: ['version', 'drop-before-offset', 'verbose'],
   alias: {
-    v: 'version'
-  }
+    v: 'version',
+  },
 })
 
 const decompress = (input, output, offset, keepHeader, config) => {
@@ -27,7 +27,8 @@ const decompress = (input, output, offset, keepHeader, config) => {
 
 ;(async () => {
   if (args.version) {
-    console.log(await getPackageVersion())
+    const version = await getPackageVersion()
+    console.log(`node-pkware - version ${version}`)
     process.exit(0)
   }
 
@@ -61,16 +62,16 @@ const decompress = (input, output, offset, keepHeader, config) => {
 
   const keepHeader = !args['drop-before-offset']
   const config = {
-    debug: args.debug,
+    verbose: args.verbose,
     inputBufferSize: parseNumberString(args['input-buffer-size'], 0x10000),
-    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x40000)
+    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x40000),
   }
 
   decompress(input, output, offset, keepHeader, config)
     .then(() => {
       process.exit(0)
     })
-    .catch(e => {
+    .catch((e) => {
       console.error(`error: ${e.message}`)
       process.exit(1)
     })

package/bin/implode.js

@@ -7,7 +7,7 @@ const {
   COMPRESSION_ASCII,
   DICTIONARY_SIZE_SMALL,
   DICTIONARY_SIZE_MEDIUM,
-  DICTIONARY_SIZE_LARGE
+  DICTIONARY_SIZE_LARGE,
 } = require('../src/constants.js')
 const { getPackageVersion, parseNumberString, fileExists } = require('../src/helpers/functions.js')
 const { implode } = require('../src/implode.js')
@@ -26,20 +26,21 @@ const decompress = (input, output, offset, keepHeader, compressionType, dictiona
 
 const args = minimist(process.argv.slice(2), {
   string: ['output', 'offset', 'input-buffer-size', 'output-buffer-size'],
-  boolean: ['version', 'binary', 'ascii', 'drop-before-offset', 'debug', 'small', 'medium', 'large'],
+  boolean: ['version', 'binary', 'ascii', 'drop-before-offset', 'verbose', 'small', 'medium', 'large'],
   alias: {
     a: 'ascii',
     b: 'binary',
     s: 'small',
     m: 'medium',
     l: 'large',
-    v: 'version'
-  }
+    v: 'version',
+  },
 })
 
 ;(async () => {
   if (args.version) {
-    console.log(await getPackageVersion())
+    const version = await getPackageVersion()
+    console.log(`node-pkware - version ${version}`)
     process.exit(0)
   }
 
@@ -67,7 +68,9 @@ const args = minimist(process.argv.slice(2), {
     hasErrors = true
   }
 
-  const sizes = [args.small, args.medium, args.large].filter(x => x === true)
+  const sizes = [args.small, args.medium, args.large].filter((x) => {
+    return x === true
+  })
   if (sizes.length > 1) {
     console.error('error: multiple size types specified, can only work with one of --small, --medium and --large')
     hasErrors = true
@@ -97,16 +100,16 @@ const args = minimist(process.argv.slice(2), {
 
   const keepHeader = !args['drop-before-offset']
   const config = {
-    debug: args.debug,
+    verbose: args.verbose,
     inputBufferSize: parseNumberString(args['input-buffer-size'], 0x10000),
-    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x12000)
+    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x12000),
   }
 
   decompress(input, output, offset, keepHeader, compressionType, dictionarySize, config)
     .then(() => {
       process.exit(0)
     })
-    .catch(e => {
+    .catch((e) => {
       console.error(`error: ${e.message}`)
       process.exit(1)
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-pkware",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "The nodejs implementation of StormLib's pkware compressor/de-compressor",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
     "implode": "bin/implode.js"
   },
   "scripts": {
-    "lint": "eslint \"src/**/*.js\"",
+    "lint": "eslint \"{bin,src,test}/**/*.{js,ts}\"",
     "lint:fix": "npm run lint -- --fix",
     "lint:staged": "lint-staged",
     "test:unit": "set FORCE_COLOR=true && mocha test/**/*.spec.js --timeout 5000",
@@ -33,28 +33,30 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "minimist-lite": "^2.2.1",
-    "ramda": "^0.28.0",
-    "ramda-adjunct": "^3.1.0"
+    "ramda": "^0.28.0"
   },
   "devDependencies": {
-    "arx-header-size": "^0.7.0",
+    "@types/node": "^18.11.10",
+    "arx-header-size": "^2.0.0",
     "binary-comparator": "^0.5.0",
-    "eslint": "^8.15.0",
+    "esbuild": "^0.15.16",
+    "eslint": "^8.28.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-config-prettier-standard": "^4.0.1",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-ramda": "^2.5.1",
     "eslint-plugin-standard": "^4.1.0",
-    "lint-staged": "^12.4.1",
-    "mocha": "^10.0.0",
-    "nodemon": "^2.0.16",
+    "lint-staged": "^13.0.4",
+    "mocha": "^10.1.0",
+    "nodemon": "^2.0.20",
     "pre-commit": "^1.2.2",
-    "prettier": "^2.6.2",
-    "prettier-config-standard": "^5.0.0"
+    "prettier": "^2.8.0",
+    "prettier-config-standard": "^5.0.0",
+    "typescript": "^4.9.3"
   },
   "pre-commit": [
     "lint:staged",
@@ -63,5 +65,14 @@
   ],
   "lint-staged": {
     "*.js": "eslint --fix"
-  }
+  },
+  "keywords": [
+    "arx-fatalis",
+    "pkware",
+    "stormlib",
+    "implode",
+    "explode",
+    "compression",
+    "blast"
+  ]
 }

package/src/constants.js

@@ -135,5 +135,5 @@ module.exports = {
   ExLenBits,
   LenBase,
   ChBitsAsc,
-  ChCodeAsc
+  ChCodeAsc,
 }

package/src/errors.js

@@ -46,5 +46,5 @@ module.exports = {
   InvalidDataError,
   AbortedError,
   ExpectedBufferError,
-  ExpectedFunctionError
+  ExpectedFunctionError,
 }

package/src/explode.js

@@ -1,14 +1,13 @@
-const { repeat, unfold, reduce, has, includes } = require('ramda')
-const { isFunction } = require('ramda-adjunct')
+const { repeat, unfold, has } = require('ramda')
 const {
   InvalidDataError,
   InvalidCompressionTypeError,
   InvalidDictionarySizeError,
   ExpectedBufferError,
   ExpectedFunctionError,
-  AbortedError
+  AbortedError,
 } = require('./errors.js')
-const { mergeSparseArrays, getLowestNBits, nBitsOfOnes, toHex } = require('./helpers/functions.js')
+const { mergeSparseArrays, getLowestNBits, nBitsOfOnes, toHex, isFunction } = require('./helpers/functions.js')
 const {
   ChBitsAsc,
   ChCodeAsc,
@@ -26,11 +25,11 @@ const {
   ExLenBits,
   DistBits,
   LenCode,
-  DistCode
+  DistCode,
 } = require('./constants.js')
 const ExpandingBuffer = require('./helpers/ExpandingBuffer.js')
 
-const readHeader = buffer => {
+const readHeader = (buffer) => {
   if (!Buffer.isBuffer(buffer)) {
     throw new ExpectedBufferError()
   }
@@ -40,22 +39,24 @@ const readHeader = buffer => {
 
   const compressionType = buffer.readUInt8(0)
   const dictionarySizeBits = buffer.readUInt8(1)
-  if (compressionType !== COMPRESSION_BINARY && compressionType !== COMPRESSION_ASCII) {
+  if (![COMPRESSION_BINARY, COMPRESSION_ASCII].includes(compressionType)) {
     throw new InvalidCompressionTypeError()
   }
-  if (!includes(dictionarySizeBits, [DICTIONARY_SIZE_SMALL, DICTIONARY_SIZE_MEDIUM, DICTIONARY_SIZE_LARGE])) {
+  if (![DICTIONARY_SIZE_SMALL, DICTIONARY_SIZE_MEDIUM, DICTIONARY_SIZE_LARGE].includes(dictionarySizeBits)) {
     throw new InvalidDictionarySizeError()
   }
 
   return {
     compressionType,
-    dictionarySizeBits
+    dictionarySizeBits,
   }
 }
 
 // PAT = populate ascii table
-const createPATIterator = (limit, stepper) => n => {
-  return n >= limit ? false : [n, n + (1 << stepper)]
+const createPATIterator = (limit, stepper) => {
+  return (n) => {
+    return n >= limit ? false : [n, n + (1 << stepper)]
+  }
 }
 
 const populateAsciiTable = (value, index, bits, limit) => {
@@ -63,14 +64,10 @@ const populateAsciiTable = (value, index, bits, limit) => {
   const seed = ChCodeAsc[index] >> bits
   const idxs = unfold(iterator, seed)
 
-  return reduce(
-    (acc, idx) => {
-      acc[idx] = index
-      return acc
-    },
-    [],
-    idxs
-  )
+  return idxs.reduce((acc, idx) => {
+    acc[idx] = index
+    return acc
+  }, [])
 }
 
 const generateAsciiTables = () => {
@@ -78,7 +75,7 @@ const generateAsciiTables = () => {
     asciiTable2C34: repeat(0, 0x100),
     asciiTable2D34: repeat(0, 0x100),
     asciiTable2E34: repeat(0, 0x80),
-    asciiTable2EB4: repeat(0, 0x100)
+    asciiTable2EB4: repeat(0, 0x100),
   }
 
   tables.chBitsAsc = ChBitsAsc.map((value, index) => {
@@ -107,7 +104,7 @@ const generateAsciiTables = () => {
   return tables
 }
 
-const parseInitialData = (state, debug = false) => {
+const parseInitialData = (state, verbose = false) => {
   if (state.inputBuffer.size() < 4) {
     return false
   }
@@ -127,12 +124,12 @@ const parseInitialData = (state, debug = false) => {
     })
   }
 
-  if (debug) {
+  if (verbose) {
     console.log(`explode: compression type: ${state.compressionType === COMPRESSION_BINARY ? 'binary' : 'ascii'}`)
     console.log(
       `explode: compression level: ${
         state.dictionarySizeBits === 4 ? 'small' : state.dictionarySizeBits === 5 ? 'medium' : 'large'
-      }`
+      }`,
     )
   }
 
@@ -158,7 +155,7 @@ const wasteBits = (state, numberOfBits) => {
   return PKDCL_OK
 }
 
-const decodeNextLiteral = state => {
+const decodeNextLiteral = (state) => {
   const lastBit = state.bitBuffer & 1
 
   if (wasteBits(state, 1) === PKDCL_STREAM_END) {
@@ -247,13 +244,13 @@ const decodeDistance = (state, repeatLength) => {
   return distance + 1
 }
 
-const processChunkData = (state, debug = false) => {
+const processChunkData = (state, verbose = false) => {
   if (state.inputBuffer.isEmpty()) {
     return
   }
 
   if (!has('compressionType', state)) {
-    const parsedHeader = parseInitialData(state, debug)
+    const parsedHeader = parseInitialData(state, verbose)
     if (!parsedHeader || state.inputBuffer.isEmpty()) {
       return
     }
@@ -312,7 +309,7 @@ const generateDecodeTables = (startIndexes, lengthBits) => {
 }
 
 const explode = (config = {}) => {
-  const { debug = false, inputBufferSize = 0x0, outputBufferSize = 0x0 } = config
+  const { verbose = false, inputBufferSize = 0x0, outputBufferSize = 0x0 } = config
 
   const handler = function (chunk, encoding, callback) {
     if (!isFunction(callback)) {
@@ -330,11 +327,11 @@ const explode = (config = {}) => {
         this._flush = state.onInputFinished
       }
 
-      if (debug) {
+      if (verbose) {
         console.log(`explode: reading ${toHex(chunk.length)} bytes from chunk #${state.stats.chunkCounter++}`)
       }
 
-      processChunkData(state, debug)
+      processChunkData(state, verbose)
 
       const blockSize = 0x1000
       if (state.outputBuffer.size() > blockSize) {
@@ -354,7 +351,7 @@ const explode = (config = {}) => {
   handler._state = {
     _backup: {
       extraBits: null,
-      bitBuffer: null
+      bitBuffer: null,
     },
     needMoreInput: true,
     isFirstChunk: true,
@@ -364,10 +361,10 @@ const explode = (config = {}) => {
     distPosCodes: generateDecodeTables(DistCode, DistBits),
     inputBuffer: new ExpandingBuffer(inputBufferSize),
     outputBuffer: new ExpandingBuffer(outputBufferSize),
-    onInputFinished: callback => {
+    onInputFinished: (callback) => {
       const state = handler._state
 
-      if (debug) {
+      if (verbose) {
         console.log('---------------')
         console.log('explode: total number of chunks read:', state.stats.chunkCounter)
         console.log('explode: inputBuffer heap size', toHex(state.inputBuffer.heapSize()))
@@ -393,8 +390,8 @@ const explode = (config = {}) => {
       state.inputBuffer._restoreIndices()
     },
     stats: {
-      chunkCounter: 0
-    }
+      chunkCounter: 0,
+    },
   }
 
   return handler
@@ -410,5 +407,5 @@ module.exports = {
   wasteBits,
   decodeNextLiteral,
   decodeDistance,
-  generateDecodeTables
+  generateDecodeTables,
 }

package/src/helpers/ExpandingBuffer.js

@@ -9,7 +9,7 @@ class ExpandingBuffer {
 
     this._backup = {
       _startIndex: 0,
-      _endIndex: 0
+      _endIndex: 0,
     }
   }
 

package/src/helpers/functions.js

@@ -1,6 +1,24 @@
 const fs = require('fs')
-const { repeat, test } = require('ramda')
-const { isNumber, isString } = require('ramda-adjunct')
+const { repeat, test, type } = require('ramda')
+
+const isNumber = (x) => {
+  return typeof x === 'number'
+}
+
+const isString = (x) => {
+  return typeof x === 'string'
+}
+
+const isFunction = (x) => {
+  return type(x) === 'Function'
+}
+
+const noop = () => {}
+
+// https://stackoverflow.com/a/68989785/1806628
+const isPlainObject = (x) => {
+  return x.constructor === Object
+}
 
 const isBetween = (min, max, num) => {
   if (!isNumber(min) || !isNumber(max) || !isNumber(num)) {
@@ -13,7 +31,7 @@ const isBetween = (min, max, num) => {
   return num >= min && num <= max
 }
 
-const nBitsOfOnes = numberOfBits => {
+const nBitsOfOnes = (numberOfBits) => {
   if (!Number.isInteger(numberOfBits) || numberOfBits < 0) {
     return null
   }
@@ -37,7 +55,7 @@ const getLowestNBits = (numberOfBits, number) => {
 
 const isDecimalString = test(/^\d+$/)
 
-const isFullHexString = str => {
+const isFullHexString = (str) => {
   if (isString(str)) {
     return /^\s*0x[0-9a-f]+\s*$/.test(str)
   } else {
@@ -77,7 +95,9 @@ const mergeSparseArrays = (a, b) => {
 /*
 export const dumpBytes = bytes => {
   const formattedBytes = Array.from(bytes)
-    .map(byte => toHex(byte, 2, true))
+    .map(byte => {
+      return toHex(byte, 2, true)
+    })
     .join(' ')
   return `<${formattedBytes}>`
 }
@@ -102,7 +122,7 @@ const getPackageVersion = async () => {
   }
 }
 
-const fileExists = async filename => {
+const fileExists = async (filename) => {
   try {
     await fs.promises.access(filename, fs.constants.R_OK)
     return true
@@ -112,6 +132,11 @@ const fileExists = async filename => {
 }
 
 module.exports = {
+  isNumber,
+  isString,
+  isFunction,
+  noop,
+  isPlainObject,
   isBetween,
   nBitsOfOnes,
   maskBits,
@@ -121,5 +146,5 @@ module.exports = {
   mergeSparseArrays,
   parseNumberString,
   getPackageVersion,
-  fileExists
+  fileExists,
 }

package/src/helpers/stream.js

@@ -1,7 +1,7 @@
 const { Transform, Writable } = require('stream')
 const { promisify } = require('util')
-const { isFunction } = require('ramda-adjunct')
 const ExpandingBuffer = require('./ExpandingBuffer.js')
+const { isFunction } = require('./functions.js')
 
 const emptyBuffer = Buffer.from([])
 
@@ -15,7 +15,7 @@ class QuasiTransform {
   }
 }
 
-const splitAt = index => {
+const splitAt = (index) => {
   let cntr = 0
 
   if (!Number.isInteger(index) || index < 0) {
@@ -24,7 +24,7 @@ const splitAt = index => {
     }
   }
 
-  return chunk => {
+  return (chunk) => {
     let left
     let right
     let isLeftDone = true
@@ -66,9 +66,9 @@ const transformEmpty = () => {
   }
 }
 
-const through = handler => {
+const through = (handler) => {
   return new Transform({
-    transform: handler
+    transform: handler,
   })
 }
 
@@ -89,7 +89,7 @@ const transformSplitBy = (predicate, leftHandler, rightHandler) => {
 
     if (isFirstChunk) {
       isFirstChunk = false
-      this._flush = flushCallback => {
+      this._flush = (flushCallback) => {
         if (!dam.isEmpty()) {
           this.push(dam.read())
         }
@@ -122,10 +122,10 @@ const transformSplitBy = (predicate, leftHandler, rightHandler) => {
         }
 
         Promise.all([leftFiller, rightFiller])
-          .then(buffers => {
+          .then((buffers) => {
             flushCallback(null, Buffer.concat(buffers))
           })
-          .catch(err => {
+          .catch((err) => {
             flushCallback(err)
           })
       }
@@ -146,7 +146,7 @@ const transformSplitBy = (predicate, leftHandler, rightHandler) => {
     }
 
     Promise.all([_left, filler, _right])
-      .then(buffers => {
+      .then((buffers) => {
         dam.append(Buffer.concat(buffers))
         if (dam.size() > damChunkSize) {
           const chunks = Math.floor(dam.size() / damChunkSize)
@@ -160,13 +160,13 @@ const transformSplitBy = (predicate, leftHandler, rightHandler) => {
           callback(null, emptyBuffer)
         }
       })
-      .catch(err => {
+      .catch((err) => {
         callback(err)
       })
   }
 }
 
-const streamToBuffer = done => {
+const streamToBuffer = (done) => {
   const buffer = new ExpandingBuffer()
   return new Writable({
     write(chunk, encoding, callback) {
@@ -176,7 +176,7 @@ const streamToBuffer = done => {
     final(callback) {
       done(buffer.getHeap())
       callback()
-    }
+    },
   })
 }
 
@@ -186,5 +186,5 @@ module.exports = {
   transformEmpty,
   through,
   transformSplitBy,
-  streamToBuffer
+  streamToBuffer,
 }

package/src/helpers/testing.js

@@ -8,10 +8,12 @@ const isPromise = promise => {
   return typeof promise === 'object' && promise.constructor.name === 'Promise'
 }
 
-const toConsole = () => (chunk, encoding, callback) => {
-  process.stdout.write(chunk)
-  process.stdout.write(Buffer.from(EOL))
-  callback(null, chunk)
+const toConsole = () => {
+  return (chunk, encoding, callback) => {
+    process.stdout.write(chunk)
+    process.stdout.write(Buffer.from(EOL))
+    callback(null, chunk)
+  }
 }
 
 const readToBuffer = (fileName, chunkSizeInBytes = 1024) => {
@@ -30,7 +32,7 @@ const readToBuffer = (fileName, chunkSizeInBytes = 1024) => {
 */
 
 // source: https://stackoverflow.com/a/43197340/1806628
-const isClass = obj => {
+const isClass = (obj) => {
   const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class'
   if (obj.prototype === undefined) {
     return isCtorClass
@@ -74,5 +76,5 @@ module.exports = {
   isClass,
   buffersShouldEqual,
   bufferToString,
-  transformToABC
+  transformToABC,
 }

package/src/implode.js

@@ -1,7 +1,6 @@
 const { has, repeat, clone, last, clamp } = require('ramda')
-const { isFunction } = require('ramda-adjunct')
 const ExpandingBuffer = require('./helpers/ExpandingBuffer.js')
-const { toHex, getLowestNBits, nBitsOfOnes } = require('./helpers/functions.js')
+const { toHex, getLowestNBits, nBitsOfOnes, isFunction } = require('./helpers/functions.js')
 const { ExpectedFunctionError, InvalidDictionarySizeError, InvalidCompressionTypeError } = require('./errors.js')
 const {
   ChBitsAsc,
@@ -16,10 +15,10 @@ const {
   LenBits,
   LenCode,
   DistCode,
-  DistBits
+  DistBits,
 } = require('./constants.js')
 
-const setup = state => {
+const setup = (state) => {
   state.nChBits = repeat(0, 0x306)
   state.nChCodes = repeat(0, 0x306)
 
@@ -128,7 +127,7 @@ const findRepetitions = (inputBytes, endOfLastMatch, cursor) => {
     const distance = cursor - endOfLastMatch - matchIndex
     return {
       distance: distance - 1,
-      size: distance > 2 ? getSizeOfMatching(inputBytes, endOfLastMatch + matchIndex, cursor) : 2
+      size: distance > 2 ? getSizeOfMatching(inputBytes, endOfLastMatch + matchIndex, cursor) : 2,
     }
   }
 
@@ -162,7 +161,7 @@ const isRepetitionFlushable = (size, distance, startIndex, inputBufferSize) => {
 
 // repetitions are at least 2 bytes long,
 // so the initial 2 bytes can be moved to the output as is
-const handleFirstTwoBytes = state => {
+const handleFirstTwoBytes = (state) => {
   if (state.handledFirstTwoBytes) {
     return
   }
@@ -179,7 +178,7 @@ const handleFirstTwoBytes = state => {
   state.startIndex += 2
 }
 
-const processChunkData = (state, debug = false) => {
+const processChunkData = (state, verbose = false) => {
   if (!has('dictionarySizeMask', state)) {
     setup(state)
   }
@@ -272,7 +271,7 @@ const processChunkData = (state, debug = false) => {
 }
 
 const implode = (compressionType, dictionarySizeBits, config = {}) => {
-  const { debug = false, inputBufferSize = 0x0, outputBufferSize = 0x0 } = config
+  const { verbose = false, inputBufferSize = 0x0, outputBufferSize = 0x0 } = config
 
   const handler = function (chunk, encoding, callback) {
     if (!isFunction(callback)) {
@@ -289,11 +288,11 @@ const implode = (compressionType, dictionarySizeBits, config = {}) => {
         this._flush = state.onInputFinished
       }
 
-      if (debug) {
+      if (verbose) {
         console.log(`implode: reading ${toHex(chunk.length)} bytes from chunk #${state.stats.chunkCounter++}`)
       }
 
-      processChunkData(state, debug)
+      processChunkData(state, verbose)
 
       const blockSize = 0x800
       if (state.outputBuffer.size() > blockSize) {
@@ -319,21 +318,21 @@ const implode = (compressionType, dictionarySizeBits, config = {}) => {
   handler._state = {
     isFirstChunk: true,
     streamEnded: false,
-    compressionType: compressionType,
-    dictionarySizeBits: dictionarySizeBits,
+    compressionType,
+    dictionarySizeBits,
     distCodes: clone(DistCode),
     distBits: clone(DistBits),
     startIndex: 0,
     inputBuffer: new ExpandingBuffer(inputBufferSize),
     outputBuffer: new ExpandingBuffer(outputBufferSize),
     handledFirstTwoBytes: false,
-    onInputFinished: callback => {
+    onInputFinished: (callback) => {
       const state = handler._state
       state.streamEnded = true
       try {
-        processChunkData(state, debug)
+        processChunkData(state, verbose)
 
-        if (debug) {
+        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()))
@@ -346,8 +345,8 @@ const implode = (compressionType, dictionarySizeBits, config = {}) => {
       }
     },
     stats: {
-      chunkCounter: 0
-    }
+      chunkCounter: 0,
+    },
   }
 
   return handler
@@ -361,5 +360,5 @@ module.exports = {
   isRepetitionFlushable,
   handleFirstTwoBytes,
   processChunkData,
-  implode
+  implode,
 }

package/src/index.js

@@ -14,5 +14,5 @@ module.exports = {
   decompress,
   constants,
   errors,
-  stream
+  stream,
 }

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "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/explode.d.ts

@@ -49,7 +49,7 @@ export function generateAsciiTables(): {
   asciiTable2E34: number[]
   asciiTable2EB4: number[]
 }
-export function processChunkData(state: PrivateExplodeState, debug?: boolean): void
+export function processChunkData(state: PrivateExplodeState, verbose?: boolean): void
 export function wasteBits(state: PrivateExplodeState, numberOfBits: number): typeof PKDCL_STREAM_END | typeof PKDCL_OK
 export function decodeNextLiteral(state: PrivateExplodeState): typeof LITERAL_STREAM_ABORTED | number
 export function decodeDistance(state: PrivateExplodeState, repeatLength: number): number

package/types/helpers/Shared.d.ts

@@ -27,10 +27,10 @@ export type PrivateState<T> = { _state: T }
  */
 export type Config = {
   /**
-   * Whether the code should display debug messages on the console or not
+   * Whether the code should display extra messages on the console or not
    * @default false
    */
-  debug?: boolean
+  verbose?: boolean
   /**
    * The starting size of the input buffer, may expand later as needed.
    * Not having to expand may have performance impact.

package/types/helpers/functions.d.ts

@@ -1,3 +1,8 @@
+export function isNumber(x: any): boolean
+export function isString(x: any): boolean
+export function isFunction(x: any): boolean
+export function noop(): void
+export function isPlainObject(x: any): boolean
 export function isBetween(min: number, max: number, num: number): boolean
 export function nBitsOfOnes(numberOfBits: number): number
 export function maskBits(numberOfBits: number, number: number): number

package/types/implode.d.ts

@@ -39,15 +39,15 @@ export function getSizeOfMatching(inputBytes: number[], a: number, b: number): n
 export function findRepetitions(
   inputBytes: number[],
   endOfLastMatch: number,
-  cursor: number
+  cursor: number,
 ): { size: number; distance: number }
 export function isRepetitionFlushable(
   size: number,
   distance: number,
   startIndex: number,
-  inputBufferSize: number
+  inputBufferSize: number,
 ): boolean | null
-export function processChunkData(state: PrivateExplodeState, debug?: boolean): void
+export function processChunkData(state: PrivateExplodeState, verbose?: boolean): void
 
 /**
  * Compresses stream
@@ -59,5 +59,5 @@ export function processChunkData(state: PrivateExplodeState, debug?: boolean): v
 export function implode(
   compressionType: CompressionType,
   dictionarySizeBits: DictionarySizeBits,
-  config?: Config
+  config?: Config,
 ): PrivateState<PrivateExplodeState> & Handler