ponomar-ts 0.1.0-alpha.0

package/src/core/calendar/jdate.ts

@@ -0,0 +1,192 @@
+// Ported from Ponomar/JDate.java (typiconman/ponomar).
+// The upstream Java class is a mutable Julian-calendar date backed by a
+// Julian Day Number (JDN). This TS port is an immutable value object with the
+// same JDN as the source of truth, plus pre-computed Y/M/D fields.
+//
+// Notes on differences vs upstream:
+//   * All operations return new values (no mutation).
+//   * `dayOfYear` matches upstream's zero-indexed convention (Jan 1 == 0).
+//   * `difference(a, b) = a.jdn - b.jdn` matches upstream's static method
+//     `JDate.difference(former, latter)`.
+
+import type { CalendarDate } from "./pcalendar.ts";
+
+/** A calendar date on the Julian calendar plus its Julian Day Number. */
+export interface JulianDate {
+	readonly year: number;
+	readonly month: number;
+	readonly day: number;
+	readonly jdn: number;
+}
+
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const;
+const DAYS_IN_MONTH_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const;
+
+const MONTH_DOY = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334] as const;
+const MONTH_DOY_LEAP = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335] as const;
+
+/** Julian calendar leap year rule: every year divisible by 4. */
+export function isJulianLeapYear(year: number): boolean {
+	return year % 4 === 0;
+}
+
+/** Maximum day number for a (Julian-calendar) month/year combination. */
+export function daysInMonth(year: number, month: number): number {
+	if (!Number.isInteger(month) || month < 1 || month > 12) {
+		throw new RangeError(`month must be 1..12, got ${month}`);
+	}
+	const table = isJulianLeapYear(year) ? DAYS_IN_MONTH_LEAP : DAYS_IN_MONTH;
+	return table[month - 1]!;
+}
+
+function assertValid(year: number, month: number, day: number): void {
+	if (!Number.isInteger(year) || year < 1) {
+		throw new RangeError(`year must be a positive integer, got ${year}`);
+	}
+	if (!Number.isInteger(month) || month < 1 || month > 12) {
+		throw new RangeError(`month must be 1..12, got ${month}`);
+	}
+	if (!Number.isInteger(day) || day < 1 || day > daysInMonth(year, month)) {
+		throw new RangeError(
+			`day must be 1..${daysInMonth(year, month)} for ${year}-${month}, got ${day}`,
+		);
+	}
+}
+
+/**
+ * Build a `JulianDate` from Julian-calendar year/month/day. Throws
+ * `RangeError` if any field is out of range for the calendar.
+ */
+export function julianDate(year: number, month: number, day: number): JulianDate {
+	assertValid(year, month, day);
+	return { year, month, day, jdn: julianYmdToJdn(year, month, day) };
+}
+
+/** Build a `JulianDate` from its Julian Day Number. */
+export function julianDateFromJdn(jdn: number): JulianDate {
+	if (!Number.isInteger(jdn) || jdn < 0) {
+		throw new RangeError(`jdn must be a non-negative integer, got ${jdn}`);
+	}
+	const { year, month, day } = jdnToJulianYmd(jdn);
+	return { year, month, day, jdn };
+}
+
+/** Add `n` days (may be negative); returns a new `JulianDate`. */
+export function addDays(date: JulianDate, n: number): JulianDate {
+	if (!Number.isInteger(n)) {
+		throw new RangeError(`n must be an integer, got ${n}`);
+	}
+	return julianDateFromJdn(date.jdn + n);
+}
+
+/** Subtract `n` days (may be negative); returns a new `JulianDate`. */
+export function subtractDays(date: JulianDate, n: number): JulianDate {
+	return addDays(date, -n);
+}
+
+/**
+ * Signed difference in days between two dates: `a.jdn - b.jdn`. Matches
+ * upstream `JDate.difference(former, latter)`.
+ */
+export function difference(a: JulianDate, b: JulianDate): number {
+	return a.jdn - b.jdn;
+}
+
+/** Day of week where Sunday = 0, Monday = 1, ... Saturday = 6. */
+export function dayOfWeek(date: JulianDate): 0 | 1 | 2 | 3 | 4 | 5 | 6 {
+	// JDN 0 was a Monday; (jdn + 1) mod 7 yields Sunday-first index.
+	return ((date.jdn + 1) % 7) as 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}
+
+/**
+ * Zero-indexed day of year on the Julian calendar (Jan 1 == 0). Matches
+ * upstream `JDate.getDoy()`.
+ */
+export function dayOfYear(date: JulianDate): number {
+	const table = isJulianLeapYear(date.year) ? MONTH_DOY_LEAP : MONTH_DOY;
+	return table[date.month - 1]! + date.day - 1;
+}
+
+export function equals(a: JulianDate, b: JulianDate): boolean {
+	return a.jdn === b.jdn;
+}
+
+export function compare(a: JulianDate, b: JulianDate): number {
+	return a.jdn - b.jdn;
+}
+
+/**
+ * Convert a Julian-calendar date to the proleptic Gregorian calendar via
+ * Julian Day Number.
+ */
+export function toGregorian(date: JulianDate): CalendarDate {
+	return jdnToGregorianYmd(date.jdn);
+}
+
+/** Convert a proleptic Gregorian date to a Julian-calendar `JulianDate`. */
+export function fromGregorian(date: CalendarDate): JulianDate {
+	return julianDateFromJdn(gregorianYmdToJdn(date.year, date.month, date.day));
+}
+
+// ---------------------------------------------------------------------------
+// Low-level JDN conversions (Meeus / Fliegel-van Flandern style, integer only)
+
+function julianYmdToJdn(year: number, month: number, day: number): number {
+	const a = Math.floor((14 - month) / 12);
+	const y = year + 4800 - a;
+	const m = month + 12 * a - 3;
+	return (
+		day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - 32083
+	);
+}
+
+function jdnToJulianYmd(jdn: number): {
+	year: number;
+	month: number;
+	day: number;
+} {
+	const c = jdn + 32082;
+	const d = Math.floor((4 * c + 3) / 1461);
+	const e = c - Math.floor((1461 * d) / 4);
+	const m = Math.floor((5 * e + 2) / 153);
+	const day = e - Math.floor((153 * m + 2) / 5) + 1;
+	const month = m + 3 - 12 * Math.floor(m / 10);
+	const year = d - 4800 + Math.floor(m / 10);
+	return { year, month, day };
+}
+
+function gregorianYmdToJdn(year: number, month: number, day: number): number {
+	const a = Math.floor((14 - month) / 12);
+	const y = year + 4800 - a;
+	const m = month + 12 * a - 3;
+	return (
+		day +
+		Math.floor((153 * m + 2) / 5) +
+		365 * y +
+		Math.floor(y / 4) -
+		Math.floor(y / 100) +
+		Math.floor(y / 400) -
+		32045
+	);
+}
+
+function jdnToGregorianYmd(jdn: number): CalendarDate {
+	const a = jdn + 32044;
+	const b = Math.floor((4 * a + 3) / 146097);
+	const c = a - Math.floor((146097 * b) / 4);
+	const d = Math.floor((4 * c + 3) / 1461);
+	const e = c - Math.floor((1461 * d) / 4);
+	const m = Math.floor((5 * e + 2) / 153);
+	const day = e - Math.floor((153 * m + 2) / 5) + 1;
+	const month = m + 3 - 12 * Math.floor(m / 10);
+	const year = 100 * b + d - 4800 + Math.floor(m / 10);
+	return { year, month, day };
+}
+
+// Internal accessors reused by pcalendar.ts to avoid duplicating conversion
+// logic. Kept `internal` in name to signal they are not part of the stable
+// public API.
+export const _internal = {
+	gregorianYmdToJdn,
+	jdnToGregorianYmd,
+} as const;

