molstar 3.3.1 → 3.4.0

package/lib/commonjs/mol-gl/renderable/spheres.js

@@ -12,14 +12,14 @@ var render_item_1 = require("../webgl/render-item");
 var schema_1 = require("./schema");
 var shader_code_1 = require("../shader-code");
 var mol_util_1 = require("../../mol-util");
-exports.SpheresSchema = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.BaseSchema), schema_1.SizeSchema), { aGroup: (0, schema_1.AttributeSpec)('float32', 1, 0), aPosition: (0, schema_1.AttributeSpec)('float32', 3, 0), aMapping: (0, schema_1.AttributeSpec)('float32', 2, 0), elements: (0, schema_1.ElementsSpec)('uint32'), padding: (0, schema_1.ValueSpec)('number'), uDoubleSided: (0, schema_1.UniformSpec)('b'), dIgnoreLight: (0, schema_1.DefineSpec)('boolean'), dXrayShaded: (0, schema_1.DefineSpec)('boolean'), uBumpFrequency: (0, schema_1.UniformSpec)('f'), uBumpAmplitude: (0, schema_1.UniformSpec)('f') });
+exports.SpheresSchema = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, schema_1.BaseSchema), schema_1.SizeSchema), { aGroup: (0, schema_1.AttributeSpec)('float32', 1, 0), aPosition: (0, schema_1.AttributeSpec)('float32', 3, 0), aMapping: (0, schema_1.AttributeSpec)('float32', 2, 0), elements: (0, schema_1.ElementsSpec)('uint32'), padding: (0, schema_1.ValueSpec)('number'), uDoubleSided: (0, schema_1.UniformSpec)('b'), dIgnoreLight: (0, schema_1.DefineSpec)('boolean'), dXrayShaded: (0, schema_1.DefineSpec)('boolean'), uBumpFrequency: (0, schema_1.UniformSpec)('f'), uBumpAmplitude: (0, schema_1.UniformSpec)('f') });
 function SpheresRenderable(ctx, id, values, state, materialId, variants) {
-    var schema = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.SpheresSchema);
+    var schema = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.SpheresSchema);
     var internalValues = {
         uObjectId: mol_util_1.ValueCell.create(id),
     };
     var shaderCode = shader_code_1.SpheresShaderCode;
-    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, values), internalValues), materialId, variants);
+    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, tslib_1.__assign(tslib_1.__assign({}, values), internalValues), materialId, variants);
     return (0, renderable_1.createRenderable)(renderItem, values, state);
 }
 exports.SpheresRenderable = SpheresRenderable;

package/lib/commonjs/mol-gl/renderable/text.js

@@ -12,14 +12,14 @@ var render_item_1 = require("../webgl/render-item");
 var schema_1 = require("./schema");
 var shader_code_1 = require("../shader-code");
 var mol_util_1 = require("../../mol-util");
