@kensio/pinyinjs 1.7.3 → 1.7.5

package/dist/grade/reading-syllables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-syllables.d.ts","sourceRoot":"","sources":["../../src/grade/reading-syllables.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,SAAS,MAAM,EAAE,CAQnB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAEnE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,SAAS,eAAe,EAAE,CAoB5B"}

package/dist/grade/reading-syllables.js

@@ -0,0 +1,58 @@
+import { toCharacters } from "../script/characters.js";
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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;
+}
+//# sourceMappingURL=reading-syllables.js.map

package/dist/grade/reading-syllables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-syllables.js","sourceRoot":"","sources":["../../src/grade/reading-syllables.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AA0BvD;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAiC;IAEjC,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACnB,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAChD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,IAAc;IACvD,OAAO,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;AAC9D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAiC;IAEjC,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAsB,EAAE,CAAC;IACxC,wEAAwE;IACxE,IAAI,QAAQ,GAAa,OAAO,CAAC;IAEjC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,EAAE,EAAE,CAAC;QAC3C,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACjC,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC9C,SAAS;QACX,CAAC;QACD,SAAS,CAAC,IAAI,CAAC;YACb,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE;YAC7C,wEAAwE;YACxE,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC;YACtB,QAAQ;SACT,CAAC,CAAC;QACH,QAAQ,GAAG,MAAM,CAAC;IACpB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/grade/reading-tolerance.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Everything a typed syllable is allowed to be, beside the one answer.
+ *
+ * The checker's whole difficulty is here: the library writes one reading, and
+ * several others are not mistakes. A tone the sandhi square reaches the other
+ * way round, a reading the decode turned down without much reason to — each is
+ * a separate source of tolerance, and each is gathered here so that
+ * `check-readings.ts` can simply put them together.
+ */
+import { type ConvertOptions } from "../decode/convert.js";
+import type { Dictionary } from "../dictionary/dictionary.js";
+import type { SandhiOptions } from "../decode/sandhi.js";
+import { type Syllable } from "../syllable/syllable.js";
+import type { Tone } from "../tone/tone.js";
+import { type ReadingPiece, type ReadingSyllable } from "./reading-syllables.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.
+ */
+export declare function oppositeSandhi(sandhi: SandhiOptions | undefined): SandhiOptions;
+/**
+ * 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.
+ */
+export declare function rejectedReadings(piece: ReadingPiece): readonly 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.
+ */
+export declare function acceptedReadings(readings: readonly Syllable[]): ReadonlyMap<string, ReadonlySet<Tone | undefined>>;
+/**
+ * The same text converted three ways, one for each source of tolerance.
+ *
+ * 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.
+ */
+export declare function readingsThreeWays(dictionary: Dictionary, text: string, options: ConvertOptions): {
+    readonly written: readonly ReadingSyllable[];
+    readonly said: readonly ReadingSyllable[];
+    readonly spaced: readonly ReadingSyllable[];
+};
+//# sourceMappingURL=reading-tolerance.d.ts.map

package/dist/grade/reading-tolerance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-tolerance.d.ts","sourceRoot":"","sources":["../../src/grade/reading-tolerance.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,KAAK,QAAQ,EAAyB,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,GAAG,SAAS,GAChC,aAAa,CAKf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,QAAQ,EAAE,CAczE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAC5B,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC,CAUpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,GACtB;IACD,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;CAC7C,CAgBA"}

package/dist/grade/reading-tolerance.js

@@ -0,0 +1,107 @@
+/**
+ * Everything a typed syllable is allowed to be, beside the one answer.
+ *
+ * The checker's whole difficulty is here: the library writes one reading, and
+ * several others are not mistakes. A tone the sandhi square reaches the other
+ * way round, a reading the decode turned down without much reason to — each is
+ * a separate source of tolerance, and each is gathered here so that
+ * `check-readings.ts` can simply put them together.
+ */
+import { convertPieces, convertPiecesUnscored, } from "../decode/convert.js";
+import { READING_CHARGE } from "../decode/lattice.js";
+import { toCharacters } from "../script/characters.js";
+import { writeSyllableSpelling } from "../syllable/syllable.js";
+import { readingSyllables, } from "./reading-syllables.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.
+ */
+export function oppositeSandhi(sandhi) {
+    return {
+        yiBu: !(sandhi?.yiBu ?? true),
+        thirdTone: !(sandhi?.thirdTone ?? false),
+    };
+}
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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;
+}
+/**
+ * The same text converted three ways, one for each source of tolerance.
+ *
+ * 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.
+ */
+export function readingsThreeWays(dictionary, text, options) {
+    return {
+        written: readingSyllables(convertPieces(dictionary, text, options)),
+        said: readingSyllables(convertPiecesUnscored(dictionary, text, {
+            ...options,
+            sandhi: oppositeSandhi(options.sandhi),
+        })),
+        spaced: readingSyllables(convertPiecesUnscored(dictionary, text, {
+            ...options,
+            grouping: !(options.grouping ?? true),
+        })),
+    };
+}
+//# sourceMappingURL=reading-tolerance.js.map

