calliope-ts 0.0.2 → 0.0.4

package/dist/phonological.d.ts

@@ -30,7 +30,7 @@ export declare function syllableVowelLengths(syllables: {
     stress?: number;
     lexicalStress?: number;
 }[]): VowelLength[];
-export declare function syllabifyWord(word: string, syllableCount: number, vowelLengths?: VowelLength[], morphSuffix?: string): string[];
+export declare function syllabifyWord(word: string, syllableCount: number, vowelLengths?: VowelLength[], morphSuffix?: string, morphPrefix?: string): string[];
 /**
  * Flatten all syllables into display entries with word context.
  * Each entry carries the original word text, the syllable text

package/dist/phonological.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phonological.d.ts","sourceRoot":"","sources":["../src/phonological.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,OAAO,EAGP,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EAET,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,WAAW,GACpB,gBAAgB,EAAE,CAoBpB;AA0UD,wBAAgB,eAAe,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,EAAE,CAM/D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAMjE;AA+ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAGjF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EAAE,EACvB,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,SAAS,EAAE,GACvB,MAAM,CASR;AAsBD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQzD;AAED,mFAAmF;AACnF,wBAAgB,oBAAoB,CAClC,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GACvE,WAAW,EAAE,CASf;AAsDD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA0N/H;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,oBAAoB,EAAE,CAwB9E"}
+{"version":3,"file":"phonological.d.ts","sourceRoot":"","sources":["../src/phonological.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,OAAO,EAGP,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EAET,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,WAAW,GACpB,gBAAgB,EAAE,CAoBpB;AA0UD,wBAAgB,eAAe,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,EAAE,CAM/D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAMjE;AA+ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAGjF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EAAE,EACvB,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,SAAS,EAAE,GACvB,MAAM,CASR;AAsBD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQzD;AAED,mFAAmF;AACnF,wBAAgB,oBAAoB,CAClC,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GACvE,WAAW,EAAE,CASf;AAsDD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA8RrJ;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,oBAAoB,EAAE,CAwB9E"}

package/dist/phonological.js

@@ -527,9 +527,32 @@ function quickSyllableCount(s) {
         groups--;
     return Math.max(1, groups);
 }
-export function syllabifyWord(word, syllableCount, vowelLengths, morphSuffix) {
+export function syllabifyWord(word, syllableCount, vowelLengths, morphSuffix, morphPrefix) {
     if (syllableCount <= 1)
         return [word];
+    // Morpheme-aware prefix peel: when OOV stress assignment validated a productive
+    // prefix ("dis"), split it off as the first syllable(s) so the stem keeps its
+    // spelling (dis·il·lu·sions, not di·sil·lu·sions — the Maximal Onset principle
+    // would otherwise pull the prefix's final consonant into the next syllable).
+    // The prefix's own syllable count is estimated orthographically; the stem gets
+    // the remaining syllables.
+    if (morphPrefix && syllableCount >= 2
+        && word.toLowerCase().startsWith(morphPrefix)
+        && word.length > morphPrefix.length + 1) {
+        const prefixSylls = quickSyllableCount(morphPrefix);
+        if (prefixSylls < syllableCount) {
+            const prefixChunk = word.slice(0, morphPrefix.length);
+            const stemChunk = word.slice(morphPrefix.length);
+            const stemChunks = syllabifyWord(stemChunk, syllableCount - prefixSylls, vowelLengths ? vowelLengths.slice(prefixSylls) : undefined, morphSuffix);
+            // If the prefix is polysyllabic, syllabify it on its own; monosyllabic → as-is.
+            const prefixChunks = prefixSylls > 1
+                ? syllabifyWord(prefixChunk, prefixSylls)
+                : [prefixChunk];
+            const result = [...prefixChunks, ...stemChunks];
+            if (result.length === syllableCount)
+                return result;
+        }
+    }
     // Lexical compound boundary (someone → some·one, not so·meone).  Only when the
     // constituents' own syllable counts add up to the requested total.
     {
@@ -581,8 +604,14 @@ export function syllabifyWord(word, syllableCount, vowelLengths, morphSuffix) {
     }
     const lower = cleanWord.toLowerCase();
     const n = lower.length;
-    // Common English consonant digraphs
-    const DIGRAPHS = new Set(['ch', 'sh', 'th', 'wh', 'ph', 'gh', 'ck', 'ng', 'wr', 'kn', 'gn']);
+    // Common English consonant digraphs.  "kn"/"gn"/"wr" are EXCLUDED: they are
+    // digraphs only WORD-INITIALLY (where the first consonant is silent — "know",
+    // "gnaw", "write"), and the digraph set is used only for MEDIAL boundary
+    // placement.  In medial position ("frankness") "kn" is two pronounced
+    // consonants: /k/ closes the first syllable (frank), /n/ opens the second
+    // (ness) — treating it as a medial digraph sends both to the next syllable
+    // ("fran-kness"), which is wrong.
+    const DIGRAPHS = new Set(['ch', 'sh', 'th', 'wh', 'ph', 'gh', 'ck', 'ng']);
     // Digraphs that commonly end syllables (codas)
     const CODA_DIGRAPHS = new Set(['ch', 'sh', 'ck', 'ng', 'th']);
     // "Muta cum liquida": an obstruent + liquid/glide that, between vowels, stays
@@ -607,6 +636,17 @@ export function syllabifyWord(word, syllableCount, vowelLengths, morphSuffix) {
     // (want·ed, embed·ded), so those are excluded.
     const endsSilentEd = n >= 3 && lower.endsWith('ed')
         && !VOWEL_CHARS.has(lower[n - 3]) && lower[n - 3] !== 't' && lower[n - 3] !== 'd';
+    // Non-syllabic inflectional "-es": the 'e' in a final "…Xes" (X a consonant
+    // other than a vowel — so "goes"/"shoes" are excluded, where 'e' is part of a
+    // vowel digraph) is silent when the nucleus count exceeds the CMU syllable
+    // count.  This is the VCe pattern extended to plurals/3sg: the 'e' makes the
+    // preceding vowel long and is not itself pronounced (receives = re·CEIVES,
+    // makes = MAKES, writes = WRITES).  When the stem ends in a sibilant
+    // (bus→buses, bush→bushes) the 'e' IS syllabic, but in that case the nucleus
+    // count already matches the syllable count and this check never fires — the
+    // surplus-nucleus guard makes it safe.
+    const endsSilentEs = n >= 3 && lower.endsWith('es')
+        && !VOWEL_CHARS.has(lower[n - 3]);
     const nuclei = [];
     let i = 0;
     while (i < n) {
@@ -636,6 +676,35 @@ export function syllabifyWord(word, syllableCount, vowelLengths, morphSuffix) {
         if (last.start === n - 2 && last.end === n - 1)
             nuclei.pop();
     }
+    // Same for non-syllabic "-es": drop the silent 'e' when there's a surplus
+    // (receives = 3 nuclei → 2 syllables → drop → re·ceives, not recei·ves).
+    if (nuclei.length > syllableCount && endsSilentEs) {
+        const last = nuclei[nuclei.length - 1];
+        if (last.start === n - 2 && last.end === n - 1)
+            nuclei.pop();
+    }
+    // Vowel hiatus: if we have TOO FEW nuclei, a multi-vowel nucleus (≥2 vowel
+    // characters scanned as one group) is a HIATUS — two syllabic vowels in
+    // adjacent syllables — not a diphthong.  Split the rightmost multi-vowel
+    // nucleus, peeling off its last vowel char as a new nucleus, until nuclei
+    // match the syllable count.  English hiatus tends word-ward ("-ia", "-eo"),
+    // so rightmost-first is the right priority.  This respects the authoritative
+    // CMU syllable count ("hysterias" = 4: hys·te·ri·as, not 3) and prevents the
+    // crude fallback chunker from producing nonsensical splits like "hy·ST·eri·as"
+    // (treating "ST" as a syllable nucleus).
+    while (nuclei.length < syllableCount) {
+        let splitIdx = -1;
+        for (let j = nuclei.length - 1; j >= 0; j--) {
+            if (nuclei[j].end - nuclei[j].start >= 2) {
+                splitIdx = j;
+                break;
+            }
+        }
+        if (splitIdx < 0)
+            break; // no multi-vowel nucleus left
+        const nuc = nuclei[splitIdx];
+        nuclei.splice(splitIdx, 1, { start: nuc.start, end: nuc.end - 1 }, { start: nuc.end - 1, end: nuc.end });
+    }
     while (nuclei.length > syllableCount && nuclei.length > 1) {
         let minConsonants = Infinity;
         let mergeIdx = 0;
@@ -770,7 +839,7 @@ export function flattenDisplayEntries(words) {
         if (isPunctuation(w.lexicalClass))
             continue;
         const sylCount = w.syllables.length;
-        const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix);
+        const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix, w.morphPrefix);
         for (let si = 0; si < sylCount; si++) {
             result.push({
                 wordText: w.word,

package/dist/phrasestress.d.ts

@@ -0,0 +1,6 @@
+import { ClsWord } from './types.js';
+/**
+ * Populate `word.phraseStress` for every word of a parsed sentence.
+ */
+export declare function computePhraseStress(words: ClsWord[]): void;
+//# sourceMappingURL=phrasestress.d.ts.map