package/src/core/calendar/pcalendar.ts

@@ -0,0 +1,47 @@
+// Proleptic Gregorian calendar utilities. The Gregorian date shape and its
+// small helper set live here so that `paschalion.ts` and `core/calendar/jdate.ts`
+// can share one definition of `CalendarDate` and one JDN-based conversion path.
+
+import { _internal } from "./jdate.ts";
+
+/** A proleptic Gregorian calendar date (all fields 1-based). */
+export interface CalendarDate {
+	readonly year: number;
+	readonly month: number;
+	readonly day: number;
+}
+
+/**
+ * Gregorian calendar offset (in days) that must be *added* to a Julian date
+ * to obtain the same civil day on the Gregorian calendar, for the given AD
+ * year. Every non-leap Gregorian century adds one day. Correct from 1583
+ * (Gregorian reform) forward.
+ */
+export function julianToGregorianOffset(year: number): number {
+	if (!Number.isInteger(year) || year < 1583) {
+		throw new RangeError(
+			`Gregorian conversion is only defined from 1583 onward, got ${year}`,
+		);
+	}
+	return Math.floor(year / 100) - Math.floor(year / 400) - 2;
+}
+
+/**
+ * Add `n` days to a Gregorian calendar date. Handles month/year boundaries.
+ * `n` may be negative.
+ */
+export function addDays(date: CalendarDate, n: number): CalendarDate {
+	if (!Number.isInteger(n)) {
+		throw new RangeError(`n must be an integer, got ${n}`);
+	}
+	const jdn = _internal.gregorianYmdToJdn(date.year, date.month, date.day);
+	return _internal.jdnToGregorianYmd(jdn + n);
+}
+
+/** Signed difference in days between two Gregorian dates (`a - b`). */
+export function difference(a: CalendarDate, b: CalendarDate): number {
+	return (
+		_internal.gregorianYmdToJdn(a.year, a.month, a.day) -
+		_internal.gregorianYmdToJdn(b.year, b.month, b.day)
+	);
+}