-exports.TextSchema = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.BaseSchema), schema_1.SizeSchema), { aGroup: (0, schema_1.AttributeSpec)('float32', 1, 0), aPosition: (0, schema_1.AttributeSpec)('float32', 3, 0), aMapping: (0, schema_1.AttributeSpec)('float32', 2, 0), aDepth: (0, schema_1.AttributeSpec)('float32', 1, 0), elements: (0, schema_1.ElementsSpec)('uint32'), aTexCoord: (0, schema_1.AttributeSpec)('float32', 2, 0), tFont: (0, schema_1.TextureSpec)('image-uint8', 'alpha', 'ubyte', 'linear'), padding: (0, schema_1.ValueSpec)('number'), uBorderWidth: (0, schema_1.UniformSpec)('f'), uBorderColor: (0, schema_1.UniformSpec)('v3'), uOffsetX: (0, schema_1.UniformSpec)('f'), uOffsetY: (0, schema_1.UniformSpec)('f'), uOffsetZ: (0, schema_1.UniformSpec)('f'), uBackgroundColor: (0, schema_1.UniformSpec)('v3'), uBackgroundOpacity: (0, schema_1.UniformSpec)('f') });
+exports.TextSchema = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, schema_1.BaseSchema), schema_1.SizeSchema), { aGroup: (0, schema_1.AttributeSpec)('float32', 1, 0), aPosition: (0, schema_1.AttributeSpec)('float32', 3, 0), aMapping: (0, schema_1.AttributeSpec)('float32', 2, 0), aDepth: (0, schema_1.AttributeSpec)('float32', 1, 0), elements: (0, schema_1.ElementsSpec)('uint32'), aTexCoord: (0, schema_1.AttributeSpec)('float32', 2, 0), tFont: (0, schema_1.TextureSpec)('image-uint8', 'alpha', 'ubyte', 'linear'), padding: (0, schema_1.ValueSpec)('number'), uBorderWidth: (0, schema_1.UniformSpec)('f'), uBorderColor: (0, schema_1.UniformSpec)('v3'), uOffsetX: (0, schema_1.UniformSpec)('f'), uOffsetY: (0, schema_1.UniformSpec)('f'), uOffsetZ: (0, schema_1.UniformSpec)('f'), uBackgroundColor: (0, schema_1.UniformSpec)('v3'), uBackgroundOpacity: (0, schema_1.UniformSpec)('f') });
 function TextRenderable(ctx, id, values, state, materialId, variants) {
-    var schema = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.TextSchema);
+    var schema = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.TextSchema);
     var internalValues = {
         uObjectId: mol_util_1.ValueCell.create(id),
     };
     var shaderCode = shader_code_1.TextShaderCode;
-    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, values), internalValues), materialId, variants);
+    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, tslib_1.__assign(tslib_1.__assign({}, values), internalValues), materialId, variants);
     return (0, renderable_1.createRenderable)(renderItem, values, state);
 }
 exports.TextRenderable = TextRenderable;

package/lib/commonjs/mol-gl/renderable/texture-mesh.js

@@ -12,14 +12,14 @@ var render_item_1 = require("../webgl/render-item");
 var schema_1 = require("./schema");
 var shader_code_1 = require("../shader-code");
 var mol_util_1 = require("../../mol-util");
-exports.TextureMeshSchema = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.BaseSchema), { uGeoTexDim: (0, schema_1.UniformSpec)('v2', 'buffered'), tPosition: (0, schema_1.TextureSpec)('texture', 'rgb', 'float', 'nearest'), tGroup: (0, schema_1.TextureSpec)('texture', 'alpha', 'float', 'nearest'), tNormal: (0, schema_1.TextureSpec)('texture', 'rgb', 'float', 'nearest'), dFlatShaded: (0, schema_1.DefineSpec)('boolean'), uDoubleSided: (0, schema_1.UniformSpec)('b'), dFlipSided: (0, schema_1.DefineSpec)('boolean'), dIgnoreLight: (0, schema_1.DefineSpec)('boolean'), dXrayShaded: (0, schema_1.DefineSpec)('boolean'), uBumpFrequency: (0, schema_1.UniformSpec)('f'), uBumpAmplitude: (0, schema_1.UniformSpec)('f'), meta: (0, schema_1.ValueSpec)('unknown') });
+exports.TextureMeshSchema = tslib_1.__assign(tslib_1.__assign({}, schema_1.BaseSchema), { uGeoTexDim: (0, schema_1.UniformSpec)('v2', 'buffered'), tPosition: (0, schema_1.TextureSpec)('texture', 'rgb', 'float', 'nearest'), tGroup: (0, schema_1.TextureSpec)('texture', 'alpha', 'float', 'nearest'), tNormal: (0, schema_1.TextureSpec)('texture', 'rgb', 'float', 'nearest'), dFlatShaded: (0, schema_1.DefineSpec)('boolean'), uDoubleSided: (0, schema_1.UniformSpec)('b'), dFlipSided: (0, schema_1.DefineSpec)('boolean'), dIgnoreLight: (0, schema_1.DefineSpec)('boolean'), dXrayShaded: (0, schema_1.DefineSpec)('boolean'), uBumpFrequency: (0, schema_1.UniformSpec)('f'), uBumpAmplitude: (0, schema_1.UniformSpec)('f'), meta: (0, schema_1.ValueSpec)('unknown') });
 function TextureMeshRenderable(ctx, id, values, state, materialId, variants) {
-    var schema = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.TextureMeshSchema);
+    var schema = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, schema_1.GlobalUniformSchema), schema_1.GlobalTextureSchema), schema_1.InternalSchema), exports.TextureMeshSchema);
     var internalValues = {
         uObjectId: mol_util_1.ValueCell.create(id),
     };
     var shaderCode = shader_code_1.MeshShaderCode;
