node-pkware 2.0.0 → 3.0.0

package/src/{constants.js → constants.ts}

@@ -1,23 +1,33 @@
-const COMPRESSION_BINARY = 0
-const COMPRESSION_ASCII = 1
+/**
+ * Compression types for implode
+ */
+export enum Compression {
+  Unknown = -1,
+  Binary = 0,
+  Ascii,
+}
 
-const DICTIONARY_SIZE_SMALL = 4
-const DICTIONARY_SIZE_MEDIUM = 5
-const DICTIONARY_SIZE_LARGE = 6
+/**
+ * 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,
+}
 
-const LONGEST_ALLOWED_REPETITION = 0x204
+export const EMPTY_BUFFER = Buffer.from([])
 
-const PKDCL_OK = 'OK'
-const PKDCL_STREAM_END = 'All data from the input stream is read'
-const PKDCL_NEED_DICT = 'Need more data (dictionary)'
-const PKDCL_CONTINUE = 'Continue (internal flag)'
-const PKDCL_GET_INPUT = 'Get input (internal flag)'
+export const LONGEST_ALLOWED_REPETITION = 0x204
 
-const LITERAL_END_STREAM = 0x305
-const LITERAL_STREAM_ABORTED = 0x306
+export const LITERAL_END_STREAM = 0x305
 
 // prettier-ignore
-const DistCode = [
+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,
@@ -25,7 +35,7 @@ const DistCode = [
 ]
 
 // prettier-ignore
-const DistBits = [
+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,
@@ -33,28 +43,28 @@ const DistBits = [
 ]
 
 // prettier-ignore
-const LenBits = [
+export const LenBits = [
   0x03, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07
 ]
 
 // prettier-ignore
-const LenCode = [
+export const LenCode = [
   0x05, 0x03, 0x01, 0x06, 0x0a, 0x02, 0x0c, 0x14, 0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00
 ]
 
 // prettier-ignore
-const ExLenBits = [
+export const ExLenBits = [
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
 ]
 
 // prettier-ignore
-const LenBase = [
+export const LenBase = [
   0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
   0x0008, 0x000A, 0x000E, 0x0016, 0x0026, 0x0046, 0x0086, 0x0106
 ]
 
 // prettier-ignore
-const ChBitsAsc = [
+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,
@@ -74,7 +84,7 @@ const ChBitsAsc = [
 ]
 
 // prettier-ignore
-const ChCodeAsc = [
+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,
@@ -108,32 +118,3 @@ const ChCodeAsc = [
   0x0600, 0x1A00, 0x0E40, 0x0640, 0x0A40, 0x0A00, 0x1200, 0x0200,
   0x1C00, 0x0C00, 0x1400, 0x0400, 0x1800, 0x0800, 0x1000, 0x0000
 ]
-
-module.exports = {
-  COMPRESSION_BINARY,
-  COMPRESSION_ASCII,
-
-  DICTIONARY_SIZE_SMALL,
-  DICTIONARY_SIZE_MEDIUM,
-  DICTIONARY_SIZE_LARGE,
-
-  LONGEST_ALLOWED_REPETITION,
-
-  PKDCL_OK,
-  PKDCL_STREAM_END,
-  PKDCL_NEED_DICT,
-  PKDCL_CONTINUE,
-  PKDCL_GET_INPUT,
-
-  LITERAL_END_STREAM,
-  LITERAL_STREAM_ABORTED,
-
-  DistCode,
-  DistBits,
-  LenBits,
-  LenCode,
-  ExLenBits,
-  LenBase,
-  ChBitsAsc,
-  ChCodeAsc,
-}

package/src/errors.ts

@@ -0,0 +1,47 @@
+/**
+ * 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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,220 @@
+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

@@ -0,0 +1,26 @@
+/**
+ * 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
+}

package/bin/implode.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs')
-const minimist = require('minimist-lite')
-const {
-  COMPRESSION_BINARY,
-  COMPRESSION_ASCII,
-  DICTIONARY_SIZE_SMALL,
-  DICTIONARY_SIZE_MEDIUM,
-  DICTIONARY_SIZE_LARGE,
-} = require('../src/constants.js')
-const { getPackageVersion, parseNumberString, fileExists } = require('../src/helpers/functions.js')
-const { implode } = require('../src/implode.js')
-const { transformEmpty, transformIdentity, transformSplitBy, splitAt, through } = require('../src/helpers/stream.js')
-
-const decompress = (input, output, offset, keepHeader, compressionType, dictionarySize, 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)
-  })
-}
-
-const args = minimist(process.argv.slice(2), {
-  string: ['output', 'offset', 'input-buffer-size', 'output-buffer-size'],
-  boolean: ['version', 'binary', 'ascii', 'drop-before-offset', 'verbose', 'small', 'medium', 'large'],
-  alias: {
-    a: 'ascii',
-    b: 'binary',
-    s: 'small',
-    m: 'medium',
-    l: 'large',
-    v: 'version',
-  },
-})
-
-;(async () => {
-  if (args.version) {
-    const version = await getPackageVersion()
-    console.log(`node-pkware - version ${version}`)
-    process.exit(0)
-  }
-
-  let input = args._[0] || args.input
-  let output = args.output
-
-  let hasErrors = false
-
-  if (input) {
-    if (await fileExists(input)) {
-      input = fs.createReadStream(input)
-    } else {
-      console.error('error: given file does not exist')
-      hasErrors = true
-    }
-  } else {
-    input = process.openStdin()
-  }
-
-  if (args.ascii && args.binary) {
-    console.error('error: multiple compression types specified, can only work with one of --ascii and --binary')
-    hasErrors = true
-  } else if (!args.ascii && !args.binary) {
-    console.error('error: compression type missing, expected either --ascii or --binary')
-    hasErrors = 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
-  } else if (sizes.length === 0) {
-    console.error('error: size type missing, expected either --small, --medium or --large')
-    hasErrors = true
-  }
-
-  if (output) {
-    output = fs.createWriteStream(output)
-  } else {
-    output = process.stdout
-  }
-
-  if (hasErrors) {
-    process.exit(1)
-  }
-
-  const compressionType = args.ascii ? COMPRESSION_ASCII : COMPRESSION_BINARY
-  const dictionarySize = args.small
-    ? DICTIONARY_SIZE_SMALL
-    : args.medium
-    ? DICTIONARY_SIZE_MEDIUM
-    : DICTIONARY_SIZE_LARGE
-
-  const offset = parseNumberString(args.offset, 0)
-
-  const keepHeader = !args['drop-before-offset']
-  const config = {
-    verbose: args.verbose,
-    inputBufferSize: parseNumberString(args['input-buffer-size'], 0x10000),
-    outputBufferSize: parseNumberString(args['output-buffer-size'], 0x12000),
-  }
-
-  decompress(input, output, offset, keepHeader, compressionType, dictionarySize, config)
-    .then(() => {
-      process.exit(0)
-    })
-    .catch((e) => {
-      console.error(`error: ${e.message}`)
-      process.exit(1)
-    })
-})()

package/src/errors.js

@@ -1,50 +0,0 @@
-class InvalidDictionarySizeError extends Error {
-  constructor() {
-    super('Invalid dictionary size')
-    this.name = 'InvalidDictionarySizeError'
-  }
-}
-
-class InvalidCompressionTypeError extends Error {
-  constructor() {
-    super('Invalid compression type')
-    this.name = 'InvalidCompressionTypeError'
-  }
-}
-
-class InvalidDataError extends Error {
-  constructor() {
-    super('Invalid data')
-    this.name = 'InvalidDataError'
-  }
-}
-
-class AbortedError extends Error {
-  constructor() {
-    super('Aborted')
-    this.name = 'AbortedError'
-  }
-}
-
-class ExpectedBufferError extends TypeError {
-  constructor() {
-    super('Expected variable to be of type Buffer')
-    this.name = 'ExpectedBufferError'
-  }
-}
-
-class ExpectedFunctionError extends TypeError {
-  constructor() {
-    super('Expected variable to be a Function')
-    this.name = 'ExpectedFunctionError'
-  }
-}
-
-module.exports = {
-  InvalidDictionarySizeError,
-  InvalidCompressionTypeError,
-  InvalidDataError,
-  AbortedError,
-  ExpectedBufferError,
-  ExpectedFunctionError,
-}