calliope-ts 0.0.1

package/dist/scansion_debug.js

@@ -0,0 +1,586 @@
+// scansion.ts — Key‑stress extraction, weighted metre scoring, and
+// scansion assembly for McAleese’s phonological method.
+import { isPunctuation } from './parser.js';
+// ─── CONSTANTS: metre definitions & weights ──────────────────────
+const METRES = {
+    iambic: { foot: 'ws', sylCount: 2 },
+    trochaic: { foot: 'sw', sylCount: 2 },
+    spondaic: { foot: 'ss', sylCount: 2 },
+    pyrrhic: { foot: 'ww', sylCount: 2 },
+    anapestic: { foot: 'wws', sylCount: 3 },
+    dactylic: { foot: 'sww', sylCount: 3 },
+    amphibrachic: { foot: 'wsw', sylCount: 3 },
+    bacchic: { foot: 'wss', sylCount: 3 },
+};
+const WEIGHT = {
+    IU: 2,
+    PP: 1,
+    PW3plus: 2,
+    PW2: 1,
+    CP: 1,
+};
+// ─── HELPER: stress compatibility ─────────────────────────────────
+function stressCompatible(actual, expected) {
+    if (expected === 's')
+        return actual === 's' || actual === 'm';
+    // McAleese: 'w' matches anything except 's'.
+    return actual !== 's';
+}
+// ─── PATTERN MATCHING ─────────────────────────────────────────────
+function patternMatches(pattern, foot, isForward = false) {
+    const plen = pattern.length;
+    const flen = foot.length;
+    // Single CP patterns: must match the STRONG position of the foot.
+    if (plen === 1) {
+        const single = pattern[0];
+        const strongPos = foot.indexOf('s');
+        if (strongPos !== -1) {
+            return stressCompatible(single, 's');
+        }
+        return foot.split('').some(expected => stressCompatible(single, expected));
+    }
+    // For shorter patterns, match against a contiguous substring of the foot
+    let tail;
+    if (plen < flen) {
+        // Only allow partial matching if pattern contains a strong syllable;
+        // otherwise a weak-only pattern gives no diagnostic rhythmic information.
+        if (!pattern.split('').some(c => c === 's' || c === 'm')) {
+            return false;
+        }
+        tail = isForward ? foot.slice(0, plen) : foot.slice(-plen);
+        for (let i = 0; i < plen; i++) {
+            const actual = pattern[i];
+            const expected = tail[i];
+            if (!stressCompatible(actual, expected))
+                return false;
+        }
+        return true;
+    }
+    if (plen > flen) {
+        tail = isForward ? pattern.slice(0, flen) : pattern.slice(-flen);
+    }
+    else {
+        tail = pattern;
+    }
+    for (let i = 0; i < flen; i++) {
+        const actual = tail[i];
+        const expected = foot[i];
+        if (!stressCompatible(actual, expected))
+            return false;
+    }
+    // Reject strong dipping for triple metres (dactylic, anapestic)
+    if (flen === 3 && plen >= flen) {
+        const first = tail[0];
+        const middle = tail[1];
+        const final = tail[2];
+        if (foot === 'sww') {
+            if ((first === 's' || first === 'm') && (middle !== 's' && middle !== 'm') && (final === 'm' || final === 's')) {
+                return false;
+            }
+        }
+        if (foot === 'wws') {
+            if ((first === 'm' || first === 's') && (middle !== 's' && middle !== 'm') && (final === 's' || final === 'm')) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function flattenSyllables(words, ius) {
+    const ppStartWords = new Set();
+    if (ius) {
+        for (const iu of ius) {
+            for (const pp of iu.phonologicalPhrases) {
+                if (pp.cliticGroups.length > 0 && pp.cliticGroups[0].tokens.length > 0) {
+                    ppStartWords.add(pp.cliticGroups[0].tokens[0]);
+                }
+            }
+        }
+    }
+    const result = [];
+    let idx = 0;
+    let wordCounter = 0;
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass))
+            continue;
+        const isPoly = w.syllables.length > 1;
+        const isLeftEdgeWord = ppStartWords.has(w);
+        for (let si = 0; si < w.syllables.length; si++) {
+            const s = w.syllables[si];
+            result.push({
+                word: w,
+                stress: s.relativeStress ?? 'w',
+                globalIndex: idx++,
+                wordIdx: wordCounter,
+                isPoly,
+                weight: s.weight || 'L',
+                isLeftEdgePP: isLeftEdgeWord && (si === 0),
+                extrametrical: s.extrametrical,
+            });
+        }
+        wordCounter++;
+    }
+    return result;
+}
+// ─── RIGHT‑MOST STRESSED IN TOKEN GROUP ────────────────────────────
+function rightmostStressed(tokens, flat, strongOnly = false) {
+    for (let i = flat.length - 1; i >= 0; i--) {
+        const fs = flat[i];
+        if (tokens.includes(fs.word)) {
+            if (strongOnly) {
+                if (fs.stress === 's' || fs.stress === 'm')
+                    return fs;
+            }
+            else {
+                if (fs.stress !== 'w')
+                    return fs;
+            }
+        }
+    }
+    return undefined;
+}
+function extractContour(syls) {
+    let headWordIdx = -1;
+    // Find the last content word
+    for (let i = syls.length - 1; i >= 0; i--) {
+        if (syls[i].word.isContent) {
+            headWordIdx = i;
+            break;
+        }
+    }
+    if (headWordIdx === -1)
+        return syls; // No content word
+    // Find the start of this word
+    const targetWord = syls[headWordIdx].word;
+    let startIdx = headWordIdx;
+    while (startIdx > 0 && syls[startIdx - 1].word === targetWord) {
+        startIdx--;
+    }
+    // Return this word and all following syllables
+    return syls.slice(startIdx);
+}
+// ─── EXTRACT KEY STRESSES WITH POSITIONS ──────────────────────────
+export function extractKeyStresses(ius, words) {
+    const result = [];
+    const flat = flattenSyllables(words);
+    // ── Polysyllabic words (PW) ──────────────────────────────
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass))
+            continue;
+        const sc = w.syllables.length;
+        if (sc < 2)
+            continue;
+        const pattern = w.syllables.map(s => s.relativeStress ?? 'w').join('');
+        const weight = sc >= 3 ? WEIGHT.PW3plus : WEIGHT.PW2;
+        const firstSylIdx = flat.findIndex(fs => fs.word === w);
+        const positions = [];
+        for (let j = 0; j < sc; j++) {
+            positions.push(firstSylIdx + j);
+        }
+        result.push({ unitType: 'PW', pattern, weight, positions });
+    }
+    // ── Clitic Groups, Phonological Phrases, Intonational Units ─
+    for (const iu of ius) {
+        const iuTokens = collectIUTokens(iu);
+        if (iuTokens.length === 0)
+            continue;
+        const unitSyllables = flat.filter(fs => iuTokens.includes(fs.word));
+        if (unitSyllables.length > 0) {
+            const tail = extractContour(unitSyllables);
+            const positions = tail.map(fs => fs.globalIndex);
+            const pattern = tail.map(fs => fs.stress).join('');
+            result.push({ unitType: 'IU', pattern, weight: WEIGHT.IU, positions });
+        }
+        for (const pp of iu.phonologicalPhrases) {
+            const ppTokens = collectPPTokens(pp);
+            if (ppTokens.length === 0)
+                continue;
+            const ppSyllables = flat.filter(fs => ppTokens.includes(fs.word));
+            if (ppSyllables.length > 0) {
+                const tail = extractContour(ppSyllables);
+                const positions = tail.map(fs => fs.globalIndex);
+                const pattern = tail.map(fs => fs.stress).join('');
+                result.push({ unitType: 'PP', pattern, weight: WEIGHT.PP, positions });
+            }
+            for (const cg of pp.cliticGroups) {
+                if (cg.tokens.length === 0)
+                    continue;
+                const cpStressed = rightmostStressed(cg.tokens, flat, false);
+                if (cpStressed) {
+                    result.push({
+                        unitType: 'CP',
+                        pattern: cpStressed.stress,
+                        weight: WEIGHT.CP,
+                        positions: [cpStressed.globalIndex],
+                    });
+                }
+            }
+        }
+    }
+    return result;
+}
+function collectIUTokens(iu) {
+    const tokens = [];
+    for (const pp of iu.phonologicalPhrases) {
+        tokens.push(...collectPPTokens(pp));
+    }
+    return tokens;
+}
+function collectPPTokens(pp) {
+    const tokens = [];
+    for (const cg of pp.cliticGroups) {
+        tokens.push(...cg.tokens);
+    }
+    return tokens;
+}
+// ─── POLYSYLLABIC RHYTHM BIAS ─────────────────────────────────────
+function polysyllabicRhythmBias(words) {
+    const bias = { iambic: 0, trochaic: 0, anapestic: 0, dactylic: 0 };
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass))
+            continue;
+        if (w.syllables.length < 2 || !w.isContent)
+            continue;
+        const pat = w.syllables.map(s => s.relativeStress ?? 'w');
+        // end‑stressed → iambic / anapestic bias
+        if (isStrong(pat[pat.length - 1])) {
+            bias.iambic += 1;
+            bias.anapestic += 1;
+        }
+        // begin‑stressed → trochaic / dactylic bias
+        if (isStrong(pat[0])) {
+            bias.trochaic += 1;
+            bias.dactylic += 1;
+        }
+    }
+    return bias;
+}
+// ─── SYLLABIC PATTERN PRE-CHECK FOR TRIPLE METERS ──────────────────
+function isStrong(stress) {
+    return stress === 's' || stress === 'm';
+}
+function isWeak(stress) {
+    return stress === 'w' || stress === 'n';
+}
+// ─── METRE SCORING ────────────────────────────────────────────────
+function lineLengthName(feet) {
+    const names = [
+        '', 'monometer', 'dimeter', 'trimeter', 'tetrameter',
+        'pentameter', 'hexameter', 'heptameter', 'octameter'
+    ];
+    return names[feet] || `${feet}-feet`;
+}
+function generateSummary(matchCounts) {
+    return Object.entries(matchCounts)
+        .map(([unit, count]) => `${unit}=${count}`)
+        .join(' ') || 'no matches';
+}
+function isStrongStress(stress) {
+    return stress === 's' || stress === 'm';
+}
+function countSyllables(str) {
+    return str.replace(/[^wmsngWsS]/g, '').length;
+}
+function getTemplatesForMeter(meter) {
+    let tmpls = [];
+    if (meter === 'iambic') {
+        tmpls = [
+            { pattern: ['W', 'S'], baseScore: 0 },
+            { pattern: ['W', 'W', 'S'], baseScore: -1 },
+            { pattern: ['S', 'W'], baseScore: -3, allowedAtStart: true },
+            { pattern: ['S'], baseScore: 0, allowedAtEnd: true },
+            { pattern: ['W', 'S', 'W'], baseScore: -1, allowedAtEnd: true },
+            { pattern: ['W', 'W', 'S', 'W'], baseScore: -1, allowedAtEnd: true },
+        ];
+    }
+    else if (meter === 'trochaic') {
+        tmpls = [
+            { pattern: ['S', 'W'], baseScore: 0 },
+            { pattern: ['S', 'W', 'W'], baseScore: -1 },
+            { pattern: ['S'], baseScore: 0, allowedAtEnd: true },
+            { pattern: ['W', 'S'], baseScore: -3 },
+            { pattern: ['S', 'W', 'S'], baseScore: -1, allowedAtEnd: true },
+        ];
+    }
+    else if (meter === 'anapestic') {
+        tmpls = [
+            { pattern: ['W', 'W', 'S'], baseScore: 0 },
+            { pattern: ['W', 'S'], baseScore: -1 },
+            { pattern: ['S'], baseScore: 0, allowedAtEnd: true },
+            { pattern: ['W', 'W', 'S', 'W'], baseScore: -1, allowedAtEnd: true },
+            { pattern: ['W', 'S', 'W'], baseScore: -1, allowedAtEnd: true },
+        ];
+    }
+    else if (meter === 'dactylic') {
+        tmpls = [
+            { pattern: ['S', 'W', 'W'], baseScore: 0 },
+            { pattern: ['S', 'W'], baseScore: 0 },
+            { pattern: ['S'], baseScore: 0, allowedAtEnd: true },
+            { pattern: ['S', 'W', 'S'], baseScore: -2, allowedAtEnd: true },
+        ];
+    }
+    else if (meter === 'amphibrachic') {
+        tmpls = [
+            { pattern: ['W', 'S', 'W'], baseScore: 0 },
+            { pattern: ['W', 'S'], baseScore: -1 },
+            { pattern: ['S', 'W'], baseScore: -2 },
+            { pattern: ['S'], baseScore: 0, allowedAtEnd: true },
+            { pattern: ['W', 'S', 'W', 'S'], baseScore: -1 },
+        ];
+    }
+    else if (meter !== 'free verse') {
+        const footStr = METRES[meter]?.foot || 'ws';
+        const basePattern = footStr.split('').map(c => c === 's' ? 'S' : 'W');
+        tmpls = [
+            { pattern: basePattern, baseScore: 0 },
+            { pattern: ['S'], baseScore: -1, allowedAtEnd: true },
+        ];
+    }
+    tmpls.push({ pattern: ['W'], baseScore: -10 });
+    tmpls.push({ pattern: ['S'], baseScore: -10 });
+    return tmpls;
+}
+function scoreSyllable(syl, expected) {
+    const actual = syl.stress;
+    let score = 0;
+    if (expected === 'S') {
+        if (actual === 's')
+            score = 4;
+        else if (actual === 'm')
+            score = 3;
+        else if (actual === 'n')
+            score = 1;
+        else
+            score = -2;
+    }
+    else {
+        if (actual === 'w')
+            score = 2;
+        else if (actual === 'n')
+            score = 1;
+        else if (actual === 'm')
+            score = -1;
+        else
+            score = -3;
+        // Fabb's constraint: heavy syllable in polysyllabic word must not
+        // occupy a weak metrical position, unless at the left edge of a PP.
+        if (syl.isPoly && syl.weight === 'H' && !syl.isLeftEdgePP) {
+            // Extrametrical syllables are already weight-invisible; reduce penalty.
+            if (syl.extrametrical) {
+                score -= 2;
+            }
+            else {
+                score -= 5;
+            }
+        }
+    }
+    return score;
+}
+function assembleScansion(words, meter, ius) {
+    const syls = flattenSyllables(words, ius);
+    if (meter === 'free verse') {
+        let out = '';
+        for (let i = 0; i < syls.length; i++) {
+            out += syls[i].stress;
+        }
+        return { scansion: out, footCount: 0, rawScore: 0 };
+    }
+    const cpMembership = new Map();
+    if (ius) {
+        let cpId = 0;
+        const wordToCp = new Map();
+        for (const iu of ius) {
+            for (const pp of iu.phonologicalPhrases) {
+                for (const cg of pp.cliticGroups) {
+                    for (const word of cg.tokens) {
+                        wordToCp.set(word, cpId);
+                    }
+                    cpId++;
+                }
+            }
+        }
+        for (let i = 0; i < syls.length; i++) {
+            const cp = wordToCp.get(syls[i].word);
+            if (cp !== undefined) {
+                cpMembership.set(i, cp);
+            }
+        }
+    }
+    const templates = getTemplatesForMeter(meter);
+    const N = syls.length;
+    const memo = {};
+    function solve(index) {
+        if (index === N) {
+            return { score: 0, feet: [] };
+        }
+        if (memo[index])
+            return memo[index];
+        let bestScore = -Infinity;
+        let bestFeet = [];
+        const isStart = index === 0;
+        for (const t of templates) {
+            const L = t.pattern.length;
+            if (index + L > N)
+                continue;
+            const isEnd = (index + L === N);
+            if (t.allowedAtStart && !isStart)
+                continue;
+            if (t.allowedAtEnd && !isEnd)
+                continue;
+            let matchScore = t.baseScore;
+            let footStr = '';
+            for (let i = 0; i < L; i++) {
+                matchScore += scoreSyllable(syls[index + i], t.pattern[i]);
+                footStr += syls[index + i].stress;
+            }
+            // Word-boundary constraint: penalize splitting polysyllabic words across feet
+            // (Kiparsky 1975: stress patterns within a single word are regulated with special strictness)
+            if (index + L < N) {
+                const lastSylInFoot = syls[index + L - 1];
+                const firstSylAfterFoot = syls[index + L];
+                if (lastSylInFoot.wordIdx === firstSylAfterFoot.wordIdx && lastSylInFoot.isPoly) {
+                    matchScore -= 8; // heavy penalty for splitting a polysyllabic word
+                }
+            }
+            const sub = solve(index + L);
+            if (sub.score !== -Infinity) {
+                const totalScore = matchScore + sub.score;
+                if (totalScore > bestScore) {
+                    bestScore = totalScore;
+                    bestFeet = [footStr, ...sub.feet];
+                }
+            }
+        }
+        memo[index] = { score: bestScore, feet: bestFeet };
+        return memo[index];
+    }
+    const result = solve(0);
+    let currentSylIdx = 0;
+    const finalFeet = [];
+    for (const footStr of result.feet) {
+        let newFootStr = '';
+        for (let i = 0; i < footStr.length; i++) {
+            const syl = syls[currentSylIdx];
+            if (currentSylIdx > 0 && isStrongStress(syl.stress)) {
+                const prevSyl = syls[currentSylIdx - 1];
+                if (isStrongStress(prevSyl.stress)) {
+                    const sameCP = cpMembership.get(currentSylIdx - 1) === cpMembership.get(currentSylIdx);
+                    const sameWord = prevSyl.wordIdx === syl.wordIdx;
+                    if (sameCP || sameWord) {
+                        newFootStr += '-';
+                    }
+                }
+            }
+            newFootStr += syl.stress;
+            currentSylIdx++;
+        }
+        finalFeet.push(newFootStr);
+    }
+    return { scansion: finalFeet.join('|'), footCount: finalFeet.length, rawScore: result.score };
+}
+export function scoreMeters(keyStresses, words, ius) {
+    const totalSyls = words.reduce((sum, w) => sum + (isPunctuation(w.lexicalClass) ? 0 : w.syllables.length), 0);
+    if (totalSyls === 0) {
+        return {
+            all: '', keyStresses: '', meter: 'free verse',
+            meterName: 'free verse', footCount: 0,
+            summary: 'no syllables', scansion: '',
+            certainty: 0, weightScore: 0, maxPossibleWeight: 0,
+        };
+    }
+    const candidateMeters = ['iambic', 'trochaic', 'anapestic', 'dactylic', 'amphibrachic'];
+    // McAleese's weighted scoring using key stresses
+    // For each candidate meter, check how many key stress patterns match the meter's foot shape
+    // Weight by unit type: IU=3, PP=2, PW3+=2, CP=1, PW2=1
+    const KEY_WEIGHT = { IU: 3, PP: 2, PW3plus: 2, CP: 1, PW2: 1 };
+    // Build linear stress pattern for triple meter detection
+    let linearPattern = '';
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass))
+            continue;
+        for (const s of w.syllables) {
+            linearPattern += s.relativeStress ?? 'w';
+        }
+    }
+    function keyStressScore(meter) { console.log("Scoring meter:", meter);
+        const foot = METRES[meter].foot;
+        let score = 0;
+        let maxPossible = 0;
+        // For triple meters, also check linear pattern
+        if (foot.length === 3) {
+            let linearMatches = 0;
+            let totalPositions = 0;
+            for (let i = 0; i <= linearPattern.length - foot.length; i++) {
+                const substring = linearPattern.substring(i, i + foot.length);
+                if (patternMatches(substring, foot, false)) {
+                    linearMatches++;
+                }
+                totalPositions++;
+            }
+            // Linear pattern matching contributes 50% of score for triple meters
+            const linearScore = totalPositions > 0 ? (linearMatches / totalPositions) * 50 : 0;
+            score += linearScore;
+            maxPossible += 50;
+        }
+        for (const ks of keyStresses) {
+            const weight = ks.unitType === 'PW'
+                ? (ks.pattern.length >= 3 ? KEY_WEIGHT.PW3plus : KEY_WEIGHT.PW2)
+                : KEY_WEIGHT[ks.unitType] || 1;
+            maxPossible += weight;
+            if (patternMatches(ks.pattern, foot, false)) {
+                score += weight;
+            }
+            else if (patternMatches(ks.pattern, foot, true)) {
+                score += weight * 0.7; // forward scan gets 70% credit
+            }
+        }
+        const result = maxPossible > 0 ? (score / maxPossible) * 100 : 0; console.log("  score:", score, "maxPossible:", maxPossible, "result:", result); return result;
+    }
+    // Score each meter using key stresses
+    let bestMeter = 'free verse';
+    let bestKeyScore = 0;
+    for (const name of candidateMeters) {
+        const keyScore = keyStressScore(name);
+        if (keyScore > bestKeyScore) {
+            bestKeyScore = keyScore;
+            bestMeter = name;
+        }
+    }
+    // If no meter reaches threshold, use DP aligner as fallback
+    if (bestKeyScore < 40) {
+        let bestDPScore = -Infinity;
+        for (const name of candidateMeters) {
+            const assembly = assembleScansion(words, name, ius);
+            if (assembly.rawScore > bestDPScore) {
+                bestDPScore = assembly.rawScore;
+                bestMeter = name;
+            }
+        }
+        if (bestDPScore < 0) {
+            bestMeter = 'free verse';
+        }
+    }
+    // Assemble scansion using the detected meter
+    const assembly = assembleScansion(words, bestMeter, ius);
+    const bestScansion = assembly.scansion;
+    const bestFootCount = assembly.footCount;
+    const maxPossible = (bestFootCount * 4) + ((totalSyls - bestFootCount) * 2);
+    const certainty = maxPossible > 0 ? Math.max(0, Math.min(100, Math.round((assembly.rawScore / maxPossible) * 100))) : 0;
+    const footType = METRES[bestMeter];
+    const metreName = bestMeter === 'free verse'
+        ? 'free verse'
+        : `${bestMeter} ${lineLengthName(bestFootCount)}`;
+    const summary = `IU=1 PP=${ius?.reduce((s, iu) => s + iu.phonologicalPhrases.length, 0) ?? 0} feet=${bestFootCount} ${footType?.sylCount ?? 0}syl`;
+    return {
+        all: '',
+        keyStresses: '',
+        meter: metreName,
+        meterName: bestMeter,
+        footCount: bestFootCount,
+        summary,
+        scansion: bestScansion,
+        certainty,
+        weightScore: assembly.rawScore,
+        maxPossibleWeight: maxPossible,
+    };
+}

