@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/scientific/HodographChart.js

@@ -0,0 +1,265 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { RadialChart } from "../../core/RadialChart.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { curveCatmullRom, curveLinear, line, max, mean, range } from "d3";
+// src/charts/scientific/HodographChart.ts
+var HodographFrame = /* @__PURE__ */ function(HodographFrame) {
+	HodographFrame["Polar"] = "polar-rings";
+	HodographFrame["Grid"] = "uv-grid";
+	return HodographFrame;
+}({});
+var HodographMark = /* @__PURE__ */ function(HodographMark) {
+	HodographMark["Trace"] = "trace";
+	HodographMark["Vectors"] = "wind-vectors";
+	return HodographMark;
+}({});
+var HodographStorm = /* @__PURE__ */ function(HodographStorm) {
+	HodographStorm["None"] = "no-storm";
+	HodographStorm["Bunkers"] = "bunkers-motion";
+	HodographStorm["Helicity"] = "storm-helicity";
+	return HodographStorm;
+}({});
+var LAYERS = [
+	[0, 1e3],
+	[1e3, 3e3],
+	[3e3, 6e3],
+	[6e3, 9e3],
+	[9e3, 12e3]
+];
+/** Wind vectors at each height joined tip to tip, revealing shear and storm rotation potential. */
+var HodographChart = class extends RadialChart {
+	static meta = {
+		id: "hodograph",
+		name: "Hodograph",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Traces the tips of wind vectors with height to show vertical shear and supercell storm motion.",
+		tags: [
+			"meteorology",
+			"wind shear",
+			"helicity"
+		],
+		sample: (seed) => ScientificSample.sounding(seed),
+		variants: {
+			frame: Object.values(HodographFrame),
+			mark: Object.values(HodographMark),
+			storm: Object.values(HodographStorm),
+			smooth: [true, false],
+			ceiling: [12e3, 6e3]
+		},
+		valid: (values) => values.mark === "trace" || values.smooth === true
+	};
+	layers = [];
+	defaults() {
+		return {
+			u: "u",
+			v: "v",
+			altitude: "height",
+			frame: "polar-rings",
+			mark: "trace",
+			storm: "bunkers-motion",
+			smooth: true,
+			ceiling: 12e3
+		};
+	}
+	plotMargin() {
+		return {
+			top: 16,
+			right: 16,
+			bottom: 16,
+			left: 16
+		};
+	}
+	legendItems() {
+		return this.layers;
+	}
+	winds() {
+		const { data, u, v, altitude, ceiling } = this.options;
+		return data.flatMap((row) => {
+			const [a, b, c] = [
+				row[u],
+				row[v],
+				row[altitude]
+			].map(Draft.number);
+			return a === null || b === null || c === null ? [] : [{
+				u: a,
+				v: b,
+				height: c
+			}];
+		}).filter((d) => d.height <= ceiling).sort((a, b) => a.height - b.height);
+	}
+	interpolate(winds, height) {
+		const upper = winds.findIndex((d) => d.height >= height);
+		if (upper < 0) return null;
+		if (upper === 0) return winds[0];
+		const a = winds[upper - 1], b = winds[upper], t = (height - a.height) / (b.height - a.height || 1);
+		return {
+			u: a.u + (b.u - a.u) * t,
+			v: a.v + (b.v - a.v) * t,
+			height
+		};
+	}
+	/** Bunkers right-moving storm: 0–6 km mean wind plus 7.5 m/s to the right of the shear. */
+	bunkers(winds) {
+		const deep = winds.filter((d) => d.height <= 6e3);
+		const low = this.interpolate(winds, 500), high = this.interpolate(winds, 5500);
+		if (deep.length < 2 || !low || !high) return null;
+		const su = high.u - low.u, sv = high.v - low.v, shear = Math.hypot(su, sv) || 1;
+		return {
+			u: (mean(deep, (d) => d.u) ?? 0) + 7.5 * sv / shear,
+			v: (mean(deep, (d) => d.v) ?? 0) - 7.5 * su / shear
+		};
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	drawRadial(ctx, { radius: outer }) {
+		const { frame, mark, storm, smooth } = this.options;
+		const winds = this.winds();
+		const radius = outer - 8;
+		const reach = Math.max(10, max(winds, (d) => Math.hypot(d.u, d.v)) ?? 10) * 1.08;
+		const step = reach > 60 ? 20 : 10;
+		const top = Math.ceil(reach / step) * step, k = radius / top;
+		const at = (u, v) => [u * k, -v * k];
+		const circles = range(step, top + 1, step);
+		Draft.paths(ctx, "rings", frame === "polar-rings" ? circles.map((r) => `M${-r * k},0A${r * k},${r * k} 0 1 1 ${r * k},0A${r * k},${r * k} 0 1 1 ${-r * k},0`) : []);
+		const lines = frame === "uv-grid" ? [...circles, ...circles.map((r) => -r)].flatMap((r) => [{
+			x1: r * k,
+			x2: r * k,
+			y1: -radius,
+			y2: radius
+		}, {
+			x1: -radius,
+			x2: radius,
+			y1: r * k,
+			y2: r * k
+		}]) : [];
+		Draft.rules(ctx, "grid", lines);
+		Draft.rules(ctx, "axes", [{
+			x1: -radius,
+			x2: radius,
+			y1: 0,
+			y2: 0
+		}, {
+			x1: 0,
+			x2: 0,
+			y1: -radius,
+			y2: radius
+		}], { stroke: ctx.theme.axis });
+		const scale = circles.filter((r) => r * k > 14).map((r) => ({
+			text: `${r}`,
+			x: 4,
+			y: r * k - 3,
+			anchor: "start",
+			size: 10,
+			tone: "muted"
+		}));
+		Draft.captions(ctx, "scale", [...scale, {
+			text: "m/s",
+			x: -4,
+			y: radius - 3,
+			anchor: "end",
+			size: 10,
+			tone: "muted"
+		}]);
+		const shown = LAYERS.map(([low, high], i) => {
+			const inside = winds.filter((d) => d.height > low && d.height < high);
+			const ends = [this.interpolate(winds, low) ?? (i === 0 ? winds[0] : null), this.interpolate(winds, high) ?? (inside.length ? winds[winds.length - 1] : null)];
+			return {
+				name: `${low / 1e3}–${high / 1e3} km`,
+				color: ctx.palette.sequential(.3 + i * .17),
+				points: [
+					ends[0],
+					...inside,
+					ends[1]
+				].filter(Boolean)
+			};
+		}).filter((layer) => layer.points.length > 1);
+		this.layers = shown.map(({ name, color }) => ({
+			key: name,
+			color
+		}));
+		const curve = line().x((d) => at(d.u, d.v)[0]).y((d) => at(d.u, d.v)[1]).curve(smooth ? curveCatmullRom : curveLinear);
+		const motion = this.bunkers(winds);
+		if (storm === "storm-helicity" && motion) {
+			const low = winds.filter((d) => d.height <= 3e3);
+			let helicity = 0;
+			low.slice(1).forEach((d, i) => {
+				const p = low[i];
+				helicity += (d.u - motion.u) * (p.v - motion.v) - (p.u - motion.u) * (d.v - motion.v);
+			});
+			Draft.paths(ctx, "helicity", low.length > 1 ? [Draft.polygon([at(motion.u, motion.v), ...low.map((d) => at(d.u, d.v))])] : [], { stroke: "none" }, ctx.palette.diverging(.7)).attr("fill-opacity", .25);
+			Draft.captions(ctx, "helicity-value", [{
+				text: `SRH₀₋₃ ${Math.round(helicity)} m²/s²`,
+				x: -radius,
+				y: radius - 16,
+				anchor: "start",
+				size: 11,
+				tone: "ink",
+				weight: 600
+			}]);
+		}
+		const ribbons = ctx.marks("layers", "path", mark === "trace" ? shown : [], (d) => d.name).attr("fill", "none").attr("stroke", (d) => d.color).attr("stroke-width", 3).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		ctx.set(ribbons, { d: (d) => curve(d.points) ?? "" }, { d: (d) => curve(d.points) ?? "" });
+		ctx.drawOn(ribbons);
+		ctx.hover(ribbons, (d) => ({
+			title: d.name,
+			color: d.color,
+			rows: [["Shear", `${Math.hypot(d.points[d.points.length - 1].u - d.points[0].u, d.points[d.points.length - 1].v - d.points[0].v).toFixed(1)} m/s`]]
+		}));
+		const colorAt = (height) => shown.find((layer) => layer.points[0].height <= height && height <= layer.points[layer.points.length - 1].height)?.color ?? ctx.theme.inkMuted;
+		const arrows = ctx.marks("vectors", "path", mark === "wind-vectors" ? winds : [], (d) => d.height).attr("fill", "none").attr("stroke", (d) => colorAt(d.height)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		const arrow = (d) => {
+			const [x, y] = at(d.u, d.v), angle = Math.atan2(y, x), head = (turn) => [x - 7 * Math.cos(angle + turn), y - 7 * Math.sin(angle + turn)];
+			const [lx, ly] = head(.45), [rx, ry] = head(-.45);
+			return `M0,0L${x},${y}M${lx},${ly}L${x},${y}L${rx},${ry}`;
+		};
+		ctx.set(arrows, { d: arrow }, { d: arrow }, 15);
+		const heights = ctx.marks("levels", "circle", mark === "trace" ? winds : [], (d) => d.height).attr("fill", "transparent");
+		ctx.set(heights, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 7
+		}, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 7
+		});
+		const joints = mark === "trace" ? shown.slice(1).map((layer) => layer.points[0]) : [];
+		const knots = ctx.marks("joints", "circle", joints, (d) => d.height).attr("fill", ctx.theme.surface).attr("stroke", ctx.theme.ink).attr("stroke-width", 1.5).style("pointer-events", "none");
+		ctx.set(knots, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 3.5
+		}, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 0
+		}, 40);
+		Draft.captions(ctx, "joint-names", joints.map((d) => ({
+			text: `${d.height / 1e3}`,
+			x: at(d.u, d.v)[0] + 7,
+			y: at(d.u, d.v)[1] - 6,
+			anchor: "start",
+			size: 10,
+			tone: "ink"
+		})));
+		const tip = (d) => ({
+			title: `${d.height.toLocaleString("en")} m`,
+			rows: [["Speed", `${Math.hypot(d.u, d.v).toFixed(1)} m/s`], ["u, v", `${d.u}, ${d.v}`]]
+		});
+		ctx.hover(heights, tip);
+		ctx.hover(arrows, tip);
+		const motions = storm !== "no-storm" && motion ? [motion] : [];
+		const stormMark = ctx.marks("storm", "path", motions, () => "storm").attr("d", "M0,-7L6,3.5H-6Z").attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(stormMark, { transform: (d) => `translate(${at(d.u, d.v).join(",")})` }, { transform: (d) => `translate(${at(d.u, d.v).join(",")})` });
+		ctx.hover(stormMark, (d) => ({
+			title: "Right-moving storm",
+			rows: [["Speed", `${Math.hypot(d.u, d.v).toFixed(1)} m/s`]]
+		}));
+	}
+};
+export { HodographChart, HodographFrame, HodographMark, HodographStorm };

