node-pkware 3.0.0 → 3.0.2

package/src/constants.ts

@@ -1,120 +0,0 @@
-/**
- * Compression types for implode
- */
-export enum Compression {
-  Unknown = -1,
-  Binary = 0,
-  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 enum DictionarySize {
-  Unknown = -1,
-  Small = 4,
-  Medium,
-  Large,
-}
-
-export const EMPTY_BUFFER = Buffer.from([])
-
-export const LONGEST_ALLOWED_REPETITION = 0x204
-
-export const LITERAL_END_STREAM = 0x305
-
-// prettier-ignore
-export const DistCode = [
-  0x03, 0x0D, 0x05, 0x19, 0x09, 0x11, 0x01, 0x3E, 0x1E, 0x2E, 0x0E, 0x36, 0x16, 0x26, 0x06, 0x3A,
-  0x1A, 0x2A, 0x0A, 0x32, 0x12, 0x22, 0x42, 0x02, 0x7C, 0x3C, 0x5C, 0x1C, 0x6C, 0x2C, 0x4C, 0x0C,
-  0x74, 0x34, 0x54, 0x14, 0x64, 0x24, 0x44, 0x04, 0x78, 0x38, 0x58, 0x18, 0x68, 0x28, 0x48, 0x08,
-  0xF0, 0x70, 0xB0, 0x30, 0xD0, 0x50, 0x90, 0x10, 0xE0, 0x60, 0xA0, 0x20, 0xC0, 0x40, 0x80, 0x00
-]
-
-// prettier-ignore
-export const DistBits = [
-  0x02, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-  0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
-]
-
-// prettier-ignore
-export const LenBits = [
-  0x03, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07
-]
-
-// prettier-ignore
-export const LenCode = [
-  0x05, 0x03, 0x01, 0x06, 0x0a, 0x02, 0x0c, 0x14, 0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00
-]
-
-// prettier-ignore
-export const ExLenBits = [
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
-]
-
-// prettier-ignore
-export const LenBase = [
-  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
-  0x0008, 0x000A, 0x000E, 0x0016, 0x0026, 0x0046, 0x0086, 0x0106
-]
-
-// prettier-ignore
-export const ChBitsAsc = [
-  0x0B, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x08, 0x07, 0x0C, 0x0C, 0x07, 0x0C, 0x0C,
-  0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
-  0x04, 0x0A, 0x08, 0x0C, 0x0A, 0x0C, 0x0A, 0x08, 0x07, 0x07, 0x08, 0x09, 0x07, 0x06, 0x07, 0x08,
-  0x07, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x07, 0x07, 0x08, 0x08, 0x0C, 0x0B, 0x07, 0x09, 0x0B,
-  0x0C, 0x06, 0x07, 0x06, 0x06, 0x05, 0x07, 0x08, 0x08, 0x06, 0x0B, 0x09, 0x06, 0x07, 0x06, 0x06,
-  0x07, 0x0B, 0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x09, 0x09, 0x0B, 0x08, 0x0B, 0x09, 0x0C, 0x08,
-  0x0C, 0x05, 0x06, 0x06, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05, 0x0B, 0x07, 0x05, 0x06, 0x05, 0x05,
-  0x06, 0x0A, 0x05, 0x05, 0x05, 0x05, 0x08, 0x07, 0x08, 0x08, 0x0A, 0x0B, 0x0B, 0x0C, 0x0C, 0x0C,
-  0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
-  0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
-  0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,
-  0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
-  0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
-  0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,
-  0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D,
-  0x0D, 0x0D, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D
-]
-
-// prettier-ignore
-export const ChCodeAsc = [
-  0x0490, 0x0FE0, 0x07E0, 0x0BE0, 0x03E0, 0x0DE0, 0x05E0, 0x09E0,
-  0x01E0, 0x00B8, 0x0062, 0x0EE0, 0x06E0, 0x0022, 0x0AE0, 0x02E0,
-  0x0CE0, 0x04E0, 0x08E0, 0x00E0, 0x0F60, 0x0760, 0x0B60, 0x0360,
-  0x0D60, 0x0560, 0x1240, 0x0960, 0x0160, 0x0E60, 0x0660, 0x0A60,
-  0x000F, 0x0250, 0x0038, 0x0260, 0x0050, 0x0C60, 0x0390, 0x00D8,
-  0x0042, 0x0002, 0x0058, 0x01B0, 0x007C, 0x0029, 0x003C, 0x0098,
-  0x005C, 0x0009, 0x001C, 0x006C, 0x002C, 0x004C, 0x0018, 0x000C,
-  0x0074, 0x00E8, 0x0068, 0x0460, 0x0090, 0x0034, 0x00B0, 0x0710,
-  0x0860, 0x0031, 0x0054, 0x0011, 0x0021, 0x0017, 0x0014, 0x00A8,
-  0x0028, 0x0001, 0x0310, 0x0130, 0x003E, 0x0064, 0x001E, 0x002E,
-  0x0024, 0x0510, 0x000E, 0x0036, 0x0016, 0x0044, 0x0030, 0x00C8,
-  0x01D0, 0x00D0, 0x0110, 0x0048, 0x0610, 0x0150, 0x0060, 0x0088,
-  0x0FA0, 0x0007, 0x0026, 0x0006, 0x003A, 0x001B, 0x001A, 0x002A,
-  0x000A, 0x000B, 0x0210, 0x0004, 0x0013, 0x0032, 0x0003, 0x001D,
-  0x0012, 0x0190, 0x000D, 0x0015, 0x0005, 0x0019, 0x0008, 0x0078,
-  0x00F0, 0x0070, 0x0290, 0x0410, 0x0010, 0x07A0, 0x0BA0, 0x03A0,
-  0x0240, 0x1C40, 0x0C40, 0x1440, 0x0440, 0x1840, 0x0840, 0x1040,
-  0x0040, 0x1F80, 0x0F80, 0x1780, 0x0780, 0x1B80, 0x0B80, 0x1380,
-  0x0380, 0x1D80, 0x0D80, 0x1580, 0x0580, 0x1980, 0x0980, 0x1180,
-  0x0180, 0x1E80, 0x0E80, 0x1680, 0x0680, 0x1A80, 0x0A80, 0x1280,
-  0x0280, 0x1C80, 0x0C80, 0x1480, 0x0480, 0x1880, 0x0880, 0x1080,
-  0x0080, 0x1F00, 0x0F00, 0x1700, 0x0700, 0x1B00, 0x0B00, 0x1300,
-  0x0DA0, 0x05A0, 0x09A0, 0x01A0, 0x0EA0, 0x06A0, 0x0AA0, 0x02A0,
-  0x0CA0, 0x04A0, 0x08A0, 0x00A0, 0x0F20, 0x0720, 0x0B20, 0x0320,
-  0x0D20, 0x0520, 0x0920, 0x0120, 0x0E20, 0x0620, 0x0A20, 0x0220,
-  0x0C20, 0x0420, 0x0820, 0x0020, 0x0FC0, 0x07C0, 0x0BC0, 0x03C0,
-  0x0DC0, 0x05C0, 0x09C0, 0x01C0, 0x0EC0, 0x06C0, 0x0AC0, 0x02C0,
-  0x0CC0, 0x04C0, 0x08C0, 0x00C0, 0x0F40, 0x0740, 0x0B40, 0x0340,
-  0x0300, 0x0D40, 0x1D00, 0x0D00, 0x1500, 0x0540, 0x0500, 0x1900,
-  0x0900, 0x0940, 0x1100, 0x0100, 0x1E00, 0x0E00, 0x0140, 0x1600,
-  0x0600, 0x1A00, 0x0E40, 0x0640, 0x0A40, 0x0A00, 0x1200, 0x0200,
-  0x1C00, 0x0C00, 0x1400, 0x0400, 0x1800, 0x0800, 0x1000, 0x0000
-]

package/src/errors.ts

@@ -1,47 +0,0 @@
-/**
- * Thrown by
- * - `implode` when invalid dictionary size was specified
- * - `explode` when it encounters invalid data in the header section (the first 2 bytes of a compressed files)
- */
-export class InvalidDictionarySizeError extends Error {
-  constructor() {
-    super('Invalid dictionary size')
-    this.name = 'InvalidDictionarySizeError'
-  }
-}
-
-/**
- * Thrown by
- * - `implode` when invalid compression type was specified
- * - `explode` when it encounters invalid data in the header section (the first 2 bytes of a compressed files)
- */
-export class InvalidCompressionTypeError extends Error {
-  constructor() {
-    super('Invalid compression type')
-    this.name = 'InvalidCompressionTypeError'
-  }
-}
-
-/**
- * Thrown by
- * - `explode`, when compressed data is less, than `5` bytes long
- *
- * Pkware compressed files have 2 bytes header followed by at lest 2 bytes of data and an end literal.
- */
-export class InvalidDataError extends Error {
-  constructor() {
-    super('Invalid data')
-    this.name = 'InvalidDataError'
-  }
-}
-
-/**
- * Thrown by
- * - `explode` when compressed data ends without reaching the end literal or in mid decompression
- */
-export class AbortedError extends Error {
-  constructor() {
-    super('Aborted')
-    this.name = 'AbortedError'
-  }
-}

package/src/functions.ts

@@ -1,73 +0,0 @@
-export const repeat = <T>(value: T, repetitions: number): T[] => {
-  return Array(repetitions).fill(value)
-}
-
-export const clamp = (min: number, max: number, n: number) => {
-  if (n < min) {
-    return min
-  }
-  if (n > max) {
-    return max
-  }
-  return n
-}
-
-export const clone = <T>(data: T): T => {
-  return JSON.parse(JSON.stringify(data))
-}
-
-export const isFunction = (x: any): x is Function => {
-  return Object.prototype.toString.call(x) === '[object Function]'
-}
-
-export const nBitsOfOnes = (numberOfBits: number) => {
-  if (!Number.isInteger(numberOfBits) || numberOfBits < 0) {
-    return 0
-  }
-
-  return (1 << numberOfBits) - 1
-}
-
-export const getLowestNBits = (numberOfBits: number, number: number) => {
-  return number & nBitsOfOnes(numberOfBits)
-}
-
-export const toHex = (num: number, digits: number = 0, withoutPrefix: boolean = false) => {
-  if (!Number.isInteger(num) || !Number.isInteger(digits) || digits < 0) {
-    return ''
-  }
-
-  const prefix = withoutPrefix ? '' : '0x'
-
-  return `${prefix}${num.toString(16).padStart(digits, '0')}`
-}
-
-export const mergeSparseArrays = <T>(a: T[], b: T[]) => {
-  const result = [...b, ...(b.length < a.length ? repeat(undefined, a.length - b.length) : [])]
-
-  for (let i = 0; i < a.length; i++) {
-    if (typeof a[i] !== 'undefined') {
-      result[i] = a[i]
-    }
-  }
-
-  return result
-}
-
-export const last = <T>(arr: T[]) => {
-  return arr[arr.length - 1]
-}
-
-export const unfold = <T, TResult>(fn: (seed: T) => [TResult, T] | false, seed: T): TResult[] => {
-  let pair = fn(seed)
-  const result: TResult[] = []
-  while (pair && pair.length) {
-    result[result.length] = pair[0]
-    pair = fn(pair[1])
-  }
-  return result
-}
-
-export const evenAndRemainder = (divisor: number, n: number): [number, number] => {
-  return [Math.floor(n / divisor), n % divisor]
-}

package/src/index.ts

@@ -1,30 +0,0 @@
-import { Compression, DictionarySize } from './constants'
-import { Explode } from './Explode'
-import { Implode } from './Implode'
-import { Config } from './types'
-
-/**
- * Decompresses stream
- * @returns a function that you can use as a `transform._transform` method.
- */
-export const explode = (config: Config = {}) => {
-  const instance = new Explode(config)
-  return instance.getHandler()
-}
-
-/**
- * Compresses stream
- * @returns a function that you can use as a `transform._transform` method.
- */
-export const implode = (compressionType: Compression, dictionarySize: DictionarySize, config: Config = {}) => {
-  const instance = new Implode(compressionType, dictionarySize, config)
-  return instance.getHandler()
-}
-
-export { explode as decompress }
-export { implode as compress }
-
-export { Compression, DictionarySize } from './constants'
-export * as errors from './errors'
-export * as stream from './stream'
-export type { Config } from './types'

package/src/stream.ts

@@ -1,220 +0,0 @@
-import { Transform, Writable, TransformCallback } from 'node:stream'
-import { promisify } from 'node:util'
-import { isFunction } from './functions'
-import { ExpandingBuffer } from './ExpandingBuffer'
-import { EMPTY_BUFFER } from './constants'
-
-class QuasiTransform {
-  #handler: (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) => void
-  _flush?: (callback: TransformCallback) => void
-
-  constructor(
-    handler: (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) => void,
-  ) {
-    this.#handler = handler
-  }
-
-  handle(chunk: Buffer, encoding: BufferEncoding): Promise<Buffer> {
-    return promisify(this.#handler).call(this, chunk, encoding)
-  }
-}
-
-/**
- * Creates a "**predicate**" function, that awaits Buffers, keeps an internal counter of the bytes from them and splits the appropriate buffer at the given index.
- * Splitting is done by returning an array with `[left: Buffer, right: Buffer, isLeftDone: bool]`.
- * If you want to split data at the 100th byte and you keep feeding 60 byte long buffers to the function returned by `splitAt(100)`, then it will return arrays in the following manner:
- * 1. `[inputBuffer, emptyBuffer, false]`
- * 2. `[inputBuffer.slice(0, 40), inputBuffer.slice(40, 60), true]`
- * 3. `[emptyBuffer, inputBuffer, true]`
- * 4. `[emptyBuffer, inputBuffer, true]`
- * 5. ... and so on
- * @param index - a positive integer at which to split the buffer
- */
-export const splitAt = (index: number) => {
-  let cntr = 0
-
-  return (chunk: Buffer) => {
-    let left: Buffer
-    let right: Buffer
-    let isLeftDone: boolean
-
-    if (index <= cntr) {
-      // index ..... cntr ..... chunk.length
-      left = EMPTY_BUFFER
-      right = chunk
-      isLeftDone = true
-    } else if (index >= cntr + chunk.length) {
-      // cntr ..... chunk.length ..... index
-      left = chunk
-      right = EMPTY_BUFFER
-      isLeftDone = index === cntr + chunk.length
-    } else {
-      // cntr ..... index ..... chunk.length
-      left = chunk.subarray(0, index - cntr)
-      right = chunk.subarray(index - cntr)
-      isLeftDone = true
-    }
-
-    cntr += chunk.length
-
-    return [left, right, isLeftDone] as [Buffer, Buffer, boolean]
-  }
-}
-
-/**
- * A `transform._transform` type function, which lets the input chunks through without any changes
- */
-export const transformIdentity = () => {
-  return function (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) {
-    callback(null, chunk)
-  }
-}
-
-/**
- * A `transform._transform` type function, which for every input chunk will output an empty buffer
- */
-export const transformEmpty = () => {
-  return function (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) {
-    callback(null, EMPTY_BUFFER)
-  }
-}
-
-/**
- * Takes a `transform._transform` type function and turns it into a Transform stream instance
- * @param handler a `transform._transform` type function
- * @returns a Transform stream instance
- */
-export const through = (
-  handler: (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) => void,
-) => {
-  return new Transform({
-    transform: handler,
-  })
-}
-
-/**
- * Higher order function for introducing conditional logic to `transform._transform` functions.
- * This is used internally to handle offsets for `explode()`.
- * @returns a `transform._transform` type function
- */
-export const transformSplitBy = (
-  predicate: (chunk: Buffer) => [Buffer, Buffer, boolean],
-  leftHandler: (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) => void,
-  rightHandler: (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) => void,
-) => {
-  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 (this: Transform, chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) {
-    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())
-        }
-
-        const leftFiller = new Promise((resolve, reject) => {
-          if (wasLeftFlushCalled || !isFunction(leftTransform._flush)) {
-            resolve(EMPTY_BUFFER)
-            return
-          }
-
-          leftTransform._flush((err, data) => {
-            if (err) {
-              reject(err)
-            } else {
-              resolve(data)
-            }
-          })
-        })
-
-        const rightFiller = new Promise((resolve, reject) => {
-          if (!isFunction(rightTransform._flush)) {
-            resolve(EMPTY_BUFFER)
-            return
-          }
-
-          rightTransform._flush((err, data) => {
-            if (err) {
-              reject(err)
-            } else {
-              resolve(data)
-            }
-          })
-        })
-
-        Promise.all([leftFiller, rightFiller])
-          .then((buffers) => {
-            // TODO: TransformCallback assumes the returned data is any instead of Buffer
-            flushCallback(null, Buffer.concat(buffers as Buffer[]))
-          })
-          .catch((err) => {
-            flushCallback(err)
-          })
-      }
-    }
-
-    const filler = new Promise((resolve, reject) => {
-      if (isLeftDone && !wasLeftFlushCalled && isFunction(leftTransform._flush)) {
-        wasLeftFlushCalled = true
-        leftTransform._flush((err, data) => {
-          if (err) {
-            reject(err)
-          } else {
-            resolve(data)
-          }
-        })
-      } else {
-        resolve(EMPTY_BUFFER)
-      }
-    })
-
-    Promise.all([_left, filler, _right])
-      .then((buffers) => {
-        // TODO: TransformCallback assumes the returned data is any instead of Buffer
-        dam.append(Buffer.concat(buffers as Buffer[]))
-        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.subarray(i * damChunkSize, i * damChunkSize + damChunkSize))
-          }
-          callback(null, data.subarray((chunks - 1) * damChunkSize))
-        } else {
-          callback(null, EMPTY_BUFFER)
-        }
-      })
-      .catch((err) => {
-        callback(err)
-      })
-  }
-}
-
-/**
- * Data can be piped to the returned function from a stream and it will concatenate all chunks into a single buffer.
- * @param done a callback function, which will receive the concatenated buffer as a parameter
- */
-export const toBuffer = (done: (buffer: Buffer) => void) => {
-  const buffer = new ExpandingBuffer()
-  return new Writable({
-    write(chunk, encoding, callback) {
-      buffer.append(chunk)
-      callback()
-    },
-    final(callback) {
-      done(buffer.getHeap())
-      callback()
-    },
-  })
-}

package/src/types.ts

@@ -1,26 +0,0 @@
-/**
- * Configuration options for the implode & explode functions.
- */
-export type Config = {
-  /**
-   * Whether the code should display extra messages on the console or not
-   * @default false
-   */
-  verbose?: boolean
-  /**
-   * The starting size of the input buffer, may expand later as needed.
-   * Not having to expand may have positive performance impact.
-   * @default 0
-   */
-  inputBufferSize?: number
-  /**
-   * The starting size of the output buffer, may expand later as needed.
-   * Not having to expand may have positive performance impact.
-   * @default 0
-   */
-  outputBufferSize?: number
-}
-
-export type Stats = {
-  chunkCounter: number
-}