package/dist/stress.d.ts

@@ -0,0 +1,32 @@
+import { ClsWord, IntonationalUnit } from './types.js';
+/**
+ * Assign per‑syllable lexical stress to each word in a sentence.
+ *
+ * Uses the first CMU pronunciation.  Function words have their
+ * primary stress downgraded to secondary (2 → 1).
+ */
+export declare function assignLexicalStress(words: ClsWord[]): void;
+/**
+ * Adjust stresses for nominal compounds.
+ *
+ * Right‑stressed by default: the second content word keeps primary (2),
+ * the first is reduced to secondary (1).
+ * Known left‑stressed compounds (material, time, measure, location, self)
+ * reverse the pattern.
+ */
+export declare function applyCompoundStress(ius: IntonationalUnit[]): void;
+/**
+ * Recursively assign higher stress to content words from right to left.
+ * Only the rightmost content word receives a boost (+1 above lexical primary).
+ * All other content words keep their lexical stress.
+ * This preserves lexical stress for meter detection while still indicating
+ * the nuclear accent for phonological phrasing.
+ */
+export declare function applyNuclearStress(ius: IntonationalUnit[]): void;
+/**
+ * Convert numeric per‑syllable stress to McAleese’s symbolic levels
+ * (w, n, m, s) and resolve adjacent identical stresses using dependency
+ * information.
+ */
+export declare function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]): void;
+//# sourceMappingURL=stress.d.ts.map

package/dist/stress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress.d.ts","sourceRoot":"","sources":["../src/stress.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAyB,gBAAgB,EAAsB,MAAM,YAAY,CAAC;AAujBlG;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CA6Q1D;AAID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAgCjE;AAmBD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAyBhE;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CA0GtF"}