molstar 3.8.2 → 3.9.0

package/lib/mol-gl/webgl/compat.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>
  */
@@ -93,4 +93,37 @@ export interface COMPAT_sRGB {
     readonly SRGB: number;
 }
 export declare function getSRGB(gl: GLRenderingContext): COMPAT_sRGB | null;
+export interface COMPAT_disjoint_timer_query {
+    /** A GLint indicating the number of bits used to hold the query result for the given target. */
+    QUERY_COUNTER_BITS: number;
+    /** A WebGLQuery object, which is the currently active query for the given target. */
+    CURRENT_QUERY: number;
+    /** A GLuint64EXT containing the query result. */
+    QUERY_RESULT: number;
+    /** A GLboolean indicating whether or not a query result is available. */
+    QUERY_RESULT_AVAILABLE: number;
+    /** Elapsed time (in nanoseconds). */
+    TIME_ELAPSED: number;
+    /** The current time. */
+    TIMESTAMP: number;
+    /** A GLboolean indicating whether or not the GPU performed any disjoint operation. */
+    GPU_DISJOINT: number;
+    /** Creates a new WebGLTimerQueryEXT. */
+    createQuery: () => WebGLQuery;
+    /** Deletes a given WebGLTimerQueryEXT. */
+    deleteQuery: (query: WebGLQuery) => void;
+    /** Returns true if a given object is a valid WebGLTimerQueryEXT. */
+    isQuery: (query: WebGLQuery) => boolean;
+    /** The timer starts when all commands prior to beginQueryEXT have been fully executed. */
+    beginQuery: (target: number, query: WebGLQuery) => void;
+    /** The timer stops when all commands prior to endQueryEXT have been fully executed. */
+    endQuery: (target: number) => void;
+    /** Records the current time into the corresponding query object. */
+    queryCounter: (query: WebGLQuery, target: number) => void;
+    /** Returns information about a query target. */
+    getQuery: (target: number, pname: number) => WebGLQuery | number;
+    /** Return the state of a query object. */
+    getQueryParameter: (query: WebGLQuery, pname: number) => number | boolean;
+}
+export declare function getDisjointTimerQuery(gl: GLRenderingContext): COMPAT_disjoint_timer_query | null;
 export declare function testColorBuffer(gl: GLRenderingContext, type: number): boolean;

package/lib/mol-gl/webgl/compat.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>
  */
@@ -231,6 +231,53 @@ export function getSRGB(gl) {
         };
     }
 }
+export function getDisjointTimerQuery(gl) {
+    if (isWebGL2(gl)) {
+        // Firefox has EXT_disjoint_timer_query in webgl2
+        var ext = gl.getExtension('EXT_disjoint_timer_query_webgl2') || gl.getExtension('EXT_disjoint_timer_query');
+        if (ext === null)
+            return null;
+        return {
+            QUERY_COUNTER_BITS: ext.QUERY_COUNTER_BITS_EXT,
+            CURRENT_QUERY: gl.CURRENT_QUERY,
+            QUERY_RESULT: gl.QUERY_RESULT,
+            QUERY_RESULT_AVAILABLE: gl.QUERY_RESULT_AVAILABLE,
+            TIME_ELAPSED: ext.TIME_ELAPSED_EXT,
+            TIMESTAMP: ext.TIMESTAMP_EXT,
+            GPU_DISJOINT: ext.GPU_DISJOINT_EXT,
+            createQuery: gl.createQuery.bind(gl),
+            deleteQuery: gl.deleteQuery.bind(gl),
+            isQuery: gl.isQuery.bind(gl),
+            beginQuery: gl.beginQuery.bind(gl),
+            endQuery: gl.endQuery.bind(gl),
+            queryCounter: ext.queryCounterEXT.bind(ext),
+            getQuery: gl.getQuery.bind(gl),
+            getQueryParameter: gl.getQueryParameter.bind(gl),
+        };
+    }
+    else {
+        var ext = gl.getExtension('EXT_disjoint_timer_query');
+        if (ext === null)
+            return null;
+        return {
+            QUERY_COUNTER_BITS: ext.QUERY_COUNTER_BITS_EXT,
+            CURRENT_QUERY: ext.CURRENT_QUERY_EXT,
+            QUERY_RESULT: ext.QUERY_RESULT_EXT,
+            QUERY_RESULT_AVAILABLE: ext.QUERY_RESULT_AVAILABLE_EXT,
+            TIME_ELAPSED: ext.TIME_ELAPSED_EXT,
+            TIMESTAMP: ext.TIMESTAMP_EXT,
+            GPU_DISJOINT: ext.GPU_DISJOINT_EXT,
+            createQuery: ext.createQueryEXT.bind(ext),
+            deleteQuery: ext.deleteQueryEXT.bind(ext),
+            isQuery: ext.isQueryEXT.bind(ext),
+            beginQuery: ext.beginQueryEXT.bind(ext),
+            endQuery: ext.endQueryEXT.bind(ext),
+            queryCounter: ext.queryCounterEXT.bind(ext),
+            getQuery: ext.getQueryEXT.bind(ext),
+            getQueryParameter: ext.getQueryObjectEXT.bind(ext),
+        };
+    }
+}
 //
 var TextureTestVertShader = "\nattribute vec4 aPosition;\n\nvoid main() {\n    gl_Position = aPosition;\n}";
 var TextureTestFragShader = "\nprecision mediump float;\nuniform vec4 uColor;\nuniform sampler2D uTexture;\n\nvoid main() {\n    gl_FragColor = texture2D(uTexture, vec2(0.5, 0.5)) * uColor;\n}";

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

