@classytic/stage 0.2.0 → 0.4.0

package/dist/chem/lewis.d.mts

@@ -0,0 +1,79 @@
+import { Centre } from "./species.mjs";
+
+//#region src/chem/lewis.d.ts
+/** Valence electrons of an element, from its configuration. */
+declare function valenceElectronsFor(symbol: string): number;
+interface LewisCount {
+  /** Valence electrons of all the atoms, adjusted for the overall charge. */
+  readonly totalValenceElectrons: number;
+  /** Sigma bonds from the central atom, one per ligand atom. */
+  readonly bondingPairs: number;
+  /** Lone pairs left on the central atom. */
+  readonly lonePairs: number;
+  /**
+   * Bonding pairs plus lone pairs: the number of regions of electron density.
+   *
+   * Pi bonds are deliberately NOT counted. A double bond points the same way as the single bond
+   * underneath it, so it is one region, which is why carbon dioxide is linear.
+   */
+  readonly stericNumber: number;
+  /**
+   * Pi bonds formed by pulling a lone pair off an outer atom into the bond.
+   *
+   * Derived rather than guessed. Every pi bond moves the central atom's formal charge one step
+   * toward zero and the donating atom's one step away from it, so they are added while that trade
+   * is an improvement and stopped when it is not. Two guards end the process:
+   *
+   *   the central atom's formal charge reaches zero, so there is nothing left to gain;
+   *   the donor would end up positively charged while being MORE electronegative than the centre,
+   *   which is the situation no real structure adopts.
+   *
+   * That second guard is the whole of the difference between carbon dioxide and boron trifluoride.
+   * Carbon starts at +2 with two oxygens at -1, and two pi bonds take all three to zero. Boron
+   * starts at 0 already, so no pi bond would improve anything, and one would push fluorine, the most
+   * electronegative element there is, to +1.
+   */
+  readonly piBonds: number;
+  /** Bond order to each outer atom, in the order the formula writes them. */
+  readonly bondOrders: readonly {
+    readonly element: string;
+    readonly order: number;
+  }[];
+  /** Electrons around the central atom, pi bonds included. */
+  readonly centralElectrons: number;
+  /**
+   * How many electrons short of an octet the central atom REMAINS once pi bonding has done what it
+   * can.
+   *
+   * Zero for carbon dioxide, which closes its gap completely. Two for boron trifluoride, which
+   * cannot close it at all and is genuinely electron deficient: that is not a limitation of the
+   * calculation, it is the reason boron trifluoride is such a strong Lewis acid.
+   */
+  readonly octetShortfall: number;
+  /**
+   * Formal charge on the central atom in the structure this record describes.
+   *
+   * Worth being precise about, because formal charge belongs to a STRUCTURE and not to a species.
+   * Carbon dioxide drawn with single bonds gives its carbon +2 and drawn with two double bonds gives
+   * it 0, and both are statements about drawings. This is the charge in the pi-bonded structure the
+   * rest of this record describes, which is the one a chemist would draw.
+   */
+  readonly formalCharge: number;
+  /** Whether the central atom can hold more than eight, which needs an accessible d subshell. */
+  readonly canExpand: boolean;
+  /** Set when the count needs more than an octet on an atom that cannot hold one. */
+  readonly impossible?: string;
+}
+/**
+ * Work out the electron budget of a species.
+ *
+ * Returns the count rather than a drawing: where the electrons GO on the page is a layout decision,
+ * and how many there are is chemistry.
+ */
+declare function lewisCount(centre: Centre): LewisCount;
+/** How the central atom's electron count compares with an octet. */
+type OctetStatus = 'short of an octet' | 'an octet' | 'an expanded octet';
+/** Whether the central atom has fewer than eight electrons, eight, or more. */
+declare function octetStatus(count: LewisCount): OctetStatus;
+//#endregion
+export { LewisCount, OctetStatus, lewisCount, octetStatus, valenceElectronsFor };

package/dist/chem/lewis.mjs

