molstar 3.0.0-dev.6 → 3.0.0

package/lib/mol-theme/color.d.ts

@@ -128,6 +128,127 @@ declare namespace ColorTheme {
             }>, "operator-name">>;
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                H: Color;
+                D: Color;
+                T: Color;
+                HE: Color;
+                LI: Color;
+                BE: Color;
+                B: Color;
+                C: Color;
+                N: Color;
+                O: Color;
+                F: Color;
+                NE: Color;
+                NA: Color;
+                MG: Color;
+                AL: Color;
+                SI: Color;
+                P: Color;
+                S: Color;
+                CL: Color;
+                AR: Color;
+                K: Color;
+                CA: Color;
+                SC: Color;
+                TI: Color;
+                V: Color;
+                CR: Color;
+                MN: Color;
+                FE: Color;
+                CO: Color;
+                NI: Color;
+                CU: Color;
+                ZN: Color;
+                GA: Color;
+                GE: Color;
+                AS: Color;
+                SE: Color;
+                BR: Color;
+                KR: Color;
+                RB: Color;
+                SR: Color;
+                Y: Color;
+                ZR: Color;
+                NB: Color;
+                MO: Color;
+                TC: Color;
+                RU: Color;
+                RH: Color;
+                PD: Color;
+                AG: Color;
+                CD: Color;
+                IN: Color;
+                SN: Color;
+                SB: Color;
+                TE: Color;
+                I: Color;
+                XE: Color;
+                CS: Color;
+                BA: Color;
+                LA: Color;
+                CE: Color;
+                PR: Color;
+                ND: Color;
+                PM: Color;
+                SM: Color;
+                EU: Color;
+                GD: Color;
+                TB: Color;
+                DY: Color;
+                HO: Color;
+                ER: Color;
+                TM: Color;
+                YB: Color;
+                LU: Color;
+                HF: Color;
+                TA: Color;
+                W: Color;
+                RE: Color;
+                OS: Color;
+                IR: Color;
+                PT: Color;
+                AU: Color;
+                HG: Color;
+                TL: Color;
+                PB: Color;
+                BI: Color;
+                PO: Color;
+                AT: Color;
+                RN: Color;
+                FR: Color;
+                RA: Color;
+                AC: Color;
+                TH: Color;
+                PA: Color;
+                U: Color;
+                NP: Color;
+                PU: Color;
+                AM: Color;
+                CM: Color;
+                BK: Color;
+                CF: Color;
+                ES: Color;
+                FM: Color;
+                MD: Color;
+                NO: Color;
+                LR: Color;
+                RF: Color;
+                DB: Color;
+                SG: Color;
+                BH: Color;
+                HS: Color;
+                MT: Color;
+                DS: Color;
+                RG: Color;
+                CN: Color;
+                UUT: Color;
+                FL: Color;
+                UUP: Color;
+                LV: Color;
+                UUH: Color;
+            }>, "custom">>;
         }, "element-symbol">;
         'entity-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -164,21 +285,56 @@ declare namespace ColorTheme {
             scale: PD.Select<"DGwif" | "DGwoct" | "Oct-IF">;
         }, "hydrophobicity">;
         illustrative: Provider<{
+            style: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                value: Color;
+            }>, "uniform"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+                asymId: "label" | "auth";
+            }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
+                saturation: number;
+                lightness: number;
+                colors: PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                    water: any;
+                    ion: any;
+                    protein: any;
+                    RNA: any;
+                    DNA: any;
+                    PNA: any;
+                    saccharide: any;
+                }>, "custom">;
+            }>, "molecule-type"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-source"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-id">>;
             carbonLightness: PD.Numeric;
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                maxCount: number;
-                hue: [number, number];
-                chroma: [number, number];
-                luminance: [number, number];
-                clusteringStepCount: number;
-                minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
-            asymId: PD.Select<"label" | "auth">;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -198,6 +354,15 @@ declare namespace ColorTheme {
         'molecule-type': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                water: Color;
+                ion: Color;
+                protein: Color;
+                RNA: Color;
+                DNA: Color;
+                PNA: Color;
+                saccharide: Color;
+            }>, "custom">>;
         }, "molecule-type">;
         occupancy: Provider<{
             domain: PD.Interval;
@@ -270,10 +435,61 @@ declare namespace ColorTheme {
         'residue-name': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                ALA: Color;
+                ARG: Color;
+                ASN: Color;
+                ASP: Color;
+                CYS: Color;
+                GLN: Color;
+                GLU: Color;
+                GLY: Color;
+                HIS: Color;
+                ILE: Color;
+                LEU: Color;
+                LYS: Color;
+                MET: Color;
+                PHE: Color;
+                PRO: Color;
+                SER: Color;
+                THR: Color;
+                TRP: Color;
+                TYR: Color;
+                VAL: Color;
+                A: Color;
+                G: Color;
+                I: Color;
+                C: Color;
+                T: Color;
+                U: Color;
+                DA: Color;
+                DG: Color;
+                DI: Color;
+                DC: Color;
+                DT: Color;
+                DU: Color;
+                APN: Color;
+                GPN: Color;
+                CPN: Color;
+                TPN: Color;
+            }>, "custom">>;
         }, "residue-name">;
         'secondary-structure': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                alphaHelix: Color;
