@ranzenjs/client 0.2.1 → 0.4.0

package/README.md

@@ -7,8 +7,8 @@ does, keeps the session alive, and reads the portal's apps into plain, typed obj
 bun add @ranzenjs/client
 ```
 
-Runs on Bun and Node 22.1 or newer. It has three small dependencies (htmlparser2, domhandler,
-css-select) and no native code.
+Runs on Bun and Node 22.1 or newer. It has four small dependencies (htmlparser2, domhandler,
+css-select, and hash-wasm for Kurswahl Online) and no native code.
 
 ## Usage
 
@@ -81,6 +81,44 @@ that a session still works, so sign in again when one reports `SESSION_EXPIRED`.
 `maxConcurrency` (default 4) caps parallel requests per connection. Extra calls wait for a free
 slot, and a download frees its slot once the headers arrive.
 
+## Kurswahl Online
+
+Many schools run their course timetable on [Kurswahl Online](https://www.kurswahl-online.de/).
+Its client stands on its own: a school may use it, Schulportal, or both, and neither needs the
+other.
+
+```ts
+import { createKurswahl } from '@ranzenjs/client/kurswahl';
+
+const kurswahl = createKurswahl({ onDrift: (drift) => console.warn('ranzen drift', drift) });
+const schools = await kurswahl.schools(); // [{ id: 'musterschule', name: '…' }, …], no sign-in needed
+const connection = await kurswahl.login({
+	school: 'musterschule',
+	username: 'max.muster',
+	password
+});
+
+const plan = await connection.timetable(); // the general plan, A and B weeks included
+const week = await connection.timetable({ week: '2025-08-25' }); // one week, one rotation
+const rotation = await connection.currentRotation(); // 'A', 'B', or null; this week
+await connection.logout();
+```
+
+Kurswahl lists only the courses the student takes, so treat it as the source of truth for them.
+Each lesson names its course, ISO weekday, period, room and `rotation` (`'A'`, `'B'`, or `null`
+for every week). Teachers come with their short code, which Schulportal uses too, and their
+salutation. Sign-in hashes the password with Argon2 the way the login page does, which takes a few
+seconds of CPU. The week list can still show last school year's dates, so ask
+`currentRotation()` for this week's rotation rather than picking a week by date.
+
+`exportState()`, `restore()`, `keepAlive()`, `keepWarm()` and `dispose()` work as they do for
+Schulportal, with requests one at a time, since each page hands out the next CSRF token. Export
+once the connection is idle, and let one connection at a time use a session.
+
+To line both up, substitution days carry `rotation` next to their `week` label, and each
+substitution has `periodNumbers` (`"3 - 4"` → `[3, 4]`). Break duties such as `"2/3"` or `"MP"`
+have none.
+
 ## Errors
 
 ranzen throws a `RanzenError` with a `code` and a `fault`. The fault says who has to act:

package/dist/apps/lessons/parse.js

@@ -1,39 +1,36 @@
 import { layoutChanged } from '../../errors.js';
-import { all, attr, cells, hasClass, one, ownText, rows, text } from '../../html.js';
+import { all, attr, cells, hasClass, one, ownText, rawText, rows, text } from '../../html.js';
 import { ignoreDrift, isoDate, parseCount, queryParam } from '../../util.js';
 export function parseOverview(document, drift = ignoreDrift) {
     const folders = one('#mappen', document);
     if (!folders)
         throw layoutChanged('#mappen on the lessons page');
     const cards = all('.thumbnail', folders);
-    // An empty #mappen is a valid account without courses; course links outside cards are not.
+    // An empty #mappen is a valid account without courses; a skipped course would read as gone.
+    const links = all('a[href*="sus_view"]', folders);
     const carded = new Set(cards.flatMap((card) => all('a[href*="sus_view"]', card)));
-    if (all('a[href*="sus_view"]', folders).some((link) => !carded.has(link))) {
-        drift('The lessons page lists courses outside known cards.');
+    if (links.some((link) => !carded.has(link))) {
+        throw layoutChanged('.thumbnail cards around every course in #mappen');
     }
     const latest = one('#aktuellTable', document);
     if (!latest && one('tr[data-entry]', document)) {
         drift('The lessons page lists entries outside #aktuellTable.');
     }
+    const courses = cards.map((card) => {
+        const id = queryParam(attr(one('a[href*="sus_view"]', card), 'href'), 'id');
+        if (!id)
+            throw layoutChanged('a course link in every .thumbnail card');
+        return {
+            id,
+            name: attr(one('h2 [title]', card), 'title') ?? text(one('h2', card)),
+            teachers: all('button.dropdown-toggle[title]', card).map(teacher),
+            marks: count(one('a.btn-info[href*="#leistungen"]', card)),
+            undoneHomework: count(one('a.btn-danger', card)),
+            upcomingEntries: count(one('a.btn-warning', card))
+        };
+    });
     return {
-        courses: cards.flatMap((card) => {
-            const id = queryParam(attr(one('a[href*="sus_view"]', card), 'href'), 'id');
-            if (!id) {
-                drift('A course card has no course link.');
-                return [];
-            }
-            const name = attr(one('h2 [title]', card), 'title') ?? text(one('h2', card));
-            return [
-                {
-                    id,
-                    name,
-                    teachers: all('button.dropdown-toggle[title]', card).map(teacher),
-                    marks: count(one('a.btn-info[href*="#leistungen"]', card)),
-                    undoneHomework: count(one('a.btn-danger', card)),
-                    upcomingEntries: count(one('a.btn-warning', card))
-                }
-            ];
-        }),
+        courses,
         latest: entryRows(rows(latest), 'A latest entry', drift).map((row) => ({
             course: { id: attr(row, 'data-book') ?? '', name: text(one('.name', row)) },
             teachers: all('.teacher button[title]', row).map(teacher),
@@ -111,7 +108,7 @@ function historyEntry(row, drift) {
     return {
         ...emptyEntry(attr(row, 'data-entry') ?? ''),
         date: entryDate(text(when), 'A history row', drift),
-        periods: periods(text(when && one('small', when)), drift),
+        periods: periods(rawText(when && one('small', when)), drift),
         topic: text(body && one(':scope > b', body)) || null,
         content: text(contentOf(body), true) || null,
         homework: historyHomework(body, drift),
@@ -171,7 +168,7 @@ function submission(group, drift) {
     return [
         {
             id,
-            name: ownText(button),
+            name: rawText(button, true),
             open: hasClass(button, 'btn-warning'),
             uploaded: text(button && one('.badge', button)) || null,
             due: day && time ? `${day}T${time[1].padStart(2, '0')}:${time[2]}` : day
@@ -185,7 +182,7 @@ function parseMarks(document, drift) {
         const [name, date, value, ...rest] = cells(row);
         const last = marks.at(-1);
         if (name && date && value && !rest.length) {
-            marks.push({ name: text(name), date: text(date), value: text(value), comment: null });
+            marks.push({ name: rawText(name), date: rawText(date), value: text(value), comment: null });
         }
         else if (last &&
             name &&
@@ -300,7 +297,7 @@ function periods(label, drift) {
     const match = /^(\d+)\.?(?:\s*[-–]\s*(\d+)\.?)?(?:\s*Stunden?)?$/.exec(label.trim());
     if (!match) {
         drift('A history row has unreadable periods.');
-        return null;
+        return { from: null, to: null, label };
     }
     const from = Number(match[1]);
     return { from, to: match[2] ? Number(match[2]) : from, label };

package/dist/apps/lessons/types.d.ts

@@ -5,8 +5,9 @@ export interface Teacher {
     lastName: string | null;
 }
 export interface Periods {
-    from: number;
-    to: number;
+    /** Null with `to` when the label names no period numbers, e.g. "08:00 - 09:30". */
+    from: number | null;
+    to: number | null;
     /** The portal's wording, unchanged, e.g. "1. - 2. Stunde". */
     label: string;
 }
@@ -22,6 +23,7 @@ export interface EntryFile {
 }
 export interface Submission {
     id: string;
+    /** As written, so it can serve as a key. */
     name: string;
     open: boolean;
     /** The portal's badge, e.g. "2" files handed in; null without one. */
@@ -70,6 +72,7 @@ export interface Overview {
     attendance: AttendanceSummary[];
 }
 export interface Mark {
+    /** As written, like `date`, so it can serve as a key. */
     name: string;
     /** As shown by the portal, which omits the year, e.g. "Do, 17.09.". */
     date: string;

package/dist/apps/substitutions/parse.js

@@ -46,10 +46,12 @@ export function parsePlan(document, drift = ignoreDrift) {
         const entries = rows(table).filter((row) => !isPlaceholder(row));
         const stamp = /(\d{2}\.\d{2}\.\d{4}) um ([01]\d|2[0-3]):([0-5]\d):([0-5]\d)/.exec(text(panel));
         const stampDay = stamp && isoDate(stamp[1]);
+        const week = text(one('.badge.woche', panel)) || null;
         return [
             {
                 date,
-                week: text(one('.badge.woche', panel)) || null,
+                week,
+                rotation: rotation(week, drift),
                 notices: parseNotices(panel),
                 substitutions: entries.map((row) => {
                     const columns = cells(row);
@@ -98,6 +100,7 @@ function substitution(values, date, marked, drift) {
     const entry = {
         date,
         periods: values.Stunde ?? '',
+        periodNumbers: periodNumbers(values.Stunde ?? '', drift),
         classes: null,
         previousClasses: null,
         substitute: null,
@@ -126,6 +129,27 @@ function substitution(values, date, marked, drift) {
     });
     return entry;
 }
+// "A-Woche" or "WA-Woche" → "A".
+function rotation(label, drift) {
+    if (!label)
+        return null;
+    const match = /^W?([AB])-?Woche$/i.exec(label);
+    if (!match)
+        drift('A plan day has an unknown week label.');
+    return match ? match[1].toUpperCase() : null;
+}
+// "3 - 4" → [3, 4]; break duties such as "2/3" (between periods 2 and 3) or "MP" (lunch) hold no lesson.
+function periodNumbers(label, drift) {
+    const range = /^(\d{1,2})\.?(?:\s*[-–]\s*(\d{1,2})\.?)?$/.exec(label.trim());
+    const first = Number(range?.[1]);
+    const last = Number(range?.[2] ?? range?.[1]);
+    if (range && last >= first)
+        return Array.from({ length: last - first + 1 }, (_, i) => first + i);
+    if (!/^(?:\d{1,2}\s*\/\s*\d{1,2}|MP)$/i.test(label.trim())) {
+        drift('A substitution has periods in an unknown format.');
+    }
+    return [];
+}
 // An empty day is one cell spanning the table, e.g. "Keine Einträge!".
 function isPlaceholder(row) {
     const [only, ...rest] = cells(row);

package/dist/apps/substitutions/types.d.ts

@@ -1,8 +1,15 @@
+import type { Rotation } from '../../rotation.js';
+export type { Rotation };
 export interface Substitution {
     /** ISO calendar date. */
     date: string;
-    /** As shown by the portal, e.g. "3 - 4". */
+    /** As shown by the portal, e.g. "3 - 4", "2/3" or "MP". */
     periods: string;
+    /**
+     * The lesson periods, e.g. [3, 4] for "3 - 4". Empty for break duties such as "2/3"
+     * (between periods 2 and 3) or "MP" (lunch break), and for labels ranzen cannot read.
+     */
+    periodNumbers: number[];
     classes: string | null;
     previousClasses: string | null;
     substitute: string | null;
@@ -27,8 +34,10 @@ export interface Notice {
 }
 export interface Day {
     date: string;
-    /** The school's week label, e.g. "A-Woche". */
+    /** The school's week label, e.g. "A-Woche" or "WA-Woche". */
     week: string | null;
+    /** The week label as A/B rotation; null without a label or for one ranzen cannot read. */
+    rotation: Rotation | null;
     notices: Notice[];
     substitutions: Substitution[];
     /** Local portal time, e.g. "2026-10-16T11:58:40". */

package/dist/html.d.ts

@@ -14,6 +14,8 @@ export declare function rows(table: Element | null | undefined): Element[];
  * Multiline keeps <br> and block breaks, for free text such as lesson content and homework.
  */
 export declare function text(node: Root | null | undefined, multiline?: boolean): string;
+/** Visible text with its whitespace as written, only trimmed, for names callers store as keys. */
+export declare function rawText(node: Element | null | undefined, own?: boolean): string;
 /** Only the element's own text, without that of badges or labels nested in it. */
 export declare function ownText(node: Element | null | undefined): string;
 export declare function attr(node: Element | null | undefined, name: string): string | undefined;

package/dist/html.js

@@ -73,6 +73,19 @@ export function text(node, multiline = false) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
+/** Visible text with its whitespace as written, only trimmed, for names callers store as keys. */
+export function rawText(node, own = false) {
+    const parts = [];
+    const walk = (current) => {
+        if (isText(current))
+            parts.push(current.data);
+        else if (!own && isTag(current) && !hasClass(current, 'hidden_encoded')) {
+            current.children.forEach(walk);
+        }
+    };
+    node?.children.forEach(walk);
+    return parts.join('').trim();
+}
 /** Only the element's own text, without that of badges or labels nested in it. */
 export function ownText(node) {
     return (node?.children ?? [])

package/dist/kurswahl/connection.d.ts

@@ -0,0 +1,34 @@
+import type { Drift } from '../app.js';
+import type { SignalOption } from '../connection.js';
+import type { KurswahlAccount, KurswahlSession } from './session.js';
+import type { Rotation, Timetable } from './types.js';
+export interface TimetableOptions extends SignalOption {
+    /** First day of a week the portal offers, as ISO date, e.g. "2025-08-25"; omit for the general plan. */
+    week?: string;
+}
+/** One signed-in Kurswahl session. Save it with exportState(), end it with logout(). */
+export declare class KurswahlConnection {
+    #private;
+    constructor(session: KurswahlSession, onDrift?: (drift: Drift) => void);
+    get account(): KurswahlAccount;
+    /**
+     * The personal timetable. The general plan lists every lesson, both rotations included;
+     * a dated week shows only the lessons of that week's rotation.
+     */
+    timetable({ week, signal }?: TimetableOptions): Promise<Timetable>;
+    /**
+     * This week's rotation, read from the plan Kurswahl shows by default, which is the current week.
+     * Null when that week has no A/B lessons, e.g. for a student without alternating courses.
+     */
+    currentRotation({ signal }?: SignalOption): Promise<Rotation | null>;
+    /** Extends the session; throws SESSION_EXPIRED once Kurswahl has ended it. */
+    keepAlive({ signal }?: SignalOption): Promise<void>;
+    /** Pings Kurswahl on an interval, as its pages do; stops on dispose() or a lasting failure. */
+    keepWarm(intervalMs?: number): void;
+    /** Cookies, CSRF token and identity; never the password. Store it encrypted. */
+    exportState(): string;
+    /** Stops keepWarm() and cancels pending requests; the session stays valid for restore(). */
+    dispose(): void;
+    /** Leaves through the logout link, then disposes. */
+    logout({ signal }?: SignalOption): Promise<void>;
+}

package/dist/kurswahl/connection.js

@@ -0,0 +1,126 @@
+import { fail, isRanzenError, layoutChanged } from '../errors.js';
+import { positive } from '../util.js';
+import { parseHtml } from '../html.js';
+import { isGeneralPlan, parseTimetable, timetableDatabase } from './parse.js';
+import { writeKurswahlState } from './state.js';
+/** One signed-in Kurswahl session. Save it with exportState(), end it with logout(). */
+export class KurswahlConnection {
+    #session;
+    #onDrift;
+    #drifted = new Set();
+    #heartbeat;
+    #beating = false;
+    constructor(session, onDrift) {
+        this.#session = session;
+        this.#onDrift = onDrift;
+    }
+    get account() {
+        return this.#session.account;
+    }
+    /**
+     * The personal timetable. The general plan lists every lesson, both rotations included;
+     * a dated week shows only the lessons of that week's rotation.
+     */
+    async timetable({ week, signal } = {}) {
+        const value = week === undefined ? '0' : weekValue(week);
+        const session = this.#session;
+        // The timetable form names its database; the first visit learns it.
+        if (!session.database) {
+            const first = await session.page('stundenplan.php', {}, signal);
+            session.database = timetableDatabase(parseHtml(first.text));
+        }
+        const { text } = await session.page('stundenplan.php', { woche: value, db_name: session.database, show_optimierung: 'false' }, signal);
+        const timetable = parseTimetable(text, (detail) => this.#drift(detail));
+        session.database = timetable.database;
+        if (week !== undefined && timetable.week?.start !== week) {
+            throw fail('NOT_FOUND', 'Kurswahl Online does not offer this week.');
+        }
+        // A single week holds only one rotation, so passing it off as the general plan would lose lessons.
+        if (week === undefined && !isGeneralPlan(text))
+            throw layoutChanged('the general plan');
+        return timetable;
+    }
+    /**
+     * This week's rotation, read from the plan Kurswahl shows by default, which is the current week.
+     * Null when that week has no A/B lessons, e.g. for a student without alternating courses.
+     */
+    async currentRotation({ signal } = {}) {
+        const { text } = await this.#session.page('stundenplan.php', {}, signal);
+        const timetable = parseTimetable(text, (detail) => this.#drift(detail));
+        this.#session.database = timetable.database;
+        if (timetable.week || isGeneralPlan(text))
+            throw layoutChanged('the current week');
+        const rotations = new Set(timetable.lessons.map((lesson) => lesson.rotation));
+        rotations.delete(null);
+        if (rotations.size > 1)
+            throw layoutChanged('a single rotation in the current week');
+        return [...rotations][0] ?? null;
+    }
+    /** Extends the session; throws SESSION_EXPIRED once Kurswahl has ended it. */
+    async keepAlive({ signal } = {}) {
+        await this.#session.ajax('index.php', { ajax: 'keepalive' }, signal);
+    }
+    /** Pings Kurswahl on an interval, as its pages do; stops on dispose() or a lasting failure. */
+    keepWarm(intervalMs = 60_000) {
+        this.#session.ensureOpen();
+        positive(intervalMs, 'intervalMs');
+        clearInterval(this.#heartbeat);
+        this.#heartbeat = setInterval(() => {
+            if (this.#beating)
+                return;
+            this.#beating = true;
+            this.keepAlive()
+                .catch((error) => {
+                if (!isRanzenError(error) || !error.retryable)
+                    clearInterval(this.#heartbeat);
+            })
+                .finally(() => (this.#beating = false));
+        }, intervalMs);
+        this.#heartbeat.unref();
+    }
+    /** Cookies, CSRF token and identity; never the password. Store it encrypted. */
+    exportState() {
+        const session = this.#session;
+        session.ensureOpen();
+        return writeKurswahlState({
+            account: session.account,
+            token: session.token,
+            database: session.database,
+            cookies: session.transport.jar.snapshot()
+        });
+    }
+    /** Stops keepWarm() and cancels pending requests; the session stays valid for restore(). */
+    dispose() {
+        clearInterval(this.#heartbeat);
+        this.#heartbeat = undefined;
+        this.#session.dispose();
+    }
+    /** Leaves through the logout link, then disposes. */
+    async logout({ signal } = {}) {
+        try {
+            await this.#session.leave(signal);
+        }
+        finally {
+            this.dispose();
+        }
+    }
+    // Once per kind and connection, so a timetable read in a loop does not flood the hook.
+    #drift(detail) {
+        if (!this.#onDrift || this.#drifted.has(detail))
+            return;
+        this.#drifted.add(detail);
+        try {
+            this.#onDrift({ app: 'kurswahl', detail });
+        }
+        catch {
+            // A failing log hook must not fail a read that succeeded.
+        }
+    }
+}
+// "2025-08-25" → "25_08_2025", the portal's week value.
+function weekValue(week) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(week);
+    if (!match)
+        throw fail('INVALID_OPTION', 'week must be an ISO date such as "2025-08-25".');
+    return `${match[3]}_${match[2]}_${match[1]}`;
+}

package/dist/kurswahl/index.d.ts

@@ -0,0 +1,30 @@
+import type { Drift } from '../app.js';
+import type { SignalOption } from '../connection.js';
+import { type FetchFunction } from '../transport/http.js';
+import { KurswahlConnection } from './connection.js';
+import { type KurswahlCredentials } from './sign-in.js';
+import type { School } from './types.js';
+export { KurswahlConnection, type TimetableOptions } from './connection.js';
+export type { KurswahlAccount } from './session.js';
+export type { KurswahlCredentials } from './sign-in.js';
+export type * from './types.js';
+export interface KurswahlOptions {
+    /** Replaces the global fetch, e.g. for a proxy or tests. */
+    fetch?: FetchFunction;
+    /** Must look like a browser's, or Kurswahl Online refuses; defaults to a current Firefox. */
+    userAgent?: string;
+    /** Milliseconds per request, including the wait for each body chunk; defaults to 15000. */
+    timeoutMs?: number;
+    /** Called once per connection for each kind of drift; log it to learn that ranzen needs an update. */
+    onDrift?: (drift: Drift) => void;
+}
+export interface Kurswahl {
+    /** Every school on Kurswahl Online; no sign-in needed. */
+    schools(options?: SignalOption): Promise<School[]>;
+    /** Signs in like the login page does, Argon2 hashing included (about a second of CPU). */
+    login(credentials: KurswahlCredentials, options?: SignalOption): Promise<KurswahlConnection>;
+    /** Validates and rebuilds a connection from exportState() without any request. */
+    restore(state: string): KurswahlConnection;
+}
+/** A Kurswahl Online client, independent of any Schulportal connection; creating it makes no request. */
+export declare function createKurswahl(options?: KurswahlOptions): Kurswahl;

package/dist/kurswahl/index.js

@@ -0,0 +1,55 @@
+import { fail, layoutChanged } from '../errors.js';
+import { CookieJar } from '../transport/cookies.js';
+import { Transport } from '../transport/http.js';
+import { isRecord, parseJson, positive } from '../util.js';
+import { KurswahlConnection } from './connection.js';
+import { KurswahlSession, WWW } from './session.js';
+import { signIn } from './sign-in.js';
+import { isSchool, readKurswahlState } from './state.js';
+export { KurswahlConnection } from './connection.js';
+// Kurswahl Online sends any client it does not take for a browser to its main site.
+const BROWSER = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0';
+/** A Kurswahl Online client, independent of any Schulportal connection; creating it makes no request. */
+export function createKurswahl(options = {}) {
+    const base = {
+        fetch: options.fetch ?? ((url, init) => fetch(url, init)),
+        userAgent: options.userAgent ?? BROWSER,
+        timeoutMs: positive(options.timeoutMs ?? 15_000, 'timeoutMs'),
+        maxConcurrency: 1
+    };
+    // One host per transport, so a signed-in session never reaches the main site or another school.
+    const settings = (school) => ({
+        ...base,
+        hosts: new Set([school ? `${school}.kurswahl-online.de` : new URL(WWW).host])
+    });
+    return {
+        async schools({ signal } = {}) {
+            const reply = await new Transport(settings(null)).send({
+                url: `${WWW}/ajax.php`,
+                query: { type: 'schulen' },
+                signal
+            });
+            const data = parseJson(reply.text, 'the school list');
+            if (!isRecord(data) || Array.isArray(data))
+                throw layoutChanged('the school list as an object');
+            return Object.entries(data).flatMap(([id, name]) => isSchool(id) && typeof name === 'string' ? [{ id, name: name.trim() }] : []);
+        },
+        async login(credentials, { signal } = {}) {
+            for (const field of ['school', 'username', 'password']) {
+                if (typeof credentials[field] !== 'string' || !credentials[field]) {
+                    throw fail('INVALID_OPTION', `${field} must be a non-empty string.`);
+                }
+            }
+            if (!isSchool(credentials.school)) {
+                throw fail('INVALID_OPTION', 'school must be a Kurswahl subdomain such as "musterschule".');
+            }
+            const session = await signIn(new Transport(settings(credentials.school)), credentials, signal);
+            return new KurswahlConnection(session, options.onDrift);
+        },
+        restore(state) {
+            const { account, token, database, cookies } = readKurswahlState(state);
+            const transport = new Transport(settings(account.school), CookieJar.restore(cookies));
+            return new KurswahlConnection(new KurswahlSession(account, transport, token, database), options.onDrift);
+        }
+    };
+}

package/dist/kurswahl/parse.d.ts

@@ -0,0 +1,13 @@
+import { type Document } from '../html.js';
+import { type DriftSink } from '../util.js';
+import type { Timetable } from './types.js';
+/** The anti-CSRF token every Kurswahl page carries. */
+export declare function csrfToken(html: string): string | null;
+/** The timetable database the page's week form posts, e.g. "musterschule_stundenplan_1". */
+export declare function timetableDatabase(doc: Document): string;
+/** Kurswahl marks "allgemeiner Stundenplan" as selected only when it shows the general plan. */
+export declare function isGeneralPlan(html: string): boolean;
+/** Visible ASCII only, since the token travels in a header; shared with state validation. */
+export declare function isToken(value: string): boolean;
+export declare function isDatabase(value: string): boolean;
+export declare function parseTimetable(html: string, drift: DriftSink): Timetable;