@@ -0,0 +1,163 @@
+import { periodOf, valenceElectronsOf } from "../atomic/periodic.mjs";
+import { elementBySymbol } from "../atomic/elements.mjs";
+import { electronegativity } from "../atomic/properties.mjs";
+
+//#region src/chem/lewis.ts
+/**
+* The electron budget of a species: how many bonding pairs and how many lone pairs.
+*
+* ## The counting, stated once
+*
+* Every shape question reduces to two numbers, and both come out of one budget:
+*
+*   1. total valence electrons = the valence electrons of every atom, plus one for each unit of
+*      negative charge and minus one for each unit of positive charge;
+*   2. one sigma bond to each ligand uses two of them;
+*   3. each non-hydrogen ligand then takes six more to complete its own octet (hydrogen takes none,
+*      because its bonding pair already fills its shell);
+*   4. whatever is left belongs to the central atom, as lone pairs.
+*
+* That is the whole method, and it gets SF4, XeF2, ClF3, NH4+ and SO4 right with no special cases.
+*
+* ## Multiple bonds, decided by formal charge
+*
+* Where the central atom ends up short of an octet, that gap is what multiple bonding closes. The
+* question is whether it actually does, and the answer is not in the electron count: carbon dioxide
+* closes its gap completely and boron trifluoride cannot close it at all.
+*
+* Formal charge settles it, with electronegativity as the guard. Every pi bond moves the central
+* atom one step toward zero and the donating outer atom one step away, so pi bonds are added while
+* that trade improves the structure and stopped when it does not:
+*
+*   carbon dioxide starts as C(+2) with two O(-1), and two pi bonds take all three to zero;
+*   boron trifluoride starts at B(0) with three F(0), so no pi bond improves anything, and one
+*   would push fluorine, the most electronegative element there is, to +1.
+*
+* That is the whole difference between them, and it needs no special case for either. A second-
+* period centre is additionally capped at an octet, which is why nitrate gets exactly one double
+* bond and leaves its nitrogen at +1 rather than reaching zero.
+*
+* None of it affects the shape. A double bond points the same way as the single bond underneath it
+* and is one region of electron density, which is why carbon dioxide is linear.
+*
+* ## Where the valence electron counts come from
+*
+* From the atomic engine, not from a table typed out here. An element's valence electron count is
+* already a consequence of its configuration, and duplicating it would let the two disagree. So
+* oxygen having six and xenon having eight is derived in one place and used here.
+*
+* ## On the octet rule and its exceptions
+*
+* The octet rule is a useful summary of the second period and is broken routinely below it. This
+* engine does not enforce it: it counts electrons and REPORTS whether the central atom ended up
+* with fewer than eight, exactly eight, or more. Boron trifluoride comes out with six and sulfur
+* hexafluoride with twelve, and both are correct, so a rule that forbade them would be a rule that
+* had to be switched off for the interesting cases.
+*
+* Expansion beyond eight needs d orbitals close enough in energy to be used, which is why it starts
+* in the third period. {@link LewisCount.canExpand} says whether the central atom is in a position
+* to do it, so a count that expands a second-period atom can be flagged as impossible rather than
+* reported as fact.
+*
+* Pure: no React, no pixels.
+*/
+/** Valence electrons of an element, from its configuration. */
+function valenceElectronsFor(symbol) {
+	const element = elementBySymbol(symbol);
+	if (!element) throw new Error(`no element with symbol "${symbol}"`);
+	return valenceElectronsOf(element.Z);
+}
+/** Electrons a ligand needs beyond its bonding pair to fill its own shell. */
+function ligandDemand(symbol) {
+	return symbol === "H" ? 0 : 6;
+}
+/**
+* Work out the electron budget of a species.
+*
+* Returns the count rather than a drawing: where the electrons GO on the page is a layout decision,
+* and how many there are is chemistry.
+*/
+function lewisCount(centre) {
+	const centralValence = valenceElectronsFor(centre.central);
+	const totalValenceElectrons = centralValence + centre.bonded.reduce((total, l) => total + valenceElectronsFor(l.element) * l.count, 0) - centre.charge;
+	const bondingPairs = centre.bondedCount;
+	const usedBySigma = 2 * bondingPairs;
+	const demandedByLigands = centre.bonded.reduce((total, l) => total + ligandDemand(l.element) * l.count, 0);
+	const leftForCentre = totalValenceElectrons - usedBySigma - demandedByLigands;
+	const lonePairs = Math.max(0, Math.floor(leftForCentre / 2));
+	const stericNumber = bondingPairs + lonePairs;
+	const singleBondElectrons = 2 * bondingPairs + 2 * lonePairs;
+	const period = periodOf(elementBySymbol(centre.central).Z);
+	const canExpand = period >= 3;
+	const bondOrders = shareOutPiBonds(centre, {
+		centralValence,
+		lonePairs,
+		bondingPairs,
+		singleBondElectrons,
+		canExpand
+	});
+	const piBonds = bondOrders.reduce((total, b) => total + b.order - 1, 0);
+	const centralElectrons = singleBondElectrons + 2 * piBonds;
+	const octetShortfall = Math.max(0, 8 - centralElectrons);
+	const formalCharge = centralValence - 2 * lonePairs - (bondingPairs + piBonds);
+	let impossible;
+	if (leftForCentre < 0) impossible = `${centre.formula} has ${totalValenceElectrons} valence electrons, which is ${-leftForCentre} short of what its ${bondingPairs} bonds and its outer atoms need: check the formula and the charge`;
+	else if (singleBondElectrons > 8 && !canExpand) impossible = `${centre.central} is in period ${period} and has no d subshell available, so it cannot hold the ${singleBondElectrons} electrons this arrangement needs`;
+	return {
+		totalValenceElectrons,
+		bondingPairs,
+		lonePairs,
+		stericNumber,
+		piBonds,
+		bondOrders,
+		centralElectrons,
+		octetShortfall,
+		formalCharge,
+		canExpand,
+		...impossible ? { impossible } : {}
+	};
+}
+/** Formal charge on an outer atom holding `pi` extra bonds beyond its single one. */
+const outerFormalCharge = (symbol, pi) => valenceElectronsFor(symbol) - 2 * (3 - pi) - (1 + pi);
+/**
+* Decide how many pi bonds form, and to which outer atoms.
+*
+* Greedy and one bond at a time, because that is what the reasoning actually is: would drawing one
+* more double bond here make the structure better? Better means the central atom's formal charge
+* moves toward zero without pushing a more electronegative neighbour above it.
+*
+* Spread across the outer atoms rather than piled onto one, so carbon dioxide comes out as two
+* double bonds and not as a triple and a single. Both satisfy the counting; only one of them is the
+* molecule.
+*/
+function shareOutPiBonds(centre, state) {
+	const orders = centre.bonded.flatMap((b) => Array.from({ length: b.count }, () => ({
+		element: b.element,
+		order: 1
+	})));
+	const centralPull = electronegativity(elementBySymbol(centre.central).Z);
+	for (;;) {
+		const piSoFar = orders.reduce((total, b) => total + b.order - 1, 0);
+		if (state.centralValence - 2 * state.lonePairs - (state.bondingPairs + piSoFar) <= 0) break;
+		if (!state.canExpand && state.singleBondElectrons + 2 * (piSoFar + 1) > 8) break;
+		const donor = orders.filter((bond) => {
+			if (bond.element === "H" || bond.order >= 4) return false;
+			if (outerFormalCharge(bond.element, bond.order) <= 0) return true;
+			const donorPull = electronegativity(elementBySymbol(bond.element).Z);
+			if (donorPull === void 0 || centralPull === void 0) return false;
+			return donorPull <= centralPull;
+		}).sort((a, b) => a.order - b.order)[0];
+		if (!donor) break;
+		donor.order += 1;
+	}
+	return orders;
+}
+/** Whether the central atom has fewer than eight electrons, eight, or more. */
+function octetStatus(count) {
+	if (count.centralElectrons < 8) return "short of an octet";
+	if (count.centralElectrons === 8) return "an octet";
+	return "an expanded octet";
+}
+
+//#endregion
+export { lewisCount, octetStatus, valenceElectronsFor };

