@mapcatch/util 2.0.5 → 2.0.7

package/src/photo-parser/image-size/fromFile.js

@@ -1,55 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import { lookup } from './lookup'
-
-// Maximum input size, with a default of 512 kilobytes.
-// TO-DO: make this adaptive based on the initial signature of the image
-const MaxInputSize = 512 * 1024
-
-// This queue is for async `fs` operations, to avoid reaching file-descriptor limits
-const queue = []
-
-let concurrency = 100
-export const setConcurrency = (c) => {
-  concurrency = c
-}
-
-const processQueue = async () => {
-  const jobs = queue.splice(0, concurrency)
-  const promises = jobs.map(async ({ filePath, resolve, reject }) => {
-    let handle
-    try {
-      handle = await fs.promises.open(path.resolve(filePath), 'r')
-    } catch (err) {
-      return reject(err)
-    }
-    try {
-      const { size } = await handle.stat()
-      if (size <= 0) {
-        throw new Error('Empty file')
-      }
-      const inputSize = Math.min(size, MaxInputSize)
-      const input = new Uint8Array(inputSize)
-      await handle.read(input, 0, inputSize, 0)
-      resolve(lookup(input))
-    } catch (err) {
-      reject(err)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  await Promise.allSettled(promises)
-
-  if (queue.length) setTimeout(processQueue, 100)
-}
-
-/**
- * @param {string} filePath - relative/absolute path of the image file
- */
-export const imageSize = async (filePath) =>
-  new Promise < ISizeCalculationResult > ((resolve, reject) => {
-    queue.push({ filePath, resolve, reject })
-    processQueue()
-  })

package/src/photo-parser/image-size/index.js

@@ -1,2 +0,0 @@
-export { types } from './types'
-export { lookup as imageSize, disableTypes } from './lookup'

package/src/photo-parser/image-size/lookup.js

@@ -1,37 +0,0 @@
-import { typeHandlers } from './types/index'
-import { detector } from './detector'
-
-const globalOptions = {
-  disabledTypes: []
-}
-
-/**
- * Return size information based on an Uint8Array
- *
- * @param {Uint8Array} input
- * @returns {ISizeCalculationResult}
- */
-export function lookup (input) {
-  // detect the file type... don't rely on the extension
-  const type = detector(input)
-
-  if (typeof type !== 'undefined') {
-    if (globalOptions.disabledTypes.indexOf(type) > -1) {
-      throw new TypeError('disabled file type: ' + type)
-    }
-
-    // find an appropriate handler for this file type
-    const size = typeHandlers.get(type).calculate(input)
-    if (size !== undefined) {
-      size.type = size.type ?? type
-      return size
-    }
-  }
-
-  // throw up, if we don't understand the file
-  throw new TypeError('unsupported file type: ' + type)
-}
-
-export const disableTypes = (types) => {
-  globalOptions.disabledTypes = types
-}

package/src/photo-parser/image-size/types/bmp.js

@@ -1,10 +0,0 @@
-import { toUTF8String, readInt32LE, readUInt32LE } from './utils'
-
-export const BMP = {
-  validate: (input) => toUTF8String(input, 0, 2) === 'BM',
-
-  calculate: (input) => ({
-    height: Math.abs(readInt32LE(input, 22)),
-    width: readUInt32LE(input, 18)
-  })
-}

package/src/photo-parser/image-size/types/cur.js

@@ -1,16 +0,0 @@
-import { ICO } from './ico'
-import { readUInt16LE } from './utils'
-
-const TYPE_CURSOR = 2
-export const CUR = {
-  validate (input) {
-    const reserved = readUInt16LE(input, 0)
-    const imageCount = readUInt16LE(input, 4)
-    if (reserved !== 0 || imageCount === 0) return false
-
-    const imageType = readUInt16LE(input, 2)
-    return imageType === TYPE_CURSOR
-  },
-
-  calculate: (input) => ICO.calculate(input)
-}

package/src/photo-parser/image-size/types/dds.js

@@ -1,10 +0,0 @@
-import { readUInt32LE } from './utils'
-
-export const DDS = {
-  validate: (input) => readUInt32LE(input, 0) === 0x20534444,
-
-  calculate: (input) => ({
-    height: readUInt32LE(input, 12),
-    width: readUInt32LE(input, 16)
-  })
-}

package/src/photo-parser/image-size/types/gif.js

@@ -1,11 +0,0 @@
-import { toUTF8String, readUInt16LE } from './utils'
-
-const gifRegexp = /^GIF8[79]a/
-export const GIF = {
-  validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),
-
-  calculate: (input) => ({
-    height: readUInt16LE(input, 8),
-    width: readUInt16LE(input, 6)
-  })
-}

package/src/photo-parser/image-size/types/heif.js

@@ -1,35 +0,0 @@
-import { findBox, readUInt32BE, toUTF8String } from './utils'
-
-const brandMap = {
-  avif: 'avif',
-  mif1: 'heif',
-  msf1: 'heif', // hief-sequence
-  heic: 'heic',
-  heix: 'heic',
-  hevc: 'heic', // heic-sequence
-  hevx: 'heic' // heic-sequence
-}
-
-export const HEIF = {
-  validate (buffer) {
-    const ftype = toUTF8String(buffer, 4, 8)
-    const brand = toUTF8String(buffer, 8, 12)
-    return 'ftyp' === ftype && brand in brandMap
-  },
-
-  calculate (buffer) {
-    // Based on https://nokiatech.github.io/heif/technical.html
-    const metaBox = findBox(buffer, 'meta', 0)
-    const iprpBox = metaBox && findBox(buffer, 'iprp', metaBox.offset + 12)
-    const ipcoBox = iprpBox && findBox(buffer, 'ipco', iprpBox.offset + 8)
-    const ispeBox = ipcoBox && findBox(buffer, 'ispe', ipcoBox.offset + 8)
-    if (ispeBox) {
-      return {
-        height: readUInt32BE(buffer, ispeBox.offset + 16),
-        width: readUInt32BE(buffer, ispeBox.offset + 12),
-        type: toUTF8String(buffer, 8, 12)
-      }
-    }
-    throw new TypeError('Invalid HEIF, no size found')
-  }
-}

package/src/photo-parser/image-size/types/icns.js

@@ -1,112 +0,0 @@
-import { toUTF8String, readUInt32BE } from './utils'
-
-/**
- * ICNS Header
- *
- * | Offset | Size | Purpose                                                |
- * | 0	    | 4    | Magic literal, must be "icns" (0x69, 0x63, 0x6e, 0x73) |
- * | 4      | 4    | Length of file, in bytes, msb first.                   |
- *
- */
-const SIZE_HEADER = 4 + 4 // 8
-const FILE_LENGTH_OFFSET = 4 // MSB => BIG ENDIAN
-
-/**
- * Image Entry
- *
- * | Offset | Size | Purpose                                                          |
- * | 0	    | 4    | Icon type, see OSType below.                                     |
- * | 4      | 4    | Length of data, in bytes (including type and length), msb first. |
- * | 8      | n    | Icon data                                                        |
- */
-const ENTRY_LENGTH_OFFSET = 4 // MSB => BIG ENDIAN
-
-const ICON_TYPE_SIZE = {
-  ICON: 32,
-  'ICN#': 32,
-  // m => 16 x 16
-  'icm#': 16,
-  icm4: 16,
-  icm8: 16,
-  // s => 16 x 16
-  'ics#': 16,
-  ics4: 16,
-  ics8: 16,
-  is32: 16,
-  s8mk: 16,
-  icp4: 16,
-  // l => 32 x 32
-  icl4: 32,
-  icl8: 32,
-  il32: 32,
-  l8mk: 32,
-  icp5: 32,
-  ic11: 32,
-  // h => 48 x 48
-  ich4: 48,
-  ich8: 48,
-  ih32: 48,
-  h8mk: 48,
-  // . => 64 x 64
-  icp6: 64,
-  ic12: 32,
-  // t => 128 x 128
-  it32: 128,
-  t8mk: 128,
-  ic07: 128,
-  // . => 256 x 256
-  ic08: 256,
-  ic13: 256,
-  // . => 512 x 512
-  ic09: 512,
-  ic14: 512,
-  // . => 1024 x 1024
-  ic10: 1024
-}
-
-function readImageHeader (
-  input,
-  imageOffset
-) {
-  const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET
-  return [
-    toUTF8String(input, imageOffset, imageLengthOffset),
-    readUInt32BE(input, imageLengthOffset)
-  ]
-}
-
-function getImageSize (type) {
-  const size = ICON_TYPE_SIZE[type]
-  return { width: size, height: size, type }
-}
-
-export const ICNS = {
-  validate: (input) => toUTF8String(input, 0, 4) === 'icns',
-
-  calculate (input) {
-    const inputLength = input.length
-    const fileLength = readUInt32BE(input, FILE_LENGTH_OFFSET)
-    let imageOffset = SIZE_HEADER
-
-    let imageHeader = readImageHeader(input, imageOffset)
-    let imageSize = getImageSize(imageHeader[0])
-    imageOffset += imageHeader[1]
-
-    if (imageOffset === fileLength) return imageSize
-
-    const result = {
-      height: imageSize.height,
-      images: [imageSize],
-      width: imageSize.width
-    }
-
-    while (imageOffset < fileLength && imageOffset < inputLength) {
-      imageHeader = readImageHeader(input, imageOffset)
-      imageSize = getImageSize(imageHeader[0])
-      imageOffset += imageHeader[1]
-      result.images.push(imageSize)
-    }
-
-    return result
-  }
-}

package/src/photo-parser/image-size/types/ico.js

@@ -1,74 +0,0 @@
-import { readUInt16LE } from './utils'
-
-const TYPE_ICON = 1
-
-/**
- * ICON Header
- *
- * | Offset | Size | Purpose |
- * | 0	    | 2    | Reserved. Must always be 0.  |
- * | 2      | 2    | Image type: 1 for icon (.ICO) image, 2 for cursor (.CUR) image. Other values are invalid. |
- * | 4      | 2    | Number of images in the file. |
- *
- */
-const SIZE_HEADER = 2 + 2 + 2 // 6
-
-/**
- * Image Entry
- *
- * | Offset | Size | Purpose |
- * | 0	    | 1    | Image width in pixels. Can be any number between 0 and 255. Value 0 means width is 256 pixels. |
- * | 1      | 1    | Image height in pixels. Can be any number between 0 and 255. Value 0 means height is 256 pixels. |
- * | 2      | 1    | Number of colors in the color palette. Should be 0 if the image does not use a color palette. |
- * | 3      | 1    | Reserved. Should be 0. |
- * | 4      | 2    | ICO format: Color planes. Should be 0 or 1. |
- * |        |      | CUR format: The horizontal coordinates of the hotspot in number of pixels from the left. |
- * | 6      | 2    | ICO format: Bits per pixel. |
- * |        |      | CUR format: The vertical coordinates of the hotspot in number of pixels from the top. |
- * | 8      | 4    | The size of the image's data in bytes |
- * | 12     | 4    | The offset of BMP or PNG data from the beginning of the ICO/CUR file |
- *
- */
-const SIZE_IMAGE_ENTRY = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4 // 16
-
-function getSizeFromOffset (input, offset) {
-  const value = input[offset]
-  return value === 0 ? 256 : value
-}
-
-function getImageSize (input, imageIndex) {
-  const offset = SIZE_HEADER + imageIndex * SIZE_IMAGE_ENTRY
-  return {
-    height: getSizeFromOffset(input, offset + 1),
-    width: getSizeFromOffset(input, offset)
-  }
-}
-
-export const ICO = {
-  validate (input) {
-    const reserved = readUInt16LE(input, 0)
-    const imageCount = readUInt16LE(input, 4)
-    if (reserved !== 0 || imageCount === 0) return false
-
-    const imageType = readUInt16LE(input, 2)
-    return imageType === TYPE_ICON
-  },
-
-  calculate (input) {
-    const nbImages = readUInt16LE(input, 4)
-    const imageSize = getImageSize(input, 0)
-
-    if (nbImages === 1) return imageSize
-
-    const imgs = [imageSize]
-    for (let imageIndex = 1; imageIndex < nbImages; imageIndex += 1) {
-      imgs.push(getImageSize(input, imageIndex))
-    }
-
-    return {
-      height: imageSize.height,
-      images: imgs,
-      width: imageSize.width
-    }
-  }
-}

package/src/photo-parser/image-size/types/index.js

@@ -1,43 +0,0 @@
-// load all available handlers explicitely for browserify support
-import { BMP } from './bmp'
-import { CUR } from './cur'
-import { DDS } from './dds'
-import { GIF } from './gif'
-import { HEIF } from './heif'
-import { ICNS } from './icns'
-import { ICO } from './ico'
-import { J2C } from './j2c'
-import { JP2 } from './jp2'
-import { JPG } from './jpg'
-import { KTX } from './ktx'
-import { PNG } from './png'
-import { PNM } from './pnm'
-import { PSD } from './psd'
-import { SVG } from './svg'
-import { TGA } from './tga'
-import { TIFF } from './tiff'
-import { WEBP } from './webp'
-
-export const typeHandlers = new Map([
-  ['bmp', BMP],
-  ['cur', CUR],
-  ['dds', DDS],
-  ['gif', GIF],
-  ['heif', HEIF],
-  ['icns', ICNS],
-  ['ico', ICO],
-  ['j2c', J2C],
-  ['jp2', JP2],
-  ['jpg', JPG],
-  ['ktx', KTX],
-  ['png', PNG],
-  ['pnm', PNM],
-  ['psd', PSD],
-  ['svg', SVG],
-  ['tga', TGA],
-  ['tiff', TIFF],
-  ['webp', WEBP]
-])
-
-
-export const types = Array.from(typeHandlers.keys())

package/src/photo-parser/image-size/types/j2c.js

@@ -1,11 +0,0 @@
-import { toHexString, readUInt32BE } from './utils'
-
-export const J2C = {
-  // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
-  validate: (input) => toHexString(input, 0, 4) === 'ff4fff51',
-
-  calculate: (input) => ({
-    height: readUInt32BE(input, 12),
-    width: readUInt32BE(input, 8)
-  })
-}

package/src/photo-parser/image-size/types/jp2.js

@@ -1,22 +0,0 @@
-import { readUInt32BE, findBox } from './utils'
-
-export const JP2 = {
-  validate (input) {
-    if (readUInt32BE(input, 4) !== 0x6a502020 || readUInt32BE(input, 0) < 1) return false
-    const ftypBox = findBox(input, 'ftyp', 0)
-    if (!ftypBox) return false
-    return readUInt32BE(input, ftypBox.offset + 4) === 0x66747970
-  },
-
-  calculate (input) {
-    const jp2hBox = findBox(input, 'jp2h', 0)
-    const ihdrBox = jp2hBox && findBox(input, 'ihdr', jp2hBox.offset + 8)
-    if (ihdrBox) {
-      return {
-        height: readUInt32BE(input, ihdrBox.offset + 8),
-        width: readUInt32BE(input, ihdrBox.offset + 12)
-      }
-    }
-    throw new TypeError('Unsupported JPEG 2000 format')
-  }
-}

package/src/photo-parser/image-size/types/jpg.js

@@ -1,157 +0,0 @@
-// NOTE: we only support baseline and progressive JPGs here
-// due to the structure of the loader class, we only get a buffer
-// with a maximum size of 4096 bytes. so if the SOF marker is outside
-// if this range we can't detect the file size correctly.
-import { readUInt, readUInt16BE, toHexString } from './utils'
-
-const EXIF_MARKER = '45786966'
-const APP1_DATA_SIZE_BYTES = 2
-const EXIF_HEADER_BYTES = 6
-const TIFF_BYTE_ALIGN_BYTES = 2
-const BIG_ENDIAN_BYTE_ALIGN = '4d4d'
-const LITTLE_ENDIAN_BYTE_ALIGN = '4949'
-
-// Each entry is exactly 12 bytes
-const IDF_ENTRY_BYTES = 12
-const NUM_DIRECTORY_ENTRIES_BYTES = 2
-
-function isEXIF (input) {
-  return toHexString(input, 2, 6) === EXIF_MARKER
-}
-
-function extractSize (input, index) {
-  return {
-    height: readUInt16BE(input, index),
-    width: readUInt16BE(input, index + 2)
-  }
-}
-
-function extractOrientation (exifBlock, isBigEndian) {
-  // TODO: assert that this contains 0x002A
-  // let STATIC_MOTOROLA_TIFF_HEADER_BYTES = 2
-  // let TIFF_IMAGE_FILE_DIRECTORY_BYTES = 4
-
-  // TODO: derive from TIFF_IMAGE_FILE_DIRECTORY_BYTES
-  const idfOffset = 8
-
-  // IDF osset works from right after the header bytes
-  // (so the offset includes the tiff byte align)
-  const offset = EXIF_HEADER_BYTES + idfOffset
-
-  const idfDirectoryEntries = readUInt(exifBlock, 16, offset, isBigEndian)
-
-  for (
-    let directoryEntryNumber = 0;
-    directoryEntryNumber < idfDirectoryEntries;
-    directoryEntryNumber++
-  ) {
-    const start =
-      offset +
-      NUM_DIRECTORY_ENTRIES_BYTES +
-      directoryEntryNumber * IDF_ENTRY_BYTES
-    const end = start + IDF_ENTRY_BYTES
-
-    // Skip on corrupt EXIF blocks
-    if (start > exifBlock.length) {
-      return
-    }
-
-    const block = exifBlock.slice(start, end)
-    const tagNumber = readUInt(block, 16, 0, isBigEndian)
-
-    // 0x0112 (decimal: 274) is the `orientation` tag ID
-    if (tagNumber === 274) {
-      const dataFormat = readUInt(block, 16, 2, isBigEndian)
-      if (dataFormat !== 3) {
-        return
-      }
-
-      // unsinged int has 2 bytes per component
-      // if there would more than 4 bytes in total it's a pointer
-      const numberOfComponents = readUInt(block, 32, 4, isBigEndian)
-      if (numberOfComponents !== 1) {
-        return
-      }
-
-      return readUInt(block, 16, 8, isBigEndian)
-    }
-  }
-}
-
-function validateExifBlock (input, index) {
-  // Skip APP1 Data Size
-  const exifBlock = input.slice(APP1_DATA_SIZE_BYTES, index)
-
-  // Consider byte alignment
-  const byteAlign = toHexString(
-    exifBlock,
-    EXIF_HEADER_BYTES,
-    EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES
-  )
-
-  // Ignore Empty EXIF. Validate byte alignment
-  const isBigEndian = byteAlign === BIG_ENDIAN_BYTE_ALIGN
-  const isLittleEndian = byteAlign === LITTLE_ENDIAN_BYTE_ALIGN
-
-  if (isBigEndian || isLittleEndian) {
-    return extractOrientation(exifBlock, isBigEndian)
-  }
-}
-
-function validateInput (input, index) {
-  // index should be within buffer limits
-  if (index > input.length) {
-    throw new TypeError('Corrupt JPG, exceeded buffer limits')
-  }
-  // Every JPEG block must begin with a 0xFF
-  if (input[index] !== 0xff) {
-    throw new TypeError('Invalid JPG, marker table corrupted')
-  }
-}
-
-export const JPG = {
-  validate: (input) => toHexString(input, 0, 2) === 'ffd8',
-
-  calculate (input) {
-    // Skip 4 chars, they are for signature
-    input = input.slice(4)
-
-    let orientation
-    let next
-    while (input.length) {
-      // read length of the next block
-      const i = readUInt16BE(input, 0)
-
-      if (isEXIF(input)) {
-        orientation = validateExifBlock(input, i)
-      }
-
-      // ensure correct format
-      validateInput(input, i)
-
-      // 0xFFC0 is baseline standard(SOF)
-      // 0xFFC1 is baseline optimized(SOF)
-      // 0xFFC2 is progressive(SOF2)
-      next = input[i + 1]
-      if (next === 0xc0 || next === 0xc1 || next === 0xc2) {
-        const size = extractSize(input, i + 5)
-
-        // TODO: is orientation=0 a valid answer here?
-        if (!orientation) {
-          return size
-        }
-
-        return {
-          height: size.height,
-          orientation,
-          width: size.width
-        }
-      }
-
-      // move to the next block
-      input = input.slice(i + 2)
-    }
-
-    throw new TypeError('Invalid JPG, no size found')
-  }
-}

package/src/photo-parser/image-size/types/ktx.js

@@ -1,18 +0,0 @@
-import { toUTF8String, readUInt32LE } from './utils'
-
-export const KTX = {
-  validate: (input) => {
-    const signature = toUTF8String(input, 1, 7)
-    return ['KTX 11', 'KTX 20'].includes(signature)
-  },
-
-  calculate: (input) => {
-    const type = input[5] === 0x31 ? 'ktx' : 'ktx2'
-    const offset = type === 'ktx' ? 36 : 20
-    return ({
-      height: readUInt32LE(input, offset + 4),
-      width: readUInt32LE(input, offset),
-      type
-    })
-  }
-}

package/src/photo-parser/image-size/types/png.js

@@ -1,36 +0,0 @@
-import { toUTF8String, readUInt32BE } from './utils'
-
-const pngSignature = 'PNG\r\n\x1a\n'
-const pngImageHeaderChunkName = 'IHDR'
-
-// Used to detect "fried" png's: http://www.jongware.com/pngdefry.html
-const pngFriedChunkName = 'CgBI'
-
-export const PNG = {
-  validate (input) {
-    if (pngSignature === toUTF8String(input, 1, 8)) {
-      let chunkName = toUTF8String(input, 12, 16)
-      if (chunkName === pngFriedChunkName) {
-        chunkName = toUTF8String(input, 28, 32)
-      }
-      if (chunkName !== pngImageHeaderChunkName) {
-        throw new TypeError('Invalid PNG')
-      }
-      return true
-    }
-    return false
-  },
-
-  calculate (input) {
-    if (toUTF8String(input, 12, 16) === pngFriedChunkName) {
-      return {
-        height: readUInt32BE(input, 36),
-        width: readUInt32BE(input, 32)
-      }
-    }
-    return {
-      height: readUInt32BE(input, 20),
-      width: readUInt32BE(input, 16)
-    }
-  }
-}