package/src/core/dsl/eval.ts

@@ -0,0 +1,94 @@
+// Ported from Ponomar/StringOp.java (typiconman/ponomar) — evaluator.
+//
+// Semantics mirror upstream:
+//   * Every operator returns a `double`. Booleans are 1.0 / 0.0.
+//   * `&&`, `||`, `!` coerce their operands via `value !== 0 → true`.
+//   * `true` / `false` are reserved identifiers.
+//   * Variables come from a plain lookup table. Missing names throw.
+//   * Numeric semantics use JS number (IEEE-754 double), matching Java double.
+
+import { type Expr, ParseError, parse } from "./parser.ts";
+
+export type Context = Readonly<Record<string, number | boolean>>;
+
+export class EvalError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "EvalError";
+	}
+}
+
+const RESERVED: Readonly<Record<string, number>> = {
+	true: 1,
+	false: 0,
+};
+
+export function evaluate(source: string, ctx: Context): number {
+	return evalExpr(parse(source), ctx);
+}
+
+export function evaluateBool(source: string, ctx: Context): boolean {
+	return evalExpr(parse(source), ctx) !== 0;
+}
+
+export function evaluateAst(expr: Expr, ctx: Context): number {
+	return evalExpr(expr, ctx);
+}
+
+function evalExpr(expr: Expr, ctx: Context): number {
+	switch (expr.kind) {
+		case "number":
+			return expr.value;
+		case "ident": {
+			const reserved = RESERVED[expr.name];
+			if (reserved !== undefined) return reserved;
+			if (!Object.prototype.hasOwnProperty.call(ctx, expr.name)) {
+				throw new EvalError(
+					`Unknown variable ${JSON.stringify(expr.name)}`,
+				);
+			}
+			const v = ctx[expr.name];
+			if (typeof v === "boolean") return v ? 1 : 0;
+			if (typeof v !== "number" || !Number.isFinite(v)) {
+				throw new EvalError(
+					`Variable ${JSON.stringify(expr.name)} is not a finite number`,
+				);
+			}
+			return v;
+		}
+		case "unary": {
+			const v = evalExpr(expr.operand, ctx);
+			return expr.op === "!" ? (v !== 0 ? 0 : 1) : -v;
+		}
+		case "binary": {
+			// Short-circuit && / ||: safe here because expressions are pure.
+			if (expr.op === "&&") {
+				return evalExpr(expr.left, ctx) !== 0 && evalExpr(expr.right, ctx) !== 0
+					? 1
+					: 0;
+			}
+			if (expr.op === "||") {
+				return evalExpr(expr.left, ctx) !== 0 || evalExpr(expr.right, ctx) !== 0
+					? 1
+					: 0;
+			}
+			const l = evalExpr(expr.left, ctx);
+			const r = evalExpr(expr.right, ctx);
+			switch (expr.op) {
+				case "==": return l === r ? 1 : 0;
+				case "!=": return l !== r ? 1 : 0;
+				case "<":  return l < r ? 1 : 0;
+				case "<=": return l <= r ? 1 : 0;
+				case ">":  return l > r ? 1 : 0;
+				case ">=": return l >= r ? 1 : 0;
+				case "+":  return l + r;
+				case "-":  return l - r;
+				case "*":  return l * r;
+				case "/":  return l / r;
+				case "%":  return l % r;
+			}
+		}
+	}
+}
+
+export { ParseError };

package/src/core/dsl/index.ts

