molstar 3.2.0 → 3.4.0

package/lib/mol-gl/shader/postprocessing.frag.d.ts

@@ -1,7 +1,7 @@
 /**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
+export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform vec2 uOcclusionOffset;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords + uOcclusionOffset);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";

package/lib/mol-gl/shader/postprocessing.frag.js

@@ -1,8 +1,7 @@
 /**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export var postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
-//# sourceMappingURL=postprocessing.frag.js.map
+export var postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform vec2 uOcclusionOffset;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords + uOcclusionOffset);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";

package/lib/mol-gl/shader/quad.vert.js

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var quad_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nvoid main(void) {\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=quad.vert.js.map

package/lib/mol-gl/shader/smaa/blend.frag.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var blend_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tWeights;\nuniform sampler2D tColor;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[2];\n\nvec4 SMAANeighborhoodBlendingPS(vec2 texCoord, vec4 offset[2], sampler2D colorTex, sampler2D blendTex) {\n    // Fetch the blending weights for current pixel:\n    vec4 a;\n    a.xz = texture2D(blendTex, texCoord).xz;\n    a.y = texture2D(blendTex, offset[1].zw).g;\n    a.w = texture2D(blendTex, offset[1].xy).a;\n\n    // Is there any blending weight with a value greater than 0.0?\n    if (dot(a, vec4(1.0, 1.0, 1.0, 1.0)) < 1e-5) {\n        return texture2D(colorTex, texCoord, 0.0);\n    } else {\n        // Up to 4 lines can be crossing a pixel (one through each edge). We\n        // favor blending by choosing the line with the maximum weight for each\n        // direction:\n        vec2 offset;\n        offset.x = a.a > a.b ? a.a : -a.b; // left vs. right\n        offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs\n\n        // Then we go in the direction that has the maximum weight:\n        if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical\n            offset.y = 0.0;\n        } else {\n            offset.x = 0.0;\n        }\n\n        // Fetch the opposite color and lerp by hand:\n        vec4 C = texture2D(colorTex, texCoord, 0.0);\n        texCoord += sign(offset) * uTexSizeInv;\n        vec4 Cop = texture2D(colorTex, texCoord, 0.0);\n        float s = abs(offset.x) > abs(offset.y) ? abs(offset.x) : abs(offset.y);\n\n        // WebGL port note: Added gamma correction\n        C.xyz = pow(C.xyz, vec3(2.2));\n        Cop.xyz = pow(Cop.xyz, vec3(2.2));\n        vec4 mixed = mix(C, Cop, s);\n        mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));\n\n        return mixed;\n    }\n}\n\nvoid main() {\n    gl_FragColor = SMAANeighborhoodBlendingPS(vUv, vOffset, tColor, tWeights);\n}\n";
-//# sourceMappingURL=blend.frag.js.map

package/lib/mol-gl/shader/smaa/blend.vert.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var blend_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[2];\n\nvoid SMAANeighborhoodBlendingVS(vec2 texCoord) {\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAANeighborhoodBlendingVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=blend.vert.js.map

package/lib/mol-gl/shader/smaa/edges.frag.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var edges_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tColor;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\n\nvec4 SMAAColorEdgeDetectionPS(vec2 texcoord, vec4 offset[3], sampler2D colorTex) {\n    vec2 threshold = vec2(dEdgeThreshold, dEdgeThreshold);\n\n    // Calculate color deltas:\n    vec4 delta;\n    vec3 C = texture2D(colorTex, texcoord).rgb;\n\n    vec3 Cleft = texture2D(colorTex, offset[0].xy).rgb;\n    vec3 t = abs(C - Cleft);\n    delta.x = max(max(t.r, t.g), t.b);\n\n    vec3 Ctop = texture2D(colorTex, offset[0].zw).rgb;\n    t = abs(C - Ctop);\n    delta.y = max(max(t.r, t.g), t.b);\n\n    // We do the usual threshold:\n    vec2 edges = step(threshold, delta.xy);\n\n    // Then discard if there is no edge:\n    if (dot(edges, vec2(1.0, 1.0 )) == 0.0)\n        discard;\n\n    // Calculate right and bottom deltas:\n    vec3 Cright = texture2D(colorTex, offset[1].xy).rgb;\n    t = abs( C - Cright );\n    delta.z = max(max(t.r, t.g), t.b);\n\n    vec3 Cbottom  = texture2D(colorTex, offset[1].zw).rgb;\n    t = abs(C - Cbottom);\n    delta.w = max(max(t.r, t.g), t.b);\n\n    // Calculate the maximum delta in the direct neighborhood:\n    float maxDelta = max(max(max(delta.x, delta.y), delta.z), delta.w );\n\n    // Calculate left-left and top-top deltas:\n    vec3 Cleftleft  = texture2D(colorTex, offset[2].xy).rgb;\n    t = abs( C - Cleftleft );\n    delta.z = max(max(t.r, t.g), t.b);\n\n    vec3 Ctoptop = texture2D(colorTex, offset[2].zw).rgb;\n    t = abs(C - Ctoptop);\n    delta.w = max(max(t.r, t.g), t.b);\n\n    // Calculate the final maximum delta:\n    maxDelta = max(max(maxDelta, delta.z), delta.w);\n\n    // Local contrast adaptation in action:\n    edges.xy *= step(0.5 * maxDelta, delta.xy);\n\n    return vec4(edges, 0.0, 0.0);\n}\n\nvoid main() {\n    gl_FragColor = SMAAColorEdgeDetectionPS(vUv, vOffset, tColor);\n}\n";
-//# sourceMappingURL=edges.frag.js.map

package/lib/mol-gl/shader/smaa/edges.vert.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var edges_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\n\nvoid SMAAEdgeDetectionVS(vec2 texCoord) {\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component\n    vOffset[2] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-2.0, 0.0, 0.0, 2.0); // WebGL port note: Changed sign in W component\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAAEdgeDetectionVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=edges.vert.js.map

package/lib/mol-gl/shader/smaa/weights.frag.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var weights_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#define SMAASampleLevelZeroOffset(tex, coord, offset) texture2D(tex, coord + float(offset) * uTexSizeInv, 0.0)\n\n#define SMAA_AREATEX_MAX_DISTANCE 16\n#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))\n#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)\n\nuniform sampler2D tEdges;\nuniform sampler2D tArea;\nuniform sampler2D tSearch;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\nvarying vec2 vPixCoord;\n\n#if __VERSION__ == 100\n    vec2 round(vec2 x) {\n        return sign(x) * floor(abs(x) + 0.5);\n    }\n#endif\n\nfloat SMAASearchLength(sampler2D searchTex, vec2 e, float bias, float scale) {\n    // Not required if searchTex accesses are set to point:\n    // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);\n    // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +\n    //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;\n    e.r = bias + e.r * scale;\n    return 255.0 * texture2D(searchTex, e, 0.0).r;\n}\n\nfloat SMAASearchXLeft(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    /**\n     * @PSEUDO_GATHER4\n     * This texCoord has been offset by (-0.25, -0.125) in the vertex shader to\n     * sample between edge, thus fetching four edges in a row.\n     * Sampling with different offsets in each direction allows to disambiguate\n     * which edges are active from the four fetched ones.\n     */\n    vec2 e = vec2(0.0, 1.0);\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D( edgesTex, texCoord, 0.0).rg;\n        texCoord -= vec2(2.0, 0.0) * uTexSizeInv;\n        if (!(texCoord.x > end && e.g > 0.8281 && e.r == 0.0)) break;\n    }\n\n    // We correct the previous (-0.25, -0.125) offset we applied:\n    texCoord.x += 0.25 * uTexSizeInv.x;\n\n    // The searches are bias by 1, so adjust the coords accordingly:\n    texCoord.x += uTexSizeInv.x;\n\n    // Disambiguate the length added by the last step:\n    texCoord.x += 2.0 * uTexSizeInv.x; // Undo last step\n    texCoord.x -= uTexSizeInv.x * SMAASearchLength(searchTex, e, 0.0, 0.5);\n\n    return texCoord.x;\n}\n\nfloat SMAASearchXRight(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 0.0, 1.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord += vec2(2.0, 0.0) * uTexSizeInv;\n        if (!(texCoord.x < end && e.g > 0.8281 && e.r == 0.0)) break;\n    }\n\n    texCoord.x -= 0.25 * uTexSizeInv.x;\n    texCoord.x -= uTexSizeInv.x;\n    texCoord.x -= 2.0 * uTexSizeInv.x;\n    texCoord.x += uTexSizeInv.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );\n\n    return texCoord.x;\n}\n\nfloat SMAASearchYUp(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 1.0, 0.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord += vec2(0.0, 2.0) * uTexSizeInv; // WebGL port note: Changed sign\n        if (!(texCoord.y > end && e.r > 0.8281 && e.g == 0.0)) break;\n    }\n\n    texCoord.y -= 0.25 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= 2.0 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += uTexSizeInv.y * SMAASearchLength(searchTex, e.gr, 0.0, 0.5); // WebGL port note: Changed sign\n\n    return texCoord.y;\n}\n\nfloat SMAASearchYDown(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 1.0, 0.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord -= vec2( 0.0, 2.0 ) * uTexSizeInv; // WebGL port note: Changed sign\n        if (!(texCoord.y < end && e.r > 0.8281 && e.g == 0.0)) break;\n    }\n\n    texCoord.y += 0.25 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += 2.0 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= uTexSizeInv.y * SMAASearchLength(searchTex, e.gr, 0.5, 0.5); // WebGL port note: Changed sign\n\n    return texCoord.y;\n}\n\nvec2 SMAAArea(sampler2D areaTex, vec2 dist, float e1, float e2, float offset) {\n    // Rounding prevents precision errors of bilinear filtering:\n    vec2 texCoord = float(SMAA_AREATEX_MAX_DISTANCE) * round(4.0 * vec2(e1, e2)) + dist;\n\n    // We do a scale and bias for mapping to texel space:\n    texCoord = SMAA_AREATEX_PIXEL_SIZE * texCoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);\n\n    // Move to proper place, according to the subpixel offset:\n    texCoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;\n\n    return texture2D(areaTex, texCoord, 0.0).rg;\n}\n\nvec4 SMAABlendingWeightCalculationPS(vec2 texCoord, vec2 pixCoord, vec4 offset[3], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices) {\n    vec4 weights = vec4(0.0, 0.0, 0.0, 0.0);\n\n    vec2 e = texture2D(edgesTex, texCoord).rg;\n\n    if (e.g > 0.0) { // Edge at north\n        vec2 d;\n\n        // Find the distance to the left:\n        vec2 coords;\n        coords.x = SMAASearchXLeft(edgesTex, searchTex, offset[0].xy, offset[2].x );\n        coords.y = offset[1].y; // offset[1].y = texCoord.y - 0.25 * uTexSizeInv.y (@CROSSING_OFFSET)\n        d.x = coords.x;\n\n        // Now fetch the left crossing edges, two at a time using bilinear\n        // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to\n        // discern what value each edge has:\n        float e1 = texture2D(edgesTex, coords, 0.0).r;\n\n        // Find the distance to the right:\n        coords.x = SMAASearchXRight(edgesTex, searchTex, offset[0].zw, offset[2].y);\n        d.y = coords.x;\n\n        // We want the distances to be in pixel units (doing this here allow to\n        // better interleave arithmetic and memory accesses):\n        d = d / uTexSizeInv.x - pixCoord.x;\n\n        // SMAAArea below needs a sqrt, as the areas texture is compressed\n        // quadratically:\n        vec2 sqrt_d = sqrt(abs(d));\n\n        // Fetch the right crossing edges:\n        coords.y -= 1.0 * uTexSizeInv.y; // WebGL port note: Added\n        float e2 = SMAASampleLevelZeroOffset(edgesTex, coords, ivec2(1, 0)).r;\n\n        // Ok, we know how this pattern looks like, now it is time for getting\n        // the actual area:\n        weights.rg = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.y));\n    }\n\n    if (e.r > 0.0) { // Edge at west\n        vec2 d;\n\n        // Find the distance to the top:\n        vec2 coords;\n\n        coords.y = SMAASearchYUp(edgesTex, searchTex, offset[1].xy, offset[2].z );\n        coords.x = offset[0].x; // offset[1].x = texCoord.x - 0.25 * uTexSizeInv.x;\n        d.x = coords.y;\n\n        // Fetch the top crossing edges:\n        float e1 = texture2D(edgesTex, coords, 0.0).g;\n\n        // Find the distance to the bottom:\n        coords.y = SMAASearchYDown(edgesTex, searchTex, offset[1].zw, offset[2].w);\n        d.y = coords.y;\n\n        // We want the distances to be in pixel units:\n        d = d / uTexSizeInv.y - pixCoord.y;\n\n        // SMAAArea below needs a sqrt, as the areas texture is compressed\n        // quadratically:\n        vec2 sqrt_d = sqrt(abs(d));\n\n        // Fetch the bottom crossing edges:\n        coords.y -= 1.0 * uTexSizeInv.y; // WebGL port note: Added\n        float e2 = SMAASampleLevelZeroOffset(edgesTex, coords, ivec2(0, 1)).g;\n\n        // Get the area for this direction:\n        weights.ba = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.x));\n    }\n\n    return weights;\n}\n\nvoid main() {\n    gl_FragColor = SMAABlendingWeightCalculationPS(vUv, vPixCoord, vOffset, tEdges, tArea, tSearch, ivec4(0.0));\n}\n";
-//# sourceMappingURL=weights.frag.js.map