package/dist/chem/molecular-orbital.d.mts

@@ -0,0 +1,114 @@
+//#region src/chem/molecular-orbital.d.ts
+/**
+ * Molecular orbitals for a diatomic: bond order, and whether the molecule is magnetic.
+ *
+ * ## What this explains that dot-and-cross cannot
+ *
+ * Oxygen is paramagnetic. Liquid oxygen sticks to a magnet, which is a thing anyone can watch, and
+ * the Lewis structure O=O has every electron neatly paired and predicts the opposite. That failure
+ * is the reason molecular orbital theory is taught at all: put the electrons into orbitals that
+ * belong to the whole molecule rather than to one atom or one bond, and two of them end up alone in
+ * a pair of degenerate antibonding orbitals.
+ *
+ * So this engine answers two questions a Lewis structure cannot: how strongly the atoms are held
+ * together when the answer is not a whole number, and whether the molecule has unpaired electrons.
+ *
+ *     bond order = (bonding electrons - antibonding electrons) / 2
+ *
+ * A bond order of zero means the molecule does not exist, which is why there is no He2 and no Ne2.
+ *
+ * ## The crossover, which is the part usually left out
+ *
+ * The order of the 2p-derived orbitals is not fixed. For the earlier second-period elements the two
+ * pi orbitals lie BELOW the sigma; from oxygen onward the sigma drops below the pi. The cause is
+ * mixing between the 2s and 2p sigma orbitals, which pushes the sigma up, and it matters most where
+ * the 2s and 2p levels are closest together, which is at the left of the period.
+ *
+ * This is not a detail. Boron's B2 has exactly two electrons to place in that region: with pi
+ * lowest they go one into each pi orbital and B2 is paramagnetic, which it is; with sigma lowest
+ * they pair up in it and B2 would be diamagnetic, which it is not. So an engine that ignored the
+ * crossover would get the right bond order and the wrong magnetism, and the magnetism is the
+ * evidence.
+ *
+ * ## What is covered
+ *
+ * Diatomics of the first two periods, neutral or charged: H2, He2, Li2 through Ne2, and the
+ * heteronuclear and ionic ones built from the same orbitals, so NO, CO, CN- and the oxygen family
+ * O2+, O2-, O2 2-. Core electrons are left out: they sit in bonding and antibonding pairs that
+ * cancel exactly, so they change no answer and only lengthen the diagram.
+ *
+ * Pure: no React, no pixels.
+ */
+interface MolecularOrbital {
+  readonly label: string;
+  readonly bonding: boolean;
+  /** How many orbitals are at this energy: two for a pi level, one for a sigma. */
+  readonly orbitals: number;
+}
+/**
+ * Where the sigma made from 2p sits relative to the pair of pi orbitals.
+ *
+ * Mixing with the 2s sigma pushes the 2p sigma up, and the effect is strongest where 2s and 2p are
+ * closest in energy, which is toward the left of the period. So the pi orbitals are lower for the
+ * earlier elements and the sigma is lower from oxygen onward.
+ */
+declare const S_P_MIXING_NOTE = "The sigma orbital built from 2p is pushed up by mixing with the sigma built from 2s, and that mixing is strongest where the 2s and 2p levels lie closest together, toward the left of the period. So for boron, carbon and nitrogen the two pi orbitals lie below the sigma, and from oxygen onward the sigma drops below them.";
+/** The orbitals in energy order, for a diatomic with this many valence electrons. */
+declare function orbitalSequence(valenceElectrons: number, firstPeriod: boolean): readonly MolecularOrbital[];
+interface Level {
+  readonly orbital: MolecularOrbital;
+  readonly electrons: number;
+  /** Electrons in this level with no partner, by Hund's rule. */
+  readonly unpaired: number;
+}
+/**
+ * Fill the orbitals from the bottom, singly across a degenerate level before pairing.
+ *
+ * Hund's rule again, and for the same reason it applies inside an atom: two electrons in one
+ * orbital repel, so they spread out while there is anywhere to spread to. It is what leaves oxygen
+ * with two unpaired electrons instead of one filled antibonding orbital.
+ */
+declare function fillOrbitals(sequence: readonly MolecularOrbital[], electrons: number): {
+  levels: Level[];
+  unpaired: number;
+  unplaced: number;
+};
+type Magnetism = 'paramagnetic' | 'diamagnetic';
+interface DiatomicResult {
+  readonly formula: string;
+  readonly atoms: readonly string[];
+  readonly charge: number;
+  /** Valence electrons only: core pairs cancel and change no answer. */
+  readonly valenceElectrons: number;
+  readonly levels: readonly Level[];
+  readonly bondingElectrons: number;
+  readonly antibondingElectrons: number;
+  /**
+   * (bonding - antibonding) / 2, so it can be a half.
+   *
+   * A half-integer bond order is not a rounding error: it is what an odd number of electrons gives,
+   * and it is why nitrogen monoxide exists as a stable radical with a bond between a double and a
+   * triple.
+   */
+  readonly bondOrder: number;
+  readonly unpairedElectrons: number;
+  readonly magnetism: Magnetism;
+  /** A bond order of zero means there is nothing holding the atoms together. */
+  readonly exists: boolean;
+  /** True when the pi orbitals lie below the sigma, which is the crossover. */
+  readonly piBelowSigma: boolean;
+}
+/**
+ * Work out the molecular orbitals of a diatomic written as a formula.
+ *
+ * `diatomic('O2')`, `diatomic('N2')`, `diatomic('NO')`, `diatomic('CN-')`, `diatomic('O2+')`.
+ */
+declare function diatomic(formula: string): DiatomicResult;
+/**
+ * The configuration written out, for a diagram caption.
+ *
+ * Empty levels are dropped, since writing them adds nothing a reader needs.
+ */
+declare const formatOccupancy: (result: DiatomicResult) => string;
+//#endregion
+export { DiatomicResult, Level, Magnetism, MolecularOrbital, S_P_MIXING_NOTE, diatomic, fillOrbitals, formatOccupancy, orbitalSequence };

