@kensio/pinyinjs 1.6.0 → 1.7.0

package/dist/dictionary/tiers.js

@@ -1,4 +1,5 @@
 import { isSingleCharacter, toCharacters } from "../script/characters.js";
+import { traditionalForms } from "./artifact.js";
 /**
  * The dictionary tiers, smallest first and each contained in the next.
  *
@@ -65,6 +66,71 @@ function charactersInUse(entries) {
     }
     return inUse;
 }
+/**
+ * The characters a tier holds: the ones in use, and the ones it has to answer.
+ *
+ * "In use" alone is not enough, because a tier is keyed by more than the
+ * headwords it holds — an entry claims every 繁體 spelling attested for it, and
+ * some of those spellings are rare characters with entries of their own. A tier
+ * holding 卒 is keyed for 䘚 whether or not it holds 䘚, so without the
+ * character's own entry it answers that key from the 卒 that reached it
+ * sideways and reads `zú`, where `full` lets 䘚's own entry win the key and
+ * reads `zhú`. Neither reading is wrong — 䘚 written for 卒 really is `zú` —
+ * but which one you get must not depend on how much of the dictionary has
+ * loaded, or the documented upgrade path contradicts itself mid-paragraph.
+ *
+ * Admitting the entry is all it takes: the artifact's `claimKeys` puts
+ * headwords ahead of 繁體 aliases in every tier, so once 䘚 is present it wins
+ * its own key exactly as it does in `full`.
+ *
+ * It repeats to a fixpoint because an admitted character claims spellings of
+ * its own, and one of those can be another character with an entry behind it.
+ * On the current sources it settles at once — 242 characters admitted, then a
+ * confirming pass that admits none — but nothing in the merge rules a chain
+ * out, and the pass is a set lookup per entry against a build that reads four
+ * source files.
+ */
+function charactersHeld(entries, words) {
+    const headed = new Set();
+    for (const entry of entries) {
+        if (isSingleCharacter(entry.hans)) {
+            headed.add(entry.hans);
+        }
+    }
+    const inUse = charactersInUse(entries);
+    const held = new Set();
+    for (const character of headed) {
+        if (inUse.has(character)) {
+            held.add(character);
+        }
+    }
+    /**
+     * Admit the characters this entry claims the key of, reporting any news.
+     */
+    const admitClaims = (entry) => {
+        let admitted = false;
+        for (const form of traditionalForms(entry)) {
+            if (headed.has(form) && !held.has(form)) {
+                held.add(form);
+                admitted = true;
+            }
+        }
+        return admitted;
+    };
+    for (const entry of words) {
+        admitClaims(entry);
+    }
+    let growing = true;
+    while (growing) {
+        growing = false;
+        for (const entry of entries) {
+            if (isSingleCharacter(entry.hans) && held.has(entry.hans)) {
+                growing = admitClaims(entry) || growing;
+            }
+        }
+    }
+    return held;
+}
 /**
  * The entries a tier contains.
  *
@@ -72,7 +138,8 @@ function charactersInUse(entries) {
  * makes a dictionary usable at all: they cover roughly half of running text on
  * their own, and they are the fallback for every position no word matches.
  * Tiering cuts the phrase tail and the unused characters, never a character
- * that some word is written with.
+ * that some word is written with — and never one the tier is keyed for anyway,
+ * which is what {@link charactersHeld} adds on top.
  *
  * `full` holds everything, including the characters no source uses in a word.
  * They cost little there and are the difference between reading a rare
@@ -82,15 +149,14 @@ export function selectTier(entries, tier) {
     if (tier === "full") {
         return entries;
     }
-    const inUse = charactersInUse(entries);
-    const characters = entries.filter((entry) => isSingleCharacter(entry.hans) && inUse.has(entry.hans));
-    if (tier === "core") {
-        return characters;
-    }
-    const words = entries
-        .filter((entry) => !isSingleCharacter(entry.hans))
-        .toSorted(byFrequency)
-        .slice(0, STANDARD_TIER_WORDS);
-    return [...characters, ...words];
+    const words = tier === "core"
+        ? []
+        : entries
+            .filter((entry) => !isSingleCharacter(entry.hans))
+            .toSorted(byFrequency)
+            .slice(0, STANDARD_TIER_WORDS);
+    const held = charactersHeld(entries, words);
+    const characters = entries.filter((entry) => isSingleCharacter(entry.hans) && held.has(entry.hans));
+    return tier === "core" ? characters : [...characters, ...words];
 }
 //# sourceMappingURL=tiers.js.map

package/dist/dictionary/tiers.js.map

@@ -1 +1 @@
-{"version":3,"file":"tiers.js","sourceRoot":"","sources":["../../src/dictionary/tiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG1E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAU,CAAC;AAO3D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAqB,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAE1C;;GAEG;AACH,SAAS,WAAW,CAAC,IAAqB,EAAE,KAAsB;IAChE,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;QACvC,OAAO,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;IAC1C,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,eAAe,CACtB,OAAmC;IAEnC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC;gBACxB,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;YACD,SAAS;QACX,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5C,KAAK,MAAM,SAAS,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC3C,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CACxB,OAAmC,EACnC,IAAU;IAEV,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACpB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAC/B,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAClE,CAAC;IACF,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACpB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,KAAK,GAAG,OAAO;SAClB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SACjD,QAAQ,CAAC,WAAW,CAAC;SACrB,KAAK,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;IACjC,OAAO,CAAC,GAAG,UAAU,EAAE,GAAG,KAAK,CAAC,CAAC;AACnC,CAAC"}
+{"version":3,"file":"tiers.js","sourceRoot":"","sources":["../../src/dictionary/tiers.ts"],"names":[],"mappings":"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"}

package/dist/grade/check.d.ts

@@ -0,0 +1,156 @@
+import { type ConvertOptions } from "../decode/convert.js";
+import type { Dictionary } from "../dictionary/dictionary.js";
+import { type Syllable } from "../syllable/syllable.js";
+/**
+ * What one syllable of a typed transcription turned out to be.
+ *
+ * `toneless` is deliberately separate from `tone`: {@link Syllable.tone} says
+ * whether a tone was written at all, so "you left the tones off" is a different
+ * thing to report than "you wrote the wrong one", and only the second is a
+ * mistake about the language. {@link CheckOptions.tones} decides which of them
+ * counts against the score.
+ */
+export type PinyinVerdict = "correct" | "toneless" | "tone" | "wrong" | "missing" | "extra";
+/**
+ * Where a typed syllable falls against the word boundaries the reading has.
+ *
+ * `split` is a word written as two — `yín háng` for 银行 — and `joined` is two
+ * words run into one. Both are reported whatever {@link CheckOptions.spacing}
+ * says, so an application can show them without having to grade them.
+ */
+export type SpacingVerdict = "correct" | "split" | "joined";
+/**
+ * Whether one dimension of the writing has to be right for a perfect score.
+ *
+ * `optional` still reports the verdict and counts the syllable correct anyway;
+ * `required` counts it wrong. Both dimensions this applies to — tones and word
+ * spacing — are things an exercise may or may not be teaching yet.
+ */
+export type CheckRequirement = "optional" | "required";
+/**
+ * How a transcription should be checked.
+ *
+ * Every {@link ConvertOptions} field is accepted and passed to the conversion
+ * the answer is read from, which is what `readings` is worth having here for:
+ * an exercise knows which sense of 长 its own sentence uses, where the decoder
+ * can only weigh the evidence.
+ */
+export interface CheckOptions extends ConvertOptions {
+    /** Whether a tone has to be written. Defaults to `optional`. */
+    readonly tones?: CheckRequirement;
+    /**
+     * Whether the word spacing has to be right. Defaults to `optional`.
+     *
+     * Off by default because the 分词连写 this grades against is not a complete
+     * 正词法 implementation — see [orthography](../../docs/orthography/) for
+     * where it stops — so a learner can write a word the standard writes
+     * differently from the way this does. On for an exercise teaching the
+     * spacing, where getting it right is the point.
+     */
+    readonly spacing?: CheckRequirement;
+}
+/**
+ * One syllable of the check: what was expected there, and what was typed.
+ */
+export interface CheckedSyllable {
+    readonly verdict: PinyinVerdict;
+    /**
+     * Where this syllable falls against the word boundaries, where both a reading
+     * and a typed syllable met here.
+     *
+     * A separate axis from {@link CheckedSyllable.verdict}, because it is a
+     * separate mistake: `yín háng` reads 银行 perfectly and writes it as two
+     * words. Undefined for a syllable that was only expected or only typed.
+     */
+    readonly spacing: SpacingVerdict | undefined;
+    /** Whether this counts as right in {@link PinyinCheck.score}. */
+    readonly isCorrect: boolean;
+    /** The reading expected here, or undefined where nothing was expected. */
+    readonly expected: Syllable | undefined;
+    /**
+     * What was typed here, parsed, or undefined where nothing was typed.
+     *
+     * Also undefined for something typed that is not a syllable at all, which
+     * {@link CheckedSyllable.text} still reports as written.
+     */
+    readonly actual: Syllable | undefined;
+    /** What was typed here, exactly as written, or empty where nothing was. */
+    readonly text: string;
+    /**
+     * The characters the expected syllable reads.
+     *
+     * Undefined where a syllable reads on into the characters named before it,
+     * exactly as {@link ConvertedPiece.source} is, and where nothing was
+     * expected at all.
+     */
+    readonly source: string | undefined;
+    /**
+     * Where those characters start, in code points from the start of the text.
+     *
+     * What highlighting the mistake in the text itself needs, and counted the way
+     * {@link import("../decode/segment.js").Segment.at} counts.
+     */
+    readonly at: number | undefined;
+}
+/**
+ * A typed transcription marked against the text it was written for.
+ */
+export interface PinyinCheck {
+    /** One entry per syllable expected or typed, in order. */
+    readonly syllables: readonly CheckedSyllable[];
+    /** Whether every syllable counted as correct. */
+    readonly isCorrect: boolean;
+    /**
+     * The share of the syllables that counted as correct, from 0 to 1.
+     *
+     * Over the entries reported rather than over the expected reading, so that
+     * inventing a syllable costs as much as dropping one: an answer with an extra
+     * syllable in it has more entries than the reading has syllables.
+     */
+    readonly score: number;
+    /** The reading that was expected, as the conversion writes it. */
+    readonly reading: readonly Syllable[];
+}
+/**
+ * Mark a typed pinyin transcription against the text it was written for.
+ *
+ * ```ts
+ * check(dictionary, "北京", "bei3jing3").syllables.map((one) => one.verdict);
+ * // ["correct", "tone"]
+ * ```
+ *
+ * **The point of doing this with a dictionary is being fair in the ways a
+ * string comparison cannot be**, and every one of these is a learner being
+ * marked wrong for being right:
+ *
+ * - **Either notation, mixed freely.** `běi` and `bei3` are the same syllable
+ *   and both parse, so `bei3jīng` is not a spelling mistake.
+ * - **A reading the decoder itself was unsure of.** Where another reading of
+ *   the same character was there for the taking, it is accepted — see
+ *   {@link rejectedReadings}. 银行 is not one of those: the word settles both
+ *   syllables, so `yínxíng` really is wrong.
+ * - **Sandhi either way.** 你好 is written `nǐ hǎo` and said `ní hǎo`, and 不是
+ *   is `bú shì` written and `bù shì` underneath. Both pass.
+ * - **Tones written or not.** A syllable typed with no tone is `toneless`
+ *   rather than `tone`, and {@link CheckOptions.tones} says whether that counts
+ *   against the score. A neutral tone typed without a mark is simply correct,
+ *   because that is how pinyin writes it.
+ * - **Apostrophes.** Not a word boundary and not a sound: `nǐhǎo`, `nǐ hǎo` and
+ *   `nǐ'hǎo` all read the same, and check the same.
+ *
+ * Word spacing is graded on its own axis, reported as
+ * {@link CheckedSyllable.spacing} and counted only where
+ * {@link CheckOptions.spacing} asks for it — and tolerant in the same spirit,
+ * since 分词连写 and the words the dictionary knows are two conventions this
+ * package writes and a learner may have been taught either.
+ *
+ * What comes back is one {@link CheckedSyllable} per syllable expected or
+ * typed, in order, each naming the characters it reads and where they are, so
+ * that a mistake can be shown against the text rather than against the answer.
+ *
+ * This is {@link import("../accuracy/score.js").scoreCase} — the scorer that
+ * marks the decoder against the gold corpus — pointed at a person instead, and
+ * it costs three conversions of the text.
+ */
+export declare function check(dictionary: Dictionary, text: string, typed: string, options?: CheckOptions): PinyinCheck;
+//# sourceMappingURL=check.d.ts.map