package/lib/mol-gl/shader/smaa/weights.vert.js

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var weights_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\nvarying vec2 vPixCoord;\n\nvoid SMAABlendingWeightCalculationVS(vec2 texCoord) {\n    vPixCoord = texCoord / uTexSizeInv;\n\n    // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-0.25, 0.125, 1.25, 0.125); // WebGL port note: Changed sign in Y and W components\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-0.125, 0.25, -0.125, -1.25); // WebGL port note: Changed sign in Y and W components\n\n    // And these for the searches, they indicate the ends of the loops:\n    vOffset[2] = vec4(vOffset[0].xz, vOffset[1].yw) + vec4(-2.0, 2.0, -2.0, 2.0) * uTexSizeInv.xxyy * float(dMaxSearchSteps);\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAABlendingWeightCalculationVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=weights.vert.js.map

package/lib/mol-gl/shader/spheres.frag.js

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var spheres_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\nuniform mat4 uInvView;\n\nvarying float vRadius;\nvarying float vRadiusSq;\nvarying vec3 vPoint;\nvarying vec3 vPointViewPosition;\n\nvec3 cameraPos;\nvec3 cameraNormal;\n\nbool Impostor(out vec3 cameraPos, out vec3 cameraNormal){\n    vec3 cameraSpherePos = -vPointViewPosition;\n    cameraSpherePos.z += vRadius;\n\n    vec3 rayOrigin = mix(vec3(0.0, 0.0, 0.0), vPoint, uIsOrtho);\n    vec3 rayDirection = mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);\n    vec3 cameraSphereDir = mix(cameraSpherePos, rayOrigin - cameraSpherePos, uIsOrtho);\n\n    float B = dot(rayDirection, cameraSphereDir);\n    float det = B * B + vRadiusSq - dot(cameraSphereDir, cameraSphereDir);\n\n    if (det < 0.0){\n        discard;\n        return false;\n    }\n\n    float sqrtDet = sqrt(det);\n    float posT = mix(B + sqrtDet, B + sqrtDet, uIsOrtho);\n    float negT = mix(B - sqrtDet, sqrtDet - B, uIsOrtho);\n\n    cameraPos = rayDirection * negT + rayOrigin;\n\n\n    if (calcDepth(cameraPos) <= 0.0) {\n        cameraPos = rayDirection * posT + rayOrigin;\n        interior = true;\n    } else {\n        interior = false;\n    }\n\n    cameraNormal = normalize(cameraPos - cameraSpherePos);\n    cameraNormal *= float(!interior) * 2.0 - 1.0;\n\n    return !interior;\n}\n\nvoid main(void){\n    #include clip_pixel\n\n    bool flag = Impostor(cameraPos, cameraNormal);\n    if (!uDoubleSided) {\n        if (interior) discard;\n    }\n\n    vec3 vViewPosition = cameraPos;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n    if (!flag && gl_FragDepthEXT >= 0.0) {\n        gl_FragDepthEXT = 0.0 + (0.0000001 / vRadius);\n    }\n\n    vec3 vModelPosition = (uInvView * vec4(vViewPosition, 1.0)).xyz;\n\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        vec3 normal = -cameraNormal;\n        #include apply_light_color\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=spheres.frag.js.map

package/lib/mol-gl/shader/spheres.vert.js

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var spheres_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform mat4 uModelView;\nuniform mat4 uInvProjection;\n\nattribute vec3 aPosition;\nattribute vec2 aMapping;\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nvarying float vRadius;\nvarying float vRadiusSq;\nvarying vec3 vPoint;\nvarying vec3 vPointViewPosition;\n\n#include matrix_scale\n\nconst mat4 D = mat4(\n    1.0, 0.0, 0.0, 0.0,\n    0.0, 1.0, 0.0, 0.0,\n    0.0, 0.0, 1.0, 0.0,\n    0.0, 0.0, 0.0, -1.0\n);\n\n/**\n * Compute point size and center using the technique described in:\n * \"GPU-Based Ray-Casting of Quadratic Surfaces\" http://dl.acm.org/citation.cfm?id=2386396\n * by Christian Sigg, Tim Weyrich, Mario Botsch, Markus Gross.\n */\nvoid quadraticProjection(const in float radius, const in vec3 position){\n    vec2 xbc, ybc;\n\n    mat4 T = mat4(\n        radius, 0.0, 0.0, 0.0,\n        0.0, radius, 0.0, 0.0,\n        0.0, 0.0, radius, 0.0,\n        position.x, position.y, position.z, 1.0\n    );\n\n    mat4 R = transpose4(uProjection * uModelView * aTransform * T);\n    float A = dot(R[3], D * R[3]);\n    float B = -2.0 * dot(R[0], D * R[3]);\n    float C = dot(R[0], D * R[0]);\n    xbc[0] = (-B - sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    xbc[1] = (-B + sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    float sx = abs(xbc[0] - xbc[1]) * 0.5;\n\n    A = dot(R[3], D * R[3]);\n    B = -2.0 * dot(R[1], D * R[3]);\n    C = dot(R[1], D * R[1]);\n    ybc[0] = (-B - sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    ybc[1] = (-B + sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    float sy = abs(ybc[0] - ybc[1]) * 0.5;\n\n    gl_Position.xy = vec2(0.5 * (xbc.x + xbc.y), 0.5 * (ybc.x + ybc.y));\n    gl_Position.xy -= aMapping * vec2(sx, sy);\n    gl_Position.xy *= gl_Position.w;\n}\n\n\nvoid main(void){\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_size\n\n    vRadius = size * matrixScale(uModelView);\n\n    vec4 position4 = vec4(aPosition, 1.0);\n    vec4 mvPosition = uModelView * aTransform * position4;\n    mvPosition.z -= vRadius; // avoid clipping, added again in fragment shader\n\n    gl_Position = uProjection * vec4(mvPosition.xyz, 1.0);\n    quadraticProjection(size, aPosition);\n\n    vRadiusSq = vRadius * vRadius;\n    vec4 vPoint4 = uInvProjection * gl_Position;\n    vPoint = vPoint4.xyz / vPoint4.w;\n    vPointViewPosition = -mvPosition.xyz / mvPosition.w;\n\n    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=spheres.vert.js.map

package/lib/mol-gl/shader/ssao-blur.frag.js

@@ -5,4 +5,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var ssaoBlur_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform float uKernel[dOcclusionKernelSize];\n\nuniform float uBlurDirectionX;\nuniform float uBlurDirectionY;\n\nuniform float uMaxPossibleViewZDiff;\n\nuniform float uNear;\nuniform float uFar;\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nbool outsideBounds(const in vec2 p) {\n    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n\n    vec2 packedDepth = texture2D(tSsaoDepth, coords).zw;\n\n    if (outsideBounds(coords)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);\n        return;\n    }\n\n    float selfDepth = unpackRGToUnitInterval(packedDepth);\n    // if background and if second pass\n    if (isBackground(selfDepth) && uBlurDirectionY != 0.0) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);\n        return;\n    }\n\n    float selfViewZ = getViewZ(selfDepth);\n\n    vec2 offset = vec2(uBlurDirectionX, uBlurDirectionY) / uTexSize;\n\n    float sum = 0.0;\n    float kernelSum = 0.0;\n    // only if kernelSize is odd\n    for (int i = -dOcclusionKernelSize / 2; i <= dOcclusionKernelSize / 2; i++) {\n        vec2 sampleCoords = coords + float(i) * offset;\n        if (outsideBounds(sampleCoords)) {\n            continue;\n        }\n\n        vec4 sampleSsaoDepth = texture2D(tSsaoDepth, sampleCoords);\n\n        float sampleDepth = unpackRGToUnitInterval(sampleSsaoDepth.zw);\n        if (isBackground(sampleDepth)) {\n            continue;\n        }\n\n        if (abs(float(i)) > 1.0) { // abs is not defined for int in webgl1\n            float sampleViewZ = getViewZ(sampleDepth);\n            if (abs(selfViewZ - sampleViewZ) > uMaxPossibleViewZDiff) {\n                continue;\n            }\n        }\n\n        float kernel = uKernel[int(abs(float(i)))]; // abs is not defined for int in webgl1\n        float sampleValue = unpackRGToUnitInterval(sampleSsaoDepth.xy);\n\n        sum += kernel * sampleValue;\n        kernelSum += kernel;\n    }\n\n    gl_FragColor = vec4(packUnitIntervalToRG(sum / kernelSum), packedDepth);\n}\n";
-//# sourceMappingURL=ssao-blur.frag.js.map

package/lib/mol-gl/shader/ssao.frag.js

@@ -5,4 +5,3 @@
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
 export var ssao_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#include common\n\nuniform sampler2D tDepth;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform vec3 uSamples[dNSamples];\n\nuniform mat4 uProjection;\nuniform mat4 uInvProjection;\n\nuniform float uRadius;\nuniform float uBias;\n\nfloat smootherstep(float edge0, float edge1, float x) {\n    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\nfloat noise(const in vec2 coords) {\n    float a = 12.9898;\n    float b = 78.233;\n    float c = 43758.5453;\n    float dt = dot(coords, vec2(a,b));\n    float sn = mod(dt, PI);\n    return abs(fract(sin(sn) * c)); // is abs necessary?\n}\n\nvec2 getNoiseVec2(const in vec2 coords) {\n    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nbool outsideBounds(const in vec2 p) {\n    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;\n}\n\nfloat getDepth(const in vec2 coords) {\n    return outsideBounds(coords) ? 1.0 : unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nvec3 normalFromDepth(const in float depth, const in float depth1, const in float depth2, vec2 offset1, vec2 offset2) {\n    vec3 p1 = vec3(offset1, depth1 - depth);\n    vec3 p2 = vec3(offset2, depth2 - depth);\n\n    vec3 normal = cross(p1, p2);\n    normal.z = -normal.z;\n\n    return normalize(normal);\n}\n\n// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]\nvoid main(void) {\n    vec2 invTexSize = 1.0 / uTexSize;\n    vec2 selfCoords = gl_FragCoord.xy * invTexSize;\n\n    float selfDepth = getDepth(selfCoords);\n    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);\n\n    if (isBackground(selfDepth)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(0.0), selfPackedDepth);\n        return;\n    }\n\n    vec2 offset1 = vec2(0.0, invTexSize.y);\n    vec2 offset2 = vec2(invTexSize.x, 0.0);\n\n    float selfDepth1 = getDepth(selfCoords + offset1);\n    float selfDepth2 = getDepth(selfCoords + offset2);\n\n    vec3 selfViewNormal = normalFromDepth(selfDepth, selfDepth1, selfDepth2, offset1, offset2);\n    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);\n\n    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));\n\n    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));\n    vec3 bitangent = cross(selfViewNormal, tangent);\n    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);\n\n    float occlusion = 0.0;\n    for(int i = 0; i < dNSamples; i++){\n        vec3 sampleViewPos = TBN * uSamples[i];\n        sampleViewPos = selfViewPos + sampleViewPos * uRadius;\n\n        vec4 offset = vec4(sampleViewPos, 1.0);\n        offset = uProjection * offset;\n        offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n        float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, getDepth(offset.xy)), uInvProjection).z;\n\n        occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));\n    }\n    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));\n\n    vec2 packedOcclusion = packUnitIntervalToRG(occlusion);\n\n    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);\n}\n";
-//# sourceMappingURL=ssao.frag.js.map

package/lib/mol-gl/shader/text.frag.js

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var text_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include common_clip\n\nuniform sampler2D tFont;\n\nuniform vec3 uBorderColor;\nuniform float uBorderWidth;\nuniform vec3 uBackgroundColor;\nuniform float uBackgroundOpacity;\n\nvarying vec2 vTexCoord;\n\nconst float smoothness = 32.0;\nconst float gamma = 2.2;\n\nvoid main2(){\n    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n}\n\nvoid main(){\n    #include clip_pixel\n\n    float fragmentDepth = gl_FragCoord.z;\n    bool interior = false;\n    #include assign_material_color\n\n    if (vTexCoord.x > 1.0) {\n        gl_FragColor = vec4(uBackgroundColor, uBackgroundOpacity * material.a);\n    } else {\n        // retrieve signed distance\n        float sdf = texture2D(tFont, vTexCoord).a + uBorderWidth;\n\n        // perform adaptive anti-aliasing of the edges\n        float w = clamp(smoothness * (abs(dFdx(vTexCoord.x)) + abs(dFdy(vTexCoord.y))), 0.0, 0.5);\n        float a = smoothstep(0.5 - w, 0.5 + w, sdf);\n\n        // gamma correction for linear attenuation\n        a = pow(a, 1.0 / gamma);\n\n        if (a < 0.5) discard;\n        material.a *= a;\n\n        // add border\n        float t = 0.5 + uBorderWidth;\n        if (uBorderWidth > 0.0 && sdf < t) {\n            material.xyz = mix(uBorderColor, material.xyz, smoothstep(t - w, t, sdf));\n        }\n\n        gl_FragColor = material;\n    }\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=text.frag.js.map

package/lib/mol-gl/shader/text.vert.js

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var text_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform mat4 uModelView;\n\nattribute vec3 aPosition;\nattribute vec2 aMapping;\nattribute float aDepth;\nattribute vec2 aTexCoord;\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nuniform float uOffsetX;\nuniform float uOffsetY;\nuniform float uOffsetZ;\n\n// uniform bool ortho;\nuniform float uPixelRatio;\nuniform vec4 uViewport;\n\nvarying vec2 vTexCoord;\n\n#include matrix_scale\n\nvoid main(void){\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_size\n\n    vTexCoord = aTexCoord;\n\n    float scale = matrixScale(uModelView);\n\n    float offsetX = uOffsetX * scale;\n    float offsetY = uOffsetY * scale;\n    float offsetZ = (uOffsetZ + aDepth * 0.95) * scale;\n\n    vec4 position4 = vec4(aPosition, 1.0);\n    vec4 mvPosition = uModelView * aTransform * position4;\n\n    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader\n\n    // TODO\n    // #ifdef FIXED_SIZE\n    //     if (ortho) {\n    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -uCameraPosition.z) * 0.1;\n    //     } else {\n    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 0.1;\n    //     }\n    // #endif\n\n    vec4 mvCorner = vec4(mvPosition.xyz, 1.0);\n\n    if (vTexCoord.x == 10.0) { // indicates background plane\n        // move a bit to the back, taking distance to camera into account to avoid z-fighting\n        offsetZ -= 0.001 * distance(uCameraPosition, (uProjection * mvCorner).xyz);\n    }\n\n    mvCorner.xy += aMapping * size * scale;\n    mvCorner.x += offsetX;\n    mvCorner.y += offsetY;\n\n    // TODO\n    // if(ortho){\n    //     mvCorner.xyz += normalize(-uCameraPosition) * offsetZ;\n    // } else {\n    //     mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;\n    // }\n    mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;\n\n    gl_Position = uProjection * mvCorner;\n\n    vViewPosition = -mvCorner.xyz;\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=text.vert.js.map

package/lib/mol-gl/shader/util/grid3d-template.frag.js

@@ -4,4 +4,3 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 export var grid3dTemplate_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform vec2 uQuadShift;\nuniform vec3 uDimensions;\nuniform vec3 uMin;\nuniform vec3 uDelta;\nuniform bool uLittleEndian;\nuniform float uWidth;\n\n#ifdef CUMULATIVE\n    uniform sampler2D tCumulativeSum;\n#endif\n\n{UNIFORMS}\n\n{UTILS}\n\n#include float_to_rgba\n#ifdef CUMULATIVE\n    #include rgba_to_float\n#endif\n\nfloat intDiv(float a, float b) { return float(int(a) / int(b)); }\nfloat intMod(float a, float b) { return a - b * float(int(a) / int(b)); }\n\nvoid main(void) {\n    float offset = floor(gl_FragCoord.x) + floor(gl_FragCoord.y) * uWidth;\n\n    // axis order fast to slow Z, Y, X\n    // TODO: support arbitrary axis orders?\n    float k = intMod(offset, uDimensions.z), kk = intDiv(offset, uDimensions.z);\n    float j = intMod(kk, uDimensions.y);\n    float i = intDiv(kk, uDimensions.y);\n\n    vec3 xyz = uMin + uDelta * vec3(i, j, k);\n\n    {MAIN}\n\n    #ifdef CUMULATIVE\n        float current = rgbaToFloat(texture2D(tCumulativeSum, gl_FragCoord.xy / vec2(uWidth, uWidth)), uLittleEndian);\n    #endif\n    gl_FragColor = floatToRgba({RETURN}, uLittleEndian);\n}\n";
-//# sourceMappingURL=grid3d-template.frag.js.map

package/lib/mol-gl/shader-code.js

@@ -163,6 +163,7 @@ import { directVolume_frag } from './shader/direct-volume.frag';
 export var DirectVolumeShaderCode = ShaderCode('direct-volume', directVolume_vert, directVolume_frag, { fragDepth: 'optional', drawBuffers: 'optional' }, {}, ignoreDefine);
 import { image_vert } from './shader/image.vert';
 import { image_frag } from './shader/image.frag';
+import { assertUnreachable } from '../mol-util/type-helpers';
 export var ImageShaderCode = ShaderCode('image', image_vert, image_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
 function getDefinesCode(defines, ignore) {
     var _a;
@@ -187,7 +188,7 @@ function getDefinesCode(defines, ignore) {
                     lines.push("#define ".concat(name_1));
             }
             else {
-                throw new Error('unknown define type');
+                assertUnreachable(v);
             }
         }
     }
@@ -273,4 +274,3 @@ export function addShaderDefines(gl, extensions, defines, shaders) {
         outTypes: shaders.outTypes
     };
 }
-//# sourceMappingURL=shader-code.js.map

package/lib/mol-gl/webgl/buffer.js

@@ -5,6 +5,7 @@
  */
 import { __assign } from "tslib";
 import { idFactory } from '../../mol-util/id-factory';
+import { assertUnreachable } from '../../mol-util/type-helpers';
 var getNextBufferId = idFactory();
 export function getUsageHint(gl, usageHint) {
     switch (usageHint) {
@@ -46,9 +47,7 @@ function dataTypeFromArray(gl, array) {
     else if (array instanceof Float32Array) {
         return gl.FLOAT;
     }
-    else {
-        throw new Error('Should nevver happen');
-    }
+    assertUnreachable(array);
 }
 export function getBufferType(gl, bufferType) {
     switch (bufferType) {
@@ -167,4 +166,3 @@ export function createElementsBuffer(gl, array, usageHint) {
             gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer.getBuffer());
         } });
 }
-//# sourceMappingURL=buffer.js.map

package/lib/mol-gl/webgl/compat.js

@@ -318,4 +318,3 @@ export function testColorBuffer(gl, type) {
     }
     return true;
 }