package/dist/phrasestress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phrasestress.d.ts","sourceRoot":"","sources":["../src/phrasestress.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAyBrC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAkB1D"}

package/dist/phrasestress.js

@@ -0,0 +1,106 @@
+// phrasestress.ts — McAleese's Phrase-Stress phase (previously SKIPPED).
+//
+// The pipeline used to map lexical stress straight to relative stress (plus a
+// single "+1 on the rightmost content word"), leaving `ClsWord.phraseStress`
+// a vestigial field stuck at 0.  This module restores the genuine phase that
+// sits BETWEEN lexical and relative stress in McAleese's procedure (thesis
+// Appendix A; Chomsky & Halle's Nuclear + Compound Stress Rules):
+//
+//   1. every word starts at 1;
+//   2. the Compound Stress Rule pins a compound's subordinate element at the
+//      floor while its principal stays in the ramp;
+//   3. the recursive Nuclear Stress Rule ramps the principal stress of each
+//      successive *stressed* word left-to-right, so prominence rises to the
+//      phrase's nuclear (rightmost) peak.
+//
+// For the right-branching structure of English declaratives the recursive NSR
+// reduces to a monotone ramp over the stressed words — function words and
+// compound-subordinates pinned at 1.  NOTE the convention: here 1 is the FLOOR
+// and the ramp climbs RIGHTWARD to the nuclear peak (the "If hairs…" example
+// below).  McAleese's "Mary ate sweet ice cream" worked example uses the
+// OPPOSITE (SPE) numbering — 1 = PRIMARY/strongest, weakened outward — so his
+// ICE cream (primary on "ice") is reproduced here as ice=PEAK, cream=floor
+// (the compound's HEAD "cream" is the subordinate, pinned at 1):
+//
+//   "Mary ate sweet ice cream"  -> Mary2 ate3 sweet4 ice5 cream1  (ICE cream: head subordinate)
+//   "If hairs be wires, black wires grow on her head" -> 1 2 3 4 5 6 7 1 1 8
+//
+// (Marked / left-branching structures are approximated by the same ramp; a
+// constituent-tree-driven refinement over `sentence.nodes` is a flagged
+// follow-up.  This module reads only POS / content flags and surface order,
+// and writes only the previously-unused phraseStress field — purely additive.)
+import { isPunctuation } from './parser.js';
+import { compoundStressSide } from './stress.js';
+/** Sentence-final punctuation resets the nuclear ramp (the NSR is
+ *  sentence-bounded).  A comma / colon / dash does NOT — the ramp runs across
+ *  an internal intonational break (cf. "If hairs…, black wires…" → 1234…5,678). */
+const SENTENCE_FINAL = new Set(['.', '!', '?', '…']);
+/** Common-/proper-noun POS tags, gating which compounds floor an element. */
+const NOUN_TAGS = new Set(['NN', 'NNS', 'NNP', 'NNPS']);
+/**
+ * Proclitic POS tags pinned at the phrase-stress floor: the NSR ramp applies to
+ * *stressed words* (nouns, adjectives, adverbs, and VERBS — including the
+ * copula/auxiliary "be" and modals, which bear lexical stress even though they
+ * reduce in the contour), while pure clitics carry none.  Verbs are NOT here,
+ * so McAleese's "if hairs BE wires…" keeps `be` in the ramp (=3).  A word the
+ * earlier pipeline promoted to content (a phrasal-verb particle, a focus
+ * demonstrative — `isContent === true`) is un-pinned and ramps.
+ */
+const PINNED_POS = new Set([
+    'IN', 'TO', 'DT', 'CC', 'PRP', 'PRP$', 'WP', 'WP$', 'WDT', 'EX', 'POS',
+]);
+/**
+ * Populate `word.phraseStress` for every word of a parsed sentence.
+ */
+export function computePhraseStress(words) {
+    const subordinate = compoundSubordinates(words);
+    let ramp = 1; // running nuclear ramp; the floor for pinned words is 1
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass)) {
+            w.phraseStress = 0;
+            if (SENTENCE_FINAL.has(w.word))
+                ramp = 1;
+            continue;
+        }
+        // Pinned at the floor: a proclitic function word bears no nuclear ramp, and
+        // a compound's subordinate element is demoted by the Compound Stress Rule.
+        const isClitic = PINNED_POS.has(w.lexicalClass) && !w.isContent;
+        if (isClitic || subordinate.has(w)) {
+            w.phraseStress = 1;
+            continue;
+        }
+        w.phraseStress = ++ramp;
+    }
+}
+/**
+ * Identify the subordinate (pinned) element of each surface-adjacent compound,
+ * delegating the direction to `compoundStressSide` (the shared rule, so phrase
+ * stress and the lexical compound pass cannot disagree).
+ *   - fore-stress ('left') → the HEAD (right) element is subordinate: SEA·shore,
+ *     ICE cream, KITCHen table — the Compound Stress Rule default for N+N;
+ *   - right-stress ('right') → the MODIFIER (left) is subordinate: apple PIE,
+ *     and proper-name pairs (New YORK);
+ *   - Adjective+noun ("sweet cream") is phrasal, not a compound (`side` is
+ *     'right' there too, so the modifier "sweet" is pinned and "cream" ramps —
+ *     i.e. end-stress, as desired).
+ */
+function compoundSubordinates(words) {
+    const subs = new Set();
+    for (let i = 0; i + 1 < words.length; i++) {
+        const a = words[i], b = words[i + 1];
+        if (isPunctuation(a.lexicalClass) || isPunctuation(b.lexicalClass))
+            continue;
+        if (!a.isContent || !b.isContent)
+            continue;
+        const side = compoundStressSide(a.word, a.lexicalClass, b.word, b.lexicalClass);
+        // Floor an element only for a genuine N+N compound; an Adj+N ("sweet ice",
+        // "red car") is phrasal — its end-stress emerges from the ramp itself, so we
+        // pin nothing and let the adjective ramp (McAleese: sweet=4, above cream).
+        const bothNouns = NOUN_TAGS.has(a.lexicalClass) && NOUN_TAGS.has(b.lexicalClass);
+        if (side === 'left')
+            subs.add(b); // fore-stress compound: head subordinate (ICE cream)
+        else if (side === 'right' && bothNouns)
+            subs.add(a); // right-stress N+N: modifier subordinate (apple PIE)
+    }
+    return subs;
+}

