node-pkware 3.0.0 → 3.0.2

package/src/Implode.ts

@@ -1,368 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { Transform, TransformCallback } from 'node:stream'
-import {
-  ChBitsAsc,
-  ChCodeAsc,
-  Compression,
-  DictionarySize,
-  DistBits,
-  DistCode,
-  ExLenBits,
-  LenBits,
-  LenCode,
-  LONGEST_ALLOWED_REPETITION,
-} from './constants'
-import { InvalidCompressionTypeError, InvalidDictionarySizeError } from './errors'
-import { ExpandingBuffer } from './ExpandingBuffer'
-import { clamp, clone, evenAndRemainder, getLowestNBits, last, nBitsOfOnes, repeat, toHex } from './functions'
-import { Config, Stats } from './types'
-
-export const getSizeOfMatching = (inputBytes: Buffer, a: number, b: number) => {
-  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: Buffer, endOfLastMatch: number, cursor: number) => {
-  const notEnoughBytes = inputBytes.length - cursor < 2
-  const tooClose = cursor === endOfLastMatch || cursor - endOfLastMatch < 2
-  if (notEnoughBytes || tooClose) {
-    return { size: 0, distance: 0 }
-  }
-
-  const haystack = inputBytes.subarray(endOfLastMatch, cursor)
-  const needle = inputBytes.subarray(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 }
-}
-
-export class Implode {
-  #verbose: boolean
-  #isFirstChunk: boolean = true
-  #inputBuffer: ExpandingBuffer
-  #outputBuffer: ExpandingBuffer
-  #stats: Stats = { chunkCounter: 0 }
-  #compressionType: Compression = Compression.Unknown
-  #dictionarySize: DictionarySize = DictionarySize.Unknown
-  #dictionarySizeMask: number = -1
-  #streamEnded: boolean = false
-  #distCodes: number[] = clone(DistCode)
-  #distBits: number[] = clone(DistBits)
-  #startIndex: number = 0
-  #handledFirstTwoBytes: boolean = false
-  #outBits: number = 0
-  #nChBits: number[] = repeat(0, 0x306)
-  #nChCodes: number[] = repeat(0, 0x306)
-
-  constructor(compressionType: Compression, dictionarySize: DictionarySize, config: Config) {
-    if (!(compressionType in Compression) || compressionType === Compression.Unknown) {
-      throw new InvalidCompressionTypeError()
-    }
-
-    if (!(dictionarySize in DictionarySize) || dictionarySize === DictionarySize.Unknown) {
-      throw new InvalidDictionarySizeError()
-    }
-
-    this.#compressionType = compressionType
-    this.#dictionarySize = dictionarySize
-    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) {
-      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(`implode: reading ${toHex(chunk.length)} bytes from chunk #${instance.#stats.chunkCounter}`)
-        }
-
-        instance.#processChunkData()
-
-        const blockSize = 0x800
-
-        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)
-
-        if (instance.#outBits === 0) {
-          // set last byte to 0
-          instance.#outputBuffer.dropEnd(1)
-          instance.#outputBuffer.append(Buffer.from([0]))
-        }
-
-        callback(null, output)
-      } catch (e: unknown) {
-        callback(e as Error)
-      }
-    }
-  }
-
-  #onInputFinished(callback: TransformCallback) {
-    this.#streamEnded = true
-
-    try {
-      this.#processChunkData()
-
-      if (this.#verbose) {
-        console.log('---------------')
-        console.log('implode: total number of chunks read:', this.#stats.chunkCounter)
-        console.log('implode: inputBuffer heap size', toHex(this.#inputBuffer.heapSize()))
-        console.log('implode: outputBuffer heap size', toHex(this.#outputBuffer.heapSize()))
-      }
-
-      callback(null, this.#outputBuffer.read())
-    } catch (e: unknown) {
-      callback(e as Error)
-    }
-  }
-
-  #processChunkData() {
-    if (this.#dictionarySizeMask === -1) {
-      this.#setup()
-    }
-
-    if (!this.#inputBuffer.isEmpty()) {
-      this.#startIndex = 0
-
-      if (!this.#handledFirstTwoBytes) {
-        if (this.#inputBuffer.size() < 3) {
-          return
-        }
-
-        this.#handledFirstTwoBytes = true
-
-        this.#handleFirstTwoBytes()
-      }
-
-      // -------------------------------
-
-      let endOfLastMatch = 0 // used when searching for longer repetitions later
-
-      while (this.#startIndex < this.#inputBuffer.size()) {
-        let { size, distance } = findRepetitions(
-          this.#inputBuffer.read(endOfLastMatch),
-          endOfLastMatch,
-          this.#startIndex,
-        )
-
-        let isFlushable = this.#isRepetitionFlushable(size, distance)
-
-        if (isFlushable === false) {
-          const byte = this.#inputBuffer.readByte(this.#startIndex)
-          this.#outputBits(this.#nChBits[byte], this.#nChCodes[byte])
-          this.#startIndex += 1
-        } else {
-          if (isFlushable === null) {
-            /*
-            // Try to find better repetition 1 byte later.
-            // stormlib/implode.c L517
-            let cursor = this.#startIndex
-            let newSize = size
-            let newDistance = distance
-            let currentSize
-            let currentDistance
-            while (newSize <= currentSize && this.#isRepetitionFlushable(newSize, newDistance)) {
-              currentSize = newSize
-              currentDistance = newDistance
-              const reps = findRepetitions(this.#inputBuffer.read(endOfLastMatch), endOfLastMatch, ++cursor)
-              newSize = reps.size
-              newDistance = reps.distance
-            }
-            size = newSize
-            distance = currentDistance
-            */
-          }
-
-          const byte = size + 0xfe
-          this.#outputBits(this.#nChBits[byte], this.#nChCodes[byte])
-          if (size === 2) {
-            const byte = distance >> 2
-            this.#outputBits(this.#distBits[byte], this.#distCodes[byte])
-            this.#outputBits(2, distance & 3)
-          } else {
-            const byte = distance >> this.#dictionarySize
-            this.#outputBits(this.#distBits[byte], this.#distCodes[byte])
-            this.#outputBits(this.#dictionarySize, this.#dictionarySizeMask & distance)
-          }
-
-          this.#startIndex += size
-        }
-
-        /*
-        this.#inputBuffer.dropStart(endOfLastMatch)
-        this.#startIndex -= endOfLastMatch
-        endOfLastMatch = 0
-        */
-
-        if (this.#dictionarySize === DictionarySize.Small && this.#startIndex >= 0x400) {
-          this.#inputBuffer.dropStart(0x400)
-          this.#startIndex -= 0x400
-        } else if (this.#dictionarySize === DictionarySize.Medium && this.#startIndex >= 0x800) {
-          this.#inputBuffer.dropStart(0x800)
-          this.#startIndex -= 0x800
-        } else if (this.#dictionarySize === DictionarySize.Large && this.#startIndex >= 0x1000) {
-          this.#inputBuffer.dropStart(0x1000)
-          this.#startIndex -= 0x1000
-        }
-      }
-
-      // -------------------------------
-
-      this.#inputBuffer.dropStart(this.#inputBuffer.size())
-    }
-
-    if (this.#streamEnded) {
-      // Write the termination literal
-      this.#outputBits(last(this.#nChBits), last(this.#nChCodes))
-    }
-  }
-
-  /**
-   * @returns false - non flushable
-   * @returns true - flushable
-   * @returns null - flushable, but there might be a better repetition
-   */
-  #isRepetitionFlushable(size: number, distance: number) {
-    if (size === 0) {
-      return false
-    }
-
-    // If we found repetition of 2 bytes, that is 0x100 or further 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 || this.#startIndex + 1 >= this.#inputBuffer.size()) {
-      return true
-    }
-
-    return null
-  }
-
-  /**
-   * repetitions are at least 2 bytes long,
-   * so the initial 2 bytes can be moved to the output as is
-   */
-  #handleFirstTwoBytes() {
-    const byte1 = this.#inputBuffer.readByte(0)
-    const byte2 = this.#inputBuffer.readByte(1)
-    this.#outputBits(this.#nChBits[byte1], this.#nChCodes[byte1])
-    this.#outputBits(this.#nChBits[byte2], this.#nChCodes[byte2])
-    this.#startIndex += 2
-  }
-
-  #setup() {
-    switch (this.#dictionarySize) {
-      case DictionarySize.Large:
-        this.#dictionarySizeMask = nBitsOfOnes(6)
-        break
-      case DictionarySize.Medium:
-        this.#dictionarySizeMask = nBitsOfOnes(5)
-        break
-      case DictionarySize.Small:
-        this.#dictionarySizeMask = nBitsOfOnes(4)
-        break
-    }
-
-    switch (this.#compressionType) {
-      case Compression.Binary:
-        let nChCode = 0
-        for (let nCount = 0; nCount < 0x100; nCount++) {
-          this.#nChBits[nCount] = 9
-          this.#nChCodes[nCount] = nChCode
-          nChCode = getLowestNBits(16, nChCode) + 2
-        }
-        break
-      case Compression.Ascii:
-        for (let nCount = 0; nCount < 0x100; nCount++) {
-          this.#nChBits[nCount] = ChBitsAsc[nCount] + 1
-          this.#nChCodes[nCount] = ChCodeAsc[nCount] * 2
-        }
-        break
-    }
-
-    let nCount = 0x100
-
-    for (let i = 0; i < 0x10; i++) {
-      for (let nCount2 = 0; nCount2 < 1 << ExLenBits[i]; nCount2++) {
-        this.#nChBits[nCount] = ExLenBits[i] + LenBits[i] + 1
-        this.#nChCodes[nCount] = (nCount2 << (LenBits[i] + 1)) | (LenCode[i] * 2) | 1
-        nCount++
-      }
-    }
-
-    this.#outputBuffer.append(Buffer.from([this.#compressionType, this.#dictionarySize, 0]))
-    this.#outBits = 0
-  }
-
-  #outputBits(nBits: number, bitBuffer: number) {
-    if (nBits > 8) {
-      this.#outputBits(8, bitBuffer)
-      bitBuffer = bitBuffer >> 8
-      nBits = nBits - 8
-    }
-
-    const outBits = this.#outBits
-
-    const lastBytes = this.#outputBuffer.readByte(this.#outputBuffer.size() - 1)
-    this.#outputBuffer.dropEnd(1)
-    this.#outputBuffer.append(Buffer.from([lastBytes | getLowestNBits(8, bitBuffer << outBits)]))
-
-    this.#outBits = this.#outBits + nBits
-
-    if (this.#outBits > 8) {
-      bitBuffer = bitBuffer >> (8 - outBits)
-      this.#outputBuffer.append(Buffer.from([getLowestNBits(8, bitBuffer)]))
-      this.#outBits = getLowestNBits(3, this.#outBits)
-    } else {
-      this.#outBits = getLowestNBits(3, this.#outBits)
-      if (this.#outBits === 0) {
-        this.#outputBuffer.append(Buffer.from([0]))
-      }
-    }
-  }
-}