-//# sourceMappingURL=compat.js.map

package/lib/mol-gl/webgl/context.js

@@ -298,4 +298,3 @@ export function createContext(gl, props) {
         }
     };
 }
-//# sourceMappingURL=context.js.map

package/lib/mol-gl/webgl/extensions.js

@@ -95,4 +95,3 @@ export function createExtensions(gl) {
         sRGB: sRGB,
     };
 }
-//# sourceMappingURL=extensions.js.map

package/lib/mol-gl/webgl/framebuffer.js

@@ -62,4 +62,3 @@ export function createNullFramebuffer() {
         destroy: function () { }
     };
 }
-//# sourceMappingURL=framebuffer.js.map

package/lib/mol-gl/webgl/program.js

@@ -188,4 +188,3 @@ export function createProgram(gl, state, extensions, getShader, props) {
         }
     };
 }
-//# sourceMappingURL=program.js.map

package/lib/mol-gl/webgl/render-item.js

@@ -325,4 +325,3 @@ export function createRenderItem(ctx, drawMode, shaderCode, schema, values, mate
         }
     };
 }
-//# sourceMappingURL=render-item.js.map

package/lib/mol-gl/webgl/render-target.js

@@ -81,4 +81,3 @@ export function createNullRenderTarget(gl) {
         destroy: function () { }
     };
 }
