@classytic/stage 0.2.0 → 0.4.0

package/dist/chem/nmr.mjs

@@ -0,0 +1,165 @@
+//#region src/chem/nmr.ts
+/**
+* Chemical shift ranges, in ppm, as the 9701 data booklet gives them.
+*
+* Ranges, never single values, because that is what the booklet prints and because a learner who
+* memorises "2.2" for a ketone cannot place a shift of 2.4. The question is always which RANGE a
+* peak falls in.
+*/
+const SHIFT_RANGES = {
+	alkane: {
+		from: .9,
+		to: 1.7,
+		environment: "R-CH3, R-CH2-R, R3CH"
+	},
+	"alkyl-next-to-carbonyl": {
+		from: 2,
+		to: 2.9,
+		environment: "CH3-CO-, -CH2-CO-"
+	},
+	"alkyl-next-to-halogen": {
+		from: 3.2,
+		to: 4,
+		environment: "R-CH2-Cl or R-CH2-Br"
+	},
+	"alkyl-next-to-oxygen": {
+		from: 3.3,
+		to: 4.3,
+		environment: "R-CH2-O-"
+	},
+	alcohol: {
+		from: .5,
+		to: 6,
+		environment: "R-O-H"
+	},
+	amine: {
+		from: 1,
+		to: 5,
+		environment: "R-N-H"
+	},
+	alkene: {
+		from: 4.5,
+		to: 6,
+		environment: "R2C=CH2"
+	},
+	arene: {
+		from: 6,
+		to: 9,
+		environment: "aromatic H"
+	},
+	aldehyde: {
+		from: 9.3,
+		to: 10.5,
+		environment: "R-CHO"
+	},
+	"carboxylic-acid": {
+		from: 9,
+		to: 13,
+		environment: "R-COOH"
+	}
+};
+/** The name for a number of lines. Beyond five, a spectrum is reported as a multiplet. */
+const MULTIPLICITY_NAMES = [
+	"singlet",
+	"doublet",
+	"triplet",
+	"quartet",
+	"quintet",
+	"sextet",
+	"septet"
+];
+/**
+* The n + 1 rule.
+*
+* An exchangeable proton is always a singlet and never splits anything, because it swaps between
+* molecules faster than the machine can see it.
+*/
+function multiplicityOf(neighbours, exchangeable = false) {
+	if (exchangeable) return "singlet";
+	return MULTIPLICITY_NAMES[neighbours + 1 - 1] ?? "multiplet";
+}
+/**
+* Relative heights of the lines in a multiplet: a row of Pascal's triangle.
+*
+* A quartet is 1:3:3:1, not four equal lines. It matters because the outer lines of a large
+* multiplet sink into the baseline, which is why a septet is so often reported as a quintet.
+*/
+function splittingPattern(lines) {
+	const row = [1];
+	for (let i = 1; i < lines; i += 1) row.push(row[i - 1] * (lines - i) / i);
+	return row;
+}
+const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+/**
+* Integration as the smallest whole-number ratio.
+*
+* A spectrum reports 2:3, not 4:6, because the integration gives the RATIO of protons and never
+* their number. That distinction is the one an exam question turns on: a 2:3 ratio fits both
+* C2H5-OH and C4H10O2, and the molecular formula is what settles it.
+*/
+function integrationRatio(environments) {
+	const counts = environments.map((e) => e.protons);
+	if (counts.length === 0) return [];
+	const divisor = counts.reduce((a, b) => gcd(a, b));
+	return counts.map((n) => n / divisor);
+}
+/**
+* Predict the spectrum.
+*
+* Refuses a declaration that contradicts itself rather than drawing a spectrum nobody could have
+* measured: a peak outside the range it claims, or an exchangeable proton given neighbours to
+* couple to. Both are ways a hand-authored figure goes quietly wrong.
+*/
+function predictNmr(molecule) {
+	const ratio = integrationRatio(molecule.environments);
+	return {
+		molecule,
+		peaks: [...molecule.environments.map((env, i) => {
+			const range = SHIFT_RANGES[env.shift];
+			if (!range) throw new Error(`${env.label}: "${env.shift}" is not a shift range in the booklet.`);
+			if (env.ppm < range.from || env.ppm > range.to) throw new Error(`${env.label}: ${env.ppm} ppm is outside the ${range.from} to ${range.to} range for ${env.shift}.`);
+			if (env.exchangeable && env.neighbours > 0) throw new Error(`${env.label}: an exchangeable proton cannot be coupled, so it must have 0 neighbours.`);
+			const multiplicity = multiplicityOf(env.neighbours, env.exchangeable);
+			const lines = env.exchangeable ? 1 : env.neighbours + 1;
+			return {
+				label: env.label,
+				ppm: env.ppm,
+				protons: env.protons,
+				integration: ratio[i],
+				multiplicity,
+				lines,
+				pattern: splittingPattern(lines),
+				range,
+				exchangeable: env.exchangeable === true
+			};
+		})].sort((a, b) => b.ppm - a.ppm),
+		totalProtons: molecule.environments.reduce((n, e) => n + e.protons, 0)
+	};
+}
+/**
+* The spectrum after a drop of D2O, with every exchangeable peak gone.
+*
+* The experiment exists to answer one question: is that broad singlet an O-H? Running it is how a
+* learner tells an alcohol from an ether without any other evidence, and doing it as a computation
+* rather than a second hand-drawn figure means the two spectra cannot disagree.
+*/
+const afterD2O = (spectrum) => ({
+	...spectrum,
+	peaks: spectrum.peaks.filter((p) => !p.exchangeable),
+	totalProtons: spectrum.peaks.filter((p) => !p.exchangeable).reduce((n, p) => n + p.protons, 0)
+});
+/**
+* The line positions of one peak, in ppm, given the coupling constant.
+*
+* `J` is in hertz and a spectrum is in ppm, so the conversion needs the spectrometer frequency.
+* That is not a detail to hide: it is why the same molecule gives the same splitting PATTERN on
+* every machine while the lines sit closer together on a stronger one.
+*/
+function linePositions(peak, jHz = 7, spectrometerMHz = 100) {
+	const spacing = jHz / spectrometerMHz;
+	const first = peak.ppm - spacing * (peak.lines - 1) / 2;
+	return Array.from({ length: peak.lines }, (_, i) => first + i * spacing);
+}
+
+//#endregion
+export { MULTIPLICITY_NAMES, SHIFT_RANGES, afterD2O, integrationRatio, linePositions, multiplicityOf, predictNmr, splittingPattern };