package/src/bin/explode.ts

@@ -1,80 +0,0 @@
-#!/usr/bin/env -S node --enable-source-maps
-
-import minimist from 'minimist-lite'
-import { getPackageVersion, parseNumberString, getInputStream, getOutputStream } from './helpers'
-import { transformEmpty, transformIdentity, transformSplitBy, splitAt, through } from '../stream'
-import { Config } from '../types'
-import { explode } from '../index'
-
-type AppArgs = {
-  _: string[]
-  output?: string
-  offset?: string
-  'input-buffer-size'?: string
-  'output-buffer-size'?: string
-  version: boolean
-  'drop-before-offset': boolean
-  verbose: boolean
-  v: boolean
-}
-
-const args: AppArgs = minimist(process.argv.slice(2), {
-  string: ['output', 'offset', 'input-buffer-size', 'output-buffer-size'],
-  boolean: ['version', 'drop-before-offset', 'verbose'],
-  alias: {
-    v: 'version',
-  },
-})
-
-const decompress = (
-  input: NodeJS.ReadableStream,
-  output: NodeJS.WritableStream,
-  offset: number,
-  keepHeader: boolean,
-  config: Config,
-) => {
-  const leftHandler = keepHeader ? transformIdentity() : transformEmpty()
-  const rightHandler = explode(config)
-
-  const handler = transformSplitBy(splitAt(offset), leftHandler, rightHandler)
-
-  return new Promise((resolve, reject) => {
-    input.pipe(through(handler).on('error', reject)).pipe(output).on('finish', resolve).on('error', reject)
-  })
-}
-
-;(async () => {
-  if (args.version) {
-    const version = await getPackageVersion()
-    console.log(`node-pkware - version ${version}`)
-    process.exit(0)
-  }
-
-  let input: NodeJS.ReadableStream
-  let output: NodeJS.WritableStream
-  try {
-    input = await getInputStream(args._[0])
-    output = await getOutputStream(args.output)
-  } catch (e: unknown) {
-    const error = e as Error
-    console.error('error:', error.message)
-    process.exit(1)
-  }
-
-  const offset = parseNumberString(args.offset, 0)
-  const keepHeader = !args['drop-before-offset']
-  const config: Config = {
-    verbose: args.verbose,
-    inputBufferSize: parseNumberString(args['input-buffer-size'], 0x10000),
-    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x40000),
-  }
-
-  decompress(input, output, offset, keepHeader, config)
-    .then(() => {
-      process.exit(0)
-    })
-    .catch((e) => {
-      console.error(`error: ${e.message}`)
-      process.exit(1)
-    })
-})()

