todoosy 0.3.4 → 0.3.7

package/dist/cjs/formatter.d.ts

@@ -1,5 +1,6 @@
 /**
  * Todoosy Formatter
  */
+import { type ParseOptions } from './parser.js';
 import type { Scheme } from './types.js';
-export declare function format(text: string, scheme?: Scheme, filename?: string): string;
+export declare function format(text: string, scheme?: Scheme, filename?: string, options?: ParseOptions): string;

package/dist/cjs/formatter.js

@@ -18,8 +18,15 @@ function parseMiscLocation(misc) {
 function formatMetadata(metadata) {
     const parts = [];
     if (metadata.due) {
-        const softPrefix = metadata.due_soft ? '~' : '';
-        parts.push(`due ${softPrefix}${metadata.due}`);
+        if (metadata.due_start) {
+            // Span form: `due start~end`. The `~` between dates carries the soft semantics;
+            // a leading `~` is never used in conjunction with a span.
+            parts.push(`due ${metadata.due_start}~${metadata.due}`);
+        }
+        else {
+            const softPrefix = metadata.due_soft ? '~' : '';
+            parts.push(`due ${softPrefix}${metadata.due}`);
+        }
     }
     if (metadata.progress) {
         parts.push(metadata.progress);
@@ -70,8 +77,8 @@ function formatComments(comments, isListItem, indent) {
     // Heading comments are not indented
     return comments;
 }
-function format(text, scheme, filename) {
-    const { ast } = (0, parser_js_1.parse)(text);
+function format(text, scheme, filename, options) {
+    const { ast } = (0, parser_js_1.parse)(text, options);
     const lines = [];
     const itemMap = new Map();
     for (const item of ast.items) {

package/dist/cjs/index.d.ts

@@ -2,7 +2,9 @@
  * Todoosy - Markdown-based todo system
  */
 export { parse, parseTokensInParenGroup, extractParenGroups } from './parser.js';
-export type { ParseResult } from './parser.js';
+export type { ParseResult, ParseOptions } from './parser.js';
+export { resolveNow, resolveKeyword, tryParseRelative } from './relative-date.js';
+export type { ResolvedNow } from './relative-date.js';
 export { format } from './formatter.js';
 export { lint } from './linter.js';
 export { queryUpcoming, queryMisc, queryByHashtag, listHashtags } from './query.js';

package/dist/cjs/index.js

@@ -3,11 +3,15 @@
  * Todoosy - Markdown-based todo system
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToBullets = exports.convertToSequence = exports.removeSequencedItem = exports.insertSequencedItem = exports.renumberChildren = exports.analyzeSequence = exports.parseSettings = exports.parseScheme = exports.listHashtags = exports.queryByHashtag = exports.queryMisc = exports.queryUpcoming = exports.lint = exports.format = exports.extractParenGroups = exports.parseTokensInParenGroup = exports.parse = void 0;
+exports.convertToBullets = exports.convertToSequence = exports.removeSequencedItem = exports.insertSequencedItem = exports.renumberChildren = exports.analyzeSequence = exports.parseSettings = exports.parseScheme = exports.listHashtags = exports.queryByHashtag = exports.queryMisc = exports.queryUpcoming = exports.lint = exports.format = exports.tryParseRelative = exports.resolveKeyword = exports.resolveNow = exports.extractParenGroups = exports.parseTokensInParenGroup = exports.parse = void 0;
 var parser_js_1 = require("./parser.js");
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_js_1.parse; } });
 Object.defineProperty(exports, "parseTokensInParenGroup", { enumerable: true, get: function () { return parser_js_1.parseTokensInParenGroup; } });
 Object.defineProperty(exports, "extractParenGroups", { enumerable: true, get: function () { return parser_js_1.extractParenGroups; } });
+var relative_date_js_1 = require("./relative-date.js");
+Object.defineProperty(exports, "resolveNow", { enumerable: true, get: function () { return relative_date_js_1.resolveNow; } });
+Object.defineProperty(exports, "resolveKeyword", { enumerable: true, get: function () { return relative_date_js_1.resolveKeyword; } });
+Object.defineProperty(exports, "tryParseRelative", { enumerable: true, get: function () { return relative_date_js_1.tryParseRelative; } });
 var formatter_js_1 = require("./formatter.js");
 Object.defineProperty(exports, "format", { enumerable: true, get: function () { return formatter_js_1.format; } });
 var linter_js_1 = require("./linter.js");

package/dist/cjs/linter.d.ts

@@ -1,6 +1,7 @@
 /**
  * Todoosy Linter
  */
+import { type ParseOptions } from './parser.js';
 import type { LintResult, Scheme } from './types.js';
-export declare function lint(text: string, scheme?: Scheme, filename?: string): LintResult;
+export declare function lint(text: string, scheme?: Scheme, filename?: string, options?: ParseOptions): LintResult;
 export declare function lintScheme(scheme: Scheme): LintResult;

package/dist/cjs/linter.js

@@ -76,8 +76,8 @@ function parseMiscLocation(misc) {
         heading: misc.substring(slashIndex + 1),
     };
 }
-function lint(text, scheme, filename) {
-    const { ast } = (0, parser_js_1.parse)(text);
+function lint(text, scheme, filename, options) {
+    const { ast } = (0, parser_js_1.parse)(text, options);
     const warnings = [];
     const lines = text.split('\n');
     // Determine misc location from scheme or use default
@@ -102,6 +102,12 @@ function lint(text, scheme, filename) {
                 miscSectionSpan = item.item_span;
             }
         }
+        // If the parser already recognized a due date for this item, skip the
+        // regex-based date-format validation entirely. The parser accepts a
+        // richer surface than these regexes know about (today/tomorrow keywords,
+        // relative offsets like "in 2 weeks", spans like `start~end`); trusting
+        // the parser is both more correct and avoids divergence between the two.
+        const skipDateFormatChecks = item.metadata.due !== null;
         // Check for invalid date formats in parentheses
         const parenMatches = rawLine.matchAll(/\(([^)]+)\)/g);
         for (const match of parenMatches) {
@@ -114,7 +120,7 @@ function lint(text, scheme, filename) {
             for (const textDueMatch of textDueMatches) {
                 textDueIndices.add(textDueMatch.index || 0);
                 const dateStr = textDueMatch[1];
-                if (!isValidDate(dateStr)) {
+                if (!isValidDate(dateStr) && !skipDateFormatChecks) {
                     const tokenStart = parenStart + 1 + (textDueMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_DATE_FORMAT',
@@ -130,7 +136,7 @@ function lint(text, scheme, filename) {
             for (const textDueMatch of textDueDayFirstMatches) {
                 textDueIndices.add(textDueMatch.index || 0);
                 const dateStr = textDueMatch[1];
-                if (!isValidDate(dateStr)) {
+                if (!isValidDate(dateStr) && !skipDateFormatChecks) {
                     const tokenStart = parenStart + 1 + (textDueMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_DATE_FORMAT',
@@ -156,7 +162,7 @@ function lint(text, scheme, filename) {
                 // Skip if this looks like a day number (could be start of day-first date, with or without ~)
                 if (/^~?\d{1,2}$/.test(dateStr))
                     continue;
-                if (!isValidDate(dateStr)) {
+                if (!isValidDate(dateStr) && !skipDateFormatChecks) {
                     const tokenStart = parenStart + 1 + (dueMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_DATE_FORMAT',
@@ -167,134 +173,138 @@ function lint(text, scheme, filename) {
                     });
                 }
             }
-            // Check for multiple due dates across all paren groups
+            // Check for multiple due dates across all paren groups.
+            // Span syntax (`start~end`) legitimately contains two ISO/text dates,
+            // so skip duplicate detection when the parser recognized a span.
             const allDueDates = [];
-            const allParenMatches = rawLine.matchAll(/\(([^)]+)\)/g);
-            for (const pMatch of allParenMatches) {
-                const pContent = pMatch[1];
-                const pStart = item.item_span[0] + (pMatch.index || 0);
-                const matchedPositions = new Set();
-                // Check text dates first (month-first, year can be 2 or 4 digits) with "due" prefix
-                // Allow optional ~ prefix for soft dates
-                const textDueDatesInGroup = pContent.matchAll(/\bdue\s+(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
-                for (const tdm of textDueDatesInGroup) {
-                    const ds = tdm[1];
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(tdm.index || 0);
-                        const dStart = pStart + 1 + (tdm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + tdm[0].length],
-                        });
+            if (item.metadata.due_start === null) {
+                const allParenMatches = rawLine.matchAll(/\(([^)]+)\)/g);
+                for (const pMatch of allParenMatches) {
+                    const pContent = pMatch[1];
+                    const pStart = item.item_span[0] + (pMatch.index || 0);
+                    const matchedPositions = new Set();
+                    // Check text dates first (month-first, year can be 2 or 4 digits) with "due" prefix
+                    // Allow optional ~ prefix for soft dates
+                    const textDueDatesInGroup = pContent.matchAll(/\bdue\s+(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+                    for (const tdm of textDueDatesInGroup) {
+                        const ds = tdm[1];
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(tdm.index || 0);
+                            const dStart = pStart + 1 + (tdm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + tdm[0].length],
+                            });
+                        }
                     }
-                }
-                // Check day-first text dates (year can be 2 or 4 digits) with "due" prefix
-                // Allow optional ~ prefix for soft dates
-                const textDueDayFirstInGroup = pContent.matchAll(/\bdue\s+(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
-                for (const tdm of textDueDayFirstInGroup) {
-                    const ds = tdm[1];
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(tdm.index || 0);
-                        const dStart = pStart + 1 + (tdm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + tdm[0].length],
-                        });
+                    // Check day-first text dates (year can be 2 or 4 digits) with "due" prefix
+                    // Allow optional ~ prefix for soft dates
+                    const textDueDayFirstInGroup = pContent.matchAll(/\bdue\s+(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+                    for (const tdm of textDueDayFirstInGroup) {
+                        const ds = tdm[1];
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(tdm.index || 0);
+                            const dStart = pStart + 1 + (tdm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + tdm[0].length],
+                            });
+                        }
                     }
-                }
-                // Check standard dates with "due" prefix
-                // Allow optional ~ prefix for soft dates
-                const dueDatesInGroup = pContent.matchAll(/\bdue\s+(~?[^\s,)]+)/gi);
-                for (const dm of dueDatesInGroup) {
-                    // Skip if already matched as text date
-                    if (matchedPositions.has(dm.index || 0))
-                        continue;
-                    const ds = dm[1];
-                    // Skip if it's a month name (part of text date, with or without ~)
-                    const strippedDs = ds.startsWith('~') ? ds.slice(1) : ds;
-                    if (MONTH_NAMES.has(strippedDs.toLowerCase()))
-                        continue;
-                    // Skip if it's a day number (part of day-first text date, with or without ~)
-                    if (/^~?\d{1,2}$/.test(ds))
-                        continue;
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(dm.index || 0);
-                        const dStart = pStart + 1 + (dm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + dm[0].length],
-                        });
+                    // Check standard dates with "due" prefix
+                    // Allow optional ~ prefix for soft dates
+                    const dueDatesInGroup = pContent.matchAll(/\bdue\s+(~?[^\s,)]+)/gi);
+                    for (const dm of dueDatesInGroup) {
+                        // Skip if already matched as text date
+                        if (matchedPositions.has(dm.index || 0))
+                            continue;
+                        const ds = dm[1];
+                        // Skip if it's a month name (part of text date, with or without ~)
+                        const strippedDs = ds.startsWith('~') ? ds.slice(1) : ds;
+                        if (MONTH_NAMES.has(strippedDs.toLowerCase()))
+                            continue;
+                        // Skip if it's a day number (part of day-first text date, with or without ~)
+                        if (/^~?\d{1,2}$/.test(ds))
+                            continue;
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(dm.index || 0);
+                            const dStart = pStart + 1 + (dm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + dm[0].length],
+                            });
+                        }
                     }
-                }
-                // Check standalone text dates (without "due" prefix, not preceded by digit+space which indicates day-first)
-                // Allow optional ~ prefix for soft dates
-                // Exclude if preceded by "due " or "due ~"
-                const standaloneTextDatesInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d\s)(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
-                for (const stm of standaloneTextDatesInGroup) {
-                    // Skip if already matched
-                    if (matchedPositions.has(stm.index || 0))
-                        continue;
-                    const ds = stm[1];
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(stm.index || 0);
-                        const dStart = pStart + 1 + (stm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + stm[0].length],
-                        });
+                    // Check standalone text dates (without "due" prefix, not preceded by digit+space which indicates day-first)
+                    // Allow optional ~ prefix for soft dates
+                    // Exclude if preceded by "due " or "due ~"
+                    const standaloneTextDatesInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d\s)(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+                    for (const stm of standaloneTextDatesInGroup) {
+                        // Skip if already matched
+                        if (matchedPositions.has(stm.index || 0))
+                            continue;
+                        const ds = stm[1];
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(stm.index || 0);
+                            const dStart = pStart + 1 + (stm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + stm[0].length],
+                            });
+                        }
                     }
-                }
-                // Check standalone day-first text dates (without "due" prefix, not preceded by digit)
-                // Note: Day-first soft dates would be like ~15 Feb, but this is unusual; keep pattern simple
-                // Exclude if preceded by "due " or "due ~"
-                const standaloneDayFirstInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
-                for (const stm of standaloneDayFirstInGroup) {
-                    // Skip if already matched
-                    if (matchedPositions.has(stm.index || 0))
-                        continue;
-                    const ds = stm[1];
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(stm.index || 0);
-                        const dStart = pStart + 1 + (stm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + stm[0].length],
-                        });
+                    // Check standalone day-first text dates (without "due" prefix, not preceded by digit)
+                    // Note: Day-first soft dates would be like ~15 Feb, but this is unusual; keep pattern simple
+                    // Exclude if preceded by "due " or "due ~"
+                    const standaloneDayFirstInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+                    for (const stm of standaloneDayFirstInGroup) {
+                        // Skip if already matched
+                        if (matchedPositions.has(stm.index || 0))
+                            continue;
+                        const ds = stm[1];
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(stm.index || 0);
+                            const dStart = pStart + 1 + (stm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + stm[0].length],
+                            });
+                        }
+                    }
+                    // Check standalone ISO/slash dates (without "due" prefix)
+                    // Use word boundary to avoid matching partial dates
+                    // Allow optional ~ prefix for soft dates
+                    // Exclude if preceded by "due " or "due ~"
+                    const standaloneNumericDates = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{2,4}[-\/]\d{1,2}[-\/]\d{1,4})(?!\d)/gi);
+                    for (const snm of standaloneNumericDates) {
+                        // Skip if already matched
+                        if (matchedPositions.has(snm.index || 0))
+                            continue;
+                        const ds = snm[1];
+                        if (isValidDate(ds)) {
+                            matchedPositions.add(snm.index || 0);
+                            const dStart = pStart + 1 + (snm.index || 0);
+                            allDueDates.push({
+                                dateStr: ds,
+                                span: [dStart, dStart + snm[0].length],
+                            });
+                        }
                     }
                 }
