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

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

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ColorTheme } from '../color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ThemeDataContext } from '../theme';
+export declare const VolumeValueColorThemeParams: {
+    colorList: PD.ColorList;
+};
+export declare type VolumeValueColorThemeParams = typeof VolumeValueColorThemeParams;
+export declare function getVolumeValueColorThemeParams(ctx: ThemeDataContext): {
+    colorList: PD.ColorList;
+};
+export declare function VolumeValueColorTheme(ctx: ThemeDataContext, props: PD.Values<VolumeValueColorThemeParams>): ColorTheme<VolumeValueColorThemeParams>;
+export declare const VolumeValueColorThemeProvider: ColorTheme.Provider<VolumeValueColorThemeParams, 'volume-value'>;

package/lib/mol-theme/color/volume-value.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Color, ColorScale } from '../../mol-util/color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ColorNames } from '../../mol-util/color/names';
+var DefaultColor = Color(0xCCCCCC);
+var Description = 'Assign color based on the given value of a volume cell.';
+export var VolumeValueColorThemeParams = {
+    colorList: PD.ColorList({
+        kind: 'interpolate',
+        colors: [
+            [ColorNames.white, 0],
+            [ColorNames.red, 0.25],
+            [ColorNames.white, 0.5],
+            [ColorNames.blue, 0.75],
+            [ColorNames.white, 1]
+        ]
+    }, { offsets: true, isEssential: true }),
+};
+export function getVolumeValueColorThemeParams(ctx) {
+    return VolumeValueColorThemeParams; // TODO return copy
+}
+export function VolumeValueColorTheme(ctx, props) {
+    var scale = ColorScale.create({ domain: [0, 1], listOrName: props.colorList.colors });
+    var colors = [];
+    for (var i = 0; i < 256; ++i) {
+        colors[i] = scale.color(i / 255);
+    }
+    var palette = { colors: colors, filter: 'linear' };
+    return {
+        factory: VolumeValueColorTheme,
+        granularity: 'direct',
+        color: function () { return DefaultColor; },
+        props: props,
+        description: Description,
+        legend: scale.legend,
+        palette: palette,
+    };
+}
+export var VolumeValueColorThemeProvider = {
+    name: 'volume-value',
+    label: 'Volume Value',
+    category: "Miscellaneous" /* Misc */,
+    factory: VolumeValueColorTheme,
+    getParams: getVolumeValueColorThemeParams,
+    defaultValues: PD.getDefaultValues(VolumeValueColorThemeParams),
+    isApplicable: function (ctx) { return !!ctx.volume; },
+};
+//# sourceMappingURL=volume-value.js.map

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