package/dist/rhyme.d.ts

@@ -1,4 +1,4 @@
-import { LineResult } from './types.js';
+import { LineResult, StressLevel } from './types.js';
 export type RhymeTypeName = 'identical' | 'rich' | 'perfect' | 'family' | 'assonant' | 'consonant' | 'augmented' | 'diminished' | 'wrenched' | 'eye';
 export interface RhymePair {
     type: RhymeTypeName;
@@ -23,4 +23,43 @@ export declare function detectScheme(endWords: string[]): LineRhyme[];
  * meter/scansion/certainty is touched.
  */
 export declare function applyRhymeAndForm(stanzas: LineResult[][]): void;
+export interface RhymeRel {
+    fromWord: string;
+    fromLabel: string;
+    toWord: string;
+    toLabel: string;
+    letter: string;
+    type?: RhymeTypeName;
+    kind: 'end' | 'caesural' | 'head';
+    topStress: StressLevel;
+}
+export interface Phonopoetics {
+    endScheme: string;
+    end: RhymeRel[];
+    caesural: RhymeRel[];
+    head: RhymeRel[];
+    alliteration: {
+        label: string;
+        words: string[];
+    }[];
+    acrostics: {
+        labels: string[];
+        firsts: string[];
+        word: string;
+    }[];
+}
+/** Whole-poem phonopoetic analysis: structured data for the Phonopoetics
+ *  synopsis section.  Read-only — never mutates the per-line scansion. */
+export declare function analyzePhonopoetics(stanzas: LineResult[][]): Phonopoetics;
+/** A labelled line of the poem synopsis (display renders each). */
+export interface SynopsisRow {
+    label: string;
+    value: string;
+}
+/**
+ * Build the cumulative poem synopsis: top meter(s)/mixed meters (accentual forms
+ * reported in beats), the poem-wide rhyme scheme (with internal rhymes), and the
+ * poetic-form alignment.  Reads only existing per-line determinations.
+ */
+export declare function summarizePoem(stanzas: LineResult[][]): SynopsisRow[];
 //# sourceMappingURL=rhyme.d.ts.map

package/dist/rhyme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rhyme.d.ts","sourceRoot":"","sources":["../src/rhyme.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAA8B,MAAM,YAAY,CAAC;AAIpE,MAAM,MAAM,aAAa,GACrB,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC3C,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GACrD,UAAU,GAAG,KAAK,CAAC;AAEvB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;CACnD;AA6DD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAkDxE;AAMD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;yEACyE;AACzE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CA6C5D;AAyGD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAe/D"}
+{"version":3,"file":"rhyme.d.ts","sourceRoot":"","sources":["../src/rhyme.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,UAAU,EAA8B,WAAW,EAAE,MAAM,YAAY,CAAC;AAK1F,MAAM,MAAM,aAAa,GACrB,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC3C,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GACrD,UAAU,GAAG,KAAK,CAAC;AAEvB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;CACnD;AA6DD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAkDxE;AAQD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;yEACyE;AACzE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CA6C5D;AA6MD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAkB/D;AAsCD,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IAAG,OAAO,EAAE,MAAM,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,SAAS,EAAE,WAAW,CAAC;CACxB;AACD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACnD,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnE;AAED;0EAC0E;AAC1E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,YAAY,CAsIzE;AAgCD,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CAAE;AA2B9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,WAAW,EAAE,CA0DpE"}