ko-chrono 0.0.0-stage → 0.2.0

package/dist/event.js

@@ -0,0 +1,28 @@
+// 날짜 바로 뒤에 붙은 조사: "3시에", "모레까지는", "주말엔"
+const TRAILING_PARTICLE = /^(?:에는|에도|에|엔|은|는|도|까지는|까지|부터|쯤|께|경)(?=[\s,.!?]|$)/;
+/**
+ * 문장에서 날짜로 인식된 부분과 거기 붙은 조사를 빼서 제목을 만든다 (규칙 28).
+ * 장소("강남역에서")나 동사("만나기")는 그대로 남긴다.
+ */
+export function toEvent(text, results) {
+    let rest = text;
+    // 뒤에서부터 지워야 앞쪽 index가 어긋나지 않는다
+    for (const r of [...results].sort((a, b) => b.index - a.index)) {
+        const after = rest.slice(r.index + r.text.length);
+        const particle = TRAILING_PARTICLE.exec(after)?.[0] ?? '';
+        rest = rest.slice(0, r.index) + ' ' + after.slice(particle.length);
+    }
+    const title = rest
+        .replace(/\s+/g, ' ')
+        .replace(/\s+([,.!?])/g, '$1')
+        .replace(/^[\s,]+|[\s,]+$/g, '');
+    const first = results[0];
+    if (!first)
+        return { title, date: null, hasTime: false };
+    const event = { title, date: first.date, hasTime: first.hasTime };
+    if (first.end)
+        event.end = first.end;
+    if (first.recurrence)
+        event.recurrence = first.recurrence;
+    return event;
+}

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import type { ParseOptions, ParseResult } from './types.js';
+import { type ParsedEvent } from './event.js';
+export type { Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
+export type { ParsedEvent } from './event.js';
+/**
+ * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
+ *
+ * @example
+ * parseAll('내일 10시 아니면 모레 2시');
+ * // → [{ date: 내일 10:00, text: '내일 10시', ... }, { date: 모레 14:00, text: '모레 2시', ... }]
+ *
+ * @example
+ * parseAll('11월 1일부터 11월 3일까지');
+ * // → [{ date: 11-01 00:00, end: 11-03 00:00, ... }]  "A부터 B까지"는 하나의 구간으로 합쳐진다
+ */
+export declare function parseAll(text: string, options?: ParseOptions): ParseResult[];
+/**
+ * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.
+ *
+ * @example
+ * parse('그럼 다음주 수요일 저녁 7시에 강남에서 볼까?');
+ * // → { date: 다음주 수요일 19:00, text: '다음주 수요일 저녁 7시', index: 3, hasTime: true }
+ *
+ * @example
+ * parse('이번달 말까지 보내주세요');
+ * // → { date: 기준 시각, end: 이번달 마지막날 23:59, text: '이번달 말까지', hasTime: false, ... }
+ *
+ * @example
+ * parse('오후 3시', { referenceDate: new Date(2026, 9, 30, 14) });
+ * // → 2026-10-30 15:00 (시간만 있으면 오늘, 이미 지났으면 내일)
+ */
+export declare function parse(text: string, options?: ParseOptions): ParseResult | null;
+/**
+ * parse()의 date만 돌려주는 단축형. 구간이면 시작 시각.
+ *
+ * @example
+ * parseDate('다음주 화요일 오후 3시'); // → Date
+ * parseDate('아무 날짜도 없음');       // → null
+ */
+export declare function parseDate(text: string, options?: ParseOptions): Date | null;
+/**
+ * 할 일·일정 한 줄을 제목과 시점으로 나눈다. 날짜로 인식된 부분과 거기 붙은 조사를 뺀 나머지가 제목.
+ *
+ * @example
+ * parseEvent('다음주 금요일까지 보고서 제출');
+ * // → { title: '보고서 제출', date: 기준 시각, end: 금요일 23:59, hasTime: false }
+ *
+ * @example
+ * parseEvent('매주 월요일 오전 9시 팀 회의');
+ * // → { title: '팀 회의', date: 다음 월요일 09:00, hasTime: true, recurrence: { rrule: 'FREQ=WEEKLY;BYDAY=MO', ... } }
+ *
+ * @example
+ * parseEvent('우유 사기');  // → { title: '우유 사기', date: null, hasTime: false }
+ */
+export declare function parseEvent(text: string, options?: ParseOptions): ParsedEvent;

package/dist/index.js

@@ -0,0 +1,183 @@
+import { relativeDay } from './parsers/relativeDay.js';
+import { offset } from './parsers/offset.js';
+import { weekday } from './parsers/weekday.js';
+import { absoluteDate } from './parsers/absoluteDate.js';
+import { relativeMonth } from './parsers/relativeMonth.js';
+import { relativeYear } from './parsers/relativeYear.js';
+import { time } from './parsers/time.js';
+import { duration } from './parsers/duration.js';
+import { recurrence } from './parsers/recurrence.js';
+import { holiday } from './parsers/holiday.js';
+import { alignEnd, groupFragments, isDayOnly, isTimeOnly, isWeekdayOnly, merge, resolve } from './resolve.js';
+import { fromWallClock, toWallClock } from './util/timezone.js';
+import { toEvent } from './event.js';
+const PARSERS = [relativeDay, offset, weekday, absoluteDate, relativeMonth, relativeYear, time, duration, recurrence, holiday];
+// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다
+const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로)/;
+const FROM = /^\s*(부터|~)\s*/;
+// "이번 주 내내" → 그 기간 전체
+const WHOLE = /^\s*내내/;
+function withDefaults(opts) {
+    return {
+        referenceDate: opts?.referenceDate ?? new Date(),
+        weekStart: opts?.weekStart ?? 'monday',
+        defaultHour: opts?.defaultHour ?? 0,
+    };
+}
+/** 겹치는 조각 제거: 더 긴 것 우선 */
+function dedupe(frags) {
+    const sorted = [...frags].sort((a, b) => b.text.length - a.text.length);
+    const kept = [];
+    for (const f of sorted) {
+        const s = f.index, e = f.index + f.text.length;
+        if (kept.some((k) => s < k.index + k.text.length && e > k.index))
+            continue;
+        kept.push(f);
+    }
+    return kept;
+}
+/**
+ * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
+ *
+ * @example
+ * parseAll('내일 10시 아니면 모레 2시');
+ * // → [{ date: 내일 10:00, text: '내일 10시', ... }, { date: 모레 14:00, text: '모레 2시', ... }]
+ *
+ * @example
+ * parseAll('11월 1일부터 11월 3일까지');
+ * // → [{ date: 11-01 00:00, end: 11-03 00:00, ... }]  "A부터 B까지"는 하나의 구간으로 합쳐진다
+ */
+export function parseAll(text, options) {
+    const opts = withDefaults(options);
+    const timezone = options?.timezone;
+    if (timezone === undefined)
+        return parseLocal(text, opts);
+    // 그 시간대의 벽시계로 계산하고, 결과를 실제 시점으로 되돌린다 (util/timezone.ts)
+    const local = parseLocal(text, { ...opts, referenceDate: toWallClock(opts.referenceDate, timezone) });
+    return local.map((r) => {
+        const out = { ...r, date: fromWallClock(r.date, timezone) };
+        if (r.end)
+            out.end = fromWallClock(r.end, timezone);
+        return out;
+    });
+}
+/** 실행 환경의 로컬 시간대로 계산 */
+function parseLocal(text, opts) {
+    const frags = dedupe(PARSERS.flatMap((p) => p(text)));
+    const groups = groupFragments(frags, text);
+    const results = [];
+    const comps = [];
+    for (const g of groups) {
+        const last = g[g.length - 1];
+        const tail = text.slice(last.index + last.text.length);
+        const until = UNTIL.exec(tail) ?? WHOLE.exec(tail);
+        if (until && until[0].includes('내내'))
+            last.components.whole = true;
+        else if (until)
+            last.components.isEnd = true;
+        if (FROM.test(tail))
+            last.components.isStart = true;
+        const r = resolve(g, opts);
+        if (!r)
+            continue;
+        let end = r._end;
+        if (until)
+            end += until[0].length;
+        delete r._end;
+        // 조각이 공백으로 시작할 수 있다 ("오후 3시" 앞의 공백). index는 첫 글자를 가리키게
+        const raw = text.slice(g[0].index, end);
+        r.index = g[0].index + (raw.length - raw.trimStart().length);
+        r.text = raw.trim();
+        results.push(r);
+        comps.push(merge(g.map((f) => f.components)));
+    }
+    // "A부터 B까지", "A~B" → 하나의 구간으로 합침
+    const merged = [];
+    for (let i = 0; i < results.length; i++) {
+        const a = results[i], b = results[i + 1];
+        const from = FROM.exec(text.slice(a.index + a.text.length));
+        // "~"는 바로 뒤에 B가 붙어 있을 때만. "부터"는 B가 "까지"로 끝나거나,
+        // 바로 뒤에 붙은 B가 시각·일뿐일 때 ("2시부터 4시", "1일부터 3일")
+        const adjacent = b !== undefined && from !== null && b.index === a.index + a.text.length + from[0].length;
+        const tilde = from?.[1] === '~' && adjacent;
+        const bareFrom = from?.[1] === '부터' && adjacent && (isTimeOnly(comps[i + 1]) || isDayOnly(comps[i + 1]));
+        if (b && from && (b.end || tilde || bareFrom)) {
+            const bc = comps[i + 1];
+            let end = b.end ?? b.date;
+            if (isTimeOnly(bc)) {
+                end = alignEnd(a.date, bc);
+            }
+            else {
+                // "11월 1일부터 3일까지": 끝에 일만 있으면 시작의 연월을 이어받는다
+                // ("11월 28일부터 2일까지"처럼 시작보다 이르면 다음 달)
+                if (isDayOnly(bc)) {
+                    const y = a.date.getFullYear(), m0 = a.date.getMonth();
+                    end = new Date(y, m0, bc.day, end.getHours(), end.getMinutes());
+                    if (end < a.date)
+                        end = new Date(y, m0 + 1, bc.day, end.getHours(), end.getMinutes());
+                }
+                // "월요일부터 금요일까지": 끝 요일이 시작보다 앞이면 다음 주
+                if (isWeekdayOnly(bc) && end < a.date)
+                    end.setDate(end.getDate() + 7);
+                if (!b.end && !b.hasTime)
+                    end = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 23, 59);
+            }
+            // "추석 ~ 11월"처럼 끝이 시작보다 앞이면 구간이 아니라 별개 표현
+            if (end < a.date) {
+                merged.push(a);
+                continue;
+            }
+            merged.push({ ...a, end, text: text.slice(a.index, b.index + b.text.length).trim() });
+            i++;
+        }
+        else {
+            merged.push(a);
+        }
+    }
+    return merged;
+}
+/**
+ * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.
+ *
+ * @example
+ * parse('그럼 다음주 수요일 저녁 7시에 강남에서 볼까?');
+ * // → { date: 다음주 수요일 19:00, text: '다음주 수요일 저녁 7시', index: 3, hasTime: true }
+ *
+ * @example
+ * parse('이번달 말까지 보내주세요');
+ * // → { date: 기준 시각, end: 이번달 마지막날 23:59, text: '이번달 말까지', hasTime: false, ... }
+ *
+ * @example
+ * parse('오후 3시', { referenceDate: new Date(2026, 9, 30, 14) });
+ * // → 2026-10-30 15:00 (시간만 있으면 오늘, 이미 지났으면 내일)
+ */
+export function parse(text, options) {
+    return parseAll(text, options)[0] ?? null;
+}
+/**
+ * parse()의 date만 돌려주는 단축형. 구간이면 시작 시각.
+ *
+ * @example
+ * parseDate('다음주 화요일 오후 3시'); // → Date
+ * parseDate('아무 날짜도 없음');       // → null
+ */
+export function parseDate(text, options) {
+    return parse(text, options)?.date ?? null;
+}
+/**
+ * 할 일·일정 한 줄을 제목과 시점으로 나눈다. 날짜로 인식된 부분과 거기 붙은 조사를 뺀 나머지가 제목.
+ *
+ * @example
+ * parseEvent('다음주 금요일까지 보고서 제출');
+ * // → { title: '보고서 제출', date: 기준 시각, end: 금요일 23:59, hasTime: false }
+ *
+ * @example
+ * parseEvent('매주 월요일 오전 9시 팀 회의');
+ * // → { title: '팀 회의', date: 다음 월요일 09:00, hasTime: true, recurrence: { rrule: 'FREQ=WEEKLY;BYDAY=MO', ... } }
+ *
+ * @example
+ * parseEvent('우유 사기');  // → { title: '우유 사기', date: null, hasTime: false }
+ */
+export function parseEvent(text, options) {
+    return toEvent(text, parseAll(text, options));
+}