package/dist/chem/molecular-orbital.mjs

@@ -0,0 +1,201 @@
+import { readFormula } from "./species.mjs";
+import { valenceElectronsFor } from "./lewis.mjs";
+
+//#region src/chem/molecular-orbital.ts
+/**
+* Molecular orbitals for a diatomic: bond order, and whether the molecule is magnetic.
+*
+* ## What this explains that dot-and-cross cannot
+*
+* Oxygen is paramagnetic. Liquid oxygen sticks to a magnet, which is a thing anyone can watch, and
+* the Lewis structure O=O has every electron neatly paired and predicts the opposite. That failure
+* is the reason molecular orbital theory is taught at all: put the electrons into orbitals that
+* belong to the whole molecule rather than to one atom or one bond, and two of them end up alone in
+* a pair of degenerate antibonding orbitals.
+*
+* So this engine answers two questions a Lewis structure cannot: how strongly the atoms are held
+* together when the answer is not a whole number, and whether the molecule has unpaired electrons.
+*
+*     bond order = (bonding electrons - antibonding electrons) / 2
+*
+* A bond order of zero means the molecule does not exist, which is why there is no He2 and no Ne2.
+*
+* ## The crossover, which is the part usually left out
+*
+* The order of the 2p-derived orbitals is not fixed. For the earlier second-period elements the two
+* pi orbitals lie BELOW the sigma; from oxygen onward the sigma drops below the pi. The cause is
+* mixing between the 2s and 2p sigma orbitals, which pushes the sigma up, and it matters most where
+* the 2s and 2p levels are closest together, which is at the left of the period.
+*
+* This is not a detail. Boron's B2 has exactly two electrons to place in that region: with pi
+* lowest they go one into each pi orbital and B2 is paramagnetic, which it is; with sigma lowest
+* they pair up in it and B2 would be diamagnetic, which it is not. So an engine that ignored the
+* crossover would get the right bond order and the wrong magnetism, and the magnetism is the
+* evidence.
+*
+* ## What is covered
+*
+* Diatomics of the first two periods, neutral or charged: H2, He2, Li2 through Ne2, and the
+* heteronuclear and ionic ones built from the same orbitals, so NO, CO, CN- and the oxygen family
+* O2+, O2-, O2 2-. Core electrons are left out: they sit in bonding and antibonding pairs that
+* cancel exactly, so they change no answer and only lengthen the diagram.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* Where the sigma made from 2p sits relative to the pair of pi orbitals.
+*
+* Mixing with the 2s sigma pushes the 2p sigma up, and the effect is strongest where 2s and 2p are
+* closest in energy, which is toward the left of the period. So the pi orbitals are lower for the
+* earlier elements and the sigma is lower from oxygen onward.
+*/
+const S_P_MIXING_NOTE = "The sigma orbital built from 2p is pushed up by mixing with the sigma built from 2s, and that mixing is strongest where the 2s and 2p levels lie closest together, toward the left of the period. So for boron, carbon and nitrogen the two pi orbitals lie below the sigma, and from oxygen onward the sigma drops below them.";
+/** Valence electron count at or below which the pi orbitals lie below the sigma. */
+const MIXING_LIMIT = 10;
+const PERIOD_1 = [{
+	label: "σ1s",
+	bonding: true,
+	orbitals: 1
+}, {
+	label: "σ*1s",
+	bonding: false,
+	orbitals: 1
+}];
+const PI_BELOW_SIGMA = [
+	{
+		label: "σ2s",
+		bonding: true,
+		orbitals: 1
+	},
+	{
+		label: "σ*2s",
+		bonding: false,
+		orbitals: 1
+	},
+	{
+		label: "π2p",
+		bonding: true,
+		orbitals: 2
+	},
+	{
+		label: "σ2p",
+		bonding: true,
+		orbitals: 1
+	},
+	{
+		label: "π*2p",
+		bonding: false,
+		orbitals: 2
+	},
+	{
+		label: "σ*2p",
+		bonding: false,
+		orbitals: 1
+	}
+];
+const SIGMA_BELOW_PI = [
+	{
+		label: "σ2s",
+		bonding: true,
+		orbitals: 1
+	},
+	{
+		label: "σ*2s",
+		bonding: false,
+		orbitals: 1
+	},
+	{
+		label: "σ2p",
+		bonding: true,
+		orbitals: 1
+	},
+	{
+		label: "π2p",
+		bonding: true,
+		orbitals: 2
+	},
+	{
+		label: "π*2p",
+		bonding: false,
+		orbitals: 2
+	},
+	{
+		label: "σ*2p",
+		bonding: false,
+		orbitals: 1
+	}
+];
+/** The orbitals in energy order, for a diatomic with this many valence electrons. */
+function orbitalSequence(valenceElectrons, firstPeriod) {
+	if (firstPeriod) return PERIOD_1;
+	return valenceElectrons <= MIXING_LIMIT ? PI_BELOW_SIGMA : SIGMA_BELOW_PI;
+}
+/**
+* Fill the orbitals from the bottom, singly across a degenerate level before pairing.
+*
+* Hund's rule again, and for the same reason it applies inside an atom: two electrons in one
+* orbital repel, so they spread out while there is anywhere to spread to. It is what leaves oxygen
+* with two unpaired electrons instead of one filled antibonding orbital.
+*/
+function fillOrbitals(sequence, electrons) {
+	let left = electrons;
+	const levels = sequence.map((orbital) => {
+		const capacity = 2 * orbital.orbitals;
+		const placed = Math.min(left, capacity);
+		left -= placed;
+		return {
+			orbital,
+			electrons: placed,
+			unpaired: placed <= orbital.orbitals ? placed : 2 * orbital.orbitals - placed
+		};
+	});
+	return {
+		levels,
+		unpaired: levels.reduce((total, l) => total + l.unpaired, 0),
+		unplaced: left
+	};
+}
+/**
+* Work out the molecular orbitals of a diatomic written as a formula.
+*
+* `diatomic('O2')`, `diatomic('N2')`, `diatomic('NO')`, `diatomic('CN-')`, `diatomic('O2+')`.
+*/
+function diatomic(formula) {
+	const { counts, charge } = readFormula(formula);
+	const atoms = counts.flatMap((c) => Array(c.count).fill(c.element));
+	if (atoms.length !== 2) throw new Error(`${formula} has ${atoms.length} atoms: this engine describes diatomic molecules, which have two`);
+	const firstPeriod = atoms.every((a) => a === "H" || a === "He");
+	const valenceElectrons = atoms.reduce((total, a) => total + valenceElectronsFor(a), 0) - charge;
+	if (valenceElectrons < 0) throw new Error(`${formula} works out to a negative electron count`);
+	const piBelowSigma = !firstPeriod && valenceElectrons <= MIXING_LIMIT;
+	const { levels, unpaired, unplaced } = fillOrbitals(orbitalSequence(valenceElectrons, firstPeriod), valenceElectrons);
+	if (unplaced > 0) throw new Error(`${formula} has ${valenceElectrons} valence electrons, more than the orbitals of the first two periods can hold`);
+	const bondingElectrons = levels.filter((l) => l.orbital.bonding).reduce((total, l) => total + l.electrons, 0);
+	const antibondingElectrons = levels.filter((l) => !l.orbital.bonding).reduce((total, l) => total + l.electrons, 0);
+	const bondOrder = (bondingElectrons - antibondingElectrons) / 2;
+	return {
+		formula,
+		atoms,
+		charge,
+		valenceElectrons,
+		levels,
+		bondingElectrons,
+		antibondingElectrons,
+		bondOrder,
+		unpairedElectrons: unpaired,
+		magnetism: unpaired > 0 ? "paramagnetic" : "diamagnetic",
+		exists: bondOrder > 0,
+		piBelowSigma
+	};
+}
+/**
+* The configuration written out, for a diagram caption.
+*
+* Empty levels are dropped, since writing them adds nothing a reader needs.
+*/
+const formatOccupancy = (result) => result.levels.filter((l) => l.electrons > 0).map((l) => `${l.orbital.label}${l.electrons === 1 ? "" : superscript(l.electrons)}`).join(" ");
+const SUPERSCRIPT = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+const superscript = (value) => String(value).split("").map((d) => SUPERSCRIPT[Number(d)] ?? d).join("");
+
+//#endregion
+export { S_P_MIXING_NOTE, diatomic, fillOrbitals, formatOccupancy, orbitalSequence };