-    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, values), internalValues), materialId, variants);
+    var renderItem = (0, render_item_1.createGraphicsRenderItem)(ctx, 'triangles', shaderCode, schema, tslib_1.__assign(tslib_1.__assign({}, values), internalValues), materialId, variants);
     return (0, renderable_1.createRenderable)(renderItem, values, state);
 }
 exports.TextureMeshRenderable = TextureMeshRenderable;

package/lib/commonjs/mol-gl/renderable/util.js

@@ -56,7 +56,7 @@ var tmpCanvasCtx;
 var tmpContainer;
 function printImageData(imageData, options) {
     if (options === void 0) { options = {}; }
-    var o = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, DefaultPrintImageOptions), options);
+    var o = tslib_1.__assign(tslib_1.__assign({}, DefaultPrintImageOptions), options);
     var canvas = tmpCanvas || document.createElement('canvas');
     tmpCanvas = canvas;
     canvas.width = imageData.width;

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

@@ -167,6 +167,7 @@ var direct_volume_frag_1 = require("./shader/direct-volume.frag");
 exports.DirectVolumeShaderCode = ShaderCode('direct-volume', direct_volume_vert_1.directVolume_vert, direct_volume_frag_1.directVolume_frag, { fragDepth: 'optional', drawBuffers: 'optional' }, {}, ignoreDefine);
 var image_vert_1 = require("./shader/image.vert");
 var image_frag_1 = require("./shader/image.frag");
+var type_helpers_1 = require("../mol-util/type-helpers");
 exports.ImageShaderCode = ShaderCode('image', image_vert_1.image_vert, image_frag_1.image_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
 function getDefinesCode(defines, ignore) {
     var _a;
@@ -191,7 +192,7 @@ function getDefinesCode(defines, ignore) {
                     lines.push("#define ".concat(name_1));
             }
             else {
-                throw new Error('unknown define type');
+                (0, type_helpers_1.assertUnreachable)(v);
             }
         }
     }

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

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createElementsBuffer = exports.createAttributeBuffers = exports.createAttributeBuffer = exports.getAttribType = exports.getBufferType = exports.getDataType = exports.getUsageHint = void 0;
 var tslib_1 = require("tslib");
 var id_factory_1 = require("../../mol-util/id-factory");