package/src/bin/helpers.ts

@@ -1,65 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-const isDecimalString = (input: string) => {
-  return /^\d+$/.test(input)
-}
-
-const isFullHexString = (input: string) => {
-  return /^\s*0x[0-9a-f]+\s*$/.test(input)
-}
-
-export const parseNumberString = (n?: string, defaultValue: number = 0) => {
-  if (typeof n === 'undefined') {
-    return defaultValue
-  }
-
-  if (isDecimalString(n)) {
-    return parseInt(n)
-  }
-
-  if (isFullHexString(n)) {
-    return parseInt(n.replace(/^0x/, ''), 16)
-  }
-
-  return defaultValue
-}
-
-export const getPackageVersion = async () => {
-  try {
-    const rawIn = await fs.promises.readFile(path.resolve(__dirname, '../../package.json'), 'utf-8')
-    const { version } = JSON.parse(rawIn) as { version: string }
-    return version
-  } catch (error: unknown) {
-    return 'unknown'
-  }
-}
-
-const fileExists = async (filename: string) => {
-  try {
-    await fs.promises.access(filename, fs.constants.R_OK)
-    return true
-  } catch (error: unknown) {
-    return false
-  }
-}
-
-export const getInputStream = async (filename?: string): Promise<NodeJS.ReadableStream> => {
-  if (typeof filename === 'undefined') {
-    return process.openStdin()
-  }
-
-  if (await fileExists(filename)) {
-    return fs.createReadStream(filename)
-  }
-
-  throw new Error('input file does not exist')
-}
-
-export const getOutputStream = async (filename?: string): Promise<NodeJS.WritableStream> => {
-  if (typeof filename === 'undefined') {
-    return process.stdout
-  }
-
-  return fs.createWriteStream(filename)
-}