-                // Check standalone ISO/slash dates (without "due" prefix)
-                // Use word boundary to avoid matching partial dates
-                // Allow optional ~ prefix for soft dates
-                // Exclude if preceded by "due " or "due ~"
-                const standaloneNumericDates = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{2,4}[-\/]\d{1,2}[-\/]\d{1,4})(?!\d)/gi);
-                for (const snm of standaloneNumericDates) {
-                    // Skip if already matched
-                    if (matchedPositions.has(snm.index || 0))
-                        continue;
-                    const ds = snm[1];
-                    if (isValidDate(ds)) {
-                        matchedPositions.add(snm.index || 0);
-                        const dStart = pStart + 1 + (snm.index || 0);
-                        allDueDates.push({
-                            dateStr: ds,
-                            span: [dStart, dStart + snm[0].length],
+                if (allDueDates.length > 1) {
+                    // Warn for the second and subsequent ones
+                    for (let i = 1; i < allDueDates.length; i++) {
+                        warnings.push({
+                            code: 'DUPLICATE_DUE_DATE',
+                            message: 'Multiple due dates found, using last value',
+                            line: item.line,
+                            column: allDueDates[i].span[0] - item.item_span[0] + 1,
+                            span: allDueDates[i].span,
                         });
                     }
+                    break; // Only warn once per item
                 }
-            }
-            if (allDueDates.length > 1) {
-                // Warn for the second and subsequent ones
-                for (let i = 1; i < allDueDates.length; i++) {
-                    warnings.push({
-                        code: 'DUPLICATE_DUE_DATE',
-                        message: 'Multiple due dates found, using last value',
-                        line: item.line,
-                        column: allDueDates[i].span[0] - item.item_span[0] + 1,
-                        span: allDueDates[i].span,
-                    });
-                }
-                break; // Only warn once per item
-            }
+            } // end if (item.metadata.due_start === null)
             // Check for standalone dates (without "due" prefix)
             // Standalone text dates: Month Day [Year] (not preceded by "due" or digit+space)
             // Allow optional ~ prefix for soft dates
@@ -302,7 +312,7 @@ function lint(text, scheme, filename) {
             const standaloneTextDates = content.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d\s)(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
             for (const stdMatch of standaloneTextDates) {
                 const dateStr = stdMatch[1];
-                if (!isValidDate(dateStr)) {
+                if (!isValidDate(dateStr) && !skipDateFormatChecks) {
                     const tokenStart = parenStart + 1 + (stdMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_DATE_FORMAT',
@@ -319,7 +329,7 @@ function lint(text, scheme, filename) {
             const standaloneDayFirstDates = content.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
             for (const stdMatch of standaloneDayFirstDates) {
                 const dateStr = stdMatch[1];
-                if (!isValidDate(dateStr)) {
+                if (!isValidDate(dateStr) && !skipDateFormatChecks) {
                     const tokenStart = parenStart + 1 + (stdMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_DATE_FORMAT',
@@ -350,7 +360,11 @@ function lint(text, scheme, filename) {
             const invalidEstimates = content.matchAll(/\b(\d+)([a-zA-Z])(?![mhdMHD])\b/gi);
             for (const ieMatch of invalidEstimates) {
                 const unit = ieMatch[2].toLowerCase();
-                if (unit !== 'm' && unit !== 'h' && unit !== 'd') {
+                // Allow relative-date single-letter units `w` (week) and `y` (year)
+                // alongside the existing estimate units m/h/d. Multi-letter forms
+                // (`2wk`, `2week`, `2years`, `2 days`, `in 2 weeks`) don't match this
+                // regex anyway because the trailing word boundary fails on extra letters.
+                if (unit !== 'm' && unit !== 'h' && unit !== 'd' && unit !== 'w' && unit !== 'y') {
                     const tokenStart = parenStart + 1 + (ieMatch.index || 0);
                     warnings.push({
                         code: 'INVALID_TOKEN',

package/dist/cjs/parser.d.ts

@@ -1,11 +1,18 @@
 /**
  * Todoosy Parser
  */
-import type { AST, ParenGroup, Warning } from './types.js';
+import type { AST, ParenGroup, Warning, Settings } from './types.js';
+import { type ResolvedNow } from './relative-date.js';
+export interface ParseOptions {
+    /** Override "now" for deterministic tests. */
+    now?: Date;
+    /** Settings (timezone) used when resolving relative dates. */
+    settings?: Settings;
+}
 export interface ParseResult {
     ast: AST;
     warnings: Warning[];
 }
-export declare function parseTokensInParenGroup(content: string, groupStart: number): ParenGroup;
-export declare function extractParenGroups(line: string, lineStart: number): ParenGroup[];
-export declare function parse(text: string): ParseResult;
+export declare function parseTokensInParenGroup(content: string, groupStart: number, now?: ResolvedNow): ParenGroup;
+export declare function extractParenGroups(line: string, _lineStart: number, now?: ResolvedNow): ParenGroup[];
+export declare function parse(text: string, options?: ParseOptions): ParseResult;