package/dist/chem/polymer.d.mts

@@ -0,0 +1,65 @@
+import { Structure } from "./molecule.mjs";
+
+//#region src/chem/polymer.d.ts
+type PolymerKind = 'addition' | 'condensation';
+/** What the two link points are: an ester link, an amide link, or a plain carbon-carbon bond. */
+type LinkKind = 'carbon-carbon' | 'ester' | 'amide';
+interface RepeatUnit {
+  readonly kind: PolymerKind;
+  readonly link: LinkKind;
+  /** The unit itself, with the two atoms that bond onto the neighbouring units. */
+  readonly structure: Structure;
+  /** Atom ids in `structure` that join to the previous and the next unit. */
+  readonly linkAtoms: readonly [number, number];
+  /** The molecular formula of one repeat unit. */
+  readonly formula: string;
+  readonly mass: number;
+  /** The small molecule lost per link, for a condensation. `undefined` for addition. */
+  readonly lost?: {
+    readonly formula: string;
+    readonly mass: number;
+  };
+  /** Why this monomer or pair polymerises the way it does, in the words a mark scheme uses. */
+  readonly reason: string;
+}
+/**
+ * Open the double bond of an alkene to give the addition repeat unit.
+ *
+ * Refuses a monomer with no C=C, because "it must be addition" is a guess a learner makes and a
+ * kernel should not. The formula is unchanged by construction, and the test asserts it.
+ */
+declare function addition(monomer: Structure): RepeatUnit;
+/**
+ * Can this monomer sustain a chain?
+ *
+ * Two reactive groups, or the chain stops after one join. Ethanoic acid has one and is therefore a
+ * dead end; hexanedioic acid has two and is not. This is the check most treatments leave out and
+ * the reason a learner cannot predict whether a new monomer will polymerise.
+ */
+declare const canSustainChain: (monomer: Structure) => boolean;
+/**
+ * Join two monomers and eliminate water, giving the condensation repeat unit.
+ *
+ * The pairing is decided by the groups that are actually present, not by an argument the caller
+ * passes: an acid with an alcohol gives an ester link and an acid with an amine gives an amide link,
+ * and those are the only two the syllabus needs. A pair that cannot make either is refused with the
+ * reason, because "nothing happened" is not a useful answer to a learner.
+ */
+declare function condensation(first: Structure, second: Structure): RepeatUnit;
+/**
+ * The mass of a chain of `n` repeat units.
+ *
+ * For an addition polymer it is n times the monomer. For a condensation polymer the water has
+ * already gone from the repeat unit, so the same multiplication works, and the difference between
+ * the two shows up as a mass that is not a whole multiple of the monomers.
+ */
+declare const chainMass: (unit: RepeatUnit, n: number) => number;
+/**
+ * How many repeat units a chain of this mass holds, to the nearest whole unit.
+ *
+ * The question an exam asks the other way round: a poly(ethene) sample with a relative molecular
+ * mass of 28 000 contains 1000 repeat units, and that number is what "long chain" means.
+ */
+declare const unitsInChain: (unit: RepeatUnit, chainMr: number) => number;
+//#endregion
+export { LinkKind, PolymerKind, RepeatUnit, addition, canSustainChain, chainMass, condensation, unitsInChain };

