{"version":3,"file":"scripts.js","mappings":"YAEA,IAAAA,GAAA,EAIAC,EAAA,SAAAC,GACA,OAAAA,aAAAD,EAAAC,EACAC,gBAAAF,OACAE,KAAAC,YAAAF,GADA,IAAAD,EAAAC,EAEA,SAEAG,QAAA,YACAC,OAAA,KAAAA,OAAAD,UACAA,QAAAC,OAAAD,QAAAJ,GAEAI,QAAAJ,QAZAE,KAcAF,OAGA,IAAAM,EAAAN,EAAAO,KAAA,CAGA,oBACA,wBAGA,mBAGA,wBACA,wBACA,gCACA,+BAGA,kBACA,oBAGA,yBAGA,yBACA,0BACA,mBACA,2BACA,4BAGA,qBACA,gBACA,wBACA,4BACA,wBACA,aACA,0BACA,sBACA,wBACA,qBACA,yBACA,wBACA,qBACA,oBACA,cACA,oBACA,oBACA,oBACA,iCACA,8BACA,8BACA,iCACA,wBACA,sBACA,sBACA,mBACA,kBACA,mBACA,uBACA,qBACA,qBACA,0BACA,8BACA,yBACA,oBACA,iBACA,mBACA,kBACA,iCACA,6BAGA,mCACA,uBAGAC,EAAAR,EAAAQ,SAAA,CACA,iBACA,kBACA,uBACA,0BACA,mCACA,oBACA,kBACA,gCACA,kBACA,sBACA,0BACA,uBACA,uBACA,kBACA,kBACA,qBACA,mBACA,mBACA,sBACA,4BACA,kCACA,uBACA,iBACA,4BACA,wBACA,0BACA,eACA,uBACA,WACA,YACA,eACA,aACA,mBAGAC,EAAAT,EAAAS,QAAA,CACA,iBACA,mBACA,gBACA,oBACA,iBACA,mBACA,gBACA,iBACA,kBACA,cACA,oBACA,YACA,iBACA,cACA,iBACA,cACA,wBACA,qBACA,iBACA,wBACA,qBACA,yBACA,sBACA,uBACA,oBACA,wBACA,qBACA,yBACA,wBACA,kBACA,sBAIAC,EAAAV,EAAAU,SAAA,CACA,iBACA,kBACA,oBACA,kBACA,gCACA,mBACA,kBACA,sBACA,mBACA,sBACA,kBACA,kBACA,0BACA,qBACA,mBACA,sBACA,wBACA,uBACA,uBACA,2BAGAC,EAAAX,EAAAW,aAAA,CACAC,gBAAA,CACA,gBACA,WACA,mBACA,sBACA,qBACA,qBACA,mB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","names":["debug","EXIF","obj","this","EXIFwrapped","exports","module","ExifTags","Tags","TiffTags","GPSTags","IFD1Tags","StringValues","ExposureProgram","MeteringMode","LightSource","Flash","SensingMethod","SceneCaptureType","SceneType","CustomRendered","WhiteBalance","GainControl","Contrast","Saturation","Sharpness","SubjectDistanceRange","FileSource","Components","imageHasData","img","exifdata","findEXIFinJPEG","file","dataView","DataView","console","log","byteLength","getUint8","marker","offset","length","readEXIFData","getUint16","IptcFieldMap","readIPTCData","startOffset","sectionLength","fieldValue","fieldName","dataSize","segmentType","data","segmentStartPos","getInt16","getStringFromDB","hasOwnProperty","Array","push","readTags","tiffStart","dirStart","strings","bigEnd","entryOffset","tag","i","entries","tags","readTagValue","vals","val","n","numerator","denominator","type","numValues","getUint32","valueOffset","Number","getInt32","buffer","start","outstr","String","fromCharCode","exifData","gpsData","tiffOffset","firstIFDOffset","ExifIFDPointer","GPSInfoIFDPointer","thumbnail","readThumbnailImage","IFD1OffsetPointer","getNextIFDOffset","thumbTags","Compression","JpegIFOffset","JpegIFByteCount","blob","Blob","Uint8Array","PhotometricInterpretation","xml2json","xml","json","nodeType","attributes","j","attribute","item","nodeName","nodeValue","hasChildNodes","childNodes","child","old","xml2Object","children","idx","itemAtt","dataKey","textContent","e","message","enableXmp","isXmpEnabled","disableXmp","getData","callback","self","Image","HTMLImageElement","complete","call","getImageData","handleBinaryFile","binFile","iptcdata","findIPTCinJPEG","isFieldSegmentStart","nameHeaderLength","xmpdata","findXMPinJPEG","dom","DOMParser","xmpString","xmpEndIndex","indexOf","indexOfXmp","substring","slice","parseFromString","src","test","arrayBuffer","base64ToArrayBuffer","base64","contentType","match","replace","binary","atob","len","ArrayBuffer","view","charCodeAt","fileReader","FileReader","onload","target","result","objectURLToBlob","url","http","XMLHttpRequest","open","responseType","status","response","send","readAsArrayBuffer","File","getTag","getIptcTag","getAllTags","a","getAllIptcTags","pretty","strPretty","readFromBinaryFile","define","amd","f","window","global","pica","r","t","o","c","require","u","Error","code","p","_dereq_","inherits","Multimath","mm_unsharp_mask","mm_resize","MathLib","requested_features","__requested_features","features","js","wasm","has_wasm","use","prototype","resizeAndUnsharp","options","cache","resize","unsharpAmount","unsharp_mask","toWidth","toHeight","unsharpRadius","unsharpThreshold","multimath","clampTo8","convolveHorizontally","dest","srcW","srcH","destW","filters","g","b","filterPtr","filterShift","filterSize","srcPtr","srcY","destX","filterVal","srcOffset","destOffset","convolveVertically","name","fn","wasm_fn","wasm_src","createFilters","width","height","destH","scaleX","scaleY","offsetX","offsetY","quality","alpha","filtersX","filtersY","tmp","resetAlpha","dst","ptr","FILTER_INFO","toFixedPoint","num","Math","round","srcSize","destSize","scale","destPixel","srcPixel","srcFirst","srcLast","filterElementSize","floatFilter","fxpFilter","total","pxl","floatVal","filterTotal","leftNotEmpty","rightNotEmpty","filterFunction","filter","scaleInverted","scaleClamped","min","srcWindow","win","maxFilterElementSize","floor","packedFilter","Int16Array","packedFilterPtr","slowCopy","subarray","set","max","ceil","Float32Array","x","xpi","PI","sin","cos","IS_LE","Uint32Array","copyInt16asLE","target_offset","asUint8Array","tmp_offset","__align","filtersX_offset","filtersY_offset","instance","__instance","mem","__memory","mem32","src32","convolveHV","_convolveHV","Pool","create","idle","available","acquired","lastId","timeoutId","acquire","resource","_this","pop","id","release","_this2","lastUsed","Date","now","setTimeout","gc","_this3","destroy","fromWidth","fromHeight","srcTileSize","destTileBorder","minScale","stageCount","pow","PIXEL_EPSILON","pixelFloor","nearest","abs","pixelCeil","innerTileWidth","innerTileHeight","y","innerX","innerY","toTileWidth","toTileHeight","tile","tiles","toX","toY","toInnerX","toInnerY","toInnerWidth","toInnerHeight","objClass","Object","toString","isCanvas","element","cname","isImage","limiter","concurrency","active","queue","roll","shift","Promise","resolve","reject","then","err","cib_quality_name","cib_support","createImageBitmap","document","createElement","resizeWidth","resizeHeight","resizeQuality","bitmap","close","catch","mathLib","onmessage","ev","opts","postMessage","a0","a1","a2","a3","b1","b2","convolveMono16","out","line","coeff","prev_src","curr_src","curr_out","prev_out","prev_prev_out","src_index","out_index","line_index","coeff_a0","coeff_a1","coeff_b1","coeff_b2","blurMono16","radius","Uint16Array","tmp_line","gaussCoef","sigma","exp","g1","g2","k","ctor","superCtor","super_","constructor","value","enumerable","writable","configurable","TempCtor","assign","base64decode","hasWebAssembly","DEFAULT_OPTIONS","MultiMath","__cache","__init_promise","__modules","modules","__wasm","__isLE","init","all","keys","map","WebAssembly","compile","__base64decode","m","__reallocate","bytes","Memory","initial","mem_size","grow","memsize","env_extra","Module","env_base","memoryBase","memory","tableBase","table","Table","Instance","env","number","base","reminder","str","input","bits","charAt","tailbits","size","glur_mono16","hsl_l16","amount","threshold","h","s","l","m1","m2","hShifted","diff","iTimes4","lightness","blured","amountFp","thresholdFp","pixels","img_bytes_cnt","hsl_bytes_cnt","blur_bytes_cnt","blur_line_byte_cnt","hsl_offset","blur_offset","blur_tmp_offset","blur_line_offset","blur_coeffs_offset","img32","_hsl_l16","_blurMono16","unsharp","_unsharp","wa","bin","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","shouldUseNative","test1","getOwnPropertyNames","test2","join","test3","split","forEach","letter","source","from","symbols","to","toObject","TypeError","arguments","key","bundleFn","sources","stringify","JSON","wkey","cacheKeys","default","random","wcache","skey","scache","workerSources","resolveSources","depPath","depKey","URL","webkitURL","mozURL","msURL","bare","workerUrl","createObjectURL","worker","Worker","objectURL","_arrayLikeToArray","arr","arr2","webworkify","utils","createStages","createRegions","singletones","NEED_SAFARI_FIX","navigator","userAgent","hardwareConcurrency","CAN_NEW_IMAGE_DATA","CAN_CREATE_IMAGE_BITMAP","DEFAULT_PICA_OPTS","DEFAULT_RESIZE_OPTS","workerFabric","terminate","revokeObjectURL","Pica","limiter_key","concat","__limit","cib","ww","__workersPool","__mathlib","__initPromise","ImageData","Uint8ClampedArray","ImageBitmap","wpool_key","checkCibResize","initMath","mathlib","isNaN","naturalWidth","naturalHeight","canceled","cancelToken","toCtx","getContext","imageBitmap","drawImage","tmpCanvas","tmpCtx","iData","putImageData","tileAndResize","srcCtx","srcImageBitmap","jobs","srcImageData","globalCompositeOperation","w","preload","wasm_nodule","__","invokeResize","toImageData","createImageData","processTile","cleanup","processStages","stages","_stages$shift2","_slicedToArray","_arrayWithHoles","isArray","_iterableToArrayLimit","Symbol","iterator","_arr","_n","_d","_e","_s","_i","next","done","return","_unsupportedIterableToArray","minLen","_nonIterableRest","isLastStage","resizeBuffer","toBlob","canvas","mimeType","convertToBlob","asString","toDataURL","asBuffer"],"sourceRoot":"webpack:///","sources":["node_modules/exif-js/exif.js","node_modules/pica/dist/pica.js"],"sourcesContent":["(function() {\n\n    var debug = false;\n\n    var root = this;\n\n    var EXIF = function(obj) {\n        if (obj instanceof EXIF) return obj;\n        if (!(this instanceof EXIF)) return new EXIF(obj);\n        this.EXIFwrapped = obj;\n    };\n\n    if (typeof exports !== 'undefined') {\n        if (typeof module !== 'undefined' && module.exports) {\n            exports = module.exports = EXIF;\n        }\n        exports.EXIF = EXIF;\n    } else {\n        root.EXIF = EXIF;\n    }\n\n    var ExifTags = EXIF.Tags = {\n\n        // version tags\n        0x9000 : \"ExifVersion\",             // EXIF version\n        0xA000 : \"FlashpixVersion\",         // Flashpix format version\n\n        // colorspace tags\n        0xA001 : \"ColorSpace\",              // Color space information tag\n\n        // image configuration\n        0xA002 : \"PixelXDimension\",         // Valid width of meaningful image\n        0xA003 : \"PixelYDimension\",         // Valid height of meaningful image\n        0x9101 : \"ComponentsConfiguration\", // Information about channels\n        0x9102 : \"CompressedBitsPerPixel\",  // Compressed bits per pixel\n\n        // user information\n        0x927C : \"MakerNote\",               // Any desired information written by the manufacturer\n        0x9286 : \"UserComment\",             // Comments by user\n\n        // related file\n        0xA004 : \"RelatedSoundFile\",        // Name of related sound file\n\n        // date and time\n        0x9003 : \"DateTimeOriginal\",        // Date and time when the original image was generated\n        0x9004 : \"DateTimeDigitized\",       // Date and time when the image was stored digitally\n        0x9290 : \"SubsecTime\",              // Fractions of seconds for DateTime\n        0x9291 : \"SubsecTimeOriginal\",      // Fractions of seconds for DateTimeOriginal\n        0x9292 : \"SubsecTimeDigitized\",     // Fractions of seconds for DateTimeDigitized\n\n        // picture-taking conditions\n        0x829A : \"ExposureTime\",            // Exposure time (in seconds)\n        0x829D : \"FNumber\",                 // F number\n        0x8822 : \"ExposureProgram\",         // Exposure program\n        0x8824 : \"SpectralSensitivity\",     // Spectral sensitivity\n        0x8827 : \"ISOSpeedRatings\",         // ISO speed rating\n        0x8828 : \"OECF\",                    // Optoelectric conversion factor\n        0x9201 : \"ShutterSpeedValue\",       // Shutter speed\n        0x9202 : \"ApertureValue\",           // Lens aperture\n        0x9203 : \"BrightnessValue\",         // Value of brightness\n        0x9204 : \"ExposureBias\",            // Exposure bias\n        0x9205 : \"MaxApertureValue\",        // Smallest F number of lens\n        0x9206 : \"SubjectDistance\",         // Distance to subject in meters\n        0x9207 : \"MeteringMode\",            // Metering mode\n        0x9208 : \"LightSource\",             // Kind of light source\n        0x9209 : \"Flash\",                   // Flash status\n        0x9214 : \"SubjectArea\",             // Location and area of main subject\n        0x920A : \"FocalLength\",             // Focal length of the lens in mm\n        0xA20B : \"FlashEnergy\",             // Strobe energy in BCPS\n        0xA20C : \"SpatialFrequencyResponse\",    //\n        0xA20E : \"FocalPlaneXResolution\",   // Number of pixels in width direction per FocalPlaneResolutionUnit\n        0xA20F : \"FocalPlaneYResolution\",   // Number of pixels in height direction per FocalPlaneResolutionUnit\n        0xA210 : \"FocalPlaneResolutionUnit\",    // Unit for measuring FocalPlaneXResolution and FocalPlaneYResolution\n        0xA214 : \"SubjectLocation\",         // Location of subject in image\n        0xA215 : \"ExposureIndex\",           // Exposure index selected on camera\n        0xA217 : \"SensingMethod\",           // Image sensor type\n        0xA300 : \"FileSource\",              // Image source (3 == DSC)\n        0xA301 : \"SceneType\",               // Scene type (1 == directly photographed)\n        0xA302 : \"CFAPattern\",              // Color filter array geometric pattern\n        0xA401 : \"CustomRendered\",          // Special processing\n        0xA402 : \"ExposureMode\",            // Exposure mode\n        0xA403 : \"WhiteBalance\",            // 1 = auto white balance, 2 = manual\n        0xA404 : \"DigitalZoomRation\",       // Digital zoom ratio\n        0xA405 : \"FocalLengthIn35mmFilm\",   // Equivalent foacl length assuming 35mm film camera (in mm)\n        0xA406 : \"SceneCaptureType\",        // Type of scene\n        0xA407 : \"GainControl\",             // Degree of overall image gain adjustment\n        0xA408 : \"Contrast\",                // Direction of contrast processing applied by camera\n        0xA409 : \"Saturation\",              // Direction of saturation processing applied by camera\n        0xA40A : \"Sharpness\",               // Direction of sharpness processing applied by camera\n        0xA40B : \"DeviceSettingDescription\",    //\n        0xA40C : \"SubjectDistanceRange\",    // Distance to subject\n\n        // other tags\n        0xA005 : \"InteroperabilityIFDPointer\",\n        0xA420 : \"ImageUniqueID\"            // Identifier assigned uniquely to each image\n    };\n\n    var TiffTags = EXIF.TiffTags = {\n        0x0100 : \"ImageWidth\",\n        0x0101 : \"ImageHeight\",\n        0x8769 : \"ExifIFDPointer\",\n        0x8825 : \"GPSInfoIFDPointer\",\n        0xA005 : \"InteroperabilityIFDPointer\",\n        0x0102 : \"BitsPerSample\",\n        0x0103 : \"Compression\",\n        0x0106 : \"PhotometricInterpretation\",\n        0x0112 : \"Orientation\",\n        0x0115 : \"SamplesPerPixel\",\n        0x011C : \"PlanarConfiguration\",\n        0x0212 : \"YCbCrSubSampling\",\n        0x0213 : \"YCbCrPositioning\",\n        0x011A : \"XResolution\",\n        0x011B : \"YResolution\",\n        0x0128 : \"ResolutionUnit\",\n        0x0111 : \"StripOffsets\",\n        0x0116 : \"RowsPerStrip\",\n        0x0117 : \"StripByteCounts\",\n        0x0201 : \"JPEGInterchangeFormat\",\n        0x0202 : \"JPEGInterchangeFormatLength\",\n        0x012D : \"TransferFunction\",\n        0x013E : \"WhitePoint\",\n        0x013F : \"PrimaryChromaticities\",\n        0x0211 : \"YCbCrCoefficients\",\n        0x0214 : \"ReferenceBlackWhite\",\n        0x0132 : \"DateTime\",\n        0x010E : \"ImageDescription\",\n        0x010F : \"Make\",\n        0x0110 : \"Model\",\n        0x0131 : \"Software\",\n        0x013B : \"Artist\",\n        0x8298 : \"Copyright\"\n    };\n\n    var GPSTags = EXIF.GPSTags = {\n        0x0000 : \"GPSVersionID\",\n        0x0001 : \"GPSLatitudeRef\",\n        0x0002 : \"GPSLatitude\",\n        0x0003 : \"GPSLongitudeRef\",\n        0x0004 : \"GPSLongitude\",\n        0x0005 : \"GPSAltitudeRef\",\n        0x0006 : \"GPSAltitude\",\n        0x0007 : \"GPSTimeStamp\",\n        0x0008 : \"GPSSatellites\",\n        0x0009 : \"GPSStatus\",\n        0x000A : \"GPSMeasureMode\",\n        0x000B : \"GPSDOP\",\n        0x000C : \"GPSSpeedRef\",\n        0x000D : \"GPSSpeed\",\n        0x000E : \"GPSTrackRef\",\n        0x000F : \"GPSTrack\",\n        0x0010 : \"GPSImgDirectionRef\",\n        0x0011 : \"GPSImgDirection\",\n        0x0012 : \"GPSMapDatum\",\n        0x0013 : \"GPSDestLatitudeRef\",\n        0x0014 : \"GPSDestLatitude\",\n        0x0015 : \"GPSDestLongitudeRef\",\n        0x0016 : \"GPSDestLongitude\",\n        0x0017 : \"GPSDestBearingRef\",\n        0x0018 : \"GPSDestBearing\",\n        0x0019 : \"GPSDestDistanceRef\",\n        0x001A : \"GPSDestDistance\",\n        0x001B : \"GPSProcessingMethod\",\n        0x001C : \"GPSAreaInformation\",\n        0x001D : \"GPSDateStamp\",\n        0x001E : \"GPSDifferential\"\n    };\n\n     // EXIF 2.3 Spec\n    var IFD1Tags = EXIF.IFD1Tags = {\n        0x0100: \"ImageWidth\",\n        0x0101: \"ImageHeight\",\n        0x0102: \"BitsPerSample\",\n        0x0103: \"Compression\",\n        0x0106: \"PhotometricInterpretation\",\n        0x0111: \"StripOffsets\",\n        0x0112: \"Orientation\",\n        0x0115: \"SamplesPerPixel\",\n        0x0116: \"RowsPerStrip\",\n        0x0117: \"StripByteCounts\",\n        0x011A: \"XResolution\",\n        0x011B: \"YResolution\",\n        0x011C: \"PlanarConfiguration\",\n        0x0128: \"ResolutionUnit\",\n        0x0201: \"JpegIFOffset\",    // When image format is JPEG, this value show offset to JPEG data stored.(aka \"ThumbnailOffset\" or \"JPEGInterchangeFormat\")\n        0x0202: \"JpegIFByteCount\", // When image format is JPEG, this value shows data size of JPEG image (aka \"ThumbnailLength\" or \"JPEGInterchangeFormatLength\")\n        0x0211: \"YCbCrCoefficients\",\n        0x0212: \"YCbCrSubSampling\",\n        0x0213: \"YCbCrPositioning\",\n        0x0214: \"ReferenceBlackWhite\"\n    };\n\n    var StringValues = EXIF.StringValues = {\n        ExposureProgram : {\n            0 : \"Not defined\",\n            1 : \"Manual\",\n            2 : \"Normal program\",\n            3 : \"Aperture priority\",\n            4 : \"Shutter priority\",\n            5 : \"Creative program\",\n            6 : \"Action program\",\n            7 : \"Portrait mode\",\n            8 : \"Landscape mode\"\n        },\n        MeteringMode : {\n            0 : \"Unknown\",\n            1 : \"Average\",\n            2 : \"CenterWeightedAverage\",\n            3 : \"Spot\",\n            4 : \"MultiSpot\",\n            5 : \"Pattern\",\n            6 : \"Partial\",\n            255 : \"Other\"\n        },\n        LightSource : {\n            0 : \"Unknown\",\n            1 : \"Daylight\",\n            2 : \"Fluorescent\",\n            3 : \"Tungsten (incandescent light)\",\n            4 : \"Flash\",\n            9 : \"Fine weather\",\n            10 : \"Cloudy weather\",\n            11 : \"Shade\",\n            12 : \"Daylight fluorescent (D 5700 - 7100K)\",\n            13 : \"Day white fluorescent (N 4600 - 5400K)\",\n            14 : \"Cool white fluorescent (W 3900 - 4500K)\",\n            15 : \"White fluorescent (WW 3200 - 3700K)\",\n            17 : \"Standard light A\",\n            18 : \"Standard light B\",\n            19 : \"Standard light C\",\n            20 : \"D55\",\n            21 : \"D65\",\n            22 : \"D75\",\n            23 : \"D50\",\n            24 : \"ISO studio tungsten\",\n            255 : \"Other\"\n        },\n        Flash : {\n            0x0000 : \"Flash did not fire\",\n            0x0001 : \"Flash fired\",\n            0x0005 : \"Strobe return light not detected\",\n            0x0007 : \"Strobe return light detected\",\n            0x0009 : \"Flash fired, compulsory flash mode\",\n            0x000D : \"Flash fired, compulsory flash mode, return light not detected\",\n            0x000F : \"Flash fired, compulsory flash mode, return light detected\",\n            0x0010 : \"Flash did not fire, compulsory flash mode\",\n            0x0018 : \"Flash did not fire, auto mode\",\n            0x0019 : \"Flash fired, auto mode\",\n            0x001D : \"Flash fired, auto mode, return light not detected\",\n            0x001F : \"Flash fired, auto mode, return light detected\",\n            0x0020 : \"No flash function\",\n            0x0041 : \"Flash fired, red-eye reduction mode\",\n            0x0045 : \"Flash fired, red-eye reduction mode, return light not detected\",\n            0x0047 : \"Flash fired, red-eye reduction mode, return light detected\",\n            0x0049 : \"Flash fired, compulsory flash mode, red-eye reduction mode\",\n            0x004D : \"Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected\",\n            0x004F : \"Flash fired, compulsory flash mode, red-eye reduction mode, return light detected\",\n            0x0059 : \"Flash fired, auto mode, red-eye reduction mode\",\n            0x005D : \"Flash fired, auto mode, return light not detected, red-eye reduction mode\",\n            0x005F : \"Flash fired, auto mode, return light detected, red-eye reduction mode\"\n        },\n        SensingMethod : {\n            1 : \"Not defined\",\n            2 : \"One-chip color area sensor\",\n            3 : \"Two-chip color area sensor\",\n            4 : \"Three-chip color area sensor\",\n            5 : \"Color sequential area sensor\",\n            7 : \"Trilinear sensor\",\n            8 : \"Color sequential linear sensor\"\n        },\n        SceneCaptureType : {\n            0 : \"Standard\",\n            1 : \"Landscape\",\n            2 : \"Portrait\",\n            3 : \"Night scene\"\n        },\n        SceneType : {\n            1 : \"Directly photographed\"\n        },\n        CustomRendered : {\n            0 : \"Normal process\",\n            1 : \"Custom process\"\n        },\n        WhiteBalance : {\n            0 : \"Auto white balance\",\n            1 : \"Manual white balance\"\n        },\n        GainControl : {\n            0 : \"None\",\n            1 : \"Low gain up\",\n            2 : \"High gain up\",\n            3 : \"Low gain down\",\n            4 : \"High gain down\"\n        },\n        Contrast : {\n            0 : \"Normal\",\n            1 : \"Soft\",\n            2 : \"Hard\"\n        },\n        Saturation : {\n            0 : \"Normal\",\n            1 : \"Low saturation\",\n            2 : \"High saturation\"\n        },\n        Sharpness : {\n            0 : \"Normal\",\n            1 : \"Soft\",\n            2 : \"Hard\"\n        },\n        SubjectDistanceRange : {\n            0 : \"Unknown\",\n            1 : \"Macro\",\n            2 : \"Close view\",\n            3 : \"Distant view\"\n        },\n        FileSource : {\n            3 : \"DSC\"\n        },\n\n        Components : {\n            0 : \"\",\n            1 : \"Y\",\n            2 : \"Cb\",\n            3 : \"Cr\",\n            4 : \"R\",\n            5 : \"G\",\n            6 : \"B\"\n        }\n    };\n\n    function addEvent(element, event, handler) {\n        if (element.addEventListener) {\n            element.addEventListener(event, handler, false);\n        } else if (element.attachEvent) {\n            element.attachEvent(\"on\" + event, handler);\n        }\n    }\n\n    function imageHasData(img) {\n        return !!(img.exifdata);\n    }\n\n\n    function base64ToArrayBuffer(base64, contentType) {\n        contentType = contentType || base64.match(/^data\\:([^\\;]+)\\;base64,/mi)[1] || ''; // e.g. 'data:image/jpeg;base64,...' => 'image/jpeg'\n        base64 = base64.replace(/^data\\:([^\\;]+)\\;base64,/gmi, '');\n        var binary = atob(base64);\n        var len = binary.length;\n        var buffer = new ArrayBuffer(len);\n        var view = new Uint8Array(buffer);\n        for (var i = 0; i < len; i++) {\n            view[i] = binary.charCodeAt(i);\n        }\n        return buffer;\n    }\n\n    function objectURLToBlob(url, callback) {\n        var http = new XMLHttpRequest();\n        http.open(\"GET\", url, true);\n        http.responseType = \"blob\";\n        http.onload = function(e) {\n            if (this.status == 200 || this.status === 0) {\n                callback(this.response);\n            }\n        };\n        http.send();\n    }\n\n    function getImageData(img, callback) {\n        function handleBinaryFile(binFile) {\n            var data = findEXIFinJPEG(binFile);\n            img.exifdata = data || {};\n            var iptcdata = findIPTCinJPEG(binFile);\n            img.iptcdata = iptcdata || {};\n            if (EXIF.isXmpEnabled) {\n               var xmpdata= findXMPinJPEG(binFile);\n               img.xmpdata = xmpdata || {};               \n            }\n            if (callback) {\n                callback.call(img);\n            }\n        }\n\n        if (img.src) {\n            if (/^data\\:/i.test(img.src)) { // Data URI\n                var arrayBuffer = base64ToArrayBuffer(img.src);\n                handleBinaryFile(arrayBuffer);\n\n            } else if (/^blob\\:/i.test(img.src)) { // Object URL\n                var fileReader = new FileReader();\n                fileReader.onload = function(e) {\n                    handleBinaryFile(e.target.result);\n                };\n                objectURLToBlob(img.src, function (blob) {\n                    fileReader.readAsArrayBuffer(blob);\n                });\n            } else {\n                var http = new XMLHttpRequest();\n                http.onload = function() {\n                    if (this.status == 200 || this.status === 0) {\n                        handleBinaryFile(http.response);\n                    } else {\n                        throw \"Could not load image\";\n                    }\n                    http = null;\n                };\n                http.open(\"GET\", img.src, true);\n                http.responseType = \"arraybuffer\";\n                http.send(null);\n            }\n        } else if (self.FileReader && (img instanceof self.Blob || img instanceof self.File)) {\n            var fileReader = new FileReader();\n            fileReader.onload = function(e) {\n                if (debug) console.log(\"Got file of length \" + e.target.result.byteLength);\n                handleBinaryFile(e.target.result);\n            };\n\n            fileReader.readAsArrayBuffer(img);\n        }\n    }\n\n    function findEXIFinJPEG(file) {\n        var dataView = new DataView(file);\n\n        if (debug) console.log(\"Got file of length \" + file.byteLength);\n        if ((dataView.getUint8(0) != 0xFF) || (dataView.getUint8(1) != 0xD8)) {\n            if (debug) console.log(\"Not a valid JPEG\");\n            return false; // not a valid jpeg\n        }\n\n        var offset = 2,\n            length = file.byteLength,\n            marker;\n\n        while (offset < length) {\n            if (dataView.getUint8(offset) != 0xFF) {\n                if (debug) console.log(\"Not a valid marker at offset \" + offset + \", found: \" + dataView.getUint8(offset));\n                return false; // not a valid marker, something is wrong\n            }\n\n            marker = dataView.getUint8(offset + 1);\n            if (debug) console.log(marker);\n\n            // we could implement handling for other markers here,\n            // but we're only looking for 0xFFE1 for EXIF data\n\n            if (marker == 225) {\n                if (debug) console.log(\"Found 0xFFE1 marker\");\n\n                return readEXIFData(dataView, offset + 4, dataView.getUint16(offset + 2) - 2);\n\n                // offset += 2 + file.getShortAt(offset+2, true);\n\n            } else {\n                offset += 2 + dataView.getUint16(offset+2);\n            }\n\n        }\n\n    }\n\n    function findIPTCinJPEG(file) {\n        var dataView = new DataView(file);\n\n        if (debug) console.log(\"Got file of length \" + file.byteLength);\n        if ((dataView.getUint8(0) != 0xFF) || (dataView.getUint8(1) != 0xD8)) {\n            if (debug) console.log(\"Not a valid JPEG\");\n            return false; // not a valid jpeg\n        }\n\n        var offset = 2,\n            length = file.byteLength;\n\n\n        var isFieldSegmentStart = function(dataView, offset){\n            return (\n                dataView.getUint8(offset) === 0x38 &&\n                dataView.getUint8(offset+1) === 0x42 &&\n                dataView.getUint8(offset+2) === 0x49 &&\n                dataView.getUint8(offset+3) === 0x4D &&\n                dataView.getUint8(offset+4) === 0x04 &&\n                dataView.getUint8(offset+5) === 0x04\n            );\n        };\n\n        while (offset < length) {\n\n            if ( isFieldSegmentStart(dataView, offset )){\n\n                // Get the length of the name header (which is padded to an even number of bytes)\n                var nameHeaderLength = dataView.getUint8(offset+7);\n                if(nameHeaderLength % 2 !== 0) nameHeaderLength += 1;\n                // Check for pre photoshop 6 format\n                if(nameHeaderLength === 0) {\n                    // Always 4\n                    nameHeaderLength = 4;\n                }\n\n                var startOffset = offset + 8 + nameHeaderLength;\n                var sectionLength = dataView.getUint16(offset + 6 + nameHeaderLength);\n\n                return readIPTCData(file, startOffset, sectionLength);\n\n                break;\n\n            }\n\n\n            // Not the marker, continue searching\n            offset++;\n\n        }\n\n    }\n    var IptcFieldMap = {\n        0x78 : 'caption',\n        0x6E : 'credit',\n        0x19 : 'keywords',\n        0x37 : 'dateCreated',\n        0x50 : 'byline',\n        0x55 : 'bylineTitle',\n        0x7A : 'captionWriter',\n        0x69 : 'headline',\n        0x74 : 'copyright',\n        0x0F : 'category'\n    };\n    function readIPTCData(file, startOffset, sectionLength){\n        var dataView = new DataView(file);\n        var data = {};\n        var fieldValue, fieldName, dataSize, segmentType, segmentSize;\n        var segmentStartPos = startOffset;\n        while(segmentStartPos < startOffset+sectionLength) {\n            if(dataView.getUint8(segmentStartPos) === 0x1C && dataView.getUint8(segmentStartPos+1) === 0x02){\n                segmentType = dataView.getUint8(segmentStartPos+2);\n                if(segmentType in IptcFieldMap) {\n                    dataSize = dataView.getInt16(segmentStartPos+3);\n                    segmentSize = dataSize + 5;\n                    fieldName = IptcFieldMap[segmentType];\n                    fieldValue = getStringFromDB(dataView, segmentStartPos+5, dataSize);\n                    // Check if we already stored a value with this name\n                    if(data.hasOwnProperty(fieldName)) {\n                        // Value already stored with this name, create multivalue field\n                        if(data[fieldName] instanceof Array) {\n                            data[fieldName].push(fieldValue);\n                        }\n                        else {\n                            data[fieldName] = [data[fieldName], fieldValue];\n                        }\n                    }\n                    else {\n                        data[fieldName] = fieldValue;\n                    }\n                }\n\n            }\n            segmentStartPos++;\n        }\n        return data;\n    }\n\n\n\n    function readTags(file, tiffStart, dirStart, strings, bigEnd) {\n        var entries = file.getUint16(dirStart, !bigEnd),\n            tags = {},\n            entryOffset, tag,\n            i;\n\n        for (i=0;i<entries;i++) {\n            entryOffset = dirStart + i*12 + 2;\n            tag = strings[file.getUint16(entryOffset, !bigEnd)];\n            if (!tag && debug) console.log(\"Unknown tag: \" + file.getUint16(entryOffset, !bigEnd));\n            tags[tag] = readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd);\n        }\n        return tags;\n    }\n\n\n    function readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd) {\n        var type = file.getUint16(entryOffset+2, !bigEnd),\n            numValues = file.getUint32(entryOffset+4, !bigEnd),\n            valueOffset = file.getUint32(entryOffset+8, !bigEnd) + tiffStart,\n            offset,\n            vals, val, n,\n            numerator, denominator;\n\n        switch (type) {\n            case 1: // byte, 8-bit unsigned int\n            case 7: // undefined, 8-bit byte, value depending on field\n                if (numValues == 1) {\n                    return file.getUint8(entryOffset + 8, !bigEnd);\n                } else {\n                    offset = numValues > 4 ? valueOffset : (entryOffset + 8);\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        vals[n] = file.getUint8(offset + n);\n                    }\n                    return vals;\n                }\n\n            case 2: // ascii, 8-bit byte\n                offset = numValues > 4 ? valueOffset : (entryOffset + 8);\n                return getStringFromDB(file, offset, numValues-1);\n\n            case 3: // short, 16 bit int\n                if (numValues == 1) {\n                    return file.getUint16(entryOffset + 8, !bigEnd);\n                } else {\n                    offset = numValues > 2 ? valueOffset : (entryOffset + 8);\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        vals[n] = file.getUint16(offset + 2*n, !bigEnd);\n                    }\n                    return vals;\n                }\n\n            case 4: // long, 32 bit int\n                if (numValues == 1) {\n                    return file.getUint32(entryOffset + 8, !bigEnd);\n                } else {\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        vals[n] = file.getUint32(valueOffset + 4*n, !bigEnd);\n                    }\n                    return vals;\n                }\n\n            case 5:    // rational = two long values, first is numerator, second is denominator\n                if (numValues == 1) {\n                    numerator = file.getUint32(valueOffset, !bigEnd);\n                    denominator = file.getUint32(valueOffset+4, !bigEnd);\n                    val = new Number(numerator / denominator);\n                    val.numerator = numerator;\n                    val.denominator = denominator;\n                    return val;\n                } else {\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        numerator = file.getUint32(valueOffset + 8*n, !bigEnd);\n                        denominator = file.getUint32(valueOffset+4 + 8*n, !bigEnd);\n                        vals[n] = new Number(numerator / denominator);\n                        vals[n].numerator = numerator;\n                        vals[n].denominator = denominator;\n                    }\n                    return vals;\n                }\n\n            case 9: // slong, 32 bit signed int\n                if (numValues == 1) {\n                    return file.getInt32(entryOffset + 8, !bigEnd);\n                } else {\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        vals[n] = file.getInt32(valueOffset + 4*n, !bigEnd);\n                    }\n                    return vals;\n                }\n\n            case 10: // signed rational, two slongs, first is numerator, second is denominator\n                if (numValues == 1) {\n                    return file.getInt32(valueOffset, !bigEnd) / file.getInt32(valueOffset+4, !bigEnd);\n                } else {\n                    vals = [];\n                    for (n=0;n<numValues;n++) {\n                        vals[n] = file.getInt32(valueOffset + 8*n, !bigEnd) / file.getInt32(valueOffset+4 + 8*n, !bigEnd);\n                    }\n                    return vals;\n                }\n        }\n    }\n\n    /**\n    * Given an IFD (Image File Directory) start offset\n    * returns an offset to next IFD or 0 if it's the last IFD.\n    */\n    function getNextIFDOffset(dataView, dirStart, bigEnd){\n        //the first 2bytes means the number of directory entries contains in this IFD\n        var entries = dataView.getUint16(dirStart, !bigEnd);\n\n        // After last directory entry, there is a 4bytes of data,\n        // it means an offset to next IFD.\n        // If its value is '0x00000000', it means this is the last IFD and there is no linked IFD.\n\n        return dataView.getUint32(dirStart + 2 + entries * 12, !bigEnd); // each entry is 12 bytes long\n    }\n\n    function readThumbnailImage(dataView, tiffStart, firstIFDOffset, bigEnd){\n        // get the IFD1 offset\n        var IFD1OffsetPointer = getNextIFDOffset(dataView, tiffStart+firstIFDOffset, bigEnd);\n\n        if (!IFD1OffsetPointer) {\n            // console.log('******** IFD1Offset is empty, image thumb not found ********');\n            return {};\n        }\n        else if (IFD1OffsetPointer > dataView.byteLength) { // this should not happen\n            // console.log('******** IFD1Offset is outside the bounds of the DataView ********');\n            return {};\n        }\n        // console.log('*******  thumbnail IFD offset (IFD1) is: %s', IFD1OffsetPointer);\n\n        var thumbTags = readTags(dataView, tiffStart, tiffStart + IFD1OffsetPointer, IFD1Tags, bigEnd)\n\n        // EXIF 2.3 specification for JPEG format thumbnail\n\n        // If the value of Compression(0x0103) Tag in IFD1 is '6', thumbnail image format is JPEG.\n        // Most of Exif image uses JPEG format for thumbnail. In that case, you can get offset of thumbnail\n        // by JpegIFOffset(0x0201) Tag in IFD1, size of thumbnail by JpegIFByteCount(0x0202) Tag.\n        // Data format is ordinary JPEG format, starts from 0xFFD8 and ends by 0xFFD9. It seems that\n        // JPEG format and 160x120pixels of size are recommended thumbnail format for Exif2.1 or later.\n\n        if (thumbTags['Compression']) {\n            // console.log('Thumbnail image found!');\n\n            switch (thumbTags['Compression']) {\n                case 6:\n                    // console.log('Thumbnail image format is JPEG');\n                    if (thumbTags.JpegIFOffset && thumbTags.JpegIFByteCount) {\n                    // extract the thumbnail\n                        var tOffset = tiffStart + thumbTags.JpegIFOffset;\n                        var tLength = thumbTags.JpegIFByteCount;\n                        thumbTags['blob'] = new Blob([new Uint8Array(dataView.buffer, tOffset, tLength)], {\n                            type: 'image/jpeg'\n                        });\n                    }\n                break;\n\n            case 1:\n                console.log(\"Thumbnail image format is TIFF, which is not implemented.\");\n                break;\n            default:\n                console.log(\"Unknown thumbnail image format '%s'\", thumbTags['Compression']);\n            }\n        }\n        else if (thumbTags['PhotometricInterpretation'] == 2) {\n            console.log(\"Thumbnail image format is RGB, which is not implemented.\");\n        }\n        return thumbTags;\n    }\n\n    function getStringFromDB(buffer, start, length) {\n        var outstr = \"\";\n        for (n = start; n < start+length; n++) {\n            outstr += String.fromCharCode(buffer.getUint8(n));\n        }\n        return outstr;\n    }\n\n    function readEXIFData(file, start) {\n        if (getStringFromDB(file, start, 4) != \"Exif\") {\n            if (debug) console.log(\"Not valid EXIF data! \" + getStringFromDB(file, start, 4));\n            return false;\n        }\n\n        var bigEnd,\n            tags, tag,\n            exifData, gpsData,\n            tiffOffset = start + 6;\n\n        // test for TIFF validity and endianness\n        if (file.getUint16(tiffOffset) == 0x4949) {\n            bigEnd = false;\n        } else if (file.getUint16(tiffOffset) == 0x4D4D) {\n            bigEnd = true;\n        } else {\n            if (debug) console.log(\"Not valid TIFF data! (no 0x4949 or 0x4D4D)\");\n            return false;\n        }\n\n        if (file.getUint16(tiffOffset+2, !bigEnd) != 0x002A) {\n            if (debug) console.log(\"Not valid TIFF data! (no 0x002A)\");\n            return false;\n        }\n\n        var firstIFDOffset = file.getUint32(tiffOffset+4, !bigEnd);\n\n        if (firstIFDOffset < 0x00000008) {\n            if (debug) console.log(\"Not valid TIFF data! (First offset less than 8)\", file.getUint32(tiffOffset+4, !bigEnd));\n            return false;\n        }\n\n        tags = readTags(file, tiffOffset, tiffOffset + firstIFDOffset, TiffTags, bigEnd);\n\n        if (tags.ExifIFDPointer) {\n            exifData = readTags(file, tiffOffset, tiffOffset + tags.ExifIFDPointer, ExifTags, bigEnd);\n            for (tag in exifData) {\n                switch (tag) {\n                    case \"LightSource\" :\n                    case \"Flash\" :\n                    case \"MeteringMode\" :\n                    case \"ExposureProgram\" :\n                    case \"SensingMethod\" :\n                    case \"SceneCaptureType\" :\n                    case \"SceneType\" :\n                    case \"CustomRendered\" :\n                    case \"WhiteBalance\" :\n                    case \"GainControl\" :\n                    case \"Contrast\" :\n                    case \"Saturation\" :\n                    case \"Sharpness\" :\n                    case \"SubjectDistanceRange\" :\n                    case \"FileSource\" :\n                        exifData[tag] = StringValues[tag][exifData[tag]];\n                        break;\n\n                    case \"ExifVersion\" :\n                    case \"FlashpixVersion\" :\n                        exifData[tag] = String.fromCharCode(exifData[tag][0], exifData[tag][1], exifData[tag][2], exifData[tag][3]);\n                        break;\n\n                    case \"ComponentsConfiguration\" :\n                        exifData[tag] =\n                            StringValues.Components[exifData[tag][0]] +\n                            StringValues.Components[exifData[tag][1]] +\n                            StringValues.Components[exifData[tag][2]] +\n                            StringValues.Components[exifData[tag][3]];\n                        break;\n                }\n                tags[tag] = exifData[tag];\n            }\n        }\n\n        if (tags.GPSInfoIFDPointer) {\n            gpsData = readTags(file, tiffOffset, tiffOffset + tags.GPSInfoIFDPointer, GPSTags, bigEnd);\n            for (tag in gpsData) {\n                switch (tag) {\n                    case \"GPSVersionID\" :\n                        gpsData[tag] = gpsData[tag][0] +\n                            \".\" + gpsData[tag][1] +\n                            \".\" + gpsData[tag][2] +\n                            \".\" + gpsData[tag][3];\n                        break;\n                }\n                tags[tag] = gpsData[tag];\n            }\n        }\n\n        // extract thumbnail\n        tags['thumbnail'] = readThumbnailImage(file, tiffOffset, firstIFDOffset, bigEnd);\n\n        return tags;\n    }\n\n   function findXMPinJPEG(file) {\n\n        if (!('DOMParser' in self)) {\n            // console.warn('XML parsing not supported without DOMParser');\n            return;\n        }\n        var dataView = new DataView(file);\n\n        if (debug) console.log(\"Got file of length \" + file.byteLength);\n        if ((dataView.getUint8(0) != 0xFF) || (dataView.getUint8(1) != 0xD8)) {\n           if (debug) console.log(\"Not a valid JPEG\");\n           return false; // not a valid jpeg\n        }\n\n        var offset = 2,\n            length = file.byteLength,\n            dom = new DOMParser();\n\n        while (offset < (length-4)) {\n            if (getStringFromDB(dataView, offset, 4) == \"http\") {\n                var startOffset = offset - 1;\n                var sectionLength = dataView.getUint16(offset - 2) - 1;\n                var xmpString = getStringFromDB(dataView, startOffset, sectionLength)\n                var xmpEndIndex = xmpString.indexOf('xmpmeta>') + 8;\n                xmpString = xmpString.substring( xmpString.indexOf( '<x:xmpmeta' ), xmpEndIndex );\n\n                var indexOfXmp = xmpString.indexOf('x:xmpmeta') + 10\n                //Many custom written programs embed xmp/xml without any namespace. Following are some of them.\n                //Without these namespaces, XML is thought to be invalid by parsers\n                xmpString = xmpString.slice(0, indexOfXmp)\n                            + 'xmlns:Iptc4xmpCore=\"http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/\" '\n                            + 'xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" '\n                            + 'xmlns:tiff=\"http://ns.adobe.com/tiff/1.0/\" '\n                            + 'xmlns:plus=\"http://schemas.android.com/apk/lib/com.google.android.gms.plus\" '\n                            + 'xmlns:ext=\"http://www.gettyimages.com/xsltExtension/1.0\" '\n                            + 'xmlns:exif=\"http://ns.adobe.com/exif/1.0/\" '\n                            + 'xmlns:stEvt=\"http://ns.adobe.com/xap/1.0/sType/ResourceEvent#\" '\n                            + 'xmlns:stRef=\"http://ns.adobe.com/xap/1.0/sType/ResourceRef#\" '\n                            + 'xmlns:crs=\"http://ns.adobe.com/camera-raw-settings/1.0/\" '\n                            + 'xmlns:xapGImg=\"http://ns.adobe.com/xap/1.0/g/img/\" '\n                            + 'xmlns:Iptc4xmpExt=\"http://iptc.org/std/Iptc4xmpExt/2008-02-29/\" '\n                            + xmpString.slice(indexOfXmp)\n\n                var domDocument = dom.parseFromString( xmpString, 'text/xml' );\n                return xml2Object(domDocument);\n            } else{\n             offset++;\n            }\n        }\n    }\n\n    function xml2json(xml) {\n        var json = {};\n      \n        if (xml.nodeType == 1) { // element node\n          if (xml.attributes.length > 0) {\n            json['@attributes'] = {};\n            for (var j = 0; j < xml.attributes.length; j++) {\n              var attribute = xml.attributes.item(j);\n              json['@attributes'][attribute.nodeName] = attribute.nodeValue;\n            }\n          }\n        } else if (xml.nodeType == 3) { // text node\n          return xml.nodeValue;\n        }\n      \n        // deal with children\n        if (xml.hasChildNodes()) {\n          for(var i = 0; i < xml.childNodes.length; i++) {\n            var child = xml.childNodes.item(i);\n            var nodeName = child.nodeName;\n            if (json[nodeName] == null) {\n              json[nodeName] = xml2json(child);\n            } else {\n              if (json[nodeName].push == null) {\n                var old = json[nodeName];\n                json[nodeName] = [];\n                json[nodeName].push(old);\n              }\n              json[nodeName].push(xml2json(child));\n            }\n          }\n        }\n        \n        return json;\n    }\n\n    function xml2Object(xml) {\n        try {\n            var obj = {};\n            if (xml.children.length > 0) {\n              for (var i = 0; i < xml.children.length; i++) {\n                var item = xml.children.item(i);\n                var attributes = item.attributes;\n                for(var idx in attributes) {\n                    var itemAtt = attributes[idx];\n                    var dataKey = itemAtt.nodeName;\n                    var dataValue = itemAtt.nodeValue;\n\n                    if(dataKey !== undefined) {\n                        obj[dataKey] = dataValue;\n                    }\n                }\n                var nodeName = item.nodeName;\n\n                if (typeof (obj[nodeName]) == \"undefined\") {\n                  obj[nodeName] = xml2json(item);\n                } else {\n                  if (typeof (obj[nodeName].push) == \"undefined\") {\n                    var old = obj[nodeName];\n\n                    obj[nodeName] = [];\n                    obj[nodeName].push(old);\n                  }\n                  obj[nodeName].push(xml2json(item));\n                }\n              }\n            } else {\n              obj = xml.textContent;\n            }\n            return obj;\n          } catch (e) {\n              console.log(e.message);\n          }\n    }\n\n    EXIF.enableXmp = function() {\n        EXIF.isXmpEnabled = true;\n    }\n\n    EXIF.disableXmp = function() {\n        EXIF.isXmpEnabled = false;\n    }\n\n    EXIF.getData = function(img, callback) {\n        if (((self.Image && img instanceof self.Image)\n            || (self.HTMLImageElement && img instanceof self.HTMLImageElement))\n            && !img.complete)\n            return false;\n\n        if (!imageHasData(img)) {\n            getImageData(img, callback);\n        } else {\n            if (callback) {\n                callback.call(img);\n            }\n        }\n        return true;\n    }\n\n    EXIF.getTag = function(img, tag) {\n        if (!imageHasData(img)) return;\n        return img.exifdata[tag];\n    }\n    \n    EXIF.getIptcTag = function(img, tag) {\n        if (!imageHasData(img)) return;\n        return img.iptcdata[tag];\n    }\n\n    EXIF.getAllTags = function(img) {\n        if (!imageHasData(img)) return {};\n        var a,\n            data = img.exifdata,\n            tags = {};\n        for (a in data) {\n            if (data.hasOwnProperty(a)) {\n                tags[a] = data[a];\n            }\n        }\n        return tags;\n    }\n    \n    EXIF.getAllIptcTags = function(img) {\n        if (!imageHasData(img)) return {};\n        var a,\n            data = img.iptcdata,\n            tags = {};\n        for (a in data) {\n            if (data.hasOwnProperty(a)) {\n                tags[a] = data[a];\n            }\n        }\n        return tags;\n    }\n\n    EXIF.pretty = function(img) {\n        if (!imageHasData(img)) return \"\";\n        var a,\n            data = img.exifdata,\n            strPretty = \"\";\n        for (a in data) {\n            if (data.hasOwnProperty(a)) {\n                if (typeof data[a] == \"object\") {\n                    if (data[a] instanceof Number) {\n                        strPretty += a + \" : \" + data[a] + \" [\" + data[a].numerator + \"/\" + data[a].denominator + \"]\\r\\n\";\n                    } else {\n                        strPretty += a + \" : [\" + data[a].length + \" values]\\r\\n\";\n                    }\n                } else {\n                    strPretty += a + \" : \" + data[a] + \"\\r\\n\";\n                }\n            }\n        }\n        return strPretty;\n    }\n\n    EXIF.readFromBinaryFile = function(file) {\n        return findEXIFinJPEG(file);\n    }\n\n    if (typeof define === 'function' && define.amd) {\n        define('exif-js', [], function() {\n            return EXIF;\n        });\n    }\n}.call(this));\n\n","/* pica 5.3.0 nodeca/pica */(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.pica = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(_dereq_,module,exports){\n// Collection of math functions\n//\n// 1. Combine components together\n// 2. Has async init to load wasm modules\n//\n'use strict';\n\nvar inherits = _dereq_('inherits');\n\nvar Multimath = _dereq_('multimath');\n\nvar mm_unsharp_mask = _dereq_('multimath/lib/unsharp_mask');\n\nvar mm_resize = _dereq_('./mm_resize');\n\nfunction MathLib(requested_features) {\n  var __requested_features = requested_features || [];\n\n  var features = {\n    js: __requested_features.indexOf('js') >= 0,\n    wasm: __requested_features.indexOf('wasm') >= 0\n  };\n  Multimath.call(this, features);\n  this.features = {\n    js: features.js,\n    wasm: features.wasm && this.has_wasm()\n  };\n  this.use(mm_unsharp_mask);\n  this.use(mm_resize);\n}\n\ninherits(MathLib, Multimath);\n\nMathLib.prototype.resizeAndUnsharp = function resizeAndUnsharp(options, cache) {\n  var result = this.resize(options, cache);\n\n  if (options.unsharpAmount) {\n    this.unsharp_mask(result, options.toWidth, options.toHeight, options.unsharpAmount, options.unsharpRadius, options.unsharpThreshold);\n  }\n\n  return result;\n};\n\nmodule.exports = MathLib;\n\n},{\"./mm_resize\":4,\"inherits\":15,\"multimath\":16,\"multimath/lib/unsharp_mask\":19}],2:[function(_dereq_,module,exports){\n// Resize convolvers, pure JS implementation\n//\n'use strict'; // Precision of fixed FP values\n//var FIXED_FRAC_BITS = 14;\n\nfunction clampTo8(i) {\n  return i < 0 ? 0 : i > 255 ? 255 : i;\n} // Convolve image in horizontal directions and transpose output. In theory,\n// transpose allow:\n//\n// - use the same convolver for both passes (this fails due different\n//   types of input array and temporary buffer)\n// - making vertical pass by horisonltal lines inprove CPU cache use.\n//\n// But in real life this doesn't work :)\n//\n\n\nfunction convolveHorizontally(src, dest, srcW, srcH, destW, filters) {\n  var r, g, b, a;\n  var filterPtr, filterShift, filterSize;\n  var srcPtr, srcY, destX, filterVal;\n  var srcOffset = 0,\n      destOffset = 0; // For each row\n\n  for (srcY = 0; srcY < srcH; srcY++) {\n    filterPtr = 0; // Apply precomputed filters to each destination row point\n\n    for (destX = 0; destX < destW; destX++) {\n      // Get the filter that determines the current output pixel.\n      filterShift = filters[filterPtr++];\n      filterSize = filters[filterPtr++];\n      srcPtr = srcOffset + filterShift * 4 | 0;\n      r = g = b = a = 0; // Apply the filter to the row to get the destination pixel r, g, b, a\n\n      for (; filterSize > 0; filterSize--) {\n        filterVal = filters[filterPtr++]; // Use reverse order to workaround deopts in old v8 (node v.10)\n        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.\n\n        a = a + filterVal * src[srcPtr + 3] | 0;\n        b = b + filterVal * src[srcPtr + 2] | 0;\n        g = g + filterVal * src[srcPtr + 1] | 0;\n        r = r + filterVal * src[srcPtr] | 0;\n        srcPtr = srcPtr + 4 | 0;\n      } // Bring this value back in range. All of the filter scaling factors\n      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.\n      //\n      // (!) Add 1/2 of value before clamping to get proper rounding. In other\n      // case brightness loss will be noticeable if you resize image with white\n      // border and place it on white background.\n      //\n\n\n      dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset] = clampTo8(r + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      destOffset = destOffset + srcH * 4 | 0;\n    }\n\n    destOffset = (srcY + 1) * 4 | 0;\n    srcOffset = (srcY + 1) * srcW * 4 | 0;\n  }\n} // Technically, convolvers are the same. But input array and temporary\n// buffer can be of different type (especially, in old browsers). So,\n// keep code in separate functions to avoid deoptimizations & speed loss.\n\n\nfunction convolveVertically(src, dest, srcW, srcH, destW, filters) {\n  var r, g, b, a;\n  var filterPtr, filterShift, filterSize;\n  var srcPtr, srcY, destX, filterVal;\n  var srcOffset = 0,\n      destOffset = 0; // For each row\n\n  for (srcY = 0; srcY < srcH; srcY++) {\n    filterPtr = 0; // Apply precomputed filters to each destination row point\n\n    for (destX = 0; destX < destW; destX++) {\n      // Get the filter that determines the current output pixel.\n      filterShift = filters[filterPtr++];\n      filterSize = filters[filterPtr++];\n      srcPtr = srcOffset + filterShift * 4 | 0;\n      r = g = b = a = 0; // Apply the filter to the row to get the destination pixel r, g, b, a\n\n      for (; filterSize > 0; filterSize--) {\n        filterVal = filters[filterPtr++]; // Use reverse order to workaround deopts in old v8 (node v.10)\n        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.\n\n        a = a + filterVal * src[srcPtr + 3] | 0;\n        b = b + filterVal * src[srcPtr + 2] | 0;\n        g = g + filterVal * src[srcPtr + 1] | 0;\n        r = r + filterVal * src[srcPtr] | 0;\n        srcPtr = srcPtr + 4 | 0;\n      } // Bring this value back in range. All of the filter scaling factors\n      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.\n      //\n      // (!) Add 1/2 of value before clamping to get proper rounding. In other\n      // case brightness loss will be noticeable if you resize image with white\n      // border and place it on white background.\n      //\n\n\n      dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      dest[destOffset] = clampTo8(r + (1 << 13) >> 14\n      /*FIXED_FRAC_BITS*/\n      );\n      destOffset = destOffset + srcH * 4 | 0;\n    }\n\n    destOffset = (srcY + 1) * 4 | 0;\n    srcOffset = (srcY + 1) * srcW * 4 | 0;\n  }\n}\n\nmodule.exports = {\n  convolveHorizontally: convolveHorizontally,\n  convolveVertically: convolveVertically\n};\n\n},{}],3:[function(_dereq_,module,exports){\n// This is autogenerated file from math.wasm, don't edit.\n//\n'use strict';\n/* eslint-disable max-len */\n\nmodule.exports = 'AGFzbQEAAAABFAJgBn9/f39/fwBgB39/f39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQQEAXAAAAcZAghjb252b2x2ZQAACmNvbnZvbHZlSFYAAQkBAArmAwLBAwEQfwJAIANFDQAgBEUNACAFQQRqIRVBACEMQQAhDQNAIA0hDkEAIRFBACEHA0AgB0ECaiESAn8gBSAHQQF0IgdqIgZBAmouAQAiEwRAQQAhCEEAIBNrIRQgFSAHaiEPIAAgDCAGLgEAakECdGohEEEAIQlBACEKQQAhCwNAIBAoAgAiB0EYdiAPLgEAIgZsIAtqIQsgB0H/AXEgBmwgCGohCCAHQRB2Qf8BcSAGbCAKaiEKIAdBCHZB/wFxIAZsIAlqIQkgD0ECaiEPIBBBBGohECAUQQFqIhQNAAsgEiATagwBC0EAIQtBACEKQQAhCUEAIQggEgshByABIA5BAnRqIApBgMAAakEOdSIGQf8BIAZB/wFIG0EQdEGAgPwHcUEAIAZBAEobIAtBgMAAakEOdSIGQf8BIAZB/wFIG0EYdEEAIAZBAEobciAJQYDAAGpBDnUiBkH/ASAGQf8BSBtBCHRBgP4DcUEAIAZBAEobciAIQYDAAGpBDnUiBkH/ASAGQf8BSBtB/wFxQQAgBkEAShtyNgIAIA4gA2ohDiARQQFqIhEgBEcNAAsgDCACaiEMIA1BAWoiDSADRw0ACwsLIQACQEEAIAIgAyAEIAUgABAAIAJBACAEIAUgBiABEAALCw==';\n\n},{}],4:[function(_dereq_,module,exports){\n'use strict';\n\nmodule.exports = {\n  name: 'resize',\n  fn: _dereq_('./resize'),\n  wasm_fn: _dereq_('./resize_wasm'),\n  wasm_src: _dereq_('./convolve_wasm_base64')\n};\n\n},{\"./convolve_wasm_base64\":3,\"./resize\":5,\"./resize_wasm\":8}],5:[function(_dereq_,module,exports){\n'use strict';\n\nvar createFilters = _dereq_('./resize_filter_gen');\n\nvar convolveHorizontally = _dereq_('./convolve').convolveHorizontally;\n\nvar convolveVertically = _dereq_('./convolve').convolveVertically;\n\nfunction resetAlpha(dst, width, height) {\n  var ptr = 3,\n      len = width * height * 4 | 0;\n\n  while (ptr < len) {\n    dst[ptr] = 0xFF;\n    ptr = ptr + 4 | 0;\n  }\n}\n\nmodule.exports = function resize(options) {\n  var src = options.src;\n  var srcW = options.width;\n  var srcH = options.height;\n  var destW = options.toWidth;\n  var destH = options.toHeight;\n  var scaleX = options.scaleX || options.toWidth / options.width;\n  var scaleY = options.scaleY || options.toHeight / options.height;\n  var offsetX = options.offsetX || 0;\n  var offsetY = options.offsetY || 0;\n  var dest = options.dest || new Uint8Array(destW * destH * 4);\n  var quality = typeof options.quality === 'undefined' ? 3 : options.quality;\n  var alpha = options.alpha || false;\n  var filtersX = createFilters(quality, srcW, destW, scaleX, offsetX),\n      filtersY = createFilters(quality, srcH, destH, scaleY, offsetY);\n  var tmp = new Uint8Array(destW * srcH * 4); // To use single function we need src & tmp of the same type.\n  // But src can be CanvasPixelArray, and tmp - Uint8Array. So, keep\n  // vertical and horizontal passes separately to avoid deoptimization.\n\n  convolveHorizontally(src, tmp, srcW, srcH, destW, filtersX);\n  convolveVertically(tmp, dest, srcH, destW, destH, filtersY); // That's faster than doing checks in convolver.\n  // !!! Note, canvas data is not premultipled. We don't need other\n  // alpha corrections.\n\n  if (!alpha) resetAlpha(dest, destW, destH);\n  return dest;\n};\n\n},{\"./convolve\":2,\"./resize_filter_gen\":6}],6:[function(_dereq_,module,exports){\n// Calculate convolution filters for each destination point,\n// and pack data to Int16Array:\n//\n// [ shift, length, data..., shift2, length2, data..., ... ]\n//\n// - shift - offset in src image\n// - length - filter length (in src points)\n// - data - filter values sequence\n//\n'use strict';\n\nvar FILTER_INFO = _dereq_('./resize_filter_info'); // Precision of fixed FP values\n\n\nvar FIXED_FRAC_BITS = 14;\n\nfunction toFixedPoint(num) {\n  return Math.round(num * ((1 << FIXED_FRAC_BITS) - 1));\n}\n\nmodule.exports = function resizeFilterGen(quality, srcSize, destSize, scale, offset) {\n  var filterFunction = FILTER_INFO[quality].filter;\n  var scaleInverted = 1.0 / scale;\n  var scaleClamped = Math.min(1.0, scale); // For upscale\n  // Filter window (averaging interval), scaled to src image\n\n  var srcWindow = FILTER_INFO[quality].win / scaleClamped;\n  var destPixel, srcPixel, srcFirst, srcLast, filterElementSize, floatFilter, fxpFilter, total, pxl, idx, floatVal, filterTotal, filterVal;\n  var leftNotEmpty, rightNotEmpty, filterShift, filterSize;\n  var maxFilterElementSize = Math.floor((srcWindow + 1) * 2);\n  var packedFilter = new Int16Array((maxFilterElementSize + 2) * destSize);\n  var packedFilterPtr = 0;\n  var slowCopy = !packedFilter.subarray || !packedFilter.set; // For each destination pixel calculate source range and built filter values\n\n  for (destPixel = 0; destPixel < destSize; destPixel++) {\n    // Scaling should be done relative to central pixel point\n    srcPixel = (destPixel + 0.5) * scaleInverted + offset;\n    srcFirst = Math.max(0, Math.floor(srcPixel - srcWindow));\n    srcLast = Math.min(srcSize - 1, Math.ceil(srcPixel + srcWindow));\n    filterElementSize = srcLast - srcFirst + 1;\n    floatFilter = new Float32Array(filterElementSize);\n    fxpFilter = new Int16Array(filterElementSize);\n    total = 0.0; // Fill filter values for calculated range\n\n    for (pxl = srcFirst, idx = 0; pxl <= srcLast; pxl++, idx++) {\n      floatVal = filterFunction((pxl + 0.5 - srcPixel) * scaleClamped);\n      total += floatVal;\n      floatFilter[idx] = floatVal;\n    } // Normalize filter, convert to fixed point and accumulate conversion error\n\n\n    filterTotal = 0;\n\n    for (idx = 0; idx < floatFilter.length; idx++) {\n      filterVal = floatFilter[idx] / total;\n      filterTotal += filterVal;\n      fxpFilter[idx] = toFixedPoint(filterVal);\n    } // Compensate normalization error, to minimize brightness drift\n\n\n    fxpFilter[destSize >> 1] += toFixedPoint(1.0 - filterTotal); //\n    // Now pack filter to useable form\n    //\n    // 1. Trim heading and tailing zero values, and compensate shitf/length\n    // 2. Put all to single array in this format:\n    //\n    //    [ pos shift, data length, value1, value2, value3, ... ]\n    //\n\n    leftNotEmpty = 0;\n\n    while (leftNotEmpty < fxpFilter.length && fxpFilter[leftNotEmpty] === 0) {\n      leftNotEmpty++;\n    }\n\n    if (leftNotEmpty < fxpFilter.length) {\n      rightNotEmpty = fxpFilter.length - 1;\n\n      while (rightNotEmpty > 0 && fxpFilter[rightNotEmpty] === 0) {\n        rightNotEmpty--;\n      }\n\n      filterShift = srcFirst + leftNotEmpty;\n      filterSize = rightNotEmpty - leftNotEmpty + 1;\n      packedFilter[packedFilterPtr++] = filterShift; // shift\n\n      packedFilter[packedFilterPtr++] = filterSize; // size\n\n      if (!slowCopy) {\n        packedFilter.set(fxpFilter.subarray(leftNotEmpty, rightNotEmpty + 1), packedFilterPtr);\n        packedFilterPtr += filterSize;\n      } else {\n        // fallback for old IE < 11, without subarray/set methods\n        for (idx = leftNotEmpty; idx <= rightNotEmpty; idx++) {\n          packedFilter[packedFilterPtr++] = fxpFilter[idx];\n        }\n      }\n    } else {\n      // zero data, write header only\n      packedFilter[packedFilterPtr++] = 0; // shift\n\n      packedFilter[packedFilterPtr++] = 0; // size\n    }\n  }\n\n  return packedFilter;\n};\n\n},{\"./resize_filter_info\":7}],7:[function(_dereq_,module,exports){\n// Filter definitions to build tables for\n// resizing convolvers.\n//\n// Presets for quality 0..3. Filter functions + window size\n//\n'use strict';\n\nmodule.exports = [{\n  // Nearest neibor (Box)\n  win: 0.5,\n  filter: function filter(x) {\n    return x >= -0.5 && x < 0.5 ? 1.0 : 0.0;\n  }\n}, {\n  // Hamming\n  win: 1.0,\n  filter: function filter(x) {\n    if (x <= -1.0 || x >= 1.0) {\n      return 0.0;\n    }\n\n    if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n      return 1.0;\n    }\n\n    var xpi = x * Math.PI;\n    return Math.sin(xpi) / xpi * (0.54 + 0.46 * Math.cos(xpi / 1.0));\n  }\n}, {\n  // Lanczos, win = 2\n  win: 2.0,\n  filter: function filter(x) {\n    if (x <= -2.0 || x >= 2.0) {\n      return 0.0;\n    }\n\n    if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n      return 1.0;\n    }\n\n    var xpi = x * Math.PI;\n    return Math.sin(xpi) / xpi * Math.sin(xpi / 2.0) / (xpi / 2.0);\n  }\n}, {\n  // Lanczos, win = 3\n  win: 3.0,\n  filter: function filter(x) {\n    if (x <= -3.0 || x >= 3.0) {\n      return 0.0;\n    }\n\n    if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n      return 1.0;\n    }\n\n    var xpi = x * Math.PI;\n    return Math.sin(xpi) / xpi * Math.sin(xpi / 3.0) / (xpi / 3.0);\n  }\n}];\n\n},{}],8:[function(_dereq_,module,exports){\n'use strict';\n\nvar createFilters = _dereq_('./resize_filter_gen');\n\nfunction resetAlpha(dst, width, height) {\n  var ptr = 3,\n      len = width * height * 4 | 0;\n\n  while (ptr < len) {\n    dst[ptr] = 0xFF;\n    ptr = ptr + 4 | 0;\n  }\n}\n\nfunction asUint8Array(src) {\n  return new Uint8Array(src.buffer, 0, src.byteLength);\n}\n\nvar IS_LE = true; // should not crash everything on module load in old browsers\n\ntry {\n  IS_LE = new Uint32Array(new Uint8Array([1, 0, 0, 0]).buffer)[0] === 1;\n} catch (__) {}\n\nfunction copyInt16asLE(src, target, target_offset) {\n  if (IS_LE) {\n    target.set(asUint8Array(src), target_offset);\n    return;\n  }\n\n  for (var ptr = target_offset, i = 0; i < src.length; i++) {\n    var data = src[i];\n    target[ptr++] = data & 0xFF;\n    target[ptr++] = data >> 8 & 0xFF;\n  }\n}\n\nmodule.exports = function resize_wasm(options) {\n  var src = options.src;\n  var srcW = options.width;\n  var srcH = options.height;\n  var destW = options.toWidth;\n  var destH = options.toHeight;\n  var scaleX = options.scaleX || options.toWidth / options.width;\n  var scaleY = options.scaleY || options.toHeight / options.height;\n  var offsetX = options.offsetX || 0.0;\n  var offsetY = options.offsetY || 0.0;\n  var dest = options.dest || new Uint8Array(destW * destH * 4);\n  var quality = typeof options.quality === 'undefined' ? 3 : options.quality;\n  var alpha = options.alpha || false;\n  var filtersX = createFilters(quality, srcW, destW, scaleX, offsetX),\n      filtersY = createFilters(quality, srcH, destH, scaleY, offsetY); // destination is 0 too.\n\n  var src_offset = 0; // buffer between convolve passes\n\n  var tmp_offset = this.__align(src_offset + Math.max(src.byteLength, dest.byteLength));\n\n  var filtersX_offset = this.__align(tmp_offset + srcH * destW * 4);\n\n  var filtersY_offset = this.__align(filtersX_offset + filtersX.byteLength);\n\n  var alloc_bytes = filtersY_offset + filtersY.byteLength;\n\n  var instance = this.__instance('resize', alloc_bytes); //\n  // Fill memory block with data to process\n  //\n\n\n  var mem = new Uint8Array(this.__memory.buffer);\n  var mem32 = new Uint32Array(this.__memory.buffer); // 32-bit copy is much faster in chrome\n\n  var src32 = new Uint32Array(src.buffer);\n  mem32.set(src32); // We should guarantee LE bytes order. Filters are not big, so\n  // speed difference is not significant vs direct .set()\n\n  copyInt16asLE(filtersX, mem, filtersX_offset);\n  copyInt16asLE(filtersY, mem, filtersY_offset); //\n  // Now call webassembly method\n  // emsdk does method names with '_'\n\n  var fn = instance.exports.convolveHV || instance.exports._convolveHV;\n  fn(filtersX_offset, filtersY_offset, tmp_offset, srcW, srcH, destW, destH); //\n  // Copy data back to typed array\n  //\n  // 32-bit copy is much faster in chrome\n\n  var dest32 = new Uint32Array(dest.buffer);\n  dest32.set(new Uint32Array(this.__memory.buffer, 0, destH * destW)); // That's faster than doing checks in convolver.\n  // !!! Note, canvas data is not premultipled. We don't need other\n  // alpha corrections.\n\n  if (!alpha) resetAlpha(dest, destW, destH);\n  return dest;\n};\n\n},{\"./resize_filter_gen\":6}],9:[function(_dereq_,module,exports){\n'use strict';\n\nvar GC_INTERVAL = 100;\n\nfunction Pool(create, idle) {\n  this.create = create;\n  this.available = [];\n  this.acquired = {};\n  this.lastId = 1;\n  this.timeoutId = 0;\n  this.idle = idle || 2000;\n}\n\nPool.prototype.acquire = function () {\n  var _this = this;\n\n  var resource;\n\n  if (this.available.length !== 0) {\n    resource = this.available.pop();\n  } else {\n    resource = this.create();\n    resource.id = this.lastId++;\n\n    resource.release = function () {\n      return _this.release(resource);\n    };\n  }\n\n  this.acquired[resource.id] = resource;\n  return resource;\n};\n\nPool.prototype.release = function (resource) {\n  var _this2 = this;\n\n  delete this.acquired[resource.id];\n  resource.lastUsed = Date.now();\n  this.available.push(resource);\n\n  if (this.timeoutId === 0) {\n    this.timeoutId = setTimeout(function () {\n      return _this2.gc();\n    }, GC_INTERVAL);\n  }\n};\n\nPool.prototype.gc = function () {\n  var _this3 = this;\n\n  var now = Date.now();\n  this.available = this.available.filter(function (resource) {\n    if (now - resource.lastUsed > _this3.idle) {\n      resource.destroy();\n      return false;\n    }\n\n    return true;\n  });\n\n  if (this.available.length !== 0) {\n    this.timeoutId = setTimeout(function () {\n      return _this3.gc();\n    }, GC_INTERVAL);\n  } else {\n    this.timeoutId = 0;\n  }\n};\n\nmodule.exports = Pool;\n\n},{}],10:[function(_dereq_,module,exports){\n// Add intermediate resizing steps when scaling down by a very large factor.\n//\n// For example, when resizing 10000x10000 down to 10x10, it'll resize it to\n// 300x300 first.\n//\n// It's needed because tiler has issues when the entire tile is scaled down\n// to a few pixels (1024px source tile with border size 3 should result in\n// at least 3+3+2 = 8px target tile, so max scale factor is 128 here).\n//\n// Also, adding intermediate steps can speed up processing if we use lower\n// quality algorithms for first stages.\n//\n'use strict'; // min size = 0 results in infinite loop,\n// min size = 1 can consume large amount of memory\n\nvar MIN_INNER_TILE_SIZE = 2;\n\nmodule.exports = function createStages(fromWidth, fromHeight, toWidth, toHeight, srcTileSize, destTileBorder) {\n  var scaleX = toWidth / fromWidth;\n  var scaleY = toHeight / fromHeight; // derived from createRegions equation:\n  // innerTileWidth = pixelFloor(srcTileSize * scaleX) - 2 * destTileBorder;\n\n  var minScale = (2 * destTileBorder + MIN_INNER_TILE_SIZE + 1) / srcTileSize; // refuse to scale image multiple times by less than twice each time,\n  // it could only happen because of invalid options\n\n  if (minScale > 0.5) return [[toWidth, toHeight]];\n  var stageCount = Math.ceil(Math.log(Math.min(scaleX, scaleY)) / Math.log(minScale)); // no additional resizes are necessary,\n  // stageCount can be zero or be negative when enlarging the image\n\n  if (stageCount <= 1) return [[toWidth, toHeight]];\n  var result = [];\n\n  for (var i = 0; i < stageCount; i++) {\n    var width = Math.round(Math.pow(Math.pow(fromWidth, stageCount - i - 1) * Math.pow(toWidth, i + 1), 1 / stageCount));\n    var height = Math.round(Math.pow(Math.pow(fromHeight, stageCount - i - 1) * Math.pow(toHeight, i + 1), 1 / stageCount));\n    result.push([width, height]);\n  }\n\n  return result;\n};\n\n},{}],11:[function(_dereq_,module,exports){\n// Split original image into multiple 1024x1024 chunks to reduce memory usage\n// (images have to be unpacked into typed arrays for resizing) and allow\n// parallel processing of multiple tiles at a time.\n//\n'use strict';\n/*\n * pixelFloor and pixelCeil are modified versions of Math.floor and Math.ceil\n * functions which take into account floating point arithmetic errors.\n * Those errors can cause undesired increments/decrements of sizes and offsets:\n * Math.ceil(36 / (36 / 500)) = 501\n * pixelCeil(36 / (36 / 500)) = 500\n */\n\nvar PIXEL_EPSILON = 1e-5;\n\nfunction pixelFloor(x) {\n  var nearest = Math.round(x);\n\n  if (Math.abs(x - nearest) < PIXEL_EPSILON) {\n    return nearest;\n  }\n\n  return Math.floor(x);\n}\n\nfunction pixelCeil(x) {\n  var nearest = Math.round(x);\n\n  if (Math.abs(x - nearest) < PIXEL_EPSILON) {\n    return nearest;\n  }\n\n  return Math.ceil(x);\n}\n\nmodule.exports = function createRegions(options) {\n  var scaleX = options.toWidth / options.width;\n  var scaleY = options.toHeight / options.height;\n  var innerTileWidth = pixelFloor(options.srcTileSize * scaleX) - 2 * options.destTileBorder;\n  var innerTileHeight = pixelFloor(options.srcTileSize * scaleY) - 2 * options.destTileBorder; // prevent infinite loop, this should never happen\n\n  if (innerTileWidth < 1 || innerTileHeight < 1) {\n    throw new Error('Internal error in pica: target tile width/height is too small.');\n  }\n\n  var x, y;\n  var innerX, innerY, toTileWidth, toTileHeight;\n  var tiles = [];\n  var tile; // we go top-to-down instead of left-to-right to make image displayed from top to\n  // doesn in the browser\n\n  for (innerY = 0; innerY < options.toHeight; innerY += innerTileHeight) {\n    for (innerX = 0; innerX < options.toWidth; innerX += innerTileWidth) {\n      x = innerX - options.destTileBorder;\n\n      if (x < 0) {\n        x = 0;\n      }\n\n      toTileWidth = innerX + innerTileWidth + options.destTileBorder - x;\n\n      if (x + toTileWidth >= options.toWidth) {\n        toTileWidth = options.toWidth - x;\n      }\n\n      y = innerY - options.destTileBorder;\n\n      if (y < 0) {\n        y = 0;\n      }\n\n      toTileHeight = innerY + innerTileHeight + options.destTileBorder - y;\n\n      if (y + toTileHeight >= options.toHeight) {\n        toTileHeight = options.toHeight - y;\n      }\n\n      tile = {\n        toX: x,\n        toY: y,\n        toWidth: toTileWidth,\n        toHeight: toTileHeight,\n        toInnerX: innerX,\n        toInnerY: innerY,\n        toInnerWidth: innerTileWidth,\n        toInnerHeight: innerTileHeight,\n        offsetX: x / scaleX - pixelFloor(x / scaleX),\n        offsetY: y / scaleY - pixelFloor(y / scaleY),\n        scaleX: scaleX,\n        scaleY: scaleY,\n        x: pixelFloor(x / scaleX),\n        y: pixelFloor(y / scaleY),\n        width: pixelCeil(toTileWidth / scaleX),\n        height: pixelCeil(toTileHeight / scaleY)\n      };\n      tiles.push(tile);\n    }\n  }\n\n  return tiles;\n};\n\n},{}],12:[function(_dereq_,module,exports){\n'use strict';\n\nfunction objClass(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nmodule.exports.isCanvas = function isCanvas(element) {\n  //return (element.nodeName && element.nodeName.toLowerCase() === 'canvas') ||\n  var cname = objClass(element);\n  return cname === '[object HTMLCanvasElement]'\n  /* browser */\n  || cname === '[object OffscreenCanvas]' || cname === '[object Canvas]'\n  /* node-canvas */\n  ;\n};\n\nmodule.exports.isImage = function isImage(element) {\n  //return element.nodeName && element.nodeName.toLowerCase() === 'img';\n  return objClass(element) === '[object HTMLImageElement]';\n};\n\nmodule.exports.limiter = function limiter(concurrency) {\n  var active = 0,\n      queue = [];\n\n  function roll() {\n    if (active < concurrency && queue.length) {\n      active++;\n      queue.shift()();\n    }\n  }\n\n  return function limit(fn) {\n    return new Promise(function (resolve, reject) {\n      queue.push(function () {\n        fn().then(function (result) {\n          resolve(result);\n          active--;\n          roll();\n        }, function (err) {\n          reject(err);\n          active--;\n          roll();\n        });\n      });\n      roll();\n    });\n  };\n};\n\nmodule.exports.cib_quality_name = function cib_quality_name(num) {\n  switch (num) {\n    case 0:\n      return 'pixelated';\n\n    case 1:\n      return 'low';\n\n    case 2:\n      return 'medium';\n  }\n\n  return 'high';\n};\n\nmodule.exports.cib_support = function cib_support() {\n  return Promise.resolve().then(function () {\n    if (typeof createImageBitmap === 'undefined' || typeof document === 'undefined') {\n      return false;\n    }\n\n    var c = document.createElement('canvas');\n    c.width = 100;\n    c.height = 100;\n    return createImageBitmap(c, 0, 0, 100, 100, {\n      resizeWidth: 10,\n      resizeHeight: 10,\n      resizeQuality: 'high'\n    }).then(function (bitmap) {\n      var status = bitmap.width === 10; // Branch below is filtered on upper level. We do not call resize\n      // detection for basic ImageBitmap.\n      //\n      // https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap\n      // old Crome 51 has ImageBitmap without .close(). Then this code\n      // will throw and return 'false' as expected.\n      //\n\n      bitmap.close();\n      c = null;\n      return status;\n    });\n  })[\"catch\"](function () {\n    return false;\n  });\n};\n\n},{}],13:[function(_dereq_,module,exports){\n// Web Worker wrapper for image resize function\n'use strict';\n\nmodule.exports = function () {\n  var MathLib = _dereq_('./mathlib');\n\n  var mathLib;\n  /* eslint-disable no-undef */\n\n  onmessage = function onmessage(ev) {\n    var opts = ev.data.opts;\n    if (!mathLib) mathLib = new MathLib(ev.data.features); // Use multimath's sync auto-init. Avoid Promise use in old browsers,\n    // because polyfills are not propagated to webworker.\n\n    var result = mathLib.resizeAndUnsharp(opts);\n    postMessage({\n      result: result\n    }, [result.buffer]);\n  };\n};\n\n},{\"./mathlib\":1}],14:[function(_dereq_,module,exports){\n// Calculate Gaussian blur of an image using IIR filter\n// The method is taken from Intel's white paper and code example attached to it:\n// https://software.intel.com/en-us/articles/iir-gaussian-blur-filter\n// -implementation-using-intel-advanced-vector-extensions\n\nvar a0, a1, a2, a3, b1, b2, left_corner, right_corner;\n\nfunction gaussCoef(sigma) {\n  if (sigma < 0.5) {\n    sigma = 0.5;\n  }\n\n  var a = Math.exp(0.726 * 0.726) / sigma,\n      g1 = Math.exp(-a),\n      g2 = Math.exp(-2 * a),\n      k = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2);\n\n  a0 = k;\n  a1 = k * (a - 1) * g1;\n  a2 = k * (a + 1) * g1;\n  a3 = -k * g2;\n  b1 = 2 * g1;\n  b2 = -g2;\n  left_corner = (a0 + a1) / (1 - b1 - b2);\n  right_corner = (a2 + a3) / (1 - b1 - b2);\n\n  // Attempt to force type to FP32.\n  return new Float32Array([ a0, a1, a2, a3, b1, b2, left_corner, right_corner ]);\n}\n\nfunction convolveMono16(src, out, line, coeff, width, height) {\n  // takes src image and writes the blurred and transposed result into out\n\n  var prev_src, curr_src, curr_out, prev_out, prev_prev_out;\n  var src_index, out_index, line_index;\n  var i, j;\n  var coeff_a0, coeff_a1, coeff_b1, coeff_b2;\n\n  for (i = 0; i < height; i++) {\n    src_index = i * width;\n    out_index = i;\n    line_index = 0;\n\n    // left to right\n    prev_src = src[src_index];\n    prev_prev_out = prev_src * coeff[6];\n    prev_out = prev_prev_out;\n\n    coeff_a0 = coeff[0];\n    coeff_a1 = coeff[1];\n    coeff_b1 = coeff[4];\n    coeff_b2 = coeff[5];\n\n    for (j = 0; j < width; j++) {\n      curr_src = src[src_index];\n\n      curr_out = curr_src * coeff_a0 +\n                 prev_src * coeff_a1 +\n                 prev_out * coeff_b1 +\n                 prev_prev_out * coeff_b2;\n\n      prev_prev_out = prev_out;\n      prev_out = curr_out;\n      prev_src = curr_src;\n\n      line[line_index] = prev_out;\n      line_index++;\n      src_index++;\n    }\n\n    src_index--;\n    line_index--;\n    out_index += height * (width - 1);\n\n    // right to left\n    prev_src = src[src_index];\n    prev_prev_out = prev_src * coeff[7];\n    prev_out = prev_prev_out;\n    curr_src = prev_src;\n\n    coeff_a0 = coeff[2];\n    coeff_a1 = coeff[3];\n\n    for (j = width - 1; j >= 0; j--) {\n      curr_out = curr_src * coeff_a0 +\n                 prev_src * coeff_a1 +\n                 prev_out * coeff_b1 +\n                 prev_prev_out * coeff_b2;\n\n      prev_prev_out = prev_out;\n      prev_out = curr_out;\n\n      prev_src = curr_src;\n      curr_src = src[src_index];\n\n      out[out_index] = line[line_index] + prev_out;\n\n      src_index--;\n      line_index--;\n      out_index -= height;\n    }\n  }\n}\n\n\nfunction blurMono16(src, width, height, radius) {\n  // Quick exit on zero radius\n  if (!radius) { return; }\n\n  var out      = new Uint16Array(src.length),\n      tmp_line = new Float32Array(Math.max(width, height));\n\n  var coeff = gaussCoef(radius);\n\n  convolveMono16(src, out, tmp_line, coeff, width, height, radius);\n  convolveMono16(out, src, tmp_line, coeff, height, width, radius);\n}\n\nmodule.exports = blurMono16;\n\n},{}],15:[function(_dereq_,module,exports){\nif (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n\n},{}],16:[function(_dereq_,module,exports){\n'use strict';\n\n\nvar assign         = _dereq_('object-assign');\nvar base64decode   = _dereq_('./lib/base64decode');\nvar hasWebAssembly = _dereq_('./lib/wa_detect');\n\n\nvar DEFAULT_OPTIONS = {\n  js: true,\n  wasm: true\n};\n\n\nfunction MultiMath(options) {\n  if (!(this instanceof MultiMath)) return new MultiMath(options);\n\n  var opts = assign({}, DEFAULT_OPTIONS, options || {});\n\n  this.options         = opts;\n\n  this.__cache         = {};\n\n  this.__init_promise  = null;\n  this.__modules       = opts.modules || {};\n  this.__memory        = null;\n  this.__wasm          = {};\n\n  this.__isLE = ((new Uint32Array((new Uint8Array([ 1, 0, 0, 0 ])).buffer))[0] === 1);\n\n  if (!this.options.js && !this.options.wasm) {\n    throw new Error('mathlib: at least \"js\" or \"wasm\" should be enabled');\n  }\n}\n\n\nMultiMath.prototype.has_wasm = hasWebAssembly;\n\n\nMultiMath.prototype.use = function (module) {\n  this.__modules[module.name] = module;\n\n  // Pin the best possible implementation\n  if (this.options.wasm && this.has_wasm() && module.wasm_fn) {\n    this[module.name] = module.wasm_fn;\n  } else {\n    this[module.name] = module.fn;\n  }\n\n  return this;\n};\n\n\nMultiMath.prototype.init = function () {\n  if (this.__init_promise) return this.__init_promise;\n\n  if (!this.options.js && this.options.wasm && !this.has_wasm()) {\n    return Promise.reject(new Error('mathlib: only \"wasm\" was enabled, but it\\'s not supported'));\n  }\n\n  var self = this;\n\n  this.__init_promise = Promise.all(Object.keys(self.__modules).map(function (name) {\n    var module = self.__modules[name];\n\n    if (!self.options.wasm || !self.has_wasm() || !module.wasm_fn) return null;\n\n    // If already compiled - exit\n    if (self.__wasm[name]) return null;\n\n    // Compile wasm source\n    return WebAssembly.compile(self.__base64decode(module.wasm_src))\n      .then(function (m) { self.__wasm[name] = m; });\n  }))\n    .then(function () { return self; });\n\n  return this.__init_promise;\n};\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Methods below are for internal use from plugins\n\n\n// Simple decode base64 to typed array. Useful to load embedded webassembly\n// code. You probably don't need to call this method directly.\n//\nMultiMath.prototype.__base64decode = base64decode;\n\n\n// Increase current memory to include specified number of bytes. Do nothing if\n// size is already ok. You probably don't need to call this method directly,\n// because it will be invoked from `.__instance()`.\n//\nMultiMath.prototype.__reallocate = function mem_grow_to(bytes) {\n  if (!this.__memory) {\n    this.__memory = new WebAssembly.Memory({\n      initial: Math.ceil(bytes / (64 * 1024))\n    });\n    return this.__memory;\n  }\n\n  var mem_size = this.__memory.buffer.byteLength;\n\n  if (mem_size < bytes) {\n    this.__memory.grow(Math.ceil((bytes - mem_size) / (64 * 1024)));\n  }\n\n  return this.__memory;\n};\n\n\n// Returns instantinated webassembly item by name, with specified memory size\n// and environment.\n// - use cache if available\n// - do sync module init, if async init was not called earlier\n// - allocate memory if not enougth\n// - can export functions to webassembly via \"env_extra\",\n//   for example, { exp: Math.exp }\n//\nMultiMath.prototype.__instance = function instance(name, memsize, env_extra) {\n  if (memsize) this.__reallocate(memsize);\n\n  // If .init() was not called, do sync compile\n  if (!this.__wasm[name]) {\n    var module = this.__modules[name];\n    this.__wasm[name] = new WebAssembly.Module(this.__base64decode(module.wasm_src));\n  }\n\n  if (!this.__cache[name]) {\n    var env_base = {\n      memoryBase: 0,\n      memory: this.__memory,\n      tableBase: 0,\n      table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' })\n    };\n\n    this.__cache[name] = new WebAssembly.Instance(this.__wasm[name], {\n      env: assign(env_base, env_extra || {})\n    });\n  }\n\n  return this.__cache[name];\n};\n\n\n// Helper to calculate memory aligh for pointers. Webassembly does not require\n// this, but you may wish to experiment. Default base = 8;\n//\nMultiMath.prototype.__align = function align(number, base) {\n  base = base || 8;\n  var reminder = number % base;\n  return number + (reminder ? base - reminder : 0);\n};\n\n\nmodule.exports = MultiMath;\n\n},{\"./lib/base64decode\":17,\"./lib/wa_detect\":23,\"object-assign\":24}],17:[function(_dereq_,module,exports){\n// base64 decode str -> Uint8Array, to load WA modules\n//\n'use strict';\n\n\nvar BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n\nmodule.exports = function base64decode(str) {\n  var input = str.replace(/[\\r\\n=]/g, ''), // remove CR/LF & padding to simplify scan\n      max   = input.length;\n\n  var out = new Uint8Array((max * 3) >> 2);\n\n  // Collect by 6*4 bits (3 bytes)\n\n  var bits = 0;\n  var ptr  = 0;\n\n  for (var idx = 0; idx < max; idx++) {\n    if ((idx % 4 === 0) && idx) {\n      out[ptr++] = (bits >> 16) & 0xFF;\n      out[ptr++] = (bits >> 8) & 0xFF;\n      out[ptr++] = bits & 0xFF;\n    }\n\n    bits = (bits << 6) | BASE64_MAP.indexOf(input.charAt(idx));\n  }\n\n  // Dump tail\n\n  var tailbits = (max % 4) * 6;\n\n  if (tailbits === 0) {\n    out[ptr++] = (bits >> 16) & 0xFF;\n    out[ptr++] = (bits >> 8) & 0xFF;\n    out[ptr++] = bits & 0xFF;\n  } else if (tailbits === 18) {\n    out[ptr++] = (bits >> 10) & 0xFF;\n    out[ptr++] = (bits >> 2) & 0xFF;\n  } else if (tailbits === 12) {\n    out[ptr++] = (bits >> 4) & 0xFF;\n  }\n\n  return out;\n};\n\n},{}],18:[function(_dereq_,module,exports){\n// Calculates 16-bit precision HSL lightness from 8-bit rgba buffer\n//\n'use strict';\n\n\nmodule.exports = function hsl_l16_js(img, width, height) {\n  var size = width * height;\n  var out = new Uint16Array(size);\n  var r, g, b, min, max;\n  for (var i = 0; i < size; i++) {\n    r = img[4 * i];\n    g = img[4 * i + 1];\n    b = img[4 * i + 2];\n    max = (r >= g && r >= b) ? r : (g >= b && g >= r) ? g : b;\n    min = (r <= g && r <= b) ? r : (g <= b && g <= r) ? g : b;\n    out[i] = (max + min) * 257 >> 1;\n  }\n  return out;\n};\n\n},{}],19:[function(_dereq_,module,exports){\n'use strict';\n\nmodule.exports = {\n  name:     'unsharp_mask',\n  fn:       _dereq_('./unsharp_mask'),\n  wasm_fn:  _dereq_('./unsharp_mask_wasm'),\n  wasm_src: _dereq_('./unsharp_mask_wasm_base64')\n};\n\n},{\"./unsharp_mask\":20,\"./unsharp_mask_wasm\":21,\"./unsharp_mask_wasm_base64\":22}],20:[function(_dereq_,module,exports){\n// Unsharp mask filter\n//\n// http://stackoverflow.com/a/23322820/1031804\n// USM(O) = O + (2 * (Amount / 100) * (O - GB))\n// GB - gaussian blur.\n//\n// Image is converted from RGB to HSL, unsharp mask is applied to the\n// lightness channel and then image is converted back to RGB.\n//\n'use strict';\n\n\nvar glur_mono16 = _dereq_('glur/mono16');\nvar hsl_l16     = _dereq_('./hsl_l16');\n\n\nmodule.exports = function unsharp(img, width, height, amount, radius, threshold) {\n  var r, g, b;\n  var h, s, l;\n  var min, max;\n  var m1, m2, hShifted;\n  var diff, iTimes4;\n\n  if (amount === 0 || radius < 0.5) {\n    return;\n  }\n  if (radius > 2.0) {\n    radius = 2.0;\n  }\n\n  var lightness = hsl_l16(img, width, height);\n\n  var blured = new Uint16Array(lightness); // copy, because blur modify src\n\n  glur_mono16(blured, width, height, radius);\n\n  var amountFp = (amount / 100 * 0x1000 + 0.5)|0;\n  var thresholdFp = (threshold * 257)|0;\n\n  var size = width * height;\n\n  /* eslint-disable indent */\n  for (var i = 0; i < size; i++) {\n    diff = 2 * (lightness[i] - blured[i]);\n\n    if (Math.abs(diff) >= thresholdFp) {\n      iTimes4 = i * 4;\n      r = img[iTimes4];\n      g = img[iTimes4 + 1];\n      b = img[iTimes4 + 2];\n\n      // convert RGB to HSL\n      // take RGB, 8-bit unsigned integer per each channel\n      // save HSL, H and L are 16-bit unsigned integers, S is 12-bit unsigned integer\n      // math is taken from here: http://www.easyrgb.com/index.php?X=MATH&H=18\n      // and adopted to be integer (fixed point in fact) for sake of performance\n      max = (r >= g && r >= b) ? r : (g >= r && g >= b) ? g : b; // min and max are in [0..0xff]\n      min = (r <= g && r <= b) ? r : (g <= r && g <= b) ? g : b;\n      l = (max + min) * 257 >> 1; // l is in [0..0xffff] that is caused by multiplication by 257\n\n      if (min === max) {\n        h = s = 0;\n      } else {\n        s = (l <= 0x7fff) ?\n          (((max - min) * 0xfff) / (max + min))|0 :\n          (((max - min) * 0xfff) / (2 * 0xff - max - min))|0; // s is in [0..0xfff]\n        // h could be less 0, it will be fixed in backward conversion to RGB, |h| <= 0xffff / 6\n        h = (r === max) ? (((g - b) * 0xffff) / (6 * (max - min)))|0\n          : (g === max) ? 0x5555 + ((((b - r) * 0xffff) / (6 * (max - min)))|0) // 0x5555 == 0xffff / 3\n          : 0xaaaa + ((((r - g) * 0xffff) / (6 * (max - min)))|0); // 0xaaaa == 0xffff * 2 / 3\n      }\n\n      // add unsharp mask mask to the lightness channel\n      l += (amountFp * diff + 0x800) >> 12;\n      if (l > 0xffff) {\n        l = 0xffff;\n      } else if (l < 0) {\n        l = 0;\n      }\n\n      // convert HSL back to RGB\n      // for information about math look above\n      if (s === 0) {\n        r = g = b = l >> 8;\n      } else {\n        m2 = (l <= 0x7fff) ? (l * (0x1000 + s) + 0x800) >> 12 :\n          l  + (((0xffff - l) * s + 0x800) >>  12);\n        m1 = 2 * l - m2 >> 8;\n        m2 >>= 8;\n        // save result to RGB channels\n        // R channel\n        hShifted = (h + 0x5555) & 0xffff; // 0x5555 == 0xffff / 3\n        r = (hShifted >= 0xaaaa) ? m1 // 0xaaaa == 0xffff * 2 / 3\n          : (hShifted >= 0x7fff) ?  m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16)\n          : (hShifted >= 0x2aaa) ? m2 // 0x2aaa == 0xffff / 6\n          : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n        // G channel\n        hShifted = h & 0xffff;\n        g = (hShifted >= 0xaaaa) ? m1 // 0xaaaa == 0xffff * 2 / 3\n          : (hShifted >= 0x7fff) ?  m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16)\n          : (hShifted >= 0x2aaa) ? m2 // 0x2aaa == 0xffff / 6\n          : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n        // B channel\n        hShifted = (h - 0x5555) & 0xffff;\n        b = (hShifted >= 0xaaaa) ? m1 // 0xaaaa == 0xffff * 2 / 3\n          : (hShifted >= 0x7fff) ?  m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16)\n          : (hShifted >= 0x2aaa) ? m2 // 0x2aaa == 0xffff / 6\n          : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n      }\n\n      img[iTimes4] = r;\n      img[iTimes4 + 1] = g;\n      img[iTimes4 + 2] = b;\n    }\n  }\n};\n\n},{\"./hsl_l16\":18,\"glur/mono16\":14}],21:[function(_dereq_,module,exports){\n'use strict';\n\n\nmodule.exports = function unsharp(img, width, height, amount, radius, threshold) {\n  if (amount === 0 || radius < 0.5) {\n    return;\n  }\n\n  if (radius > 2.0) {\n    radius = 2.0;\n  }\n\n  var pixels = width * height;\n\n  var img_bytes_cnt        = pixels * 4;\n  var hsl_bytes_cnt        = pixels * 2;\n  var blur_bytes_cnt       = pixels * 2;\n  var blur_line_byte_cnt   = Math.max(width, height) * 4; // float32 array\n  var blur_coeffs_byte_cnt = 8 * 4; // float32 array\n\n  var img_offset         = 0;\n  var hsl_offset         = img_bytes_cnt;\n  var blur_offset        = hsl_offset + hsl_bytes_cnt;\n  var blur_tmp_offset    = blur_offset + blur_bytes_cnt;\n  var blur_line_offset   = blur_tmp_offset + blur_bytes_cnt;\n  var blur_coeffs_offset = blur_line_offset + blur_line_byte_cnt;\n\n  var instance = this.__instance(\n    'unsharp_mask',\n    img_bytes_cnt + hsl_bytes_cnt + blur_bytes_cnt * 2 + blur_line_byte_cnt + blur_coeffs_byte_cnt,\n    { exp: Math.exp }\n  );\n\n  // 32-bit copy is much faster in chrome\n  var img32 = new Uint32Array(img.buffer);\n  var mem32 = new Uint32Array(this.__memory.buffer);\n  mem32.set(img32);\n\n  // HSL\n  var fn = instance.exports.hsl_l16 || instance.exports._hsl_l16;\n  fn(img_offset, hsl_offset, width, height);\n\n  // BLUR\n  fn = instance.exports.blurMono16 || instance.exports._blurMono16;\n  fn(hsl_offset, blur_offset, blur_tmp_offset,\n    blur_line_offset, blur_coeffs_offset, width, height, radius);\n\n  // UNSHARP\n  fn = instance.exports.unsharp || instance.exports._unsharp;\n  fn(img_offset, img_offset, hsl_offset,\n    blur_offset, width, height, amount, threshold);\n\n  // 32-bit copy is much faster in chrome\n  img32.set(new Uint32Array(this.__memory.buffer, 0, pixels));\n};\n\n},{}],22:[function(_dereq_,module,exports){\n// This is autogenerated file from math.wasm, don't edit.\n//\n'use strict';\n\n/* eslint-disable max-len */\nmodule.exports = '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';\n\n},{}],23:[function(_dereq_,module,exports){\n// Detect WebAssembly support.\n// - Check global WebAssembly object\n// - Try to load simple module (can be disabled via CSP)\n//\n'use strict';\n\n\nvar wa;\n\n\nmodule.exports = function hasWebAssembly() {\n  // use cache if called before;\n  if (typeof wa !== 'undefined') return wa;\n\n  wa = false;\n\n  if (typeof WebAssembly === 'undefined') return wa;\n\n  // If WebAssenbly is disabled, code can throw on compile\n  try {\n    // https://github.com/brion/min-wasm-fail/blob/master/min-wasm-fail.in.js\n    // Additional check that WA internals are correct\n\n    /* eslint-disable comma-spacing, max-len */\n    var bin      = new Uint8Array([ 0,97,115,109,1,0,0,0,1,6,1,96,1,127,1,127,3,2,1,0,5,3,1,0,1,7,8,1,4,116,101,115,116,0,0,10,16,1,14,0,32,0,65,1,54,2,0,32,0,40,2,0,11 ]);\n    var module   = new WebAssembly.Module(bin);\n    var instance = new WebAssembly.Instance(module, {});\n\n    // test storing to and loading from a non-zero location via a parameter.\n    // Safari on iOS 11.2.5 returns 0 unexpectedly at non-zero locations\n    if (instance.exports.test(4) !== 0) wa = true;\n\n    return wa;\n  } catch (__) {}\n\n  return wa;\n};\n\n},{}],24:[function(_dereq_,module,exports){\n/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n\n},{}],25:[function(_dereq_,module,exports){\nvar bundleFn = arguments[3];\nvar sources = arguments[4];\nvar cache = arguments[5];\n\nvar stringify = JSON.stringify;\n\nmodule.exports = function (fn, options) {\n    var wkey;\n    var cacheKeys = Object.keys(cache);\n\n    for (var i = 0, l = cacheKeys.length; i < l; i++) {\n        var key = cacheKeys[i];\n        var exp = cache[key].exports;\n        // Using babel as a transpiler to use esmodule, the export will always\n        // be an object with the default export as a property of it. To ensure\n        // the existing api and babel esmodule exports are both supported we\n        // check for both\n        if (exp === fn || exp && exp.default === fn) {\n            wkey = key;\n            break;\n        }\n    }\n\n    if (!wkey) {\n        wkey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);\n        var wcache = {};\n        for (var i = 0, l = cacheKeys.length; i < l; i++) {\n            var key = cacheKeys[i];\n            wcache[key] = key;\n        }\n        sources[wkey] = [\n            'function(require,module,exports){' + fn + '(self); }',\n            wcache\n        ];\n    }\n    var skey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);\n\n    var scache = {}; scache[wkey] = wkey;\n    sources[skey] = [\n        'function(require,module,exports){' +\n            // try to call default if defined to also support babel esmodule exports\n            'var f = require(' + stringify(wkey) + ');' +\n            '(f.default ? f.default : f)(self);' +\n        '}',\n        scache\n    ];\n\n    var workerSources = {};\n    resolveSources(skey);\n\n    function resolveSources(key) {\n        workerSources[key] = true;\n\n        for (var depPath in sources[key][1]) {\n            var depKey = sources[key][1][depPath];\n            if (!workerSources[depKey]) {\n                resolveSources(depKey);\n            }\n        }\n    }\n\n    var src = '(' + bundleFn + ')({'\n        + Object.keys(workerSources).map(function (key) {\n            return stringify(key) + ':['\n                + sources[key][0]\n                + ',' + stringify(sources[key][1]) + ']'\n            ;\n        }).join(',')\n        + '},{},[' + stringify(skey) + '])'\n    ;\n\n    var URL = window.URL || window.webkitURL || window.mozURL || window.msURL;\n\n    var blob = new Blob([src], { type: 'text/javascript' });\n    if (options && options.bare) { return blob; }\n    var workerUrl = URL.createObjectURL(blob);\n    var worker = new Worker(workerUrl);\n    worker.objectURL = workerUrl;\n    return worker;\n};\n\n},{}],\"/\":[function(_dereq_,module,exports){\n'use strict';\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar assign = _dereq_('object-assign');\n\nvar webworkify = _dereq_('webworkify');\n\nvar MathLib = _dereq_('./lib/mathlib');\n\nvar Pool = _dereq_('./lib/pool');\n\nvar utils = _dereq_('./lib/utils');\n\nvar worker = _dereq_('./lib/worker');\n\nvar createStages = _dereq_('./lib/stepper');\n\nvar createRegions = _dereq_('./lib/tiler'); // Deduplicate pools & limiters with the same configs\n// when user creates multiple pica instances.\n\n\nvar singletones = {};\nvar NEED_SAFARI_FIX = false;\n\ntry {\n  if (typeof navigator !== 'undefined' && navigator.userAgent) {\n    NEED_SAFARI_FIX = navigator.userAgent.indexOf('Safari') >= 0;\n  }\n} catch (e) {}\n\nvar concurrency = 1;\n\nif (typeof navigator !== 'undefined') {\n  concurrency = Math.min(navigator.hardwareConcurrency || 1, 4);\n}\n\nvar DEFAULT_PICA_OPTS = {\n  tile: 1024,\n  concurrency: concurrency,\n  features: ['js', 'wasm', 'ww'],\n  idle: 2000\n};\nvar DEFAULT_RESIZE_OPTS = {\n  quality: 3,\n  alpha: false,\n  unsharpAmount: 0,\n  unsharpRadius: 0.0,\n  unsharpThreshold: 0\n};\nvar CAN_NEW_IMAGE_DATA;\nvar CAN_CREATE_IMAGE_BITMAP;\n\nfunction workerFabric() {\n  return {\n    value: webworkify(worker),\n    destroy: function destroy() {\n      this.value.terminate();\n\n      if (typeof window !== 'undefined') {\n        var url = window.URL || window.webkitURL || window.mozURL || window.msURL;\n\n        if (url && url.revokeObjectURL && this.value.objectURL) {\n          url.revokeObjectURL(this.value.objectURL);\n        }\n      }\n    }\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n// API methods\n\n\nfunction Pica(options) {\n  if (!(this instanceof Pica)) return new Pica(options);\n  this.options = assign({}, DEFAULT_PICA_OPTS, options || {});\n  var limiter_key = \"lk_\".concat(this.options.concurrency); // Share limiters to avoid multiple parallel workers when user creates\n  // multiple pica instances.\n\n  this.__limit = singletones[limiter_key] || utils.limiter(this.options.concurrency);\n  if (!singletones[limiter_key]) singletones[limiter_key] = this.__limit; // List of supported features, according to options & browser/node.js\n\n  this.features = {\n    js: false,\n    // pure JS implementation, can be disabled for testing\n    wasm: false,\n    // webassembly implementation for heavy functions\n    cib: false,\n    // resize via createImageBitmap (only FF at this moment)\n    ww: false // webworkers\n\n  };\n  this.__workersPool = null; // Store requested features for webworkers\n\n  this.__requested_features = [];\n  this.__mathlib = null;\n}\n\nPica.prototype.init = function () {\n  var _this = this;\n\n  if (this.__initPromise) return this.__initPromise; // Test if we can create ImageData without canvas and memory copy\n\n  if (CAN_NEW_IMAGE_DATA !== false && CAN_NEW_IMAGE_DATA !== true) {\n    CAN_NEW_IMAGE_DATA = false;\n\n    if (typeof ImageData !== 'undefined' && typeof Uint8ClampedArray !== 'undefined') {\n      try {\n        /* eslint-disable no-new */\n        new ImageData(new Uint8ClampedArray(400), 10, 10);\n        CAN_NEW_IMAGE_DATA = true;\n      } catch (__) {}\n    }\n  } // ImageBitmap can be effective in 2 places:\n  //\n  // 1. Threaded jpeg unpack (basic)\n  // 2. Built-in resize (blocked due problem in chrome, see issue #89)\n  //\n  // For basic use we also need ImageBitmap wo support .close() method,\n  // see https://developer.mozilla.org/ru/docs/Web/API/ImageBitmap\n\n\n  if (CAN_CREATE_IMAGE_BITMAP !== false && CAN_CREATE_IMAGE_BITMAP !== true) {\n    CAN_CREATE_IMAGE_BITMAP = false;\n\n    if (typeof ImageBitmap !== 'undefined') {\n      if (ImageBitmap.prototype && ImageBitmap.prototype.close) {\n        CAN_CREATE_IMAGE_BITMAP = true;\n      } else {\n        this.debug('ImageBitmap does not support .close(), disabled');\n      }\n    }\n  }\n\n  var features = this.options.features.slice();\n\n  if (features.indexOf('all') >= 0) {\n    features = ['cib', 'wasm', 'js', 'ww'];\n  }\n\n  this.__requested_features = features;\n  this.__mathlib = new MathLib(features); // Check WebWorker support if requested\n\n  if (features.indexOf('ww') >= 0) {\n    if (typeof window !== 'undefined' && 'Worker' in window) {\n      // IE <= 11 don't allow to create webworkers from string. We should check it.\n      // https://connect.microsoft.com/IE/feedback/details/801810/web-workers-from-blob-urls-in-ie-10-and-11\n      try {\n        var wkr = _dereq_('webworkify')(function () {});\n\n        wkr.terminate();\n        this.features.ww = true; // pool uniqueness depends on pool config + webworker config\n\n        var wpool_key = \"wp_\".concat(JSON.stringify(this.options));\n\n        if (singletones[wpool_key]) {\n          this.__workersPool = singletones[wpool_key];\n        } else {\n          this.__workersPool = new Pool(workerFabric, this.options.idle);\n          singletones[wpool_key] = this.__workersPool;\n        }\n      } catch (__) {}\n    }\n  }\n\n  var initMath = this.__mathlib.init().then(function (mathlib) {\n    // Copy detected features\n    assign(_this.features, mathlib.features);\n  });\n\n  var checkCibResize;\n\n  if (!CAN_CREATE_IMAGE_BITMAP) {\n    checkCibResize = Promise.resolve(false);\n  } else {\n    checkCibResize = utils.cib_support().then(function (status) {\n      if (_this.features.cib && features.indexOf('cib') < 0) {\n        _this.debug('createImageBitmap() resize supported, but disabled by config');\n\n        return;\n      }\n\n      if (features.indexOf('cib') >= 0) _this.features.cib = status;\n    });\n  } // Init math lib. That's async because can load some\n\n\n  this.__initPromise = Promise.all([initMath, checkCibResize]).then(function () {\n    return _this;\n  });\n  return this.__initPromise;\n};\n\nPica.prototype.resize = function (from, to, options) {\n  var _this2 = this;\n\n  this.debug('Start resize...');\n  var opts = assign({}, DEFAULT_RESIZE_OPTS);\n\n  if (!isNaN(options)) {\n    opts = assign(opts, {\n      quality: options\n    });\n  } else if (options) {\n    opts = assign(opts, options);\n  }\n\n  opts.toWidth = to.width;\n  opts.toHeight = to.height;\n  opts.width = from.naturalWidth || from.width;\n  opts.height = from.naturalHeight || from.height; // Prevent stepper from infinite loop\n\n  if (to.width === 0 || to.height === 0) {\n    return Promise.reject(new Error(\"Invalid output size: \".concat(to.width, \"x\").concat(to.height)));\n  }\n\n  if (opts.unsharpRadius > 2) opts.unsharpRadius = 2;\n  var canceled = false;\n  var cancelToken = null;\n\n  if (opts.cancelToken) {\n    // Wrap cancelToken to avoid successive resolve & set flag\n    cancelToken = opts.cancelToken.then(function (data) {\n      canceled = true;\n      throw data;\n    }, function (err) {\n      canceled = true;\n      throw err;\n    });\n  }\n\n  var DEST_TILE_BORDER = 3; // Max possible filter window size\n\n  var destTileBorder = Math.ceil(Math.max(DEST_TILE_BORDER, 2.5 * opts.unsharpRadius | 0));\n  return this.init().then(function () {\n    if (canceled) return cancelToken; // if createImageBitmap supports resize, just do it and return\n\n    if (_this2.features.cib) {\n      var toCtx = to.getContext('2d', {\n        alpha: Boolean(opts.alpha)\n      });\n\n      _this2.debug('Resize via createImageBitmap()');\n\n      return createImageBitmap(from, {\n        resizeWidth: opts.toWidth,\n        resizeHeight: opts.toHeight,\n        resizeQuality: utils.cib_quality_name(opts.quality)\n      }).then(function (imageBitmap) {\n        if (canceled) return cancelToken; // if no unsharp - draw directly to output canvas\n\n        if (!opts.unsharpAmount) {\n          toCtx.drawImage(imageBitmap, 0, 0);\n          imageBitmap.close();\n          toCtx = null;\n\n          _this2.debug('Finished!');\n\n          return to;\n        }\n\n        _this2.debug('Unsharp result');\n\n        var tmpCanvas = document.createElement('canvas');\n        tmpCanvas.width = opts.toWidth;\n        tmpCanvas.height = opts.toHeight;\n        var tmpCtx = tmpCanvas.getContext('2d', {\n          alpha: Boolean(opts.alpha)\n        });\n        tmpCtx.drawImage(imageBitmap, 0, 0);\n        imageBitmap.close();\n        var iData = tmpCtx.getImageData(0, 0, opts.toWidth, opts.toHeight);\n\n        _this2.__mathlib.unsharp_mask(iData.data, opts.toWidth, opts.toHeight, opts.unsharpAmount, opts.unsharpRadius, opts.unsharpThreshold);\n\n        toCtx.putImageData(iData, 0, 0);\n        iData = tmpCtx = tmpCanvas = toCtx = null;\n\n        _this2.debug('Finished!');\n\n        return to;\n      });\n    } //\n    // No easy way, let's resize manually via arrays\n    //\n    // Share cache between calls:\n    //\n    // - wasm instance\n    // - wasm memory object\n    //\n\n\n    var cache = {}; // Call resizer in webworker or locally, depending on config\n\n    var invokeResize = function invokeResize(opts) {\n      return Promise.resolve().then(function () {\n        if (!_this2.features.ww) return _this2.__mathlib.resizeAndUnsharp(opts, cache);\n        return new Promise(function (resolve, reject) {\n          var w = _this2.__workersPool.acquire();\n\n          if (cancelToken) cancelToken[\"catch\"](function (err) {\n            return reject(err);\n          });\n\n          w.value.onmessage = function (ev) {\n            w.release();\n            if (ev.data.err) reject(ev.data.err);else resolve(ev.data.result);\n          };\n\n          w.value.postMessage({\n            opts: opts,\n            features: _this2.__requested_features,\n            preload: {\n              wasm_nodule: _this2.__mathlib.__\n            }\n          }, [opts.src.buffer]);\n        });\n      });\n    };\n\n    var tileAndResize = function tileAndResize(from, to, opts) {\n      var srcCtx;\n      var srcImageBitmap;\n      var toCtx;\n\n      var processTile = function processTile(tile) {\n        return _this2.__limit(function () {\n          if (canceled) return cancelToken;\n          var srcImageData; // Extract tile RGBA buffer, depending on input type\n\n          if (utils.isCanvas(from)) {\n            _this2.debug('Get tile pixel data'); // If input is Canvas - extract region data directly\n\n\n            srcImageData = srcCtx.getImageData(tile.x, tile.y, tile.width, tile.height);\n          } else {\n            // If input is Image or decoded to ImageBitmap,\n            // draw region to temporary canvas and extract data from it\n            //\n            // Note! Attempt to reuse this canvas causes significant slowdown in chrome\n            //\n            _this2.debug('Draw tile imageBitmap/image to temporary canvas');\n\n            var tmpCanvas = document.createElement('canvas');\n            tmpCanvas.width = tile.width;\n            tmpCanvas.height = tile.height;\n            var tmpCtx = tmpCanvas.getContext('2d', {\n              alpha: Boolean(opts.alpha)\n            });\n            tmpCtx.globalCompositeOperation = 'copy';\n            tmpCtx.drawImage(srcImageBitmap || from, tile.x, tile.y, tile.width, tile.height, 0, 0, tile.width, tile.height);\n\n            _this2.debug('Get tile pixel data');\n\n            srcImageData = tmpCtx.getImageData(0, 0, tile.width, tile.height);\n            tmpCtx = tmpCanvas = null;\n          }\n\n          var o = {\n            src: srcImageData.data,\n            width: tile.width,\n            height: tile.height,\n            toWidth: tile.toWidth,\n            toHeight: tile.toHeight,\n            scaleX: tile.scaleX,\n            scaleY: tile.scaleY,\n            offsetX: tile.offsetX,\n            offsetY: tile.offsetY,\n            quality: opts.quality,\n            alpha: opts.alpha,\n            unsharpAmount: opts.unsharpAmount,\n            unsharpRadius: opts.unsharpRadius,\n            unsharpThreshold: opts.unsharpThreshold\n          };\n\n          _this2.debug('Invoke resize math');\n\n          return Promise.resolve().then(function () {\n            return invokeResize(o);\n          }).then(function (result) {\n            if (canceled) return cancelToken;\n            srcImageData = null;\n            var toImageData;\n\n            _this2.debug('Convert raw rgba tile result to ImageData');\n\n            if (CAN_NEW_IMAGE_DATA) {\n              // this branch is for modern browsers\n              // If `new ImageData()` & Uint8ClampedArray suported\n              toImageData = new ImageData(new Uint8ClampedArray(result), tile.toWidth, tile.toHeight);\n            } else {\n              // fallback for `node-canvas` and old browsers\n              // (IE11 has ImageData but does not support `new ImageData()`)\n              toImageData = toCtx.createImageData(tile.toWidth, tile.toHeight);\n\n              if (toImageData.data.set) {\n                toImageData.data.set(result);\n              } else {\n                // IE9 don't have `.set()`\n                for (var i = toImageData.data.length - 1; i >= 0; i--) {\n                  toImageData.data[i] = result[i];\n                }\n              }\n            }\n\n            _this2.debug('Draw tile');\n\n            if (NEED_SAFARI_FIX) {\n              // Safari draws thin white stripes between tiles without this fix\n              toCtx.putImageData(toImageData, tile.toX, tile.toY, tile.toInnerX - tile.toX, tile.toInnerY - tile.toY, tile.toInnerWidth + 1e-5, tile.toInnerHeight + 1e-5);\n            } else {\n              toCtx.putImageData(toImageData, tile.toX, tile.toY, tile.toInnerX - tile.toX, tile.toInnerY - tile.toY, tile.toInnerWidth, tile.toInnerHeight);\n            }\n\n            return null;\n          });\n        });\n      }; // Need to normalize data source first. It can be canvas or image.\n      // If image - try to decode in background if possible\n\n\n      return Promise.resolve().then(function () {\n        toCtx = to.getContext('2d', {\n          alpha: Boolean(opts.alpha)\n        });\n\n        if (utils.isCanvas(from)) {\n          srcCtx = from.getContext('2d', {\n            alpha: Boolean(opts.alpha)\n          });\n          return null;\n        }\n\n        if (utils.isImage(from)) {\n          // try do decode image in background for faster next operations\n          if (!CAN_CREATE_IMAGE_BITMAP) return null;\n\n          _this2.debug('Decode image via createImageBitmap');\n\n          return createImageBitmap(from).then(function (imageBitmap) {\n            srcImageBitmap = imageBitmap;\n          }) // Suppress error to use fallback, if method fails\n          // https://github.com/nodeca/pica/issues/190\n\n          /* eslint-disable no-unused-vars */\n          [\"catch\"](function (e) {\n            return null;\n          });\n        }\n\n        throw new Error('\".from\" should be image or canvas');\n      }).then(function () {\n        if (canceled) return cancelToken;\n\n        _this2.debug('Calculate tiles'); //\n        // Here we are with \"normalized\" source,\n        // follow to tiling\n        //\n\n\n        var regions = createRegions({\n          width: opts.width,\n          height: opts.height,\n          srcTileSize: _this2.options.tile,\n          toWidth: opts.toWidth,\n          toHeight: opts.toHeight,\n          destTileBorder: destTileBorder\n        });\n        var jobs = regions.map(function (tile) {\n          return processTile(tile);\n        });\n\n        function cleanup() {\n          if (srcImageBitmap) {\n            srcImageBitmap.close();\n            srcImageBitmap = null;\n          }\n        }\n\n        _this2.debug('Process tiles');\n\n        return Promise.all(jobs).then(function () {\n          _this2.debug('Finished!');\n\n          cleanup();\n          return to;\n        }, function (err) {\n          cleanup();\n          throw err;\n        });\n      });\n    };\n\n    var processStages = function processStages(stages, from, to, opts) {\n      if (canceled) return cancelToken;\n\n      var _stages$shift = stages.shift(),\n          _stages$shift2 = _slicedToArray(_stages$shift, 2),\n          toWidth = _stages$shift2[0],\n          toHeight = _stages$shift2[1];\n\n      var isLastStage = stages.length === 0;\n      opts = assign({}, opts, {\n        toWidth: toWidth,\n        toHeight: toHeight,\n        // only use user-defined quality for the last stage,\n        // use simpler (Hamming) filter for the first stages where\n        // scale factor is large enough (more than 2-3)\n        quality: isLastStage ? opts.quality : Math.min(1, opts.quality)\n      });\n      var tmpCanvas;\n\n      if (!isLastStage) {\n        // create temporary canvas\n        tmpCanvas = document.createElement('canvas');\n        tmpCanvas.width = toWidth;\n        tmpCanvas.height = toHeight;\n      }\n\n      return tileAndResize(from, isLastStage ? to : tmpCanvas, opts).then(function () {\n        if (isLastStage) return to;\n        opts.width = toWidth;\n        opts.height = toHeight;\n        return processStages(stages, tmpCanvas, to, opts);\n      });\n    };\n\n    var stages = createStages(opts.width, opts.height, opts.toWidth, opts.toHeight, _this2.options.tile, destTileBorder);\n    return processStages(stages, from, to, opts);\n  });\n}; // RGBA buffer resize\n//\n\n\nPica.prototype.resizeBuffer = function (options) {\n  var _this3 = this;\n\n  var opts = assign({}, DEFAULT_RESIZE_OPTS, options);\n  return this.init().then(function () {\n    return _this3.__mathlib.resizeAndUnsharp(opts);\n  });\n};\n\nPica.prototype.toBlob = function (canvas, mimeType, quality) {\n  mimeType = mimeType || 'image/png';\n  return new Promise(function (resolve) {\n    if (canvas.toBlob) {\n      canvas.toBlob(function (blob) {\n        return resolve(blob);\n      }, mimeType, quality);\n      return;\n    }\n\n    if (canvas.convertToBlob) {\n      resolve(canvas.convertToBlob({\n        type: mimeType,\n        quality: quality\n      }));\n      return;\n    } // Fallback for old browsers\n\n\n    var asString = atob(canvas.toDataURL(mimeType, quality).split(',')[1]);\n    var len = asString.length;\n    var asBuffer = new Uint8Array(len);\n\n    for (var i = 0; i < len; i++) {\n      asBuffer[i] = asString.charCodeAt(i);\n    }\n\n    resolve(new Blob([asBuffer], {\n      type: mimeType\n    }));\n  });\n};\n\nPica.prototype.debug = function () {};\n\nmodule.exports = Pica;\n\n},{\"./lib/mathlib\":1,\"./lib/pool\":9,\"./lib/stepper\":10,\"./lib/tiler\":11,\"./lib/utils\":12,\"./lib/worker\":13,\"object-assign\":24,\"webworkify\":25}]},{},[])(\"/\")\n});\n"],"x_google_ignoreList":[]}