+                threeTenHelix: Color;
+                piHelix: Color;
+                betaTurn: Color;
+                betaStrand: Color;
+                coil: Color;
+                bend: Color;
+                turn: Color;
+                dna: Color;
+                rna: Color;
+                carbohydrate: Color;
+            }>, "custom">>;
         }, "secondary-structure">;
         'sequence-id': Provider<{
             list: PD.ColorList;
@@ -301,6 +517,9 @@ declare namespace ColorTheme {
         uniform: Provider<{
             value: PD.Color;
         }, "uniform">;
+        'volume-value': Provider<{
+            colorList: PD.ColorList;
+        }, "volume-value">;
     };
     type _BuiltIn = typeof BuiltIn;
     export type BuiltIn = keyof _BuiltIn;

package/lib/mol-theme/color.js

@@ -30,6 +30,7 @@ import { OperatorHklColorThemeProvider } from './color/operator-hkl';
 import { PartialChargeColorThemeProvider } from './color/partial-charge';
 import { AtomIdColorThemeProvider } from './color/atom-id';
 import { EntityIdColorThemeProvider } from './color/entity-id';
+import { VolumeValueColorThemeProvider } from './color/volume-value';
 export { ColorTheme };
 var ColorTheme;
 (function (ColorTheme) {
@@ -76,6 +77,7 @@ var ColorTheme;
         'uncertainty': UncertaintyColorThemeProvider,
         'unit-index': UnitIndexColorThemeProvider,
         'uniform': UniformColorThemeProvider,
+        'volume-value': VolumeValueColorThemeProvider,
     };
 })(ColorTheme || (ColorTheme = {}));
 export function ColorThemeProvider(p) { return p; }

package/lib/mol-util/clip.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Vec3 } from '../mol-math/linear-algebra';
+import { ParamDefinition as PD } from './param-definition';
+export interface Clip {
+    variant: Clip.Variant;
+    objects: Clip.Objects;
+}
+export declare function Clip(): void;
+export declare namespace Clip {
+    /** Clip object types */
+    const Type: {
+        none: number;
+        plane: number;
+        sphere: number;
+        cube: number;
+        cylinder: number;
+        infiniteCone: number;
+    };
+    type Variant = 'instance' | 'pixel';
+    type Objects = {
+        count: number;
+        type: number[];
+        invert: boolean[];
+        position: number[];
+        rotation: number[];
+        scale: number[];
+    };
+    const Params: {
+        variant: PD.Select<Variant>;
+        objects: PD.ObjectList<PD.Normalize<{
+            type: "none" | "sphere" | "cube" | "plane" | "cylinder" | "infiniteCone";
+            invert: boolean;
+            position: Vec3;
+            rotation: PD.Normalize<{
+                axis: any;
+                angle: any;
+            }>;
+            scale: Vec3;
+        }>>;
+    };
+    type Params = typeof Params;
+    type Props = PD.Values<Params>;
+    function getClip(props: Props, clip?: Clip): Clip;
+    function areEqual(cA: Clip, cB: Clip): boolean;
+}

