molstar 3.0.0-dev.0 → 3.0.0-dev.10

package/lib/mol-repr/volume/representation.d.ts

@@ -38,9 +38,20 @@ export declare function VolumeRepresentationProvider<P extends VolumeParams, Id
 export declare const VolumeParams: {
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
-    material: PD.Converted<import("../../mol-util/material").Material, PD.Normalize<{
+    material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type VolumeParams = typeof VolumeParams;

package/lib/mol-repr/volume/slice.d.ts

@@ -60,9 +60,20 @@ export declare const SliceParams: {
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
-    material: PD.Converted<import("../../mol-util/material").Material, PD.Normalize<{
+    material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type SliceParams = typeof SliceParams;
@@ -115,9 +126,20 @@ export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
-    material: PD.Converted<import("../../mol-util/material").Material, PD.Normalize<{
+    material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare function SliceVisual(materialId: number): VolumeVisual<SliceParams>;
@@ -171,8 +193,19 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
-    material: PD.Converted<import("../../mol-util/material").Material, PD.Normalize<{
+    material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 }, "slice">;

package/lib/mol-repr/volume/slice.js

@@ -15,7 +15,7 @@ import { Interval, SortedArray } from '../../mol-data/int';
 import { transformPositionArray } from '../../mol-geo/util';
 import { Color } from '../../mol-util/color';
 import { ColorTheme } from '../../mol-theme/color';
-import { encodeFloatRGBtoArray } from '../../mol-util/float-packing';
+import { packIntToRGBArray } from '../../mol-util/number-packing';
 import { eachVolumeLoci } from './util';
 export function createImage(ctx, volume, theme, props, image) {
     return __awaiter(this, void 0, void 0, function () {
@@ -99,7 +99,7 @@ function getPackedGroupArray(grid, props) {
     for (var iy = y0; iy < ny; ++iy) {
         for (var ix = x0; ix < nx; ++ix) {
             for (var iz = z0; iz < nz; ++iz) {
-                encodeFloatRGBtoArray(space.dataOffset(ix, iy, iz), groupArray, j);
+                packIntToRGBArray(space.dataOffset(ix, iy, iz), groupArray, j);
                 j += 4;
             }
         }

package/lib/mol-repr/volume/util.js

@@ -7,7 +7,7 @@ import { Volume } from '../../mol-model/volume';
 import { Interval, OrderedSet } from '../../mol-data/int';
 import { equalEps } from '../../mol-math/linear-algebra/3d/common';
 import { Vec3 } from '../../mol-math/linear-algebra/3d/vec3';
-import { encodeFloatRGBtoArray } from '../../mol-util/float-packing';
+import { packIntToRGBArray } from '../../mol-util/number-packing';
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
 var v3set = Vec3.set;
 var v3normalize = Vec3.normalize;
@@ -113,7 +113,7 @@ export function createVolumeTexture2d(volume, variant, padding) {
                 }
                 else {
                     if (variant === 'groups') {
-                        encodeFloatRGBtoArray(offset, array, index);
+                        packIntToRGBArray(offset, array, index);
                     }
                     else {
                         v3set(n0, data[o(Math.max(0, x - 1), y, z)], data[o(x, Math.max(0, y - 1), z)], data[o(x, y, Math.max(0, z - 1))]);

package/lib/mol-state/tree/immutable.d.ts

@@ -29,11 +29,23 @@ declare namespace StateTree {
         readonly map: OrderedSet<Ref>['map'];
         toArray(): Ref[];
         first(): Ref;
+        asMutable(): MutableChildSet;
+    }
+    export interface MutableChildSet extends ChildSet {
+        add(ref: Ref): MutableChildSet;
+        remove(ref: Ref): MutableChildSet;
+        asImmutable(): ChildSet;
     }
     interface _Map<T> {
         readonly size: number;
         has(ref: Ref): boolean;
         get(ref: Ref): T;
+        asImmutable(): _Map<T>;
+        asMutable(): MutableMap<T>;
+    }
+    export interface MutableMap<T> extends _Map<T> {
+        set(ref: Ref, value: T): MutableMap<T>;
+        delete(ref: Ref): MutableMap<T>;
     }
     export interface Transforms extends _Map<StateTransform> {
     }
@@ -41,6 +53,12 @@ declare namespace StateTree {
     }
     export interface Dependencies extends _Map<ChildSet> {
     }
+    export interface MutableTransforms extends MutableMap<StateTransform> {
+    }
+    export interface MutableChildren extends MutableMap<MutableChildSet> {
+    }
+    export interface MutableDependencies extends MutableMap<MutableChildSet> {
+    }
     /**
      * Create an instance of an immutable tree.
      */

package/lib/mol-state/tree/transient.d.ts

@@ -3,15 +3,14 @@
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
-import { Map as ImmutableMap, OrderedSet } from 'immutable';
 import { StateTransform } from '../transform';
 import { StateTree } from './immutable';
 export { TransientTree };
 declare class TransientTree implements StateTree {
     private tree;
-    transforms: ImmutableMap<string, StateTransform<import("../transformer").StateTransformer<import("../object").StateObject<any, import("../object").StateObject.Type<any>>, import("../object").StateObject<any, import("../object").StateObject.Type<any>>, any>>>;
-    children: ImmutableMap<string, OrderedSet<string>>;
-    dependencies: ImmutableMap<string, OrderedSet<string>>;
+    transforms: StateTree.MutableTransforms;
+    children: StateTree.MutableChildren;
+    dependencies: StateTree.MutableDependencies;
     private changedNodes;
     private changedChildren;
     private changedDependencies;

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ export { Clipping };
 declare type Clipping = {
     readonly layers: ReadonlyArray<Clipping.Layer>;
 };
-declare function Clipping(layers: ReadonlyArray<Clipping.Layer>): Clipping;
+declare function Clipping(layers: Clipping['layers']): Clipping;
 declare namespace Clipping {
     type Layer = {
         readonly loci: StructureElement.Loci;
@@ -44,22 +44,14 @@ declare namespace Clipping {
         function fromNames(names: Names[]): Flag;
         function toNames(groups: Groups): Names[];
     }
-    /** Clip object types */
-    const Type: {
-        none: number;
-        plane: number;
-        sphere: number;
-        cube: number;
-        cylinder: number;
-        infiniteCone: number;
-    };
-    type Variant = 'instance' | 'pixel';
     function areEqual(cA: Clipping, cB: Clipping): boolean;
+    /** Check if layers empty */
     function isEmpty(clipping: Clipping): boolean;
-    function remap(clipping: Clipping, structure: Structure): {
-        layers: Layer[];
-    };
+    /** Remap layers */
+    function remap(clipping: Clipping, structure: Structure): Clipping;
+    /** Merge layers */
     function merge(clipping: Clipping): Clipping;
+    /** Filter layers */
     function filter(clipping: Clipping, filter: Structure): Clipping;
     type ScriptLayer = {
         script: Script;

package/lib/mol-theme/clipping.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -69,18 +69,7 @@ function Clipping(layers) {
         }
         Groups.toNames = toNames;
     })(Groups = Clipping.Groups || (Clipping.Groups = {}));
-    /** Clip object types */
-    Clipping.Type = {
-        none: 0,
-        plane: 1,
-        sphere: 2,
-        cube: 3,
-        cylinder: 4,
-        infiniteCone: 5,
-    };
     function areEqual(cA, cB) {
-        if (cA.layers.length === 0 && cB.layers.length === 0)
-            return true;
         if (cA.layers.length !== cB.layers.length)
             return false;
         for (var i = 0, il = cA.layers.length; i < il; ++i) {
@@ -92,10 +81,12 @@ function Clipping(layers) {
         return true;
     }
     Clipping.areEqual = areEqual;
+    /** Check if layers empty */
     function isEmpty(clipping) {
         return clipping.layers.length === 0;
     }
     Clipping.isEmpty = isEmpty;
+    /** Remap layers */
     function remap(clipping, structure) {
         var layers = [];
         for (var _i = 0, _a = clipping.layers; _i < _a.length; _i++) {
@@ -109,6 +100,7 @@ function Clipping(layers) {
         return { layers: layers };
     }
     Clipping.remap = remap;
+    /** Merge layers */
     function merge(clipping) {
         if (isEmpty(clipping))
             return clipping;
@@ -133,6 +125,7 @@ function Clipping(layers) {
         return { layers: layers };
     }
     Clipping.merge = merge;
+    /** Filter layers */
     function filter(clipping, filter) {
         if (isEmpty(clipping))
             return clipping;

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

@@ -1,43 +1,118 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
+import { Color } from '../../mol-util/color';
 import { ColorTheme } from '../color';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const IllustrativeColorThemeParams: {
-    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">;
+    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.Normalize<{
+            water: any;
+            ion: any;
+            protein: any;
+            rna: any;
+            dna: any;
+            pna: any;
+            saccharide: any;
+            lipid: any;
+        }>;
+    }>, "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;
 };
 export declare type IllustrativeColorThemeParams = typeof IllustrativeColorThemeParams;
 export declare function getIllustrativeColorThemeParams(ctx: ThemeDataContext): {
-    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">;
+    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.Normalize<{
+            water: any;
+            ion: any;
+            protein: any;
+            rna: any;
+            dna: any;
+            pna: any;
+            saccharide: any;
+            lipid: any;
+        }>;
+    }>, "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;
 };
 export declare function IllustrativeColorTheme(ctx: ThemeDataContext, props: PD.Values<IllustrativeColorThemeParams>): ColorTheme<IllustrativeColorThemeParams>;
 export declare const IllustrativeColorThemeProvider: ColorTheme.Provider<IllustrativeColorThemeParams, 'illustrative'>;

package/lib/mol-theme/color/illustrative.js

@@ -1,24 +1,43 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-import { __assign } from "tslib";
 import { Color } from '../../mol-util/color';
 import { StructureElement, Unit, Bond } from '../../mol-model/structure';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ChainIdColorTheme, ChainIdColorThemeParams } from './chain-id';
+import { UniformColorTheme, UniformColorThemeParams } from './uniform';
+import { assertUnreachable } from '../../mol-util/type-helpers';
+import { EntityIdColorTheme, EntityIdColorThemeParams } from './entity-id';
+import { MoleculeTypeColorTheme, MoleculeTypeColorThemeParams } from './molecule-type';
+import { EntitySourceColorTheme, EntitySourceColorThemeParams } from './entity-source';
 var DefaultIllustrativeColor = Color(0xEEEEEE);
-var Description = "Assigns an illustrative color that gives every chain a unique color with lighter carbons (inspired by David Goodsell's Molecule of the Month style).";
-export var IllustrativeColorThemeParams = __assign({}, ChainIdColorThemeParams);
+var Description = "Assigns an illustrative color that gives every chain a color based on the choosen style but with lighter carbons (inspired by David Goodsell's Molecule of the Month style).";
+export var IllustrativeColorThemeParams = {
+    style: PD.MappedStatic('entity-id', {
+        uniform: PD.Group(UniformColorThemeParams),
+        'chain-id': PD.Group(ChainIdColorThemeParams),
+        'entity-id': PD.Group(EntityIdColorThemeParams),
+        'entity-source': PD.Group(EntitySourceColorThemeParams),
+        'molecule-type': PD.Group(MoleculeTypeColorThemeParams),
+    }),
+    carbonLightness: PD.Numeric(0.8, { min: -6, max: 6, step: 0.1 })
+};
 export function getIllustrativeColorThemeParams(ctx) {
-    return IllustrativeColorThemeParams; // TODO return copy
+    var params = PD.clone(IllustrativeColorThemeParams);
+    return params;
 }
 export function IllustrativeColorTheme(ctx, props) {
-    var _a = ChainIdColorTheme(ctx, props), chainIdColor = _a.color, legend = _a.legend;
+    var _a = props.style.name === 'uniform' ? UniformColorTheme(ctx, props.style.params) :
+        props.style.name === 'chain-id' ? ChainIdColorTheme(ctx, props.style.params) :
+            props.style.name === 'entity-id' ? EntityIdColorTheme(ctx, props.style.params) :
+                props.style.name === 'entity-source' ? EntitySourceColorTheme(ctx, props.style.params) :
+                    props.style.name === 'molecule-type' ? MoleculeTypeColorTheme(ctx, props.style.params) :
+                        assertUnreachable(props.style), styleColor = _a.color, legend = _a.legend;
     function illustrativeColor(location, typeSymbol) {
-        var baseColor = chainIdColor(location, false);
-        return typeSymbol === 'C' ? Color.lighten(baseColor, 0.8) : baseColor;
+        var baseColor = styleColor(location, false);
+        return typeSymbol === 'C' ? Color.lighten(baseColor, props.carbonLightness) : baseColor;
     }
     function color(location) {
         if (StructureElement.Location.is(location) && Unit.isAtomic(location.unit)) {

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

@@ -1,32 +1,44 @@
 /**
- * Copyright (c) 2018-2019 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 { Color, ColorMap } from '../../mol-util/color';
+import { Color } from '../../mol-util/color';
 import { Unit, ElementIndex } from '../../mol-model/structure';
 import { ColorTheme } from '../color';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
-export declare const MoleculeTypeColors: ColorMap<{
-    water: number;
-    ion: number;
-    protein: number;
-    RNA: number;
-    DNA: number;
-    PNA: number;
-    saccharide: number;
-}>;
-export declare type MoleculeTypeColors = typeof MoleculeTypeColors;
 export declare const MoleculeTypeColorThemeParams: {
     saturation: PD.Numeric;
     lightness: PD.Numeric;
+    colors: PD.Group<PD.Normalize<{
+        water: Color;
+        ion: Color;
+        protein: Color;
+        rna: Color;
+        dna: Color;
+        pna: Color;
+        saccharide: Color;
+        lipid: Color;
+    }>>;
 };
 export declare type MoleculeTypeColorThemeParams = typeof MoleculeTypeColorThemeParams;
 export declare function getMoleculeTypeColorThemeParams(ctx: ThemeDataContext): {
     saturation: PD.Numeric;
     lightness: PD.Numeric;
+    colors: PD.Group<PD.Normalize<{
+        water: Color;
+        ion: Color;
+        protein: Color;
+        rna: Color;
+        dna: Color;
+        pna: Color;
+        saccharide: Color;
+        lipid: Color;
+    }>>;
 };
-export declare function moleculeTypeColor(colorMap: MoleculeTypeColors, unit: Unit, element: ElementIndex): Color;
+declare type MoleculeTypeColorThemeProps = PD.Values<MoleculeTypeColorThemeParams>;
+export declare function moleculeTypeColor(props: MoleculeTypeColorThemeProps, unit: Unit, element: ElementIndex): Color;
 export declare function MoleculeTypeColorTheme(ctx: ThemeDataContext, props: PD.Values<MoleculeTypeColorThemeParams>): ColorTheme<MoleculeTypeColorThemeParams>;
 export declare const MoleculeTypeColorThemeProvider: ColorTheme.Provider<MoleculeTypeColorThemeParams, 'molecule-type'>;
+export {};

package/lib/mol-theme/color/molecule-type.js

@@ -1,53 +1,72 @@
 /**
- * Copyright (c) 2018-2019 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 { Color, ColorMap } from '../../mol-util/color';
+import { Color } from '../../mol-util/color';
 import { StructureElement, Bond } from '../../mol-model/structure';
 import { getElementMoleculeType } from '../../mol-model/structure/util';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { TableLegend } from '../../mol-util/legend';
-import { getAdjustedColorMap } from '../../mol-util/color/color';
-export var MoleculeTypeColors = ColorMap({
-    water: 0x386cb0,
-    ion: 0xf0027f,
-    protein: 0xbeaed4,
-    RNA: 0xfdc086,
-    DNA: 0xbf5b17,
-    PNA: 0x42A49A,
-    saccharide: 0x7fc97f,
-});
 var DefaultMoleculeTypeColor = Color(0xffff99);
 var Description = 'Assigns a color based on the molecule type of a residue.';
 export var MoleculeTypeColorThemeParams = {
     saturation: PD.Numeric(0, { min: -6, max: 6, step: 0.1 }),
-    lightness: PD.Numeric(0, { min: -6, max: 6, step: 0.1 })
+    lightness: PD.Numeric(0, { min: -6, max: 6, step: 0.1 }),
+    colors: PD.Group({
+        water: PD.Color(Color(0x386cb0)),
+        ion: PD.Color(Color(0xf0027f)),
+        protein: PD.Color(Color(0xbeaed4)),
+        rna: PD.Color(Color(0xfdc086)),
+        dna: PD.Color(Color(0xbf5b17)),
+        pna: PD.Color(Color(0x42A49A)),
+        saccharide: PD.Color(Color(0x7fc97f)),
+        lipid: PD.Color(Color(0xcccccc)),
+    })
 };
 export function getMoleculeTypeColorThemeParams(ctx) {
     return MoleculeTypeColorThemeParams; // TODO return copy
 }
-export function moleculeTypeColor(colorMap, unit, element) {
+export function moleculeTypeColor(props, unit, element) {
+    var c = DefaultMoleculeTypeColor;
     var moleculeType = getElementMoleculeType(unit, element);
     switch (moleculeType) {
-        case 2 /* Water */: return colorMap.water;
-        case 3 /* Ion */: return colorMap.ion;
-        case 5 /* Protein */: return colorMap.protein;
-        case 6 /* RNA */: return colorMap.RNA;
-        case 7 /* DNA */: return colorMap.DNA;
-        case 8 /* PNA */: return colorMap.PNA;
-        case 9 /* Saccharide */: return colorMap.saccharide;
+        case 2 /* Water */:
+            c = props.colors.water;
+            break;
+        case 3 /* Ion */:
+            c = props.colors.ion;
+            break;
+        case 5 /* Protein */:
+            c = props.colors.protein;
+            break;
+        case 6 /* RNA */:
+            c = props.colors.rna;
+            break;
+        case 7 /* DNA */:
+            c = props.colors.dna;
+            break;
+        case 8 /* PNA */:
+            c = props.colors.pna;
+            break;
+        case 9 /* Saccharide */:
+            c = props.colors.saccharide;
+            break;
+        case 4 /* Lipid */:
+            c = props.colors.lipid;
+            break;
     }
-    return DefaultMoleculeTypeColor;
+    c = Color.saturate(c, props.saturation);
+    c = Color.darken(c, -props.lightness);
+    return c;
 }
 export function MoleculeTypeColorTheme(ctx, props) {
-    var colorMap = getAdjustedColorMap(MoleculeTypeColors, props.saturation, props.lightness);
     function color(location) {
         if (StructureElement.Location.is(location)) {
-            return moleculeTypeColor(colorMap, location.unit, location.element);
+            return moleculeTypeColor(props, location.unit, location.element);
         }
         else if (Bond.isLocation(location)) {
-            return moleculeTypeColor(colorMap, location.aUnit, location.aUnit.elements[location.aIndex]);
+            return moleculeTypeColor(props, location.aUnit, location.aUnit.elements[location.aIndex]);
         }
         return DefaultMoleculeTypeColor;
     }
@@ -57,8 +76,8 @@ export function MoleculeTypeColorTheme(ctx, props) {
         color: color,
         props: props,
         description: Description,
-        legend: TableLegend(Object.keys(MoleculeTypeColors).map(function (name) {
-            return [name, MoleculeTypeColors[name]];
+        legend: TableLegend(Object.keys(props.colors).map(function (name) {
+            return [name, props.colors[name]];
         }).concat([['Other/unknown', DefaultMoleculeTypeColor]]))
     };
 }