-//# sourceMappingURL=render-target.js.map

package/lib/mol-gl/webgl/renderbuffer.js

@@ -74,4 +74,3 @@ export function createRenderbuffer(gl, format, attachment, _width, _height) {
         }
     };
 }
-//# sourceMappingURL=renderbuffer.js.map

package/lib/mol-gl/webgl/resources.js

@@ -121,4 +121,3 @@ export function createResources(gl, state, stats, extensions) {
         }
     };
 }
-//# sourceMappingURL=resources.js.map

package/lib/mol-gl/webgl/shader.js

@@ -42,4 +42,3 @@ export function createShader(gl, props) {
         }
     };
 }
-//# sourceMappingURL=shader.js.map

package/lib/mol-gl/webgl/state.js

@@ -140,4 +140,3 @@ export function createState(gl) {
         }
     };
 }
-//# sourceMappingURL=state.js.map

package/lib/mol-gl/webgl/texture.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/mol-gl/webgl/texture.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -194,6 +194,9 @@ export function createTexture(gl, extensions, kind, _format, _type, _filter) {
     var loadedData;
     var destroyed = false;
     function define(_width, _height, _depth) {
+        if (_width === 0 || _height === 0 || (isWebGL2(gl) && target === gl.TEXTURE_3D && _depth === 0)) {
+            throw new Error('empty textures are not allowed');
+        }
         if (width === _width && height === _height && depth === (_depth || 0))
             return;
         width = _width, height = _height, depth = _depth || 0;
@@ -208,14 +211,19 @@ export function createTexture(gl, extensions, kind, _format, _type, _filter) {
             throw new Error('unknown texture target');
         }
     }
+    define(1, 1, isWebGL2(gl) && target === gl.TEXTURE_3D ? 1 : 0);
     function load(data, sub) {
         if (sub === void 0) { sub = false; }
+        if (data.width === 0 || data.height === 0 || (!isImage(data) && isWebGL2(gl) && isTexture3d(data, target, gl) && data.depth === 0)) {
+            throw new Error('empty textures are not allowed');
+        }
         gl.bindTexture(target, texture);
         // unpack alignment of 1 since we use textures only for data
         gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
         gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
         gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
         if (isImage(data)) {
+            width = data.width, height = data.height;
             gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
             gl.bindTexture(gl.TEXTURE_2D, texture);
             gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, format, type, data);
@@ -382,4 +390,3 @@ export function createNullTexture(gl) {
         destroy: function () { },
     };
 }
-//# sourceMappingURL=texture.js.map

package/lib/mol-gl/webgl/uniform.js

@@ -101,4 +101,3 @@ export function cloneUniformValues(uniformValues) {
     });
     return clonedValues;
 }