package/dist/grade/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/grade/check.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,UAAU,GACV,MAAM,GACN,OAAO,GACP,SAAS,GACT,OAAO,CAAC;AAEZ;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,UAAU,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,CAAC;IAC7C,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;CACvC;AAqaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,KAAK,CACnB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,YAAiB,GACzB,WAAW,CAuBb"}

package/dist/grade/check.js

@@ -0,0 +1,356 @@
+import { alignSequences } from "../accuracy/align.js";
+import { tokenisePinyin } from "../accuracy/tokenise.js";
+import { convertPieces, convertPiecesUnscored, } from "../decode/convert.js";
+import { READING_CHARGE } from "../decode/lattice.js";
+import { toCharacters } from "../script/characters.js";
+import { readSyllable, writeSyllableSpelling, } from "../syllable/syllable.js";
+import { NEUTRAL_TONE } from "../tone/tone.js";
+/**
+ * The other corner of the sandhi square.
+ *
+ * A learner may write the underlying tones or the tones actually said, and both
+ * are right — 你好 is written `nǐ hǎo` and said `ní hǎo`. Rather than convert
+ * four times for the four combinations of {@link SandhiOptions}, this converts
+ * twice and inverts both switches at once, which reaches every tone: 一 and 不
+ * sandhi applies to syllables in the first and fourth tones, third-tone sandhi
+ * only to syllables in the third, so the two passes never touch the same
+ * syllable and each one's two forms both appear across the two corners.
+ */
+function oppositeSandhi(sandhi) {
+    return {
+        yiBu: !(sandhi?.yiBu ?? true),
+        thirdTone: !(sandhi?.thirdTone ?? false),
+    };
+}
+/**
+ * Where each piece's source characters start, in code points.
+ *
+ * Read off the sources rather than tracked through the conversion, which works
+ * because every character of the text is named by exactly one piece — a piece
+ * naming none is either pinyin orthography the source has no trace of, such as
+ * the space between two words, or a syllable reading on into the characters the
+ * piece before it named.
+ */
+function sourcePositions(pieces) {
+    const positions = [];
+    let at = 0;
+    for (const piece of pieces) {
+        positions.push(at);
+        at += toCharacters(piece.source ?? "").length;
+    }
+    return positions;
+}
+/**
+ * What a piece written between two syllables makes of the join.
+ *
+ * Only a hyphen written where the syllables would otherwise have run together
+ * is 分词连写's internal boundary; anything else — a space, punctuation, a
+ * stretch that was never Han — separates two words.
+ */
+function junctionOver(text, held) {
+    return text === "-" && held === "join" ? "hyphen" : "break";
+}
+/**
+ * The syllables a conversion writes, with their positions and what joins them.
+ *
+ * A conversion writes its syllables as adjacent pieces within a word — the
+ * 隔音符号 is part of a syllable's own spelling rather than a piece of its own —
+ * so anything standing between two of them is a boundary, and the hyphen of
+ * 分词连写 is the one that is not a word boundary.
+ */
+function readingSyllables(pieces) {
+    const positions = sourcePositions(pieces);
+    const syllables = [];
+    // The first syllable of a text begins a word, whatever comes before it.
+    let junction = "break";
+    for (const [at, piece] of pieces.entries()) {
+        if (piece.syllable === undefined) {
+            junction = junctionOver(piece.text, junction);
+            continue;
+        }
+        syllables.push({
+            piece: { ...piece, syllable: piece.syllable },
+            /* c8 ignore next -- one position is recorded for each piece there is */
+            at: positions[at] ?? 0,
+            junction,
+        });
+        junction = "join";
+    }
+    return syllables;
+}
+/**
+ * The readings the decode turned down without much reason to.
+ *
+ * The decode charges {@link READING_CHARGE} for a word boundary, so a rejected
+ * reading costing less than that was available without breaking any dictionary
+ * word apart — see {@link import("../decode/confidence.js").isUncertain}, which
+ * is the same threshold read as a question rather than as a filter. The library
+ * knows it was guessing there, so a learner who guessed the other way is not
+ * wrong.
+ *
+ * Only a rejected reading of exactly the one character this syllable reads is
+ * taken. An alternative can cover a different stretch — 玩儿 read as `wánr`
+ * competes with 玩 `wán` and 儿 `ér` — and a claim about other characters says
+ * nothing about what belongs in this position.
+ */
+function rejectedReadings(piece) {
+    const { confidence, source } = piece;
+    if (source === undefined || toCharacters(source).length !== 1) {
+        return [];
+    }
+    return (confidence?.alternatives ?? []).flatMap((alternative) => {
+        const [syllable] = alternative.reading;
+        return alternative.cost < READING_CHARGE &&
+            alternative.to - alternative.from === 1 &&
+            alternative.reading.length === 1 &&
+            syllable !== undefined
+            ? [syllable]
+            : [];
+    });
+}
+/**
+ * Gather readings into the spellings and tones they allow.
+ *
+ * The tone is allowed to be undefined only because {@link Syllable.tone} is: a
+ * reading that came out of the dictionary always carries one.
+ */
+function acceptedReadings(readings) {
+    const accepted = new Map();
+    for (const syllable of readings) {
+        const base = writeSyllableSpelling(syllable);
+        const tones = accepted.get(base) ?? new Set();
+        tones.add(syllable.tone);
+        accepted.set(base, tones);
+    }
+    return accepted;
+}
+/**
+ * Read the text, and work out what a typed syllable is allowed to be.
+ *
+ * Three conversions of the same text, and each one answers a different question.
+ * The first is the answer itself, with the confidence report beside it. The
+ * second is the other corner of the sandhi square, which is where the second
+ * form of every tone comes from. The third is the same text written under the
+ * other spacing convention, which is where a boundary's tolerance comes from:
+ * 分词连写 is what puts 了 on its verb and separates 市 from 南京, and a learner
+ * who wrote the words the dictionary knows instead — `tā kàn le`, `Nánjīngshì`
+ * — has written one of the two conventions this package implements rather than
+ * made a mistake.
+ *
+ * All three decode identically. Sandhi rewrites tones and 分词连写 moves
+ * boundaries; neither touches the syllables underneath, so all three line up one
+ * for one.
+ */
+function expectedReading(dictionary, text, options) {
+    const written = readingSyllables(convertPieces(dictionary, text, options));
+    const said = readingSyllables(convertPiecesUnscored(dictionary, text, {
+        ...options,
+        sandhi: oppositeSandhi(options.sandhi),
+    }));
+    const spaced = readingSyllables(convertPiecesUnscored(dictionary, text, {
+        ...options,
+        grouping: !(options.grouping ?? true),
+    }));
+    return written.map(({ piece, at, junction }, index) => {
+        // Sliced rather than indexed, so that a conversion somehow reporting fewer
+        // syllables than the others contributes nothing rather than needing a
+        // fallback: the caller's own conversion decides alone.
+        const alternate = said
+            .slice(index, index + 1)
+            .map((one) => one.piece.syllable);
+        const other = spaced.slice(index, index + 1).map((one) => one.junction);
+        return {
+            syllable: piece.syllable,
+            accepted: acceptedReadings([
+                piece.syllable,
+                ...alternate,
+                ...rejectedReadings(piece),
+            ]),
+            // A hyphen is neither a break nor a join, and so allows both: it is a
+            // boundary the standard writes inside a word, and a learner rendering it
+            // as a space has not invented one.
+            acceptsBreak: junction !== "join" || other.some((one) => one !== "join"),
+            acceptsJoin: junction !== "break" || other.some((one) => one !== "break"),
+            source: piece.source,
+            at,
+        };
+    });
+}
+/**
+ * Read what was typed, one syllable at a time.
+ *
+ * {@link tokenisePinyin} is what the decoder is scored with, and it is tolerant
+ * in the two ways that matter here: word spacing is discarded, and the
+ * apostrophes and hyphens inside a word are read as the syllable boundaries
+ * they are and dropped. Both are orthography rather than pronunciation.
+ *
+ * A stretch that is not pinyin at all comes back whole, and is reported as
+ * written rather than thrown away.
+ */
+function typedReading(typed) {
+    const { syllables, wordStarts } = tokenisePinyin(typed);
+    return syllables.map((text, at) => {
+        const syllable = readSyllable(text);
+        return {
+            text,
+            syllable,
+            base: syllable === undefined
+                ? text.toLowerCase().normalize("NFC")
+                : writeSyllableSpelling(syllable),
+            tone: syllable?.tone,
+            startsWord: wordStarts.has(at),
+        };
+    });
+}
+/**
+ * Match the expected syllables up with the typed ones.
+ *
+ * Aligned on the toneless spellings, for the reason
+ * {@link import("../accuracy/score.js").scoreCase} aligns on them: a syllable
+ * dropped or invented halfway through would otherwise knock everything after it
+ * out of step, and be reported as a mistake on every syllable rather than on
+ * the one.
+ *
+ * What the alignment leaves over is then paired off within each gap, which is
+ * what turns two unrelated stretches into substitutions: 银行 typed `yínxíng`
+ * anchors on `yín`, leaving one expected `háng` against one typed `xíng` — one
+ * wrong syllable rather than one missing and one invented.
+ */
+function pairSyllables(expected, actual) {
+    const pairs = [];
+    let held = 0;
+    let typed = 0;
+    const gap = (untilExpected, untilActual) => {
+        while (held < untilExpected || typed < untilActual) {
+            const takesExpected = held < untilExpected;
+            const takesActual = typed < untilActual;
+            pairs.push({
+                expected: takesExpected ? held : undefined,
+                actual: takesActual ? typed : undefined,
+            });
+            held += takesExpected ? 1 : 0;
+            typed += takesActual ? 1 : 0;
+        }
+    };
+    for (const anchor of alignSequences(expected, actual)) {
+        gap(anchor.expected, anchor.actual);
+        pairs.push({ expected: held, actual: typed });
+        held++;
+        typed++;
+    }
+    gap(expected.length, actual.length);
+    return pairs;
+}
+/**
+ * What a typed syllable is, against what was expected in its place.
+ *
+ * The neutral tone is the one tone pinyin writes with no mark at all, so a
+ * syllable expected in it and typed without one has had its tone written
+ * correctly rather than left off.
+ */
+function verdictFor(expected, actual) {
+    const tones = expected.accepted.get(actual.base);
+    if (tones === undefined) {
+        return "wrong";
+    }
+    if (actual.tone === undefined) {
+        return tones.has(NEUTRAL_TONE) ? "correct" : "toneless";
+    }
+    return tones.has(actual.tone) ? "correct" : "tone";
+}
+/**
+ * Where a typed syllable falls against the word boundaries.
+ */
+function spacingFor(expected, actual) {
+    if (actual.startsWord) {
+        return expected.acceptsBreak ? "correct" : "split";
+    }
+    return expected.acceptsJoin ? "correct" : "joined";
+}
+/**
+ * Mark one pairing.
+ *
+ * The two axes are graded separately and reported separately, and a syllable
+ * only counts as right where both of them are: `yín háng` reads 银行 perfectly
+ * and writes it as two words, which is one mistake rather than none.
+ */
+function checkPair(expected, actual, required) {
+    const verdict = expected === undefined
+        ? "extra"
+        : actual === undefined
+            ? "missing"
+            : verdictFor(expected, actual);
+    const spacing = expected === undefined || actual === undefined
+        ? undefined
+        : spacingFor(expected, actual);
+    const readRight = verdict === "correct" ||
+        (verdict === "toneless" && required.tones === "optional");
+    const spacedRight = spacing !== "split" && spacing !== "joined"
+        ? true
+        : required.spacing === "optional";
+    return {
+        verdict,
+        spacing,
+        isCorrect: readRight && spacedRight,
+        expected: expected?.syllable,
+        actual: actual?.syllable,
+        text: actual?.text ?? "",
+        source: expected?.source,
+        at: expected?.at,
+    };
+}
+/**
+ * Mark a typed pinyin transcription against the text it was written for.
+ *
+ * ```ts
+ * check(dictionary, "北京", "bei3jing3").syllables.map((one) => one.verdict);
+ * // ["correct", "tone"]
+ * ```
+ *
+ * **The point of doing this with a dictionary is being fair in the ways a
+ * string comparison cannot be**, and every one of these is a learner being
+ * marked wrong for being right:
+ *
+ * - **Either notation, mixed freely.** `běi` and `bei3` are the same syllable
+ *   and both parse, so `bei3jīng` is not a spelling mistake.
+ * - **A reading the decoder itself was unsure of.** Where another reading of
+ *   the same character was there for the taking, it is accepted — see
+ *   {@link rejectedReadings}. 银行 is not one of those: the word settles both
+ *   syllables, so `yínxíng` really is wrong.
+ * - **Sandhi either way.** 你好 is written `nǐ hǎo` and said `ní hǎo`, and 不是
+ *   is `bú shì` written and `bù shì` underneath. Both pass.
+ * - **Tones written or not.** A syllable typed with no tone is `toneless`
+ *   rather than `tone`, and {@link CheckOptions.tones} says whether that counts
+ *   against the score. A neutral tone typed without a mark is simply correct,
+ *   because that is how pinyin writes it.
+ * - **Apostrophes.** Not a word boundary and not a sound: `nǐhǎo`, `nǐ hǎo` and
+ *   `nǐ'hǎo` all read the same, and check the same.
+ *
+ * Word spacing is graded on its own axis, reported as
+ * {@link CheckedSyllable.spacing} and counted only where
+ * {@link CheckOptions.spacing} asks for it — and tolerant in the same spirit,
+ * since 分词连写 and the words the dictionary knows are two conventions this
+ * package writes and a learner may have been taught either.
+ *
+ * What comes back is one {@link CheckedSyllable} per syllable expected or
+ * typed, in order, each naming the characters it reads and where they are, so
+ * that a mistake can be shown against the text rather than against the answer.
+ *
+ * This is {@link import("../accuracy/score.js").scoreCase} — the scorer that
+ * marks the decoder against the gold corpus — pointed at a person instead, and
+ * it costs three conversions of the text.
+ */
+export function check(dictionary, text, typed, options = {}) {
+    const { tones = "optional", spacing = "optional", ...converting } = options;
+    const expected = expectedReading(dictionary, text, converting);
+    const actual = typedReading(typed);
+    const syllables = pairSyllables(expected.map((one) => writeSyllableSpelling(one.syllable)), actual.map((one) => one.base)).map((pair) => checkPair(pair.expected === undefined ? undefined : expected[pair.expected], pair.actual === undefined ? undefined : actual[pair.actual], { tones, spacing }));
+    const correct = syllables.filter((one) => one.isCorrect).length;
+    return {
+        syllables,
+        isCorrect: correct === syllables.length,
+        score: syllables.length === 0 ? 1 : correct / syllables.length,
+        reading: expected.map((one) => one.syllable),
+    };
+}
+//# sourceMappingURL=check.js.map

package/dist/grade/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","sourceRoot":"","sources":["../../src/grade/check.ts"],"names":[],"mappings":"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"}