node-pkware 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-pkware",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "The nodejs implementation of StormLib's pkware compressor/de-compressor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/ExpandingBuffer.ts

@@ -1,148 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { clamp } from './functions'
-
-export class ExpandingBuffer {
-  #heap: Buffer
-  #startIndex: number = 0
-  #endIndex: number = 0
-  #backup: { startIndex: number; endIndex: number } = {
-    startIndex: 0,
-    endIndex: 0,
-  }
-
-  constructor(numberOfBytes: number = 0) {
-    this.#heap = Buffer.allocUnsafe(numberOfBytes)
-  }
-
-  #getActualData(offset: number = 0) {
-    return this.#heap.subarray(this.#startIndex + offset, this.#endIndex)
-  }
-
-  size() {
-    return this.#endIndex - this.#startIndex
-  }
-
-  isEmpty() {
-    return this.size() === 0
-  }
-
-  heapSize() {
-    return this.#heap.length
-  }
-
-  append(buffer: Buffer) {
-    if (this.#endIndex + buffer.length < this.heapSize()) {
-      buffer.copy(this.#heap, this.#endIndex)
-      this.#endIndex += buffer.length
-    } else {
-      this.#heap = Buffer.concat([this.#getActualData(), buffer])
-      this.#startIndex = 0
-      this.#endIndex = this.heapSize()
-    }
-  }
-
-  /**
-   * Watch out! The returned slice of Buffer points to the same Buffer in memory!
-   */
-  read(offset: number = 0, limit: number = this.size()) {
-    if (offset < 0 || limit < 1) {
-      return Buffer.from([])
-    }
-
-    if (offset + limit < this.size()) {
-      return this.#heap.subarray(this.#startIndex + offset, this.#startIndex + limit + offset)
-    }
-
-    return this.#getActualData(offset)
-  }
-
-  readByte(offset: number = 0) {
-    return this.#heap[this.#startIndex + offset]
-  }
-
-  /**
-   * Does hard delete
-   *
-   * Removes data from the start of the internal buffer (heap)
-   * by copying bytes to lower indices making sure the
-   * startIndex goes back to 0 afterwards
-   */
-  flushStart(numberOfBytes: number) {
-    numberOfBytes = clamp(0, this.heapSize(), numberOfBytes)
-    if (numberOfBytes > 0) {
-      if (numberOfBytes < this.heapSize()) {
-        this.#heap.copy(this.#heap, 0, this.#startIndex + numberOfBytes)
-      }
-
-      this.#endIndex -= this.#startIndex + numberOfBytes
-      this.#startIndex = 0
-    }
-  }
-
-  /**
-   * Does hard delete
-   *
-   * Removes data from the end of the internal buffer (heap)
-   * by moving the endIndex back
-   */
-  flushEnd(numberOfBytes: number) {
-    const clampedNumberOfBytes = clamp(0, this.heapSize(), numberOfBytes)
-    if (clampedNumberOfBytes > 0) {
-      this.#endIndex -= clampedNumberOfBytes
-    }
-  }
-
-  /**
-   * Does soft delete
-   *
-   * Removes data from the start of the internal buffer (heap)
-   * by moving the startIndex forward
-   * When the heap gets empty it also resets the indices as a cleanup
-   */
-  dropStart(numberOfBytes: number) {
-    if (numberOfBytes > 0) {
-      this.#startIndex += numberOfBytes
-      if (this.#startIndex >= this.#endIndex) {
-        this.clear()
-      }
-    }
-  }
-
-  /**
-   * Does soft delete
-   *
-   * removes data from the end of the internal buffer (heap)
-   * by moving the endIndex back
-   * When the heap gets empty it also resets the indices as a cleanup
-   */
-  dropEnd(numberOfBytes: number) {
-    if (numberOfBytes > 0) {
-      this.#endIndex -= numberOfBytes
-      if (this.#startIndex >= this.#endIndex) {
-        this.clear()
-      }
-    }
-  }
-
-  /**
-   * returns the internal buffer
-   */
-  getHeap() {
-    return this.#heap
-  }
-
-  clear() {
-    this.#startIndex = 0
-    this.#endIndex = 0
-  }
-
-  saveIndices() {
-    this.#backup.startIndex = this.#startIndex
-    this.#backup.endIndex = this.#endIndex
-  }
-
-  restoreIndices() {
-    this.#startIndex = this.#backup.startIndex
-    this.#endIndex = this.#backup.endIndex
-  }
-}

package/src/Explode.ts