-//# sourceMappingURL=uniform.js.map

package/lib/mol-gl/webgl/vertex-array.js

@@ -62,4 +62,3 @@ export function createVertexArray(gl, extensions, program, attributeBuffers, ele
         }
     };
 }
-//# sourceMappingURL=vertex-array.js.map

package/lib/mol-io/common/ascii.js

@@ -8,4 +8,3 @@ export function asciiWrite(data, str) {
         data[i] = str.charCodeAt(i);
     }
 }
-//# sourceMappingURL=ascii.js.map

package/lib/mol-io/common/binary-cif/array-encoder.js

@@ -390,4 +390,3 @@ export var ArrayEncoding;
     }
     ArrayEncoding.stringArray = stringArray;
 })(ArrayEncoding || (ArrayEncoding = {}));
-//# sourceMappingURL=array-encoder.js.map

package/lib/mol-io/common/binary-cif/classifier.js

@@ -6,6 +6,7 @@
 import { __assign } from "tslib";
 import { ArrayEncoding as E } from './array-encoder';
 import { getArrayDigitCount } from '../../../mol-util/number';
+import { assertUnreachable } from '../../../mol-util/type-helpers';
 export function classifyIntArray(xs) {
     return IntClassifier.classify(xs);
 }
@@ -119,8 +120,8 @@ var IntClassifier;
             case 'rle': return E.by(E.runLength).and(E.integerPacking);
             case 'delta': return E.by(E.delta).and(E.integerPacking);
             case 'delta-rle': return E.by(E.delta).and(E.runLength).and(E.integerPacking);