package/dist/parsers/absoluteDate.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 절대 날짜 표현 */
+export declare const absoluteDate: Parser;

package/dist/parsers/absoluteDate.js

@@ -0,0 +1,91 @@
+import { parseKoreanNumber } from '../util/number.js';
+// 2026년 11월 5일 / 26년 11월 5일 / 11월 5일 / 11/5 / 2026-11-05 / 26.11.5 / 11.5(월일로 해석)
+const FULL = /(?:(?<!\d)(\d{4}|\d{2})\s*년\s*)?(\d{1,2})\s*월\s*(\d{1,2})\s*일(?!간|\s*동안)/g;
+// "2027-01-01T09:00" (ISO 8601 날짜+시각)
+const ISO = /(?<![\d/.-])(\d{4}|\d{2})[-./]\s*(\d{1,2})[-./]\s*(\d{1,2})(?!\d)(?:T(\d{2}):(\d{2}))?/g;
+const SLASH = /(?<![\d/.-])(\d{1,2})\s*[/.]\s*(\d{1,2})(?![\d/.:])/g;
+// "십일월 오일", "유월 이십오일" (오탐 방지를 위해 월과 일이 모두 있을 때만)
+const HANGUL = /(?<![가-힣])(유|시|[일이삼사오육칠팔구십]{1,2})월\s*([일이삼사오육칠팔구십]{1,3})일(?!요일)/g;
+const HANGUL_MONTH = { 유: 6, 시: 10 };
+// "2027년" 단독 (월이 뒤따르지 않을 때). "26년"은 "26년 동안" 오탐이 있어 4자리만
+const YEAR_ONLY = /(?<!\d)((?:19|20)\d{2})\s*년(?!\s*\d{1,2}\s*월)/g;
+// "11월" 단독, "5일" 단독
+const MONTH_ONLY = /(?<![\d가-힣])(\d{1,2})\s*월(?!\s*\d{1,2}\s*일|생|세)/g;
+// "5일간", "3일 동안", "3박 4일"은 기간이지 날짜가 아니다
+const DAY_ONLY = /(?<!\d)(?<!\d\s*박\s*)(\d{1,2})\s*일(?!요일|간|장|째|차|분|\s*동안|\s*연속)/g;
+/** 두 자리 연도 확장: 00~69 → 20xx, 70~99 → 19xx */
+const expandYear = (y) => {
+    const n = +y;
+    if (y.length !== 2)
+        return n;
+    return n < 70 ? 2000 + n : 1900 + n;
+};
+/** 절대 날짜 표현 */
+export const absoluteDate = (text) => {
+    const out = [];
+    const taken = [];
+    const take = (i, len) => {
+        if (taken.some(([s, e]) => i < e && i + len > s))
+            return false;
+        taken.push([i, i + len]);
+        return true;
+    };
+    for (const m of text.matchAll(ISO)) {
+        const month = +m[2], day = +m[3];
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            continue;
+        if (!take(m.index, m[0].length))
+            continue;
+        const c = { year: expandYear(m[1]), month, day };
+        if (m[4] && +m[4] < 24 && +m[5] < 60)
+            Object.assign(c, { hour: +m[4], minute: +m[5], meridiem: true });
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    for (const m of text.matchAll(FULL)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        const c = { month: +m[2], day: +m[3] };
+        if (m[1])
+            c.year = expandYear(m[1]);
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    for (const m of text.matchAll(HANGUL)) {
+        const month = HANGUL_MONTH[m[1]] ?? parseKoreanNumber(m[1]);
+        const day = parseKoreanNumber(m[2]);
+        if (month == null || day == null || month < 1 || month > 12 || day < 1 || day > 31)
+            continue;
+        if (!take(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { month, day } });
+    }
+    for (const m of text.matchAll(SLASH)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        const month = +m[1], day = +m[2];
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { month, day } });
+    }
+    for (const m of text.matchAll(YEAR_ONLY)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { year: +m[1] } });
+    }
+    for (const m of text.matchAll(MONTH_ONLY)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        const month = +m[1];
+        if (month < 1 || month > 12)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { month } });
+    }
+    for (const m of text.matchAll(DAY_ONLY)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        const day = +m[1];
+        if (day < 1 || day > 31)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { day } });
+    }
+    return out;
+};