@@ -1,404 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { Transform, TransformCallback } from 'node:stream'
-import {
-  ChBitsAsc,
-  ChCodeAsc,
-  Compression,
-  DictionarySize,
-  DistBits,
-  DistCode,
-  ExLenBits,
-  LenBase,
-  LenBits,
-  LenCode,
-  LITERAL_END_STREAM,
-} from './constants'
-import { AbortedError, InvalidCompressionTypeError, InvalidDictionarySizeError } from './errors'
-import { ExpandingBuffer } from './ExpandingBuffer'
-import { evenAndRemainder, getLowestNBits, mergeSparseArrays, nBitsOfOnes, repeat, toHex, unfold } from './functions'
-import { Config, Stats } from './types'
-
-/**
- * This function assumes there are at least 2 bytes of data in the buffer
- */
-const readHeader = (buffer: Buffer) => {
-  const compressionType = buffer.readUInt8(0)
-  const dictionarySize = buffer.readUInt8(1)
-
-  if (!(compressionType in Compression) || compressionType === Compression.Unknown) {
-    throw new InvalidCompressionTypeError()
-  }
-
-  if (!(dictionarySize in DictionarySize) || dictionarySize === DictionarySize.Unknown) {
-    throw new InvalidDictionarySizeError()
-  }
-
-  return {
-    compressionType: compressionType as Compression,
-    dictionarySize: dictionarySize as DictionarySize,
-  }
-}
-
-const generateDecodeTables = (startIndexes: number[], lengthBits: number[]) => {
-  const codes = repeat(0, 0x100)
-
-  lengthBits.forEach((lengthBit, i) => {
-    for (let index = startIndexes[i]; index < 0x100; index += 1 << lengthBit) {
-      codes[index] = i
-    }
-  })
-
-  return codes
-}
-
-/**
- * PAT = populate ascii table
- */
-const createPATIterator = (limit: number, stepper: number) => {
-  return (n: number) => {
-    return n >= limit ? false : ([n, n + (1 << stepper)] as [number, number])
-  }
-}
-
-const populateAsciiTable = (value: number, index: number, bits: number, limit: number) => {
-  const iterator = createPATIterator(limit, value - bits)
-  const seed = ChCodeAsc[index] >> bits
-  const idxs = unfold(iterator, seed)
-
-  const table: number[] = []
-  idxs.forEach((idx) => {
-    table[idx] = index
-  })
-  return table
-}
-
-export class Explode {
-  #verbose: boolean
-  #needMoreInput: boolean = true
-  #isFirstChunk: boolean = true
-  #extraBits: number = 0
-  #bitBuffer: number = 0
-  #backupData: { extraBits: number; bitBuffer: number } = {
-    extraBits: -1,
-    bitBuffer: -1,
-  }
-  #lengthCodes: number[] = generateDecodeTables(LenCode, LenBits)
-  #distPosCodes: number[] = generateDecodeTables(DistCode, DistBits)
-  #inputBuffer: ExpandingBuffer
-  #outputBuffer: ExpandingBuffer
-  #stats: Stats = { chunkCounter: 0 }
-  #compressionType: Compression = Compression.Unknown
-  #dictionarySize: DictionarySize = DictionarySize.Unknown
-  #dictionarySizeMask: number = 0
-  #chBitsAsc: number[] = repeat(0, 0x100)
-  #asciiTable2C34: number[] = repeat(0, 0x100)
-  #asciiTable2D34: number[] = repeat(0, 0x100)
-  #asciiTable2E34: number[] = repeat(0, 0x80)
-  #asciiTable2EB4: number[] = repeat(0, 0x100)
-
-  constructor(config: Config = {}) {
-    this.#verbose = config?.verbose ?? false
-    this.#inputBuffer = new ExpandingBuffer(config?.inputBufferSize ?? 0)
-    this.#outputBuffer = new ExpandingBuffer(config?.outputBufferSize ?? 0)
-  }
-
-  getHandler() {
-    const instance = this
-
-    return function (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) {
-      instance.#needMoreInput = true
-
-      try {
-        instance.#inputBuffer.append(chunk)
-
-        if (instance.#isFirstChunk) {
-          instance.#isFirstChunk = false
-          this._flush = instance.#onInputFinished.bind(instance)
-        }
-
-        if (instance.#verbose) {
-          instance.#stats.chunkCounter++
-          console.log(`explode: reading ${toHex(chunk.length)} bytes from chunk #${instance.#stats.chunkCounter}`)
-        }
-
-        instance.#processChunkData()
-
-        const blockSize = 0x1000
-
-        if (instance.#outputBuffer.size() <= blockSize) {
-          callback(null, Buffer.from([]))
-          return
-        }
-
-        let [numberOfBlocks] = evenAndRemainder(instance.#outputBuffer.size(), blockSize)
-
-        // making sure to leave one block worth of data for lookback when processing chunk data
-        numberOfBlocks--
-
-        const numberOfBytes = numberOfBlocks * blockSize
-        // make sure to create a copy of the output buffer slice as it will get flushed in the next line
-        const output = Buffer.from(instance.#outputBuffer.read(0, numberOfBytes))
-        instance.#outputBuffer.flushStart(numberOfBytes)
-
-        callback(null, output)
-      } catch (e: unknown) {
-        callback(e as Error)
-      }
-    }
-  }
-
-  #generateAsciiTables() {
-    this.#chBitsAsc = ChBitsAsc.map((value, index) => {
-      if (value <= 8) {
-        this.#asciiTable2C34 = mergeSparseArrays(
-          populateAsciiTable(value, index, 0, 0x100),
-          this.#asciiTable2C34,
-        ) as number[]
-        return value - 0
-      }
-
-      const acc = getLowestNBits(8, ChCodeAsc[index])
-      if (acc === 0) {
-        this.#asciiTable2EB4 = mergeSparseArrays(
-          populateAsciiTable(value, index, 8, 0x100),
-          this.#asciiTable2EB4,
-        ) as number[]
-        return value - 8
-      }
-
-      this.#asciiTable2C34[acc] = 0xff
-
-      if (getLowestNBits(6, acc) === 0) {
-        this.#asciiTable2E34 = mergeSparseArrays(
-          populateAsciiTable(value, index, 6, 0x80),
-          this.#asciiTable2E34,
-        ) as number[]
-        return value - 6
-      }
-
-      this.#asciiTable2D34 = mergeSparseArrays(
-        populateAsciiTable(value, index, 4, 0x100),
-        this.#asciiTable2D34,
-      ) as number[]
-
-      return value - 4
-    })
-  }
-
-  #onInputFinished(callback: TransformCallback) {
-    if (this.#verbose) {
-      console.log('---------------')
-      console.log('explode: total number of chunks read:', this.#stats.chunkCounter)
-      console.log('explode: inputBuffer heap size', toHex(this.#inputBuffer.heapSize()))
-      console.log('explode: outputBuffer heap size', toHex(this.#outputBuffer.heapSize()))
-    }
-
-    if (this.#needMoreInput) {
-      callback(new AbortedError())
-      return
-    }
-
-    callback(null, this.#outputBuffer.read())
-  }
-
-  /**
-   * @throws {@link AbortedError} when there isn't enough data to be wasted
-   */
-  #wasteBits(numberOfBits: number) {
-    if (numberOfBits > this.#extraBits && this.#inputBuffer.isEmpty()) {
-      throw new AbortedError()
-    }
-
-    if (numberOfBits <= this.#extraBits) {
-      this.#bitBuffer = this.#bitBuffer >> numberOfBits
-      this.#extraBits = this.#extraBits - numberOfBits
-      return
-    }
-
-    const nextByte = this.#inputBuffer.readByte(0)
-    this.#inputBuffer.dropStart(1)
-
-    this.#bitBuffer = ((this.#bitBuffer >> this.#extraBits) | (nextByte << 8)) >> (numberOfBits - this.#extraBits)
-    this.#extraBits = this.#extraBits + 8 - numberOfBits
-  }
-
-  /**
-   * @throws {@link AbortedError}
-   */
-  #decodeNextLiteral() {
-    const lastBit = getLowestNBits(1, this.#bitBuffer)
-
-    this.#wasteBits(1)
-
-    if (lastBit) {
-      let lengthCode = this.#lengthCodes[getLowestNBits(8, this.#bitBuffer)]
-
-      this.#wasteBits(LenBits[lengthCode])
-
-      const extraLenghtBits = ExLenBits[lengthCode]
-      if (extraLenghtBits !== 0) {
-        const extraLength = getLowestNBits(extraLenghtBits, this.#bitBuffer)
-
-        try {
-          this.#wasteBits(extraLenghtBits)
-        } catch (e) {
-          if (lengthCode + extraLength !== 0x10e) {
-            throw new AbortedError()
-          }
-        }
-
-        lengthCode = LenBase[lengthCode] + extraLength
-      }
-
-      return lengthCode + 0x100
-    }
-
-    const lastByte = getLowestNBits(8, this.#bitBuffer)
-
-    if (this.#compressionType === Compression.Binary) {
-      this.#wasteBits(8)
-      return lastByte
-    }
-
-    let value: number
-
-    if (lastByte > 0) {
-      value = this.#asciiTable2C34[lastByte]
-
-      if (value === 0xff) {
-        if (getLowestNBits(6, this.#bitBuffer)) {
-          this.#wasteBits(4)
-
-          value = this.#asciiTable2D34[getLowestNBits(8, this.#bitBuffer)]
-        } else {
-          this.#wasteBits(6)
-
-          value = this.#asciiTable2E34[getLowestNBits(7, this.#bitBuffer)]
-        }
-      }
-    } else {
-      this.#wasteBits(8)
-
-      value = this.#asciiTable2EB4[getLowestNBits(8, this.#bitBuffer)]
-    }
-
-    this.#wasteBits(this.#chBitsAsc[value])
-
-    return value
-  }
-
-  /**
-   * @throws {@link AbortedError}
-   */
-  #decodeDistance(repeatLength: number) {
-    const distPosCode = this.#distPosCodes[getLowestNBits(8, this.#bitBuffer)]
-    const distPosBits = DistBits[distPosCode]
-
-    this.#wasteBits(distPosBits)
-
-    let distance: number
-    let bitsToWaste: number
-
-    if (repeatLength === 2) {
-      distance = (distPosCode << 2) | getLowestNBits(2, this.#bitBuffer)
-      bitsToWaste = 2
-    } else {
-      distance = (distPosCode << this.#dictionarySize) | (this.#bitBuffer & this.#dictionarySizeMask)
-      bitsToWaste = this.#dictionarySize
-    }
-
-    this.#wasteBits(bitsToWaste)
-
-    return distance + 1
-  }
-
-  #processChunkData() {
-    if (this.#inputBuffer.isEmpty()) {
-      return
-    }
-
-    if (this.#compressionType === Compression.Unknown) {
-      const headerParsedSuccessfully = this.#parseInitialData()
-      if (!headerParsedSuccessfully || this.#inputBuffer.isEmpty()) {
-        return
-      }
-    }
-
-    this.#needMoreInput = false
-
-    this.#backup()
-
-    try {
-      let nextLiteral = this.#decodeNextLiteral()
-
-      while (nextLiteral !== LITERAL_END_STREAM) {
-        let addition: Buffer
-
-        if (nextLiteral >= 0x100) {
-          const repeatLength = nextLiteral - 0xfe
-
-          const minusDistance = this.#decodeDistance(repeatLength)
-          const availableData = this.#outputBuffer.read(this.#outputBuffer.size() - minusDistance, repeatLength)
-
-          if (repeatLength > minusDistance) {
-            const multipliedData = repeat(availableData, Math.ceil(repeatLength / availableData.length))
-            addition = Buffer.concat(multipliedData).subarray(0, repeatLength)
-          } else {
-            addition = availableData
-          }
-        } else {
-          addition = Buffer.from([nextLiteral])
-        }
-
-        this.#outputBuffer.append(addition)
-
-        this.#backup()
-
-        nextLiteral = this.#decodeNextLiteral()
-      }
-    } catch (e) {
-      this.#needMoreInput = true
-    }
-
-    if (this.#needMoreInput) {
-      this.#restore()
-    }
-  }
-
-  #parseInitialData() {
-    if (this.#inputBuffer.size() < 4) {
-      return false
-    }
-
-    const { compressionType, dictionarySize } = readHeader(this.#inputBuffer.read(0, 2))
-
-    this.#compressionType = compressionType
-    this.#dictionarySize = dictionarySize
-    this.#bitBuffer = this.#inputBuffer.readByte(2)
-    this.#inputBuffer.dropStart(3)
-    this.#dictionarySizeMask = nBitsOfOnes(dictionarySize)
-
-    if (this.#compressionType === Compression.Ascii) {
-      this.#generateAsciiTables()
-    }
-
-    if (this.#verbose) {
-      console.log(`explode: compression type: ${Compression[this.#compressionType]}`)
-      console.log(`explode: compression level: ${DictionarySize[this.#dictionarySize]}`)
-    }
-
-    return true
-  }
-
-  #backup() {
-    this.#backupData.extraBits = this.#extraBits
-    this.#backupData.bitBuffer = this.#bitBuffer
-    this.#inputBuffer.saveIndices()
-  }
-
-  #restore() {
-    this.#extraBits = this.#backupData.extraBits
-    this.#bitBuffer = this.#backupData.bitBuffer
-    this.#inputBuffer.restoreIndices()
-  }
-}