@neaps/tide-predictor 0.0.5 → 0.2.0

package/dist/index.js

@@ -0,0 +1,930 @@
+//#region src/astronomy/constants.ts
+const d2r = Math.PI / 180;
+const r2d = 180 / Math.PI;
+
+//#endregion
+//#region src/astronomy/coefficients.ts
+const sexagesimalToDecimal = (degrees, arcmins = 0, arcsecs = 0, mas = 0, muas = 0) => {
+	return degrees + arcmins / 60 + arcsecs / 3600 + mas / (3600 * 1e3) + muas / (3600 * 1e6);
+};
+const coefficients = {
+	terrestrialObliquity: [
+		sexagesimalToDecimal(23, 26, 21.448),
+		-sexagesimalToDecimal(0, 0, 4680.93),
+		-sexagesimalToDecimal(0, 0, 1.55),
+		sexagesimalToDecimal(0, 0, 1999.25),
+		-sexagesimalToDecimal(0, 0, 51.38),
+		-sexagesimalToDecimal(0, 0, 249.67),
+		-sexagesimalToDecimal(0, 0, 39.05),
+		sexagesimalToDecimal(0, 0, 7.12),
+		sexagesimalToDecimal(0, 0, 27.87),
+		sexagesimalToDecimal(0, 0, 5.79),
+		sexagesimalToDecimal(0, 0, 2.45)
+	].map((number, index) => {
+		return number * Math.pow(.01, index);
+	}),
+	solarPerigee: [
+		-77.06265000000002,
+		1.7190199999968172,
+		4591e-7,
+		48e-8
+	],
+	solarLongitude: [
+		280.46645,
+		36000.76983,
+		3032e-7
+	],
+	lunarInclination: [5.145],
+	lunarLongitude: [
+		218.3164591,
+		481267.88134236,
+		-.0013268,
+		1 / 538841 - 1 / 65194e3
+	],
+	lunarNode: [
+		125.044555,
+		-1934.1361849,
+		.0020762,
+		1 / 467410,
+		-1 / 60616e3
+	],
+	lunarPerigee: [
+		83.353243,
+		4069.0137111,
+		-.0103238,
+		-1 / 80053,
+		1 / 18999e3
+	]
+};
+var coefficients_default = coefficients;
+
+//#endregion
+//#region src/astronomy/index.ts
+const polynomial = (coefficients$1, argument) => {
+	const result = [];
+	coefficients$1.forEach((coefficient, index) => {
+		result.push(coefficient * Math.pow(argument, index));
+	});
+	return result.reduce((a, b) => a + b);
+};
+const derivativePolynomial = (coefficients$1, argument) => {
+	const result = [];
+	coefficients$1.forEach((coefficient, index) => {
+		result.push(coefficient * index * Math.pow(argument, index - 1));
+	});
+	return result.reduce((a, b) => a + b);
+};
+const T = (t) => {
+	return (JD(t) - 2451545) / 36525;
+};
+const JD = (t) => {
+	let Y = t.getFullYear();
+	let M = t.getMonth() + 1;
+	const D = t.getDate() + t.getHours() / 24 + t.getMinutes() / 1440 + t.getSeconds() / (1440 * 60) + t.getMilliseconds() / (1440 * 60 * 1e6);
+	if (M <= 2) {
+		Y = Y - 1;
+		M = M + 12;
+	}
+	const A = Math.floor(Y / 100);
+	const B = 2 - A + Math.floor(A / 4);
+	return Math.floor(365.25 * (Y + 4716)) + Math.floor(30.6001 * (M + 1)) + D + B - 1524.5;
+};
+const _I = (N, i, omega) => {
+	N = d2r * N;
+	i = d2r * i;
+	omega = d2r * omega;
+	const cosI = Math.cos(i) * Math.cos(omega) - Math.sin(i) * Math.sin(omega) * Math.cos(N);
+	return r2d * Math.acos(cosI);
+};
+const _xi = (N, i, omega) => {
+	N = d2r * N;
+	i = d2r * i;
+	omega = d2r * omega;
+	let e1 = Math.cos(.5 * (omega - i)) / Math.cos(.5 * (omega + i)) * Math.tan(.5 * N);
+	let e2 = Math.sin(.5 * (omega - i)) / Math.sin(.5 * (omega + i)) * Math.tan(.5 * N);
+	e1 = Math.atan(e1);
+	e2 = Math.atan(e2);
+	e1 = e1 - .5 * N;
+	e2 = e2 - .5 * N;
+	return -(e1 + e2) * r2d;
+};
+const _nu = (N, i, omega) => {
+	N = d2r * N;
+	i = d2r * i;
+	omega = d2r * omega;
+	let e1 = Math.cos(.5 * (omega - i)) / Math.cos(.5 * (omega + i)) * Math.tan(.5 * N);
+	let e2 = Math.sin(.5 * (omega - i)) / Math.sin(.5 * (omega + i)) * Math.tan(.5 * N);
+	e1 = Math.atan(e1);
+	e2 = Math.atan(e2);
+	e1 = e1 - .5 * N;
+	e2 = e2 - .5 * N;
+	return (e1 - e2) * r2d;
+};
+const _nup = (N, i, omega) => {
+	const I = d2r * _I(N, i, omega);
+	const nu = d2r * _nu(N, i, omega);
+	return r2d * Math.atan(Math.sin(2 * I) * Math.sin(nu) / (Math.sin(2 * I) * Math.cos(nu) + .3347));
+};
+const _nupp = (N, i, omega) => {
+	const I = d2r * _I(N, i, omega);
+	const nu = d2r * _nu(N, i, omega);
+	const tan2nupp = Math.sin(I) ** 2 * Math.sin(2 * nu) / (Math.sin(I) ** 2 * Math.cos(2 * nu) + .0727);
+	return r2d * .5 * Math.atan(tan2nupp);
+};
+const modulus$1 = (a, b) => {
+	return (a % b + b) % b;
+};
+const astro = (time) => {
+	const result = {};
+	const polynomials = {
+		s: coefficients_default.lunarLongitude,
+		h: coefficients_default.solarLongitude,
+		p: coefficients_default.lunarPerigee,
+		N: coefficients_default.lunarNode,
+		pp: coefficients_default.solarPerigee,
+		"90": [90],
+		omega: coefficients_default.terrestrialObliquity,
+		i: coefficients_default.lunarInclination
+	};
+	const dTdHour = 1 / (24 * 365.25 * 100);
+	for (const name in polynomials) result[name] = {
+		value: modulus$1(polynomial(polynomials[name], T(time)), 360),
+		speed: derivativePolynomial(polynomials[name], T(time)) * dTdHour
+	};
+	const functions = {
+		I: _I,
+		xi: _xi,
+		nu: _nu,
+		nup: _nup,
+		nupp: _nupp
+	};
+	Object.keys(functions).forEach((name) => {
+		const functionCall = functions[name];
+		result[name] = {
+			value: modulus$1(functionCall(result.N.value, result.i.value, result.omega.value), 360),
+			speed: null
+		};
+	});
+	const hour = {
+		value: (JD(time) - Math.floor(JD(time))) * 360,
+		speed: 15
+	};
+	result["T+h-s"] = {
+		value: hour.value + result.h.value - result.s.value,
+		speed: hour.speed + result.h.speed - result.s.speed
+	};
+	result.P = {
+		value: result.p.value - result.xi.value % 360,
+		speed: null
+	};
+	return result;
+};
+var astronomy_default = astro;
+
+//#endregion
+//#region src/harmonics/prediction.ts
+const modulus = (a, b) => {
+	return (a % b + b) % b;
+};
+const addExtremesOffsets = (extreme, offsets) => {
+	if (typeof offsets === "undefined" || !offsets) return extreme;
+	if (extreme.high && offsets.height?.high) if (offsets.height.type === "fixed") extreme.level += offsets.height.high;
+	else extreme.level *= offsets.height.high;
+	if (extreme.low && offsets.height?.low) if (offsets.height.type === "fixed") extreme.level += offsets.height.low;
+	else extreme.level *= offsets.height.low;
+	if (extreme.high && offsets.time?.high) extreme.time = new Date(extreme.time.getTime() + offsets.time.high * 60 * 1e3);
+	if (extreme.low && offsets.time?.low) extreme.time = new Date(extreme.time.getTime() + offsets.time.low * 60 * 1e3);
+	return extreme;
+};
+const getExtremeLabel = (label, highLowLabels) => {
+	if (typeof highLowLabels !== "undefined" && typeof highLowLabels[label] !== "undefined") return highLowLabels[label];
+	return {
+		high: "High",
+		low: "Low"
+	}[label];
+};
+const predictionFactory = ({ timeline, constituents: constituents$1, start }) => {
+	const getLevel = (hour, modelBaseSpeed, modelU, modelF, modelBaseValue) => {
+		const amplitudes = [];
+		let result = 0;
+		constituents$1.forEach((constituent) => {
+			const amplitude = constituent.amplitude;
+			const phase = constituent._phase;
+			const f = modelF[constituent.name];
+			const speed = modelBaseSpeed[constituent.name];
+			const u = modelU[constituent.name];
+			const V0 = modelBaseValue[constituent.name];
+			amplitudes.push(amplitude * f * Math.cos(speed * hour + (V0 + u) - phase));
+		});
+		amplitudes.forEach((item) => {
+			result += item;
+		});
+		return result;
+	};
+	const prediction = {};
+	prediction.getExtremesPrediction = (options) => {
+		const { labels, offsets } = typeof options !== "undefined" ? options : {};
+		const results = [];
+		const { baseSpeed, u, f, baseValue } = prepare();
+		let goingUp = false;
+		let goingDown = false;
+		let lastLevel = getLevel(0, baseSpeed, u[0], f[0], baseValue);
+		timeline.items.forEach((time, index) => {
+			const hour = timeline.hours[index];
+			const level = getLevel(hour, baseSpeed, u[index], f[index], baseValue);
+			if (level > lastLevel && goingDown) results.push(addExtremesOffsets({
+				time: timeline.items[index - 1],
+				level: lastLevel,
+				high: false,
+				low: true,
+				label: getExtremeLabel("low", labels)
+			}, offsets));
+			if (level < lastLevel && goingUp) results.push(addExtremesOffsets({
+				time: timeline.items[index - 1],
+				level: lastLevel,
+				high: true,
+				low: false,
+				label: getExtremeLabel("high", labels)
+			}, offsets));
+			if (level > lastLevel) {
+				goingUp = true;
+				goingDown = false;
+			}
+			if (level < lastLevel) {
+				goingUp = false;
+				goingDown = true;
+			}
+			lastLevel = level;
+		});
+		return results;
+	};
+	prediction.getTimelinePrediction = () => {
+		const results = [];
+		const { baseSpeed, u, f, baseValue } = prepare();
+		timeline.items.forEach((time, index) => {
+			const hour = timeline.hours[index];
+			const prediction$1 = {
+				time,
+				hour,
+				level: getLevel(hour, baseSpeed, u[index], f[index], baseValue)
+			};
+			results.push(prediction$1);
+		});
+		return results;
+	};
+	const prepare = () => {
+		const baseAstro = astronomy_default(start);
+		const baseValue = {};
+		const baseSpeed = {};
+		const u = [];
+		const f = [];
+		constituents$1.forEach((constituent) => {
+			const value = constituent._model.value(baseAstro);
+			const speed = constituent._model.speed(baseAstro);
+			baseValue[constituent.name] = d2r * value;
+			baseSpeed[constituent.name] = d2r * speed;
+		});
+		timeline.items.forEach((time) => {
+			const uItem = {};
+			const fItem = {};
+			const itemAstro = astronomy_default(time);
+			constituents$1.forEach((constituent) => {
+				const constituentU = modulus(constituent._model.u(itemAstro), 360);
+				uItem[constituent.name] = d2r * constituentU;
+				fItem[constituent.name] = modulus(constituent._model.f(itemAstro), 360);
+			});
+			u.push(uItem);
+			f.push(fItem);
+		});
+		return {
+			baseValue,
+			baseSpeed,
+			u,
+			f
+		};
+	};
+	return Object.freeze(prediction);
+};
+var prediction_default = predictionFactory;
+
+//#endregion
+//#region src/node-corrections/index.ts
+const corrections = {
+	fUnity() {
+		return 1;
+	},
+	fMm(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = (2 / 3 - Math.pow(Math.sin(omega), 2)) * (1 - 3 / 2 * Math.pow(Math.sin(i), 2));
+		return (2 / 3 - Math.pow(Math.sin(I), 2)) / mean;
+	},
+	fMf(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = Math.pow(Math.sin(omega), 2) * Math.pow(Math.cos(.5 * i), 4);
+		return Math.pow(Math.sin(I), 2) / mean;
+	},
+	fO1(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = Math.sin(omega) * Math.pow(Math.cos(.5 * omega), 2) * Math.pow(Math.cos(.5 * i), 4);
+		return Math.sin(I) * Math.pow(Math.cos(.5 * I), 2) / mean;
+	},
+	fJ1(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = Math.sin(2 * omega) * (1 - 3 / 2 * Math.pow(Math.sin(i), 2));
+		return Math.sin(2 * I) / mean;
+	},
+	fOO1(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = Math.sin(omega) * Math.pow(Math.sin(.5 * omega), 2) * Math.pow(Math.cos(.5 * i), 4);
+		return Math.sin(I) * Math.pow(Math.sin(.5 * I), 2) / mean;
+	},
+	fM2(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const mean = Math.pow(Math.cos(.5 * omega), 4) * Math.pow(Math.cos(.5 * i), 4);
+		return Math.pow(Math.cos(.5 * I), 4) / mean;
+	},
+	fK1(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const nu = d2r * a.nu.value;
+		const mean = .5023 * (Math.sin(2 * omega) * (1 - 3 / 2 * Math.pow(Math.sin(i), 2))) + .1681;
+		return Math.pow(.2523 * Math.pow(Math.sin(2 * I), 2) + .1689 * Math.sin(2 * I) * Math.cos(nu) + .0283, .5) / mean;
+	},
+	fL2(a) {
+		const P = d2r * a.P.value;
+		const I = d2r * a.I.value;
+		const rAInv = Math.pow(1 - 12 * Math.pow(Math.tan(.5 * I), 2) * Math.cos(2 * P) + 36 * Math.pow(Math.tan(.5 * I), 4), .5);
+		return corrections.fM2(a) * rAInv;
+	},
+	fK2(a) {
+		const omega = d2r * a.omega.value;
+		const i = d2r * a.i.value;
+		const I = d2r * a.I.value;
+		const nu = d2r * a.nu.value;
+		const mean = .5023 * (Math.sin(omega) ** 2 * (1 - 3 / 2 * Math.sin(i) ** 2)) + .0365;
+		return Math.pow(.2523 * Math.pow(Math.sin(I), 4) + .0367 * Math.pow(Math.sin(I), 2) * Math.cos(2 * nu) + .0013, .5) / mean;
+	},
+	fM1(a) {
+		const P = d2r * a.P.value;
+		const I = d2r * a.I.value;
+		const qAInv = Math.pow(.25 + 1.5 * Math.cos(I) * Math.cos(2 * P) * Math.pow(Math.cos(.5 * I), -.5) + 2.25 * Math.pow(Math.cos(I), 2) * Math.pow(Math.cos(.5 * I), -4), .5);
+		return corrections.fO1(a) * qAInv;
+	},
+	fModd(a, n) {
+		return Math.pow(corrections.fM2(a), n / 2);
+	},
+	uZero() {
+		return 0;
+	},
+	uMf(a) {
+		return -2 * a.xi.value;
+	},
+	uO1(a) {
+		return 2 * a.xi.value - a.nu.value;
+	},
+	uJ1(a) {
+		return -a.nu.value;
+	},
+	uOO1(a) {
+		return -2 * a.xi.value - a.nu.value;
+	},
+	uM2(a) {
+		return 2 * a.xi.value - 2 * a.nu.value;
+	},
+	uK1(a) {
+		return -a.nup.value;
+	},
+	uL2(a) {
+		const I = d2r * a.I.value;
+		const P = d2r * a.P.value;
+		const R = r2d * Math.atan(Math.sin(2 * P) / (1 / 6 * Math.pow(Math.tan(.5 * I), -2) - Math.cos(2 * P)));
+		return 2 * a.xi.value - 2 * a.nu.value - R;
+	},
+	uK2(a) {
+		return -2 * a.nupp.value;
+	},
+	uM1(a) {
+		const I = d2r * a.I.value;
+		const P = d2r * a.P.value;
+		const Q = r2d * Math.atan((5 * Math.cos(I) - 1) / (7 * Math.cos(I) + 1) * Math.tan(P));
+		return a.xi.value - a.nu.value + Q;
+	},
+	uModd(a, n) {
+		return n / 2 * corrections.uM2(a);
+	}
+};
+var node_corrections_default = corrections;
+
+//#endregion
+//#region src/constituents/constituent.ts
+/**
+* Computes the dot notation of two arrays
+*/
+const dotArray = (a, b) => {
+	const results = [];
+	a.forEach((value, index) => {
+		results.push(value * b[index]);
+	});
+	return results.reduce((total, value) => total + value);
+};
+const astronimicDoodsonNumber = (astro$1) => {
+	return [
+		astro$1["T+h-s"],
+		astro$1.s,
+		astro$1.h,
+		astro$1.p,
+		astro$1.N,
+		astro$1.pp,
+		astro$1["90"]
+	];
+};
+const astronomicSpeed = (astro$1) => {
+	const results = [];
+	astronimicDoodsonNumber(astro$1).forEach((number) => {
+		results.push(number.speed);
+	});
+	return results;
+};
+const astronomicValues = (astro$1) => {
+	const results = [];
+	astronimicDoodsonNumber(astro$1).forEach((number) => {
+		results.push(number.value);
+	});
+	return results;
+};
+const constituentFactory = (name, coefficients$1, u, f) => {
+	if (!coefficients$1) throw new Error("Coefficient must be defined for a constituent");
+	const constituent = {
+		name,
+		coefficients: coefficients$1,
+		value: (astro$1) => {
+			return dotArray(coefficients$1, astronomicValues(astro$1));
+		},
+		speed(astro$1) {
+			return dotArray(coefficients$1, astronomicSpeed(astro$1));
+		},
+		u: typeof u !== "undefined" ? u : node_corrections_default.uZero,
+		f: typeof f !== "undefined" ? f : node_corrections_default.fUnity
+	};
+	return Object.freeze(constituent);
+};
+var constituent_default = constituentFactory;
+
+//#endregion
+//#region src/constituents/compound-constituent.ts
+const compoundConstituentFactory = (name, members) => {
+	const coefficients$1 = [];
+	members.forEach(({ constituent, factor }) => {
+		constituent.coefficients.forEach((coefficient, index) => {
+			if (typeof coefficients$1[index] === "undefined") coefficients$1[index] = 0;
+			coefficients$1[index] += coefficient * factor;
+		});
+	});
+	const compoundConstituent = {
+		name,
+		coefficients: coefficients$1,
+		speed: (astro$1) => {
+			let speed = 0;
+			members.forEach(({ constituent, factor }) => {
+				speed += constituent.speed(astro$1) * factor;
+			});
+			return speed;
+		},
+		value: (astro$1) => {
+			let value = 0;
+			members.forEach(({ constituent, factor }) => {
+				value += constituent.value(astro$1) * factor;
+			});
+			return value;
+		},
+		u: (astro$1) => {
+			let u = 0;
+			members.forEach(({ constituent, factor }) => {
+				u += constituent.u(astro$1) * factor;
+			});
+			return u;
+		},
+		f: (astro$1) => {
+			const f = [];
+			members.forEach(({ constituent, factor }) => {
+				f.push(Math.pow(constituent.f(astro$1), Math.abs(factor)));
+			});
+			return f.reduce((previous, value) => previous * value);
+		}
+	};
+	return Object.freeze(compoundConstituent);
+};
+var compound_constituent_default = compoundConstituentFactory;
+
+//#endregion
+//#region src/constituents/index.ts
+const constituents = {};
+constituents.Z0 = constituent_default("Z0", [
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.SA = constituent_default("Sa", [
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.SSA = constituent_default("Ssa", [
+	0,
+	0,
+	2,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.MM = constituent_default("MM", [
+	0,
+	1,
+	0,
+	-1,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fMm);
+constituents.MF = constituent_default("MF", [
+	0,
+	2,
+	0,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uMf, node_corrections_default.fMf);
+constituents.Q1 = constituent_default("Q1", [
+	1,
+	-2,
+	0,
+	1,
+	0,
+	0,
+	1
+], node_corrections_default.uO1, node_corrections_default.fO1);
+constituents.O1 = constituent_default("O1", [
+	1,
+	-1,
+	0,
+	0,
+	0,
+	0,
+	1
+], node_corrections_default.uO1, node_corrections_default.fO1);
+constituents.K1 = constituent_default("K1", [
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	-1
+], node_corrections_default.uK1, node_corrections_default.fK1);
+constituents.J1 = constituent_default("J1", [
+	1,
+	2,
+	0,
+	-1,
+	0,
+	0,
+	-1
+], node_corrections_default.uJ1, node_corrections_default.fJ1);
+constituents.M1 = constituent_default("M1", [
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1
+], node_corrections_default.uM1, node_corrections_default.fM1);
+constituents.P1 = constituent_default("P1", [
+	1,
+	1,
+	-2,
+	0,
+	0,
+	0,
+	1
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.S1 = constituent_default("S1", [
+	1,
+	1,
+	-1,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.OO1 = constituent_default("OO1", [
+	1,
+	3,
+	0,
+	0,
+	0,
+	0,
+	-1
+], node_corrections_default.uOO1, node_corrections_default.fOO1);
+constituents["2N2"] = constituent_default("2N2", [
+	2,
+	-2,
+	0,
+	2,
+	0,
+	0,
+	0
+], node_corrections_default.uM2, node_corrections_default.fM2);
+constituents.N2 = constituent_default("N2", [
+	2,
+	-1,
+	0,
+	1,
+	0,
+	0,
+	0
+], node_corrections_default.uM2, node_corrections_default.fM2);
+constituents.NU2 = constituent_default("NU2", [
+	2,
+	-1,
+	2,
+	-1,
+	0,
+	0,
+	0
+], node_corrections_default.uM2, node_corrections_default.fM2);
+constituents.M2 = constituent_default("M2", [
+	2,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uM2, node_corrections_default.fM2);
+constituents.LAM2 = constituent_default("LAM2", [
+	2,
+	1,
+	-2,
+	1,
+	0,
+	0,
+	2
+], node_corrections_default.uM2, node_corrections_default.fM2);
+constituents.L2 = constituent_default("L2", [
+	2,
+	1,
+	0,
+	-1,
+	0,
+	0,
+	2
+], node_corrections_default.uL2, node_corrections_default.fL2);
+constituents.T2 = constituent_default("T2", [
+	2,
+	2,
+	-3,
+	0,
+	0,
+	1,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.S2 = constituent_default("S2", [
+	2,
+	2,
+	-2,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.R2 = constituent_default("R2", [
+	2,
+	2,
+	-1,
+	0,
+	0,
+	-1,
+	2
+], node_corrections_default.uZero, node_corrections_default.fUnity);
+constituents.K2 = constituent_default("K2", [
+	2,
+	2,
+	0,
+	0,
+	0,
+	0,
+	0
+], node_corrections_default.uK2, node_corrections_default.fK2);
+constituents.M3 = constituent_default("M3", [
+	3,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+], (a) => {
+	return node_corrections_default.uModd(a, 3);
+}, (a) => {
+	return node_corrections_default.fModd(a, 3);
+});
+constituents.MSF = compound_constituent_default("MSF", [{
+	constituent: constituents.S2,
+	factor: 1
+}, {
+	constituent: constituents.M2,
+	factor: -1
+}]);
+constituents["2Q1"] = compound_constituent_default("2Q1", [{
+	constituent: constituents.N2,
+	factor: 1
+}, {
+	constituent: constituents.J1,
+	factor: -1
+}]);
+constituents.RHO = compound_constituent_default("RHO", [{
+	constituent: constituents.NU2,
+	factor: 1
+}, {
+	constituent: constituents.K1,
+	factor: -1
+}]);
+constituents.MU2 = compound_constituent_default("MU2", [{
+	constituent: constituents.M2,
+	factor: 2
+}, {
+	constituent: constituents.S2,
+	factor: -1
+}]);
+constituents["2SM2"] = compound_constituent_default("2SM2", [{
+	constituent: constituents.S2,
+	factor: 2
+}, {
+	constituent: constituents.M2,
+	factor: -1
+}]);
+constituents["2MK3"] = compound_constituent_default("2MK3", [{
+	constituent: constituents.M2,
+	factor: 1
+}, {
+	constituent: constituents.O1,
+	factor: 1
+}]);
+constituents.MK3 = compound_constituent_default("MK3", [{
+	constituent: constituents.M2,
+	factor: 1
+}, {
+	constituent: constituents.K1,
+	factor: 1
+}]);
+constituents.MN4 = compound_constituent_default("MN4", [{
+	constituent: constituents.M2,
+	factor: 1
+}, {
+	constituent: constituents.N2,
+	factor: 1
+}]);
+constituents.M4 = compound_constituent_default("M4", [{
+	constituent: constituents.M2,
+	factor: 2
+}]);
+constituents.MS4 = compound_constituent_default("MS4", [{
+	constituent: constituents.M2,
+	factor: 1
+}, {
+	constituent: constituents.S2,
+	factor: 1
+}]);
+constituents.S4 = compound_constituent_default("S4", [{
+	constituent: constituents.S2,
+	factor: 2
+}]);
+constituents.M6 = compound_constituent_default("M6", [{
+	constituent: constituents.M2,
+	factor: 3
+}]);
+constituents.S6 = compound_constituent_default("S6", [{
+	constituent: constituents.S2,
+	factor: 3
+}]);
+constituents.M8 = compound_constituent_default("M8", [{
+	constituent: constituents.M2,
+	factor: 4
+}]);
+var constituents_default = constituents;
+
+//#endregion
+//#region src/harmonics/index.ts
+const getDate = (time) => {
+	if (time instanceof Date) return time;
+	if (typeof time === "number") return /* @__PURE__ */ new Date(time * 1e3);
+	throw new Error("Invalid date format, should be a Date object, or timestamp");
+};
+const getTimeline = (start, end, seconds = 600) => {
+	const items = [];
+	const endTime = end.getTime() / 1e3;
+	let lastTime = start.getTime() / 1e3;
+	const startTime = lastTime;
+	const hours = [];
+	while (lastTime <= endTime) {
+		items.push(/* @__PURE__ */ new Date(lastTime * 1e3));
+		hours.push((lastTime - startTime) / 3600);
+		lastTime += seconds;
+	}
+	return {
+		items,
+		hours
+	};
+};
+const harmonicsFactory = ({ harmonicConstituents, phaseKey, offset }) => {
+	if (!Array.isArray(harmonicConstituents)) throw new Error("Harmonic constituents are not an array");
+	const constituents$1 = [];
+	harmonicConstituents.forEach((constituent) => {
+		if (typeof constituent.name === "undefined") throw new Error("Harmonic constituents must have a name property");
+		if (constituents_default[constituent.name] !== void 0) constituents$1.push({
+			...constituent,
+			_model: constituents_default[constituent.name],
+			_phase: d2r * constituent[phaseKey]
+		});
+	});
+	if (offset !== false) constituents$1.push({
+		name: "Z0",
+		_model: constituents_default.Z0,
+		_phase: 0,
+		amplitude: offset
+	});
+	let start = /* @__PURE__ */ new Date();
+	let end = /* @__PURE__ */ new Date();
+	const harmonics = {};
+	harmonics.setTimeSpan = (startTime, endTime) => {
+		start = getDate(startTime);
+		end = getDate(endTime);
+		if (start.getTime() >= end.getTime()) throw new Error("Start time must be before end time");
+		return harmonics;
+	};
+	harmonics.prediction = (options) => {
+		return prediction_default({
+			timeline: getTimeline(start, end, (typeof options !== "undefined" ? options : { timeFidelity: 600 }).timeFidelity),
+			constituents: constituents$1,
+			start
+		});
+	};
+	return Object.freeze(harmonics);
+};
+var harmonics_default = harmonicsFactory;
+
+//#endregion
+//#region src/index.ts
+const tidePredictionFactory = (constituents$1, options = {}) => {
+	const harmonicsOptions = {
+		harmonicConstituents: constituents$1,
+		phaseKey: "phase_GMT",
+		offset: false,
+		...options
+	};
+	return {
+		getTimelinePrediction: ({ start, end }) => {
+			return harmonics_default(harmonicsOptions).setTimeSpan(start, end).prediction().getTimelinePrediction();
+		},
+		getExtremesPrediction: ({ start, end, labels, offsets, timeFidelity }) => {
+			return harmonics_default(harmonicsOptions).setTimeSpan(start, end).prediction({ timeFidelity }).getExtremesPrediction({
+				labels,
+				offsets
+			});
+		},
+		getWaterLevelAtTime: ({ time }) => {
+			const endDate = new Date(time.getTime() + 600 * 1e3);
+			return harmonics_default(harmonicsOptions).setTimeSpan(time, endDate).prediction().getTimelinePrediction()[0];
+		}
+	};
+};
+tidePredictionFactory.constituents = constituents_default;
+var src_default = tidePredictionFactory;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=index.js.map