package/dist/parsers/duration.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 기간 표현. 날짜를 계산하지 않고 길이만 뽑는다. "A부터 N일간"으로 쓰일 때 resolve가 end를 만든다. */
+export declare const duration: Parser;

package/dist/parsers/duration.js

@@ -0,0 +1,41 @@
+import { parseKoreanNumber } from '../util/number.js';
+// "3일간", "일주일 동안", "2주간", "한 달간", "2시간 동안", "90분간", "이틀간"
+const RE = /(?:(\d+|[일이삼사오육칠팔구십한두세네다섯여섯일곱여덟아홉열]+)\s*(일|주|주일|달|개월|시간|분)|(보름|열흘|이틀|사흘|나흘|닷새|엿새|이레|여드레|아흐레))\s*(간|동안)/g;
+// "3박 4일" → 4일
+const NIGHTS = /(\d+)\s*박\s*(\d+)\s*일/g;
+/** 기간 표현. 날짜를 계산하지 않고 길이만 뽑는다. "A부터 N일간"으로 쓰일 때 resolve가 end를 만든다. */
+export const duration = (text) => {
+    const out = [];
+    for (const m of text.matchAll(NIGHTS)) {
+        if (+m[2] === 0)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { durationDays: +m[2] } });
+    }
+    for (const m of text.matchAll(RE)) {
+        const n = parseKoreanNumber(m[3] ?? m[1]);
+        if (!n)
+            continue; // "0일간"은 기간이 아니다
+        const c = {};
+        switch (m[3] ? '일' : m[2]) {
+            case '일':
+                c.durationDays = n;
+                break;
+            case '주':
+            case '주일':
+                c.durationDays = n * 7;
+                break;
+            case '달':
+            case '개월':
+                c.durationMonths = n;
+                break;
+            case '시간':
+                c.durationMinutes = n * 60;
+                break;
+            case '분':
+                c.durationMinutes = n;
+                break;
+        }
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    return out;
+};