package/dist/charts/scientific/MassSpectrumChart.js

@@ -0,0 +1,180 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { area, max, range, scaleLinear, scalePow, scaleSymlog } from "d3";
+// src/charts/scientific/MassSpectrumChart.ts
+var SpectrumDisplay = /* @__PURE__ */ function(SpectrumDisplay) {
+	SpectrumDisplay["Centroid"] = "centroid";
+	SpectrumDisplay["Profile"] = "profile";
+	SpectrumDisplay["Overlaid"] = "profile-and-sticks";
+	return SpectrumDisplay;
+}({});
+var SpectrumIntensity = /* @__PURE__ */ function(SpectrumIntensity) {
+	SpectrumIntensity["Relative"] = "relative";
+	SpectrumIntensity["Absolute"] = "absolute";
+	return SpectrumIntensity;
+}({});
+/** Ion abundance against mass-to-charge, for identifying compounds from fragmentation patterns. */
+var MassSpectrumChart = class extends CartesianChart {
+	static meta = {
+		id: "mass-spectrum",
+		name: "Mass spectrum",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots ion intensity against mass-to-charge ratio, with base-peak normalisation and head-to-tail library matching.",
+		tags: [
+			"mass spectrometry",
+			"stick spectrum",
+			"proteomics",
+			"mirror plot"
+		],
+		sample: (seed) => ScientificSample.spectra(seed),
+		variants: {
+			display: Object.values(SpectrumDisplay),
+			scale: [
+				ScaleKind.Linear,
+				ScaleKind.Sqrt,
+				ScaleKind.Symlog
+			],
+			normalization: Object.values(SpectrumIntensity),
+			mirror: [true, false],
+			labels: [5, 0]
+		}
+	};
+	defaults() {
+		return {
+			mz: "mz",
+			intensity: "intensity",
+			spectrum: "spectrum",
+			xLabel: "m/z",
+			grid: true,
+			display: "centroid",
+			scale: ScaleKind.Linear,
+			normalization: "relative",
+			mirror: true,
+			labels: 5,
+			spread: .9
+		};
+	}
+	sticks() {
+		const { data, mz, intensity, spectrum, mirror, normalization } = this.options;
+		const rows = data.flatMap((row) => {
+			const m = Draft.number(row[mz]), i = Draft.number(row[intensity]);
+			return m === null || i === null || i < 0 ? [] : [{
+				mz: m,
+				intensity: i,
+				spectrum: String(row[spectrum] ?? "Spectrum")
+			}];
+		});
+		const names = [...new Set(rows.map((d) => d.spectrum))];
+		return (mirror ? names.slice(0, 2) : names.slice(0, 1)).flatMap((name, s) => {
+			const own = rows.filter((d) => d.spectrum === name), base = max(own, (d) => d.intensity) || 1;
+			return own.map((d) => {
+				const relative = d.intensity / base * 100;
+				return {
+					...d,
+					relative,
+					sign: s ? -1 : 1,
+					value: normalization === "relative" ? relative : d.intensity
+				};
+			});
+		});
+	}
+	scales(ctx) {
+		const { scale, mirror } = this.options;
+		const sticks = this.sticks();
+		const peak = (max(sticks, (d) => d.value) || 1) * 1.14;
+		const lowest = Math.min(...sticks.map((d) => d.mz), 0), highest = max(sticks, (d) => d.mz) ?? 100;
+		const y = scale === ScaleKind.Sqrt ? scalePow().exponent(.5) : scale === ScaleKind.Symlog ? scaleSymlog().constant(peak / 100) : scaleLinear();
+		y.domain(mirror ? [-peak, peak] : [0, peak]).range([ctx.plot.height, 0]);
+		if (scale === ScaleKind.Symlog && peak > 0) {
+			const decades = range(Math.floor(Math.log10(peak / 100)) + 1, Math.floor(Math.log10(peak)) + 1).map((power) => 10 ** power);
+			Object.assign(y, { ticks: () => [
+				0,
+				...decades,
+				...mirror ? decades.map((value) => -value) : []
+			] });
+		}
+		return {
+			x: scaleLinear([lowest > 0 ? 0 : lowest, highest * 1.05], [0, ctx.plot.width]),
+			y
+		};
+	}
+	tickFormat(scale) {
+		const base = super.tickFormat(scale);
+		if (!base) return base;
+		const sparse = "constant" in scale;
+		return (value) => {
+			const v = Math.abs(+value), power = v ? Math.floor(Math.log10(v) + 1e-9) : 0;
+			return sparse && v && Math.round(v / 10 ** power) !== 1 ? "" : base(v);
+		};
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	plotMarks(ctx, { x, y }) {
+		const { display, labels, mirror, spread } = this.options;
+		const sticks = this.sticks();
+		const names = [...new Set(sticks.map((d) => d.spectrum))];
+		const position = (d) => y(d.value * d.sign);
+		const zero = y(0);
+		Draft.rules(ctx, "baseline", mirror ? [{
+			x1: 0,
+			x2: ctx.plot.width,
+			y1: zero,
+			y2: zero
+		}] : [], {
+			stroke: ctx.theme.axis,
+			width: 1.5
+		});
+		if (display !== "centroid") {
+			const [low, high] = x.domain();
+			const samples = range(low, high, Math.max((high - low) / 900, spread / 3));
+			const profiles = names.map((name) => {
+				const own = sticks.filter((d) => d.spectrum === name);
+				return {
+					name,
+					curve: samples.map((mz) => [mz, own.reduce((sum, d) => sum + d.value * d.sign * Math.exp(-(((mz - d.mz) / spread) ** 2) / 2), 0)])
+				};
+			});
+			const shape = area().x((d) => x(d[0])).y0(zero).y1((d) => y(d[1]));
+			const fills = ctx.marks("profiles", "path", profiles, (d) => d.name).attr("fill", (d) => ctx.palette.color(d.name)).attr("fill-opacity", display === "profile-and-sticks" ? .3 : .85).attr("stroke", (d) => ctx.palette.color(d.name)).attr("stroke-width", 1);
+			ctx.set(fills, { d: (d) => shape(d.curve) ?? "" }, { d: (d) => shape(d.curve) ?? "" });
+			ctx.hover(fills, (d) => ({
+				title: d.name,
+				color: ctx.palette.color(d.name),
+				rows: [["Peaks", sticks.filter((s) => s.spectrum === d.name).length]]
+			}));
+		}
+		if (display !== "profile") {
+			const lines = ctx.marks("sticks", "line", sticks, (d, i) => `${d.spectrum}/${i}`).attr("stroke", (d) => ctx.palette.color(d.spectrum)).attr("stroke-width", 2).attr("stroke-linecap", "round");
+			const bars = {
+				x1: (d) => x(d.mz),
+				x2: (d) => x(d.mz),
+				y1: zero,
+				y2: position
+			};
+			ctx.set(lines, bars, {
+				...bars,
+				y2: zero
+			}, 5);
+			ctx.hover(lines, (d) => ({
+				title: `m/z ${d.mz.toFixed(2)}`,
+				color: ctx.palette.color(d.spectrum),
+				rows: [[d.spectrum, d.intensity], ["Relative", `${d.relative.toFixed(1)}%`]]
+			}));
+		}
+		const captions = names.flatMap((name) => sticks.filter((d) => d.spectrum === name).sort((a, b) => b.value - a.value).slice(0, labels)).map((d) => ({
+			text: d.mz.toFixed(1),
+			x: x(d.mz),
+			y: position(d) + (d.sign > 0 ? -5 : 13),
+			size: 10,
+			tone: "secondary"
+		}));
+		Draft.captions(ctx, "peak-labels", Draft.declutter(captions, ctx.plot.width, ctx.plot.height));
+	}
+};
+export { MassSpectrumChart, SpectrumDisplay, SpectrumIntensity };

package/dist/charts/scientific/PeakFinder.js

@@ -0,0 +1,31 @@
+// src/charts/scientific/PeakFinder.ts
+/** Peak picking on sampled traces: prominence walk with trapezoid integration above a straight valley line. */
+var PeakFinder = class {
+	static find(x, y, prominence = .05) {
+		if (y.length < 3) return [];
+		const low = Math.min(...y), floor = (Math.max(...y) - low) * prominence;
+		const peaks = [];
+		for (let i = 1; i < y.length - 1; i++) {
+			if (y[i] < y[i - 1] || y[i] <= y[i + 1]) continue;
+			let left = i, right = i;
+			while (left > 0 && y[left - 1] <= y[left]) left--;
+			while (right < y.length - 1 && y[right + 1] <= y[right]) right++;
+			const height = y[i] - Math.max(y[left], y[right]);
+			if (height < floor) continue;
+			let area = 0;
+			for (let k = left; k < right; k++) {
+				const base = (t) => y[left] + (y[right] - y[left]) * (t - left) / (right - left || 1);
+				area += (y[k] - base(k) + (y[k + 1] - base(k + 1))) / 2 * (x[k + 1] - x[k]);
+			}
+			peaks.push({
+				apex: i,
+				start: left,
+				end: right,
+				height,
+				area
+			});
+		}
+		return peaks;
+	}
+};
+export { PeakFinder };

package/dist/charts/scientific/PeriodicElements.js

@@ -0,0 +1,111 @@
+// src/charts/scientific/PeriodicElements.ts
+var SYMBOLS = "H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr Rf Db Sg Bh Hs Mt Ds Rg Cn Nh Fl Mc Lv Ts Og".split(" ");
+var NAMES = "Hydrogen Helium Lithium Beryllium Boron Carbon Nitrogen Oxygen Fluorine Neon Sodium Magnesium Aluminium Silicon Phosphorus Sulfur Chlorine Argon Potassium Calcium Scandium Titanium Vanadium Chromium Manganese Iron Cobalt Nickel Copper Zinc Gallium Germanium Arsenic Selenium Bromine Krypton Rubidium Strontium Yttrium Zirconium Niobium Molybdenum Technetium Ruthenium Rhodium Palladium Silver Cadmium Indium Tin Antimony Tellurium Iodine Xenon Caesium Barium Lanthanum Cerium Praseodymium Neodymium Promethium Samarium Europium Gadolinium Terbium Dysprosium Holmium Erbium Thulium Ytterbium Lutetium Hafnium Tantalum Tungsten Rhenium Osmium Iridium Platinum Gold Mercury Thallium Lead Bismuth Polonium Astatine Radon Francium Radium Actinium Thorium Protactinium Uranium Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium Lawrencium Rutherfordium Dubnium Seaborgium Bohrium Hassium Meitnerium Darmstadtium Roentgenium Copernicium Nihonium Flerovium Moscovium Livermorium Tennessine Oganesson".split(" ");
+/** The 118 elements, indexed by the Aufbau subshell each fills, which every table layout derives from. */
+var ELEMENTS = [
+	[
+		1,
+		"s",
+		2
+	],
+	[
+		2,
+		"s",
+		2
+	],
+	[
+		2,
+		"p",
+		6
+	],
+	[
+		3,
+		"s",
+		2
+	],
+	[
+		3,
+		"p",
+		6
+	],
+	[
+		4,
+		"s",
+		2
+	],
+	[
+		3,
+		"d",
+		10
+	],
+	[
+		4,
+		"p",
+		6
+	],
+	[
+		5,
+		"s",
+		2
+	],
+	[
+		4,
+		"d",
+		10
+	],
+	[
+		5,
+		"p",
+		6
+	],
+	[
+		6,
+		"s",
+		2
+	],
+	[
+		4,
+		"f",
+		14
+	],
+	[
+		5,
+		"d",
+		10
+	],
+	[
+		6,
+		"p",
+		6
+	],
+	[
+		7,
+		"s",
+		2
+	],
+	[
+		5,
+		"f",
+		14
+	],
+	[
+		6,
+		"d",
+		10
+	],
+	[
+		7,
+		"p",
+		6
+	]
+].flatMap(([shell, block, size]) => Array.from({ length: size }, (_, slot) => ({
+	shell,
+	block,
+	slot
+}))).map((place, i) => ({
+	...place,
+	number: i + 1,
+	symbol: SYMBOLS[i],
+	name: NAMES[i]
+}));
+export { ELEMENTS };