@czi-sds/data-viz 2.4.3 → 2.5.1

package/dist/shared/renderStructureImage.esm.js

@@ -0,0 +1,2157 @@
+"use client";
+import { n as _objectWithoutProperties, t as _objectSpread2 } from "./objectSpread2.esm.js";
+import { n as sampleColorScale, r as sampleSteppedScale, t as PLASMA_COLOR_SCALE } from "./colorScales.esm.js";
+import { Vec3 } from "molstar/lib/mol-math/linear-algebra";
+import { Loci } from "molstar/lib/mol-model/loci";
+import { OrderedSet } from "molstar/lib/mol-data/int";
+import { QueryContext, StructureElement, StructureProperties, StructureSelection } from "molstar/lib/mol-model/structure";
+import { BondType } from "molstar/lib/mol-model/structure/model/types";
+import { elementLabel } from "molstar/lib/mol-theme/label";
+import { MolScriptBuilder } from "molstar/lib/mol-script/language/builder";
+import { Color } from "molstar/lib/mol-util/color";
+import { setSubtreeVisibility } from "molstar/lib/mol-plugin/behavior/static/state";
+import { compile } from "molstar/lib/mol-script/runtime/query/compiler";
+import { PluginContext } from "molstar/lib/mol-plugin/context";
+import { DefaultPluginSpec } from "molstar/lib/mol-plugin/spec";
+import { download } from "molstar/lib/mol-util/download";
+//#region src/core/ProteinStructureViewer/utils/selection.ts
+/**
+* A stable string for a selection, for comparing one against another.
+*
+* A consumer holding the selection in state hands back a new object on every
+* render, so identity says nothing about whether the selection changed. Order
+* is normalized too: `{ residues: [2, 1] }` and `{ residues: [1, 2] }` select
+* the same residues and must not read as a change.
+*/
+function selectionKey(selection) {
+	var _selection$residues, _selection$chains;
+	const residues = [...new Set((_selection$residues = selection.residues) !== null && _selection$residues !== void 0 ? _selection$residues : [])].sort((a, b) => a - b);
+	return `${[...new Set((_selection$chains = selection.chains) !== null && _selection$chains !== void 0 ? _selection$chains : [])].sort().join(",")}|${residues.join(",")}`;
+}
+/** True when the selection names nothing at all. */
+function isEmptySelection(selection) {
+	var _selection$residues2, _selection$chains2;
+	if (!selection) return true;
+	return !((_selection$residues2 = selection.residues) === null || _selection$residues2 === void 0 ? void 0 : _selection$residues2.length) && !((_selection$chains2 = selection.chains) === null || _selection$chains2 === void 0 ? void 0 : _selection$chains2.length);
+}
+/**
+* The residues a selection covers, ascending and without repeats.
+*
+* Chains are expanded through `residuesByChain`, which was read off the loaded
+* structure, so a chain contributes exactly the residues it holds rather than
+* the span between its ends. A residue named directly and also carried by a
+* selected chain is counted once.
+*/
+function selectionResidues(selection, residuesByChain) {
+	var _selection$residues3, _selection$chains3;
+	const residues = new Set((_selection$residues3 = selection.residues) !== null && _selection$residues3 !== void 0 ? _selection$residues3 : []);
+	for (const chainId of (_selection$chains3 = selection.chains) !== null && _selection$chains3 !== void 0 ? _selection$chains3 : []) {
+		var _residuesByChain$get;
+		for (const index of (_residuesByChain$get = residuesByChain.get(chainId)) !== null && _residuesByChain$get !== void 0 ? _residuesByChain$get : []) residues.add(index);
+	}
+	return [...residues].sort((a, b) => a - b);
+}
+/**
+* Names a selection for the legend's readout.
+*
+* A single chain is named as one, since "Chain A" says more than the number of
+* residues it happens to hold. Anything else is reported as a count, which is
+* the only thing true of every shape a selection can take. A lone residue is
+* named by the caller instead, which reads it back off the structure to get its
+* three-letter code and the number the file gives it.
+*/
+function selectionLabel(selection, residueCount) {
+	var _selection$chains4, _selection$residues4;
+	const chains = (_selection$chains4 = selection.chains) !== null && _selection$chains4 !== void 0 ? _selection$chains4 : [];
+	if (chains.length === 1 && !((_selection$residues4 = selection.residues) === null || _selection$residues4 === void 0 ? void 0 : _selection$residues4.length)) return `Chain ${chains[0]}`;
+	return `${residueCount} residues`;
+}
+/** The mean of the values `read` returns, ignoring residues without one. */
+function meanOverResidues(residues, read) {
+	let sum = 0;
+	let count = 0;
+	for (const index of residues) {
+		const value = read(index);
+		if (value === null || value === void 0) continue;
+		sum += value;
+		count++;
+	}
+	return count === 0 ? null : sum / count;
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/residueLoci.ts
+/**
+* Every atom the predicate accepts, as geometry Mol* can focus, frame and mark,
+* or undefined when it accepts none.
+*
+* One pass over the structure rather than a pass per residue: a whole-chain
+* selection names hundreds of residues, and resolving them one at a time would
+* walk the structure once for each.
+*
+* Atoms are bucketed by the unit they belong to because element indices are
+* unit-local. That bucketing is also what lets a result span a chain break: it
+* carries an entry per unit, which is what a range across two chains needs and
+* what a single unit-local entry cannot express.
+*
+* Whole residues are collected rather than one atom each, since the caller
+* frames the camera on the loci's bounding sphere and a lone atom would zoom
+* far closer than the residue warrants.
+*/
+function lociMatching(structure, matches) {
+	const location = StructureElement.Location.create(structure);
+	const elements = [];
+	for (const unit of structure.units) {
+		location.unit = unit;
+		const indices = [];
+		for (let i = 0; i < unit.elements.length; i++) {
+			location.element = unit.elements[i];
+			if (matches(location)) indices.push(i);
+		}
+		if (indices.length > 0) elements.push({
+			indices,
+			unit
+		});
+	}
+	if (elements.length === 0) return void 0;
+	return StructureElement.Loci(structure, elements.map(({ indices, unit }) => ({
+		indices: OrderedSet.ofSortedArray(indices),
+		unit
+	})));
+}
+/**
+* Every atom of the residues a selection covers, within one structure.
+*
+* `hiddenChains` is subtracted from the result. A hidden chain is not drawn, so
+* geometry built from it would have nothing to sit on: Mol*'s focus
+* representation draws its own ball-and-stick from whatever is focused, in a
+* part of the state tree the chain's own visibility does not reach, and a
+* hidden chain left in the loci would keep showing up there after its cartoon
+* had gone.
+*/
+function lociForSelectionInStructure(structure, selection, hiddenChains) {
+	var _selection$residues, _selection$chains;
+	if (isEmptySelection(selection)) return void 0;
+	const residues = new Set((_selection$residues = selection.residues) !== null && _selection$residues !== void 0 ? _selection$residues : []);
+	const chains = new Set((_selection$chains = selection.chains) !== null && _selection$chains !== void 0 ? _selection$chains : []);
+	return lociMatching(structure, (location) => {
+		const chainId = StructureProperties.chain.auth_asym_id(location);
+		if (hiddenChains === null || hiddenChains === void 0 ? void 0 : hiddenChains.has(chainId)) return false;
+		return residues.has(StructureProperties.residue.key(location)) || chains.has(chainId);
+	});
+}
+/**
+* Every atom of the residues between two 0-based indices, inclusive.
+*
+* A contiguous span is tested by comparison rather than by expanding it into a
+* set of indices: this runs on every residue a drag crosses, and a drag can
+* span the whole structure.
+*/
+function lociForResidueRange(structure, min, max) {
+	return lociMatching(structure, (location) => {
+		const index = StructureProperties.residue.key(location);
+		return index >= min && index <= max;
+	});
+}
+/**
+* The same, across every structure loaded into a plugin. Results are merged
+* into the first structure that matched: a loci belongs to one structure, and
+* the residue index space already spans them as though they were one.
+*/
+function lociForSelection(plugin, selection, hiddenChains) {
+	for (const entry of plugin.managers.structure.hierarchy.current.structures) {
+		var _entry$cell$obj;
+		const structure = (_entry$cell$obj = entry.cell.obj) === null || _entry$cell$obj === void 0 ? void 0 : _entry$cell$obj.data;
+		if (!structure) continue;
+		const loci = lociForSelectionInStructure(structure, selection, hiddenChains);
+		if (loci) return loci;
+	}
+}
+/**
+* Every atom on chains other than the named ones, within one structure - what
+* dimming a component that spans chains dims, leaving the lit chains as they
+* are.
+*/
+function lociOutsideChains(structure, chains) {
+	return lociMatching(structure, (location) => !chains.has(StructureProperties.chain.auth_asym_id(location)));
+}
+/** Every atom of a set of residues, within one structure. */
+function lociForResidueIndices(structure, residueIndices) {
+	return lociForSelectionInStructure(structure, { residues: [...residueIndices] });
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/camera.ts
+/** How far two camera readings may differ and still be the same camera. */
+const CAMERA_EPSILON = 1e-4;
+const toTuple = (v) => [
+	v[0],
+	v[1],
+	v[2]
+];
+/** Where the canvas camera is now, in the form `onCameraChange` reports. */
+function readCameraState(canvas3d) {
+	const { camera } = canvas3d;
+	const snapshot = camera.getSnapshot();
+	return {
+		fov: snapshot.fov,
+		position: toTuple(snapshot.position),
+		projection: snapshot.mode,
+		radius: snapshot.radius,
+		radiusMax: snapshot.radiusMax,
+		target: toTuple(snapshot.target),
+		up: toTuple(snapshot.up),
+		viewport: {
+			height: camera.viewport.height,
+			width: camera.viewport.width
+		}
+	};
+}
+/** A camera state as the Mol* snapshot that puts the camera there. */
+function cameraSnapshot(state) {
+	return {
+		fov: state.fov,
+		mode: state.projection,
+		position: Vec3.create(...state.position),
+		radius: state.radius,
+		radiusMax: state.radiusMax,
+		target: Vec3.create(...state.target),
+		up: Vec3.create(...state.up)
+	};
+}
+const near = (a, b) => Math.abs(a - b) <= CAMERA_EPSILON;
+const nearAll = (a, b) => a.every((value, i) => near(value, b[i]));
+/** True when two readings place the camera in the same spot. */
+function camerasEqual(a, b) {
+	return a.projection === b.projection && near(a.fov, b.fov) && near(a.radius, b.radius) && nearAll(a.position, b.position) && nearAll(a.target, b.target) && nearAll(a.up, b.up);
+}
+/**
+* The center of the named residues, or undefined when the structure holds
+* none of them - which is what an orientation relative to highlights falls
+* back to the overview from.
+*/
+function residuesCenter(structure, residueIndices) {
+	if (residueIndices.length === 0) return void 0;
+	const loci = lociForResidueIndices(structure, residueIndices);
+	const sphere = loci && Loci.getBoundingSphere(loci);
+	return sphere ? Vec3.clone(sphere.center) : void 0;
+}
+/**
+* Looks at the scene from one side or another of the named residues.
+*
+* Resolved against the scene as Mol* draws it, when the reset it is handed to
+* comes round, rather than when it is asked for: the visible bounding sphere
+* is only known once what is visible has been drawn, and a structure just
+* loaded has not been yet.
+*
+* `facing` looks at the residues from outside the structure, down the line
+* from its center through theirs; `opposite` looks from the far side; `side`
+* looks across that line. Without residues, `overview` looks down the view's
+* default axis, with up as up.
+*/
+function orientationSnapshot(orientation, residues) {
+	return (scene, camera) => {
+		const { center, radius } = scene.boundingSphereVisible;
+		const outward = Vec3.create(0, 0, 1);
+		if (orientation !== "overview" && residues) {
+			Vec3.sub(outward, residues, center);
+			if (Vec3.magnitude(outward) < 1e-6) Vec3.set(outward, 0, 0, 1);
+			Vec3.normalize(outward, outward);
+		}
+		const reference = Math.abs(outward[1]) < .9 ? Vec3.create(0, 1, 0) : Vec3.create(1, 0, 0);
+		const up = Vec3.normalize(Vec3(), Vec3.sub(Vec3(), reference, Vec3.scale(Vec3(), outward, Vec3.dot(reference, outward))));
+		let direction = outward;
+		if (orientation === "opposite") direction = Vec3.negate(Vec3(), outward);
+		if (orientation === "side") direction = Vec3.normalize(Vec3(), Vec3.cross(Vec3(), outward, up));
+		return camera.getInvariantFocus(center, radius, up, Vec3.negate(Vec3(), direction));
+	};
+}
+/**
+* Places the camera on a structure just loaded: at `initialCamera` when there
+* is one, turned to `orientation` when there is one, and otherwise fitted to
+* the structure when `fit` asks for it.
+*
+* Handed to Mol* as a camera reset, which waits for the scene to be drawn: set
+* directly, the camera would be fitted again by Mol* the first time something
+* is drawn into the empty scene.
+*
+* Returns the orientation now in force, so a change to it can be told from the
+* one the load already applied. `fitDurationMs` is how long a plain fit
+* animates, Mol*'s own default when left out.
+*/
+function frameStructure(canvas3d, framing, residues, fit, fitDurationMs) {
+	const { initialCamera, orientation, projection } = framing;
+	if (projection) canvas3d.setProps({ camera: { mode: projection } });
+	if (initialCamera) {
+		canvas3d.setProps({ camera: { mode: initialCamera.projection } });
+		canvas3d.requestCameraReset({
+			durationMs: 0,
+			snapshot: cameraSnapshot(initialCamera)
+		});
+	} else if (orientation) canvas3d.requestCameraReset({
+		durationMs: 0,
+		snapshot: orientationSnapshot(orientation, residues)
+	});
+	else if (fit && fitDurationMs === void 0) canvas3d.requestCameraReset();
+	else if (fit) canvas3d.requestCameraReset({ durationMs: fitDurationMs });
+	return orientation;
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/chains.ts
+/**
+* The polymer of one chain, as named in the file. What each chain's cartoon is
+* built from, and so what makes a chain a thing Mol* can hide on its own.
+*
+* Paired with `chainLigandExpression`: between them they cover everything on a
+* chain the viewer draws, split by what it draws it as. The polymer
+* restriction is the one Mol*'s `polymer-cartoon` preset applied, and is what
+* keeps a heme from being handed to a representation that can only trace a
+* backbone.
+*/
+function chainPolymerExpression(chainId) {
+	return MolScriptBuilder.struct.generator.atomGroups({
+		"chain-test": MolScriptBuilder.core.rel.eq([MolScriptBuilder.ammp("auth_asym_id"), chainId]),
+		"entity-test": MolScriptBuilder.core.rel.eq([MolScriptBuilder.ammp("entityType"), "polymer"])
+	});
+}
+/**
+* Bonds worth following out of a ligand: the ones holding it to the protein.
+*
+* Mol*'s own pair, and metallic coordination is the half that matters most -
+* a heme's iron is held to its histidine by a coordination bond and not a
+* covalent one, so covalent alone would leave every metalloprotein's cofactor
+* looking dropped in rather than bound.
+*/
+const CONNECTING_BOND = MolScriptBuilder.core.flags.hasAny([MolScriptBuilder.struct.bondProperty.flags(), MolScriptBuilder.core.type.bitflags([BondType.fromNames(["covalent", "metal-coordination"])])]);
+/**
+* The heteroatoms of one chain - ligands, ions, glycans, lipids - along with
+* the residues holding them, which is what its ball-and-stick is built from.
+*
+* `non-polymer` is the one entity type a PDB's HETATM records land under,
+* ligands and ions alike, so there is nothing finer to test here: the
+* distinction Mol*'s presets draw between their `ligand`, `ion` and `lipid`
+* components is a residue-name lookup made to give each a slightly different
+* style, and all three are sticks. `branched` is the separate type glycans
+* arrive as.
+*
+* Water is the third type and is left out of the seed. Every solvent molecule
+* drawn as sticks buries the structure they surround, which is why Mol* draws
+* them at 60% alpha rather than plain, and none of them is what "show the
+* ligands" asks for.
+*
+* One layer of bonds out from there, taken as whole residues, is what brings
+* the binding residue along - myoglobin's His93, say. Without it the heme
+* floats unattached in the middle of a cartoon it is visibly bonded to, and
+* the bond drawn to its iron ends in mid-air. One layer and no more: the
+* residue that holds the ligand, not that residue's own neighbours.
+*
+* Intersected back with the chain, so everything a chain is drawn with belongs
+* to that chain. A ligand bonded across an interface would otherwise leave the
+* partner chain's residue in this chain's component, somewhere hiding the
+* partner chain could not reach.
+*/
+function chainLigandExpression(chainId) {
+	const onThisChain = MolScriptBuilder.core.rel.eq([MolScriptBuilder.ammp("auth_asym_id"), chainId]);
+	return MolScriptBuilder.struct.modifier.union([MolScriptBuilder.struct.modifier.intersectBy({
+		0: MolScriptBuilder.struct.modifier.includeConnected({
+			0: MolScriptBuilder.struct.generator.atomGroups({
+				"chain-test": onThisChain,
+				"entity-test": MolScriptBuilder.core.set.has([MolScriptBuilder.set("non-polymer", "branched"), MolScriptBuilder.ammp("entityType")])
+			}),
+			"as-whole-residues": true,
+			"bond-test": CONNECTING_BOND,
+			"layer-count": 1
+		}),
+		by: MolScriptBuilder.struct.generator.atomGroups({ "chain-test": onThisChain })
+	})]);
+}
+/**
+* Matches how the sequence panel captions its chains, which reaches the same
+* label through Mol*'s own `getChainOptions`. Deriving it the same way is what
+* keeps a chain from going by one name in the legend and another in the panel.
+*/
+const CHAIN_LABEL_OPTIONS = {
+	granularity: "chain",
+	hidePrefix: true,
+	htmlStyling: false
+};
+/**
+* Reads the chains of a structure and the polymer residues on each.
+*
+* Residue indices are Mol*'s residue keys, counting residues in file order
+* across the whole structure, so what is reported here addresses the same
+* residues as `plddt`, `residueOverlay` and `selection`.
+*
+* Heteroatoms are drawn (see `chainLigandExpression`) but are not counted
+* here. A heme is a residue to the file and not to a reader: it is no part of
+* the sequence the panel lists, and averaging a confidence score over it would
+* divide by a residue that has none.
+*
+* Residues are gathered into a set rather than inferred from the ends: a chain
+* carrying several symmetry operators repeats each of its residues once per
+* operator, and a structure whose chains interleave leaves a chain's indices
+* non-contiguous. Neither is what a predicted complex looks like, but a range
+* would misread both.
+*/
+function scanChains(structure) {
+	const accumulators = /* @__PURE__ */ new Map();
+	const location = StructureElement.Location.create(structure);
+	for (const unit of structure.units) {
+		location.unit = unit;
+		for (let i = 0; i < unit.elements.length; i++) {
+			location.element = unit.elements[i];
+			const chainId = StructureProperties.chain.auth_asym_id(location);
+			let chain = accumulators.get(chainId);
+			if (!chain) {
+				chain = {
+					chainId,
+					label: elementLabel(location, CHAIN_LABEL_OPTIONS),
+					residues: /* @__PURE__ */ new Set()
+				};
+				accumulators.set(chainId, chain);
+			}
+			if (StructureProperties.entity.type(location) !== "polymer") continue;
+			chain.residues.add(StructureProperties.residue.key(location));
+		}
+	}
+	const ordered = [...accumulators.values()].filter((chain) => chain.residues.size > 0).map((chain) => _objectSpread2(_objectSpread2({}, chain), {}, { residues: [...chain.residues].sort((a, b) => a - b) })).sort((a, b) => {
+		var _a$residues$, _b$residues$;
+		return ((_a$residues$ = a.residues[0]) !== null && _a$residues$ !== void 0 ? _a$residues$ : 0) - ((_b$residues$ = b.residues[0]) !== null && _b$residues$ !== void 0 ? _b$residues$ : 0);
+	});
+	return {
+		chainLabels: new Map([...accumulators.values()].map(({ chainId, label }) => [chainId, label])),
+		chains: ordered.map(({ chainId, label, residues }) => {
+			var _residues, _residues$;
+			return {
+				chainId,
+				endIndex: (_residues = residues[residues.length - 1]) !== null && _residues !== void 0 ? _residues : 0,
+				label,
+				residueCount: residues.length,
+				startIndex: (_residues$ = residues[0]) !== null && _residues$ !== void 0 ? _residues$ : 0
+			};
+		}),
+		residuesByChain: new Map(ordered.map(({ chainId, residues }) => [chainId, residues]))
+	};
+}
+/** True when the two lists name the same chains, in the same order. */
+function chainsEqual(a, b) {
+	return a.length === b.length && a.every((chain, i) => {
+		const other = b[i];
+		return other !== void 0 && chain.chainId === other.chainId && chain.startIndex === other.startIndex && chain.endIndex === other.endIndex && chain.residueCount === other.residueCount;
+	});
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/residueAddress.ts
+const _excluded = ["addresses"];
+/**
+* A residue's address as one comparable string.
+*
+* Insertion codes are trimmed, so a blank one and an absent one are the same
+* code: a file writes "no insertion" as a space, and a caller as nothing.
+*/
+function residueAddressKey(address) {
+	var _address$insCode;
+	const insCode = ((_address$insCode = address.insCode) !== null && _address$insCode !== void 0 ? _address$insCode : "").trim();
+	return `${address.chainId}\u0000${address.seqId}\u0000${insCode}`;
+}
+/**
+* Every residue's 0-based index by its address, from one pass over the
+* structure: what turns the address a caller knows a residue by into the index
+* the viewer keys everything else on.
+*
+* A residue carrying several symmetry operators is indexed once, under the
+* first, as `ChainRef` counts its chain once.
+*/
+function indexResidueAddresses(structure) {
+	const index = /* @__PURE__ */ new Map();
+	const location = StructureElement.Location.create(structure);
+	for (const unit of structure.units) {
+		location.unit = unit;
+		let previous = -1;
+		for (let i = 0; i < unit.elements.length; i++) {
+			location.element = unit.elements[i];
+			const residue = StructureProperties.residue.key(location);
+			if (residue === previous) continue;
+			previous = residue;
+			const key = residueAddressKey({
+				chainId: StructureProperties.chain.auth_asym_id(location),
+				insCode: StructureProperties.residue.pdbx_PDB_ins_code(location),
+				seqId: StructureProperties.residue.auth_seq_id(location)
+			});
+			if (!index.has(key)) index.set(key, residue);
+		}
+	}
+	return index;
+}
+/** The indices of the addresses the structure has, in the order given. */
+function resolveResidueAddresses(index, addresses) {
+	const resolved = [];
+	for (const address of addresses) {
+		const residue = index.get(residueAddressKey(address));
+		if (residue !== void 0) resolved.push(residue);
+	}
+	return resolved;
+}
+/**
+* A selection with its addresses resolved into `residues`, which is the only
+* form the rest of the viewer reads. Handed back unchanged when it names none.
+*/
+function resolveSelectionAddresses(selection, index) {
+	var _selection$addresses, _rest$residues;
+	if (!(selection === null || selection === void 0 || (_selection$addresses = selection.addresses) === null || _selection$addresses === void 0 ? void 0 : _selection$addresses.length)) return selection;
+	const { addresses } = selection, rest = _objectWithoutProperties(selection, _excluded);
+	const residues = [...new Set([...(_rest$residues = rest.residues) !== null && _rest$residues !== void 0 ? _rest$residues : [], ...resolveResidueAddresses(index, addresses)])];
+	return _objectSpread2(_objectSpread2({}, rest), {}, { residues });
+}
+/** A stable string for a list of addresses, for comparing one with another. */
+function residueAddressesKey(addresses) {
+	return (addresses !== null && addresses !== void 0 ? addresses : []).map(residueAddressKey).join("
");
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/structureFormat.ts
+/** How much of the file to inspect when guessing the format. */
+const DETECT_SAMPLE = 16384;
+/**
+* Infers whether `text` is PDB or mmCIF (PDBx).
+*
+* mmCIF documents start with a `data_` block and name their coordinates
+* `_atom_site.`. PDB never does either, so either marker is enough. A leading
+* comment (`# ...`) before `data_` is still mmCIF.
+*/
+function detectStructureFormat(text) {
+	const sample = text.slice(0, DETECT_SAMPLE);
+	if (/(?:^|\n)\s*data_/.test(sample) || /_atom_site\./.test(sample)) return "mmcif";
+	return "pdb";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n) {
+		e(n);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+			}
+			function _throw(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+			}
+			_next(void 0);
+		});
+	};
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/load.ts
+const NOTHING_LOADED = {
+	addressIndex: /* @__PURE__ */ new Map(),
+	atomCount: 0,
+	chainLabels: /* @__PURE__ */ new Map(),
+	chains: [],
+	residuesByChain: /* @__PURE__ */ new Map()
+};
+/**
+* Clears the plugin and parses the structure into it, reading off what the
+* rest of the viewer addresses it by. Nothing is drawn here.
+*
+* The format is detected from the text - PDB or mmCIF - and handed to Mol*.
+*/
+function parseStructure(_x, _x2) {
+	return _parseStructure.apply(this, arguments);
+}
+function _parseStructure() {
+	_parseStructure = _asyncToGenerator(function* (plugin, structureText) {
+		try {
+			yield plugin.clear();
+			const data = yield plugin.builders.data.rawData({
+				data: structureText,
+				label: "Structure"
+			});
+			const trajectory = yield plugin.builders.structure.parseTrajectory(data, detectStructureFormat(structureText));
+			const model = yield plugin.builders.structure.createModel(trajectory);
+			const structure = yield plugin.builders.structure.createStructure(model, {
+				name: "model",
+				params: {}
+			});
+			const data3d = structure.data;
+			if (!data3d) return {
+				loaded: NOTHING_LOADED,
+				ok: true
+			};
+			const { chainLabels, chains, residuesByChain } = scanChains(data3d);
+			return {
+				loaded: {
+					addressIndex: indexResidueAddresses(data3d),
+					atomCount: data3d.elementCount,
+					chainLabels,
+					chains,
+					residuesByChain,
+					structure,
+					structureData: data3d
+				},
+				ok: true
+			};
+		} catch (error) {
+			return {
+				error,
+				ok: false
+			};
+		}
+	});
+	return _parseStructure.apply(this, arguments);
+}
+/** What a load reports to a consumer. */
+function loadInfo(loaded) {
+	return {
+		atomCount: loaded.atomCount,
+		chains: loaded.chains,
+		residueCount: loaded.chains.reduce((count, chain) => count + chain.residueCount, 0)
+	};
+}
+//#endregion
+//#region src/common/chainColors.ts
+/**
+* Default colors for telling chains apart, in assignment order.
+*
+* The Okabe-Ito qualitative palette, which is built to stay distinguishable
+* under every common form of color blindness - the reason to prefer it over a
+* hand-picked set, since a complex is read by which chain is which and a
+* viewer that collapses two of them into one color stops answering that.
+*
+* Its black is left out: the canvas inverts with the theme, so a chain painted
+* black would vanish against the dark background. The rest carry enough
+* lightness to hold up against both.
+*
+* Chains past the end of the palette wrap around to the start.
+*/
+const CHAIN_COLOR_PALETTE = [
+	"#009E73",
+	"#0072B2",
+	"#E69F00",
+	"#CC79A7",
+	"#56B4E9",
+	"#D55E00",
+	"#F0E442"
+];
+/**
+* Assigns each chain a color, in the order given, with `overrides` taking
+* precedence by `chainId`.
+*
+* Palette positions are spent on every chain whether or not it is overridden,
+* so overriding one chain does not shift the colors of the others.
+*/
+function chainColorMap(chainIds, overrides) {
+	const colors = /* @__PURE__ */ new Map();
+	chainIds.forEach((chainId, i) => {
+		var _overrides$chainId;
+		const fallback = CHAIN_COLOR_PALETTE[i % CHAIN_COLOR_PALETTE.length];
+		colors.set(chainId, (_overrides$chainId = overrides === null || overrides === void 0 ? void 0 : overrides[chainId]) !== null && _overrides$chainId !== void 0 ? _overrides$chainId : fallback);
+	});
+	return colors;
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/color.ts
+/** Parses `#RRGGBB` (or `RRGGBB`) into a Mol* `Color`. */
+function parseHexColor(hex) {
+	const h = hex.replace("#", "");
+	return Color.fromRgb(parseInt(h.substring(0, 2), 16), parseInt(h.substring(2, 4), 16), parseInt(h.substring(4, 6), 16));
+}
+/**
+* Parses a theme color into a Mol* `Color`, falling back when the token is
+* missing or is a format Mol* cannot consume (theme values are hex in practice,
+* but the palette types allow any CSS color string).
+*/
+function themeColor(value, fallback) {
+	const candidate = value === null || value === void 0 ? void 0 : value.trim();
+	return parseHexColor(candidate !== void 0 && /^#?[0-9a-f]{6}$/i.test(candidate) ? candidate : fallback);
+}
+/**
+* Neutral fill for residues with no overlay value. Sits between the light and
+* dark backgrounds so unhighlighted geometry stays legible in both modes.
+*/
+function neutralResidueColor(mode) {
+	const g = mode === "dark" ? 100 : 180;
+	return Color.fromRgb(g, g, g);
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/highlights.ts
+/**
+* Colors for highlights that name none, in the order the highlights are given.
+* Saturated enough to stand out over a chain, pLDDT or overlay coloring, and
+* wrapping around once they run out.
+*/
+const HIGHLIGHT_COLOR_PALETTE = [
+	"#E64545",
+	"#F0C229",
+	"#12A9A0",
+	"#BD57D4",
+	"#FF8A32",
+	"#559DF3"
+];
+/**
+* Resolves highlights to the residues they name and the colors they are
+* painted. A highlight naming a residue the structure does not have paints
+* nothing, and still spends its place in the palette, so the others keep
+* their colors whichever structure they land on.
+*/
+function resolveHighlights(highlights, addressIndex) {
+	const colors = /* @__PURE__ */ new Map();
+	const byChain = /* @__PURE__ */ new Map();
+	(highlights !== null && highlights !== void 0 ? highlights : []).forEach((highlight, i) => {
+		var _byChain$get;
+		const residue = addressIndex.get(residueAddressKey(highlight));
+		if (residue === void 0) return;
+		const fallback = HIGHLIGHT_COLOR_PALETTE[i % HIGHLIGHT_COLOR_PALETTE.length];
+		colors.set(residue, themeColor(highlight.color, fallback));
+		const onChain = (_byChain$get = byChain.get(highlight.chainId)) !== null && _byChain$get !== void 0 ? _byChain$get : [];
+		if (!onChain.includes(residue)) onChain.push(residue);
+		byChain.set(highlight.chainId, onChain);
+	});
+	return {
+		byChain,
+		colors
+	};
+}
+/** A stable string for a set of highlights, colors included. */
+function highlightsKey(highlights) {
+	return (highlights !== null && highlights !== void 0 ? highlights : []).map((highlight) => {
+		var _highlight$color;
+		return `${residueAddressKey(highlight)}\u0000${(_highlight$color = highlight.color) !== null && _highlight$color !== void 0 ? _highlight$color : ""}`;
+	}).join("
");
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/chainColorTheme.ts
+/** Mol* color theme name under which per-chain coloring is registered. */
+const CHAIN_COLOR_THEME_NAME = "chain-color";
+/** Painted for a chain with no color assigned, or one assigned a bad value. */
+const DEFAULT_CHAIN_COLOR_HEX = "#808080";
+const DEFAULT_CHAIN_COLOR = Color.fromRgb(128, 128, 128);
+/**
+* Builds a Mol* color theme that paints each chain its own color.
+*
+* This stands in for Mol*'s built-in `chain-id` theme, which picks its own
+* colors from a palette we cannot read back. Owning the assignment is what
+* lets the chain legend show a swatch that matches the structure, rather than
+* a key for colors it has to guess at.
+*
+* Created per plugin instance, and its state read live inside `color()`, for
+* the same reasons as the residue value theme beside it: several viewers can
+* color chains differently on one page, and recoloring does not rebuild the
+* structure. `overrides` paints single residues - the highlights - over it.
+*/
+function createChainColorTheme(overrides) {
+	const state = {
+		colors: /* @__PURE__ */ new Map(),
+		version: 0
+	};
+	const provider = {
+		category: "chain property",
+		defaultValues: {},
+		factory() {
+			const { colors } = state;
+			const overrideColors = overrides === null || overrides === void 0 ? void 0 : overrides.current;
+			const parsed = /* @__PURE__ */ new Map();
+			for (const [chainId, hex] of colors) parsed.set(chainId, themeColor(hex, DEFAULT_CHAIN_COLOR_HEX));
+			return {
+				color(location) {
+					var _parsed$get;
+					if (!StructureElement.Location.is(location)) return DEFAULT_CHAIN_COLOR;
+					const override = overrideColors === null || overrideColors === void 0 ? void 0 : overrideColors.get(StructureProperties.residue.key(location));
+					if (override !== void 0) return override;
+					const chainId = StructureProperties.chain.auth_asym_id(location);
+					return (_parsed$get = parsed.get(chainId)) !== null && _parsed$get !== void 0 ? _parsed$get : DEFAULT_CHAIN_COLOR;
+				},
+				contextHash: state.version,
+				description: "Color residues by the chain they sit on",
+				factory: provider.factory,
+				granularity: "group",
+				props: {}
+			};
+		},
+		getParams: () => ({}),
+		isApplicable: () => true,
+		label: "Chain Color",
+		name: CHAIN_COLOR_THEME_NAME
+	};
+	return {
+		provider,
+		setState(colors) {
+			state.colors = colors;
+			state.version++;
+		}
+	};
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/plddt.ts
+/**
+* AlphaFold's pLDDT confidence bands. Thresholds are on the 0-1 scale that
+* `plddt` values use, ascending from lowest to highest confidence.
+*/
+const PLDDT_COLOR_SCALE = {
+	kind: "stepped",
+	stops: [
+		{
+			color: "#FF7C45",
+			label: "0.5",
+			threshold: .5
+		},
+		{
+			color: "#FFDB11",
+			label: "0.7",
+			threshold: .7
+		},
+		{
+			color: "#64CBF3",
+			label: "0.9",
+			threshold: .9
+		},
+		{
+			color: "#0053D5",
+			label: "1.0",
+			threshold: 1
+		}
+	]
+};
+/**
+* The band colors alone, ascending from least to most confident.
+*
+* What the chain legend shows in place of a single color while pLDDT is
+* painting the structure: no one color stands for a chain then, so the swatch
+* carries the whole key instead.
+*/
+const PLDDT_BAND_COLORS = (PLDDT_COLOR_SCALE.kind === "stepped" ? PLDDT_COLOR_SCALE.stops : []).map((stop) => stop.color);
+/**
+* Rewrites a PDB file's B-factor column with pLDDT scores so Mol* can read them
+* off the parsed model. B-factors occupy columns 60-66 of ATOM/HETATM lines;
+* scores arrive on a 0-1 scale and are stored on the conventional 0-100 one.
+* Residues past the end of `plddtValues` fall back to a mid-confidence 50.
+*
+* A residue is identified by chain, sequence number and insertion code. The
+* code has to be part of that: `10` and `10A` are two residues, Mol* counts
+* them as two, and treating them as one here would hand every residue after
+* them its neighbour's score.
+*/
+function injectPlddtIntoPdb(pdbData, plddtValues) {
+	const lines = pdbData.split("\n");
+	let residueIndex = -1;
+	let lastResidue = "";
+	return lines.map((line) => {
+		var _plddtValues$residueI;
+		if (!line.startsWith("ATOM") && !line.startsWith("HETATM")) return line;
+		const residue = line.substring(21, 27);
+		if (residue !== lastResidue) {
+			residueIndex++;
+			lastResidue = residue;
+		}
+		const bfactorStr = (residueIndex < plddtValues.length ? ((_plddtValues$residueI = plddtValues[residueIndex]) !== null && _plddtValues$residueI !== void 0 ? _plddtValues$residueI : 0) * 100 : 50).toFixed(2).padStart(6, " ");
+		const paddedLine = line.padEnd(66, " ");
+		return paddedLine.substring(0, 60) + bfactorStr + paddedLine.substring(66);
+	}).join("\n");
+}
+const ATOM_SITE_PREFIX = "_atom_site.";
+const B_FACTOR_COLUMN = "B_iso_or_equiv";
+function skipCifWhitespace(line, index) {
+	let i = index;
+	while (i < line.length && /\s/.test(line.charAt(i))) i += 1;
+	return i;
+}
+function readCifToken(line, start) {
+	const quote = line.charAt(start);
+	if (quote === "'" || quote === "\"") {
+		const end = line.indexOf(quote, start + 1);
+		if (end < 0) return {
+			next: line.length,
+			token: line.slice(start + 1)
+		};
+		return {
+			next: end + 1,
+			token: line.slice(start + 1, end)
+		};
+	}
+	let i = start;
+	while (i < line.length && !/\s/.test(line.charAt(i))) i += 1;
+	return {
+		next: i,
+		token: line.slice(start, i)
+	};
+}
+/**
+* Splits one CIF line into tokens, honouring `'quoted'` and `"quoted"` values.
+* Atom-site rows are one line each in practice; multiline `;text;` fields are
+* not used there and are not handled.
+*/
+function tokenizeCifLine(line) {
+	const tokens = [];
+	let i = skipCifWhitespace(line, 0);
+	while (i < line.length) {
+		const { next, token } = readCifToken(line, i);
+		tokens.push(token);
+		i = skipCifWhitespace(line, next);
+	}
+	return tokens;
+}
+function isCifNull(value) {
+	return value === void 0 || value === "." || value === "?";
+}
+function columnIndex(columns, name) {
+	return columns.indexOf(name);
+}
+/**
+* Residue identity matching `injectPlddtIntoPdb`: chain + sequence number +
+* insertion code. Prefers the `auth_*` columns Mol* reports on the parsed
+* model, falling back to `label_*` when a file omitted them. `.` / `?`
+* insertion codes count as empty, the way a blank PDB column 27 does.
+*/
+function mmcifResidueKey(tokens, columns) {
+	var _ref, _ref2, _ref3, _ref4;
+	const authAsym = columnIndex(columns, "auth_asym_id");
+	const labelAsym = columnIndex(columns, "label_asym_id");
+	const authSeq = columnIndex(columns, "auth_seq_id");
+	const labelSeq = columnIndex(columns, "label_seq_id");
+	const ins = columnIndex(columns, "pdbx_PDB_ins_code");
+	return `${(_ref = (_ref2 = authAsym >= 0 ? tokens[authAsym] : void 0) !== null && _ref2 !== void 0 ? _ref2 : labelAsym >= 0 ? tokens[labelAsym] : void 0) !== null && _ref !== void 0 ? _ref : ""}|${(_ref3 = (_ref4 = authSeq >= 0 ? tokens[authSeq] : void 0) !== null && _ref4 !== void 0 ? _ref4 : labelSeq >= 0 ? tokens[labelSeq] : void 0) !== null && _ref3 !== void 0 ? _ref3 : ""}|${isCifNull(ins >= 0 ? tokens[ins] : void 0) ? "" : tokens[ins]}`;
+}
+function isAtomSiteRow(tokens, columns) {
+	const group = columnIndex(columns, "group_PDB");
+	if (group < 0) return true;
+	const value = tokens[group];
+	return value === "ATOM" || value === "HETATM";
+}
+function plddtBFactor(residueIndex, plddtValues) {
+	var _plddtValues$residueI2;
+	return (residueIndex < plddtValues.length ? ((_plddtValues$residueI2 = plddtValues[residueIndex]) !== null && _plddtValues$residueI2 !== void 0 ? _plddtValues$residueI2 : 0) * 100 : 50).toFixed(2);
+}
+function isLoopStart(line) {
+	return line.trim() === "loop_" || line.trim().startsWith("loop_");
+}
+function isAtomSiteColumn(line) {
+	return line.trim().startsWith(ATOM_SITE_PREFIX);
+}
+function endsAtomSiteLoop(line) {
+	const trimmed = line.trim();
+	if (trimmed === "") return false;
+	if (trimmed.startsWith("#")) return true;
+	if (isLoopStart(trimmed)) return true;
+	if (trimmed.startsWith("data_") || trimmed.startsWith("save_")) return true;
+	return trimmed.startsWith("_") && !trimmed.startsWith(ATOM_SITE_PREFIX);
+}
+function isAtomSiteLoop(lines, loopIndex) {
+	let peek = loopIndex + 1;
+	while (peek < lines.length && lines[peek].trim() === "") peek += 1;
+	return peek < lines.length && isAtomSiteColumn(lines[peek]);
+}
+function ensureBFactorColumn(columns, headerLines) {
+	const existing = columnIndex(columns, B_FACTOR_COLUMN);
+	if (existing >= 0) return existing;
+	columns.push(B_FACTOR_COLUMN);
+	headerLines.push(`${ATOM_SITE_PREFIX}${B_FACTOR_COLUMN}`);
+	return columns.length - 1;
+}
+function rewriteAtomSiteRow(dataLine, columns, bIndex, plddtValues, walk) {
+	if (dataLine.trim() === "") return dataLine;
+	const tokens = tokenizeCifLine(dataLine);
+	if (tokens.length === 0) return dataLine;
+	while (tokens.length < columns.length) tokens.push(".");
+	if (isAtomSiteRow(tokens, columns)) {
+		const residue = mmcifResidueKey(tokens, columns);
+		if (residue !== walk.lastResidue) {
+			walk.residueIndex += 1;
+			walk.lastResidue = residue;
+		}
+		tokens[bIndex] = plddtBFactor(walk.residueIndex, plddtValues);
+	}
+	return tokens.join(" ");
+}
+function rewriteAtomSiteLoop(lines, loopIndex, plddtValues, walk) {
+	const rows = [lines[loopIndex]];
+	let i = loopIndex + 1;
+	const columns = [];
+	while (i < lines.length && isAtomSiteColumn(lines[i])) {
+		columns.push(lines[i].trim().slice(11));
+		rows.push(lines[i]);
+		i += 1;
+	}
+	const bIndex = ensureBFactorColumn(columns, rows);
+	while (i < lines.length && !endsAtomSiteLoop(lines[i])) {
+		rows.push(rewriteAtomSiteRow(lines[i], columns, bIndex, plddtValues, walk));
+		i += 1;
+	}
+	return {
+		next: i,
+		rows
+	};
+}
+/**
+* Rewrites an mmCIF (PDBx) file's `_atom_site.B_iso_or_equiv` column with
+* pLDDT scores so Mol* can read them off the parsed model, the same way
+* `injectPlddtIntoPdb` rewrites the PDB B-factor column. Scores arrive on a
+* 0-1 scale and are stored on the conventional 0-100 one. Residues past the
+* end of `plddtValues` fall back to a mid-confidence 50.
+*
+* If the file has no B-factor column, one is appended to the atom-site loop
+* rather than leaving the scores behind.
+*/
+function injectPlddtIntoMmcif(mmcifData, plddtValues) {
+	const lines = mmcifData.split("\n");
+	const result = [];
+	const walk = {
+		lastResidue: "",
+		residueIndex: -1
+	};
+	let i = 0;
+	let rewrittenLoop = false;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (!rewrittenLoop && isLoopStart(line) && isAtomSiteLoop(lines, i)) {
+			const rewritten = rewriteAtomSiteLoop(lines, i, plddtValues, walk);
+			result.push(...rewritten.rows);
+			i = rewritten.next;
+			rewrittenLoop = true;
+			continue;
+		}
+		result.push(line);
+		i += 1;
+	}
+	return result.join("\n");
+}
+/**
+* Rewrites a structure file's B-factors with pLDDT scores. Dispatches to
+* `injectPlddtIntoPdb` or `injectPlddtIntoMmcif` from `format`, or from
+* detecting the format of `data` when `format` is omitted.
+*/
+function injectPlddt(data, plddtValues, format = detectStructureFormat(data)) {
+	return format === "mmcif" ? injectPlddtIntoMmcif(data, plddtValues) : injectPlddtIntoPdb(data, plddtValues);
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/plddtTheme.ts
+/** Mol* color theme name under which pLDDT coloring is registered. */
+const PLDDT_THEME_NAME = "plddt";
+const PLDDT_BANDS = PLDDT_COLOR_SCALE.kind === "stepped" ? PLDDT_COLOR_SCALE.stops : [];
+/** The band color for a score on the 0-1 scale `plddt` uses. */
+function plddtColor(score) {
+	const [r, g, b] = sampleSteppedScale(PLDDT_BANDS, score);
+	return Color.fromRgb(r, g, b);
+}
+/**
+* Builds a Mol* color theme that paints each residue its pLDDT band.
+*
+* Read from the scores themselves, by residue index, rather than written into
+* the file's B-factor column first. A column has no way to say "unscored", so a
+* residue without a score would have to be given one; here it reads neutral,
+* as it does under an overlay, and the structure text reaching Mol* is exactly
+* the text the consumer passed. Scores arriving after the structure recolor it
+* without reloading it, which leaves the camera where it was.
+*
+* Created per plugin instance for the same reasons as the other themes, and
+* `overrides` paints single residues - the highlights - over it.
+*/
+function createPlddtTheme(mode, overrides) {
+	const state = {
+		mode,
+		scores: [],
+		version: 0
+	};
+	const provider = {
+		category: "residue property",
+		defaultValues: {},
+		factory() {
+			const { mode: currentMode, scores } = state;
+			const neutral = neutralResidueColor(currentMode);
+			const overrideColors = overrides === null || overrides === void 0 ? void 0 : overrides.current;
+			return {
+				color(location) {
+					if (!StructureElement.Location.is(location)) return neutral;
+					const residue = StructureProperties.residue.key(location);
+					const override = overrideColors === null || overrideColors === void 0 ? void 0 : overrideColors.get(residue);
+					if (override !== void 0) return override;
+					const score = scores[residue];
+					if (score === null || score === void 0 || !Number.isFinite(score)) return neutral;
+					return plddtColor(score);
+				},
+				contextHash: state.version,
+				description: "Color residues by pLDDT confidence",
+				factory: provider.factory,
+				granularity: "group",
+				props: {}
+			};
+		},
+		getParams: () => ({}),
+		isApplicable: () => true,
+		label: "pLDDT",
+		name: PLDDT_THEME_NAME
+	};
+	return {
+		provider,
+		setState(next) {
+			Object.assign(state, next);
+			state.version++;
+		}
+	};
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/residueColorOverrides.ts
+function createResidueColorOverrides() {
+	return { current: /* @__PURE__ */ new Map() };
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/residueValueTheme.ts
+/** Mol* color theme name under which residue value overlays are registered. */
+const RESIDUE_VALUE_THEME_NAME = "residue-value";
+/**
+* Builds a Mol* color theme that paints residues by an arbitrary per-residue
+* value.
+*
+* The theme is created per plugin instance rather than shared at module scope,
+* so several viewers can render different overlays on the same page. Its state
+* lives in the closure below and is read live inside `color()`, which is what
+* lets an overlay update recolor the structure without rebuilding it.
+* `overrides` paints single residues - the highlights - over it.
+*/
+function createResidueValueTheme(mode, overrides) {
+	const state = {
+		colorScale: PLASMA_COLOR_SCALE,
+		max: 1,
+		min: 0,
+		mode,
+		values: /* @__PURE__ */ new Map(),
+		version: 0
+	};
+	const provider = {
+		category: "residue property",
+		defaultValues: {},
+		factory() {
+			const { colorScale, max, min, mode: currentMode, values } = state;
+			const neutral = neutralResidueColor(currentMode);
+			const overrideColors = overrides === null || overrides === void 0 ? void 0 : overrides.current;
+			return {
+				color(location) {
+					if (!StructureElement.Location.is(location)) return neutral;
+					const residue = StructureProperties.residue.key(location);
+					const override = overrideColors === null || overrideColors === void 0 ? void 0 : overrideColors.get(residue);
+					if (override !== void 0) return override;
+					const value = values.get(residue);
+					if (value === void 0) return neutral;
+					const rgb = sampleColorScale(colorScale, value, max, min);
+					return rgb ? Color.fromRgb(rgb[0], rgb[1], rgb[2]) : neutral;
+				},
+				contextHash: state.version,
+				description: "Color residues by a per-residue value",
+				factory: provider.factory,
+				granularity: "group",
+				props: {}
+			};
+		},
+		getParams: () => ({}),
+		isApplicable: () => true,
+		label: "Residue Value",
+		name: RESIDUE_VALUE_THEME_NAME
+	};
+	return {
+		provider,
+		setState(next) {
+			Object.assign(state, next);
+			state.version++;
+		}
+	};
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/coloring.ts
+function createSceneThemes(mode) {
+	const overrides = createResidueColorOverrides();
+	return {
+		chain: createChainColorTheme(overrides),
+		overrides,
+		plddt: createPlddtTheme(mode, overrides),
+		value: createResidueValueTheme(mode, overrides)
+	};
+}
+/** Registers the themes on a plugin, so representations can name them. */
+function registerSceneThemes(plugin, themes) {
+	const registry = plugin.representation.structure.themes.colorThemeRegistry;
+	for (const { provider } of [
+		themes.chain,
+		themes.plddt,
+		themes.value
+	]) registry.add(provider);
+}
+const themesByPlugin = /* @__PURE__ */ new WeakMap();
+/**
+* The themes a plugin paints with, created and registered the first time it
+* is asked for them.
+*
+* One set per plugin rather than one per scene: Mol*'s registry refuses a
+* name it already holds, so a plugin a scene is applied to a second time -
+* the same offscreen plugin rendering one structure after another - reuses
+* the themes it has instead of failing to register new ones.
+*/
+function sceneThemesFor(plugin, mode) {
+	let themes = themesByPlugin.get(plugin);
+	if (!themes) {
+		themes = createSceneThemes(mode);
+		registerSceneThemes(plugin, themes);
+		themesByPlugin.set(plugin, themes);
+	}
+	return themes;
+}
+/** The Mol* theme name each way of coloring is registered under. */
+const COLOR_THEME_NAMES = {
+	chain: CHAIN_COLOR_THEME_NAME,
+	overlay: RESIDUE_VALUE_THEME_NAME,
+	plddt: PLDDT_THEME_NAME
+};
+/**
+* What paints the structure: `colorBy` when it names one, and otherwise the
+* first of an overlay, pLDDT scores and chain colors that is supplied.
+*
+* Set is what makes an overlay active, not populated. An overlay whose values
+* have not arrived yet still owns the coloring: its residues read as missing
+* and come out neutral, which is the honest answer and the one the legend
+* beside it is describing.
+*/
+function resolveColorBy(colorBy, overlay, plddt) {
+	if (colorBy) return colorBy;
+	if (overlay) return "overlay";
+	return plddt && plddt.length > 0 ? "plddt" : "chain";
+}
+/**
+* Hands every theme the data it paints from and names the one to paint with.
+*
+* All three are kept current whichever is showing, so switching between them
+* reveals the right colors at once rather than the ones a theme had when it
+* was last on screen.
+*/
+function syncSceneThemes(themes, coloring) {
+	var _overlay$colorScale, _overlay$min;
+	const { chainColors, highlightColors, mode, overlay, plddt } = coloring;
+	themes.overrides.current = highlightColors;
+	themes.chain.setState(chainColors);
+	themes.plddt.setState({
+		mode,
+		scores: plddt !== null && plddt !== void 0 ? plddt : []
+	});
+	themes.value.setState(overlay ? {
+		colorScale: (_overlay$colorScale = overlay.colorScale) !== null && _overlay$colorScale !== void 0 ? _overlay$colorScale : PLASMA_COLOR_SCALE,
+		max: overlay.max,
+		min: (_overlay$min = overlay.min) !== null && _overlay$min !== void 0 ? _overlay$min : 0,
+		mode,
+		values: overlay.values
+	} : {
+		mode,
+		values: /* @__PURE__ */ new Map()
+	});
+	return COLOR_THEME_NAMES[coloring.colorBy];
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/representation.ts
+/**
+* The parts the viewer draws a structure in. Each names the components built
+* for it and tags the representations drawn over them, and it is those names
+* and tags the rest of the viewer reads back: to tell its own components from
+* a consumer's, to keep ligands on element colors, and to hide or dim a chain.
+*/
+const POLYMER_PART = "polymer";
+const LIGAND_PART = "ligand";
+const HIGHLIGHT_PART = "highlight";
+const SURFACE_PART = "surface";
+/**
+* How heteroatoms are colored: the theme Mol* puts on a ball-and-stick when
+* left to itself, with the parameters it chooses too.
+*
+* Named rather than left blank only so that it survives `applyColorTheme`,
+* which would otherwise repaint the ligands along with everything else. The
+* structure-wide theme is the wrong answer for them twice over: a heme reads
+* as a heme because its iron is orange and its nitrogens are blue, which one
+* flat color throws away, and pLDDT and residue overlays have no value for a
+* HETATM to be colored by at all.
+*/
+const ELEMENT_THEME = "element-symbol";
+/** Grid spacing and probe of the molecular surface, in angstroms. */
+const SURFACE_RESOLUTION = .6;
+const SURFACE_PROBE_RADIUS = 1.4;
+/**
+* The representation parameters Mol*'s own presets compute, read from the same
+* manager state they read. Ported rather than hardcoded so a chain drawn here
+* looks exactly like the one the preset used to draw. Mol* hands the same set
+* to its cartoons and its ball-and-sticks, and so does this.
+*/
+function representationTypeParams(plugin) {
+	const { hydrogens, ignoreLight, visualQuality } = plugin.managers.structure.component.state.options;
+	return {
+		ignoreHydrogens: hydrogens !== "all",
+		ignoreHydrogensVariant: hydrogens === "only-polar" ? "non-polar" : "all",
+		ignoreLight,
+		quality: visualQuality
+	};
+}
+/**
+* True for the representation drawing a chain's heteroatoms.
+*
+* Read off the tag put on the representation when it was built, rather than
+* off the component's key. Mol* does not store the key as it was given: it
+* files components under `structure-component-<key>`, so a test against the
+* key as written here silently matches nothing, and every ligand quietly takes
+* the structure-wide theme instead. The tag survives untouched.
+*/
+function isLigandRepresentation(representation) {
+	var _representation$cell$;
+	return ((_representation$cell$ = representation.cell.transform.tags) === null || _representation$cell$ === void 0 ? void 0 : _representation$cell$.includes(LIGAND_PART)) === true;
+}
+const VIEWER_COMPONENT = /structure-component-(?:(?:polymer|ligand|highlight)-[^,]+|surface(?:,|$))/;
+/**
+* True for a component the viewer built, as opposed to one a consumer added
+* through `onReady`. Only the viewer's own are recolored, hidden or replaced.
+*/
+function isViewerComponent(component) {
+	var _component$key;
+	return VIEWER_COMPONENT.test((_component$key = component.key) !== null && _component$key !== void 0 ? _component$key : component.cell.transform.ref);
+}
+/**
+* Builds one component and draws it, handing back its ref - or nothing, when
+* the expression selects no atoms, which is what a chain with no ligands or
+* no polymer looks like.
+*
+* Mol* files components by key, and updates the one it finds under a key
+* rather than adding a second. So a component built again under its old key
+* comes back under its old ref, with the representation drawn over it still
+* in place and recomputing against the new selection by itself; drawing it
+* again would put a second one on top. `previous` is that old ref, which is
+* how the two cases are told apart.
+*/
+function drawComponent(_x, _x2, _x3, _x4, _x5, _x6, _x7, _x8) {
+	return _drawComponent.apply(this, arguments);
+}
+function _drawComponent() {
+	_drawComponent = _asyncToGenerator(function* (plugin, structure, key, label, expression, props, tag, previous) {
+		const builders = plugin.builders.structure;
+		const component = yield builders.tryCreateComponentFromExpression(structure, expression, key, { label });
+		if (!component) return void 0;
+		if (component.ref !== previous) yield builders.representation.addRepresentation(component, props, { tag });
+		return component.ref;
+	});
+	return _drawComponent.apply(this, arguments);
+}
+/**
+* Each chain's polymer as a cartoon, by `chainId`.
+*
+* One component per chain rather than Mol*'s `default` preset, which groups
+* every polymer chain into one: a component is the unit Mol* can hide, so a
+* component per chain is what makes a chain individually hideable.
+*
+* Every chain the file names, not just the ones the legend lists; a chain
+* with no polymer simply gets no cartoon.
+*/
+function buildCartoonLayer(_x9, _x10, _x11, _x12, _x13) {
+	return _buildCartoonLayer.apply(this, arguments);
+}
+function _buildCartoonLayer() {
+	_buildCartoonLayer = _asyncToGenerator(function* (plugin, structure, chainLabels, typeParams, colorTheme, previous = /* @__PURE__ */ new Map()) {
+		const refs = /* @__PURE__ */ new Map();
+		for (const [chainId, label] of chainLabels) {
+			const ref = yield drawComponent(plugin, structure, `${POLYMER_PART}-${chainId}`, label, chainPolymerExpression(chainId), {
+				color: colorTheme,
+				type: "cartoon",
+				typeParams
+			}, POLYMER_PART, previous.get(chainId));
+			if (ref) refs.set(chainId, ref);
+		}
+		return refs;
+	});
+	return _buildCartoonLayer.apply(this, arguments);
+}
+/**
+* Each chain's ligands and ions as ball-and-stick in element colors, by
+* `chainId`. A cartoon has no backbone to trace through a heme, so these are
+* drawn beside it; grouping them under their chain is what makes hiding a
+* chain take its ligands with it.
+*/
+function buildLigandLayer(_x14, _x15, _x16, _x17) {
+	return _buildLigandLayer.apply(this, arguments);
+}
+function _buildLigandLayer() {
+	_buildLigandLayer = _asyncToGenerator(function* (plugin, structure, chainLabels, typeParams) {
+		const refs = /* @__PURE__ */ new Map();
+		for (const [chainId, label] of chainLabels) {
+			const ref = yield drawComponent(plugin, structure, `${LIGAND_PART}-${chainId}`, label, chainLigandExpression(chainId), {
+				color: ELEMENT_THEME,
+				type: "ball-and-stick",
+				typeParams
+			}, LIGAND_PART);
+			if (ref) refs.set(chainId, ref);
+		}
+		return refs;
+	});
+	return _buildLigandLayer.apply(this, arguments);
+}
+/**
+* The highlighted residues on each chain as ball-and-stick, by `chainId`,
+* painted by the structure-wide theme - which gives them their highlight
+* colors.
+*
+* Matched by residue index rather than by number and insertion code: the index
+* is what the highlights were resolved to, and it names one residue however
+* the file spells its numbering.
+*/
+function buildHighlightLayer(_x18, _x19, _x20, _x21, _x22) {
+	return _buildHighlightLayer.apply(this, arguments);
+}
+function _buildHighlightLayer() {
+	_buildHighlightLayer = _asyncToGenerator(function* (plugin, structure, byChain, typeParams, colorTheme, previous = /* @__PURE__ */ new Map()) {
+		const refs = /* @__PURE__ */ new Map();
+		for (const [chainId, residues] of byChain) {
+			if (residues.length === 0) continue;
+			const ref = yield drawComponent(plugin, structure, `${HIGHLIGHT_PART}-${chainId}`, `Highlights on ${chainId}`, MolScriptBuilder.struct.generator.atomGroups({ "residue-test": MolScriptBuilder.core.set.has([MolScriptBuilder.set(...residues), MolScriptBuilder.ammp("residueKey")]) }), {
+				color: colorTheme,
+				type: "ball-and-stick",
+				typeParams
+			}, HIGHLIGHT_PART, previous.get(chainId));
+			if (ref) refs.set(chainId, ref);
+		}
+		return refs;
+	});
+	return _buildHighlightLayer.apply(this, arguments);
+}
+/** The polymer of the named chains, together. */
+function polymerOfChainsExpression(chainIds) {
+	return MolScriptBuilder.struct.generator.atomGroups({
+		"chain-test": MolScriptBuilder.core.set.has([MolScriptBuilder.set(...chainIds), MolScriptBuilder.ammp("auth_asym_id")]),
+		"entity-test": MolScriptBuilder.core.rel.eq([MolScriptBuilder.ammp("entityType"), "polymer"])
+	});
+}
+/**
+* Throws when a molecular surface over the structure would take more grid
+* cells than `MAX_SURFACE_GRID_CELLS`.
+*
+* Estimated the way the surface is computed: a grid at the surface's spacing
+* over the bounding box, padded on every side by the largest atom and the
+* probe rolled over it.
+*/
+function assertSurfaceBudget(structure) {
+	let maxRadius = 0;
+	const location = StructureElement.Location.create(structure);
+	for (const unit of structure.units) {
+		location.unit = unit;
+		for (let i = 0; i < unit.elements.length; i++) {
+			location.element = unit.elements[i];
+			maxRadius = Math.max(maxRadius, StructureProperties.atom.vdw_radius(location));
+		}
+	}
+	const { max, min } = structure.boundary.box;
+	const padding = maxRadius + SURFACE_PROBE_RADIUS;
+	let cells = 1;
+	for (let axis = 0; axis < 3; axis++) {
+		const extent = max[axis] - min[axis];
+		cells *= Math.ceil((extent + 2 * padding) / SURFACE_RESOLUTION);
+	}
+	if (!Number.isFinite(cells) || cells > 4e6) throw new Error("The molecular surface of the visible chains is too large to compute.");
+}
+/** What an expression selects in a structure, as a structure of its own. */
+function selectStructure(structure, expression) {
+	const selection = compile(expression)(new QueryContext(structure));
+	return StructureSelection.unionStructure(selection);
+}
+/**
+* One molecular surface over the polymers of the visible chains, or nothing
+* when no chain is visible.
+*
+* One surface rather than one per chain: where two chains meet, a surface of
+* each would wrap the interface twice over, and a surface of the pair buries
+* it - so hiding the partner is what exposes the face it was bound to.
+*
+* Built again under the same key when the visible chains change, which
+* updates the surface in place rather than replacing it. Throws, before
+* anything is built or updated, when the surface would outgrow its grid.
+*/
+function buildSurfaceLayer(_x23, _x24, _x25, _x26, _x27, _x28) {
+	return _buildSurfaceLayer.apply(this, arguments);
+}
+function _buildSurfaceLayer() {
+	_buildSurfaceLayer = _asyncToGenerator(function* (plugin, structure, visibleChainIds, typeParams, colorTheme, previous) {
+		if (visibleChainIds.length === 0) return void 0;
+		const expression = polymerOfChainsExpression(visibleChainIds);
+		if (structure.data) assertSurfaceBudget(selectStructure(structure.data, expression));
+		return drawComponent(plugin, structure, SURFACE_PART, "Surface", expression, {
+			color: colorTheme,
+			type: "molecular-surface",
+			typeParams: _objectSpread2(_objectSpread2({}, typeParams), {}, {
+				probeRadius: SURFACE_PROBE_RADIUS,
+				quality: "custom",
+				resolution: SURFACE_RESOLUTION,
+				visuals: ["structure-molecular-surface-mesh"]
+			})
+		}, SURFACE_PART, previous);
+	});
+	return _buildSurfaceLayer.apply(this, arguments);
+}
+/** Deletes components, and everything drawn over them, in one commit. */
+function removeComponents(_x29, _x30) {
+	return _removeComponents.apply(this, arguments);
+}
+function _removeComponents() {
+	_removeComponents = _asyncToGenerator(function* (plugin, refs) {
+		if (refs.length === 0) return;
+		const update = plugin.state.data.build();
+		for (const ref of refs) update.delete(ref);
+		yield update.commit();
+	});
+	return _removeComponents.apply(this, arguments);
+}
+/**
+* Shows or hides everything each chain is drawn with. The whole subtree of
+* each component, since visibility is per-cell and it is the representation
+* underneath that actually draws.
+*
+* Set outright rather than through the component manager's `toggleVisibility`,
+* which flips whatever it finds: the hidden set is derived from props on every
+* pass, so it has to be applied as a statement of what should be true and not
+* as a change to what already is.
+*/
+function applyChainVisibility(plugin, refsByChain, hidden) {
+	for (const [chainId, refs] of refsByChain) for (const ref of refs) setSubtreeVisibility(plugin.state.data, ref, hidden.has(chainId));
+}
+/**
+* Recolors the viewer's own representations with the named theme, leaving the
+* heteroatoms on `ELEMENT_THEME` and a consumer's representations as they
+* were made.
+*
+* The per-representation form of `updateRepresentationsTheme`, so the two can
+* be told apart in one pass; handing it a filtered list instead would leave
+* the ligands on whichever theme happened to be current when they were built.
+*/
+function applyColorTheme(_x31, _x32) {
+	return _applyColorTheme.apply(this, arguments);
+}
+function _applyColorTheme() {
+	_applyColorTheme = _asyncToGenerator(function* (plugin, colorTheme) {
+		yield plugin.dataTransaction(_asyncToGenerator(function* () {
+			for (const s of plugin.managers.structure.hierarchy.current.structures) {
+				const own = s.components.filter(isViewerComponent);
+				if (own.length === 0) continue;
+				yield plugin.managers.structure.component.updateRepresentationsTheme(own, (_component, representation) => ({ color: isLigandRepresentation(representation) ? ELEMENT_THEME : colorTheme }));
+			}
+		}));
+	});
+	return _applyColorTheme.apply(this, arguments);
+}
+/** A set of chain ids as one comparable string. */
+function chainSetKey(chains) {
+	return [...chains].sort().join("\0");
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/StructureScene.ts
+const emptyLayers = () => ({
+	highlight: /* @__PURE__ */ new Map(),
+	ligand: /* @__PURE__ */ new Map(),
+	polymer: {
+		cartoon: /* @__PURE__ */ new Map(),
+		drawn: "cartoon"
+	}
+});
+const polymerRefs = (layer) => [...layer.cartoon.values(), ...layer.surface ? [layer.surface] : []];
+/**
+* Objects compared by identity, as numbers a string key can carry. A new
+* `plddt` array or overlay is new data even when it holds the same values,
+* which is how the rest of the viewer treats them too.
+*/
+const identities = /* @__PURE__ */ new WeakMap();
+let nextIdentity = 1;
+function identityKey(value) {
+	if (!value) return 0;
+	let id = identities.get(value);
+	if (id === void 0) {
+		id = nextIdentity++;
+		identities.set(value, id);
+	}
+	return id;
+}
+/**
+* A structure scene on a Mol* plugin: loads a structure into it, draws it from
+* props, keeps the drawing in line with them, and places the camera.
+*
+* It takes any plugin - the viewer's own, a consumer's, or one rendering
+* offscreen - and draws the same scene on each, which is what makes an image
+* rendered without the viewer match what the viewer shows.
+*
+* Every change to the plugin's state tree - a load clearing it, an update
+* rebuilding part of it - runs through one queue, so no two ever interleave:
+* a surface half built when the next structure arrives would otherwise be
+* built on a cell that no longer exists.
+*
+* An update rebuilds only the parts whose inputs changed. Recoloring is a
+* theme update and rebuilds nothing, hiding a chain toggles its components,
+* and only the surface - which is computed over whatever is visible - is
+* rebuilt when visibility changes.
+*/
+var StructureScene = class {
+	constructor(plugin, options) {
+		this.plugin = plugin;
+		this.options = options;
+		this.tail = Promise.resolve();
+		this.pending = 0;
+		this.generation = 0;
+		this.disposed = false;
+		this.scene = null;
+		this.parsed = null;
+		this.layers = emptyLayers();
+		this.applied = null;
+		this.themes = sceneThemesFor(plugin, options.mode);
+	}
+	/** Runs `task` once everything queued before it has finished. */
+	enqueue(task) {
+		this.changePending(1);
+		const run = this.tail.then(task);
+		const settle = () => this.changePending(-1);
+		this.tail = run.then(settle, settle);
+		return run;
+	}
+	/**
+	* Clears the plugin, parses the structure, and draws it from `props` when
+	* the scene draws. Call it from inside the queue.
+	*
+	* A scene disposed of while the structure was parsing draws nothing: the
+	* plugin it would draw on is going.
+	*/
+	load(text, props) {
+		var _this = this;
+		return _asyncToGenerator(function* () {
+			const outcome = yield parseStructure(_this.plugin, text);
+			if (!outcome.ok || _this.disposed) return outcome;
+			_this.parsed = outcome.loaded;
+			const { addressIndex, chainLabels, chains, structure } = outcome.loaded;
+			if (!_this.options.draw || !structure) return outcome;
+			try {
+				_this.generation++;
+				_this.scene = {
+					addressIndex,
+					chainLabels,
+					chains,
+					structure
+				};
+				_this.layers = emptyLayers();
+				_this.applied = null;
+				yield _this.apply(props, true);
+			} catch (error) {
+				return {
+					error,
+					ok: false
+				};
+			}
+			return outcome;
+		})();
+	}
+	/** Brings the scene in line with new props. */
+	update(props) {
+		var _this2 = this;
+		const { generation } = this;
+		return this.enqueue(_asyncToGenerator(function* () {
+			if (_this2.disposed || !_this2.scene || generation !== _this2.generation) return;
+			try {
+				yield _this2.apply(props, false);
+			} catch (error) {
+				if (!_this2.disposed) _this2.options.reportError(error, "representation");
+			}
+		}));
+	}
+	/**
+	* Places the camera on the structure last loaded, as `framing` says, and
+	* returns the orientation now in force. Call it once something is drawn:
+	* Mol* settles the reset on its next frame, and one settled against an empty
+	* scene is lost.
+	*
+	* `fitDurationMs` is how long a plain fit animates; an offscreen render asks
+	* for none, so the image it takes is of the camera at rest.
+	*/
+	frame(framing, fit, fitDurationMs) {
+		const { canvas3d } = this.plugin;
+		if (!canvas3d) return void 0;
+		return frameStructure(canvas3d, framing, Boolean(framing.orientation && !framing.initialCamera) ? this.highlightsCenter(framing.highlights) : void 0, fit, fitDurationMs);
+	}
+	/** Turns the camera to an orientation, over `durationMs`. */
+	orient(orientation, highlights, durationMs) {
+		var _this$plugin$canvas3d;
+		(_this$plugin$canvas3d = this.plugin.canvas3d) === null || _this$plugin$canvas3d === void 0 || _this$plugin$canvas3d.requestCameraReset({
+			durationMs,
+			snapshot: orientationSnapshot(orientation, this.highlightsCenter(highlights))
+		});
+	}
+	/** Where the camera is now, or undefined before there is a canvas. */
+	camera() {
+		const { canvas3d } = this.plugin;
+		return canvas3d ? readCameraState(canvas3d) : void 0;
+	}
+	/** Stops the scene touching a plugin that is being disposed of. */
+	dispose() {
+		this.disposed = true;
+	}
+	/** The center of the highlighted residues on the structure last loaded. */
+	highlightsCenter(highlights) {
+		const parsed = this.parsed;
+		if (!(parsed === null || parsed === void 0 ? void 0 : parsed.structureData)) return void 0;
+		const residues = [...resolveHighlights(highlights, parsed.addressIndex).colors.keys()];
+		return residuesCenter(parsed.structureData, residues);
+	}
+	changePending(delta) {
+		var _this$options$onBusyC, _this$options;
+		const wasBusy = this.pending > 0;
+		this.pending += delta;
+		const busy = this.pending > 0;
+		if (busy !== wasBusy) (_this$options$onBusyC = (_this$options = this.options).onBusyChange) === null || _this$options$onBusyC === void 0 || _this$options$onBusyC.call(_this$options, busy);
+	}
+	apply(props, fresh) {
+		var _this3 = this;
+		return _asyncToGenerator(function* () {
+			var _this$options$onRebui, _this$options2;
+			const { plugin } = _this3;
+			const scene = _this3.scene;
+			const previous = _this3.applied;
+			const highlights = resolveHighlights(props.highlights, scene.addressIndex);
+			const coloring = {
+				chainColors: chainColorMap(scene.chains.map((chain) => chain.chainId), props.chainColors),
+				colorBy: resolveColorBy(props.colorBy, props.overlay, props.plddt),
+				highlightColors: highlights.colors,
+				mode: props.mode,
+				overlay: props.overlay,
+				plddt: props.plddt
+			};
+			const colorTheme = COLOR_THEME_NAMES[coloring.colorBy];
+			const coloringKey = [
+				coloring.colorBy,
+				[...coloring.chainColors].join(";"),
+				identityKey(props.plddt),
+				identityKey(props.overlay),
+				props.mode,
+				highlightsKey(props.highlights)
+			].join("|");
+			const hiddenKey = chainSetKey(props.hiddenChains);
+			const recolor = !previous || previous.coloringKey !== coloringKey;
+			if (recolor) syncSceneThemes(_this3.themes, coloring);
+			const typeParams = representationTypeParams(plugin);
+			const replaced = [];
+			let rebuilt = false;
+			if (!previous || previous.representation !== props.representation || props.representation === "surface" && previous.hiddenKey !== hiddenKey) {
+				replaced.push(...polymerRefs(_this3.layers.polymer));
+				_this3.layers.polymer = yield _this3.buildPolymer(scene, props, typeParams, colorTheme);
+				rebuilt = true;
+			}
+			if (fresh) _this3.layers.ligand = yield buildLigandLayer(plugin, scene.structure, scene.chainLabels, typeParams);
+			const { drawn } = _this3.layers.polymer;
+			const highlightLayerKey = `${drawn}|${residueAddressesKey(props.highlights)}`;
+			if (!previous || previous.highlightLayerKey !== highlightLayerKey) {
+				replaced.push(..._this3.layers.highlight.values());
+				_this3.layers.highlight = yield buildHighlightLayer(plugin, scene.structure, drawn === "cartoon" ? highlights.byChain : /* @__PURE__ */ new Map(), typeParams, colorTheme, _this3.layers.highlight);
+				rebuilt = true;
+			}
+			const kept = new Set([...polymerRefs(_this3.layers.polymer), ..._this3.layers.highlight.values()]);
+			yield removeComponents(plugin, replaced.filter((ref) => !kept.has(ref)));
+			if (recolor) yield applyColorTheme(plugin, colorTheme);
+			applyChainVisibility(plugin, _this3.refsByChain(), props.hiddenChains);
+			_this3.applied = {
+				coloringKey,
+				hiddenKey,
+				highlightLayerKey,
+				representation: props.representation
+			};
+			if (rebuilt && !fresh) (_this$options$onRebui = (_this$options2 = _this3.options).onRebuild) === null || _this$options$onRebui === void 0 || _this$options$onRebui.call(_this$options2);
+		})();
+	}
+	/**
+	* The polymer as the props ask: a cartoon per chain, or one surface over
+	* the visible chains - falling back to the cartoon, reported, when the
+	* surface cannot be drawn. What is already drawn is updated in place where
+	* it can be.
+	*/
+	buildPolymer(scene, props, typeParams, colorTheme) {
+		var _this4 = this;
+		return _asyncToGenerator(function* () {
+			const current = _this4.layers.polymer;
+			if (props.representation === "surface") {
+				const visible = scene.chains.map((chain) => chain.chainId).filter((chainId) => !props.hiddenChains.has(chainId));
+				try {
+					const surface = yield buildSurfaceLayer(_this4.plugin, scene.structure, visible, typeParams, colorTheme, current.surface);
+					return {
+						cartoon: /* @__PURE__ */ new Map(),
+						drawn: "surface",
+						surface
+					};
+				} catch (error) {
+					_this4.options.reportError(error, "representation");
+				}
+			}
+			return {
+				cartoon: yield buildCartoonLayer(_this4.plugin, scene.structure, scene.chainLabels, typeParams, colorTheme, current.cartoon),
+				drawn: "cartoon"
+			};
+		})();
+	}
+	/**
+	* Each chain's components, for hiding it: its cartoon, its ligands and its
+	* highlights. A surface is not among them - it is rebuilt over what is
+	* visible instead.
+	*/
+	refsByChain() {
+		const refs = /* @__PURE__ */ new Map();
+		const add = (layer) => {
+			for (const [chainId, ref] of layer) {
+				var _refs$get;
+				refs.set(chainId, [...(_refs$get = refs.get(chainId)) !== null && _refs$get !== void 0 ? _refs$get : [], ref]);
+			}
+		};
+		add(this.layers.polymer.cartoon);
+		add(this.layers.ligand);
+		add(this.layers.highlight);
+		return refs;
+	}
+};
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/applyStructureScene.ts
+/** The options as the props the scene draws from. */
+function sceneProps(options) {
+	var _options$hiddenChains, _options$mode, _options$representati;
+	return {
+		chainColors: options.chainColors,
+		colorBy: options.colorBy,
+		hiddenChains: new Set((_options$hiddenChains = options.hiddenChains) !== null && _options$hiddenChains !== void 0 ? _options$hiddenChains : []),
+		highlights: options.highlights,
+		mode: (_options$mode = options.mode) !== null && _options$mode !== void 0 ? _options$mode : "light",
+		overlay: options.residueOverlay,
+		plddt: options.plddt,
+		representation: (_options$representati = options.representation) !== null && _options$representati !== void 0 ? _options$representati : "cartoon"
+	};
+}
+/**
+* Draws a scene on a plugin and hands back its handle. `fitDurationMs` is how
+* long fitting the camera to each structure animates - none, for an image
+* taken straight after.
+*/
+function applyScene(_x2, _x3, _x4) {
+	return _applyScene.apply(this, arguments);
+}
+function _applyScene() {
+	_applyScene = _asyncToGenerator(function* (plugin, options, fitDurationMs) {
+		var _options$mode2;
+		let current = options;
+		const reportError = (error, phase) => {
+			if (current.onError) current.onError(error, phase);
+			else console.error("Failed to draw the structure:", error);
+		};
+		const scene = new StructureScene(plugin, {
+			draw: true,
+			mode: (_options$mode2 = options.mode) !== null && _options$mode2 !== void 0 ? _options$mode2 : "light",
+			reportError
+		});
+		const load = function() {
+			var _ref = _asyncToGenerator(function* (next) {
+				const outcome = yield scene.enqueue(() => scene.load(next.structure, sceneProps(next)));
+				if (!outcome.ok) throw outcome.error;
+				scene.frame(next, true, fitDurationMs);
+				return loadInfo(outcome.loaded);
+			});
+			return function load(_x) {
+				return _ref.apply(this, arguments);
+			};
+		}();
+		let info = yield load(options);
+		return {
+			dispose: () => scene.dispose(),
+			getCamera: () => scene.camera(),
+			get info() {
+				return info;
+			},
+			update(changes) {
+				return _asyncToGenerator(function* () {
+					const previous = current;
+					current = _objectSpread2(_objectSpread2({}, current), changes);
+					if (current.structure !== previous.structure) {
+						info = yield load(current);
+						return;
+					}
+					yield scene.update(sceneProps(current));
+					const { canvas3d } = plugin;
+					if (current.projection && current.projection !== previous.projection) canvas3d === null || canvas3d === void 0 || canvas3d.setProps({ camera: { mode: current.projection } });
+					if (current.orientation && current.orientation !== previous.orientation) scene.orient(current.orientation, current.highlights, 250);
+				})();
+			}
+		};
+	});
+	return _applyScene.apply(this, arguments);
+}
+/**
+* Draws a structure on a Mol* plugin of your own, the way the viewer draws it:
+* the same representations, coloring, highlights and camera, from the same
+* options its props take. Works on any plugin - one rendering offscreen, one
+* inside a viewer of your own - and resolves once the structure is drawn and
+* the camera placed on it.
+*
+* The scene clears the plugin's state to load the structure, and keeps what it
+* draws in line with `update` from then on. It adds nothing to the plugin
+* beyond the structure and its representations, and three color themes
+* registered once per plugin.
+*/
+function applyStructureScene(plugin, options) {
+	return applyScene(plugin, options);
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/axes.ts
+/**
+* The orientation axes widget, as Mol* parameterizes it.
+*
+* Shared rather than declared where it is used, because two different parts of
+* Mol* take the same shape: the live canvas takes it as
+* `camera.helper.axes`, and the screenshot helper takes it as its own `axes`,
+* so an image can carry the widget or leave it out independently of the view
+* it was captured from.
+*/
+const AXES_ON = {
+	name: "on",
+	params: {
+		alpha: .51,
+		colorX: 16711680,
+		colorY: 32768,
+		colorZ: 255,
+		labelColorX: 8421504,
+		labelColorY: 8421504,
+		labelColorZ: 8421504,
+		labelOpacity: 1,
+		labelScale: .25,
+		labelX: "X",
+		labelY: "Y",
+		labelZ: "Z",
+		location: "bottom-left",
+		locationOffsetX: 0,
+		locationOffsetY: 0,
+		originColor: 8421504,
+		planeColorXY: 8421504,
+		planeColorXZ: 8421504,
+		planeColorYZ: 8421504,
+		radiusScale: .075,
+		scale: .15,
+		showLabels: false,
+		showPlanes: true
+	}
+};
+const AXES_OFF = {
+	name: "off",
+	params: {}
+};
+//#endregion
+//#region src/core/ProteinStructureViewer/utils/screenshot.ts
+/**
+* Each resolution as the Mol* preset that produces it: 1280x720, 1920x1080,
+* 3840x2160, 7680x4320. Named here rather than given as dimensions so the
+* aspect stays Mol*'s to choose.
+*
+* Mol*'s own `viewport` preset - the canvas at its current size - is left out
+* deliberately: it makes the image depend on how big the viewer happens to be
+* on screen, which is not something a caller asking for "high" is asking for.
+*/
+const RESOLUTION_PRESETS = {
+	high: "ultra-hd",
+	low: "hd",
+	maximum: "8k-ultra-hd",
+	medium: "full-hd"
+};
+/** Painted behind the structure when a background is asked for but unreadable. */
+const FALLBACK_BACKGROUND$1 = "#ffffff";
+/** Named for a file when neither the caller nor Mol* has a better name. */
+const FALLBACK_FILENAME = "structure.png";
+/**
+* Runs `capture` with Mol*'s screenshot helper set up the way `options` asks,
+* and resolves undefined when the plugin has no helper to capture with.
+*
+* Mol*'s screenshot helper renders its own pass rather than reading the canvas
+* back, so the image is drawn fresh at the requested size and carries its own
+* transparency and axes settings - none of which disturb the view on screen.
+*
+* A named background is the one exception. The helper only chooses between
+* transparent and whatever the renderer is already painting, so a color has to
+* be put on the canvas for the length of the capture and taken off afterwards.
+* `finally` is what guarantees the second half: leaving a figure's background
+* behind on the viewer would be a worse bug than a failed download.
+*/
+function withScreenshotHelper(_x, _x2, _x3) {
+	return _withScreenshotHelper.apply(this, arguments);
+}
+function _withScreenshotHelper() {
+	_withScreenshotHelper = _asyncToGenerator(function* (plugin, options, capture) {
+		const helper = plugin.helpers.viewportScreenshot;
+		if (!helper) return void 0;
+		const { backgroundColor, resolution = "medium", showAxes } = options;
+		const transparent = backgroundColor === void 0;
+		helper.behaviors.values.next(_objectSpread2(_objectSpread2({}, helper.behaviors.values.value), {}, {
+			axes: showAxes ? AXES_ON : AXES_OFF,
+			format: {
+				name: "png",
+				params: {}
+			},
+			resolution: {
+				name: RESOLUTION_PRESETS[resolution],
+				params: {}
+			},
+			transparent
+		}));
+		const canvas3d = plugin.canvas3d;
+		const painted = canvas3d === null || canvas3d === void 0 ? void 0 : canvas3d.props.renderer.backgroundColor;
+		const overrideBackground = !transparent && canvas3d !== void 0;
+		if (overrideBackground) canvas3d === null || canvas3d === void 0 || canvas3d.setProps({ renderer: { backgroundColor: themeColor(backgroundColor, FALLBACK_BACKGROUND$1) } });
+		try {
+			return yield capture(helper);
+		} finally {
+			if (overrideBackground && painted !== void 0) canvas3d === null || canvas3d === void 0 || canvas3d.setProps({ renderer: { backgroundColor: painted } });
+		}
+	});
+	return _withScreenshotHelper.apply(this, arguments);
+}
+/**
+* Decodes a `data:` URI into a Blob.
+*
+* By hand rather than through `fetch`, which a page's `connect-src` can refuse
+* for `data:` URIs - and the sandboxed hosts that need `deliver` in the first
+* place are exactly the pages that set one.
+*/
+function blobFromDataUri(uri) {
+	const comma = uri.indexOf(",");
+	const header = uri.slice(0, comma);
+	const body = uri.slice(comma + 1);
+	const type = header.slice(5).split(";")[0] || "image/png";
+	if (!header.endsWith(";base64")) return new Blob([decodeURIComponent(body)], { type });
+	const binary = atob(body);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new Blob([bytes], { type });
+}
+/** Downloads the structure as a PNG, the capture button's default. */
+function downloadStructureImage(_x4) {
+	return _downloadStructureImage.apply(this, arguments);
+}
+function _downloadStructureImage() {
+	_downloadStructureImage = _asyncToGenerator(function* (plugin, options = {}) {
+		yield withScreenshotHelper(plugin, options, (helper) => helper.download(options.filename));
+	});
+	return _downloadStructureImage.apply(this, arguments);
+}
+/**
+* Renders the structure as a PNG and hands it back rather than downloading it,
+* the same image `downloadStructureImage` would have saved.
+*/
+function captureStructureImage(_x5) {
+	return _captureStructureImage.apply(this, arguments);
+}
+function _captureStructureImage() {
+	_captureStructureImage = _asyncToGenerator(function* (plugin, options = {}) {
+		const uri = yield withScreenshotHelper(plugin, options, (helper) => helper.getImageDataUri());
+		if (uri === void 0) throw new Error("This Mol* plugin has no screenshot helper to capture with.");
+		return blobFromDataUri(uri);
+	});
+	return _captureStructureImage.apply(this, arguments);
+}
+/**
+* The name an image is saved or delivered under: the caller's, or else the
+* one Mol* derives from the loaded structure, `.png` included either way.
+*/
+function imageFilename(plugin, filename) {
+	var _plugin$helpers$viewp, _plugin$helpers$viewp2, _plugin$helpers$viewp3;
+	if (filename) return `${filename}.png`;
+	return (_plugin$helpers$viewp = (_plugin$helpers$viewp2 = plugin.helpers.viewportScreenshot) === null || _plugin$helpers$viewp2 === void 0 || (_plugin$helpers$viewp3 = _plugin$helpers$viewp2.getFilename) === null || _plugin$helpers$viewp3 === void 0 ? void 0 : _plugin$helpers$viewp3.call(_plugin$helpers$viewp2, ".png")) !== null && _plugin$helpers$viewp !== void 0 ? _plugin$helpers$viewp : FALLBACK_FILENAME;
+}
+/**
+* What the capture button does: produces the image and gets it to the user.
+*
+* Without `render` or `deliver` this is the stock download, unchanged. With
+* them, the image comes from `render` when one is given and from the viewer's
+* own capture otherwise, and goes to `deliver` when one is given and to a
+* browser download otherwise.
+*/
+function exportStructureImage(_x6) {
+	return _exportStructureImage.apply(this, arguments);
+}
+function _exportStructureImage() {
+	_exportStructureImage = _asyncToGenerator(function* (plugin, download$1 = {}) {
+		const { deliver, filename, render } = download$1;
+		if (!render && !deliver) {
+			yield downloadStructureImage(plugin, download$1);
+			return;
+		}
+		const image = render ? yield render(plugin) : yield captureStructureImage(plugin, download$1);
+		const name = imageFilename(plugin, filename);
+		if (deliver) yield deliver(image, name);
+		else download(image, name);
+	});
+	return _exportStructureImage.apply(this, arguments);
+}
+//#endregion
+//#region src/core/ProteinStructureViewer/scene/renderStructureImage.ts
+/** Painted behind the structure when a background is asked for but unreadable. */
+const FALLBACK_BACKGROUND = "#ffffff";
+/**
+* Renders a structure to a PNG without a viewer on the page, drawn exactly as
+* the viewer would draw it from the same options - the image a caller can show
+* beside the interactive view, or hand to someone who cannot open one.
+*
+* A plugin is created for the one image, offscreen, and disposed of once it is
+* taken, whether or not taking it succeeded. The image is `width` by `height`
+* exactly: rendered at that size rather than scaled, and not cropped to the
+* structure.
+*
+* It needs a DOM and WebGL - a browser, or headless Chromium - and rejects
+* when there is no WebGL to render with.
+*/
+function renderStructureImage(_x) {
+	return _renderStructureImage.apply(this, arguments);
+}
+function _renderStructureImage() {
+	_renderStructureImage = _asyncToGenerator(function* (options) {
+		const { backgroundColor, height, width } = options;
+		if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1) throw new Error("An image needs a width and a height of at least 1.");
+		const container = document.createElement("div");
+		container.setAttribute("aria-hidden", "true");
+		container.style.cssText = `position:fixed;left:-10000px;top:0;width:${width}px;height:${height}px;pointer-events:none`;
+		const canvas = document.createElement("canvas");
+		canvas.style.cssText = "display:block;width:100%;height:100%";
+		container.append(canvas);
+		document.body.append(container);
+		const plugin = new PluginContext(DefaultPluginSpec());
+		plugin.canvas3dInitialized.catch(() => void 0);
+		try {
+			yield plugin.init();
+			const initialized = yield plugin.initViewerAsync(canvas, container);
+			const { canvas3d } = plugin;
+			const helper = plugin.helpers.viewportScreenshot;
+			if (!initialized || !canvas3d || !helper) throw new Error("WebGL is not available to render the structure.");
+			if (backgroundColor !== void 0) canvas3d.setProps({ renderer: { backgroundColor: themeColor(backgroundColor, FALLBACK_BACKGROUND) } });
+			yield applyScene(plugin, options, 0);
+			canvas3d.commit(true);
+			helper.behaviors.cropParams.next({
+				auto: false,
+				relativePadding: 0
+			});
+			helper.resetCrop();
+			helper.behaviors.values.next(_objectSpread2(_objectSpread2({}, helper.behaviors.values.value), {}, {
+				axes: AXES_OFF,
+				format: {
+					name: "png",
+					params: {}
+				},
+				resolution: {
+					name: "custom",
+					params: {
+						height,
+						width
+					}
+				},
+				transparent: backgroundColor === void 0
+			}));
+			return blobFromDataUri(yield helper.getImageDataUri());
+		} finally {
+			plugin.dispose();
+			container.remove();
+		}
+	});
+	return _renderStructureImage.apply(this, arguments);
+}
+//#endregion
+export { isEmptySelection as A, resolveSelectionAddresses as C, lociForResidueRange as D, readCameraState as E, selectionKey as M, selectionLabel as N, lociForSelection as O, selectionResidues as P, residueAddressesKey as S, camerasEqual as T, chainColorMap as _, applyStructureScene as a, _asyncToGenerator as b, resolveColorBy as c, injectPlddt as d, injectPlddtIntoMmcif as f, themeColor as g, highlightsKey as h, AXES_ON as i, meanOverResidues as j, lociOutsideChains as k, PLDDT_BAND_COLORS as l, HIGHLIGHT_COLOR_PALETTE as m, exportStructureImage as n, StructureScene as o, injectPlddtIntoPdb as p, AXES_OFF as r, chainSetKey as s, renderStructureImage as t, PLDDT_COLOR_SCALE as u, NOTHING_LOADED as v, chainsEqual as w, detectStructureFormat as x, loadInfo as y };