package/dist/grade/reading-tolerance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-tolerance.js","sourceRoot":"","sources":["../../src/grade/reading-tolerance.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAEL,aAAa,EACb,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAiB,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,EAGL,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAiC;IAEjC,OAAO;QACL,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,IAAI,IAAI,CAAC;QAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,IAAI,KAAK,CAAC;KACzC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAmB;IAClD,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IACrC,IAAI,MAAM,KAAK,SAAS,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9D,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,CAAC,UAAU,EAAE,YAAY,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE;QAC9D,MAAM,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC;QACvC,OAAO,WAAW,CAAC,IAAI,GAAG,cAAc;YACtC,WAAW,CAAC,EAAE,GAAG,WAAW,CAAC,IAAI,KAAK,CAAC;YACvC,WAAW,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;YAChC,QAAQ,KAAK,SAAS;YACtB,CAAC,CAAC,CAAC,QAAQ,CAAC;YACZ,CAAC,CAAC,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,QAA6B;IAE7B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiC,CAAC;IAE1D,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,EAAoB,CAAC;QAChE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACzB,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAAsB,EACtB,IAAY,EACZ,OAAuB;IAMvB,OAAO;QACL,OAAO,EAAE,gBAAgB,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QACnE,IAAI,EAAE,gBAAgB,CACpB,qBAAqB,CAAC,UAAU,EAAE,IAAI,EAAE;YACtC,GAAG,OAAO;YACV,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC;SACvC,CAAC,CACH;QACD,MAAM,EAAE,gBAAgB,CACtB,qBAAqB,CAAC,UAAU,EAAE,IAAI,EAAE;YACtC,GAAG,OAAO;YACV,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC;SACtC,CAAC,CACH;KACF,CAAC;AACJ,CAAC"}

package/dist/grade/typed-reading.d.ts

@@ -0,0 +1,28 @@
+import { type Syllable } from "../syllable/syllable.js";
+import type { Tone } from "../tone/tone.js";
+/**
+ * One syllable of what was typed.
+ */
+export interface TypedSyllable {
+    readonly text: string;
+    readonly syllable: Syllable | undefined;
+    /** The toneless spelling this is aligned and compared by. */
+    readonly base: string;
+    /** The tone written on it, or undefined where none was. */
+    readonly tone: Tone | undefined;
+    /** Whether a written word begins here. */
+    readonly startsWord: boolean;
+}
+/**
+ * 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.
+ */
+export declare function typedReading(typed: string): readonly TypedSyllable[];
+//# sourceMappingURL=typed-reading.d.ts.map

package/dist/grade/typed-reading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-reading.d.ts","sourceRoot":"","sources":["../../src/grade/typed-reading.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IACxC,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IAChC,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,aAAa,EAAE,CAepE"}

package/dist/grade/typed-reading.js

@@ -0,0 +1,36 @@
+/**
+ * The reading someone typed, as the checker compares it.
+ *
+ * The other side from `check-readings.ts`, and much the smaller one: there is
+ * no dictionary behind a typed string, only the tokeniser and what each token
+ * turns out to spell.
+ */
+import { tokenisePinyin } from "../accuracy/tokenise.js";
+import { readSyllable, writeSyllableSpelling, } from "../syllable/syllable.js";
+/**
+ * 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.
+ */
+export 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),
+        };
+    });
+}
+//# sourceMappingURL=typed-reading.js.map

