molstar 3.8.2 → 3.9.0

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

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * 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>
  */
@@ -198,6 +198,18 @@ function getDefinesCode(defines, ignore) {
     }
     return lines.join('\n') + '\n';
 }
+function getGlsl100VertPrefix(extensions, shaderExtensions) {
+    var prefix = [];
+    if (shaderExtensions.drawBuffers) {
+        if (extensions.drawBuffers) {
+            prefix.push('#define requiredDrawBuffers');
+        }
+        else if (shaderExtensions.drawBuffers === 'required') {
+            throw new Error("required 'GL_EXT_draw_buffers' extension not available");
+        }
+    }
+    return prefix.join('\n') + '\n';
+}
 function getGlsl100FragPrefix(extensions, shaderExtensions) {
     var prefix = [
         '#extension GL_OES_standard_derivatives : enable'
@@ -235,25 +247,43 @@ function getGlsl100FragPrefix(extensions, shaderExtensions) {
     }
     return prefix.join('\n') + '\n';
 }
-var glsl300VertPrefix = "#version 300 es\n#define attribute in\n#define varying out\n#define texture2D texture\n";
+var glsl300VertPrefixCommon = "\n#define attribute in\n#define varying out\n#define texture2D texture\n";
 var glsl300FragPrefixCommon = "\n#define varying in\n#define texture2D texture\n#define texture2DLodEXT textureLod\n\n#define gl_FragColor out_FragData0\n#define gl_FragDepthEXT gl_FragDepth\n\n#define depthTextureSupport\n";
+function getGlsl300VertPrefix(extensions, shaderExtensions) {
+    var prefix = [
+        '#version 300 es',
+    ];
+    if (shaderExtensions.drawBuffers) {
+        if (extensions.drawBuffers) {
+            prefix.push('#define requiredDrawBuffers');
+        }
+    }
+    prefix.push(glsl300VertPrefixCommon);
+    return prefix.join('\n') + '\n';
+}
 function getGlsl300FragPrefix(gl, extensions, shaderExtensions, outTypes) {
     var prefix = [
         '#version 300 es',
         "layout(location = 0) out highp ".concat(outTypes[0] || 'vec4', " out_FragData0;")
     ];
     if (shaderExtensions.fragDepth) {
-        prefix.push('#define enabledFragDepth');
+        if (extensions.fragDepth) {
+            prefix.push('#define enabledFragDepth');
+        }
     }
     if (shaderExtensions.drawBuffers) {
-        prefix.push('#define requiredDrawBuffers');
-        var maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);
-        for (var i = 1, il = maxDrawBuffers; i < il; ++i) {
-            prefix.push("layout(location = ".concat(i, ") out highp ").concat(outTypes[i] || 'vec4', " out_FragData").concat(i, ";"));
+        if (extensions.drawBuffers) {
+            prefix.push('#define requiredDrawBuffers');
+            var maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);
+            for (var i = 1, il = maxDrawBuffers; i < il; ++i) {
+                prefix.push("layout(location = ".concat(i, ") out highp ").concat(outTypes[i] || 'vec4', " out_FragData").concat(i, ";"));
+            }
         }
     }
     if (shaderExtensions.shaderTextureLod) {
-        prefix.push('#define enabledShaderTextureLod');
+        if (extensions.shaderTextureLod) {
+            prefix.push('#define enabledShaderTextureLod');
+        }
     }
     prefix.push(glsl300FragPrefixCommon);
     return prefix.join('\n') + '\n';
@@ -264,7 +294,9 @@ function transformGlsl300Frag(frag) {
 function addShaderDefines(gl, extensions, defines, shaders) {
     var vertHeader = getDefinesCode(defines, shaders.ignoreDefine);
     var fragHeader = getDefinesCode(defines, shaders.ignoreDefine);
-    var vertPrefix = (0, compat_1.isWebGL2)(gl) ? glsl300VertPrefix : '';
+    var vertPrefix = (0, compat_1.isWebGL2)(gl)
+        ? getGlsl300VertPrefix(extensions, shaders.extensions)
+        : getGlsl100VertPrefix(extensions, shaders.extensions);
     var fragPrefix = (0, compat_1.isWebGL2)(gl)
         ? getGlsl300FragPrefix(gl, extensions, shaders.extensions, shaders.outTypes)
         : getGlsl100FragPrefix(extensions, shaders.extensions);

package/lib/commonjs/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/commonjs/mol-gl/webgl/compat.js

@@ -1,11 +1,11 @@
 "use strict";
 /**
- * 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>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testColorBuffer = exports.getSRGB = exports.getDepthTexture = exports.getShaderTextureLod = exports.getDrawBuffers = exports.getColorBufferHalfFloat = exports.getColorBufferFloat = exports.getFragDepth = exports.getBlendMinMax = exports.getTextureHalfFloatLinear = exports.getTextureHalfFloat = exports.getTextureFloatLinear = exports.getTextureFloat = exports.getVertexArrayObject = exports.getElementIndexUint = exports.getStandardDerivatives = exports.getInstancedArrays = exports.isWebGL2 = exports.isWebGL = void 0;
+exports.testColorBuffer = exports.getDisjointTimerQuery = exports.getSRGB = exports.getDepthTexture = exports.getShaderTextureLod = exports.getDrawBuffers = exports.getColorBufferHalfFloat = exports.getColorBufferFloat = exports.getFragDepth = exports.getBlendMinMax = exports.getTextureHalfFloatLinear = exports.getTextureHalfFloat = exports.getTextureFloatLinear = exports.getTextureFloat = exports.getVertexArrayObject = exports.getElementIndexUint = exports.getStandardDerivatives = exports.getInstancedArrays = exports.isWebGL2 = exports.isWebGL = void 0;
 var debug_1 = require("../../mol-util/debug");
 var context_1 = require("./context");
 var program_1 = require("./program");
@@ -252,6 +252,54 @@ function getSRGB(gl) {
     }
 }
 exports.getSRGB = getSRGB;
+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),
+        };
+    }
+}
+exports.getDisjointTimerQuery = getDisjointTimerQuery;
 //
 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/commonjs/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/commonjs/mol-gl/webgl/context.js

@@ -18,6 +18,7 @@ var resources_1 = require("./resources");
 var render_target_1 = require("./render-target");
 var rxjs_1 = require("rxjs");
 var now_1 = require("../../mol-util/now");
+var timer_1 = require("./timer");
 function getGLContext(canvas, attribs) {
     function get(id) {
         try {
@@ -176,6 +177,7 @@ function createContext(gl, props) {
     var state = (0, state_1.createState)(gl);
     var stats = createStats();
     var resources = (0, resources_1.createResources)(gl, state, stats, extensions);
+    var timer = (0, timer_1.createTimer)(gl, extensions);
     var parameters = {
         maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
         max3dTextureSize: (0, compat_1.isWebGL2)(gl) ? gl.getParameter(gl.MAX_3D_TEXTURE_SIZE) : 0,
@@ -240,6 +242,7 @@ 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/commonjs/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/commonjs/mol-gl/webgl/extensions.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * 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>
  */
@@ -79,6 +79,10 @@ function createExtensions(gl) {
     if (debug_1.isDebugMode && sRGB === null) {
         console.log('Could not find support for "sRGB"');
     }
+    var disjointTimerQuery = (0, compat_1.getDisjointTimerQuery)(gl);
+    if (debug_1.isDebugMode && disjointTimerQuery === null) {
+        console.log('Could not find support for "disjoint_timer_query"');
+    }
     return {
         instancedArrays: instancedArrays,
         standardDerivatives: standardDerivatives,
@@ -96,6 +100,7 @@ function createExtensions(gl) {
         drawBuffers: drawBuffers,
         shaderTextureLod: shaderTextureLod,
         sRGB: sRGB,
+        disjointTimerQuery: disjointTimerQuery,
     };
 }
 exports.createExtensions = createExtensions;

package/lib/commonjs/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/commonjs/mol-gl/webgl/timer.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTimerResults = exports.createTimer = void 0;
+function getQuery(extensions) {
+    return extensions.disjointTimerQuery ? extensions.disjointTimerQuery.createQuery() : null;
+}
+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();
+        }
+    };
+}
+exports.createTimer = createTimer;
+function formatTimerResult(result) {
+    var timeElapsed = result.timeElapsed / 1000 / 1000;
+    return "".concat(result.label, " ").concat(timeElapsed.toFixed(2), "ms");
+}
+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);
+        }
+    });
+}
+exports.printTimerResults = printTimerResults;

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

@@ -78,37 +78,37 @@ 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_1.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];
@@ -173,7 +173,7 @@ var ArrayEncoding;
         var srcType = encoding_1.Encoding.getDataType(data);
         if (srcType === void 0) {
             data = new Int32Array(data);
-            srcType = 3 /* Int32 */;
+            srcType = 3 /* Encoding.IntDataType.Int32 */;
         }
         if (!data.length) {
             return {
@@ -217,7 +217,7 @@ var ArrayEncoding;
         var srcType = encoding_1.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/commonjs/mol-io/common/binary-cif/decoder.js

@@ -25,14 +25,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: (0, type_helpers_1.assertUnreachable)(encoding.type);
             }
         }
@@ -46,19 +46,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: (0, type_helpers_1.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: (0, type_helpers_1.assertUnreachable)(type);
     }
 }

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

@@ -13,23 +13,23 @@ 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;