@mapcatch/util 1.0.15 → 2.0.0

package/src/photo-parser/exif/util.js

@@ -0,0 +1,103 @@
+export default {
+  imageHasData (img) {
+    return !!(img.exifdata)
+  },
+  getStringFromDB (buffer, start, length) {
+    var outstr = ''
+    for (var n = start; n < start + length; n++) {
+      outstr += String.fromCharCode(buffer.getUint8(n))
+    }
+    return outstr
+  },
+  xml2Object (xml) {
+    var obj = {}
+    if (xml.childNodes.length > 0) {
+      for (var i = 0; i < xml.childNodes.length; i++) {
+        var item = xml.childNodes[i]
+        var attributes = item.attributes
+        for (var idx in attributes) {
+          var itemAtt = attributes[idx]
+          var dataKey = itemAtt.nodeName
+          var dataValue = itemAtt.nodeValue
+
+          if (dataKey !== undefined) {
+            obj[dataKey] = dataValue
+          }
+        }
+        var nodeName = item.nodeName
+
+        if (obj[nodeName] == null || typeof (obj[nodeName]) == 'undefined') {
+          obj[nodeName] = this.xml2json(item)
+        } else {
+          if (typeof (obj[nodeName].push) == 'undefined') {
+            var old = obj[nodeName]
+
+            obj[nodeName] = []
+            obj[nodeName].push(old)
+          }
+          obj[nodeName].push(this.xml2json(item))
+        }
+      }
+    } else {
+      obj = xml.textContent
+    }
+    return obj
+  },
+  xml2json (xml) {
+    var json = {}
+
+    if (xml.nodeType == 1) { // element node
+      if (xml.attributes.length > 0) {
+        json['@attributes'] = {}
+        for (var j = 0; j < xml.attributes.length; j++) {
+          var attribute = xml.attributes.item(j)
+          json['@attributes'][attribute.nodeName] = attribute.nodeValue
+        }
+      }
+    } else if (xml.nodeType == 3) { // text node
+      return xml.nodeValue
+    }
+
+    // deal with children
+    if (xml.hasChildNodes()) {
+      for (var i = 0; i < xml.childNodes.length; i++) {
+        var child = xml.childNodes.item(i)
+        var nodeName = child.nodeName
+        if (json[nodeName] == null) {
+          json[nodeName] = this.xml2json(child)
+        } else {
+          if (json[nodeName].push == null) {
+            var old = json[nodeName]
+            json[nodeName] = []
+            json[nodeName].push(old)
+          }
+          json[nodeName].push(this.xml2json(child))
+        }
+      }
+    }
+
+    return json
+  },
+  objectURLToBlob (url, callback) {
+    var http = new XMLHttpRequest()
+    http.open('GET', url, true)
+    http.responseType = 'blob'
+    http.onload = function () {
+      if (this.status == 200 || this.status === 0) {
+        callback(this.response)
+      }
+    }
+    http.send()
+  },
+  base64ToArrayBuffer (base64) {
+    base64 = base64.replace(/^data:([^;]+);base64,/gmi, '')
+    var binary = atob(base64)
+    var len = binary.length
+    var buffer = new ArrayBuffer(len)
+    var view = new Uint8Array(buffer)
+    for (var i = 0; i < len; i++) {
+      view[i] = binary.charCodeAt(i)
+    }
+    return buffer
+  }
+}

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

@@ -0,0 +1,24 @@
+import { typeHandlers, types } from './types/index'
+
+// This map helps avoid validating for every single image type
+const firstBytes = new Map([
+  [0x38, 'psd'],
+  [0x42, 'bmp'],
+  [0x44, 'dds'],
+  [0x47, 'gif'],
+  [0x49, 'tiff'],
+  [0x4d, 'tiff'],
+  [0x52, 'webp'],
+  [0x69, 'icns'],
+  [0x89, 'png'],
+  [0xff, 'jpg']
+])
+
+export function detector (input) {
+  const byte = input[0]
+  const type = firstBytes.get(byte)
+  if (type && typeHandlers.get(type).validate(input)) {
+    return type
+  }
+  return types.find((type) => typeHandlers.get(type).validate(input))
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+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')
+  }
+}