+            default: assertUnreachable(size);
         }
-        throw new Error('should not happen :)');
     }
     IntClassifier.classify = classify;
 })(IntClassifier || (IntClassifier = {}));
@@ -154,8 +155,8 @@ var FloatClassifier;
             case 'rle': return fp.and(E.runLength).and(E.integerPacking);
             case 'delta': return fp.and(E.delta).and(E.integerPacking);
             case 'delta-rle': return fp.and(E.delta).and(E.runLength).and(E.integerPacking);
+            default: assertUnreachable(size);
         }
-        throw new Error('should not happen :)');
     }
     FloatClassifier.classify = classify;
     function getMultiplier(mantissaDigits) {
@@ -165,4 +166,3 @@ var FloatClassifier;
         return m;
     }
 })(FloatClassifier || (FloatClassifier = {}));
-//# sourceMappingURL=classifier.js.map

package/lib/mol-io/common/binary-cif/decoder.js

@@ -5,6 +5,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 import { IsNativeEndianLittle, flipByteOrder } from '../binary';
+import { assertUnreachable } from '../../../mol-util/type-helpers';
 /**
  * Fixed point, delta, RLE, integer packing adopted from https://github.com/rcsb/mmtf-javascript/
  * by Alexander Rose <alexander.rose@weirdbyte.de>, MIT License, Copyright (c) 2016
@@ -28,7 +29,7 @@ function decodeStep(data, encoding) {
                 case 6 /* Uint32 */: return uint32(data);
                 case 32 /* Float32 */: return float32(data);
                 case 33 /* Float64 */: return float64(data);
