molstar 3.8.2 → 3.10.0

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
     };

package/lib/mol-io/reader/cif/text/parser.js

@@ -373,7 +373,7 @@ function getTokenString(state) {
 function moveNextInternal(state) {
     var prev = skipWhitespace(state);
     if (state.position >= state.length) {
-        state.tokenType = 6 /* End */;
+        state.tokenType = 6 /* CifTokenType.End */;
         return;
     }
     state.tokenStart = state.position;
@@ -383,17 +383,17 @@ function moveNextInternal(state) {
     switch (c) {
         case 35: // #, comment
             skipCommentLine(state);
-            state.tokenType = 5 /* Comment */;
+            state.tokenType = 5 /* CifTokenType.Comment */;
             break;
         case 39: // ', escaped value
             if (isTripleQuoteAtPosition(state)) {
                 eatTripleQuote(state);
-                state.tokenType = 3 /* Value */;
+                state.tokenType = 3 /* CifTokenType.Value */;
                 break;
             }
         case 34: // ", escaped value
             eatEscaped(state, c);
-            state.tokenType = 3 /* Value */;
+            state.tokenType = 3 /* CifTokenType.Value */;
             break;
         case 59: // ;, possible multiline value
             // multiline value must start at the beginning of the line.
@@ -403,7 +403,7 @@ function moveNextInternal(state) {
             else {
                 eatValue(state);
             }
-            state.tokenType = 3 /* Value */;
+            state.tokenType = 3 /* CifTokenType.Value */;
             break;
         default:
             if (state.isImportGet) {
@@ -414,29 +414,29 @@ function moveNextInternal(state) {
             }
             // escaped is always Value
             if (state.isEscaped) {
-                state.tokenType = 3 /* Value */;
+                state.tokenType = 3 /* CifTokenType.Value */;
                 // _ means column name, including _import.get
             }
             else if (state.data.charCodeAt(state.tokenStart) === 95) { // _
                 if (state.inSaveFrame && isImportGet(state)) {
                     state.isImportGet = true;
                 }
-                state.tokenType = 4 /* ColumnName */;
+                state.tokenType = 4 /* CifTokenType.ColumnName */;
                 // 5th char needs to be _ for data_, save_ or loop_
             }
             else if (state.tokenEnd - state.tokenStart >= 5 && state.data.charCodeAt(state.tokenStart + 4) === 95) {
                 if (isData(state))
-                    state.tokenType = 0 /* Data */;
+                    state.tokenType = 0 /* CifTokenType.Data */;
                 else if (isSave(state))
-                    state.tokenType = 1 /* Save */;
+                    state.tokenType = 1 /* CifTokenType.Save */;
                 else if (isLoop(state))
-                    state.tokenType = 2 /* Loop */;
+                    state.tokenType = 2 /* CifTokenType.Loop */;
                 else
-                    state.tokenType = 3 /* Value */;
+                    state.tokenType = 3 /* CifTokenType.Value */;
                 // all other tests failed, we are at Value token.
             }
             else {
-                state.tokenType = 3 /* Value */;
+                state.tokenType = 3 /* CifTokenType.Value */;
             }
             break;
     }
@@ -446,7 +446,7 @@ function moveNextInternal(state) {
  */
 function moveNext(state) {
     moveNextInternal(state);
-    while (state.tokenType === 5 /* Comment */)
+    while (state.tokenType === 5 /* CifTokenType.Comment */)
         moveNextInternal(state);
 }
 function createTokenizer(data, runtimeCtx) {
@@ -456,7 +456,7 @@ function createTokenizer(data, runtimeCtx) {
         position: 0,
         tokenStart: 0,
         tokenEnd: 0,
-        tokenType: 6 /* End */,
+        tokenType: 6 /* CifTokenType.End */,
         lineNumber: 1,
         isEscaped: false,
         isImportGet: false,
@@ -504,13 +504,13 @@ function handleSingle(tokenizer, ctx) {
     var fieldNames = [];
     var readingNames = true;
     while (readingNames) {
-        if (tokenizer.tokenType !== 4 /* ColumnName */ || !isNamespace(tokenizer, nsStart, nsEnd)) {
+        if (tokenizer.tokenType !== 4 /* CifTokenType.ColumnName */ || !isNamespace(tokenizer, nsStart, nsEnd)) {
             readingNames = false;
             break;
         }
         var fieldName = getTokenString(tokenizer).substring(name.length + 1);
         moveNext(tokenizer);
-        if (tokenizer.tokenType !== 3 /* Value */) {
+        if (tokenizer.tokenType !== 3 /* CifTokenType.Value */) {
             return {
                 hasError: true,
                 errorLine: tokenizer.lineNumber,
@@ -532,7 +532,7 @@ function readLoopChunk(chunkSize, state) {
     var tokenizer = state.tokenizer, tokens = state.tokens, fieldCount = state.fieldCount;
     var tokenCount = state.tokenCount;
     var counter = 0;
-    while (tokenizer.tokenType === 3 /* Value */ && counter < chunkSize) {
+    while (tokenizer.tokenType === 3 /* CifTokenType.Value */ && counter < chunkSize) {
         TokenBuilder.add(tokens[(tokenCount++) % fieldCount], tokenizer.tokenStart, tokenizer.tokenEnd);
         moveNext(tokenizer);
         counter++;
@@ -560,7 +560,7 @@ function handleLoop(tokenizer, ctx) {
                     name = getNamespace(tokenizer, getNamespaceEnd(tokenizer));
                     isFlat = isFlatNamespace(tokenizer);
                     fieldNames = [];
-                    while (tokenizer.tokenType === 4 /* ColumnName */) {
+                    while (tokenizer.tokenType === 4 /* CifTokenType.ColumnName */) {
                         fieldNames[fieldNames.length] = isFlat
                             ? getTokenString(tokenizer)
                             : getTokenString(tokenizer).substring(name.length + 1);
@@ -645,9 +645,9 @@ function parseInternal(data, runtimeCtx) {
                     moveNext(tokenizer);
                     _a.label = 1;
                 case 1:
-                    if (!(tokenizer.tokenType !== 6 /* End */)) return [3 /*break*/, 7];
+                    if (!(tokenizer.tokenType !== 6 /* CifTokenType.End */)) return [3 /*break*/, 7];
                     token = tokenizer.tokenType;
-                    if (!(token === 0 /* Data */)) return [3 /*break*/, 2];
+                    if (!(token === 0 /* CifTokenType.Data */)) return [3 /*break*/, 2];
                     if (tokenizer.inSaveFrame) {
                         return [2 /*return*/, error(tokenizer.lineNumber, 'Unexpected data block inside a save frame.')];
                     }
@@ -660,7 +660,7 @@ function parseInternal(data, runtimeCtx) {
                     moveNext(tokenizer);
                     return [3 /*break*/, 6];
                 case 2:
-                    if (!(token === 1 /* Save */)) return [3 /*break*/, 3];
+                    if (!(token === 1 /* CifTokenType.Save */)) return [3 /*break*/, 3];
                     if (tokenizer.tokenEnd - tokenizer.tokenStart === 5) { // end of save frame
                         if (saveCtx.categoryNames.length > 0) {
                             saveFrames[saveFrames.length] = CifSaveFrame(saveCtx, saveHeader);
@@ -679,7 +679,7 @@ function parseInternal(data, runtimeCtx) {
                     moveNext(tokenizer);
                     return [3 /*break*/, 6];
                 case 3:
-                    if (!(token === 2 /* Loop */)) return [3 /*break*/, 5];
+                    if (!(token === 2 /* CifTokenType.Loop */)) return [3 /*break*/, 5];
                     return [4 /*yield*/, handleLoop(tokenizer, tokenizer.inSaveFrame ? saveCtx : blockCtx)];
                 case 4:
                     cat = _a.sent();
@@ -688,7 +688,7 @@ function parseInternal(data, runtimeCtx) {
                     }
                     return [3 /*break*/, 6];
                 case 5:
-                    if (token === 4 /* ColumnName */) {
+                    if (token === 4 /* CifTokenType.ColumnName */) {
                         cat = handleSingle(tokenizer, tokenizer.inSaveFrame ? saveCtx : blockCtx);
                         if (cat.hasError) {
                             return [2 /*return*/, error(cat.errorLine, cat.errorMessage)];