calliope-ts 0.0.2 → 0.0.3

package/dist/engine.js

@@ -0,0 +1,12 @@
+// engine.ts — the prosody-engine abstraction (type-only; no runtime deps, so
+// the concrete engines can import this without a cycle).
+//
+// Two engines produce the SAME shape — a per-sentence prosodic hierarchy with
+// lexical/phrase/relative stress populated on the words:
+//   • "calliope" — the faithful, default, syntax-driven rebuild (Match-Theory
+//     hierarchy + Scenario A–O relation-keyed stress);
+//   • "clio"     — a frozen snapshot of the prior pipeline, the legacy /
+//     alternative parse, selectable via the CLI.
+// Everything downstream (metrical scoring, rhyme/form, display, synopsis) is
+// shared and engine-agnostic.
+export {};

package/dist/index.d.ts

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
+import { ProsodyEngine } from './engine.js';
 import { type ReadingStanza } from './display.js';
 import type { LineResult } from './types.js';
-export declare function analyzeStanzas(text: string, useScandroid?: boolean): LineResult[][];
+export declare function analyzeStanzas(text: string, useScandroid?: boolean, engine?: ProsodyEngine): LineResult[][];
 /**
  * Convenience wrapper: analyse a multi‑line text, ignore stanza breaks,
  * return a flat list of LineResult for each line.
  */
-export declare function analyzeText(text: string, useScandroid?: boolean): LineResult[];
+export declare function analyzeText(text: string, useScandroid?: boolean, engine?: ProsodyEngine): LineResult[];
 /**
  * Analyse a document for the reading view: like analyzeStanzas, but retains
  * each original input line alongside its (1+) parsed sentence results so the
  * stress gradient can be projected back over the verbatim text.
  */