-                default: throw new Error('Unsupported ByteArray type.');
+                default: assertUnreachable(encoding.type);
             }
         }
         case 'FixedPoint': return fixedPoint(data, encoding);
@@ -47,14 +48,14 @@ function getIntArray(type, size) {
         case 4 /* Uint8 */: return new Uint8Array(size);
         case 5 /* Uint16 */: return new Uint16Array(size);
         case 6 /* Uint32 */: return new Uint32Array(size);
-        default: throw new Error('Unsupported integer data type.');
+        default: assertUnreachable(type);
     }
 }
 function getFloatArray(type, size) {
     switch (type) {
         case 32 /* Float32 */: return new Float32Array(size);
         case 33 /* Float64 */: return new Float64Array(size);
-        default: throw new Error('Unsupported floating data type.');
+        default: assertUnreachable(type);
     }
 }
 function int8(data) { return new Int8Array(data.buffer, data.byteOffset); }
@@ -173,4 +174,3 @@ function stringArray(data, encoding) {
     }
     return result;
 }
-//# sourceMappingURL=decoder.js.map

package/lib/mol-io/common/binary-cif/encoding.js

@@ -41,4 +41,3 @@ export var Encoding;
     }
     Encoding.isSignedIntegerDataType = isSignedIntegerDataType;
 })(Encoding || (Encoding = {}));
-//# sourceMappingURL=encoding.js.map

package/lib/mol-io/common/binary-cif.js

@@ -7,4 +7,3 @@ export { decode } from './binary-cif/decoder';
 export * from './binary-cif/encoding';
 export * from './binary-cif/array-encoder';
 export * from './binary-cif/classifier';
-//# sourceMappingURL=binary-cif.js.map

package/lib/mol-io/common/binary.js

@@ -28,4 +28,3 @@ export function uint8ToString(array) {
         return String.fromCharCode.apply(null, array);
     }
 }
-//# sourceMappingURL=binary.js.map

package/lib/mol-io/common/file-handle.js

@@ -49,4 +49,3 @@ export var FileHandle;
     }
     FileHandle.fromBuffer = fromBuffer;
 })(FileHandle || (FileHandle = {}));
-//# sourceMappingURL=file-handle.js.map