package/dist/grade/typed-reading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-reading.js","sourceRoot":"","sources":["../../src/grade/typed-reading.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EACL,YAAY,EAEZ,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AAiBjC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACxD,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE;QAChC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QACpC,OAAO;YACL,IAAI;YACJ,QAAQ;YACR,IAAI,EACF,QAAQ,KAAK,SAAS;gBACpB,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;gBACrC,CAAC,CAAC,qBAAqB,CAAC,QAAQ,CAAC;YACrC,IAAI,EAAE,QAAQ,EAAE,IAAI;YACpB,UAAU,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;SAC/B,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/numerals/numeral-parse.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What a number is made of, once its sign and its point are taken off.
+ */
+export interface Parsed {
+    readonly isNegative: boolean;
+    /** The digits before the point, as written. */
+    readonly whole: string;
+    /** The digits after it, as written, or the empty string. */
+    readonly fraction: string;
+}
+/**
+ * Anything this module will read: digits, optionally signed and pointed.
+ *
+ * `security/detect-unsafe-regex` flags the optional group after `\d+`, and the
+ * literal `.` in front of it means no input can be split between the two. Timed
+ * on a signed decimal that cannot match, it is linear to 128k characters.
+ */
+export declare const NUMBER: RegExp;
+/**
+ * Take a number apart, keeping the digits exactly as they were written.
+ *
+ * A string rather than a number is the input that carries the most: `007` and
+ * `7` are the same quantity and different digits, and a room number keeps its
+ * zeros. A `number` is stringified first, which is why a caller who cares about
+ * leading zeros should pass the string.
+ */
+export declare function parse(value: string | number): Parsed | undefined;
+/**
+ * Write digits one at a time: 2019 → 二〇一九.
+ */
+export declare function digitsHanzi(digits: string, zero: string): string;
+//# sourceMappingURL=numeral-parse.d.ts.map

package/dist/numerals/numeral-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeral-parse.d.ts","sourceRoot":"","sources":["../../src/numerals/numeral-parse.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,QAAuD,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAUhE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMhE"}

package/dist/numerals/numeral-parse.js

@@ -0,0 +1,44 @@
+/**
+ * Taking a number apart into the pieces 汉字 are written from.
+ *
+ * A sign, a whole part and a fraction, plus the digit-at-a-time reading a
+ * fraction and a spelled-out number both use.
+ */
+import { toCharacters } from "../script/characters.js";
+import { DIGIT_CHARACTERS } from "./characters.js";
+/**
+ * Anything this module will read: digits, optionally signed and pointed.
+ *
+ * `security/detect-unsafe-regex` flags the optional group after `\d+`, and the
+ * literal `.` in front of it means no input can be split between the two. Timed
+ * on a signed decimal that cannot match, it is linear to 128k characters.
+ */
+export const NUMBER = /^(?<sign>-?)(?<whole>\d+)(?:\.(?<fraction>\d+))?$/u;
+/**
+ * Take a number apart, keeping the digits exactly as they were written.
+ *
+ * A string rather than a number is the input that carries the most: `007` and
+ * `7` are the same quantity and different digits, and a room number keeps its
+ * zeros. A `number` is stringified first, which is why a caller who cares about
+ * leading zeros should pass the string.
+ */
+export function parse(value) {
+    const found = NUMBER.exec(String(value))?.groups;
+    if (found === undefined) {
+        return undefined;
+    }
+    return {
+        isNegative: found["sign"] === "-",
+        whole: found["whole"] ?? "",
+        fraction: found["fraction"] ?? "",
+    };
+}
+/**
+ * Write digits one at a time: 2019 → 二〇一九.
+ */
+export function digitsHanzi(digits, zero) {
+    return toCharacters(digits)
+        .map((digit) => digit === "0" ? zero : (DIGIT_CHARACTERS[Number(digit)] ?? digit))
+        .join("");
+}
+//# sourceMappingURL=numeral-parse.js.map

package/dist/numerals/numeral-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeral-parse.js","sourceRoot":"","sources":["../../src/numerals/numeral-parse.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAanD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,oDAAoD,CAAC;AAE3E;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,KAAsB;IAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC;IACjD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO;QACL,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG;QACjC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE;QAC3B,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE;KAClC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,IAAY;IACtD,OAAO,YAAY,CAAC,MAAM,CAAC;SACxB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACb,KAAK,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,CAClE;SACA,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC"}