package/dist/chem/polymer.mjs

@@ -0,0 +1,179 @@
+import { ATOMIC_MASS, molecularFormula, relativeMass } from "./molecule.mjs";
+import { functionalGroups } from "./functional-groups.mjs";
+
+//#region src/chem/polymer.ts
+/**
+* polymer, the repeat unit worked out from the monomer rather than drawn beside it.
+*
+* WHAT THIS IS FOR. Polymerisation is taught as two pictures to copy: an alkene with its double bond
+* opened, and two monomers with a water molecule falling out between them. Copied, they are
+* indistinguishable, and a learner who has copied both still cannot say which one a new monomer will
+* do. The question an exam actually asks is "draw the repeat unit", and that is a transformation of
+* a structure, so it can be performed.
+*
+* ## Addition: the double bond becomes the link
+*
+* An alkene's C=C opens. One bond stays holding the two carbons together, and the other becomes the
+* two bonds that join this unit to the next. So the repeat unit has the SAME molecular formula as
+* the monomer, which is the fact that tells addition from condensation without looking at anything
+* else.
+*
+* ## Condensation: two groups meet and lose a small molecule
+*
+* A carboxylic acid meets an alcohol and loses water, leaving an ester link. It meets an amine and
+* loses water, leaving an amide link, which is also the peptide link in a protein. The repeat unit
+* is therefore LIGHTER than the monomers by the mass of what left, and each monomer needs TWO
+* reactive groups or the chain stops after one join.
+*
+* That last point is the one usually left out, and it is what makes the difference between ethanoic
+* acid, which cannot polymerise, and hexanedioic acid, which can.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* Open the double bond of an alkene to give the addition repeat unit.
+*
+* Refuses a monomer with no C=C, because "it must be addition" is a guess a learner makes and a
+* kernel should not. The formula is unchanged by construction, and the test asserts it.
+*/
+function addition(monomer) {
+	const alkene = functionalGroups(monomer).find((g) => g.kind === "alkene");
+	if (!alkene) throw new Error(`${molecularFormula(monomer)} has no C=C, so it cannot polymerise by addition. Addition polymerisation needs a double bond to open.`);
+	const [a, b] = alkene.atoms;
+	const bonds = monomer.bonds.map((bond) => bond.a === a && bond.b === b || bond.a === b && bond.b === a ? {
+		...bond,
+		order: 1
+	} : bond);
+	const structure = {
+		atoms: monomer.atoms.map((atom) => atom.id === a || atom.id === b ? {
+			...atom,
+			openValence: (atom.openValence ?? 0) + 1
+		} : atom),
+		bonds
+	};
+	return {
+		kind: "addition",
+		link: "carbon-carbon",
+		structure,
+		linkAtoms: [a, b],
+		formula: molecularFormula(structure),
+		mass: relativeMass(structure),
+		reason: "The C=C opens. One of its two bonds holds the carbons together and the other becomes the bonds to the units on either side, so nothing is lost and the repeat unit has the same formula as the monomer."
+	};
+}
+/** Groups that can form a link, and what they form it with. */
+const REACTIVE = [
+	"carboxylic-acid",
+	"alcohol",
+	"amine"
+];
+const reactiveGroups = (s) => functionalGroups(s).filter((g) => REACTIVE.includes(g.kind));
+/**
+* Can this monomer sustain a chain?
+*
+* Two reactive groups, or the chain stops after one join. Ethanoic acid has one and is therefore a
+* dead end; hexanedioic acid has two and is not. This is the check most treatments leave out and
+* the reason a learner cannot predict whether a new monomer will polymerise.
+*/
+const canSustainChain = (monomer) => reactiveGroups(monomer).length >= 2;
+const WATER = {
+	formula: "H2O",
+	mass: ATOMIC_MASS.H * 2 + ATOMIC_MASS.O
+};
+/**
+* Join two monomers and eliminate water, giving the condensation repeat unit.
+*
+* The pairing is decided by the groups that are actually present, not by an argument the caller
+* passes: an acid with an alcohol gives an ester link and an acid with an amine gives an amide link,
+* and those are the only two the syllabus needs. A pair that cannot make either is refused with the
+* reason, because "nothing happened" is not a useful answer to a learner.
+*/
+function condensation(first, second) {
+	const a = reactiveGroups(first);
+	const b = reactiveGroups(second);
+	const kindsA = new Set(a.map((g) => g.kind));
+	const kindsB = new Set(b.map((g) => g.kind));
+	const pairing = [[
+		"carboxylic-acid",
+		"alcohol",
+		"ester"
+	], [
+		"carboxylic-acid",
+		"amine",
+		"amide"
+	]].find(([x, y]) => kindsA.has(x) && kindsB.has(y) || kindsA.has(y) && kindsB.has(x));
+	if (!pairing) throw new Error(`${molecularFormula(first)} and ${molecularFormula(second)} have no pair of groups that can condense. An ester link needs an acid and an alcohol; an amide link needs an acid and an amine.`);
+	const [, , link] = pairing;
+	if (!canSustainChain(first) || !canSustainChain(second)) throw new Error(`A condensation polymer needs TWO reactive groups on each monomer. ${canSustainChain(first) ? molecularFormula(second) : molecularFormula(first)} has only one, so the chain would stop after a single join.`);
+	const acids = a.filter((g) => g.kind === "carboxylic-acid");
+	const partners = b.filter((g) => g.kind === (link === "ester" ? "alcohol" : "amine"));
+	if (acids.length < 2 || partners.length < 2) throw new Error("A repeat unit needs two acid groups and two partner groups, one pair to link and one pair to continue the chain.");
+	/** The atom that carries the new bond: the oxygen of an alcohol, or the nitrogen of an amine. */
+	const partnerAtom = (group) => group.kind === "alcohol" ? group.atoms[1] : group.atoms[0];
+	const shift = first.atoms.length;
+	const dropped = new Set([acids[0].atoms[2], acids[1].atoms[2]]);
+	const opened = new Map([[acids[1].atoms[0], 1], [partnerAtom(partners[1]) + shift, 1]]);
+	const kept = [...first.atoms.filter((atom) => !dropped.has(atom.id)), ...second.atoms.map((atom) => ({
+		...atom,
+		id: atom.id + shift
+	}))];
+	const renumber = new Map(kept.map((atom, i) => [atom.id, i]));
+	const merged = {
+		atoms: kept.map((atom, i) => ({
+			...atom,
+			id: i,
+			...opened.has(atom.id) ? { openValence: (atom.openValence ?? 0) + opened.get(atom.id) } : {}
+		})),
+		bonds: [
+			...first.bonds.filter((bond) => !dropped.has(bond.a) && !dropped.has(bond.b)),
+			...second.bonds.map((bond) => ({
+				...bond,
+				a: bond.a + shift,
+				b: bond.b + shift
+			})),
+			{
+				a: acids[0].atoms[0],
+				b: partnerAtom(partners[0]) + shift,
+				order: 1,
+				aromatic: false
+			}
+		].map((bond) => ({
+			...bond,
+			a: renumber.get(bond.a),
+			b: renumber.get(bond.b)
+		}))
+	};
+	const mass = relativeMass(merged);
+	const formula = molecularFormula(merged);
+	return {
+		kind: "condensation",
+		link,
+		structure: merged,
+		linkAtoms: [renumber.get(acids[1].atoms[0]), renumber.get(partnerAtom(partners[1]) + shift)],
+		formula,
+		mass,
+		lost: {
+			formula: WATER.formula,
+			mass: Math.round(WATER.mass * 10) / 10
+		},
+		reason: link === "ester" ? "The O-H of the acid and the O-H of the alcohol meet, water is eliminated and an ester link is left. Each monomer needs two groups, so the chain can continue at both ends." : "The O-H of the acid and an N-H of the amine meet, water is eliminated and an amide link is left. That is the same link that joins amino acids into a protein, where it is called a peptide link."
+	};
+}
+/**
+* The mass of a chain of `n` repeat units.
+*
+* For an addition polymer it is n times the monomer. For a condensation polymer the water has
+* already gone from the repeat unit, so the same multiplication works, and the difference between
+* the two shows up as a mass that is not a whole multiple of the monomers.
+*/
+const chainMass = (unit, n) => Math.round(unit.mass * n * 10) / 10;
+/**
+* How many repeat units a chain of this mass holds, to the nearest whole unit.
+*
+* The question an exam asks the other way round: a poly(ethene) sample with a relative molecular
+* mass of 28 000 contains 1000 repeat units, and that number is what "long chain" means.
+*/
+const unitsInChain = (unit, chainMr) => Math.round(chainMr / unit.mass);
+
+//#endregion
+export { addition, canSustainChain, chainMass, condensation, unitsInChain };