package/dist/parsers/holiday.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 공휴일·기념일·명절. 음력 명절의 양력 날짜는 resolve가 표에서 찾는다 */
+export declare const holiday: Parser;

package/dist/parsers/holiday.js

@@ -0,0 +1,60 @@
+// 양력 고정 공휴일·기념일 → [월, 일]. 여러 단어는 띄어쓰기를 생략해도 된다
+const FIXED = {
+    '크리스마스 이브': [12, 24],
+    크리스마스: [12, 25],
+    성탄절: [12, 25],
+    신정: [1, 1],
+    삼일절: [3, 1],
+    '근로자의 날': [5, 1],
+    노동절: [5, 1],
+    어린이날: [5, 5],
+    어버이날: [5, 8],
+    '스승의 날': [5, 15],
+    현충일: [6, 6],
+    제헌절: [7, 17],
+    광복절: [8, 15],
+    개천절: [10, 3],
+    한글날: [10, 9],
+    할로윈: [10, 31],
+    핼러윈: [10, 31],
+    빼빼로데이: [11, 11],
+    발렌타인데이: [2, 14],
+    밸런타인데이: [2, 14],
+    화이트데이: [3, 14],
+};
+const SHIFT = { 전날: -1, 다음날: 1, 이튿날: 1, 당일: 0 };
+const MODIFIER = '(?:\\s*(전날|다음\\s*날|이튿날|당일))?';
+// "크리스마스", "광복절 전날", "스승의날"
+const FIXED_RE = new RegExp(`(${Object.keys(FIXED).map((k) => k.replace(/ /g, '\\s*')).join('|')})${MODIFIER}`, 'g');
+// "설날", "구정", "설 연휴", "추석 전날", "한가위", "부처님 오신 날". "설"만은 "설명", "설거지"와 겹쳐서 뒤에 연휴·전날 등이 올 때만
+const LUNAR_RE = /(설날|구정|설(?=\s*(?:연휴|전날|다음\s*날|당일))|추석|한가위|부처님\s*오신\s*날|석가\s*탄신일|석탄일|초파일)(?:\s*(연휴))?(?:\s*(전날|다음\s*날|이튿날|당일))?/g;
+const fixedKey = (name) => Object.keys(FIXED).find((k) => k.replace(/ /g, '') === name.replace(/\s/g, ''));
+const shiftOf = (m) => (m ? SHIFT[m.replace(/\s/g, '')] : 0);
+/** 공휴일·기념일·명절. 음력 명절의 양력 날짜는 resolve가 표에서 찾는다 */
+export const holiday = (text) => {
+    const out = [];
+    for (const m of text.matchAll(FIXED_RE)) {
+        const [month, day] = FIXED[fixedKey(m[1])];
+        const c = { month, day };
+        const shift = shiftOf(m[2]);
+        if (shift)
+            c.dayOffset = shift;
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    for (const m of text.matchAll(LUNAR_RE)) {
+        const name = m[1].replace(/\s/g, '');
+        const lunar = name === '설날' || name === '구정' || name === '설' ? 'seollal'
+            : name === '추석' || name === '한가위' ? 'chuseok' : 'buddha';
+        const c = { lunar };
+        // "설 연휴", "추석 연휴" = 전날부터 다음날까지 3일 (부처님 오신 날은 연휴가 없다)
+        if (m[2] && lunar !== 'buddha')
+            Object.assign(c, { dayOffset: -1, durationDays: 3 });
+        else {
+            const shift = shiftOf(m[3]);
+            if (shift)
+                c.dayOffset = shift;
+        }
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    return out;
+};

package/dist/parsers/offset.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** "N일 뒤 / N주 후 / N달 전 / N시간 뒤 / N분 후" */
+export declare const offset: Parser;

package/dist/parsers/offset.js

@@ -0,0 +1,60 @@
+import { parseKoreanNumber } from '../util/number.js';
+// "3일 뒤", "2주 후", "한 달 전", "세 시간 뒤", "30분 후", "열흘 뒤", "이틀 뒤", "1년 뒤", "30분 내로", "30분쯤 뒤"
+const RE = /(?:(\d+|[일이삼사오육칠팔구십한두세네다섯여섯일곱여덟아홉열]+)\s*(일|주|주일|달|개월|년|시간|분)|(보름|열흘|이틀|사흘|나흘|닷새|엿새|이레|여드레|아흐레))\s*(?:쯤|정도)?\s*(뒤|후|전|이내|안에|안으로|내로|이후)/g;
+// "한 시간 반 뒤", "1시간 30분 후", "2시간반 전"
+const HOUR_MIN = /(\d+|[일이삼사오육칠팔구십한두세네다섯여섯일곱여덟아홉열]+)\s*시간\s*(?:(반)|(\d+)\s*분)\s*(?:쯤|정도)?\s*(뒤|후|전|이내|안에|이후)/g;
+/** "N일 뒤 / N주 후 / N달 전 / N시간 뒤 / N분 후" */
+export const offset = (text) => {
+    const out = [];
+    const taken = [];
+    for (const m of text.matchAll(HOUR_MIN)) {
+        const h = parseKoreanNumber(m[1]);
+        if (h == null)
+            continue;
+        const sign = m[4] === '전' ? -1 : 1;
+        const c = { hourOffset: sign * h, minuteOffset: sign * (m[2] ? 30 : +m[3]) };
+        if (m[4] === '이내' || m[4] === '안에')
+            c.isEnd = true;
+        out.push({ text: m[0], index: m.index, components: c });
+        taken.push([m.index, m.index + m[0].length]);
+    }
+    for (const m of text.matchAll(RE)) {
+        if (taken.some(([s, e]) => m.index < e && m.index + m[0].length > s))
+            continue;
+        const n = parseKoreanNumber(m[3] ?? m[1]);
+        if (n == null)
+            continue;
+        const sign = m[4] === '전' ? -1 : 1;
+        const c = {};
+        switch (m[3] ? '일' : m[2]) {
+            case '일':
+                c.dayOffset = sign * n;
+                break;
+            case '주':
+            case '주일':
+                c.dayOffset = sign * n * 7;
+                break;
+            case '달':
+            case '개월':
+                c.monthOffset = sign * n;
+                break;
+            case '년':
+                // "2028년 후"는 "2028년 뒤"가 아니라 "2028년 이후"일 가능성이 크다. 100년 넘게는 상대 이동으로 보지 않는다
+                if (n > 100)
+                    continue;
+                c.yearOffset = sign * n;
+                c.sameDay = true;
+                break;
+            case '시간':
+                c.hourOffset = sign * n;
+                break;
+            case '분':
+                c.minuteOffset = sign * n;
+                break;
+        }
+        if (['이내', '안에', '안으로', '내로'].includes(m[4]))
+            c.isEnd = true;
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    return out;
+};

package/dist/parsers/recurrence.d.ts

@@ -0,0 +1,5 @@
+import type { Parser, Recurrence } from '../types.js';
+/** 반복 일정. 날짜는 계산하지 않고 규칙만 뽑는다 (첫 발생일은 resolve가 계산) */
+export declare const recurrence: Parser;
+/** RFC 5545 RRULE 문자열. 요일은 월요일부터 */
+export declare function toRRule(r: Omit<Recurrence, 'rrule'>): string;

package/dist/parsers/recurrence.js

@@ -0,0 +1,112 @@
+import { parseKoreanNumber } from '../util/number.js';
+const WEEKDAY = { 일: 0, 월: 1, 화: 2, 수: 3, 목: 4, 금: 5, 토: 6 };
+const NTH = { 첫째: 1, 첫: 1, 둘째: 2, 셋째: 3, 넷째: 4, 마지막: -1 };
+const SETS = { 평일: [1, 2, 3, 4, 5], 주중: [1, 2, 3, 4, 5], 주말: [6, 0] };
+// 요일 목록 "월수금", "화, 목", "월요일이랑 수요일", "월~금". 목록이 끝난 뒤에는 다른 한글이 붙으면 안 된다
+// ("매주 일요일 일정"의 "일"을 요일로 잡지 않게). 조사·마다는 허용
+const ITEM = '[월화수목금토일](?:요일|욜)?(?:\\s*~\\s*[월화수목금토일](?:요일|욜)?)?';
+const LIST = `${ITEM}(?:\\s*(?:,|·|/|이랑|랑|하고|과|와)?\\s*${ITEM})*`;
+const LIST_END = '(?:(?![가-힣])|(?=마다|에|엔|은|는|도))';
+// "매달 첫째 주 월요일", "매월 마지막 주 금요일"
+const MONTHLY_NTH = /(?:매달|매월|매\s*달)\s*(첫째|첫|둘째|셋째|넷째|마지막)\s*주\s*([월화수목금토일])(?:요일|욜)/g;
+// "매달 15일", "매월 말일", "매달 말", "매달 초"
+const MONTHLY_DAY = /(?:매달|매월|매\s*달|다달이)\s*(?:(\d{1,2})\s*일|(말일|마지막\s*날|말)|(초))/g;
+// "매년 3월 1일", "해마다 12월 25일"
+const YEARLY = /(?:매년|매해|해마다)\s*(\d{1,2})\s*월\s*(\d{1,2})\s*일/g;
+// "매주 평일", "평일마다", "주말마다", "평일 매일"
+const WEEKDAY_SET = /매주\s*(평일|주중|주말)|(?<![가-힣])(평일|주중|주말)\s*(?:마다|매일)/g;
+// "매주 월요일", "매주 월수금", "격주 금요일", "2주마다 수요일", "2주에 한 번 화요일"
+const WEEKLY = new RegExp(`(매주|매\\s*주|격주|(\\d{1,2}|두|세|네)\\s*주\\s*(?:마다|에\\s*한\\s*번))\\s*(${LIST})${LIST_END}(?:\\s*마다)?`, 'g');
+// "월요일마다", "화요일이랑 목요일마다"
+const DAYS_EVERY = /(?<![가-힣])([월화수목금토일](?:요일|욜)(?:\s*(?:,|·|이랑|랑|하고|과|와)?\s*[월화수목금토일](?:요일|욜))*)\s*마다/g;
+// "매일", "날마다", "매일매일"
+const DAILY = /(?<![가-힣])(?:매일매일|매일|날마다)/g;
+// "2시간마다", "30분마다", "매시간"
+const HOURLY = /(?<![가-힣\d])(?:(\d{1,2}|한|두|세|네|다섯|여섯)\s*시간\s*마다|매\s*시간)/g;
+const MINUTELY = /(?<!\d)(\d{1,3})\s*분\s*마다/g;
+/** "월수금", "화, 목요일", "월~금" → 요일 번호들. "요일" 안의 "일"은 일요일이 아니다 */
+function weekdaysOf(list) {
+    const out = [];
+    const plain = list.replace(/요일|욜/g, '');
+    // "월~금" → 월화수목금 (월요일부터 센다, "금~일"은 금토일)
+    for (const m of plain.matchAll(/([월화수목금토일])\s*~\s*([월화수목금토일])|([월화수목금토일])/g)) {
+        if (m[3]) {
+            out.push(WEEKDAY[m[3]]);
+            continue;
+        }
+        const from = (WEEKDAY[m[1]] + 6) % 7, to = (WEEKDAY[m[2]] + 6) % 7;
+        for (let i = from; i !== (to + 1) % 7; i = (i + 1) % 7)
+            out.push((i + 1) % 7);
+    }
+    return [...new Set(out)];
+}
+/** 반복 일정. 날짜는 계산하지 않고 규칙만 뽑는다 (첫 발생일은 resolve가 계산) */
+export const recurrence = (text) => {
+    const out = [];
+    const taken = [];
+    const push = (m, recur) => {
+        const s = m.index, e = s + m[0].length;
+        if (taken.some(([a, b]) => s < b && e > a))
+            return;
+        taken.push([s, e]);
+        out.push({ text: m[0], index: s, components: { recur } });
+    };
+    for (const m of text.matchAll(MONTHLY_NTH)) {
+        push(m, { freq: 'MONTHLY', interval: 1, byWeekday: [WEEKDAY[m[2]]], byWeekdayNth: NTH[m[1]] });
+    }
+    for (const m of text.matchAll(MONTHLY_DAY)) {
+        const day = m[1] ? +m[1] : m[2] ? -1 : 1;
+        if (day === 0 || day > 31)
+            continue;
+        push(m, { freq: 'MONTHLY', interval: 1, byMonthDay: day });
+    }
+    for (const m of text.matchAll(YEARLY)) {
+        const month = +m[1], day = +m[2];
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            continue;
+        push(m, { freq: 'YEARLY', interval: 1, byMonth: month, byMonthDay: day });
+    }
+    for (const m of text.matchAll(WEEKDAY_SET)) {
+        push(m, { freq: 'WEEKLY', interval: 1, byWeekday: SETS[m[1] ?? m[2]] });
+    }
+    for (const m of text.matchAll(WEEKLY)) {
+        const n = m[1].startsWith('격주') ? 2 : m[2] ? parseKoreanNumber(m[2]) : 1;
+        if (!n)
+            continue;
+        push(m, { freq: 'WEEKLY', interval: n, byWeekday: weekdaysOf(m[3]) });
+    }
+    for (const m of text.matchAll(DAYS_EVERY)) {
+        push(m, { freq: 'WEEKLY', interval: 1, byWeekday: weekdaysOf(m[1]) });
+    }
+    for (const m of text.matchAll(DAILY)) {
+        push(m, { freq: 'DAILY', interval: 1 });
+    }
+    for (const m of text.matchAll(HOURLY)) {
+        const n = m[1] ? parseKoreanNumber(m[1]) : 1;
+        if (!n)
+            continue;
+        push(m, { freq: 'HOURLY', interval: n });
+    }
+    for (const m of text.matchAll(MINUTELY)) {
+        if (+m[1] === 0)
+            continue;
+        push(m, { freq: 'MINUTELY', interval: +m[1] });
+    }
+    return out;
+};
+const CODE = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+/** RFC 5545 RRULE 문자열. 요일은 월요일부터 */
+export function toRRule(r) {
+    const parts = [`FREQ=${r.freq}`];
+    if (r.interval > 1)
+        parts.push(`INTERVAL=${r.interval}`);
+    if (r.byMonth !== undefined)
+        parts.push(`BYMONTH=${r.byMonth}`);
+    if (r.byMonthDay !== undefined)
+        parts.push(`BYMONTHDAY=${r.byMonthDay}`);
+    if (r.byWeekday?.length) {
+        const days = [...r.byWeekday].sort((a, b) => ((a + 6) % 7) - ((b + 6) % 7)).map((d) => CODE[d]);
+        parts.push(`BYDAY=${days.map((c) => (r.byWeekdayNth ? `${r.byWeekdayNth}${c}` : c)).join(',')}`);
+    }
+    return parts.join(';');
+}