package/lib/mol-util/clip.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Quat, Vec3 } from '../mol-math/linear-algebra';
+import { degToRad } from '../mol-math/misc';
+import { ParamDefinition as PD } from './param-definition';
+import { stringToWords } from './string';
+export function Clip() {
+}
+(function (Clip) {
+    /** Clip object types */
+    Clip.Type = {
+        none: 0,
+        plane: 1,
+        sphere: 2,
+        cube: 3,
+        cylinder: 4,
+        infiniteCone: 5,
+    };
+    Clip.Params = {
+        variant: PD.Select('pixel', PD.arrayToOptions(['instance', 'pixel'])),
+        objects: PD.ObjectList({
+            type: PD.Select('plane', PD.objectToOptions(Clip.Type, function (t) { return stringToWords(t); })),
+            invert: PD.Boolean(false),
+            position: PD.Vec3(Vec3()),
+            rotation: PD.Group({
+                axis: PD.Vec3(Vec3.create(1, 0, 0)),
+                angle: PD.Numeric(0, { min: -180, max: 180, step: 1 }, { description: 'Angle in Degrees' }),
+            }, { isExpanded: true }),
+            scale: PD.Vec3(Vec3.create(1, 1, 1)),
+        }, function (o) { return stringToWords(o.type); })
+    };
+    function createClipObjects() {
+        return {
+            count: 0,
+            type: (new Array(5)).fill(1),
+            invert: (new Array(5)).fill(false),
+            position: (new Array(5 * 3)).fill(0),
+            rotation: (new Array(5 * 4)).fill(0),
+            scale: (new Array(5 * 3)).fill(1),
+        };
+    }
+    var qA = Quat();
+    var qB = Quat();
+    var vA = Vec3();
+    var vB = Vec3();
+    function getClip(props, clip) {
+        var _a = (clip === null || clip === void 0 ? void 0 : clip.objects) || createClipObjects(), type = _a.type, invert = _a.invert, position = _a.position, rotation = _a.rotation, scale = _a.scale;
+        for (var i = 0, il = props.objects.length; i < il; ++i) {
+            var p = props.objects[i];
+            type[i] = Clip.Type[p.type];
+            invert[i] = p.invert;
+            Vec3.toArray(p.position, position, i * 3);
+            Quat.toArray(Quat.setAxisAngle(qA, p.rotation.axis, degToRad(p.rotation.angle)), rotation, i * 4);
+            Vec3.toArray(p.scale, scale, i * 3);
+        }
+        return {
+            variant: props.variant,
+            objects: { count: props.objects.length, type: type, invert: invert, position: position, rotation: rotation, scale: scale }
+        };
+    }
+    Clip.getClip = getClip;
+    function areEqual(cA, cB) {
+        if (cA.variant !== cB.variant)
+            return false;
+        if (cA.objects.count !== cB.objects.count)
+            return false;
+        var oA = cA.objects, oB = cB.objects;
+        for (var i = 0, il = oA.count; i < il; ++i) {
+            if (oA.invert[i] !== oB.invert[i])
+                return false;
+            if (oA.type[i] !== oB.type[i])
+                return false;
+            Vec3.fromArray(vA, oA.position, i * 3);
+            Vec3.fromArray(vB, oB.position, i * 3);
+            if (!Vec3.equals(vA, vB))
+                return false;
+            Vec3.fromArray(vA, oA.scale, i * 3);
+            Vec3.fromArray(vB, oB.scale, i * 3);
+            if (!Vec3.equals(vA, vB))
+                return false;
+            Quat.fromArray(qA, oA.rotation, i * 4);
+            Quat.fromArray(qB, oB.rotation, i * 4);
+            if (!Quat.equals(qA, qB))
+                return false;
+        }
+        return true;
+    }
+    Clip.areEqual = areEqual;
+})(Clip || (Clip = {}));
+//# sourceMappingURL=clip.js.map

package/lib/mol-util/color/color.d.ts

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

package/lib/mol-util/color/color.js

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

package/lib/mol-util/color/params.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ColorMap } from './color';
+export declare function getColorMapParams<T extends {
+    [k: string]: number;
+}>(map: ColorMap<T>): { [k in keyof T]: PD.Color; };

