@mapcatch/util 1.0.9 → 1.0.10

package/src/exif/string_values.js

@@ -1,137 +0,0 @@
-export default {
-  ExposureProgram: {
-    0: "Not defined",
-    1: "Manual",
-    2: "Normal program",
-    3: "Aperture priority",
-    4: "Shutter priority",
-    5: "Creative program",
-    6: "Action program",
-    7: "Portrait mode",
-    8: "Landscape mode"
-  },
-  MeteringMode: {
-    0: "Unknown",
-    1: "Average",
-    2: "CenterWeightedAverage",
-    3: "Spot",
-    4: "MultiSpot",
-    5: "Pattern",
-    6: "Partial",
-    255: "Other"
-  },
-  LightSource: {
-    0: "Unknown",
-    1: "Daylight",
-    2: "Fluorescent",
-    3: "Tungsten (incandescent light)",
-    4: "Flash",
-    9: "Fine weather",
-    10: "Cloudy weather",
-    11: "Shade",
-    12: "Daylight fluorescent (D 5700 - 7100K)",
-    13: "Day white fluorescent (N 4600 - 5400K)",
-    14: "Cool white fluorescent (W 3900 - 4500K)",
-    15: "White fluorescent (WW 3200 - 3700K)",
-    17: "Standard light A",
-    18: "Standard light B",
-    19: "Standard light C",
-    20: "D55",
-    21: "D65",
-    22: "D75",
-    23: "D50",
-    24: "ISO studio tungsten",
-    255: "Other"
-  },
-  Flash: {
-    0x0000: "Flash did not fire",
-    0x0001: "Flash fired",
-    0x0005: "Strobe return light not detected",
-    0x0007: "Strobe return light detected",
-    0x0009: "Flash fired, compulsory flash mode",
-    0x000D: "Flash fired, compulsory flash mode, return light not detected",
-    0x000F: "Flash fired, compulsory flash mode, return light detected",
-    0x0010: "Flash did not fire, compulsory flash mode",
-    0x0018: "Flash did not fire, auto mode",
-    0x0019: "Flash fired, auto mode",
-    0x001D: "Flash fired, auto mode, return light not detected",
-    0x001F: "Flash fired, auto mode, return light detected",
-    0x0020: "No flash function",
-    0x0041: "Flash fired, red-eye reduction mode",
-    0x0045: "Flash fired, red-eye reduction mode, return light not detected",
-    0x0047: "Flash fired, red-eye reduction mode, return light detected",
-    0x0049: "Flash fired, compulsory flash mode, red-eye reduction mode",
-    0x004D: "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected",
-    0x004F: "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected",
-    0x0059: "Flash fired, auto mode, red-eye reduction mode",
-    0x005D: "Flash fired, auto mode, return light not detected, red-eye reduction mode",
-    0x005F: "Flash fired, auto mode, return light detected, red-eye reduction mode"
-  },
-  SensingMethod: {
-    1: "Not defined",
-    2: "One-chip color area sensor",
-    3: "Two-chip color area sensor",
-    4: "Three-chip color area sensor",
-    5: "Color sequential area sensor",
-    7: "Trilinear sensor",
-    8: "Color sequential linear sensor"
-  },
-  SceneCaptureType: {
-    0: "Standard",
-    1: "Landscape",
-    2: "Portrait",
-    3: "Night scene"
-  },
-  SceneType: {
-    1: "Directly photographed"
-  },
-  CustomRendered: {
-    0: "Normal process",
-    1: "Custom process"
-  },
-  WhiteBalance: {
-    0: "Auto white balance",
-    1: "Manual white balance"
-  },
-  GainControl: {
-    0: "None",
-    1: "Low gain up",
-    2: "High gain up",
-    3: "Low gain down",
-    4: "High gain down"
-  },
-  Contrast: {
-    0: "Normal",
-    1: "Soft",
-    2: "Hard"
-  },
-  Saturation: {
-    0: "Normal",
-    1: "Low saturation",
-    2: "High saturation"
-  },
-  Sharpness: {
-    0: "Normal",
-    1: "Soft",
-    2: "Hard"
-  },
-  SubjectDistanceRange: {
-    0: "Unknown",
-    1: "Macro",
-    2: "Close view",
-    3: "Distant view"
-  },
-  FileSource: {
-    3: "DSC"
-  },
-
-  Components: {
-    0: "",
-    1: "Y",
-    2: "Cb",
-    3: "Cr",
-    4: "R",
-    5: "G",
-    6: "B"
-  }
-};

package/src/exif/tags.js