@@ -14,6 +14,7 @@ import { BehaviorSubject } from 'rxjs';
 import { now } from '../../mol-util/now';
 import { Texture, TextureFilter } from './texture';
 import { ComputeRenderable } from '../renderable';
+import { WebGLTimer } from './timer';
 export declare function getGLContext(canvas: HTMLCanvasElement, attribs?: WebGLContextAttributes & {
     preferWebGl1?: boolean;
 }): GLRenderingContext | null;
@@ -45,6 +46,7 @@ export interface WebGLContext {
     readonly state: WebGLState;
     readonly stats: WebGLStats;
     readonly resources: WebGLResources;
+    readonly timer: WebGLTimer;
     readonly maxTextureSize: number;
     readonly max3dTextureSize: number;
     readonly maxRenderbufferSize: number;

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

@@ -15,6 +15,7 @@ import { createResources } from './resources';
 import { createRenderTarget } from './render-target';
 import { BehaviorSubject } from 'rxjs';
 import { now } from '../../mol-util/now';
+import { createTimer } from './timer';
 export function getGLContext(canvas, attribs) {
     function get(id) {
         try {
@@ -169,6 +170,7 @@ export function createContext(gl, props) {
     var state = createState(gl);
     var stats = createStats();
     var resources = createResources(gl, state, stats, extensions);
+    var timer = createTimer(gl, extensions);
     var parameters = {
         maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
         max3dTextureSize: isWebGL2(gl) ? gl.getParameter(gl.MAX_3D_TEXTURE_SIZE) : 0,
@@ -233,6 +235,7 @@ export function createContext(gl, props) {
         state: state,
         stats: stats,
         resources: resources,
+        timer: timer,
         get maxTextureSize() { return parameters.maxTextureSize; },
         get max3dTextureSize() { return parameters.max3dTextureSize; },
         get maxRenderbufferSize() { return parameters.maxRenderbufferSize; },

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

@@ -1,9 +1,9 @@
 /**
- * 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>
  */
-import { GLRenderingContext, COMPAT_instanced_arrays, COMPAT_standard_derivatives, COMPAT_vertex_array_object, COMPAT_element_index_uint, COMPAT_texture_float, COMPAT_texture_float_linear, COMPAT_blend_minmax, COMPAT_frag_depth, COMPAT_color_buffer_float, COMPAT_draw_buffers, COMPAT_shader_texture_lod, COMPAT_depth_texture, COMPAT_sRGB, COMPAT_texture_half_float, COMPAT_texture_half_float_linear, COMPAT_color_buffer_half_float } from './compat';
+import { GLRenderingContext, COMPAT_instanced_arrays, COMPAT_standard_derivatives, COMPAT_vertex_array_object, COMPAT_element_index_uint, COMPAT_texture_float, COMPAT_texture_float_linear, COMPAT_blend_minmax, COMPAT_frag_depth, COMPAT_color_buffer_float, COMPAT_draw_buffers, COMPAT_shader_texture_lod, COMPAT_depth_texture, COMPAT_sRGB, COMPAT_texture_half_float, COMPAT_texture_half_float_linear, COMPAT_color_buffer_half_float, COMPAT_disjoint_timer_query } from './compat';
 export declare type WebGLExtensions = {
     instancedArrays: COMPAT_instanced_arrays;
     elementIndexUint: COMPAT_element_index_uint;
@@ -21,5 +21,6 @@ export declare type WebGLExtensions = {
     drawBuffers: COMPAT_draw_buffers | null;
     shaderTextureLod: COMPAT_shader_texture_lod | null;
     sRGB: COMPAT_sRGB | null;
+    disjointTimerQuery: COMPAT_disjoint_timer_query | null;
 };
 export declare function createExtensions(gl: GLRenderingContext): WebGLExtensions;

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

@@ -1,9 +1,9 @@
 /**
- * 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>
  */
-import { getInstancedArrays, getStandardDerivatives, getElementIndexUint, getTextureFloat, getTextureFloatLinear, getBlendMinMax, getFragDepth, getColorBufferFloat, getDrawBuffers, getShaderTextureLod, getDepthTexture, getSRGB, getTextureHalfFloat, getTextureHalfFloatLinear, getColorBufferHalfFloat, getVertexArrayObject } from './compat';
+import { getInstancedArrays, getStandardDerivatives, getElementIndexUint, getTextureFloat, getTextureFloatLinear, getBlendMinMax, getFragDepth, getColorBufferFloat, getDrawBuffers, getShaderTextureLod, getDepthTexture, getSRGB, getTextureHalfFloat, getTextureHalfFloatLinear, getColorBufferHalfFloat, getVertexArrayObject, getDisjointTimerQuery } from './compat';
 import { isDebugMode } from '../../mol-util/debug';
 export function createExtensions(gl) {
     var instancedArrays = getInstancedArrays(gl);
@@ -76,6 +76,10 @@ export function createExtensions(gl) {
     if (isDebugMode && sRGB === null) {
         console.log('Could not find support for "sRGB"');
     }
+    var disjointTimerQuery = getDisjointTimerQuery(gl);
+    if (isDebugMode && disjointTimerQuery === null) {
+        console.log('Could not find support for "disjoint_timer_query"');
+    }
     return {
         instancedArrays: instancedArrays,
         standardDerivatives: standardDerivatives,
@@ -93,5 +97,6 @@ export function createExtensions(gl) {
         drawBuffers: drawBuffers,
         shaderTextureLod: shaderTextureLod,
         sRGB: sRGB,
+        disjointTimerQuery: disjointTimerQuery,
     };
 }

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

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { GLRenderingContext } from './compat';
+import { WebGLExtensions } from './extensions';
+export declare type TimerResult = {
+    readonly label: string;
+    readonly timeElapsed: number;
+    readonly children: TimerResult[];
+};
+export declare type WebGLTimer = {
+    /** Check with GPU for finished timers. */
+    resolve: () => TimerResult[];
+    mark: (label: string) => void;
+    markEnd: (label: string) => void;
+    clear: () => void;
+    destroy: () => void;
+};
+export declare function createTimer(gl: GLRenderingContext, extensions: WebGLExtensions): WebGLTimer;
+export declare function printTimerResults(results: TimerResult[]): void[];

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

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+function getQuery(extensions) {
+    return extensions.disjointTimerQuery ? extensions.disjointTimerQuery.createQuery() : null;
+}
+export function createTimer(gl, extensions) {
+    var dtq = extensions.disjointTimerQuery;
+    var queries = new Map();
+    var pending = new Map();
+    var stack = [];
+    var measures = [];
+    var current = null;
+    var clear = function () {
+        if (!dtq)
+            return;
+        queries.forEach(function (_, query) {
+            dtq.deleteQuery(query);
+        });
+        pending.clear();
+        measures = [];
+        current = null;
+    };
+    var add = function () {
+        if (!dtq)
+            return;
+        var query = getQuery(extensions);
+        if (!query)
+            return;
+        dtq.beginQuery(dtq.TIME_ELAPSED, query);
+        pending.forEach(function (measure, _) {
+            measure.queries.push(query);
+        });
+        queries.set(query, { refCount: pending.size });
+        current = query;
+    };
+    return {
+        resolve: function () {
+            var results = [];
+            if (!dtq || !measures.length)
+                return results;
+            // console.log('resolve');
+            queries.forEach(function (result, query) {
+                if (result.timeElapsed !== undefined)
+                    return;
+                var available = dtq.getQueryParameter(query, dtq.QUERY_RESULT_AVAILABLE);
+                var disjoint = gl.getParameter(dtq.GPU_DISJOINT);
+                if (available && !disjoint) {
+                    var timeElapsed = dtq.getQueryParameter(query, dtq.QUERY_RESULT);
+                    result.timeElapsed = timeElapsed;
+                    // console.log('timeElapsed', result.timeElapsed);
+                }
+                if (available || disjoint) {
+                    dtq.deleteQuery(query);
+                }
+            });
+            var unresolved = [];
+            var _loop_1 = function (measure) {
+                if (measure.queries.every(function (q) { var _a; return ((_a = queries.get(q)) === null || _a === void 0 ? void 0 : _a.timeElapsed) !== undefined; })) {
+                    var timeElapsed = 0;
+                    for (var _a = 0, _b = measure.queries; _a < _b.length; _a++) {
+                        var query = _b[_a];
+                        var result = queries.get(query);
+                        timeElapsed += result.timeElapsed;
+                        result.refCount -= 1;
+                    }
+                    measure.timeElapsed = timeElapsed;
+                    if (measure.root) {
+                        var children = [];
+                        var add_1 = function (measures, children) {
+                            for (var _i = 0, measures_2 = measures; _i < measures_2.length; _i++) {
+                                var measure_1 = measures_2[_i];
+                                var result = {
+                                    label: measure_1.label,
+                                    timeElapsed: measure_1.timeElapsed,
+                                    children: []
+                                };
+                                children.push(result);
+                                add_1(measure_1.children, result.children);
+                            }
+                        };
+                        add_1(measure.children, children);
+                        results.push({ label: measure.label, timeElapsed: timeElapsed, children: children });
+                    }
+                }
+                else {
+                    unresolved.push(measure);
+                }
+            };
+            for (var _i = 0, measures_1 = measures; _i < measures_1.length; _i++) {
+                var measure = measures_1[_i];
+                _loop_1(measure);
+            }
+            measures = unresolved;
+            queries.forEach(function (result, query) {
+                if (result.refCount === 0) {
+                    queries.delete(query);
+                }
+            });
+            return results;
+        },
+        mark: function (label) {
+            if (!dtq)
+                return;
+            if (pending.has(label)) {
+                throw new Error("Timer mark for '".concat(label, "' already exists"));
+            }
+            if (current !== null) {
+                dtq.endQuery(dtq.TIME_ELAPSED);
+            }
+            var measure = { label: label, queries: [], children: [], root: current === null };
+            pending.set(label, measure);
+            if (stack.length) {
+                stack[stack.length - 1].children.push(measure);
+            }
+            stack.push(measure);
+            add();
+        },
+        markEnd: function (label) {
+            var _a;
+            if (!dtq)
+                return;
+            var measure = pending.get(label);
+            if (!measure) {
+                throw new Error("Timer mark for '".concat(label, "' does not exist"));
+            }
+            if (((_a = stack.pop()) === null || _a === void 0 ? void 0 : _a.label) !== label) {
+                throw new Error("Timer mark for '".concat(label, "' has pending nested mark"));
+            }
+            dtq.endQuery(dtq.TIME_ELAPSED);
+            pending.delete(label);
+            measures.push(measure);
+            if (pending.size > 0) {
+                add();
+            }
+            else {
+                current = null;
+            }
+        },
+        clear: clear,
+        destroy: function () {
+            clear();
+        }
+    };
+}
+function formatTimerResult(result) {
+    var timeElapsed = result.timeElapsed / 1000 / 1000;
+    return "".concat(result.label, " ").concat(timeElapsed.toFixed(2), "ms");
+}
+export function printTimerResults(results) {
+    return results.map(function (r) {
+        var f = formatTimerResult(r);
+        if (r.children.length) {
+            console.groupCollapsed(f);
+            printTimerResults(r.children);
+            console.groupEnd();
+        }
+        else {
+            console.log(f);
+        }
+    });
+}

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

@@ -75,37 +75,37 @@ export var ArrayEncoding;
     ArrayEncoding.by = by;
     function uint8(data) {
         return {
-            encodings: [{ kind: 'ByteArray', type: 4 /* Uint8 */ }],
+            encodings: [{ kind: 'ByteArray', type: 4 /* Encoding.IntDataType.Uint8 */ }],
             data: data
         };
     }
     function int8(data) {
         return {
-            encodings: [{ kind: 'ByteArray', type: 1 /* Int8 */ }],
+            encodings: [{ kind: 'ByteArray', type: 1 /* Encoding.IntDataType.Int8 */ }],
             data: new Uint8Array(data.buffer, data.byteOffset)
         };
     }
     var writers = (_a = {},
-        _a[2 /* Int16 */] = function (v, i, a) { v.setInt16(2 * i, a, true); },
-        _a[5 /* Uint16 */] = function (v, i, a) { v.setUint16(2 * i, a, true); },
-        _a[3 /* Int32 */] = function (v, i, a) { v.setInt32(4 * i, a, true); },
-        _a[6 /* Uint32 */] = function (v, i, a) { v.setUint32(4 * i, a, true); },
-        _a[32 /* Float32 */] = function (v, i, a) { v.setFloat32(4 * i, a, true); },
-        _a[33 /* Float64 */] = function (v, i, a) { v.setFloat64(8 * i, a, true); },
+        _a[2 /* Encoding.IntDataType.Int16 */] = function (v, i, a) { v.setInt16(2 * i, a, true); },
+        _a[5 /* Encoding.IntDataType.Uint16 */] = function (v, i, a) { v.setUint16(2 * i, a, true); },
+        _a[3 /* Encoding.IntDataType.Int32 */] = function (v, i, a) { v.setInt32(4 * i, a, true); },
+        _a[6 /* Encoding.IntDataType.Uint32 */] = function (v, i, a) { v.setUint32(4 * i, a, true); },
+        _a[32 /* Encoding.FloatDataType.Float32 */] = function (v, i, a) { v.setFloat32(4 * i, a, true); },
+        _a[33 /* Encoding.FloatDataType.Float64 */] = function (v, i, a) { v.setFloat64(8 * i, a, true); },
         _a);
     var byteSizes = (_b = {},
-        _b[2 /* Int16 */] = 2,
-        _b[5 /* Uint16 */] = 2,
-        _b[3 /* Int32 */] = 4,
-        _b[6 /* Uint32 */] = 4,
-        _b[32 /* Float32 */] = 4,
-        _b[33 /* Float64 */] = 8,
+        _b[2 /* Encoding.IntDataType.Int16 */] = 2,
+        _b[5 /* Encoding.IntDataType.Uint16 */] = 2,
+        _b[3 /* Encoding.IntDataType.Int32 */] = 4,
+        _b[6 /* Encoding.IntDataType.Uint32 */] = 4,
+        _b[32 /* Encoding.FloatDataType.Float32 */] = 4,
+        _b[33 /* Encoding.FloatDataType.Float64 */] = 8,
         _b);
     function byteArray(data) {
         var type = Encoding.getDataType(data);
-        if (type === 1 /* Int8 */)
+        if (type === 1 /* Encoding.IntDataType.Int8 */)
             return int8(data);
-        else if (type === 4 /* Uint8 */)
+        else if (type === 4 /* Encoding.IntDataType.Uint8 */)
             return uint8(data);
         var result = new Uint8Array(data.length * byteSizes[type]);
         var w = writers[type];
@@ -170,7 +170,7 @@ export var ArrayEncoding;
         var srcType = Encoding.getDataType(data);
         if (srcType === void 0) {
             data = new Int32Array(data);
-            srcType = 3 /* Int32 */;
+            srcType = 3 /* Encoding.IntDataType.Int32 */;
         }
         if (!data.length) {
             return {
@@ -214,7 +214,7 @@ export var ArrayEncoding;
         var srcType = Encoding.getDataType(data);
         if (srcType === void 0) {
             data = new Int32Array(data);
-            srcType = 3 /* Int32 */;
+            srcType = 3 /* Encoding.IntDataType.Int32 */;
         }
         if (!data.length) {
             return {

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

@@ -21,14 +21,14 @@ function decodeStep(data, encoding) {
     switch (encoding.kind) {
         case 'ByteArray': {
             switch (encoding.type) {
-                case 4 /* Uint8 */: return data;
-                case 1 /* Int8 */: return int8(data);
-                case 2 /* Int16 */: return int16(data);
-                case 5 /* Uint16 */: return uint16(data);
-                case 3 /* Int32 */: return int32(data);
-                case 6 /* Uint32 */: return uint32(data);
-                case 32 /* Float32 */: return float32(data);
-                case 33 /* Float64 */: return float64(data);
+                case 4 /* Encoding.IntDataType.Uint8 */: return data;
+                case 1 /* Encoding.IntDataType.Int8 */: return int8(data);
+                case 2 /* Encoding.IntDataType.Int16 */: return int16(data);
+                case 5 /* Encoding.IntDataType.Uint16 */: return uint16(data);
+                case 3 /* Encoding.IntDataType.Int32 */: return int32(data);
+                case 6 /* Encoding.IntDataType.Uint32 */: return uint32(data);
+                case 32 /* Encoding.FloatDataType.Float32 */: return float32(data);
+                case 33 /* Encoding.FloatDataType.Float64 */: return float64(data);
                 default: assertUnreachable(encoding.type);
             }
         }
@@ -42,19 +42,19 @@ function decodeStep(data, encoding) {
 }
 function getIntArray(type, size) {
     switch (type) {
-        case 1 /* Int8 */: return new Int8Array(size);
-        case 2 /* Int16 */: return new Int16Array(size);
-        case 3 /* Int32 */: return new Int32Array(size);
-        case 4 /* Uint8 */: return new Uint8Array(size);
-        case 5 /* Uint16 */: return new Uint16Array(size);
-        case 6 /* Uint32 */: return new Uint32Array(size);
+        case 1 /* Encoding.IntDataType.Int8 */: return new Int8Array(size);
+        case 2 /* Encoding.IntDataType.Int16 */: return new Int16Array(size);
+        case 3 /* Encoding.IntDataType.Int32 */: return new Int32Array(size);
+        case 4 /* Encoding.IntDataType.Uint8 */: return new Uint8Array(size);
+        case 5 /* Encoding.IntDataType.Uint16 */: return new Uint16Array(size);
+        case 6 /* Encoding.IntDataType.Uint32 */: return new Uint32Array(size);
         default: assertUnreachable(type);
     }
 }
 function getFloatArray(type, size) {
     switch (type) {
-        case 32 /* Float32 */: return new Float32Array(size);
-        case 33 /* Float64 */: return new Float64Array(size);
+        case 32 /* Encoding.FloatDataType.Float32 */: return new Float32Array(size);
+        case 33 /* Encoding.FloatDataType.Float64 */: return new Float64Array(size);
         default: assertUnreachable(type);
     }
 }

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

@@ -10,23 +10,23 @@ export var Encoding;
     function getDataType(data) {
         var srcType;
         if (data instanceof Int8Array)
-            srcType = 1 /* Int8 */;
+            srcType = 1 /* Encoding.IntDataType.Int8 */;
         else if (data instanceof Int16Array)
-            srcType = 2 /* Int16 */;
+            srcType = 2 /* Encoding.IntDataType.Int16 */;
         else if (data instanceof Int32Array)
-            srcType = 3 /* Int32 */;
+            srcType = 3 /* Encoding.IntDataType.Int32 */;
         else if (data instanceof Uint8Array)
-            srcType = 4 /* Uint8 */;
+            srcType = 4 /* Encoding.IntDataType.Uint8 */;
         else if (data instanceof Uint16Array)
-            srcType = 5 /* Uint16 */;
+            srcType = 5 /* Encoding.IntDataType.Uint16 */;
         else if (data instanceof Uint32Array)
-            srcType = 6 /* Uint32 */;
+            srcType = 6 /* Encoding.IntDataType.Uint32 */;
         else if (data instanceof Float32Array)
-            srcType = 32 /* Float32 */;
+            srcType = 32 /* Encoding.FloatDataType.Float32 */;
         else if (data instanceof Float64Array)
-            srcType = 33 /* Float64 */;
+            srcType = 33 /* Encoding.FloatDataType.Float64 */;
         else
-            srcType = 3 /* Int32 */; // throw new Error('Unsupported integer data type.');
+            srcType = 3 /* Encoding.IntDataType.Int32 */; // throw new Error('Unsupported integer data type.');
         return srcType;
     }
     Encoding.getDataType = getDataType;

package/lib/mol-io/reader/cif/binary/field.js

@@ -13,10 +13,10 @@ export function Field(column) {
     var isNumeric = ColumnHelpers.isTypedArray(data);
     var str = isNumeric
         ? mask
-            ? function (row) { return mask[row] === 0 /* Present */ ? '' + data[row] : ''; }
+            ? function (row) { return mask[row] === 0 /* Column.ValueKind.Present */ ? '' + data[row] : ''; }
             : function (row) { return '' + data[row]; }
         : mask
-            ? function (row) { return mask[row] === 0 /* Present */ ? data[row] : ''; }
+            ? function (row) { return mask[row] === 0 /* Column.ValueKind.Present */ ? data[row] : ''; }
             : function (row) { return data[row]; };
     var int = isNumeric
         ? function (row) { return data[row]; }
@@ -26,7 +26,7 @@ export function Field(column) {
         : function (row) { var v = data[row]; return fastParseFloat(v, 0, v.length); };
     var valueKind = mask
         ? function (row) { return mask[row]; }
-        : function (row) { return 0 /* Present */; };
+        : function (row) { return 0 /* Column.ValueKind.Present */; };
     var rowCount = data.length;
     return {
         __array: data,

package/lib/mol-io/reader/cif/data-model.js

@@ -71,15 +71,15 @@ export var CifField;
         var valueKind = function (row) {
             var v = values[row], l = v.length;
             if (l > 1)
-                return 0 /* Present */;
+                return 0 /* Column.ValueKind.Present */;
             if (l === 0)
-                return 1 /* NotPresent */;
+                return 1 /* Column.ValueKind.NotPresent */;
             var c = v.charCodeAt(0);
             if (c === 46 /* . */)
-                return 1 /* NotPresent */;
+                return 1 /* Column.ValueKind.NotPresent */;
             if (c === 63 /* ? */)
-                return 2 /* Unknown */;
-            return 0 /* Present */;
+                return 2 /* Column.ValueKind.Unknown */;
+            return 0 /* Column.ValueKind.Present */;
         };
         return {
             __array: void 0,
@@ -101,7 +101,7 @@ export var CifField;
         var rowCount = values.length;
         var str = function (row) { return '' + values[row]; };
         var float = function (row) { return values[row]; };
-        var valueKind = function (row) { return 0 /* Present */; };
+        var valueKind = function (row) { return 0 /* Column.ValueKind.Present */; };
         var toFloatArray = function (params) {
             if (!params || params.array && values instanceof params.array) {
                 return values;
@@ -143,15 +143,15 @@ export var CifField;
         var valueKind = function (row) {
             var s = indices[2 * row], l = indices[2 * row + 1] - s;
             if (l > 1)
-                return 0 /* Present */;
+                return 0 /* Column.ValueKind.Present */;
             if (l === 0)
-                return 1 /* NotPresent */;
+                return 1 /* Column.ValueKind.NotPresent */;
             var v = data.charCodeAt(s);
             if (v === 46 /* . */)
-                return 1 /* NotPresent */;
+                return 1 /* Column.ValueKind.NotPresent */;
             if (v === 63 /* ? */)
-                return 2 /* Unknown */;
-            return 0 /* Present */;
+                return 2 /* Column.ValueKind.Unknown */;
+            return 0 /* Column.ValueKind.Present */;
         };
         return {
             __array: void 0,
@@ -273,14 +273,14 @@ export function getCifFieldType(field) {
     var floatCount = 0, hasStringOrScientific = false, undefinedCount = 0;
     for (var i = 0, _i = field.rowCount; i < _i; i++) {
         var k = field.valueKind(i);
-        if (k !== 0 /* Present */) {
+        if (k !== 0 /* Column.ValueKind.Present */) {
             undefinedCount++;
             continue;
         }
         var type = getNumberType(field.str(i));
-        if (type === 0 /* Int */)
+        if (type === 0 /* NumberType.Int */)
             continue;
-        else if (type === 1 /* Float */)
+        else if (type === 1 /* NumberType.Float */)
             floatCount++;
         else {
             hasStringOrScientific = true;

package/lib/mol-io/reader/cif/schema.js

@@ -93,7 +93,7 @@ function createListColumn(schema, category, key) {
         isDefined: !!f,
         rowCount: category.rowCount,
         value: value,
-        valueKind: f ? f.valueKind : function () { return 1 /* NotPresent */; },
+        valueKind: f ? f.valueKind : function () { return 1 /* Column.ValueKind.NotPresent */; },
         areValuesEqual: function (rowA, rowB) { return arrayEqual(value(rowA), value(rowB)); },
         toArray: toArray
     };