package/dist/numerals/numeral-shapes.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The shapes a number takes in running text.
+ *
+ * What counts as a number, what follows one and changes how it is said, and
+ * the bounds a time is written within. `text.ts` walks a text against them.
+ */
+/**
+ * A number as it appears in running text: digits, with the separators a writer
+ * uses and an optional decimal part.
+ *
+ * `security/detect-unsafe-regex` flags the optional decimal after `[\d,]*`. A
+ * comma run and a decimal part cannot claim the same characters, since `\.` is
+ * neither a digit nor a comma, so there is nothing to backtrack over — timed
+ * linear to 128k characters.
+ */
+export declare const NUMBER: RegExp;
+/**
+ * The percent signs a number can carry, half-width and full-width.
+ */
+export declare const PERCENT: Set<string>;
+/**
+ * Marks that make the digits beside them an identifier rather than a quantity.
+ *
+ * 6:30 is a time, 3202－5625 is a phone number and COVID-19 is a name; none of
+ * them is counted, and the mark between the parts has no reading at all. So a
+ * digit run touching one is left exactly as it was written — of 7,846 digit
+ * runs measured over Tatoeba and zh.wikipedia about 55 are this shape, and
+ * reading them produced `liù:sānshí` for 6:30, which is worse than leaving it.
+ */
+export declare const IDENTIFIER: Set<string>;
+/**
+ * A time as a writer punctuates it: 6:30, 07:05, 2：30.
+ *
+ * Sticky, because it is tried at the start of a digit run the number scanner
+ * has already found rather than searched for on its own.
+ *
+ * Two digits after the colon and no more, which is what separates a time from
+ * a ratio: 16:9 and 2:1 are proportions and scores and are read `shíliù bǐ
+ * jiǔ`, which this does not attempt. Measured over Tatoeba and zh.wikipedia,
+ * the shape catches 104 runs and every one of them is a time — none has an
+ * hour above 23 or a minute above 59, and the four colon runs that are not
+ * times all have a single digit after the colon.
+ */
+export declare const TIME: RegExp;
+/**
+ * The bounds a time is written within.
+ */
+export declare const HOURS_IN_A_DAY = 24;
+export declare const MINUTES_IN_AN_HOUR = 60;
+/**
+ * The characters a lone 2 in front of them labels rather than counts.
+ *
+ * A 2 standing immediately in front of what it counts is 两 — 两个, 两人, 两岁,
+ * 两次, 两天 — and the measure words it can count with are an open list, so 两
+ * is the default and this is the exception. What is left is the positions a
+ * digit *names*: 2月 is February, 2日 and 2号 are the second of the month, 2楼
+ * is the second floor, 2路 is the number 2 bus, 2班 is the second class and 2期
+ * is the second phase. A named position is 二.
+ *
+ * The traditional forms are listed beside the simplified ones, since the text
+ * being converted may be in either script.
+ */
+export declare const LABELLED: Set<string>;
+/**
+ * The units a lone 2 in front of them keeps 二 for, as the number itself does.
+ *
+ * 20 是二十 and 200 是二百, so 2十 and 2百 are written the same way: whether the
+ * unit is a digit or a character does not change how the number is said. 千, 万
+ * and 亿 are left to `CardinalOptions.liang` for exactly the same reason, which
+ * is why 2万 is 两万 as 20,000 already is.
+ */
+export declare const SMALL_UNITS: Set<string>;
+/**
+ * The mark that makes the number after it an ordinal: 第2次 is 第二次.
+ *
+ * An ordinal names a position however ordinary the measure word after it is,
+ * so it takes 二 where the same 2次 on its own would be 两次.
+ */
+export declare const ORDINAL = "\u7B2C";
+/**
+ * How many digits a year is written with, when it is a year and not a count.
+ *
+ * 1998年 is a year and is spelled out; 30年 is thirty years and is counted.
+ * Four is the length that separates them, and a two-digit year — 98年 for 1998
+ * — is left counted, because 20年 meaning twenty years is far commoner than
+ * 20年 meaning 2020 and nothing in the text tells them apart.
+ */
+export declare const YEAR_DIGITS = 4;
+//# sourceMappingURL=numeral-shapes.d.ts.map

package/dist/numerals/numeral-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeral-shapes.d.ts","sourceRoot":"","sources":["../../src/numerals/numeral-shapes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,QAAyB,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,OAAO,aAAsB,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,aAAoD,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,QAAkC,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,aAUnB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,aAAsB,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,OAAO,WAAM,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,IAAI,CAAC"}

package/dist/numerals/numeral-shapes.js