@@ -1,75 +0,0 @@
-export default {
-
-  // version tags
-  0x9000: "ExifVersion",             // EXIF version
-  0xA000: "FlashpixVersion",         // Flashpix format version
-
-  // colorspace tags
-  0xA001: "ColorSpace",              // Color space information tag
-
-  // image configuration
-  0xA002: "PixelXDimension",         // Valid width of meaningful image
-  0xA003: "PixelYDimension",         // Valid height of meaningful image
-  0x9101: "ComponentsConfiguration", // Information about channels
-  0x9102: "CompressedBitsPerPixel",  // Compressed bits per pixel
-
-  // user information
-  //0x927C: "MakerNote",               // Any desired information written by the manufacturer
-  //0x9286: "UserComment",             // Comments by user
-
-  // related file
-  0xA004: "RelatedSoundFile",        // Name of related sound file
-
-  // date and time
-  0x9003: "DateTimeOriginal",        // Date and time when the original image was generated
-  0x9004: "DateTimeDigitized",       // Date and time when the image was stored digitally
-  0x9290: "SubsecTime",              // Fractions of seconds for DateTime
-  0x9291: "SubsecTimeOriginal",      // Fractions of seconds for DateTimeOriginal
-  0x9292: "SubsecTimeDigitized",     // Fractions of seconds for DateTimeDigitized
-
-  // picture-taking conditions
-  0x829A: "ExposureTime",            // Exposure time (in seconds)
-  0x829D: "FNumber",                 // F number
-  0x8822: "ExposureProgram",         // Exposure program
-  0x8824: "SpectralSensitivity",     // Spectral sensitivity
-  0x8827: "ISOSpeedRatings",         // ISO speed rating
-  0x8828: "OECF",                    // Optoelectric conversion factor
-  0x9201: "ShutterSpeedValue",       // Shutter speed
-  0x9202: "ApertureValue",           // Lens aperture
-  0x9203: "BrightnessValue",         // Value of brightness
-  0x9204: "ExposureBias",            // Exposure bias
-  0x9205: "MaxApertureValue",        // Smallest F number of lens
-  0x9206: "SubjectDistance",         // Distance to subject in meters
-  0x9207: "MeteringMode",            // Metering mode
-  0x9208: "LightSource",             // Kind of light source
-  0x9209: "Flash",                   // Flash status
-  0x9214: "SubjectArea",             // Location and area of main subject
-  0x920A: "FocalLength",             // Focal length of the lens in mm
-  0xA20B: "FlashEnergy",             // Strobe energy in BCPS
-  0xA20C: "SpatialFrequencyResponse",    //
-  0xA20E: "FocalPlaneXResolution",   // Number of pixels in width direction per FocalPlaneResolutionUnit
-  0xA20F: "FocalPlaneYResolution",   // Number of pixels in height direction per FocalPlaneResolutionUnit
-  0xA210: "FocalPlaneResolutionUnit",    // Unit for measuring FocalPlaneXResolution and FocalPlaneYResolution
-  0xA214: "SubjectLocation",         // Location of subject in image
-  0xA215: "ExposureIndex",           // Exposure index selected on camera
-  0xA217: "SensingMethod",           // Image sensor type
-  0xA300: "FileSource",              // Image source (3 == DSC)
-  0xA301: "SceneType",               // Scene type (1 == directly photographed)
-  0xA302: "CFAPattern",              // Color filter array geometric pattern
-  0xA401: "CustomRendered",          // Special processing
-  0xA402: "ExposureMode",            // Exposure mode
-  0xA403: "WhiteBalance",            // 1 = auto white balance, 2 = manual
-  0xA404: "DigitalZoomRation",       // Digital zoom ratio
-  0xA405: "FocalLengthIn35mmFilm",   // Equivalent foacl length assuming 35mm film camera (in mm)
-  0xA406: "SceneCaptureType",        // Type of scene
-  0xA407: "GainControl",             // Degree of overall image gain adjustment
-  0xA408: "Contrast",                // Direction of contrast processing applied by camera
-  0xA409: "Saturation",              // Direction of saturation processing applied by camera
-  0xA40A: "Sharpness",               // Direction of sharpness processing applied by camera
-  0xA40B: "DeviceSettingDescription",    //
-  0xA40C: "SubjectDistanceRange",    // Distance to subject
-
-  // other tags
-  0xA005: "InteroperabilityIFDPointer",
-  0xA420: "ImageUniqueID"            // Identifier assigned uniquely to each image
-};

package/src/exif/tiff_tags.js

@@ -1,35 +0,0 @@
-export default {
-  0x0100: "ImageWidth",
-  0x0101: "ImageHeight",
-  0x8769: "ExifIFDPointer",
-  0x8825: "GPSInfoIFDPointer",
-  0xA005: "InteroperabilityIFDPointer",
-  0x0102: "BitsPerSample",
-  0x0103: "Compression",
-  0x0106: "PhotometricInterpretation",
-  0x0112: "Orientation",
-  0x0115: "SamplesPerPixel",
-  0x011C: "PlanarConfiguration",
-  0x0212: "YCbCrSubSampling",
-  0x0213: "YCbCrPositioning",
-  0x011A: "XResolution",
-  0x011B: "YResolution",
-  0x0128: "ResolutionUnit",
-  0x0111: "StripOffsets",
-  0x0116: "RowsPerStrip",
-  0x0117: "StripByteCounts",
-  0x0201: "JPEGInterchangeFormat",
-  0x0202: "JPEGInterchangeFormatLength",
-  0x012D: "TransferFunction",
-  0x013E: "WhitePoint",
-  0x013F: "PrimaryChromaticities",
-  0x0211: "YCbCrCoefficients",
-  0x0214: "ReferenceBlackWhite",
-  0x0132: "DateTime",
-  0x010E: "ImageDescription",
-  0x010F: "Make",
-  0x0110: "Model",
-  0x0131: "Software",
-  0x013B: "Artist",
-  0x8298: "Copyright"
-};

package/src/exif/util.js

@@ -1,108 +0,0 @@
-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) {
-    try {
-      var obj = {};
-      if (xml.children.length > 0) {
-        for (var i = 0; i < xml.children.length; i++) {
-          var item = xml.children.item(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 (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;
-    } catch (e) {
-      console.log(e.message);
-    }
-  },
-  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 (e) {
-      if (this.status == 200 || this.status === 0) {
-        callback(this.response);
-      }
-    };
-    http.send();
-  },
-  base64ToArrayBuffer(base64, contentType) {
-    contentType = contentType || base64.match(/^data\:([^\;]+)\;base64,/mi)[1] || ''; // e.g. 'data:image/jpeg;base64,...' => 'image/jpeg'
-    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/image-size/detector.js

@@ -1,24 +0,0 @@
-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/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/image-size/index.js

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

package/src/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/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/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/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/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/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/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
-  },
-}