-export declare function analyzeReadingDocument(text: string): ReadingStanza[];
+export declare function analyzeReadingDocument(text: string, engine?: ProsodyEngine): ReadingStanza[];
 export declare const ML_IDLE_MS = 120;
 export type MLEvent = {
     kind: 'char';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAyBA,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAMV,UAAU,EAMX,MAAM,YAAY,CAAC;AAmIpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,GAAG,UAAU,EAAE,EAAE,CAoChF;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,GAAG,UAAU,EAAE,CAG3E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAwBpE;AAoCD,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,OAAO;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;CAAE;AAC7E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,wBAAgB,UAAU,IAAI,OAAO,CAAoD;AAMzF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,QAAQ,CAoCrE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA0B5C,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAOV,UAAU,EAMX,MAAM,YAAY,CAAC;AAkLpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,EAAE,CA2CtH;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,CAGjH;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,aAA4B,GAAG,aAAa,EAAE,CA0B1G;AAwCD,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,OAAO;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;CAAE;AAC7E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,wBAAgB,UAAU,IAAI,OAAO,CAAoD;AAMzF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,QAAQ,CAoCrE"}

package/dist/index.js

@@ -3,13 +3,73 @@ import * as fs from 'fs';
 import * as readline from 'readline';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
-import { parseDocument } from './parser.js';
-import { assignLexicalStress, applyCompoundStress, applyNuclearStress, assignRelativeStresses, } from './stress.js';
-import { buildPhonologicalHierarchy, renderHierarchy, renderKeyStresses, } from './phonological.js';
-import { extractKeyStresses, scoreMeters, applyStanzaConsensus, applyRhythmLayer } from './scansion.js';
+import { parseDocument, isPunctuation } from './parser.js';
+import { calliopeEngine } from './calliope/engine.js';
+import { clioEngine } from './clio/engine.js';
+// The FROZEN Clio pipeline + renderers (its own copy of the whole computational
+// tree).  When Clio is active the CLI runs entirely through these, so live changes
+// to the regular (Calliope) pipeline — scorer included — cannot affect Clio.
+import { analyzeReadingDocumentClio, renderUnifiedDisplay as clioRenderUnifiedDisplay, renderReadingView as clioRenderReadingView, renderFullLegend as clioRenderFullLegend, parseDocument as clioParseDocument, isPunctuation as clioIsPunctuation, } from './clio/pipeline.js';
+import { renderHierarchy, renderKeyStresses, } from './phonological.js';
+import { extractKeyStresses, scoreMeters, applyStanzaConsensus, applyRhythmLayer, applyMetricalityLayer } from './scansion.js';
 import { applyRhymeAndForm } from './rhyme.js';
 import { scandroidCorralWeird, scandroidMaximizeNormal, stressToMarks, } from './scandroid.js';
 import { renderUnifiedDisplay, renderFullLegend, renderReadingView, } from './display.js';
+// The active prosody engine for this process: Calliope (faithful, default) or
+// Clio (the frozen legacy / alternative parse), chosen by `--clio` or the REPL
+// menu.  The exported analysis functions default their `engine` parameter to
+// this, so library callers (tests, trials, benchmark) transparently use the
+// active engine without signature churn.
+let activeEngine = calliopeEngine;
+/**
+ * Stanza-level discourse givenness (Wagner Ch.7, the plan's Gap 13) — CAREFUL and
+ * cross-line only.  A CONTENT word repeated from an EARLIER line of the same stanza
+ * is discourse-given, so it may be subordinated relative to a new-information sister
+ * (the relativiser reads `discourseGiven`).  Constraints that protect single-line
+ * scanning and thematically-focused words:
+ *   • the first line is never marked (no prior context);
+ *   • a lemma repeated WITHIN a single line is FOCUSED, not given → never marked
+ *     (Eliot's "Nothing … nothing", a refrain);
+ *   • only the 2nd-and-later occurrence (across lines) is marked, never the first;
+ *   • single-line input has no previous line, so nothing is marked — the standout
+ *     isolated-line feature is untouched.
+ * Mutates `discourseGiven` on the words; must run BEFORE the per-line relativisation.
+ */
+function markStanzaGivenness(docPerLine) {
+    if (docPerLine.length < 2)
+        return; // single line → no givenness
+    const key = (w) => w.word.toLowerCase().replace(/['’]/g, '');
+    // Lemmas that appear ≥2× within ANY one line are focal (refrain/emphasis) — exempt.
+    const focal = new Set();
+    for (const sents of docPerLine) {
+        const counts = new Map();
+        for (const sent of sents)
+            for (const w of sent.words) {
+                if (!w.isContent)
+                    continue;
+                const k = key(w);
+                counts.set(k, (counts.get(k) ?? 0) + 1);
+            }
+        for (const [k, n] of counts)
+            if (n >= 2)
+                focal.add(k);
+    }
+    const seen = new Set(); // content lemmas in PRIOR lines
+    for (const sents of docPerLine) {
+        const thisLine = new Set();
+        for (const sent of sents)
+            for (const w of sent.words) {
+                if (!w.isContent)
+                    continue;
+                const k = key(w);
+                if (seen.has(k) && !focal.has(k))
+                    w.discourseGiven = true;
+                thisLine.add(k);
+            }
+        for (const k of thisLine)
+            seen.add(k);
+    }
+}
 /**
  * Scan one VERSE LINE (which may parse into several grammatical sentences).
  *
@@ -23,16 +83,15 @@ import { renderUnifiedDisplay, renderFullLegend, renderReadingView, } from './di
  * line's full concatenated syllable stream, with each sentence's IUs preserved
  * as IU boundaries (→ hard caesurae) inside the line.
  */
-function processLine(sents) {
+function processLine(sents, engine = activeEngine) {
     if (sents.length === 0)
         return null;
     const iusPerSent = [];
     for (const sent of sents) {
-        assignLexicalStress(sent.words);
-        const sentIus = buildPhonologicalHierarchy(sent);
-        applyCompoundStress(sentIus);
-        applyNuclearStress(sentIus);
-        assignRelativeStresses(sent.words, sentIus);
+        // The selected engine runs the per-sentence linguistic passes (lexical →
+        // hierarchy → compound/nuclear → phrase → relative stress) and returns the
+        // prosodic hierarchy.  Calliope (default) and Clio differ only here.
+        const sentIus = engine.analyzeSentence(sent);
         iusPerSent.push(sentIus);
     }
     // Merge the sentences' streams into the line-level scansion domain.
@@ -132,15 +191,19 @@ function applyContinuityRename(results) {
         d.consensusMeter = undefined;
     }
 }
-export function analyzeStanzas(text, useScandroid = true) {
+export function analyzeStanzas(text, useScandroid = true, engine = activeEngine) {
     const stanzas = text.split(/\n\s*\n/);
     const results = [];
     for (const stanza of stanzas) {
         const lines = stanza.split('\n').filter(l => l.trim() !== '');
         const stanzaResults = [];
-        for (const line of lines) {
-            const doc = parseDocument(line);
-            const res = processLine(doc.sentences);
+        // Parse every line first, then mark cross-line discourse givenness BEFORE the
+        // per-line stress passes (relativisation reads `discourseGiven`).  Only the
+        // default (Calliope) relativiser consults it; Clio ignores the flag.
+        const docs = lines.map(line => parseDocument(line));
+        markStanzaGivenness(docs.map(d => d.sentences));
+        for (const doc of docs) {
+            const res = processLine(doc.sentences, engine);
             if (res)
                 stanzaResults.push(res);
         }
@@ -166,6 +229,9 @@ export function analyzeStanzas(text, useScandroid = true) {
         for (const st of results)
             applyRhythmLayer(st.map(r => r.phonologicalScansion));
     }
+    // Prose-likeness hedge (Option 0): advisory, runs after the rhythm layer so it
+    // can defer to any accentual/dolnik verdict; annotation-only (metricalityNote).
+    applyMetricalityLayer(results.flatMap(st => st.map(r => r.phonologicalScansion)));
     // Rhyme scheme + poetic-form identification spans stanzas (sonnets, terza
     // rima); annotation-only (rhyme/formNote on each line's detail).
     applyRhymeAndForm(results);
@@ -175,8 +241,8 @@ export function analyzeStanzas(text, useScandroid = true) {
  * Convenience wrapper: analyse a multi‑line text, ignore stanza breaks,
  * return a flat list of LineResult for each line.
  */
-export function analyzeText(text, useScandroid = true) {
-    const stanzaResults = analyzeStanzas(text, useScandroid);
+export function analyzeText(text, useScandroid = true, engine = activeEngine) {
+    const stanzaResults = analyzeStanzas(text, useScandroid, engine);
     return stanzaResults.flat();
 }
 /**
@@ -184,16 +250,17 @@ export function analyzeText(text, useScandroid = true) {
  * each original input line alongside its (1+) parsed sentence results so the
  * stress gradient can be projected back over the verbatim text.
  */
-export function analyzeReadingDocument(text) {
+export function analyzeReadingDocument(text, engine = activeEngine) {
     const stanzas = text.split(/\n\s*\n/);
     const out = [];
     for (const stanza of stanzas) {
         const rawLines = stanza.split('\n').filter(l => l.trim() !== '');
         if (rawLines.length === 0)
             continue;
-        const lines = rawLines.map(raw => {
-            const doc = parseDocument(raw);
-            const res = processLine(doc.sentences);
+        const rawDocs = rawLines.map(raw => ({ raw, doc: parseDocument(raw) }));
+        markStanzaGivenness(rawDocs.map(rd => rd.doc.sentences));
+        const lines = rawDocs.map(({ raw, doc }) => {
+            const res = processLine(doc.sentences, engine);
             return { raw, results: res ? [res] : [] };
         });
         applyStanzaConsensus(lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
@@ -208,6 +275,7 @@ export function analyzeReadingDocument(text) {
         for (const st of out)
             applyRhythmLayer(st.lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
     }
+    applyMetricalityLayer(out.flatMap(st => st.lines.flatMap(l => l.results.map(r => r.phonologicalScansion))));
     applyRhymeAndForm(out.map(st => st.lines.flatMap(l => l.results)));
     return out;
 }
@@ -215,21 +283,25 @@ export function analyzeReadingDocument(text) {
 function showResults(text) {
     // Use the reading-document analysis so each LineResult keeps its verbatim input
     // line (for the tail Reading Projection) and the stanza-consensus annotation.
-    const stanzas = analyzeReadingDocument(text);
+    // Clio routes through its own frozen pipeline + renderer.
+    const isClio = activeEngine.name === 'clio';
+    const stanzas = (isClio ? analyzeReadingDocumentClio : analyzeReadingDocument)(text);
+    const render = isClio ? clioRenderUnifiedDisplay : renderUnifiedDisplay;
     for (let s = 0; s < stanzas.length; s++) {
         if (stanzas.length > 1) {
             console.log('\n' + chalk.bold('═══ Stanza ' + (s + 1) + ' ═══'));
         }
         for (const ln of stanzas[s].lines) {
             for (const res of ln.results) {
-                console.log(renderUnifiedDisplay(res, ln.raw));
+                console.log(render(res, ln.raw));
             }
         }
     }
 }
 function showReadingView(text) {
-    const stanzas = analyzeReadingDocument(text);
-    console.log(renderReadingView(stanzas));
+    const isClio = activeEngine.name === 'clio';
+    const stanzas = (isClio ? analyzeReadingDocumentClio : analyzeReadingDocument)(text);
+    console.log((isClio ? clioRenderReadingView : renderReadingView)(stanzas));
 }
 // ─── MULTI-LINE INPUT (paste-friendly) ──────────────────────────
 // Goal: the user pastes a whole poem (stanza breaks and all) and presses Enter
@@ -396,6 +468,7 @@ async function replMode() {
                 { title: 'Line-by-Line Analysis (detailed view)', value: 'multiline' },
                 { title: 'Parse & Scan from File (reading view)', value: 'reading-file' },
                 { title: 'Analyze from File (detailed view)', value: 'file' },
+                { title: 'Ask Clio instead (alternative parse) — toggle engine', value: 'engine' },
                 { title: 'Display Legend', value: 'legend' },
                 { title: 'Exit', value: 'exit' },
             ],
@@ -405,8 +478,20 @@ async function replMode() {
             console.log(chalk.dim('\nGoodbye.\n'));
             break;
         }
+        if (response.action === 'engine') {
+            // Toggle between Calliope (faithful, default) and Clio (the legacy /
+            // alternative parse).  Clio is Calliope's historian sister — sometimes
+            // on point, but not the primary poetic voice.
+            activeEngine = activeEngine.name === 'calliope' ? clioEngine : calliopeEngine;
+            const label = activeEngine.name === 'clio'
+                ? 'Clio — legacy / alternative parse'
+                : 'Calliope — faithful, default';
+            console.log(chalk.dim(`\n  Active engine: ${chalk.bold(label)}\n`));
+            continue;
+        }
         if (response.action === 'legend') {
-            console.log('\n' + renderFullLegend() + '\n');
+            const legend = activeEngine.name === 'clio' ? clioRenderFullLegend : renderFullLegend;
+            console.log('\n' + legend() + '\n');
             continue;
         }
         if (response.action === 'scan') {
@@ -462,6 +547,50 @@ async function replMode() {
         }
     }
 }
+// ─── PARSE-AUDIT DIAGNOSTIC ──────────────────────────────────────
+//
+// `--debug-parse` dumps, per word, the full chain the scansion rests on: POS
+// tag, dependency role + governor, prosodic membership (IU.PP.CP), and the
+// lexical / phrase / relative stress.  This is the audit instrument for the
+// POS + dependency + correction layers — read alongside trials/parse_audit.mjs,
+// which tabulates tag/dependency distributions and anomalies over a corpus.
+function debugParse(text) {
+    // Clio audits through its own frozen parser; Calliope through the live one.
+    const isClio = activeEngine.name === 'clio';
+    const parse = isClio ? clioParseDocument : parseDocument;
+    const isPunct = isClio ? clioIsPunctuation : isPunctuation;
+    const lines = text.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+    for (const line of lines) {
+        const doc = parse(line);
+        console.log('\n' + chalk.bold.cyan('› ' + line));
+        for (const sent of doc.sentences) {
+            // Route the audit dump through the active engine so --debug-parse reflects
+            // whichever engine (Calliope / Clio) is selected.
+            const ius = activeEngine.analyzeSentence(sent);
+            const loc = new Map();
+            ius.forEach((iu, ii) => iu.phonologicalPhrases.forEach((pp, pi) => pp.cliticGroups.forEach((cg, ci) => cg.tokens.forEach(t => loc.set(t, `${ii + 1}.${pi + 1}.${ci + 1}`)))));
+            console.log(chalk.dim('  word         POS    C/F  dep            ←governor     IU.PP.CP  lex   phr  rel   canon      name'));
+            for (const w of sent.words) {
+                if (isPunctuation(w.lexicalClass))
+                    continue;
+                const d = w.dependency;
+                const gov = d && d.governor ? d.governor.word : '—';
+                const cf = w.isContent ? 'C' : 'f';
+                const lex = w.syllables.map(s => (s.lexicalStress ?? s.stress)).join('');
+                const rel = w.syllables.map(s => s.relativeStress).join('');
+                // Calliope substrate (Stage 1): normalised relation + person/place flags.
+                const canon = w.canonicalRel ?? '-';
+                const name = w.isPersonName && w.isPlaceName ? 'P+C'
+                    : w.isPersonName ? 'person' : w.isPlaceName ? 'place' : '';
+                console.log('  ' + w.word.padEnd(12) + w.lexicalClass.padEnd(6) + ' ' + cf + '   '
+                    + (d ? d.dependentType : '?').padEnd(14) + ' ' + String(gov).padEnd(13) + ' '
+                    + (loc.get(w) ?? '-').padEnd(9) + ' ' + lex.padEnd(5) + ' '
+                    + String(w.phraseStress).padEnd(4) + ' ' + rel.padEnd(5) + ' '
+                    + canon.padEnd(10) + ' ' + name);
+            }
+        }
+    }
+}
 // ─── CLI ENTRY POINT ─────────────────────────────────────────────
 async function main() {
     let rawArgs = process.argv.slice(2);
@@ -469,7 +598,15 @@ async function main() {
     // syllables stress-coloured, + per-line stress maps) instead of the full dump.
     const reading = rawArgs.includes('--reading') || rawArgs.includes('-r');
     rawArgs = rawArgs.filter(a => a !== '--reading' && a !== '-r');
-    const show = reading ? showReadingView : showResults;
+    // --debug-parse : dump the per-word POS / dependency / prosody / stress chain.
+    const debugParseMode = rawArgs.includes('--debug-parse');
+    rawArgs = rawArgs.filter(a => a !== '--debug-parse');
+    // --clio : run the frozen legacy / alternative parse engine instead of the
+    // default faithful Calliope engine.
+    if (rawArgs.includes('--clio'))
+        activeEngine = clioEngine;
+    rawArgs = rawArgs.filter(a => a !== '--clio');
+    const show = debugParseMode ? debugParse : reading ? showReadingView : showResults;
     // Explicit arguments take precedence over piped stdin — otherwise running
     // `calliope_ts "some line"` from a script/CI (where stdin is a non-TTY but
     // empty) silently analysed the empty pipe and ignored the argument.
@@ -495,6 +632,12 @@ async function main() {
     // No arguments: launch interactive REPL
     await replMode();
 }
+// Is this module being run directly as the CLI, or imported as a library?
+// A plain `process.argv[1] === fileURLToPath(import.meta.url)` check breaks under
+// `npm install -g`: npm invokes us through a symlink in its bin directory, so
+// process.argv[1] is that symlink's path, not the real dist/index.js. The two
+// never match, `main()` never fires, and the command exits silently. Resolve
+// symlinks on BOTH sides before comparing so the global command actually runs.
 let isMain = false;
 if (process.argv[1]) {
     try {

package/dist/parser.d.ts

@@ -2,9 +2,9 @@ import { ClsDocument } from './types.js';
 export declare function isPunctuation(tag: string): boolean;
 export declare function isQuoteTag(tag: string): boolean;
 /**
- * Parse a multi‑sentence text string and return a ClsDocument whose
- * internal structure mirrors the Antelope NLP (aka Universal Dependency type)
- * output from McAleese’s original Calliope implementation.
+ * Lowercase the first alphabetic character of every line. Kept available but
+ * NOT called by default — empirically net-negative with UDPipe (see parseDocument).
  */
+export declare function lowerLineInitials(text: string): string;
 export declare function parseDocument(text: string): ClsDocument;
 //# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,WAAW,EAKZ,MAAM,YAAY,CAAC;AA6TpB,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAElD;AAUD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAgED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAiPvD"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,WAAW,EAKZ,MAAM,YAAY,CAAC;AAkCpB,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAElD;AASD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAMD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtD;AAmJD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAsJvD"}