+var type_helpers_1 = require("../../mol-util/type-helpers");
 var getNextBufferId = (0, id_factory_1.idFactory)();
 function getUsageHint(gl, usageHint) {
     switch (usageHint) {
@@ -51,9 +52,7 @@ function dataTypeFromArray(gl, array) {
     else if (array instanceof Float32Array) {
         return gl.FLOAT;
     }
-    else {
-        throw new Error('Should nevver happen');
-    }
+    (0, type_helpers_1.assertUnreachable)(array);
 }
 function getBufferType(gl, bufferType) {
     switch (bufferType) {
@@ -141,7 +140,7 @@ function createAttributeBuffer(gl, state, extensions, array, itemSize, divisor,
     var instancedArrays = extensions.instancedArrays;
     var buffer = createBuffer(gl, array, usageHint, 'attribute');
     var _bufferType = buffer._bufferType, _dataType = buffer._dataType, _bpe = buffer._bpe;
-    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, buffer), { bind: function (location) {
+    return tslib_1.__assign(tslib_1.__assign({}, buffer), { bind: function (location) {
             gl.bindBuffer(_bufferType, buffer.getBuffer());
             if (itemSize === 16) {
                 for (var i = 0; i < 4; ++i) {
@@ -172,7 +171,7 @@ exports.createAttributeBuffers = createAttributeBuffers;
 function createElementsBuffer(gl, array, usageHint) {
     if (usageHint === void 0) { usageHint = 'static'; }
     var buffer = createBuffer(gl, array, usageHint, 'elements');
-    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, buffer), { bind: function () {
+    return tslib_1.__assign(tslib_1.__assign({}, buffer), { bind: function () {
             gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer.getBuffer());
         } });
 }

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

@@ -221,8 +221,8 @@ function createContext(gl, props) {
         }); };
     }
     else {
-        readPixelsAsync = function (x, y, width, height, buffer) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
+        readPixelsAsync = function (x, y, width, height, buffer) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
                 readPixels(gl, x, y, width, height, buffer);
                 return [2 /*return*/];
             });
@@ -270,7 +270,7 @@ function createContext(gl, props) {
         createRenderTarget: function (width, height, depth, type, filter) {
             var renderTarget = (0, render_target_1.createRenderTarget)(gl, resources, width, height, depth, type, filter);
             renderTargets.add(renderTarget);
-            return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, renderTarget), { destroy: function () {
+            return tslib_1.__assign(tslib_1.__assign({}, renderTarget), { destroy: function () {
                     renderTarget.destroy();
                     renderTargets.delete(renderTarget);
                 } });

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

@@ -40,7 +40,7 @@ exports.GraphicsRenderVariantsWboit = exports.GraphicsRenderVariants.filter(func
 var ComputeRenderVariant = { compute: '' };
 exports.ComputeRenderVariants = Object.keys(ComputeRenderVariant);
 function createProgramVariant(ctx, variant, defineValues, shaderCode, schema) {
-    defineValues = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, defineValues), { dRenderVariant: mol_util_1.ValueCell.create(variant) });
+    defineValues = tslib_1.__assign(tslib_1.__assign({}, defineValues), { dRenderVariant: mol_util_1.ValueCell.create(variant) });
     if (schema.dRenderVariant === undefined) {
         Object.defineProperty(schema, 'dRenderVariant', { value: (0, schema_1.DefineSpec)('string') });
     }

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

@@ -21,7 +21,7 @@ function defineValueHash(v) {
         typeof v === 'number' ? (v * 10000) : (0, util_1.hashString)(v);
 }
 function wrapCached(resourceItem) {
-    var wrapped = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, resourceItem.value), { destroy: function () {
+    var wrapped = tslib_1.__assign(tslib_1.__assign({}, resourceItem.value), { destroy: function () {
             resourceItem.free();
         } });
     return wrapped;
@@ -40,7 +40,7 @@ function createResources(gl, state, stats, extensions) {
     function wrap(name, resource) {
         sets[name].add(resource);
         stats.resourceCounts[name] += 1;
-        return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, resource), { destroy: function () {
+        return tslib_1.__assign(tslib_1.__assign({}, resource), { destroy: function () {
                 resource.destroy();
                 sets[name].delete(resource);
                 stats.resourceCounts[name] -= 1;

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

@@ -9,6 +9,7 @@ exports.classifyFloatArray = exports.classifyIntArray = void 0;
 var tslib_1 = require("tslib");
 var array_encoder_1 = require("./array-encoder");
 var number_1 = require("../../../mol-util/number");
+var type_helpers_1 = require("../../../mol-util/type-helpers");
 function classifyIntArray(xs) {
     return IntClassifier.classify(xs);
 }
@@ -59,7 +60,7 @@ var IntClassifier;
         for (var i = 0, n = data.length; i < n; i++) {
             incSize(info, size, data[i]);
         }
-        return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, byteSize(size)), { kind: 'pack' });
+        return tslib_1.__assign(tslib_1.__assign({}, byteSize(size)), { kind: 'pack' });
     }
     function deltaSize(data, info) {
         var size = SizeInfo();
@@ -68,7 +69,7 @@ var IntClassifier;
             incSizeSigned(size, data[i] - prev);
             prev = data[i];
         }
-        return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, byteSize(size)), { kind: 'delta' });
+        return tslib_1.__assign(tslib_1.__assign({}, byteSize(size)), { kind: 'delta' });
     }
     function rleSize(data, info) {
         var size = SizeInfo();
@@ -85,7 +86,7 @@ var IntClassifier;
         }
         incSize(info, size, data[data.length - 1]);
         incSize(info, size, run);
-        return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, byteSize(size)), { kind: 'rle' });
+        return tslib_1.__assign(tslib_1.__assign({}, byteSize(size)), { kind: 'rle' });
     }
     function deltaRleSize(data, info) {
         var size = SizeInfo();
@@ -105,7 +106,7 @@ var IntClassifier;
         }
         incSizeSigned(size, prevValue);
         incSizeSigned(size, run);
-        return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, byteSize(size)), { kind: 'delta-rle' });
+        return tslib_1.__assign(tslib_1.__assign({}, byteSize(size)), { kind: 'delta-rle' });
     }
     function getSize(data) {
         var info = getInfo(data);
@@ -124,8 +125,8 @@ var IntClassifier;
             case 'rle': return array_encoder_1.ArrayEncoding.by(array_encoder_1.ArrayEncoding.runLength).and(array_encoder_1.ArrayEncoding.integerPacking);
             case 'delta': return array_encoder_1.ArrayEncoding.by(array_encoder_1.ArrayEncoding.delta).and(array_encoder_1.ArrayEncoding.integerPacking);
             case 'delta-rle': return array_encoder_1.ArrayEncoding.by(array_encoder_1.ArrayEncoding.delta).and(array_encoder_1.ArrayEncoding.runLength).and(array_encoder_1.ArrayEncoding.integerPacking);
+            default: (0, type_helpers_1.assertUnreachable)(size);
         }
-        throw new Error('should not happen :)');
     }
     IntClassifier.classify = classify;
 })(IntClassifier || (IntClassifier = {}));
@@ -159,8 +160,8 @@ var FloatClassifier;
             case 'rle': return fp.and(array_encoder_1.ArrayEncoding.runLength).and(array_encoder_1.ArrayEncoding.integerPacking);
             case 'delta': return fp.and(array_encoder_1.ArrayEncoding.delta).and(array_encoder_1.ArrayEncoding.integerPacking);
             case 'delta-rle': return fp.and(array_encoder_1.ArrayEncoding.delta).and(array_encoder_1.ArrayEncoding.runLength).and(array_encoder_1.ArrayEncoding.integerPacking);
+            default: (0, type_helpers_1.assertUnreachable)(size);
         }
-        throw new Error('should not happen :)');
     }
     FloatClassifier.classify = classify;
     function getMultiplier(mantissaDigits) {

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

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode = void 0;
 var binary_1 = require("../binary");
+var type_helpers_1 = require("../../../mol-util/type-helpers");
 /**
  * Fixed point, delta, RLE, integer packing adopted from https://github.com/rcsb/mmtf-javascript/
  * by Alexander Rose <alexander.rose@weirdbyte.de>, MIT License, Copyright (c) 2016
@@ -32,7 +33,7 @@ function decodeStep(data, encoding) {
                 case 6 /* Uint32 */: return uint32(data);
                 case 32 /* Float32 */: return float32(data);
                 case 33 /* Float64 */: return float64(data);
-                default: throw new Error('Unsupported ByteArray type.');
+                default: (0, type_helpers_1.assertUnreachable)(encoding.type);
             }
         }
         case 'FixedPoint': return fixedPoint(data, encoding);