package/dist/chem/redox.d.mts

@@ -0,0 +1,138 @@
+//#region src/chem/redox.d.ts
+/**
+ * redox: oxidation numbers, half-equations, and the ionic equation they combine into.
+ *
+ * Three things the syllabus treats as three topics and which are one procedure applied at
+ * different scales. A learner who balances a half-equation in alkali by first balancing it in acid
+ * has understood that; one who memorises two procedures has not, which is why `medium` is an
+ * ARGUMENT here rather than a second function.
+ *
+ * ## Writing a species, and why the caret is required
+ *
+ * `'MnO4-'`, `'Cr2O7^2-'`, `'Fe^3+'`, `'H2O'`.
+ *
+ * A charge of one is a bare sign. **Any larger charge needs a caret**, because plain ASCII cannot
+ * distinguish the two readings of a digit before a sign and no syntactic rule can:
+ *
+ *   `MnO4-`  the 4 is a subscript, and the charge is −1
+ *   `Mn2+`   the 2 is the charge, and there is one manganese
+ *
+ * Both end in a letter, a digit and a sign. Only chemistry tells them apart, so an implementation
+ * that guesses is wrong roughly half the time and silently. Writing `Mn^2+` removes the question,
+ * and a digit before a bare sign is refused with a message saying so.
+ *
+ * `speciesToUnicode` renders `Mn^2+` as `Mn²⁺` for display, so the caret never reaches a learner.
+ *
+ * ## Oxidation numbers
+ *
+ * The rules are applied in order of how rarely they are broken: F is always −1, group 1 always +1,
+ * group 2 always +2, H is +1 except in a metal hydride, O is −2 except in a peroxide. Everything
+ * else is then fixed by the requirement that the oxidation numbers sum to the charge.
+ *
+ * That last line is the whole method, and it is why only ONE element may be unknown. A species with
+ * two unknowns is refused rather than guessed at, because the answer would not be determined.
+ *
+ * ## Balancing
+ *
+ * The five steps, in the order a mark scheme wants them:
+ *
+ *   1. balance the element being oxidised or reduced,
+ *   2. balance oxygen with H₂O,
+ *   3. balance hydrogen with H⁺,
+ *   4. balance the charge with electrons,
+ *   5. in ALKALI only, add OH⁻ to both sides to mop up the H⁺.
+ *
+ * Step 5 is what makes alkaline balancing one procedure rather than two: balance in acid, then
+ * neutralise. Every H⁺ meets an OH⁻ and becomes water, and the excess water cancels.
+ *
+ * Pure: no React, no pixels.
+ */
+type Medium = 'acid' | 'alkali';
+interface Species {
+  /** The formula as written, without its coefficient. */
+  readonly formula: string;
+  /** Element symbol to count. */
+  readonly elements: Readonly<Record<string, number>>;
+  /** Net charge. 0 for a neutral species. */
+  readonly charge: number;
+}
+interface Term {
+  readonly coeff: number;
+  readonly species: Species;
+}
+interface HalfEquation {
+  readonly left: readonly Term[];
+  readonly right: readonly Term[];
+  /** Electrons, on the side they appear. Always positive. */
+  readonly electrons: number;
+  /** 'left' for a reduction (electrons are gained), 'right' for an oxidation. */
+  readonly electronSide: 'left' | 'right';
+  readonly medium: Medium;
+}
+/** Parse `'Cr2O7^2-'` into its element counts and charge. See the docblock on the caret rule. */
+declare function parseSpecies(input: string): Species;
+/**
+ * Oxidation number of every element in a species.
+ *
+ * `peroxide` forces O to −1, for H₂O₂ and its salts. It is an argument rather than a detection
+ * rule, because H₂O₂ and H₂O differ only in a subscript and guessing from the formula would make
+ * the kernel wrong in exactly the case the syllabus asks about.
+ */
+declare function oxidationNumbers(input: string | Species, opts?: {
+  peroxide?: boolean;
+  hydride?: boolean;
+}): Record<string, number>;
+/**
+ * `'Cr2O7^2-'` → `'Cr₂O₇²⁻'`, for display.
+ *
+ * The caret is an input convention forced by ASCII ambiguity, and a learner should never see it.
+ *
+ * ## The one place the caret is not needed
+ *
+ * After a closing bracket. `[Cu(H2O)6]2+` has no ambiguity at all, because a digit cannot be the
+ * subscript of a `]`, and that is the form `complexFormula` emits. Without this case a complex ion
+ * came back as `[Cu(H₂O)₆]₂⁺`, with its charge written as a subscript: the same class of defect as a
+ * formatter producing a string its sibling parser cannot read.
+ */
+declare function speciesToUnicode(formula: string): string;
+/** Positive when oxidised, negative when reduced, for `element` between two species. */
+declare function oxidationChange(element: string, from: string, to: string): number;
+/**
+ * Balance one half-equation, in acid or in alkali.
+ *
+ * `balanceHalf('MnO4-', 'Mn2+')` → MnO₄⁻ + 8H⁺ + 5e⁻ → Mn²⁺ + 4H₂O.
+ *
+ * Alkali is not a second procedure: the equation is balanced in acid and then neutralised, which is
+ * exactly what a mark scheme wants written.
+ */
+declare function balanceHalf(from: string, to: string, medium?: Medium): HalfEquation;
+/**
+ * "MnO₄⁻ + 8H⁺ + 5e⁻ → Mn²⁺ + 4H₂O", for display.
+ *
+ * Built from the TERMS, not by running `speciesToUnicode` over the finished string. That was tried
+ * and is wrong: a coefficient is a normal-size number and a separator is a plus sign, so formatting
+ * the whole line turns `2Cr^3+ + 7H2O` into subscripted coefficients and superscripted plus signs.
+ * Chemistry typography is per-species, so the formatter has to be too.
+ */
+declare function halfToUnicode(half: HalfEquation): string;
+/** "MnO₄⁻ + 8H⁺ + 5Fe²⁺ → Mn²⁺ + 4H₂O + 5Fe³⁺", for display. */
+declare function ionicToUnicode(equation: IonicEquation): string;
+/** "MnO4- + 8H+ + 5e- -> Mn2+ + 4H2O" */
+declare function halfToString(half: HalfEquation): string;
+interface IonicEquation {
+  readonly left: readonly Term[];
+  readonly right: readonly Term[];
+  /** How many electrons were transferred once the two halves were scaled to match. */
+  readonly transferred: number;
+}
+/**
+ * Combine a reduction and an oxidation into the full ionic equation.
+ *
+ * Each half is scaled so the electrons cancel exactly, which is the step the whole topic exists to
+ * teach: electrons are not created, so the number lost must equal the number gained.
+ */
+declare function combineHalves(a: HalfEquation, b: HalfEquation): IonicEquation;
+/** "2MnO4- + 16H+ + 10Fe2+ -> 2Mn2+ + 8H2O + 10Fe3+" */
+declare function ionicToString(equation: IonicEquation): string;
+//#endregion
+export { HalfEquation, IonicEquation, Medium, Species, Term, balanceHalf, combineHalves, halfToString, halfToUnicode, ionicToString, ionicToUnicode, oxidationChange, oxidationNumbers, parseSpecies, speciesToUnicode };