package/src/bin/implode.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env -S node --enable-source-maps
-
-import minimist from 'minimist-lite'
-import { Compression, DictionarySize } from '../constants'
-import { getPackageVersion, parseNumberString, getInputStream, getOutputStream } from './helpers'
-import { transformEmpty, transformIdentity, transformSplitBy, splitAt, through } from '../stream'
-import { Config } from '../types'
-import { implode } from '../index'
-
-type AppArgs = {
-  _: string[]
-  output?: string
-  offset?: string
-  'input-buffer-size'?: string
-  'output-buffer-size'?: string
-  version: boolean
-  binary: boolean
-  ascii: boolean
-  'drop-before-offset': boolean
-  verbose: boolean
-  small: boolean
-  medium: boolean
-  large: boolean
-  v: boolean
-  b: boolean
-  a: boolean
-  s: boolean
-  m: boolean
-  l: boolean
-}
-
-const args: AppArgs = minimist(process.argv.slice(2), {
-  string: ['output', 'offset', 'input-buffer-size', 'output-buffer-size'],
-  boolean: ['version', 'ascii', 'binary', 'small', 'medium', 'large', 'drop-before-offset', 'verbose'],
-  alias: {
-    v: 'version',
-    a: 'ascii',
-    b: 'binary',
-    s: 'small',
-    m: 'medium',
-    l: 'large',
-  },
-})
-
-const compress = (
-  input: NodeJS.ReadableStream,
-  output: NodeJS.WritableStream,
-  offset: number,
-  keepHeader: boolean,
-  compressionType: Compression,
-  dictionarySize: DictionarySize,
-  config: Config,
-) => {
-  const leftHandler = keepHeader ? transformIdentity() : transformEmpty()
-  const rightHandler = implode(compressionType, dictionarySize, config)
-
-  const handler = transformSplitBy(splitAt(offset), leftHandler, rightHandler)
-
-  return new Promise((resolve, reject) => {
-    input.pipe(through(handler).on('error', reject)).pipe(output).on('finish', resolve).on('error', reject)
-  })
-}
-
-;(async () => {
-  if (args.version) {
-    const version = await getPackageVersion()
-    console.log(`node-pkware - version ${version}`)
-    process.exit(0)
-  }
-
-  let input: NodeJS.ReadableStream
-  let output: NodeJS.WritableStream
-  try {
-    if (!args.ascii && !args.binary) {
-      throw new Error('compression type missing, expected either --ascii or --binary')
-    }
-
-    if (args.ascii && args.binary) {
-      throw new Error('multiple compression types specified, can only work with either --ascii or --binary')
-    }
-
-    if (!args.small && !args.medium && !args.large) {
-      throw new Error('dictionary size missing, expected either --small, --medium or --large')
-    }
-
-    if ((args.small ? 1 : 0) + (args.medium ? 1 : 0) + (args.large ? 1 : 0) > 1) {
-      throw new Error('multiple dictionary sizes specified, can only work with either --small, --medium or --large')
-    }
-
-    input = await getInputStream(args._[0])
-    output = await getOutputStream(args.output)
-  } catch (e: unknown) {
-    const error = e as Error
-    console.error('error:', error.message)
-    process.exit(1)
-  }
-
-  const compressionType = args.ascii ? Compression.Ascii : Compression.Binary
-  const dictionarySize = args.small ? DictionarySize.Small : args.medium ? DictionarySize.Medium : DictionarySize.Large
-  const offset = parseNumberString(args.offset, 0)
-  const keepHeader = !args['drop-before-offset']
-  const config: Config = {
-    verbose: args.verbose,
-    inputBufferSize: parseNumberString(args['input-buffer-size'], 0x10000),
-    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x12000),
-  }
-
-  compress(input, output, offset, keepHeader, compressionType, dictionarySize, config)
-    .then(() => {
-      process.exit(0)
-    })
-    .catch((e) => {
-      console.error(`error: ${e.message}`)
-      process.exit(1)
-    })
-})()