@@ -51,14 +52,14 @@ function getIntArray(type, size) {
         case 4 /* Uint8 */: return new Uint8Array(size);
         case 5 /* Uint16 */: return new Uint16Array(size);
         case 6 /* Uint32 */: return new Uint32Array(size);
-        default: throw new Error('Unsupported integer data type.');
+        default: (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);
-        default: throw new Error('Unsupported floating data type.');
+        default: (0, type_helpers_1.assertUnreachable)(type);
     }
 }
 function int8(data) { return new Int8Array(data.buffer, data.byteOffset); }

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

@@ -9,6 +9,6 @@ exports.decode = void 0;
 var tslib_1 = require("tslib");
 var decoder_1 = require("./binary-cif/decoder");
 Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return decoder_1.decode; } });
-(0, tslib_1.__exportStar)(require("./binary-cif/encoding"), exports);
-(0, tslib_1.__exportStar)(require("./binary-cif/array-encoder"), exports);
-(0, tslib_1.__exportStar)(require("./binary-cif/classifier"), exports);
+tslib_1.__exportStar(require("./binary-cif/encoding"), exports);
+tslib_1.__exportStar(require("./binary-cif/array-encoder"), exports);
+tslib_1.__exportStar(require("./binary-cif/classifier"), exports);

package/lib/commonjs/mol-io/common/io-buffer.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted and converted to TypeScript from https://github.com/image-js/iobuffer
+ * MIT License, Copyright (c) 2015 Michaël Zasso
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { TypedArray } from '../../mol-util/type-helpers';
+export interface IOBufferParameters {
+    offset?: number;
+}
+/**
+ * Class for writing and reading binary data
+ */
+export declare class IOBuffer {
+    private _lastWrittenByte;
+    private _mark;
+    private _marks;
+    private _data;
+    offset: number;
+    littleEndian: boolean;
+    buffer: ArrayBuffer;
+    length: number;
+    byteLength: number;
+    byteOffset: number;
+    /**
+     * If it's a number, it will initialize the buffer with the number as
+     * the buffer's length. If it's undefined, it will initialize the buffer
+     * with a default length of 8 Kb. If its an ArrayBuffer, a TypedArray,
+     * it will create a view over the underlying ArrayBuffer.
+     */
+    constructor(data: number | ArrayBuffer | TypedArray, params?: IOBufferParameters);
+    /**
+     * Checks if the memory allocated to the buffer is sufficient to store more bytes after the offset
+     * @param byteLength The needed memory in bytes
+     */
+    available(byteLength?: number): boolean;
+    /**
+     * Check if little-endian mode is used for reading and writing multi-byte values
+     * Returns true if little-endian mode is used, false otherwise
+     */
+    isLittleEndian(): boolean;
+    /**
+     * Set little-endian mode for reading and writing multi-byte values
+     */
+    setLittleEndian(): this;
+    /**
+     * Check if big-endian mode is used for reading and writing multi-byte values
+     * Returns true if big-endian mode is used, false otherwise
+     */
+    isBigEndian(): boolean;
+    /**
+     * Switches to big-endian mode for reading and writing multi-byte values
+     */
+    setBigEndian(): this;
+    /**
+     * Move the pointer n bytes forward
+     */
+    skip(n: number): this;
+    /**
+     * Move the pointer to the given offset
+     */
+    seek(offset: number): this;
+    /**
+     * Store the current pointer offset.
+     */
+    mark(): this;
+    /**
+     * Move the pointer back to the last pointer offset set by mark
+     */
+    reset(): this;
+    /**
+     * Push the current pointer offset to the mark stack
+     */
+    pushMark(): this;
+    /**
+     * Pop the last pointer offset from the mark stack, and set the current pointer offset to the popped value
+     */
+    popMark(): this;
+    /**
+     * Move the pointer offset back to 0
+     */
+    rewind(): this;
+    /**
+     * Make sure the buffer has sufficient memory to write a given byteLength at the current pointer offset
+     * If the buffer's memory is insufficient, this method will create a new buffer (a copy) with a length
+     * that is twice (byteLength + current offset)
+     */
+    ensureAvailable(byteLength: number): this;
+    /**
+     * Read a byte and return false if the byte's value is 0, or true otherwise
+     * Moves pointer forward
+     */
+    readBoolean(): boolean;
+    /**
+     * Read a signed 8-bit integer and move pointer forward
+     */
+    readInt8(): number;
+    /**
+     * Read an unsigned 8-bit integer and move pointer forward
+     */
+    readUint8(): number;
+    /**
+     * Alias for {@link IOBuffer#readUint8}
+     */
+    readByte(): number;
+    /**
+     * Read n bytes and move pointer forward.
+     */
+    readBytes(n: number): Uint8Array;
+    /**
+     * Read a 16-bit signed integer and move pointer forward
+     */
+    readInt16(): number;
+    /**
+     * Read a 16-bit unsigned integer and move pointer forward
+     */
+    readUint16(): number;
+    /**
+     * Read a 32-bit signed integer and move pointer forward
+     */
+    readInt32(): number;
+    /**
+     * Read a 32-bit unsigned integer and move pointer forward
+     */
+    readUint32(): number;
+    /**
+     * Read a 32-bit floating number and move pointer forward
+     */
+    readFloat32(): number;
+    /**
+     * Read a 64-bit floating number and move pointer forward
+     */
+    readFloat64(): number;
+    /**
+     * Read 1-byte ascii character and move pointer forward
+     */
+    readChar(): string;
+    /**
+     * Read n 1-byte ascii characters and move pointer forward
+     */
+    readChars(n?: number): string;
+    /**
+     * Write 0xff if the passed value is truthy, 0x00 otherwise
+     */
+    writeBoolean(value?: boolean): this;
+    /**
+     * Write value as an 8-bit signed integer
+     */
+    writeInt8(value: number): this;
+    /**
+     * Write value as a 8-bit unsigned integer
+     */
+    writeUint8(value: number): this;
+    /**
+     * An alias for IOBuffer#writeUint8
+     */
+    writeByte(value: number): this;
+    /**
+     * Write bytes
+     */
+    writeBytes(bytes: number[] | Uint8Array): this;
+    /**
+     * Write value as an 16-bit signed integer
+     */
+    writeInt16(value: number): this;
+    /**
+     * Write value as a 16-bit unsigned integer
+     */
+    writeUint16(value: number): this;
+    /**
+     * Write a 32-bit signed integer at the current pointer offset
+     */
+    writeInt32(value: number): this;
+    /**
+     * Write a 32-bit unsigned integer at the current pointer offset
+     */
+    writeUint32(value: number): this;
+    /**
+     * Write a 32-bit floating number at the current pointer offset
+     */
+    writeFloat32(value: number): this;
+    /**
+     * Write a 64-bit floating number at the current pointer offset
+     */
+    writeFloat64(value: number): this;
+    /**
+     * Write the charCode of the passed string's first character to the current pointer offset
+     */
+    writeChar(str: string): this;
+    /**
+     * Write the charCodes of the passed string's characters to the current pointer offset
+     */
+    writeChars(str: string): this;
+    /**
+     * Export a Uint8Array view of the internal buffer.
+     * The view starts at the byte offset and its length
+     * is calculated to stop at the last written byte or the original length.
+     */
+    toArray(): Uint8Array;
+    /**
+     * Update the last written byte offset
+     */
+    private _updateLastWrittenByte;
+}