@@ -0,0 +1,15 @@
+export {
+	EvalError,
+	evaluate,
+	evaluateAst,
+	evaluateBool,
+	type Context,
+} from "./eval.ts";
+export { LexError, tokenize, type Token, type TokenKind } from "./lexer.ts";
+export {
+	ParseError,
+	parse,
+	type BinaryOp,
+	type Expr,
+	type UnaryOp,
+} from "./parser.ts";

package/src/core/dsl/lexer.ts

@@ -0,0 +1,121 @@
+// Ported from Ponomar/StringOp.java (typiconman/ponomar) — tokenizer.
+//
+// The upstream Java `StringOp.eval` is a recursive text-splitting parser.
+// This port tokenises first and then runs a Pratt parser, which yields the
+// same semantics for well-formed expressions but tolerates arbitrary
+// whitespace (upstream requires spaces around binary operators due to its
+// `substring(0, n - 1)` / `substring(n + 2)` slicing).
+
+export type TokenKind =
+	| "NUMBER"
+	| "IDENT"
+	| "LP"
+	| "RP"
+	| "PLUS"
+	| "MINUS"
+	| "STAR"
+	| "SLASH"
+	| "PERCENT"
+	| "EQ"
+	| "NE"
+	| "LT"
+	| "LE"
+	| "GT"
+	| "GE"
+	| "AND"
+	| "OR"
+	| "NOT"
+	| "EOF";
+
+export interface Token {
+	readonly kind: TokenKind;
+	readonly text: string;
+	/** 0-based source offset where this token starts. */
+	readonly pos: number;
+}
+
+export class LexError extends Error {
+	readonly source: string;
+	readonly pos: number;
+	constructor(message: string, source: string, pos: number) {
+		super(`${message} at position ${pos} in ${JSON.stringify(source)}`);
+		this.name = "LexError";
+		this.source = source;
+		this.pos = pos;
+	}
+}
+
+const SINGLE: Readonly<Record<string, TokenKind>> = {
+	"(": "LP",
+	")": "RP",
+	"+": "PLUS",
+	"-": "MINUS",
+	"*": "STAR",
+	"/": "SLASH",
+	"%": "PERCENT",
+};
+
+export function tokenize(source: string): Token[] {
+	const out: Token[] = [];
+	let i = 0;
+	const n = source.length;
+	while (i < n) {
+		const c = source[i] as string;
+		if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		const start = i;
+		const two = source.slice(i, i + 2);
+		switch (two) {
+			case "==": out.push({ kind: "EQ", text: two, pos: start }); i += 2; continue;
+			case "!=": out.push({ kind: "NE", text: two, pos: start }); i += 2; continue;
+			case "<=": out.push({ kind: "LE", text: two, pos: start }); i += 2; continue;
+			case ">=": out.push({ kind: "GE", text: two, pos: start }); i += 2; continue;
+			case "&&": out.push({ kind: "AND", text: two, pos: start }); i += 2; continue;
+			case "||": out.push({ kind: "OR", text: two, pos: start }); i += 2; continue;
+		}
+		if (c === "<") { out.push({ kind: "LT", text: "<", pos: start }); i++; continue; }
+		if (c === ">") { out.push({ kind: "GT", text: ">", pos: start }); i++; continue; }
+		if (c === "!") { out.push({ kind: "NOT", text: "!", pos: start }); i++; continue; }
+		const single = SINGLE[c];
+		if (single !== undefined) {
+			out.push({ kind: single, text: c, pos: start });
+			i++;
+			continue;
+		}
+		if (isDigit(c) || (c === "." && isDigit(source[i + 1] ?? ""))) {
+			let j = i;
+			while (j < n && isDigit(source[j] as string)) j++;
+			if (source[j] === ".") {
+				j++;
+				while (j < n && isDigit(source[j] as string)) j++;
+			}
+			out.push({ kind: "NUMBER", text: source.slice(i, j), pos: start });
+			i = j;
+			continue;
+		}
+		if (isIdentStart(c)) {
+			let j = i + 1;
+			while (j < n && isIdentPart(source[j] as string)) j++;
+			out.push({ kind: "IDENT", text: source.slice(i, j), pos: start });
+			i = j;
+			continue;
+		}
+		throw new LexError(`Unexpected character ${JSON.stringify(c)}`, source, i);
+	}
+	out.push({ kind: "EOF", text: "", pos: n });
+	return out;
+}
+
+function isDigit(c: string): boolean {
+	return c >= "0" && c <= "9";
+}
+
+function isIdentStart(c: string): boolean {
+	return (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_";
+}
+
+function isIdentPart(c: string): boolean {
+	return isIdentStart(c) || isDigit(c);
+}

package/src/core/dsl/parser.ts

@@ -0,0 +1,148 @@
+// Ported from Ponomar/StringOp.java (typiconman/ponomar) — Pratt parser.
+//
+// Precedence (low → high) matches the upstream recursive text-splitting
+// evaluator, which splits on operators in exactly this order:
+//   ||, &&, == / !=, < / <= / > / >=, + / -, * / / / %, unary ! / -.
+
+import { type Token, type TokenKind, tokenize } from "./lexer.ts";
+
+export type BinaryOp =
+	| "||"
+	| "&&"
+	| "=="
+	| "!="
+	| "<"
+	| "<="
+	| ">"
+	| ">="
+	| "+"
+	| "-"
+	| "*"
+	| "/"
+	| "%";
+
+export type UnaryOp = "!" | "-";
+
+export type Expr =
+	| { readonly kind: "number"; readonly value: number }
+	| { readonly kind: "ident"; readonly name: string }
+	| { readonly kind: "unary"; readonly op: UnaryOp; readonly operand: Expr }
+	| {
+			readonly kind: "binary";
+			readonly op: BinaryOp;
+			readonly left: Expr;
+			readonly right: Expr;
+	  };
+
+export class ParseError extends Error {
+	readonly source: string;
+	readonly pos: number;
+	constructor(message: string, source: string, pos: number) {
+		super(`${message} at position ${pos} in ${JSON.stringify(source)}`);
+		this.name = "ParseError";
+		this.source = source;
+		this.pos = pos;
+	}
+}
+
+const INFIX: Partial<Record<TokenKind, { prec: number; op: BinaryOp }>> = {
+	OR: { prec: 1, op: "||" },
+	AND: { prec: 2, op: "&&" },
+	EQ: { prec: 3, op: "==" },
+	NE: { prec: 3, op: "!=" },
+	LT: { prec: 4, op: "<" },
+	LE: { prec: 4, op: "<=" },
+	GT: { prec: 4, op: ">" },
+	GE: { prec: 4, op: ">=" },
+	PLUS: { prec: 5, op: "+" },
+	MINUS: { prec: 5, op: "-" },
+	STAR: { prec: 6, op: "*" },
+	SLASH: { prec: 6, op: "/" },
+	PERCENT: { prec: 6, op: "%" },
+};
+
+const UNARY_PREC = 7;
+
+export function parse(source: string): Expr {
+	const tokens = tokenize(source);
+	const p = new Parser(source, tokens);
+	const expr = p.parseExpr(0);
+	p.expect("EOF");
+	return expr;
+}
+
+class Parser {
+	private i = 0;
+	private readonly source: string;
+	private readonly tokens: readonly Token[];
+	constructor(source: string, tokens: readonly Token[]) {
+		this.source = source;
+		this.tokens = tokens;
+	}
+
+	parseExpr(minPrec: number): Expr {
+		let left = this.parseUnary();
+		while (true) {
+			const tok = this.peek();
+			const inf = INFIX[tok.kind];
+			if (inf === undefined || inf.prec < minPrec) break;
+			this.i++;
+			const right = this.parseExpr(inf.prec + 1);
+			left = { kind: "binary", op: inf.op, left, right };
+		}
+		return left;
+	}
+
+	private parseUnary(): Expr {
+		const tok = this.peek();
+		if (tok.kind === "NOT") {
+			this.i++;
+			return { kind: "unary", op: "!", operand: this.parseExpr(UNARY_PREC) };
+		}
+		if (tok.kind === "MINUS") {
+			this.i++;
+			return { kind: "unary", op: "-", operand: this.parseExpr(UNARY_PREC) };
+		}
+		return this.parsePrimary();
+	}
+
+	private parsePrimary(): Expr {
+		const tok = this.peek();
+		if (tok.kind === "NUMBER") {
+			this.i++;
+			return { kind: "number", value: Number(tok.text) };
+		}
+		if (tok.kind === "IDENT") {
+			this.i++;
+			return { kind: "ident", name: tok.text };
+		}
+		if (tok.kind === "LP") {
+			this.i++;
+			const inner = this.parseExpr(0);
+			this.expect("RP");
+			return inner;
+		}
+		throw new ParseError(
+			`Expected expression, got ${tok.kind} ${JSON.stringify(tok.text)}`,
+			this.source,
+			tok.pos,
+		);
+	}
+
+	private peek(): Token {
+		return this.tokens[this.i] as Token;
+	}
+
+	expect(kind: TokenKind): Token {
+		const tok = this.peek();
+		if (tok.kind !== kind) {
+			throw new ParseError(
+				`Expected ${kind}, got ${tok.kind} ${JSON.stringify(tok.text)}`,
+				this.source,
+				tok.pos,
+			);
+		}
+		this.i++;
+		return tok;
+	}
+}

package/src/data/divineLiturgy.ts

@@ -0,0 +1,82 @@
+// AUTO-GENERATED by scripts/codegen — DO NOT EDIT.
+// Source: vendor/ponomar/Ponomar/languages/xml (git submodule).
+// Regenerate with `npm run codegen`.
+
+import type { Command } from "./types.ts";
+
+export const DIVINE_LITURGY_COMMANDS: ReadonlyArray<Command> = [
+	{
+		"name": "Transfer",
+		"value": "nday >= 52 || nday < -55",
+		"cmd": "GS == 1",
+		"comment": "This determines whether the sequential readings may be skipped or transferred."
+	},
+	{
+		"name": "Transfer",
+		"value": "nday >= 52 || nday < -55",
+		"cmd": "GS == 0",
+		"comment": "This determines whether the sequential readings may be skipped or transferred."
+	},
+	{
+		"name": "Suppress",
+		"value": "doy == 4 && dow != 0 && dow != 6",
+		"cmd": "GS == 1",
+		"comment": "Eve of Theophany can have seq. readings on Sat. (see Table 25b, 2019) and on Sun. (see Table 24b, 2087)"
+	},
+	{
+		"name": "Suppress",
+		"value": "doy == 357 && dow != 6",
+		"cmd": "GS == 1",
+		"comment": "Eve of Nativity can have seq. readings on Sat. (see Table 27a, 2084)"
+	},
+	{
+		"name": "Suppress",
+		"value": "(doy == 358 || doy == 5)",
+		"comment": "Nativity and Theophany never have seq. readings"
+	},
+	{
+		"name": "Suppress",
+		"value": "(doy == 256 || doy == 217) && dow == 0",
+		"comment": "Suppress seq. readings if Exaltation or Transfiguration falls on Sunday"
+	},
+	{
+		"name": "Class3Transfers",
+		"value": "!(doy == 358 || doy == 357 || doy == 4 || doy == 5 || doy == 256 || doy == 217) && ((dRank >= 5 && dow != 0) || dRank == 8)",
+		"cmd": "GS == 1 || GS == 0"
+	},
+	{
+		"name": "Class3Transfers",
+		"value": "(doy == 3 && dow == 5) || (doy == 356 && dow == 5)",
+		"cmd": "GS == 1 || GS == 0",
+		"comment": "There is no Liturgy on Friday when the Royal Hours occur. The readings are moved to Thursday."
+	},
+	{
+		"name": "Class3Transfers",
+		"value": "(doy == 256 || doy == 217) && dow != 0",
+		"comment": "Exaltation and Transfiguration readings are only transferred if it's not a Sunday"
+	},
+	{
+		"name": "TransferRulesB",
+		"value": "dow != 0 && !(nday >= -63 && nday <= 0) && doy != 338",
+		"cmd": "GS == 1",
+		"comment": "This determines the rules used to transfer the readings to the previous day. Note that St. Nicholas's day has a special set of rules"
+	},
+	{
+		"name": "TransferRulesF",
+		"value": "!(nday >= -63 && nday <= 0) && (dow == 2  && doy != 339) || ((doy == 340 && (dow != 0 && dow != 2)))",
+		"cmd": "GS == 1",
+		"comment": "This determines the rules used to transfer the readings to the next day (forwards). Note that St. Nicholas's day has a special set of rules."
+	},
+	{
+		"name": "TransferRulesB",
+		"value": "dow != 0 && !(nday >= -63 && nday <= 0) && doy != 338",
+		"cmd": "GS == 0",
+		"comment": "This determines the rules used to transfer the readings to the previous day. Note that St. Nicholas's day has a special set of rules"
+	},
+	{
+		"name": "TransferRulesF",
+		"value": "!(nday >= -63 && nday <= 0) && (dow == 2  && doy != 339) || ((doy == 340 && (dow != 0 && dow != 2)))",
+		"cmd": "GS == 0",
+		"comment": "This determines the rules used to transfer the readings to the next day (forwards). Note that St. Nicholas's day has a special set of rules."
+	}
+] as const;