@@ -0,0 +1,99 @@
+/**
+ * The shapes a number takes in running text.
+ *
+ * What counts as a number, what follows one and changes how it is said, and
+ * the bounds a time is written within. `text.ts` walks a text against them.
+ */
+/**
+ * A number as it appears in running text: digits, with the separators a writer
+ * uses and an optional decimal part.
+ *
+ * `security/detect-unsafe-regex` flags the optional decimal after `[\d,]*`. A
+ * comma run and a decimal part cannot claim the same characters, since `\.` is
+ * neither a digit nor a comma, so there is nothing to backtrack over — timed
+ * linear to 128k characters.
+ */
+export const NUMBER = /\d[\d,]*(?:\.\d+)?/gu;
+/**
+ * The percent signs a number can carry, half-width and full-width.
+ */
+export const PERCENT = new Set(["%", "％"]);
+/**
+ * Marks that make the digits beside them an identifier rather than a quantity.
+ *
+ * 6:30 is a time, 3202－5625 is a phone number and COVID-19 is a name; none of
+ * them is counted, and the mark between the parts has no reading at all. So a
+ * digit run touching one is left exactly as it was written — of 7,846 digit
+ * runs measured over Tatoeba and zh.wikipedia about 55 are this shape, and
+ * reading them produced `liù:sānshí` for 6:30, which is worse than leaving it.
+ */
+export const IDENTIFIER = new Set([":", "：", "-", "－", "—", "–", "/", "／"]);
+/**
+ * A time as a writer punctuates it: 6:30, 07:05, 2：30.
+ *
+ * Sticky, because it is tried at the start of a digit run the number scanner
+ * has already found rather than searched for on its own.
+ *
+ * Two digits after the colon and no more, which is what separates a time from
+ * a ratio: 16:9 and 2:1 are proportions and scores and are read `shíliù bǐ
+ * jiǔ`, which this does not attempt. Measured over Tatoeba and zh.wikipedia,
+ * the shape catches 104 runs and every one of them is a time — none has an
+ * hour above 23 or a minute above 59, and the four colon runs that are not
+ * times all have a single digit after the colon.
+ */
+export const TIME = /(\d{1,2})[:：](\d{2})(?!\d)/duy;
+/**
+ * The bounds a time is written within.
+ */
+export const HOURS_IN_A_DAY = 24;
+export const MINUTES_IN_AN_HOUR = 60;
+/**
+ * The characters a lone 2 in front of them labels rather than counts.
+ *
+ * A 2 standing immediately in front of what it counts is 两 — 两个, 两人, 两岁,
+ * 两次, 两天 — and the measure words it can count with are an open list, so 两
+ * is the default and this is the exception. What is left is the positions a
+ * digit *names*: 2月 is February, 2日 and 2号 are the second of the month, 2楼
+ * is the second floor, 2路 is the number 2 bus, 2班 is the second class and 2期
+ * is the second phase. A named position is 二.
+ *
+ * The traditional forms are listed beside the simplified ones, since the text
+ * being converted may be in either script.
+ */
+export const LABELLED = new Set([
+    "月",
+    "日",
+    "号",
+    "號",
+    "楼",
+    "樓",
+    "路",
+    "班",
+    "期",
+]);
+/**
+ * The units a lone 2 in front of them keeps 二 for, as the number itself does.
+ *
+ * 20 是二十 and 200 是二百, so 2十 and 2百 are written the same way: whether the
+ * unit is a digit or a character does not change how the number is said. 千, 万
+ * and 亿 are left to `CardinalOptions.liang` for exactly the same reason, which
+ * is why 2万 is 两万 as 20,000 already is.
+ */
+export const SMALL_UNITS = new Set(["十", "百"]);
+/**
+ * The mark that makes the number after it an ordinal: 第2次 is 第二次.
+ *
+ * An ordinal names a position however ordinary the measure word after it is,
+ * so it takes 二 where the same 2次 on its own would be 两次.
+ */
+export const ORDINAL = "第";
+/**
+ * How many digits a year is written with, when it is a year and not a count.
+ *
+ * 1998年 is a year and is spelled out; 30年 is thirty years and is counted.
+ * Four is the length that separates them, and a two-digit year — 98年 for 1998
+ * — is left counted, because 20年 meaning twenty years is far commoner than
+ * 20年 meaning 2020 and nothing in the text tells them apart.
+ */
+export const YEAR_DIGITS = 4;
+//# sourceMappingURL=numeral-shapes.js.map

package/dist/numerals/numeral-shapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeral-shapes.js","sourceRoot":"","sources":["../../src/numerals/numeral-shapes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,sBAAsB,CAAC;AAE7C;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE3C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAEpD;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AACjC,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC;IAC9B,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;CACJ,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAG,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC"}

package/dist/numerals/numerals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numerals.d.ts","sourceRoot":"","sources":["../../src/numerals/numerals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,eAAe,CAAC;AAOvB;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,8BAA8B;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;CAC3B;AAqDD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CA0BpB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,SAAS,QAAQ,EAAE,GAAG,SAAS,CAajC;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,SAAS,QAAQ,EAAE,GAAG,SAAS,CAGjC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CAOpB"}
+{"version":3,"file":"numerals.d.ts","sourceRoot":"","sources":["../../src/numerals/numerals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,eAAe,CAAC;AAGvB;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,8BAA8B;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CA0BpB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,SAAS,QAAQ,EAAE,GAAG,SAAS,CAajC;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,SAAS,QAAQ,EAAE,GAAG,SAAS,CAGjC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,SAAS,CAOpB"}