@@ -164,20 +164,57 @@ declare namespace ColorTheme {
             scale: PD.Select<"DGwif" | "DGwoct" | "Oct-IF">;
         }, "hydrophobicity">;
         illustrative: Provider<{
-            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;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -197,6 +234,16 @@ declare namespace ColorTheme {
         'molecule-type': Provider<{
             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;
+            }>>;
         }, "molecule-type">;
         occupancy: Provider<{
             domain: PD.Interval;
@@ -300,6 +347,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-theme/substance.js

@@ -7,6 +7,7 @@ import { Loci } from '../mol-model/loci';
 import { StructureElement } from '../mol-model/structure';
 import { Script } from '../mol-script/script';
 import { Material } from '../mol-util/material';
+import { shallowEqual } from '../mol-util/object';
 export { Substance };
 function Substance(layers) {
     return { layers: layers };
@@ -21,7 +22,7 @@ function Substance(layers) {
         for (var i = 0, il = sA.layers.length; i < il; ++i) {
             if (sA.layers[i].clear !== sB.layers[i].clear)
                 return false;
-            if (sA.layers[i].material !== sB.layers[i].material)
+            if (!shallowEqual(sA.layers[i].material, sB.layers[i].material))
                 return false;
             if (!Loci.areEqual(sA.layers[i].loci, sB.layers[i].loci))
                 return false;
@@ -50,6 +51,7 @@ function Substance(layers) {
         if (isEmpty(substance))
             return substance;
         var structure = substance.layers[0].loci.structure;
+        var clearLoci = void 0;
         var map = new Map();
         var shadowed = StructureElement.Loci.none(structure);
         for (var i = 0, il = substance.layers.length; i < il; ++i) {
@@ -57,18 +59,25 @@ function Substance(layers) {
             loci = StructureElement.Loci.subtract(loci, shadowed);
             shadowed = StructureElement.Loci.union(loci, shadowed);
             if (!StructureElement.Loci.isEmpty(loci)) {
-                var materialOrClear = clear ? -1 : material;
-                if (map.has(materialOrClear)) {
-                    loci = StructureElement.Loci.union(loci, map.get(materialOrClear));
+                if (clear) {
+                    clearLoci = clearLoci
+                        ? StructureElement.Loci.union(loci, clearLoci)
+                        : loci;
+                }
+                else {
+                    if (map.has(material)) {
+                        loci = StructureElement.Loci.union(loci, map.get(material));
+                    }
+                    map.set(material, loci);
                 }
-                map.set(materialOrClear, loci);
             }
         }
         var layers = [];
-        map.forEach(function (loci, materialOrClear) {
-            var clear = materialOrClear === -1;
-            var material = clear ? Material(0) : materialOrClear;
-            layers.push({ loci: loci, material: material, clear: clear });
+        if (clearLoci) {
+            layers.push({ loci: clearLoci, material: Material(), clear: true });
+        }
+        map.forEach(function (loci, material) {
+            layers.push({ loci: loci, material: material, clear: false });
         });
         return { layers: layers };
     }

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/material.d.ts

@@ -5,28 +5,29 @@
  */
 import { NumberArray } from './type-helpers';
 import { ParamDefinition as PD } from './param-definition';
-/** Material properties expressed as a single number */
-export declare type Material = {
-    readonly '@type': 'material';
-} & number;
-export declare function Material(hex: number): Material;
+export interface Material {
+    /** Normalized to [0, 1] range */
+    metalness: number;
+    /** Normalized to [0, 1] range */
+    roughness: number;
+    /** Normalized to [0, 1] range */
+    bumpiness: number;
+}
+export declare function Material(values?: Partial<Material>): {
+    metalness: number;
+    roughness: number;
+    bumpiness: number;
+};
 export declare namespace Material {
-    function fromNormalized(metalness: number, roughness: number): Material;
-    function fromObjectNormalized(v: {
-        metalness: number;
-        roughness: number;
-    }): Material;
-    function toObjectNormalized(material: Material, fractionDigits?: number): {
-        metalness: number;
-        roughness: number;
-    };
+    const Zero: Material;
     function toArray(material: Material, array: NumberArray, offset: number): NumberArray;
-    function toString(material: Material): string;
+    function toString({ metalness, roughness, bumpiness }: Material): string;
     function getParam(info?: {
         isExpanded?: boolean;
         isFlat?: boolean;
-    }): PD.Converted<Material, PD.Normalize<{
+    }): PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 }

package/lib/mol-util/material.js

@@ -3,44 +3,36 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
+import { __assign } from "tslib";
 import { ParamDefinition as PD } from './param-definition';
-import { toFixed } from './number';
-export function Material(hex) { return hex; }
+export function Material(values) {
+    return __assign(__assign({}, Material.Zero), values);
+}
 (function (Material) {
-    function fromNormalized(metalness, roughness) {
-        return (((metalness * 255) << 16) | ((roughness * 255) << 8));
-    }
-    Material.fromNormalized = fromNormalized;
-    function fromObjectNormalized(v) {
-        return fromNormalized(v.metalness, v.roughness);
-    }
-    Material.fromObjectNormalized = fromObjectNormalized;
-    function toObjectNormalized(material, fractionDigits) {
-        var metalness = (material >> 16 & 255) / 255;
-        var roughness = (material >> 8 & 255) / 255;
-        return {
-            metalness: fractionDigits ? toFixed(metalness, fractionDigits) : metalness,
-            roughness: fractionDigits ? toFixed(roughness, fractionDigits) : roughness
-        };
-    }
-    Material.toObjectNormalized = toObjectNormalized;
+    Material.Zero = { metalness: 0, roughness: 0, bumpiness: 0 };
     function toArray(material, array, offset) {
-        array[offset] = (material >> 16 & 255);
-        array[offset + 1] = (material >> 8 & 255);
+        array[offset] = material.metalness * 255;
+        array[offset + 1] = material.roughness * 255;
+        array[offset + 2] = material.bumpiness * 255;
         return array;
     }
     Material.toArray = toArray;
-    function toString(material) {
-        var metalness = (material >> 16 & 255) / 255;
-        var roughness = (material >> 8 & 255) / 255;
-        return "M ".concat(metalness, " | R ").concat(roughness);
+    function toString(_a) {
+        var metalness = _a.metalness, roughness = _a.roughness, bumpiness = _a.bumpiness;
+        return "M ".concat(metalness.toFixed(2), " | R ").concat(roughness.toFixed(2), " | B ").concat(bumpiness.toFixed(2));
     }
     Material.toString = toString;
     function getParam(info) {
-        return PD.Converted(function (v) { return toObjectNormalized(v, 2); }, function (v) { return fromObjectNormalized(v); }, PD.Group({
+        return PD.Group({
             metalness: PD.Numeric(0, { min: 0, max: 1, step: 0.01 }),
             roughness: PD.Numeric(1, { min: 0, max: 1, step: 0.01 }),
-        }, info));
+            bumpiness: PD.Numeric(0, { min: 0, max: 1, step: 0.01 }),
+        }, __assign(__assign({}, info), { presets: [
+                [{ metalness: 0, roughness: 1, bumpiness: 0 }, 'Matte'],
+                [{ metalness: 0, roughness: 0.2, bumpiness: 0 }, 'Plastic'],
+                [{ metalness: 0, roughness: 0.6, bumpiness: 0 }, 'Glossy'],
+                [{ metalness: 1.0, roughness: 0.6, bumpiness: 0 }, 'Metallic'],
+            ] }));
     }
     Material.getParam = getParam;
 })(Material || (Material = {}));

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/lib/mol-util/param-definition.d.ts

@@ -165,6 +165,7 @@ export declare namespace ParamDefinition {
     export interface Group<T> extends Base<T> {
         type: 'group';
         params: Params;
+        presets?: Select<T>['options'];
         isExpanded?: boolean;
         isFlat?: boolean;
         pivot?: keyof T;
@@ -174,6 +175,7 @@ export declare namespace ParamDefinition {
         isFlat?: boolean;
         customDefault?: any;
         pivot?: keyof T;
+        presets?: Select<T>['options'];
     }): Group<Normalize<T>>;
     export function EmptyGroup(info?: Info): Group<Normalize<unknown>>;
     export interface NamedParams<T = any, K = string> {

package/lib/mol-util/param-definition.js

@@ -147,6 +147,8 @@ export var ParamDefinition;
     ParamDefinition.LineGraph = LineGraph;
     function Group(params, info) {
         var ret = setInfo({ type: 'group', defaultValue: (info === null || info === void 0 ? void 0 : info.customDefault) || getDefaultValues(params), params: params }, info);
+        if (info === null || info === void 0 ? void 0 : info.presets)
+            ret.presets = info.presets;
         if (info === null || info === void 0 ? void 0 : info.isExpanded)
             ret.isExpanded = info.isExpanded;
         if (info === null || info === void 0 ? void 0 : info.isFlat)