@vcmap/ui 5.0.0-rc.9 → 5.0.1

package/dist/assets/cesium/Workers/createVerticesFromHeightmap.js

@@ -1,3 +1,2277 @@
-define(["./Matrix2-47e98d76","./AxisAlignedBoundingBox-a655a4bc","./Transforms-c8cb8f43","./defaultValue-81eec7ed","./RuntimeError-8952249c","./TerrainEncoding-f96552d5","./ComponentDatatype-a15c9a19","./OrientedBoundingBox-fcb5b750","./WebMercatorProjection-79b3214e","./_commonjsHelpers-3aae1032-26891ab7","./createTaskProcessorWorker","./combine-3c023bda","./AttributeCompression-80665726","./WebGLConstants-508b9636","./EllipsoidTangentPlane-a01286f6","./IntersectionTests-58aa8f80","./Plane-3f01019d"],(function(e,t,i,a,n,r,s,l,o,f,u,c,d,h,m,g,p){"use strict";var x=Object.freeze({NONE:0,LERC:1});const w={};w.DEFAULT_STRUCTURE=Object.freeze({heightScale:1,heightOffset:0,elementsPerHeight:1,stride:1,elementMultiplier:256,isBigEndian:!1});const k=new e.Cartesian3,y=new e.Matrix4,I=new e.Cartesian3,b=new e.Cartesian3;w.computeVertices=function(n){const f=Math.cos,u=Math.sin,c=Math.sqrt,d=Math.atan,h=Math.exp,m=s.CesiumMath.PI_OVER_TWO,g=s.CesiumMath.toRadians,p=n.heightmap,x=n.width,U=n.height,T=n.skirtHeight,M=T>0,V=a.defaultValue(n.isGeographic,!0),v=a.defaultValue(n.ellipsoid,e.Ellipsoid.WGS84),A=1/v.maximumRadius,B=e.Rectangle.clone(n.nativeRectangle),D=e.Rectangle.clone(n.rectangle);let S,P,E,C;a.defined(D)?(S=D.west,P=D.south,E=D.east,C=D.north):V?(S=g(B.west),P=g(B.south),E=g(B.east),C=g(B.north)):(S=B.west*A,P=m-2*d(h(-B.south*A)),E=B.east*A,C=m-2*d(h(-B.north*A)));let F=n.relativeToCenter;const N=a.defined(F);F=N?F:e.Cartesian3.ZERO;const O=a.defaultValue(n.includeWebMercatorT,!1),R=a.defaultValue(n.exaggeration,1),L=a.defaultValue(n.exaggerationRelativeHeight,0),z=1!==R,H=a.defaultValue(n.structure,w.DEFAULT_STRUCTURE),_=a.defaultValue(H.heightScale,w.DEFAULT_STRUCTURE.heightScale),Y=a.defaultValue(H.heightOffset,w.DEFAULT_STRUCTURE.heightOffset),W=a.defaultValue(H.elementsPerHeight,w.DEFAULT_STRUCTURE.elementsPerHeight),X=a.defaultValue(H.stride,w.DEFAULT_STRUCTURE.stride),Z=a.defaultValue(H.elementMultiplier,w.DEFAULT_STRUCTURE.elementMultiplier),j=a.defaultValue(H.isBigEndian,w.DEFAULT_STRUCTURE.isBigEndian);let G=e.Rectangle.computeWidth(B),q=e.Rectangle.computeHeight(B);const Q=G/(x-1),J=q/(U-1);V||(G*=A,q*=A);const K=v.radiiSquared,$=K.x,ee=K.y,te=K.z;let ie=65536,ae=-65536;const ne=i.Transforms.eastNorthUpToFixedFrame(F,v),re=e.Matrix4.inverseTransformation(ne,y);let se,le;O&&(se=o.WebMercatorProjection.geodeticLatitudeToMercatorAngle(P),le=1/(o.WebMercatorProjection.geodeticLatitudeToMercatorAngle(C)-se));const oe=I;oe.x=Number.POSITIVE_INFINITY,oe.y=Number.POSITIVE_INFINITY,oe.z=Number.POSITIVE_INFINITY;const fe=b;fe.x=Number.NEGATIVE_INFINITY,fe.y=Number.NEGATIVE_INFINITY,fe.z=Number.NEGATIVE_INFINITY;let ue=Number.POSITIVE_INFINITY;const ce=x*U,de=ce+(T>0?2*x+2*U:0),he=new Array(de),me=new Array(de),ge=new Array(de),pe=O?new Array(de):[],xe=z?new Array(de):[];let we=0,ke=U,ye=0,Ie=x;M&&(--we,++ke,--ye,++Ie);const be=1e-5;for(let t=we;t<ke;++t){let i=t;i<0&&(i=0),i>=U&&(i=U-1);let a=B.north-J*i;a=V?g(a):m-2*d(h(-a*A));let n=(a-P)/(C-P);n=s.CesiumMath.clamp(n,0,1);const r=t===we,l=t===ke-1;T>0&&(r?a+=be*q:l&&(a-=be*q));const w=f(a),y=u(a),I=te*y;let b;O&&(b=(o.WebMercatorProjection.geodeticLatitudeToMercatorAngle(a)-se)*le);for(let t=ye;t<Ie;++t){let a=t;a<0&&(a=0),a>=x&&(a=x-1);const o=i*(x*X)+a*X;let d;if(1===W)d=p[o];else{let e;if(d=0,j)for(e=0;e<W;++e)d=d*Z+p[o+e];else for(e=W-1;e>=0;--e)d=d*Z+p[o+e]}d=d*_+Y,ae=Math.max(ae,d),ie=Math.min(ie,d);let h=B.west+Q*a;V?h=g(h):h*=A;let m=(h-S)/(E-S);m=s.CesiumMath.clamp(m,0,1);let M=i*x+a;if(T>0){const e=t===ye,n=t===Ie-1,s=r||l||e||n;if((r||l)&&(e||n))continue;s&&(d-=T,e?(M=ce+(U-i-1),h-=be*G):l?M=ce+U+(x-a-1):n?(M=ce+U+x+i,h+=be*G):r&&(M=ce+U+x+U+a))}const D=w*f(h),P=w*u(h),C=$*D,F=ee*P,N=1/c(C*D+F*P+I*y),R=C*N,L=F*N,H=I*N,q=new e.Cartesian3;q.x=R+D*d,q.y=L+P*d,q.z=H+y*d,e.Matrix4.multiplyByPoint(re,q,k),e.Cartesian3.minimumByComponent(k,oe,oe),e.Cartesian3.maximumByComponent(k,fe,fe),ue=Math.min(ue,d),he[M]=q,ge[M]=new e.Cartesian2(m,n),me[M]=d,O&&(pe[M]=b),z&&(xe[M]=v.geodeticSurfaceNormal(q))}}const Ue=i.BoundingSphere.fromPoints(he);let Te,Me;if(a.defined(D)&&(Te=l.OrientedBoundingBox.fromRectangle(D,ie,ae,v)),N){Me=new r.EllipsoidalOccluder(v).computeHorizonCullingPointPossiblyUnderEllipsoid(F,he,ie)}const Ve=new t.AxisAlignedBoundingBox(oe,fe,F),ve=new r.TerrainEncoding(F,Ve,ue,ae,ne,!1,O,z,R,L),Ae=new Float32Array(de*ve.stride);let Be=0;for(let e=0;e<de;++e)Be=ve.encode(Ae,Be,he[e],ge[e],me[e],void 0,pe[e],xe[e]);return{vertices:Ae,maximumHeight:ae,minimumHeight:ie,encoding:ve,boundingSphere3D:Ue,orientedBoundingBox:Te,occludeePointInScaledSpace:Me}};var U=f.createCommonjsModule((function(e){
-/* Copyright 2015-2018 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve */
-!function(){var t,i,a,n,r,s,l,o,f,u,c,d,h,m,g,p,x=(t={defaultNoDataValue:-34027999387901484e22,decode:function(e,s){var l=(s=s||{}).encodedMaskData||null===s.encodedMaskData,o=r(e,s.inputOffset||0,l),f=null!==s.noDataValue?s.noDataValue:t.defaultNoDataValue,u=i(o,s.pixelType||Float32Array,s.encodedMaskData,f,s.returnMask),c={width:o.width,height:o.height,pixelData:u.resultPixels,minValue:u.minValue,maxValue:o.pixels.maxValue,noDataValue:f};return u.resultMask&&(c.maskData=u.resultMask),s.returnEncodedMask&&o.mask&&(c.encodedMaskData=o.mask.bitset?o.mask.bitset:null),s.returnFileInfo&&(c.fileInfo=a(o),s.computeUsedBitDepths&&(c.fileInfo.bitDepths=n(o))),c}},i=function(e,t,i,a,n){var r,l,o,f=0,u=e.pixels.numBlocksX,c=e.pixels.numBlocksY,d=Math.floor(e.width/u),h=Math.floor(e.height/c),m=2*e.maxZError,g=Number.MAX_VALUE;i=i||(e.mask?e.mask.bitset:null),l=new t(e.width*e.height),n&&i&&(o=new Uint8Array(e.width*e.height));for(var p,x,w=new Float32Array(d*h),k=0;k<=c;k++){var y=k!==c?h:e.height%c;if(0!==y)for(var I=0;I<=u;I++){var b=I!==u?d:e.width%u;if(0!==b){var U,T,M,V,v=k*e.width*h+I*d,A=e.width-b,B=e.pixels.blocks[f];if(B.encoding<2?(0===B.encoding?U=B.rawData:(s(B.stuffedData,B.bitsPerPixel,B.numValidPixels,B.offset,m,w,e.pixels.maxValue),U=w),T=0):M=2===B.encoding?0:B.offset,i)for(x=0;x<y;x++){for(7&v&&(V=i[v>>3],V<<=7&v),p=0;p<b;p++)7&v||(V=i[v>>3]),128&V?(o&&(o[v]=1),g=g>(r=B.encoding<2?U[T++]:M)?r:g,l[v++]=r):(o&&(o[v]=0),l[v++]=a),V<<=1;v+=A}else if(B.encoding<2)for(x=0;x<y;x++){for(p=0;p<b;p++)g=g>(r=U[T++])?r:g,l[v++]=r;v+=A}else for(g=g>M?M:g,x=0;x<y;x++){for(p=0;p<b;p++)l[v++]=M;v+=A}if(1===B.encoding&&T!==B.numValidPixels)throw"Block and Mask do not match";f++}}}return{resultPixels:l,resultMask:o,minValue:g}},a=function(e){return{fileIdentifierString:e.fileIdentifierString,fileVersion:e.fileVersion,imageType:e.imageType,height:e.height,width:e.width,maxZError:e.maxZError,eofOffset:e.eofOffset,mask:e.mask?{numBlocksX:e.mask.numBlocksX,numBlocksY:e.mask.numBlocksY,numBytes:e.mask.numBytes,maxValue:e.mask.maxValue}:null,pixels:{numBlocksX:e.pixels.numBlocksX,numBlocksY:e.pixels.numBlocksY,numBytes:e.pixels.numBytes,maxValue:e.pixels.maxValue,noDataValue:e.noDataValue}}},n=function(e){for(var t=e.pixels.numBlocksX*e.pixels.numBlocksY,i={},a=0;a<t;a++){var n=e.pixels.blocks[a];0===n.encoding?i.float32=!0:1===n.encoding?i[n.bitsPerPixel]=!0:i[0]=!0}return Object.keys(i)},r=function(e,t,i){var a={},n=new Uint8Array(e,t,10);if(a.fileIdentifierString=String.fromCharCode.apply(null,n),"CntZImage"!==a.fileIdentifierString.trim())throw"Unexpected file identifier string: "+a.fileIdentifierString;t+=10;var r=new DataView(e,t,24);if(a.fileVersion=r.getInt32(0,!0),a.imageType=r.getInt32(4,!0),a.height=r.getUint32(8,!0),a.width=r.getUint32(12,!0),a.maxZError=r.getFloat64(16,!0),t+=24,!i)if(r=new DataView(e,t,16),a.mask={},a.mask.numBlocksY=r.getUint32(0,!0),a.mask.numBlocksX=r.getUint32(4,!0),a.mask.numBytes=r.getUint32(8,!0),a.mask.maxValue=r.getFloat32(12,!0),t+=16,a.mask.numBytes>0){var s=new Uint8Array(Math.ceil(a.width*a.height/8)),l=(r=new DataView(e,t,a.mask.numBytes)).getInt16(0,!0),o=2,f=0;do{if(l>0)for(;l--;)s[f++]=r.getUint8(o++);else{var u=r.getUint8(o++);for(l=-l;l--;)s[f++]=u}l=r.getInt16(o,!0),o+=2}while(o<a.mask.numBytes);if(-32768!==l||f<s.length)throw"Unexpected end of mask RLE encoding";a.mask.bitset=s,t+=a.mask.numBytes}else 0==(a.mask.numBytes|a.mask.numBlocksY|a.mask.maxValue)&&(a.mask.bitset=new Uint8Array(Math.ceil(a.width*a.height/8)));r=new DataView(e,t,16),a.pixels={},a.pixels.numBlocksY=r.getUint32(0,!0),a.pixels.numBlocksX=r.getUint32(4,!0),a.pixels.numBytes=r.getUint32(8,!0),a.pixels.maxValue=r.getFloat32(12,!0),t+=16;var c=a.pixels.numBlocksX,d=a.pixels.numBlocksY,h=c+(a.width%c>0?1:0),m=d+(a.height%d>0?1:0);a.pixels.blocks=new Array(h*m);for(var g=0,p=0;p<m;p++)for(var x=0;x<h;x++){var w=0,k=e.byteLength-t;r=new DataView(e,t,Math.min(10,k));var y={};a.pixels.blocks[g++]=y;var I=r.getUint8(0);if(w++,y.encoding=63&I,y.encoding>3)throw"Invalid block encoding ("+y.encoding+")";if(2!==y.encoding){if(0!==I&&2!==I){if(I>>=6,y.offsetType=I,2===I)y.offset=r.getInt8(1),w++;else if(1===I)y.offset=r.getInt16(1,!0),w+=2;else{if(0!==I)throw"Invalid block offset type";y.offset=r.getFloat32(1,!0),w+=4}if(1===y.encoding)if(I=r.getUint8(w),w++,y.bitsPerPixel=63&I,I>>=6,y.numValidPixelsType=I,2===I)y.numValidPixels=r.getUint8(w),w++;else if(1===I)y.numValidPixels=r.getUint16(w,!0),w+=2;else{if(0!==I)throw"Invalid valid pixel count type";y.numValidPixels=r.getUint32(w,!0),w+=4}}var b;if(t+=w,3!==y.encoding)if(0===y.encoding){var U=(a.pixels.numBytes-1)/4;if(U!==Math.floor(U))throw"uncompressed block has invalid length";b=new ArrayBuffer(4*U),new Uint8Array(b).set(new Uint8Array(e,t,4*U));var T=new Float32Array(b);y.rawData=T,t+=4*U}else if(1===y.encoding){var M=Math.ceil(y.numValidPixels*y.bitsPerPixel/8),V=Math.ceil(M/4);b=new ArrayBuffer(4*V),new Uint8Array(b).set(new Uint8Array(e,t,M)),y.stuffedData=new Uint32Array(b),t+=M}}else t++}return a.eofOffset=t,a},s=function(e,t,i,a,n,r,s){var l,o,f,u=(1<<t)-1,c=0,d=0,h=Math.ceil((s-a)/n),m=4*e.length-Math.ceil(t*i/8);for(e[e.length-1]<<=8*m,l=0;l<i;l++){if(0===d&&(f=e[c++],d=32),d>=t)o=f>>>d-t&u,d-=t;else{var g=t-d;o=(f&u)<<g&u,o+=(f=e[c++])>>>(d=32-g)}r[l]=o<h?a+o*n:s}return r},t),w=(l=function(e,t,i,a,n,r,s,l){var o,f,u,c,d,h=(1<<i)-1,m=0,g=0,p=4*e.length-Math.ceil(i*a/8);if(e[e.length-1]<<=8*p,n)for(o=0;o<a;o++)0===g&&(u=e[m++],g=32),g>=i?(f=u>>>g-i&h,g-=i):(f=(u&h)<<(c=i-g)&h,f+=(u=e[m++])>>>(g=32-c)),t[o]=n[f];else for(d=Math.ceil((l-r)/s),o=0;o<a;o++)0===g&&(u=e[m++],g=32),g>=i?(f=u>>>g-i&h,g-=i):(f=(u&h)<<(c=i-g)&h,f+=(u=e[m++])>>>(g=32-c)),t[o]=f<d?r+f*s:l},o=function(e,t,i,a,n,r){var s,l=(1<<t)-1,o=0,f=0,u=0,c=0,d=0,h=[],m=4*e.length-Math.ceil(t*i/8);e[e.length-1]<<=8*m;var g=Math.ceil((r-a)/n);for(f=0;f<i;f++)0===c&&(s=e[o++],c=32),c>=t?(d=s>>>c-t&l,c-=t):(d=(s&l)<<(u=t-c)&l,d+=(s=e[o++])>>>(c=32-u)),h[f]=d<g?a+d*n:r;return h.unshift(a),h},f=function(e,t,i,a,n,r,s,l){var o,f,u,c,d=(1<<i)-1,h=0,m=0,g=0;if(n)for(o=0;o<a;o++)0===m&&(u=e[h++],m=32,g=0),m>=i?(f=u>>>g&d,m-=i,g+=i):(f=u>>>g&d,m=32-(c=i-m),f|=((u=e[h++])&(1<<c)-1)<<i-c,g=c),t[o]=n[f];else{var p=Math.ceil((l-r)/s);for(o=0;o<a;o++)0===m&&(u=e[h++],m=32,g=0),m>=i?(f=u>>>g&d,m-=i,g+=i):(f=u>>>g&d,m=32-(c=i-m),f|=((u=e[h++])&(1<<c)-1)<<i-c,g=c),t[o]=f<p?r+f*s:l}return t},u=function(e,t,i,a,n,r){var s,l=(1<<t)-1,o=0,f=0,u=0,c=0,d=0,h=0,m=[],g=Math.ceil((r-a)/n);for(f=0;f<i;f++)0===c&&(s=e[o++],c=32,h=0),c>=t?(d=s>>>h&l,c-=t,h+=t):(d=s>>>h&l,c=32-(u=t-c),d|=((s=e[o++])&(1<<u)-1)<<t-u,h=u),m[f]=d<g?a+d*n:r;return m.unshift(a),m},c=function(e,t,i,a){var n,r,s,l,o=(1<<i)-1,f=0,u=0,c=4*e.length-Math.ceil(i*a/8);for(e[e.length-1]<<=8*c,n=0;n<a;n++)0===u&&(s=e[f++],u=32),u>=i?(r=s>>>u-i&o,u-=i):(r=(s&o)<<(l=i-u)&o,r+=(s=e[f++])>>>(u=32-l)),t[n]=r;return t},d=function(e,t,i,a){var n,r,s,l,o=(1<<i)-1,f=0,u=0,c=0;for(n=0;n<a;n++)0===u&&(s=e[f++],u=32,c=0),u>=i?(r=s>>>c&o,u-=i,c+=i):(r=s>>>c&o,u=32-(l=i-u),r|=((s=e[f++])&(1<<l)-1)<<i-l,c=l),t[n]=r;return t},h={HUFFMAN_LUT_BITS_MAX:12,computeChecksumFletcher32:function(e){for(var t=65535,i=65535,a=e.length,n=Math.floor(a/2),r=0;n;){var s=n>=359?359:n;n-=s;do{t+=e[r++]<<8,i+=t+=e[r++]}while(--s);t=(65535&t)+(t>>>16),i=(65535&i)+(i>>>16)}return 1&a&&(i+=t+=e[r]<<8),((i=(65535&i)+(i>>>16))<<16|(t=(65535&t)+(t>>>16)))>>>0},readHeaderInfo:function(e,t){var i=t.ptr,a=new Uint8Array(e,i,6),n={};if(n.fileIdentifierString=String.fromCharCode.apply(null,a),0!==n.fileIdentifierString.lastIndexOf("Lerc2",0))throw"Unexpected file identifier string (expect Lerc2 ): "+n.fileIdentifierString;i+=6;var r,s=new DataView(e,i,8),l=s.getInt32(0,!0);if(n.fileVersion=l,i+=4,l>=3&&(n.checksum=s.getUint32(4,!0),i+=4),s=new DataView(e,i,12),n.height=s.getUint32(0,!0),n.width=s.getUint32(4,!0),i+=8,l>=4?(n.numDims=s.getUint32(8,!0),i+=4):n.numDims=1,s=new DataView(e,i,40),n.numValidPixel=s.getUint32(0,!0),n.microBlockSize=s.getInt32(4,!0),n.blobSize=s.getInt32(8,!0),n.imageType=s.getInt32(12,!0),n.maxZError=s.getFloat64(16,!0),n.zMin=s.getFloat64(24,!0),n.zMax=s.getFloat64(32,!0),i+=40,t.headerInfo=n,t.ptr=i,l>=3&&(r=l>=4?52:48,this.computeChecksumFletcher32(new Uint8Array(e,i-r,n.blobSize-14))!==n.checksum))throw"Checksum failed.";return!0},checkMinMaxRanges:function(e,t){var i=t.headerInfo,a=this.getDataTypeArray(i.imageType),n=i.numDims*this.getDataTypeSize(i.imageType),r=this.readSubArray(e,t.ptr,a,n),s=this.readSubArray(e,t.ptr+n,a,n);t.ptr+=2*n;var l,o=!0;for(l=0;l<i.numDims;l++)if(r[l]!==s[l]){o=!1;break}return i.minValues=r,i.maxValues=s,o},readSubArray:function(e,t,i,a){var n;if(i===Uint8Array)n=new Uint8Array(e,t,a);else{var r=new ArrayBuffer(a);new Uint8Array(r).set(new Uint8Array(e,t,a)),n=new i(r)}return n},readMask:function(e,t){var i,a,n=t.ptr,r=t.headerInfo,s=r.width*r.height,l=r.numValidPixel,o=new DataView(e,n,4),f={};if(f.numBytes=o.getUint32(0,!0),n+=4,(0===l||s===l)&&0!==f.numBytes)throw"invalid mask";if(0===l)i=new Uint8Array(Math.ceil(s/8)),f.bitset=i,a=new Uint8Array(s),t.pixels.resultMask=a,n+=f.numBytes;else if(f.numBytes>0){i=new Uint8Array(Math.ceil(s/8));var u=(o=new DataView(e,n,f.numBytes)).getInt16(0,!0),c=2,d=0,h=0;do{if(u>0)for(;u--;)i[d++]=o.getUint8(c++);else for(h=o.getUint8(c++),u=-u;u--;)i[d++]=h;u=o.getInt16(c,!0),c+=2}while(c<f.numBytes);if(-32768!==u||d<i.length)throw"Unexpected end of mask RLE encoding";a=new Uint8Array(s);var m=0,g=0;for(g=0;g<s;g++)7&g?(m=i[g>>3],m<<=7&g):m=i[g>>3],128&m&&(a[g]=1);t.pixels.resultMask=a,f.bitset=i,n+=f.numBytes}return t.ptr=n,t.mask=f,!0},readDataOneSweep:function(e,t,i){var a,n=t.ptr,r=t.headerInfo,s=r.numDims,l=r.width*r.height,o=r.imageType,f=r.numValidPixel*h.getDataTypeSize(o)*s,u=t.pixels.resultMask;if(i===Uint8Array)a=new Uint8Array(e,n,f);else{var c=new ArrayBuffer(f);new Uint8Array(c).set(new Uint8Array(e,n,f)),a=new i(c)}if(a.length===l*s)t.pixels.resultPixels=a;else{t.pixels.resultPixels=new i(l*s);var d=0,m=0,g=0,p=0;if(s>1)for(g=0;g<s;g++)for(p=g*l,m=0;m<l;m++)u[m]&&(t.pixels.resultPixels[p+m]=a[d++]);else for(m=0;m<l;m++)u[m]&&(t.pixels.resultPixels[m]=a[d++])}return n+=f,t.ptr=n,!0},readHuffmanTree:function(e,t){var i=this.HUFFMAN_LUT_BITS_MAX,a=new DataView(e,t.ptr,16);if(t.ptr+=16,a.getInt32(0,!0)<2)throw"unsupported Huffman version";var n=a.getInt32(4,!0),r=a.getInt32(8,!0),s=a.getInt32(12,!0);if(r>=s)return!1;var l=new Uint32Array(s-r);h.decodeBits(e,t,l);var o,f,u,c,d=[];for(o=r;o<s;o++)d[f=o-(o<n?0:n)]={first:l[o-r],second:null};var g=e.byteLength-t.ptr,p=Math.ceil(g/4),x=new ArrayBuffer(4*p);new Uint8Array(x).set(new Uint8Array(e,t.ptr,g));var w,k=new Uint32Array(x),y=0,I=0;for(w=k[0],o=r;o<s;o++)(c=d[f=o-(o<n?0:n)].first)>0&&(d[f].second=w<<y>>>32-c,32-y>=c?32===(y+=c)&&(y=0,w=k[++I]):(y+=c-32,w=k[++I],d[f].second|=w>>>32-y));var b=0,U=0,T=new m;for(o=0;o<d.length;o++)void 0!==d[o]&&(b=Math.max(b,d[o].first));U=b>=i?i:b,b>=30&&console.log("WARning, large NUM LUT BITS IS "+b);var M,V,v,A,B,D=[];for(o=r;o<s;o++)if((c=d[f=o-(o<n?0:n)].first)>0)if(M=[c,f],c<=U)for(V=d[f].second<<U-c,v=1<<U-c,u=0;u<v;u++)D[V|u]=M;else for(V=d[f].second,B=T,A=c-1;A>=0;A--)V>>>A&1?(B.right||(B.right=new m),B=B.right):(B.left||(B.left=new m),B=B.left),0!==A||B.val||(B.val=M[1]);return{decodeLut:D,numBitsLUTQick:U,numBitsLUT:b,tree:T,stuffedData:k,srcPtr:I,bitPos:y}},readHuffman:function(e,t,i){var a,n,r,s,l,o,f,u,c,d=t.headerInfo,h=d.numDims,m=t.headerInfo.height,g=t.headerInfo.width,p=g*m,x=this.readHuffmanTree(e,t),w=x.decodeLut,k=x.tree,y=x.stuffedData,I=x.srcPtr,b=x.bitPos,U=x.numBitsLUTQick,T=x.numBitsLUT,M=0===t.headerInfo.imageType?128:0,V=t.pixels.resultMask,v=0;b>0&&(I++,b=0);var A,B=y[I],D=1===t.encodeMode,S=new i(p*h),P=S;for(A=0;A<d.numDims;A++){if(h>1&&(P=new i(S.buffer,p*A,p),v=0),t.headerInfo.numValidPixel===g*m)for(u=0,o=0;o<m;o++)for(f=0;f<g;f++,u++){if(n=0,l=s=B<<b>>>32-U,32-b<U&&(l=s|=y[I+1]>>>64-b-U),w[l])n=w[l][1],b+=w[l][0];else for(l=s=B<<b>>>32-T,32-b<T&&(l=s|=y[I+1]>>>64-b-T),a=k,c=0;c<T;c++)if(!(a=s>>>T-c-1&1?a.right:a.left).left&&!a.right){n=a.val,b=b+c+1;break}b>=32&&(b-=32,B=y[++I]),r=n-M,D?(r+=f>0?v:o>0?P[u-g]:v,r&=255,P[u]=r,v=r):P[u]=r}else for(u=0,o=0;o<m;o++)for(f=0;f<g;f++,u++)if(V[u]){if(n=0,l=s=B<<b>>>32-U,32-b<U&&(l=s|=y[I+1]>>>64-b-U),w[l])n=w[l][1],b+=w[l][0];else for(l=s=B<<b>>>32-T,32-b<T&&(l=s|=y[I+1]>>>64-b-T),a=k,c=0;c<T;c++)if(!(a=s>>>T-c-1&1?a.right:a.left).left&&!a.right){n=a.val,b=b+c+1;break}b>=32&&(b-=32,B=y[++I]),r=n-M,D?(f>0&&V[u-1]?r+=v:o>0&&V[u-g]?r+=P[u-g]:r+=v,r&=255,P[u]=r,v=r):P[u]=r}t.ptr=t.ptr+4*(I+1)+(b>0?4:0)}t.pixels.resultPixels=S},decodeBits:function(e,t,i,a,n){var r=t.headerInfo,s=r.fileVersion,h=0,m=new DataView(e,t.ptr,5),g=m.getUint8(0);h++;var p=g>>6,x=0===p?4:3-p,w=(32&g)>0,k=31&g,y=0;if(1===x)y=m.getUint8(h),h++;else if(2===x)y=m.getUint16(h,!0),h+=2;else{if(4!==x)throw"Invalid valid pixel count type";y=m.getUint32(h,!0),h+=4}var I,b,U,T,M,V,v,A,B,D=2*r.maxZError,S=r.numDims>1?r.maxValues[n]:r.zMax;if(w){for(t.counter.lut++,A=m.getUint8(h),h++,T=Math.ceil((A-1)*k/8),M=Math.ceil(T/4),b=new ArrayBuffer(4*M),U=new Uint8Array(b),t.ptr+=h,U.set(new Uint8Array(e,t.ptr,T)),v=new Uint32Array(b),t.ptr+=T,B=0;A-1>>>B;)B++;T=Math.ceil(y*B/8),M=Math.ceil(T/4),b=new ArrayBuffer(4*M),(U=new Uint8Array(b)).set(new Uint8Array(e,t.ptr,T)),I=new Uint32Array(b),t.ptr+=T,V=s>=3?u(v,k,A-1,a,D,S):o(v,k,A-1,a,D,S),s>=3?f(I,i,B,y,V):l(I,i,B,y,V)}else t.counter.bitstuffer++,B=k,t.ptr+=h,B>0&&(T=Math.ceil(y*B/8),M=Math.ceil(T/4),b=new ArrayBuffer(4*M),(U=new Uint8Array(b)).set(new Uint8Array(e,t.ptr,T)),I=new Uint32Array(b),t.ptr+=T,s>=3?null==a?d(I,i,B,y):f(I,i,B,y,!1,a,D,S):null==a?c(I,i,B,y):l(I,i,B,y,!1,a,D,S))},readTiles:function(e,t,i){var a=t.headerInfo,n=a.width,r=a.height,s=a.microBlockSize,l=a.imageType,o=h.getDataTypeSize(l),f=Math.ceil(n/s),u=Math.ceil(r/s);t.pixels.numBlocksY=u,t.pixels.numBlocksX=f,t.pixels.ptr=0;var c,d,m,g,p,x,w,k,y=0,I=0,b=0,U=0,T=0,M=0,V=0,v=0,A=0,B=0,D=0,S=0,P=0,E=0,C=0,F=new i(s*s),N=r%s||s,O=n%s||s,R=a.numDims,L=t.pixels.resultMask,z=t.pixels.resultPixels;for(b=0;b<u;b++)for(T=b!==u-1?s:N,U=0;U<f;U++)for(B=b*n*s+U*s,D=n-(M=U!==f-1?s:O),k=0;k<R;k++){if(R>1&&(z=new i(t.pixels.resultPixels.buffer,n*r*k*o,n*r)),V=e.byteLength-t.ptr,d={},C=0,C++,A=(v=(c=new DataView(e,t.ptr,Math.min(10,V))).getUint8(0))>>6&255,(v>>2&15)!=(U*s>>3&15))throw"integrity issue";if((p=3&v)>3)throw t.ptr+=C,"Invalid block encoding ("+p+")";if(2!==p)if(0===p){if(t.counter.uncompressed++,t.ptr+=C,S=(S=T*M*o)<(P=e.byteLength-t.ptr)?S:P,m=new ArrayBuffer(S%o==0?S:S+o-S%o),new Uint8Array(m).set(new Uint8Array(e,t.ptr,S)),g=new i(m),E=0,L)for(y=0;y<T;y++){for(I=0;I<M;I++)L[B]&&(z[B]=g[E++]),B++;B+=D}else for(y=0;y<T;y++){for(I=0;I<M;I++)z[B++]=g[E++];B+=D}t.ptr+=E*o}else if(x=h.getDataTypeUsed(l,A),w=h.getOnePixel(d,C,x,c),C+=h.getDataTypeSize(x),3===p)if(t.ptr+=C,t.counter.constantoffset++,L)for(y=0;y<T;y++){for(I=0;I<M;I++)L[B]&&(z[B]=w),B++;B+=D}else for(y=0;y<T;y++){for(I=0;I<M;I++)z[B++]=w;B+=D}else if(t.ptr+=C,h.decodeBits(e,t,F,w,k),C=0,L)for(y=0;y<T;y++){for(I=0;I<M;I++)L[B]&&(z[B]=F[C++]),B++;B+=D}else for(y=0;y<T;y++){for(I=0;I<M;I++)z[B++]=F[C++];B+=D}else t.counter.constant++,t.ptr+=C}},formatFileInfo:function(e){return{fileIdentifierString:e.headerInfo.fileIdentifierString,fileVersion:e.headerInfo.fileVersion,imageType:e.headerInfo.imageType,height:e.headerInfo.height,width:e.headerInfo.width,numValidPixel:e.headerInfo.numValidPixel,microBlockSize:e.headerInfo.microBlockSize,blobSize:e.headerInfo.blobSize,maxZError:e.headerInfo.maxZError,pixelType:h.getPixelType(e.headerInfo.imageType),eofOffset:e.eofOffset,mask:e.mask?{numBytes:e.mask.numBytes}:null,pixels:{numBlocksX:e.pixels.numBlocksX,numBlocksY:e.pixels.numBlocksY,maxValue:e.headerInfo.zMax,minValue:e.headerInfo.zMin,noDataValue:e.noDataValue}}},constructConstantSurface:function(e){var t=e.headerInfo.zMax,i=e.headerInfo.numDims,a=e.headerInfo.height*e.headerInfo.width,n=a*i,r=0,s=0,l=0,o=e.pixels.resultMask;if(o)if(i>1)for(r=0;r<i;r++)for(l=r*a,s=0;s<a;s++)o[s]&&(e.pixels.resultPixels[l+s]=t);else for(s=0;s<a;s++)o[s]&&(e.pixels.resultPixels[s]=t);else if(e.pixels.resultPixels.fill)e.pixels.resultPixels.fill(t);else for(s=0;s<n;s++)e.pixels.resultPixels[s]=t},getDataTypeArray:function(e){var t;switch(e){case 0:t=Int8Array;break;case 1:t=Uint8Array;break;case 2:t=Int16Array;break;case 3:t=Uint16Array;break;case 4:t=Int32Array;break;case 5:t=Uint32Array;break;default:t=Float32Array;break;case 7:t=Float64Array}return t},getPixelType:function(e){var t;switch(e){case 0:t="S8";break;case 1:t="U8";break;case 2:t="S16";break;case 3:t="U16";break;case 4:t="S32";break;case 5:t="U32";break;default:t="F32";break;case 7:t="F64"}return t},isValidPixelValue:function(e,t){if(null==t)return!1;var i;switch(e){case 0:i=t>=-128&&t<=127;break;case 1:i=t>=0&&t<=255;break;case 2:i=t>=-32768&&t<=32767;break;case 3:i=t>=0&&t<=65536;break;case 4:i=t>=-2147483648&&t<=2147483647;break;case 5:i=t>=0&&t<=4294967296;break;case 6:i=t>=-34027999387901484e22&&t<=34027999387901484e22;break;case 7:i=t>=5e-324&&t<=17976931348623157e292;break;default:i=!1}return i},getDataTypeSize:function(e){var t=0;switch(e){case 0:case 1:t=1;break;case 2:case 3:t=2;break;case 4:case 5:case 6:t=4;break;case 7:t=8;break;default:t=e}return t},getDataTypeUsed:function(e,t){var i=e;switch(e){case 2:case 4:i=e-t;break;case 3:case 5:i=e-2*t;break;case 6:i=0===t?e:1===t?2:1;break;case 7:i=0===t?e:e-2*t+1;break;default:i=e}return i},getOnePixel:function(e,t,i,a){var n=0;switch(i){case 0:n=a.getInt8(t);break;case 1:n=a.getUint8(t);break;case 2:n=a.getInt16(t,!0);break;case 3:n=a.getUint16(t,!0);break;case 4:n=a.getInt32(t,!0);break;case 5:n=a.getUInt32(t,!0);break;case 6:n=a.getFloat32(t,!0);break;case 7:n=a.getFloat64(t,!0);break;default:throw"the decoder does not understand this pixel type"}return n}},m=function(e,t,i){this.val=e,this.left=t,this.right=i},{decode:function(e,t){var i=(t=t||{}).noDataValue,a=0,n={};n.ptr=t.inputOffset||0,n.pixels={},h.readHeaderInfo(e,n);var r=n.headerInfo,s=r.fileVersion,l=h.getDataTypeArray(r.imageType);h.readMask(e,n),r.numValidPixel===r.width*r.height||n.pixels.resultMask||(n.pixels.resultMask=t.maskData);var o,f=r.width*r.height;if(n.pixels.resultPixels=new l(f*r.numDims),n.counter={onesweep:0,uncompressed:0,lut:0,bitstuffer:0,constant:0,constantoffset:0},0!==r.numValidPixel)if(r.zMax===r.zMin)h.constructConstantSurface(n);else if(s>=4&&h.checkMinMaxRanges(e,n))h.constructConstantSurface(n);else{var u=new DataView(e,n.ptr,2),c=u.getUint8(0);if(n.ptr++,c)h.readDataOneSweep(e,n,l);else if(s>1&&r.imageType<=1&&Math.abs(r.maxZError-.5)<1e-5){var d=u.getUint8(1);if(n.ptr++,n.encodeMode=d,d>2||s<4&&d>1)throw"Invalid Huffman flag "+d;d?h.readHuffman(e,n,l):h.readTiles(e,n,l)}else h.readTiles(e,n,l)}n.eofOffset=n.ptr,t.inputOffset?(o=n.headerInfo.blobSize+t.inputOffset-n.ptr,Math.abs(o)>=1&&(n.eofOffset=t.inputOffset+n.headerInfo.blobSize)):(o=n.headerInfo.blobSize-n.ptr,Math.abs(o)>=1&&(n.eofOffset=n.headerInfo.blobSize));var m={width:r.width,height:r.height,pixelData:n.pixels.resultPixels,minValue:r.zMin,maxValue:r.zMax,validPixelCount:r.numValidPixel,dimCount:r.numDims,dimStats:{minValues:r.minValues,maxValues:r.maxValues},maskData:n.pixels.resultMask};if(n.pixels.resultMask&&h.isValidPixelValue(r.imageType,i)){var g=n.pixels.resultMask;for(a=0;a<f;a++)g[a]||(m.pixelData[a]=i);m.noDataValue=i}return n.noDataValue=i,t.returnFileInfo&&(m.fileInfo=h.formatFileInfo(n)),m},getBandCount:function(e){for(var t=0,i=0,a={ptr:0,pixels:{}};i<e.byteLength-58;)h.readHeaderInfo(e,a),i+=a.headerInfo.blobSize,t++,a.ptr=i;return t}}),k=(g=new ArrayBuffer(4),p=new Uint8Array(g),new Uint32Array(g)[0]=1,1===p[0]),y={decode:function(e,t){if(!k)throw"Big endian system is not supported.";var i,a,n=(t=t||{}).inputOffset||0,r=new Uint8Array(e,n,10),s=String.fromCharCode.apply(null,r);if("CntZImage"===s.trim())i=x,a=1;else{if("Lerc2"!==s.substring(0,5))throw"Unexpected file identifier string: "+s;i=w,a=2}for(var l,o,f,u,c,d,h=0,m=e.byteLength-10,g=[],p={width:0,height:0,pixels:[],pixelType:t.pixelType,mask:null,statistics:[]};n<m;){var y=i.decode(e,{inputOffset:n,encodedMaskData:l,maskData:f,returnMask:0===h,returnEncodedMask:0===h,returnFileInfo:!0,pixelType:t.pixelType||null,noDataValue:t.noDataValue||null});n=y.fileInfo.eofOffset,0===h&&(l=y.encodedMaskData,f=y.maskData,p.width=y.width,p.height=y.height,p.dimCount=y.dimCount||1,p.pixelType=y.pixelType||y.fileInfo.pixelType,p.mask=y.maskData),a>1&&y.fileInfo.mask&&y.fileInfo.mask.numBytes>0&&g.push(y.maskData),h++,p.pixels.push(y.pixelData),p.statistics.push({minValue:y.minValue,maxValue:y.maxValue,noDataValue:y.noDataValue,dimStats:y.dimStats})}if(a>1&&g.length>1){for(d=p.width*p.height,p.bandMasks=g,(f=new Uint8Array(d)).set(g[0]),u=1;u<g.length;u++)for(o=g[u],c=0;c<d;c++)f[c]=f[c]&o[c];p.maskData=f}return p}};e.exports?e.exports=y:this.Lerc=y}()}));return u((function(t,i){if(t.encoding===x.LERC){let e;try{e=U.decode(t.heightmap)}catch(e){throw new n.RuntimeError(e)}if(e.statistics[0].minValue===Number.MAX_VALUE)throw new n.RuntimeError("Invalid tile data");t.heightmap=e.pixels[0],t.width=e.width,t.height=e.height}t.ellipsoid=e.Ellipsoid.clone(t.ellipsoid),t.rectangle=e.Rectangle.clone(t.rectangle);const a=w.computeVertices(t),r=a.vertices;return i.push(r.buffer),{vertices:r.buffer,numberOfAttributes:a.encoding.stride,minimumHeight:a.minimumHeight,maximumHeight:a.maximumHeight,gridWidth:t.width,gridHeight:t.height,boundingSphere3D:a.boundingSphere3D,orientedBoundingBox:a.orientedBoundingBox,occludeePointInScaledSpace:a.occludeePointInScaledSpace,encoding:a.encoding,westIndicesSouthToNorth:a.westIndicesSouthToNorth,southIndicesEastToWest:a.southIndicesEastToWest,eastIndicesNorthToSouth:a.eastIndicesNorthToSouth,northIndicesWestToEast:a.northIndicesWestToEast}}))}));
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109.3
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  EllipsoidalOccluder_default,
+  TerrainEncoding_default
+} from "./chunk-TFC6TZ3S.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  WebMercatorProjection_default
+} from "./chunk-HQF437NJ.js";
+import {
+  OrientedBoundingBox_default
+} from "./chunk-Z24VKNDO.js";
+import "./chunk-O5AMBQ36.js";
+import "./chunk-RP2A7BR5.js";
+import {
+  AxisAlignedBoundingBox_default
+} from "./chunk-2R5O53JW.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  BoundingSphere_default,
+  Transforms_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import {
+  Cartesian2_default,
+  Matrix4_default,
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import {
+  RuntimeError_default
+} from "./chunk-ABADGKYE.js";
+import {
+  defaultValue_default
+} from "./chunk-WXTV4ATB.js";
+import {
+  DeveloperError_default
+} from "./chunk-4MFFIWUA.js";
+import {
+  __commonJS,
+  __toESM,
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// node_modules/lerc/LercDecode.js
+var require_LercDecode = __commonJS({
+  "node_modules/lerc/LercDecode.js"(exports, module) {
+    /* Copyright 2015-2018 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve */
+    (function() {
+      var LercDecode = function() {
+        var CntZImage = {};
+        CntZImage.defaultNoDataValue = -34027999387901484e22;
+        CntZImage.decode = function(input, options) {
+          options = options || {};
+          var skipMask = options.encodedMaskData || options.encodedMaskData === null;
+          var parsedData = parse(input, options.inputOffset || 0, skipMask);
+          var noDataValue = options.noDataValue !== null ? options.noDataValue : CntZImage.defaultNoDataValue;
+          var uncompressedData = uncompressPixelValues(
+            parsedData,
+            options.pixelType || Float32Array,
+            options.encodedMaskData,
+            noDataValue,
+            options.returnMask
+          );
+          var result = {
+            width: parsedData.width,
+            height: parsedData.height,
+            pixelData: uncompressedData.resultPixels,
+            minValue: uncompressedData.minValue,
+            maxValue: parsedData.pixels.maxValue,
+            noDataValue
+          };
+          if (uncompressedData.resultMask) {
+            result.maskData = uncompressedData.resultMask;
+          }
+          if (options.returnEncodedMask && parsedData.mask) {
+            result.encodedMaskData = parsedData.mask.bitset ? parsedData.mask.bitset : null;
+          }
+          if (options.returnFileInfo) {
+            result.fileInfo = formatFileInfo(parsedData);
+            if (options.computeUsedBitDepths) {
+              result.fileInfo.bitDepths = computeUsedBitDepths(parsedData);
+            }
+          }
+          return result;
+        };
+        var uncompressPixelValues = function(data, TypedArrayClass, maskBitset, noDataValue, storeDecodedMask) {
+          var blockIdx = 0;
+          var numX = data.pixels.numBlocksX;
+          var numY = data.pixels.numBlocksY;
+          var blockWidth = Math.floor(data.width / numX);
+          var blockHeight = Math.floor(data.height / numY);
+          var scale = 2 * data.maxZError;
+          var minValue = Number.MAX_VALUE, currentValue;
+          maskBitset = maskBitset || (data.mask ? data.mask.bitset : null);
+          var resultPixels, resultMask;
+          resultPixels = new TypedArrayClass(data.width * data.height);
+          if (storeDecodedMask && maskBitset) {
+            resultMask = new Uint8Array(data.width * data.height);
+          }
+          var blockDataBuffer = new Float32Array(blockWidth * blockHeight);
+          var xx, yy;
+          for (var y = 0; y <= numY; y++) {
+            var thisBlockHeight = y !== numY ? blockHeight : data.height % numY;
+            if (thisBlockHeight === 0) {
+              continue;
+            }
+            for (var x = 0; x <= numX; x++) {
+              var thisBlockWidth = x !== numX ? blockWidth : data.width % numX;
+              if (thisBlockWidth === 0) {
+                continue;
+              }
+              var outPtr = y * data.width * blockHeight + x * blockWidth;
+              var outStride = data.width - thisBlockWidth;
+              var block = data.pixels.blocks[blockIdx];
+              var blockData, blockPtr, constValue;
+              if (block.encoding < 2) {
+                if (block.encoding === 0) {
+                  blockData = block.rawData;
+                } else {
+                  unstuff(block.stuffedData, block.bitsPerPixel, block.numValidPixels, block.offset, scale, blockDataBuffer, data.pixels.maxValue);
+                  blockData = blockDataBuffer;
+                }
+                blockPtr = 0;
+              } else if (block.encoding === 2) {
+                constValue = 0;
+              } else {
+                constValue = block.offset;
+              }
+              var maskByte;
+              if (maskBitset) {
+                for (yy = 0; yy < thisBlockHeight; yy++) {
+                  if (outPtr & 7) {
+                    maskByte = maskBitset[outPtr >> 3];
+                    maskByte <<= outPtr & 7;
+                  }
+                  for (xx = 0; xx < thisBlockWidth; xx++) {
+                    if (!(outPtr & 7)) {
+                      maskByte = maskBitset[outPtr >> 3];
+                    }
+                    if (maskByte & 128) {
+                      if (resultMask) {
+                        resultMask[outPtr] = 1;
+                      }
+                      currentValue = block.encoding < 2 ? blockData[blockPtr++] : constValue;
+                      minValue = minValue > currentValue ? currentValue : minValue;
+                      resultPixels[outPtr++] = currentValue;
+                    } else {
+                      if (resultMask) {
+                        resultMask[outPtr] = 0;
+                      }
+                      resultPixels[outPtr++] = noDataValue;
+                    }
+                    maskByte <<= 1;
+                  }
+                  outPtr += outStride;
+                }
+              } else {
+                if (block.encoding < 2) {
+                  for (yy = 0; yy < thisBlockHeight; yy++) {
+                    for (xx = 0; xx < thisBlockWidth; xx++) {
+                      currentValue = blockData[blockPtr++];
+                      minValue = minValue > currentValue ? currentValue : minValue;
+                      resultPixels[outPtr++] = currentValue;
+                    }
+                    outPtr += outStride;
+                  }
+                } else {
+                  minValue = minValue > constValue ? constValue : minValue;
+                  for (yy = 0; yy < thisBlockHeight; yy++) {
+                    for (xx = 0; xx < thisBlockWidth; xx++) {
+                      resultPixels[outPtr++] = constValue;
+                    }
+                    outPtr += outStride;
+                  }
+                }
+              }
+              if (block.encoding === 1 && blockPtr !== block.numValidPixels) {
+                throw "Block and Mask do not match";
+              }
+              blockIdx++;
+            }
+          }
+          return {
+            resultPixels,
+            resultMask,
+            minValue
+          };
+        };
+        var formatFileInfo = function(data) {
+          return {
+            "fileIdentifierString": data.fileIdentifierString,
+            "fileVersion": data.fileVersion,
+            "imageType": data.imageType,
+            "height": data.height,
+            "width": data.width,
+            "maxZError": data.maxZError,
+            "eofOffset": data.eofOffset,
+            "mask": data.mask ? {
+              "numBlocksX": data.mask.numBlocksX,
+              "numBlocksY": data.mask.numBlocksY,
+              "numBytes": data.mask.numBytes,
+              "maxValue": data.mask.maxValue
+            } : null,
+            "pixels": {
+              "numBlocksX": data.pixels.numBlocksX,
+              "numBlocksY": data.pixels.numBlocksY,
+              "numBytes": data.pixels.numBytes,
+              "maxValue": data.pixels.maxValue,
+              "noDataValue": data.noDataValue
+            }
+          };
+        };
+        var computeUsedBitDepths = function(data) {
+          var numBlocks = data.pixels.numBlocksX * data.pixels.numBlocksY;
+          var bitDepths = {};
+          for (var i = 0; i < numBlocks; i++) {
+            var block = data.pixels.blocks[i];
+            if (block.encoding === 0) {
+              bitDepths.float32 = true;
+            } else if (block.encoding === 1) {
+              bitDepths[block.bitsPerPixel] = true;
+            } else {
+              bitDepths[0] = true;
+            }
+          }
+          return Object.keys(bitDepths);
+        };
+        var parse = function(input, fp, skipMask) {
+          var data = {};
+          var fileIdView = new Uint8Array(input, fp, 10);
+          data.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
+          if (data.fileIdentifierString.trim() !== "CntZImage") {
+            throw "Unexpected file identifier string: " + data.fileIdentifierString;
+          }
+          fp += 10;
+          var view = new DataView(input, fp, 24);
+          data.fileVersion = view.getInt32(0, true);
+          data.imageType = view.getInt32(4, true);
+          data.height = view.getUint32(8, true);
+          data.width = view.getUint32(12, true);
+          data.maxZError = view.getFloat64(16, true);
+          fp += 24;
+          if (!skipMask) {
+            view = new DataView(input, fp, 16);
+            data.mask = {};
+            data.mask.numBlocksY = view.getUint32(0, true);
+            data.mask.numBlocksX = view.getUint32(4, true);
+            data.mask.numBytes = view.getUint32(8, true);
+            data.mask.maxValue = view.getFloat32(12, true);
+            fp += 16;
+            if (data.mask.numBytes > 0) {
+              var bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
+              view = new DataView(input, fp, data.mask.numBytes);
+              var cnt = view.getInt16(0, true);
+              var ip = 2, op = 0;
+              do {
+                if (cnt > 0) {
+                  while (cnt--) {
+                    bitset[op++] = view.getUint8(ip++);
+                  }
+                } else {
+                  var val = view.getUint8(ip++);
+                  cnt = -cnt;
+                  while (cnt--) {
+                    bitset[op++] = val;
+                  }
+                }
+                cnt = view.getInt16(ip, true);
+                ip += 2;
+              } while (ip < data.mask.numBytes);
+              if (cnt !== -32768 || op < bitset.length) {
+                throw "Unexpected end of mask RLE encoding";
+              }
+              data.mask.bitset = bitset;
+              fp += data.mask.numBytes;
+            } else if ((data.mask.numBytes | data.mask.numBlocksY | data.mask.maxValue) === 0) {
+              data.mask.bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
+            }
+          }
+          view = new DataView(input, fp, 16);
+          data.pixels = {};
+          data.pixels.numBlocksY = view.getUint32(0, true);
+          data.pixels.numBlocksX = view.getUint32(4, true);
+          data.pixels.numBytes = view.getUint32(8, true);
+          data.pixels.maxValue = view.getFloat32(12, true);
+          fp += 16;
+          var numBlocksX = data.pixels.numBlocksX;
+          var numBlocksY = data.pixels.numBlocksY;
+          var actualNumBlocksX = numBlocksX + (data.width % numBlocksX > 0 ? 1 : 0);
+          var actualNumBlocksY = numBlocksY + (data.height % numBlocksY > 0 ? 1 : 0);
+          data.pixels.blocks = new Array(actualNumBlocksX * actualNumBlocksY);
+          var blockI = 0;
+          for (var blockY = 0; blockY < actualNumBlocksY; blockY++) {
+            for (var blockX = 0; blockX < actualNumBlocksX; blockX++) {
+              var size = 0;
+              var bytesLeft = input.byteLength - fp;
+              view = new DataView(input, fp, Math.min(10, bytesLeft));
+              var block = {};
+              data.pixels.blocks[blockI++] = block;
+              var headerByte = view.getUint8(0);
+              size++;
+              block.encoding = headerByte & 63;
+              if (block.encoding > 3) {
+                throw "Invalid block encoding (" + block.encoding + ")";
+              }
+              if (block.encoding === 2) {
+                fp++;
+                continue;
+              }
+              if (headerByte !== 0 && headerByte !== 2) {
+                headerByte >>= 6;
+                block.offsetType = headerByte;
+                if (headerByte === 2) {
+                  block.offset = view.getInt8(1);
+                  size++;
+                } else if (headerByte === 1) {
+                  block.offset = view.getInt16(1, true);
+                  size += 2;
+                } else if (headerByte === 0) {
+                  block.offset = view.getFloat32(1, true);
+                  size += 4;
+                } else {
+                  throw "Invalid block offset type";
+                }
+                if (block.encoding === 1) {
+                  headerByte = view.getUint8(size);
+                  size++;
+                  block.bitsPerPixel = headerByte & 63;
+                  headerByte >>= 6;
+                  block.numValidPixelsType = headerByte;
+                  if (headerByte === 2) {
+                    block.numValidPixels = view.getUint8(size);
+                    size++;
+                  } else if (headerByte === 1) {
+                    block.numValidPixels = view.getUint16(size, true);
+                    size += 2;
+                  } else if (headerByte === 0) {
+                    block.numValidPixels = view.getUint32(size, true);
+                    size += 4;
+                  } else {
+                    throw "Invalid valid pixel count type";
+                  }
+                }
+              }
+              fp += size;
+              if (block.encoding === 3) {
+                continue;
+              }
+              var arrayBuf, store8;
+              if (block.encoding === 0) {
+                var numPixels = (data.pixels.numBytes - 1) / 4;
+                if (numPixels !== Math.floor(numPixels)) {
+                  throw "uncompressed block has invalid length";
+                }
+                arrayBuf = new ArrayBuffer(numPixels * 4);
+                store8 = new Uint8Array(arrayBuf);
+                store8.set(new Uint8Array(input, fp, numPixels * 4));
+                var rawData = new Float32Array(arrayBuf);
+                block.rawData = rawData;
+                fp += numPixels * 4;
+              } else if (block.encoding === 1) {
+                var dataBytes = Math.ceil(block.numValidPixels * block.bitsPerPixel / 8);
+                var dataWords = Math.ceil(dataBytes / 4);
+                arrayBuf = new ArrayBuffer(dataWords * 4);
+                store8 = new Uint8Array(arrayBuf);
+                store8.set(new Uint8Array(input, fp, dataBytes));
+                block.stuffedData = new Uint32Array(arrayBuf);
+                fp += dataBytes;
+              }
+            }
+          }
+          data.eofOffset = fp;
+          return data;
+        };
+        var unstuff = function(src, bitsPerPixel, numPixels, offset, scale, dest, maxValue) {
+          var bitMask = (1 << bitsPerPixel) - 1;
+          var i = 0, o;
+          var bitsLeft = 0;
+          var n, buffer;
+          var nmax = Math.ceil((maxValue - offset) / scale);
+          var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
+          src[src.length - 1] <<= 8 * numInvalidTailBytes;
+          for (o = 0; o < numPixels; o++) {
+            if (bitsLeft === 0) {
+              buffer = src[i++];
+              bitsLeft = 32;
+            }
+            if (bitsLeft >= bitsPerPixel) {
+              n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
+              bitsLeft -= bitsPerPixel;
+            } else {
+              var missingBits = bitsPerPixel - bitsLeft;
+              n = (buffer & bitMask) << missingBits & bitMask;
+              buffer = src[i++];
+              bitsLeft = 32 - missingBits;
+              n += buffer >>> bitsLeft;
+            }
+            dest[o] = n < nmax ? offset + n * scale : maxValue;
+          }
+          return dest;
+        };
+        return CntZImage;
+      }();
+      var Lerc2Decode = function() {
+        "use strict";
+        var BitStuffer = {
+          //methods ending with 2 are for the new byte order used by Lerc2.3 and above.
+          //originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons.
+          unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o;
+            var bitsLeft = 0;
+            var n, buffer, missingBits, nmax;
+            var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
+            src[src.length - 1] <<= 8 * numInvalidTailBytes;
+            if (lutArr) {
+              for (o = 0; o < numPixels; o++) {
+                if (bitsLeft === 0) {
+                  buffer = src[i++];
+                  bitsLeft = 32;
+                }
+                if (bitsLeft >= bitsPerPixel) {
+                  n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
+                  bitsLeft -= bitsPerPixel;
+                } else {
+                  missingBits = bitsPerPixel - bitsLeft;
+                  n = (buffer & bitMask) << missingBits & bitMask;
+                  buffer = src[i++];
+                  bitsLeft = 32 - missingBits;
+                  n += buffer >>> bitsLeft;
+                }
+                dest[o] = lutArr[n];
+              }
+            } else {
+              nmax = Math.ceil((maxValue - offset) / scale);
+              for (o = 0; o < numPixels; o++) {
+                if (bitsLeft === 0) {
+                  buffer = src[i++];
+                  bitsLeft = 32;
+                }
+                if (bitsLeft >= bitsPerPixel) {
+                  n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
+                  bitsLeft -= bitsPerPixel;
+                } else {
+                  missingBits = bitsPerPixel - bitsLeft;
+                  n = (buffer & bitMask) << missingBits & bitMask;
+                  buffer = src[i++];
+                  bitsLeft = 32 - missingBits;
+                  n += buffer >>> bitsLeft;
+                }
+                dest[o] = n < nmax ? offset + n * scale : maxValue;
+              }
+            }
+          },
+          unstuffLUT: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0;
+            var buffer;
+            var dest = [];
+            var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
+            src[src.length - 1] <<= 8 * numInvalidTailBytes;
+            var nmax = Math.ceil((maxValue - offset) / scale);
+            for (o = 0; o < numPixels; o++) {
+              if (bitsLeft === 0) {
+                buffer = src[i++];
+                bitsLeft = 32;
+              }
+              if (bitsLeft >= bitsPerPixel) {
+                n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
+                bitsLeft -= bitsPerPixel;
+              } else {
+                missingBits = bitsPerPixel - bitsLeft;
+                n = (buffer & bitMask) << missingBits & bitMask;
+                buffer = src[i++];
+                bitsLeft = 32 - missingBits;
+                n += buffer >>> bitsLeft;
+              }
+              dest[o] = n < nmax ? offset + n * scale : maxValue;
+            }
+            dest.unshift(offset);
+            return dest;
+          },
+          unstuff2: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o;
+            var bitsLeft = 0, bitPos = 0;
+            var n, buffer, missingBits;
+            if (lutArr) {
+              for (o = 0; o < numPixels; o++) {
+                if (bitsLeft === 0) {
+                  buffer = src[i++];
+                  bitsLeft = 32;
+                  bitPos = 0;
+                }
+                if (bitsLeft >= bitsPerPixel) {
+                  n = buffer >>> bitPos & bitMask;
+                  bitsLeft -= bitsPerPixel;
+                  bitPos += bitsPerPixel;
+                } else {
+                  missingBits = bitsPerPixel - bitsLeft;
+                  n = buffer >>> bitPos & bitMask;
+                  buffer = src[i++];
+                  bitsLeft = 32 - missingBits;
+                  n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
+                  bitPos = missingBits;
+                }
+                dest[o] = lutArr[n];
+              }
+            } else {
+              var nmax = Math.ceil((maxValue - offset) / scale);
+              for (o = 0; o < numPixels; o++) {
+                if (bitsLeft === 0) {
+                  buffer = src[i++];
+                  bitsLeft = 32;
+                  bitPos = 0;
+                }
+                if (bitsLeft >= bitsPerPixel) {
+                  n = buffer >>> bitPos & bitMask;
+                  bitsLeft -= bitsPerPixel;
+                  bitPos += bitsPerPixel;
+                } else {
+                  missingBits = bitsPerPixel - bitsLeft;
+                  n = buffer >>> bitPos & bitMask;
+                  buffer = src[i++];
+                  bitsLeft = 32 - missingBits;
+                  n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
+                  bitPos = missingBits;
+                }
+                dest[o] = n < nmax ? offset + n * scale : maxValue;
+              }
+            }
+            return dest;
+          },
+          unstuffLUT2: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0, bitPos = 0;
+            var buffer;
+            var dest = [];
+            var nmax = Math.ceil((maxValue - offset) / scale);
+            for (o = 0; o < numPixels; o++) {
+              if (bitsLeft === 0) {
+                buffer = src[i++];
+                bitsLeft = 32;
+                bitPos = 0;
+              }
+              if (bitsLeft >= bitsPerPixel) {
+                n = buffer >>> bitPos & bitMask;
+                bitsLeft -= bitsPerPixel;
+                bitPos += bitsPerPixel;
+              } else {
+                missingBits = bitsPerPixel - bitsLeft;
+                n = buffer >>> bitPos & bitMask;
+                buffer = src[i++];
+                bitsLeft = 32 - missingBits;
+                n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
+                bitPos = missingBits;
+              }
+              dest[o] = n < nmax ? offset + n * scale : maxValue;
+            }
+            dest.unshift(offset);
+            return dest;
+          },
+          originalUnstuff: function(src, dest, bitsPerPixel, numPixels) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o;
+            var bitsLeft = 0;
+            var n, buffer, missingBits;
+            var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
+            src[src.length - 1] <<= 8 * numInvalidTailBytes;
+            for (o = 0; o < numPixels; o++) {
+              if (bitsLeft === 0) {
+                buffer = src[i++];
+                bitsLeft = 32;
+              }
+              if (bitsLeft >= bitsPerPixel) {
+                n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
+                bitsLeft -= bitsPerPixel;
+              } else {
+                missingBits = bitsPerPixel - bitsLeft;
+                n = (buffer & bitMask) << missingBits & bitMask;
+                buffer = src[i++];
+                bitsLeft = 32 - missingBits;
+                n += buffer >>> bitsLeft;
+              }
+              dest[o] = n;
+            }
+            return dest;
+          },
+          originalUnstuff2: function(src, dest, bitsPerPixel, numPixels) {
+            var bitMask = (1 << bitsPerPixel) - 1;
+            var i = 0, o;
+            var bitsLeft = 0, bitPos = 0;
+            var n, buffer, missingBits;
+            for (o = 0; o < numPixels; o++) {
+              if (bitsLeft === 0) {
+                buffer = src[i++];
+                bitsLeft = 32;
+                bitPos = 0;
+              }
+              if (bitsLeft >= bitsPerPixel) {
+                n = buffer >>> bitPos & bitMask;
+                bitsLeft -= bitsPerPixel;
+                bitPos += bitsPerPixel;
+              } else {
+                missingBits = bitsPerPixel - bitsLeft;
+                n = buffer >>> bitPos & bitMask;
+                buffer = src[i++];
+                bitsLeft = 32 - missingBits;
+                n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
+                bitPos = missingBits;
+              }
+              dest[o] = n;
+            }
+            return dest;
+          }
+        };
+        var Lerc2Helpers = {
+          HUFFMAN_LUT_BITS_MAX: 12,
+          //use 2^12 lut, treat it like constant
+          computeChecksumFletcher32: function(input) {
+            var sum1 = 65535, sum2 = 65535;
+            var len = input.length;
+            var words = Math.floor(len / 2);
+            var i = 0;
+            while (words) {
+              var tlen = words >= 359 ? 359 : words;
+              words -= tlen;
+              do {
+                sum1 += input[i++] << 8;
+                sum2 += sum1 += input[i++];
+              } while (--tlen);
+              sum1 = (sum1 & 65535) + (sum1 >>> 16);
+              sum2 = (sum2 & 65535) + (sum2 >>> 16);
+            }
+            if (len & 1) {
+              sum2 += sum1 += input[i] << 8;
+            }
+            sum1 = (sum1 & 65535) + (sum1 >>> 16);
+            sum2 = (sum2 & 65535) + (sum2 >>> 16);
+            return (sum2 << 16 | sum1) >>> 0;
+          },
+          readHeaderInfo: function(input, data) {
+            var ptr = data.ptr;
+            var fileIdView = new Uint8Array(input, ptr, 6);
+            var headerInfo = {};
+            headerInfo.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
+            if (headerInfo.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0) {
+              throw "Unexpected file identifier string (expect Lerc2 ): " + headerInfo.fileIdentifierString;
+            }
+            ptr += 6;
+            var view = new DataView(input, ptr, 8);
+            var fileVersion = view.getInt32(0, true);
+            headerInfo.fileVersion = fileVersion;
+            ptr += 4;
+            if (fileVersion >= 3) {
+              headerInfo.checksum = view.getUint32(4, true);
+              ptr += 4;
+            }
+            view = new DataView(input, ptr, 12);
+            headerInfo.height = view.getUint32(0, true);
+            headerInfo.width = view.getUint32(4, true);
+            ptr += 8;
+            if (fileVersion >= 4) {
+              headerInfo.numDims = view.getUint32(8, true);
+              ptr += 4;
+            } else {
+              headerInfo.numDims = 1;
+            }
+            view = new DataView(input, ptr, 40);
+            headerInfo.numValidPixel = view.getUint32(0, true);
+            headerInfo.microBlockSize = view.getInt32(4, true);
+            headerInfo.blobSize = view.getInt32(8, true);
+            headerInfo.imageType = view.getInt32(12, true);
+            headerInfo.maxZError = view.getFloat64(16, true);
+            headerInfo.zMin = view.getFloat64(24, true);
+            headerInfo.zMax = view.getFloat64(32, true);
+            ptr += 40;
+            data.headerInfo = headerInfo;
+            data.ptr = ptr;
+            var checksum, keyLength;
+            if (fileVersion >= 3) {
+              keyLength = fileVersion >= 4 ? 52 : 48;
+              checksum = this.computeChecksumFletcher32(new Uint8Array(input, ptr - keyLength, headerInfo.blobSize - 14));
+              if (checksum !== headerInfo.checksum) {
+                throw "Checksum failed.";
+              }
+            }
+            return true;
+          },
+          checkMinMaxRanges: function(input, data) {
+            var headerInfo = data.headerInfo;
+            var OutPixelTypeArray = this.getDataTypeArray(headerInfo.imageType);
+            var rangeBytes = headerInfo.numDims * this.getDataTypeSize(headerInfo.imageType);
+            var minValues = this.readSubArray(input, data.ptr, OutPixelTypeArray, rangeBytes);
+            var maxValues = this.readSubArray(input, data.ptr + rangeBytes, OutPixelTypeArray, rangeBytes);
+            data.ptr += 2 * rangeBytes;
+            var i, equal = true;
+            for (i = 0; i < headerInfo.numDims; i++) {
+              if (minValues[i] !== maxValues[i]) {
+                equal = false;
+                break;
+              }
+            }
+            headerInfo.minValues = minValues;
+            headerInfo.maxValues = maxValues;
+            return equal;
+          },
+          readSubArray: function(input, ptr, OutPixelTypeArray, numBytes) {
+            var rawData;
+            if (OutPixelTypeArray === Uint8Array) {
+              rawData = new Uint8Array(input, ptr, numBytes);
+            } else {
+              var arrayBuf = new ArrayBuffer(numBytes);
+              var store8 = new Uint8Array(arrayBuf);
+              store8.set(new Uint8Array(input, ptr, numBytes));
+              rawData = new OutPixelTypeArray(arrayBuf);
+            }
+            return rawData;
+          },
+          readMask: function(input, data) {
+            var ptr = data.ptr;
+            var headerInfo = data.headerInfo;
+            var numPixels = headerInfo.width * headerInfo.height;
+            var numValidPixel = headerInfo.numValidPixel;
+            var view = new DataView(input, ptr, 4);
+            var mask = {};
+            mask.numBytes = view.getUint32(0, true);
+            ptr += 4;
+            if ((0 === numValidPixel || numPixels === numValidPixel) && 0 !== mask.numBytes) {
+              throw "invalid mask";
+            }
+            var bitset, resultMask;
+            if (numValidPixel === 0) {
+              bitset = new Uint8Array(Math.ceil(numPixels / 8));
+              mask.bitset = bitset;
+              resultMask = new Uint8Array(numPixels);
+              data.pixels.resultMask = resultMask;
+              ptr += mask.numBytes;
+            } else if (mask.numBytes > 0) {
+              bitset = new Uint8Array(Math.ceil(numPixels / 8));
+              view = new DataView(input, ptr, mask.numBytes);
+              var cnt = view.getInt16(0, true);
+              var ip = 2, op = 0, val = 0;
+              do {
+                if (cnt > 0) {
+                  while (cnt--) {
+                    bitset[op++] = view.getUint8(ip++);
+                  }
+                } else {
+                  val = view.getUint8(ip++);
+                  cnt = -cnt;
+                  while (cnt--) {
+                    bitset[op++] = val;
+                  }
+                }
+                cnt = view.getInt16(ip, true);
+                ip += 2;
+              } while (ip < mask.numBytes);
+              if (cnt !== -32768 || op < bitset.length) {
+                throw "Unexpected end of mask RLE encoding";
+              }
+              resultMask = new Uint8Array(numPixels);
+              var mb = 0, k = 0;
+              for (k = 0; k < numPixels; k++) {
+                if (k & 7) {
+                  mb = bitset[k >> 3];
+                  mb <<= k & 7;
+                } else {
+                  mb = bitset[k >> 3];
+                }
+                if (mb & 128) {
+                  resultMask[k] = 1;
+                }
+              }
+              data.pixels.resultMask = resultMask;
+              mask.bitset = bitset;
+              ptr += mask.numBytes;
+            }
+            data.ptr = ptr;
+            data.mask = mask;
+            return true;
+          },
+          readDataOneSweep: function(input, data, OutPixelTypeArray) {
+            var ptr = data.ptr;
+            var headerInfo = data.headerInfo;
+            var numDims = headerInfo.numDims;
+            var numPixels = headerInfo.width * headerInfo.height;
+            var imageType = headerInfo.imageType;
+            var numBytes = headerInfo.numValidPixel * Lerc2Helpers.getDataTypeSize(imageType) * numDims;
+            var rawData;
+            var mask = data.pixels.resultMask;
+            if (OutPixelTypeArray === Uint8Array) {
+              rawData = new Uint8Array(input, ptr, numBytes);
+            } else {
+              var arrayBuf = new ArrayBuffer(numBytes);
+              var store8 = new Uint8Array(arrayBuf);
+              store8.set(new Uint8Array(input, ptr, numBytes));
+              rawData = new OutPixelTypeArray(arrayBuf);
+            }
+            if (rawData.length === numPixels * numDims) {
+              data.pixels.resultPixels = rawData;
+            } else {
+              data.pixels.resultPixels = new OutPixelTypeArray(numPixels * numDims);
+              var z = 0, k = 0, i = 0, nStart = 0;
+              if (numDims > 1) {
+                for (i = 0; i < numDims; i++) {
+                  nStart = i * numPixels;
+                  for (k = 0; k < numPixels; k++) {
+                    if (mask[k]) {
+                      data.pixels.resultPixels[nStart + k] = rawData[z++];
+                    }
+                  }
+                }
+              } else {
+                for (k = 0; k < numPixels; k++) {
+                  if (mask[k]) {
+                    data.pixels.resultPixels[k] = rawData[z++];
+                  }
+                }
+              }
+            }
+            ptr += numBytes;
+            data.ptr = ptr;
+            return true;
+          },
+          readHuffmanTree: function(input, data) {
+            var BITS_MAX = this.HUFFMAN_LUT_BITS_MAX;
+            var view = new DataView(input, data.ptr, 16);
+            data.ptr += 16;
+            var version = view.getInt32(0, true);
+            if (version < 2) {
+              throw "unsupported Huffman version";
+            }
+            var size = view.getInt32(4, true);
+            var i0 = view.getInt32(8, true);
+            var i1 = view.getInt32(12, true);
+            if (i0 >= i1) {
+              return false;
+            }
+            var blockDataBuffer = new Uint32Array(i1 - i0);
+            Lerc2Helpers.decodeBits(input, data, blockDataBuffer);
+            var codeTable = [];
+            var i, j, k, len;
+            for (i = i0; i < i1; i++) {
+              j = i - (i < size ? 0 : size);
+              codeTable[j] = { first: blockDataBuffer[i - i0], second: null };
+            }
+            var dataBytes = input.byteLength - data.ptr;
+            var dataWords = Math.ceil(dataBytes / 4);
+            var arrayBuf = new ArrayBuffer(dataWords * 4);
+            var store8 = new Uint8Array(arrayBuf);
+            store8.set(new Uint8Array(input, data.ptr, dataBytes));
+            var stuffedData = new Uint32Array(arrayBuf);
+            var bitPos = 0, word, srcPtr = 0;
+            word = stuffedData[0];
+            for (i = i0; i < i1; i++) {
+              j = i - (i < size ? 0 : size);
+              len = codeTable[j].first;
+              if (len > 0) {
+                codeTable[j].second = word << bitPos >>> 32 - len;
+                if (32 - bitPos >= len) {
+                  bitPos += len;
+                  if (bitPos === 32) {
+                    bitPos = 0;
+                    srcPtr++;
+                    word = stuffedData[srcPtr];
+                  }
+                } else {
+                  bitPos += len - 32;
+                  srcPtr++;
+                  word = stuffedData[srcPtr];
+                  codeTable[j].second |= word >>> 32 - bitPos;
+                }
+              }
+            }
+            var numBitsLUT = 0, numBitsLUTQick = 0;
+            var tree = new TreeNode();
+            for (i = 0; i < codeTable.length; i++) {
+              if (codeTable[i] !== void 0) {
+                numBitsLUT = Math.max(numBitsLUT, codeTable[i].first);
+              }
+            }
+            if (numBitsLUT >= BITS_MAX) {
+              numBitsLUTQick = BITS_MAX;
+            } else {
+              numBitsLUTQick = numBitsLUT;
+            }
+            if (numBitsLUT >= 30) {
+              console.log("WARning, large NUM LUT BITS IS " + numBitsLUT);
+            }
+            var decodeLut = [], entry, code, numEntries, jj, currentBit, node;
+            for (i = i0; i < i1; i++) {
+              j = i - (i < size ? 0 : size);
+              len = codeTable[j].first;
+              if (len > 0) {
+                entry = [len, j];
+                if (len <= numBitsLUTQick) {
+                  code = codeTable[j].second << numBitsLUTQick - len;
+                  numEntries = 1 << numBitsLUTQick - len;
+                  for (k = 0; k < numEntries; k++) {
+                    decodeLut[code | k] = entry;
+                  }
+                } else {
+                  code = codeTable[j].second;
+                  node = tree;
+                  for (jj = len - 1; jj >= 0; jj--) {
+                    currentBit = code >>> jj & 1;
+                    if (currentBit) {
+                      if (!node.right) {
+                        node.right = new TreeNode();
+                      }
+                      node = node.right;
+                    } else {
+                      if (!node.left) {
+                        node.left = new TreeNode();
+                      }
+                      node = node.left;
+                    }
+                    if (jj === 0 && !node.val) {
+                      node.val = entry[1];
+                    }
+                  }
+                }
+              }
+            }
+            return {
+              decodeLut,
+              numBitsLUTQick,
+              numBitsLUT,
+              tree,
+              stuffedData,
+              srcPtr,
+              bitPos
+            };
+          },
+          readHuffman: function(input, data, OutPixelTypeArray) {
+            var headerInfo = data.headerInfo;
+            var numDims = headerInfo.numDims;
+            var height = data.headerInfo.height;
+            var width = data.headerInfo.width;
+            var numPixels = width * height;
+            var huffmanInfo = this.readHuffmanTree(input, data);
+            var decodeLut = huffmanInfo.decodeLut;
+            var tree = huffmanInfo.tree;
+            var stuffedData = huffmanInfo.stuffedData;
+            var srcPtr = huffmanInfo.srcPtr;
+            var bitPos = huffmanInfo.bitPos;
+            var numBitsLUTQick = huffmanInfo.numBitsLUTQick;
+            var numBitsLUT = huffmanInfo.numBitsLUT;
+            var offset = data.headerInfo.imageType === 0 ? 128 : 0;
+            var node, val, delta, mask = data.pixels.resultMask, valTmp, valTmpQuick, currentBit;
+            var i, j, k, ii;
+            var prevVal = 0;
+            if (bitPos > 0) {
+              srcPtr++;
+              bitPos = 0;
+            }
+            var word = stuffedData[srcPtr];
+            var deltaEncode = data.encodeMode === 1;
+            var resultPixelsAllDim = new OutPixelTypeArray(numPixels * numDims);
+            var resultPixels = resultPixelsAllDim;
+            var iDim;
+            for (iDim = 0; iDim < headerInfo.numDims; iDim++) {
+              if (numDims > 1) {
+                resultPixels = new OutPixelTypeArray(resultPixelsAllDim.buffer, numPixels * iDim, numPixels);
+                prevVal = 0;
+              }
+              if (data.headerInfo.numValidPixel === width * height) {
+                for (k = 0, i = 0; i < height; i++) {
+                  for (j = 0; j < width; j++, k++) {
+                    val = 0;
+                    valTmp = word << bitPos >>> 32 - numBitsLUTQick;
+                    valTmpQuick = valTmp;
+                    if (32 - bitPos < numBitsLUTQick) {
+                      valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
+                      valTmpQuick = valTmp;
+                    }
+                    if (decodeLut[valTmpQuick]) {
+                      val = decodeLut[valTmpQuick][1];
+                      bitPos += decodeLut[valTmpQuick][0];
+                    } else {
+                      valTmp = word << bitPos >>> 32 - numBitsLUT;
+                      valTmpQuick = valTmp;
+                      if (32 - bitPos < numBitsLUT) {
+                        valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
+                        valTmpQuick = valTmp;
+                      }
+                      node = tree;
+                      for (ii = 0; ii < numBitsLUT; ii++) {
+                        currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
+                        node = currentBit ? node.right : node.left;
+                        if (!(node.left || node.right)) {
+                          val = node.val;
+                          bitPos = bitPos + ii + 1;
+                          break;
+                        }
+                      }
+                    }
+                    if (bitPos >= 32) {
+                      bitPos -= 32;
+                      srcPtr++;
+                      word = stuffedData[srcPtr];
+                    }
+                    delta = val - offset;
+                    if (deltaEncode) {
+                      if (j > 0) {
+                        delta += prevVal;
+                      } else if (i > 0) {
+                        delta += resultPixels[k - width];
+                      } else {
+                        delta += prevVal;
+                      }
+                      delta &= 255;
+                      resultPixels[k] = delta;
+                      prevVal = delta;
+                    } else {
+                      resultPixels[k] = delta;
+                    }
+                  }
+                }
+              } else {
+                for (k = 0, i = 0; i < height; i++) {
+                  for (j = 0; j < width; j++, k++) {
+                    if (mask[k]) {
+                      val = 0;
+                      valTmp = word << bitPos >>> 32 - numBitsLUTQick;
+                      valTmpQuick = valTmp;
+                      if (32 - bitPos < numBitsLUTQick) {
+                        valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
+                        valTmpQuick = valTmp;
+                      }
+                      if (decodeLut[valTmpQuick]) {
+                        val = decodeLut[valTmpQuick][1];
+                        bitPos += decodeLut[valTmpQuick][0];
+                      } else {
+                        valTmp = word << bitPos >>> 32 - numBitsLUT;
+                        valTmpQuick = valTmp;
+                        if (32 - bitPos < numBitsLUT) {
+                          valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
+                          valTmpQuick = valTmp;
+                        }
+                        node = tree;
+                        for (ii = 0; ii < numBitsLUT; ii++) {
+                          currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
+                          node = currentBit ? node.right : node.left;
+                          if (!(node.left || node.right)) {
+                            val = node.val;
+                            bitPos = bitPos + ii + 1;
+                            break;
+                          }
+                        }
+                      }
+                      if (bitPos >= 32) {
+                        bitPos -= 32;
+                        srcPtr++;
+                        word = stuffedData[srcPtr];
+                      }
+                      delta = val - offset;
+                      if (deltaEncode) {
+                        if (j > 0 && mask[k - 1]) {
+                          delta += prevVal;
+                        } else if (i > 0 && mask[k - width]) {
+                          delta += resultPixels[k - width];
+                        } else {
+                          delta += prevVal;
+                        }
+                        delta &= 255;
+                        resultPixels[k] = delta;
+                        prevVal = delta;
+                      } else {
+                        resultPixels[k] = delta;
+                      }
+                    }
+                  }
+                }
+              }
+              data.ptr = data.ptr + (srcPtr + 1) * 4 + (bitPos > 0 ? 4 : 0);
+            }
+            data.pixels.resultPixels = resultPixelsAllDim;
+          },
+          decodeBits: function(input, data, blockDataBuffer, offset, iDim) {
+            {
+              var headerInfo = data.headerInfo;
+              var fileVersion = headerInfo.fileVersion;
+              var blockPtr = 0;
+              var view = new DataView(input, data.ptr, 5);
+              var headerByte = view.getUint8(0);
+              blockPtr++;
+              var bits67 = headerByte >> 6;
+              var n = bits67 === 0 ? 4 : 3 - bits67;
+              var doLut = (headerByte & 32) > 0 ? true : false;
+              var numBits = headerByte & 31;
+              var numElements = 0;
+              if (n === 1) {
+                numElements = view.getUint8(blockPtr);
+                blockPtr++;
+              } else if (n === 2) {
+                numElements = view.getUint16(blockPtr, true);
+                blockPtr += 2;
+              } else if (n === 4) {
+                numElements = view.getUint32(blockPtr, true);
+                blockPtr += 4;
+              } else {
+                throw "Invalid valid pixel count type";
+              }
+              var scale = 2 * headerInfo.maxZError;
+              var stuffedData, arrayBuf, store8, dataBytes, dataWords;
+              var lutArr, lutData, lutBytes, lutBitsPerElement, bitsPerPixel;
+              var zMax = headerInfo.numDims > 1 ? headerInfo.maxValues[iDim] : headerInfo.zMax;
+              if (doLut) {
+                data.counter.lut++;
+                lutBytes = view.getUint8(blockPtr);
+                lutBitsPerElement = numBits;
+                blockPtr++;
+                dataBytes = Math.ceil((lutBytes - 1) * numBits / 8);
+                dataWords = Math.ceil(dataBytes / 4);
+                arrayBuf = new ArrayBuffer(dataWords * 4);
+                store8 = new Uint8Array(arrayBuf);
+                data.ptr += blockPtr;
+                store8.set(new Uint8Array(input, data.ptr, dataBytes));
+                lutData = new Uint32Array(arrayBuf);
+                data.ptr += dataBytes;
+                bitsPerPixel = 0;
+                while (lutBytes - 1 >>> bitsPerPixel) {
+                  bitsPerPixel++;
+                }
+                dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
+                dataWords = Math.ceil(dataBytes / 4);
+                arrayBuf = new ArrayBuffer(dataWords * 4);
+                store8 = new Uint8Array(arrayBuf);
+                store8.set(new Uint8Array(input, data.ptr, dataBytes));
+                stuffedData = new Uint32Array(arrayBuf);
+                data.ptr += dataBytes;
+                if (fileVersion >= 3) {
+                  lutArr = BitStuffer.unstuffLUT2(lutData, numBits, lutBytes - 1, offset, scale, zMax);
+                } else {
+                  lutArr = BitStuffer.unstuffLUT(lutData, numBits, lutBytes - 1, offset, scale, zMax);
+                }
+                if (fileVersion >= 3) {
+                  BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
+                } else {
+                  BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
+                }
+              } else {
+                data.counter.bitstuffer++;
+                bitsPerPixel = numBits;
+                data.ptr += blockPtr;
+                if (bitsPerPixel > 0) {
+                  dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
+                  dataWords = Math.ceil(dataBytes / 4);
+                  arrayBuf = new ArrayBuffer(dataWords * 4);
+                  store8 = new Uint8Array(arrayBuf);
+                  store8.set(new Uint8Array(input, data.ptr, dataBytes));
+                  stuffedData = new Uint32Array(arrayBuf);
+                  data.ptr += dataBytes;
+                  if (fileVersion >= 3) {
+                    if (offset == null) {
+                      BitStuffer.originalUnstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
+                    } else {
+                      BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
+                    }
+                  } else {
+                    if (offset == null) {
+                      BitStuffer.originalUnstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
+                    } else {
+                      BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
+                    }
+                  }
+                }
+              }
+            }
+          },
+          readTiles: function(input, data, OutPixelTypeArray) {
+            var headerInfo = data.headerInfo;
+            var width = headerInfo.width;
+            var height = headerInfo.height;
+            var microBlockSize = headerInfo.microBlockSize;
+            var imageType = headerInfo.imageType;
+            var dataTypeSize = Lerc2Helpers.getDataTypeSize(imageType);
+            var numBlocksX = Math.ceil(width / microBlockSize);
+            var numBlocksY = Math.ceil(height / microBlockSize);
+            data.pixels.numBlocksY = numBlocksY;
+            data.pixels.numBlocksX = numBlocksX;
+            data.pixels.ptr = 0;
+            var row = 0, col = 0, blockY = 0, blockX = 0, thisBlockHeight = 0, thisBlockWidth = 0, bytesLeft = 0, headerByte = 0, bits67 = 0, testCode = 0, outPtr = 0, outStride = 0, numBytes = 0, bytesleft = 0, z = 0, blockPtr = 0;
+            var view, block, arrayBuf, store8, rawData;
+            var blockEncoding;
+            var blockDataBuffer = new OutPixelTypeArray(microBlockSize * microBlockSize);
+            var lastBlockHeight = height % microBlockSize || microBlockSize;
+            var lastBlockWidth = width % microBlockSize || microBlockSize;
+            var offsetType, offset;
+            var numDims = headerInfo.numDims, iDim;
+            var mask = data.pixels.resultMask;
+            var resultPixels = data.pixels.resultPixels;
+            for (blockY = 0; blockY < numBlocksY; blockY++) {
+              thisBlockHeight = blockY !== numBlocksY - 1 ? microBlockSize : lastBlockHeight;
+              for (blockX = 0; blockX < numBlocksX; blockX++) {
+                thisBlockWidth = blockX !== numBlocksX - 1 ? microBlockSize : lastBlockWidth;
+                outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
+                outStride = width - thisBlockWidth;
+                for (iDim = 0; iDim < numDims; iDim++) {
+                  if (numDims > 1) {
+                    resultPixels = new OutPixelTypeArray(data.pixels.resultPixels.buffer, width * height * iDim * dataTypeSize, width * height);
+                  }
+                  bytesLeft = input.byteLength - data.ptr;
+                  view = new DataView(input, data.ptr, Math.min(10, bytesLeft));
+                  block = {};
+                  blockPtr = 0;
+                  headerByte = view.getUint8(0);
+                  blockPtr++;
+                  bits67 = headerByte >> 6 & 255;
+                  testCode = headerByte >> 2 & 15;
+                  if (testCode !== (blockX * microBlockSize >> 3 & 15)) {
+                    throw "integrity issue";
+                  }
+                  blockEncoding = headerByte & 3;
+                  if (blockEncoding > 3) {
+                    data.ptr += blockPtr;
+                    throw "Invalid block encoding (" + blockEncoding + ")";
+                  } else if (blockEncoding === 2) {
+                    data.counter.constant++;
+                    data.ptr += blockPtr;
+                    continue;
+                  } else if (blockEncoding === 0) {
+                    data.counter.uncompressed++;
+                    data.ptr += blockPtr;
+                    numBytes = thisBlockHeight * thisBlockWidth * dataTypeSize;
+                    bytesleft = input.byteLength - data.ptr;
+                    numBytes = numBytes < bytesleft ? numBytes : bytesleft;
+                    arrayBuf = new ArrayBuffer(numBytes % dataTypeSize === 0 ? numBytes : numBytes + dataTypeSize - numBytes % dataTypeSize);
+                    store8 = new Uint8Array(arrayBuf);
+                    store8.set(new Uint8Array(input, data.ptr, numBytes));
+                    rawData = new OutPixelTypeArray(arrayBuf);
+                    z = 0;
+                    if (mask) {
+                      for (row = 0; row < thisBlockHeight; row++) {
+                        for (col = 0; col < thisBlockWidth; col++) {
+                          if (mask[outPtr]) {
+                            resultPixels[outPtr] = rawData[z++];
+                          }
+                          outPtr++;
+                        }
+                        outPtr += outStride;
+                      }
+                    } else {
+                      for (row = 0; row < thisBlockHeight; row++) {
+                        for (col = 0; col < thisBlockWidth; col++) {
+                          resultPixels[outPtr++] = rawData[z++];
+                        }
+                        outPtr += outStride;
+                      }
+                    }
+                    data.ptr += z * dataTypeSize;
+                  } else {
+                    offsetType = Lerc2Helpers.getDataTypeUsed(imageType, bits67);
+                    offset = Lerc2Helpers.getOnePixel(block, blockPtr, offsetType, view);
+                    blockPtr += Lerc2Helpers.getDataTypeSize(offsetType);
+                    if (blockEncoding === 3) {
+                      data.ptr += blockPtr;
+                      data.counter.constantoffset++;
+                      if (mask) {
+                        for (row = 0; row < thisBlockHeight; row++) {
+                          for (col = 0; col < thisBlockWidth; col++) {
+                            if (mask[outPtr]) {
+                              resultPixels[outPtr] = offset;
+                            }
+                            outPtr++;
+                          }
+                          outPtr += outStride;
+                        }
+                      } else {
+                        for (row = 0; row < thisBlockHeight; row++) {
+                          for (col = 0; col < thisBlockWidth; col++) {
+                            resultPixels[outPtr++] = offset;
+                          }
+                          outPtr += outStride;
+                        }
+                      }
+                    } else {
+                      data.ptr += blockPtr;
+                      Lerc2Helpers.decodeBits(input, data, blockDataBuffer, offset, iDim);
+                      blockPtr = 0;
+                      if (mask) {
+                        for (row = 0; row < thisBlockHeight; row++) {
+                          for (col = 0; col < thisBlockWidth; col++) {
+                            if (mask[outPtr]) {
+                              resultPixels[outPtr] = blockDataBuffer[blockPtr++];
+                            }
+                            outPtr++;
+                          }
+                          outPtr += outStride;
+                        }
+                      } else {
+                        for (row = 0; row < thisBlockHeight; row++) {
+                          for (col = 0; col < thisBlockWidth; col++) {
+                            resultPixels[outPtr++] = blockDataBuffer[blockPtr++];
+                          }
+                          outPtr += outStride;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          /*****************
+          *  private methods (helper methods)
+          *****************/
+          formatFileInfo: function(data) {
+            return {
+              "fileIdentifierString": data.headerInfo.fileIdentifierString,
+              "fileVersion": data.headerInfo.fileVersion,
+              "imageType": data.headerInfo.imageType,
+              "height": data.headerInfo.height,
+              "width": data.headerInfo.width,
+              "numValidPixel": data.headerInfo.numValidPixel,
+              "microBlockSize": data.headerInfo.microBlockSize,
+              "blobSize": data.headerInfo.blobSize,
+              "maxZError": data.headerInfo.maxZError,
+              "pixelType": Lerc2Helpers.getPixelType(data.headerInfo.imageType),
+              "eofOffset": data.eofOffset,
+              "mask": data.mask ? {
+                "numBytes": data.mask.numBytes
+              } : null,
+              "pixels": {
+                "numBlocksX": data.pixels.numBlocksX,
+                "numBlocksY": data.pixels.numBlocksY,
+                //"numBytes": data.pixels.numBytes,
+                "maxValue": data.headerInfo.zMax,
+                "minValue": data.headerInfo.zMin,
+                "noDataValue": data.noDataValue
+              }
+            };
+          },
+          constructConstantSurface: function(data) {
+            var val = data.headerInfo.zMax;
+            var numDims = data.headerInfo.numDims;
+            var numPixels = data.headerInfo.height * data.headerInfo.width;
+            var numPixelAllDims = numPixels * numDims;
+            var i = 0, k = 0, nStart = 0;
+            var mask = data.pixels.resultMask;
+            if (mask) {
+              if (numDims > 1) {
+                for (i = 0; i < numDims; i++) {
+                  nStart = i * numPixels;
+                  for (k = 0; k < numPixels; k++) {
+                    if (mask[k]) {
+                      data.pixels.resultPixels[nStart + k] = val;
+                    }
+                  }
+                }
+              } else {
+                for (k = 0; k < numPixels; k++) {
+                  if (mask[k]) {
+                    data.pixels.resultPixels[k] = val;
+                  }
+                }
+              }
+            } else {
+              if (data.pixels.resultPixels.fill) {
+                data.pixels.resultPixels.fill(val);
+              } else {
+                for (k = 0; k < numPixelAllDims; k++) {
+                  data.pixels.resultPixels[k] = val;
+                }
+              }
+            }
+            return;
+          },
+          getDataTypeArray: function(t) {
+            var tp;
+            switch (t) {
+              case 0:
+                tp = Int8Array;
+                break;
+              case 1:
+                tp = Uint8Array;
+                break;
+              case 2:
+                tp = Int16Array;
+                break;
+              case 3:
+                tp = Uint16Array;
+                break;
+              case 4:
+                tp = Int32Array;
+                break;
+              case 5:
+                tp = Uint32Array;
+                break;
+              case 6:
+                tp = Float32Array;
+                break;
+              case 7:
+                tp = Float64Array;
+                break;
+              default:
+                tp = Float32Array;
+            }
+            return tp;
+          },
+          getPixelType: function(t) {
+            var tp;
+            switch (t) {
+              case 0:
+                tp = "S8";
+                break;
+              case 1:
+                tp = "U8";
+                break;
+              case 2:
+                tp = "S16";
+                break;
+              case 3:
+                tp = "U16";
+                break;
+              case 4:
+                tp = "S32";
+                break;
+              case 5:
+                tp = "U32";
+                break;
+              case 6:
+                tp = "F32";
+                break;
+              case 7:
+                tp = "F64";
+                break;
+              default:
+                tp = "F32";
+            }
+            return tp;
+          },
+          isValidPixelValue: function(t, val) {
+            if (val == null) {
+              return false;
+            }
+            var isValid;
+            switch (t) {
+              case 0:
+                isValid = val >= -128 && val <= 127;
+                break;
+              case 1:
+                isValid = val >= 0 && val <= 255;
+                break;
+              case 2:
+                isValid = val >= -32768 && val <= 32767;
+                break;
+              case 3:
+                isValid = val >= 0 && val <= 65536;
+                break;
+              case 4:
+                isValid = val >= -2147483648 && val <= 2147483647;
+                break;
+              case 5:
+                isValid = val >= 0 && val <= 4294967296;
+                break;
+              case 6:
+                isValid = val >= -34027999387901484e22 && val <= 34027999387901484e22;
+                break;
+              case 7:
+                isValid = val >= 5e-324 && val <= 17976931348623157e292;
+                break;
+              default:
+                isValid = false;
+            }
+            return isValid;
+          },
+          getDataTypeSize: function(t) {
+            var s = 0;
+            switch (t) {
+              case 0:
+              case 1:
+                s = 1;
+                break;
+              case 2:
+              case 3:
+                s = 2;
+                break;
+              case 4:
+              case 5:
+              case 6:
+                s = 4;
+                break;
+              case 7:
+                s = 8;
+                break;
+              default:
+                s = t;
+            }
+            return s;
+          },
+          getDataTypeUsed: function(dt, tc) {
+            var t = dt;
+            switch (dt) {
+              case 2:
+              case 4:
+                t = dt - tc;
+                break;
+              case 3:
+              case 5:
+                t = dt - 2 * tc;
+                break;
+              case 6:
+                if (0 === tc) {
+                  t = dt;
+                } else if (1 === tc) {
+                  t = 2;
+                } else {
+                  t = 1;
+                }
+                break;
+              case 7:
+                if (0 === tc) {
+                  t = dt;
+                } else {
+                  t = dt - 2 * tc + 1;
+                }
+                break;
+              default:
+                t = dt;
+                break;
+            }
+            return t;
+          },
+          getOnePixel: function(block, blockPtr, offsetType, view) {
+            var temp = 0;
+            switch (offsetType) {
+              case 0:
+                temp = view.getInt8(blockPtr);
+                break;
+              case 1:
+                temp = view.getUint8(blockPtr);
+                break;
+              case 2:
+                temp = view.getInt16(blockPtr, true);
+                break;
+              case 3:
+                temp = view.getUint16(blockPtr, true);
+                break;
+              case 4:
+                temp = view.getInt32(blockPtr, true);
+                break;
+              case 5:
+                temp = view.getUInt32(blockPtr, true);
+                break;
+              case 6:
+                temp = view.getFloat32(blockPtr, true);
+                break;
+              case 7:
+                temp = view.getFloat64(blockPtr, true);
+                break;
+              default:
+                throw "the decoder does not understand this pixel type";
+            }
+            return temp;
+          }
+        };
+        var TreeNode = function(val, left, right) {
+          this.val = val;
+          this.left = left;
+          this.right = right;
+        };
+        var Lerc2Decode2 = {
+          /*
+          * ********removed options compared to LERC1. We can bring some of them back if needed.
+           * removed pixel type. LERC2 is typed and doesn't require user to give pixel type
+           * changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly.
+           * removed returnMask. mask is used by LERC2 internally and is cost free. In case of user input mask, it's returned as well and has neglible cost.
+           * removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc,
+           *       user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now.
+           *       We can add it back later if their's a clear requirement.
+           * removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient)
+           * removed computeUsedBitDepths.
+           *
+           *
+           * response changes compared to LERC1
+           * 1. encodedMaskData is not available
+           * 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range)
+           * 3. maskData is always available
+          */
+          /*****************
+          *  public properties
+          ******************/
+          //HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable
+          /*****************
+          *  public methods
+          *****************/
+          /**
+           * Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata.
+           *
+           * @param {ArrayBuffer} input The LERC input byte stream
+           * @param {object} [options] options Decoding options
+           * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position
+           * @param {boolean} [options.returnFileInfo] If true, the return value will have a fileInfo property that contains metadata obtained from the LERC headers and the decoding process
+           */
+          decode: function(input, options) {
+            options = options || {};
+            var noDataValue = options.noDataValue;
+            var i = 0, data = {};
+            data.ptr = options.inputOffset || 0;
+            data.pixels = {};
+            if (!Lerc2Helpers.readHeaderInfo(input, data)) {
+              return;
+            }
+            var headerInfo = data.headerInfo;
+            var fileVersion = headerInfo.fileVersion;
+            var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
+            Lerc2Helpers.readMask(input, data);
+            if (headerInfo.numValidPixel !== headerInfo.width * headerInfo.height && !data.pixels.resultMask) {
+              data.pixels.resultMask = options.maskData;
+            }
+            var numPixels = headerInfo.width * headerInfo.height;
+            data.pixels.resultPixels = new OutPixelTypeArray(numPixels * headerInfo.numDims);
+            data.counter = {
+              onesweep: 0,
+              uncompressed: 0,
+              lut: 0,
+              bitstuffer: 0,
+              constant: 0,
+              constantoffset: 0
+            };
+            if (headerInfo.numValidPixel !== 0) {
+              if (headerInfo.zMax === headerInfo.zMin) {
+                Lerc2Helpers.constructConstantSurface(data);
+              } else if (fileVersion >= 4 && Lerc2Helpers.checkMinMaxRanges(input, data)) {
+                Lerc2Helpers.constructConstantSurface(data);
+              } else {
+                var view = new DataView(input, data.ptr, 2);
+                var bReadDataOneSweep = view.getUint8(0);
+                data.ptr++;
+                if (bReadDataOneSweep) {
+                  Lerc2Helpers.readDataOneSweep(input, data, OutPixelTypeArray);
+                } else {
+                  if (fileVersion > 1 && headerInfo.imageType <= 1 && Math.abs(headerInfo.maxZError - 0.5) < 1e-5) {
+                    var flagHuffman = view.getUint8(1);
+                    data.ptr++;
+                    data.encodeMode = flagHuffman;
+                    if (flagHuffman > 2 || fileVersion < 4 && flagHuffman > 1) {
+                      throw "Invalid Huffman flag " + flagHuffman;
+                    }
+                    if (flagHuffman) {
+                      Lerc2Helpers.readHuffman(input, data, OutPixelTypeArray);
+                    } else {
+                      Lerc2Helpers.readTiles(input, data, OutPixelTypeArray);
+                    }
+                  } else {
+                    Lerc2Helpers.readTiles(input, data, OutPixelTypeArray);
+                  }
+                }
+              }
+            }
+            data.eofOffset = data.ptr;
+            var diff;
+            if (options.inputOffset) {
+              diff = data.headerInfo.blobSize + options.inputOffset - data.ptr;
+              if (Math.abs(diff) >= 1) {
+                data.eofOffset = options.inputOffset + data.headerInfo.blobSize;
+              }
+            } else {
+              diff = data.headerInfo.blobSize - data.ptr;
+              if (Math.abs(diff) >= 1) {
+                data.eofOffset = data.headerInfo.blobSize;
+              }
+            }
+            var result = {
+              width: headerInfo.width,
+              height: headerInfo.height,
+              pixelData: data.pixels.resultPixels,
+              minValue: headerInfo.zMin,
+              maxValue: headerInfo.zMax,
+              validPixelCount: headerInfo.numValidPixel,
+              dimCount: headerInfo.numDims,
+              dimStats: {
+                minValues: headerInfo.minValues,
+                maxValues: headerInfo.maxValues
+              },
+              maskData: data.pixels.resultMask
+              //noDataValue: noDataValue
+            };
+            if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
+              var mask = data.pixels.resultMask;
+              for (i = 0; i < numPixels; i++) {
+                if (!mask[i]) {
+                  result.pixelData[i] = noDataValue;
+                }
+              }
+              result.noDataValue = noDataValue;
+            }
+            data.noDataValue = noDataValue;
+            if (options.returnFileInfo) {
+              result.fileInfo = Lerc2Helpers.formatFileInfo(data);
+            }
+            return result;
+          },
+          getBandCount: function(input) {
+            var count = 0;
+            var i = 0;
+            var temp = {};
+            temp.ptr = 0;
+            temp.pixels = {};
+            while (i < input.byteLength - 58) {
+              Lerc2Helpers.readHeaderInfo(input, temp);
+              i += temp.headerInfo.blobSize;
+              count++;
+              temp.ptr = i;
+            }
+            return count;
+          }
+        };
+        return Lerc2Decode2;
+      }();
+      var isPlatformLittleEndian = function() {
+        var a = new ArrayBuffer(4);
+        var b = new Uint8Array(a);
+        var c = new Uint32Array(a);
+        c[0] = 1;
+        return b[0] === 1;
+      }();
+      var Lerc2 = {
+        /************wrapper**********************************************/
+        /**
+         * A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types.
+         *
+         * @alias module:Lerc
+         * @param {ArrayBuffer} input The LERC input byte stream
+         * @param {object} [options] The decoding options below are optional.
+         * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position.
+         * @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32.
+         * @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value.
+         * @returns {{width, height, pixels, pixelType, mask, statistics}}
+           * @property {number} width Width of decoded image.
+           * @property {number} height Height of decoded image.
+           * @property {array} pixels [band1, band2, …] Each band is a typed array of width*height.
+           * @property {string} pixelType The type of pixels represented in the output.
+           * @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid.
+           * @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values
+        **/
+        decode: function(encodedData, options) {
+          if (!isPlatformLittleEndian) {
+            throw "Big endian system is not supported.";
+          }
+          options = options || {};
+          var inputOffset = options.inputOffset || 0;
+          var fileIdView = new Uint8Array(encodedData, inputOffset, 10);
+          var fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
+          var lerc, majorVersion;
+          if (fileIdentifierString.trim() === "CntZImage") {
+            lerc = LercDecode;
+            majorVersion = 1;
+          } else if (fileIdentifierString.substring(0, 5) === "Lerc2") {
+            lerc = Lerc2Decode;
+            majorVersion = 2;
+          } else {
+            throw "Unexpected file identifier string: " + fileIdentifierString;
+          }
+          var iPlane = 0, eof = encodedData.byteLength - 10, encodedMaskData, bandMasks = [], bandMask, maskData;
+          var decodedPixelBlock = {
+            width: 0,
+            height: 0,
+            pixels: [],
+            pixelType: options.pixelType,
+            mask: null,
+            statistics: []
+          };
+          while (inputOffset < eof) {
+            var result = lerc.decode(encodedData, {
+              inputOffset,
+              //for both lerc1 and lerc2
+              encodedMaskData,
+              //lerc1 only
+              maskData,
+              //lerc2 only
+              returnMask: iPlane === 0 ? true : false,
+              //lerc1 only
+              returnEncodedMask: iPlane === 0 ? true : false,
+              //lerc1 only
+              returnFileInfo: true,
+              //for both lerc1 and lerc2
+              pixelType: options.pixelType || null,
+              //lerc1 only
+              noDataValue: options.noDataValue || null
+              //lerc1 only
+            });
+            inputOffset = result.fileInfo.eofOffset;
+            if (iPlane === 0) {
+              encodedMaskData = result.encodedMaskData;
+              maskData = result.maskData;
+              decodedPixelBlock.width = result.width;
+              decodedPixelBlock.height = result.height;
+              decodedPixelBlock.dimCount = result.dimCount || 1;
+              decodedPixelBlock.pixelType = result.pixelType || result.fileInfo.pixelType;
+              decodedPixelBlock.mask = result.maskData;
+            }
+            if (majorVersion > 1 && result.fileInfo.mask && result.fileInfo.mask.numBytes > 0) {
+              bandMasks.push(result.maskData);
+            }
+            iPlane++;
+            decodedPixelBlock.pixels.push(result.pixelData);
+            decodedPixelBlock.statistics.push({
+              minValue: result.minValue,
+              maxValue: result.maxValue,
+              noDataValue: result.noDataValue,
+              dimStats: result.dimStats
+            });
+          }
+          var i, j, numPixels;
+          if (majorVersion > 1 && bandMasks.length > 1) {
+            numPixels = decodedPixelBlock.width * decodedPixelBlock.height;
+            decodedPixelBlock.bandMasks = bandMasks;
+            maskData = new Uint8Array(numPixels);
+            maskData.set(bandMasks[0]);
+            for (i = 1; i < bandMasks.length; i++) {
+              bandMask = bandMasks[i];
+              for (j = 0; j < numPixels; j++) {
+                maskData[j] = maskData[j] & bandMask[j];
+              }
+            }
+            decodedPixelBlock.maskData = maskData;
+          }
+          return decodedPixelBlock;
+        }
+      };
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          return Lerc2;
+        });
+      } else if (typeof module !== "undefined" && module.exports) {
+        module.exports = Lerc2;
+      } else {
+        this.Lerc = Lerc2;
+      }
+    })();
+  }
+});
+
+// packages/engine/Source/Core/HeightmapEncoding.js
+var HeightmapEncoding = {
+  /**
+   * No encoding
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * LERC encoding
+   *
+   * @type {number}
+   * @constant
+   *
+   * @see {@link https://github.com/Esri/lerc|The LERC specification}
+   */
+  LERC: 1
+};
+var HeightmapEncoding_default = Object.freeze(HeightmapEncoding);
+
+// packages/engine/Source/Core/HeightmapTessellator.js
+var HeightmapTessellator = {};
+HeightmapTessellator.DEFAULT_STRUCTURE = Object.freeze({
+  heightScale: 1,
+  heightOffset: 0,
+  elementsPerHeight: 1,
+  stride: 1,
+  elementMultiplier: 256,
+  isBigEndian: false
+});
+var cartesian3Scratch = new Cartesian3_default();
+var matrix4Scratch = new Matrix4_default();
+var minimumScratch = new Cartesian3_default();
+var maximumScratch = new Cartesian3_default();
+HeightmapTessellator.computeVertices = function(options) {
+  if (!defined_default(options) || !defined_default(options.heightmap)) {
+    throw new DeveloperError_default("options.heightmap is required.");
+  }
+  if (!defined_default(options.width) || !defined_default(options.height)) {
+    throw new DeveloperError_default("options.width and options.height are required.");
+  }
+  if (!defined_default(options.nativeRectangle)) {
+    throw new DeveloperError_default("options.nativeRectangle is required.");
+  }
+  if (!defined_default(options.skirtHeight)) {
+    throw new DeveloperError_default("options.skirtHeight is required.");
+  }
+  const cos = Math.cos;
+  const sin = Math.sin;
+  const sqrt = Math.sqrt;
+  const atan = Math.atan;
+  const exp = Math.exp;
+  const piOverTwo = Math_default.PI_OVER_TWO;
+  const toRadians = Math_default.toRadians;
+  const heightmap = options.heightmap;
+  const width = options.width;
+  const height = options.height;
+  const skirtHeight = options.skirtHeight;
+  const hasSkirts = skirtHeight > 0;
+  const isGeographic = defaultValue_default(options.isGeographic, true);
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
+  const oneOverGlobeSemimajorAxis = 1 / ellipsoid.maximumRadius;
+  const nativeRectangle = Rectangle_default.clone(options.nativeRectangle);
+  const rectangle = Rectangle_default.clone(options.rectangle);
+  let geographicWest;
+  let geographicSouth;
+  let geographicEast;
+  let geographicNorth;
+  if (!defined_default(rectangle)) {
+    if (isGeographic) {
+      geographicWest = toRadians(nativeRectangle.west);
+      geographicSouth = toRadians(nativeRectangle.south);
+      geographicEast = toRadians(nativeRectangle.east);
+      geographicNorth = toRadians(nativeRectangle.north);
+    } else {
+      geographicWest = nativeRectangle.west * oneOverGlobeSemimajorAxis;
+      geographicSouth = piOverTwo - 2 * atan(exp(-nativeRectangle.south * oneOverGlobeSemimajorAxis));
+      geographicEast = nativeRectangle.east * oneOverGlobeSemimajorAxis;
+      geographicNorth = piOverTwo - 2 * atan(exp(-nativeRectangle.north * oneOverGlobeSemimajorAxis));
+    }
+  } else {
+    geographicWest = rectangle.west;
+    geographicSouth = rectangle.south;
+    geographicEast = rectangle.east;
+    geographicNorth = rectangle.north;
+  }
+  let relativeToCenter = options.relativeToCenter;
+  const hasRelativeToCenter = defined_default(relativeToCenter);
+  relativeToCenter = hasRelativeToCenter ? relativeToCenter : Cartesian3_default.ZERO;
+  const includeWebMercatorT = defaultValue_default(options.includeWebMercatorT, false);
+  const exaggeration = defaultValue_default(options.exaggeration, 1);
+  const exaggerationRelativeHeight = defaultValue_default(
+    options.exaggerationRelativeHeight,
+    0
+  );
+  const hasExaggeration = exaggeration !== 1;
+  const includeGeodeticSurfaceNormals = hasExaggeration;
+  const structure = defaultValue_default(
+    options.structure,
+    HeightmapTessellator.DEFAULT_STRUCTURE
+  );
+  const heightScale = defaultValue_default(
+    structure.heightScale,
+    HeightmapTessellator.DEFAULT_STRUCTURE.heightScale
+  );
+  const heightOffset = defaultValue_default(
+    structure.heightOffset,
+    HeightmapTessellator.DEFAULT_STRUCTURE.heightOffset
+  );
+  const elementsPerHeight = defaultValue_default(
+    structure.elementsPerHeight,
+    HeightmapTessellator.DEFAULT_STRUCTURE.elementsPerHeight
+  );
+  const stride = defaultValue_default(
+    structure.stride,
+    HeightmapTessellator.DEFAULT_STRUCTURE.stride
+  );
+  const elementMultiplier = defaultValue_default(
+    structure.elementMultiplier,
+    HeightmapTessellator.DEFAULT_STRUCTURE.elementMultiplier
+  );
+  const isBigEndian = defaultValue_default(
+    structure.isBigEndian,
+    HeightmapTessellator.DEFAULT_STRUCTURE.isBigEndian
+  );
+  let rectangleWidth = Rectangle_default.computeWidth(nativeRectangle);
+  let rectangleHeight = Rectangle_default.computeHeight(nativeRectangle);
+  const granularityX = rectangleWidth / (width - 1);
+  const granularityY = rectangleHeight / (height - 1);
+  if (!isGeographic) {
+    rectangleWidth *= oneOverGlobeSemimajorAxis;
+    rectangleHeight *= oneOverGlobeSemimajorAxis;
+  }
+  const radiiSquared = ellipsoid.radiiSquared;
+  const radiiSquaredX = radiiSquared.x;
+  const radiiSquaredY = radiiSquared.y;
+  const radiiSquaredZ = radiiSquared.z;
+  let minimumHeight = 65536;
+  let maximumHeight = -65536;
+  const fromENU = Transforms_default.eastNorthUpToFixedFrame(
+    relativeToCenter,
+    ellipsoid
+  );
+  const toENU = Matrix4_default.inverseTransformation(fromENU, matrix4Scratch);
+  let southMercatorY;
+  let oneOverMercatorHeight;
+  if (includeWebMercatorT) {
+    southMercatorY = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
+      geographicSouth
+    );
+    oneOverMercatorHeight = 1 / (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(geographicNorth) - southMercatorY);
+  }
+  const minimum = minimumScratch;
+  minimum.x = Number.POSITIVE_INFINITY;
+  minimum.y = Number.POSITIVE_INFINITY;
+  minimum.z = Number.POSITIVE_INFINITY;
+  const maximum = maximumScratch;
+  maximum.x = Number.NEGATIVE_INFINITY;
+  maximum.y = Number.NEGATIVE_INFINITY;
+  maximum.z = Number.NEGATIVE_INFINITY;
+  let hMin = Number.POSITIVE_INFINITY;
+  const gridVertexCount = width * height;
+  const edgeVertexCount = skirtHeight > 0 ? width * 2 + height * 2 : 0;
+  const vertexCount = gridVertexCount + edgeVertexCount;
+  const positions = new Array(vertexCount);
+  const heights = new Array(vertexCount);
+  const uvs = new Array(vertexCount);
+  const webMercatorTs = includeWebMercatorT ? new Array(vertexCount) : [];
+  const geodeticSurfaceNormals = includeGeodeticSurfaceNormals ? new Array(vertexCount) : [];
+  let startRow = 0;
+  let endRow = height;
+  let startCol = 0;
+  let endCol = width;
+  if (hasSkirts) {
+    --startRow;
+    ++endRow;
+    --startCol;
+    ++endCol;
+  }
+  const skirtOffsetPercentage = 1e-5;
+  for (let rowIndex = startRow; rowIndex < endRow; ++rowIndex) {
+    let row = rowIndex;
+    if (row < 0) {
+      row = 0;
+    }
+    if (row >= height) {
+      row = height - 1;
+    }
+    let latitude = nativeRectangle.north - granularityY * row;
+    if (!isGeographic) {
+      latitude = piOverTwo - 2 * atan(exp(-latitude * oneOverGlobeSemimajorAxis));
+    } else {
+      latitude = toRadians(latitude);
+    }
+    let v = (latitude - geographicSouth) / (geographicNorth - geographicSouth);
+    v = Math_default.clamp(v, 0, 1);
+    const isNorthEdge = rowIndex === startRow;
+    const isSouthEdge = rowIndex === endRow - 1;
+    if (skirtHeight > 0) {
+      if (isNorthEdge) {
+        latitude += skirtOffsetPercentage * rectangleHeight;
+      } else if (isSouthEdge) {
+        latitude -= skirtOffsetPercentage * rectangleHeight;
+      }
+    }
+    const cosLatitude = cos(latitude);
+    const nZ = sin(latitude);
+    const kZ = radiiSquaredZ * nZ;
+    let webMercatorT;
+    if (includeWebMercatorT) {
+      webMercatorT = (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(latitude) - southMercatorY) * oneOverMercatorHeight;
+    }
+    for (let colIndex = startCol; colIndex < endCol; ++colIndex) {
+      let col = colIndex;
+      if (col < 0) {
+        col = 0;
+      }
+      if (col >= width) {
+        col = width - 1;
+      }
+      const terrainOffset = row * (width * stride) + col * stride;
+      let heightSample;
+      if (elementsPerHeight === 1) {
+        heightSample = heightmap[terrainOffset];
+      } else {
+        heightSample = 0;
+        let elementOffset;
+        if (isBigEndian) {
+          for (elementOffset = 0; elementOffset < elementsPerHeight; ++elementOffset) {
+            heightSample = heightSample * elementMultiplier + heightmap[terrainOffset + elementOffset];
+          }
+        } else {
+          for (elementOffset = elementsPerHeight - 1; elementOffset >= 0; --elementOffset) {
+            heightSample = heightSample * elementMultiplier + heightmap[terrainOffset + elementOffset];
+          }
+        }
+      }
+      heightSample = heightSample * heightScale + heightOffset;
+      maximumHeight = Math.max(maximumHeight, heightSample);
+      minimumHeight = Math.min(minimumHeight, heightSample);
+      let longitude = nativeRectangle.west + granularityX * col;
+      if (!isGeographic) {
+        longitude = longitude * oneOverGlobeSemimajorAxis;
+      } else {
+        longitude = toRadians(longitude);
+      }
+      let u = (longitude - geographicWest) / (geographicEast - geographicWest);
+      u = Math_default.clamp(u, 0, 1);
+      let index = row * width + col;
+      if (skirtHeight > 0) {
+        const isWestEdge = colIndex === startCol;
+        const isEastEdge = colIndex === endCol - 1;
+        const isEdge = isNorthEdge || isSouthEdge || isWestEdge || isEastEdge;
+        const isCorner = (isNorthEdge || isSouthEdge) && (isWestEdge || isEastEdge);
+        if (isCorner) {
+          continue;
+        } else if (isEdge) {
+          heightSample -= skirtHeight;
+          if (isWestEdge) {
+            index = gridVertexCount + (height - row - 1);
+            longitude -= skirtOffsetPercentage * rectangleWidth;
+          } else if (isSouthEdge) {
+            index = gridVertexCount + height + (width - col - 1);
+          } else if (isEastEdge) {
+            index = gridVertexCount + height + width + row;
+            longitude += skirtOffsetPercentage * rectangleWidth;
+          } else if (isNorthEdge) {
+            index = gridVertexCount + height + width + height + col;
+          }
+        }
+      }
+      const nX = cosLatitude * cos(longitude);
+      const nY = cosLatitude * sin(longitude);
+      const kX = radiiSquaredX * nX;
+      const kY = radiiSquaredY * nY;
+      const gamma = sqrt(kX * nX + kY * nY + kZ * nZ);
+      const oneOverGamma = 1 / gamma;
+      const rSurfaceX = kX * oneOverGamma;
+      const rSurfaceY = kY * oneOverGamma;
+      const rSurfaceZ = kZ * oneOverGamma;
+      const position = new Cartesian3_default();
+      position.x = rSurfaceX + nX * heightSample;
+      position.y = rSurfaceY + nY * heightSample;
+      position.z = rSurfaceZ + nZ * heightSample;
+      Matrix4_default.multiplyByPoint(toENU, position, cartesian3Scratch);
+      Cartesian3_default.minimumByComponent(cartesian3Scratch, minimum, minimum);
+      Cartesian3_default.maximumByComponent(cartesian3Scratch, maximum, maximum);
+      hMin = Math.min(hMin, heightSample);
+      positions[index] = position;
+      uvs[index] = new Cartesian2_default(u, v);
+      heights[index] = heightSample;
+      if (includeWebMercatorT) {
+        webMercatorTs[index] = webMercatorT;
+      }
+      if (includeGeodeticSurfaceNormals) {
+        geodeticSurfaceNormals[index] = ellipsoid.geodeticSurfaceNormal(
+          position
+        );
+      }
+    }
+  }
+  const boundingSphere3D = BoundingSphere_default.fromPoints(positions);
+  let orientedBoundingBox;
+  if (defined_default(rectangle)) {
+    orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
+      rectangle,
+      minimumHeight,
+      maximumHeight,
+      ellipsoid
+    );
+  }
+  let occludeePointInScaledSpace;
+  if (hasRelativeToCenter) {
+    const occluder = new EllipsoidalOccluder_default(ellipsoid);
+    occludeePointInScaledSpace = occluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
+      relativeToCenter,
+      positions,
+      minimumHeight
+    );
+  }
+  const aaBox = new AxisAlignedBoundingBox_default(minimum, maximum, relativeToCenter);
+  const encoding = new TerrainEncoding_default(
+    relativeToCenter,
+    aaBox,
+    hMin,
+    maximumHeight,
+    fromENU,
+    false,
+    includeWebMercatorT,
+    includeGeodeticSurfaceNormals,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const vertices = new Float32Array(vertexCount * encoding.stride);
+  let bufferIndex = 0;
+  for (let j = 0; j < vertexCount; ++j) {
+    bufferIndex = encoding.encode(
+      vertices,
+      bufferIndex,
+      positions[j],
+      uvs[j],
+      heights[j],
+      void 0,
+      webMercatorTs[j],
+      geodeticSurfaceNormals[j]
+    );
+  }
+  return {
+    vertices,
+    maximumHeight,
+    minimumHeight,
+    encoding,
+    boundingSphere3D,
+    orientedBoundingBox,
+    occludeePointInScaledSpace
+  };
+};
+var HeightmapTessellator_default = HeightmapTessellator;
+
+// packages/engine/Source/Workers/createVerticesFromHeightmap.js
+var import_lerc = __toESM(require_LercDecode(), 1);
+function createVerticesFromHeightmap(parameters, transferableObjects) {
+  if (parameters.encoding === HeightmapEncoding_default.LERC) {
+    let result;
+    try {
+      result = import_lerc.default.decode(parameters.heightmap);
+    } catch (error) {
+      throw new RuntimeError_default(error);
+    }
+    const lercStatistics = result.statistics[0];
+    if (lercStatistics.minValue === Number.MAX_VALUE) {
+      throw new RuntimeError_default("Invalid tile data");
+    }
+    parameters.heightmap = result.pixels[0];
+    parameters.width = result.width;
+    parameters.height = result.height;
+  }
+  parameters.ellipsoid = Ellipsoid_default.clone(parameters.ellipsoid);
+  parameters.rectangle = Rectangle_default.clone(parameters.rectangle);
+  const statistics = HeightmapTessellator_default.computeVertices(parameters);
+  const vertices = statistics.vertices;
+  transferableObjects.push(vertices.buffer);
+  return {
+    vertices: vertices.buffer,
+    numberOfAttributes: statistics.encoding.stride,
+    minimumHeight: statistics.minimumHeight,
+    maximumHeight: statistics.maximumHeight,
+    gridWidth: parameters.width,
+    gridHeight: parameters.height,
+    boundingSphere3D: statistics.boundingSphere3D,
+    orientedBoundingBox: statistics.orientedBoundingBox,
+    occludeePointInScaledSpace: statistics.occludeePointInScaledSpace,
+    encoding: statistics.encoding,
+    westIndicesSouthToNorth: statistics.westIndicesSouthToNorth,
+    southIndicesEastToWest: statistics.southIndicesEastToWest,
+    eastIndicesNorthToSouth: statistics.eastIndicesNorthToSouth,
+    northIndicesWestToEast: statistics.northIndicesWestToEast
+  };
+}
+var createVerticesFromHeightmap_default = createTaskProcessorWorker_default(createVerticesFromHeightmap);
+export {
+  createVerticesFromHeightmap_default as default
+};