package/lib/mol-util/color/params.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { objectForEach } from '../object';
+export function getColorMapParams(map) {
+    var colors = {};
+    objectForEach(map, function (_, k) {
+        colors[k] = PD.Color(map[k]);
+    });
+    return colors;
+}
+//# sourceMappingURL=params.js.map

package/lib/mol-util/number-packing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { NumberArray } from './type-helpers';
+/** encode positive integer as rgb byte triplet into array at offset */
+export declare function packIntToRGBArray(value: number, array: NumberArray, offset: number): NumberArray;
+/** decode positive integer encoded as rgb byte triplet */
+export declare function unpackRGBToInt(r: number, g: number, b: number): number;
+export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;

package/lib/mol-util/{float-packing.js → number-packing.js}

@@ -1,20 +1,13 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { clamp } from '../mol-math/interpolate';
-import { fasterExp, fasterLog } from '../mol-math/approx';
 import { Vec3, Vec4 } from '../mol-math/linear-algebra';
-var maxFloat = 10000.0; // NOTE same constant is set in shaders
-var floatLogFactor = fasterLog(maxFloat + 1);
-/** encode float logarithmically */
-export function encodeFloatLog(value) { return fasterLog(value + 1) / floatLogFactor; }
-/** decode logarithmically encoded float */
-export function decodeFloatLog(value) { return fasterExp(value * floatLogFactor) - 1; }
-/** encode float as rgb triplet into array at offset */
-export function encodeFloatRGBtoArray(value, array, offset) {
-    value = clamp(value, 0, 16777216 - 1) + 1;
+/** encode positive integer as rgb byte triplet into array at offset */
+export function packIntToRGBArray(value, array, offset) {
+    value = clamp(Math.round(value), 0, 16777216 - 1) + 1;
     array[offset + 2] = value % 256;
     value = Math.floor(value / 256);
     array[offset + 1] = value % 256;
@@ -22,8 +15,8 @@ export function encodeFloatRGBtoArray(value, array, offset) {
     array[offset] = value % 256;
     return array;
 }
-/** decode float encoded as rgb triplet */
-export function decodeFloatRGB(r, g, b) {
+/** decode positive integer encoded as rgb byte triplet */
+export function unpackRGBToInt(r, g, b) {
     return (Math.floor(r) * 256 * 256 + Math.floor(g) * 256 + Math.floor(b)) - 1;
 }
 var UnpackDownscale = 255 / 256; // 0..1 -> fraction (excluding 1)
@@ -34,4 +27,4 @@ export function unpackRGBAToDepth(r, g, b, a) {
     Vec4.set(tmpDepthRGBA, r / 255, g / 255, b / 255, a / 255);
     return Vec4.dot(tmpDepthRGBA, UnpackFactors);
 }
-//# sourceMappingURL=float-packing.js.map
+//# sourceMappingURL=number-packing.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "molstar",
-  "version": "3.0.0-dev.6",
+  "version": "3.0.0",
   "description": "A comprehensive macromolecular library.",
   "homepage": "https://github.com/molstar/molstar#readme",
   "repository": {
@@ -86,45 +86,46 @@
     "Áron Samuel Kovács <aron.kovacs@mail.muni.cz>",
     "Ludovic Autin <autin@scripps.edu>",
     "Michal Malý <michal.maly@ibt.cas.cz>",
-    "Jiří Černý <jiri.cerny@ibt.cas.cz>"
+    "Jiří Černý <jiri.cerny@ibt.cas.cz>",
+    "Panagiotis Tourlas <panagiot_tourlov@hotmail.com>"
   ],
   "license": "MIT",
   "devDependencies": {
-    "@graphql-codegen/add": "^3.1.0",
-    "@graphql-codegen/cli": "^2.3.0",
-    "@graphql-codegen/time": "^3.1.0",
-    "@graphql-codegen/typescript": "^2.4.1",
-    "@graphql-codegen/typescript-graphql-files-modules": "^2.1.0",
-    "@graphql-codegen/typescript-graphql-request": "^4.3.1",
-    "@graphql-codegen/typescript-operations": "^2.2.1",
+    "@graphql-codegen/add": "^3.1.1",
+    "@graphql-codegen/cli": "^2.4.0",
+    "@graphql-codegen/time": "^3.1.1",
+    "@graphql-codegen/typescript": "^2.4.2",
+    "@graphql-codegen/typescript-graphql-files-modules": "^2.1.1",
+    "@graphql-codegen/typescript-graphql-request": "^4.3.3",
+    "@graphql-codegen/typescript-operations": "^2.2.2",
     "@types/cors": "^2.8.12",
     "@types/gl": "^4.1.0",
-    "@types/jest": "^27.0.3",
-    "@typescript-eslint/eslint-plugin": "^5.5.0",
-    "@typescript-eslint/parser": "^5.5.0",
+    "@types/jest": "^27.4.0",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
     "benchmark": "^2.1.4",
-    "concurrently": "^6.4.0",
-    "cpx2": "^4.0.0",
+    "concurrently": "^7.0.0",
+    "cpx2": "^4.1.2",
     "crypto-browserify": "^3.12.0",
     "css-loader": "^6.5.1",
-    "eslint": "^8.3.0",
+    "eslint": "^8.7.0",
     "extra-watch-webpack-plugin": "^1.0.3",
     "file-loader": "^6.2.0",
     "fs-extra": "^10.0.0",
-    "graphql": "^15.7.2",
-    "http-server": "^14.0.0",
-    "jest": "^27.3.1",
-    "mini-css-extract-plugin": "^2.4.5",
+    "graphql": "^16.2.0",
+    "http-server": "^14.1.0",
+    "jest": "^27.4.7",
+    "mini-css-extract-plugin": "^2.5.2",
     "path-browserify": "^1.0.1",
     "raw-loader": "^4.0.2",
-    "sass": "^1.43.5",
-    "sass-loader": "^12.3.0",
-    "simple-git": "^2.47.0",
+    "sass": "^1.49.0",
+    "sass-loader": "^12.4.0",
+    "simple-git": "^2.48.0",
     "stream-browserify": "^3.0.0",
     "style-loader": "^3.3.1",
-    "ts-jest": "^27.0.7",
-    "typescript": "^4.5.2",
-    "webpack": "^5.64.4",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.5.5",
+    "webpack": "^5.67.0",
     "webpack-cli": "^4.9.1"
   },
   "dependencies": {
@@ -132,22 +133,22 @@
     "@types/benchmark": "^2.1.1",
     "@types/compression": "1.7.2",
     "@types/express": "^4.17.13",
-    "@types/node": "^16.11.10",
+    "@types/node": "^16.11.21",
     "@types/node-fetch": "^2.5.12",
-    "@types/react": "^17.0.37",
+    "@types/react": "^17.0.38",
     "@types/react-dom": "^17.0.11",
     "@types/swagger-ui-dist": "3.30.1",
     "argparse": "^2.0.1",
-    "body-parser": "^1.19.0",
+    "body-parser": "^1.19.1",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
-    "express": "^4.17.1",
+    "express": "^4.17.2",
     "h264-mp4-encoder": "^1.0.12",
-    "immer": "^9.0.7",
-    "immutable": "^3.8.2",
-    "node-fetch": "^2.6.2",
-    "rxjs": "^7.4.0",
-    "swagger-ui-dist": "^4.1.1",
+    "immer": "^9.0.12",
+    "immutable": "^4.0.0",
+    "node-fetch": "^2.6.7",
+    "rxjs": "^7.5.2",
+    "swagger-ui-dist": "^4.2.1",
     "tslib": "^2.3.1",
     "util.promisify": "^1.1.1",
     "xhr2": "^0.2.1"
@@ -157,6 +158,6 @@
     "react-dom": "^17.0.2"
   },
   "optionalDependencies": {
-    "gl": "^4.9.2"
+    "gl": "^5.0.0"
   }
 }

package/lib/commonjs/mol-util/float-packing.d.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-import { NumberArray } from './type-helpers';
-/** encode float logarithmically */
-export declare function encodeFloatLog(value: number): number;
-/** decode logarithmically encoded float */
-export declare function decodeFloatLog(value: number): number;
-/** encode float as rgb triplet into array at offset */
-export declare function encodeFloatRGBtoArray(value: number, array: NumberArray, offset: number): NumberArray;
-/** decode float encoded as rgb triplet */
-export declare function decodeFloatRGB(r: number, g: number, b: number): number;
-export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;