ko-chrono 0.1.0 → 0.3.0

package/dist/cjs/util/number.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKoreanNumber = parseKoreanNumber;
+const NATIVE = {
+    한: 1, 하나: 1, 두: 2, 둘: 2, 세: 3, 셋: 3, 네: 4, 넷: 4,
+    다섯: 5, 여섯: 6, 일곱: 7, 여덟: 8, 아홉: 9, 열: 10,
+    열흘: 10, 보름: 15, 스무: 20, 스물: 20,
+    이틀: 2, 사흘: 3, 나흘: 4, 닷새: 5, 엿새: 6, 이레: 7, 여드레: 8, 아흐레: 9,
+};
+const SINO = {
+    일: 1, 이: 2, 삼: 3, 사: 4, 오: 5, 육: 6, 칠: 7, 팔: 8, 구: 9, 십: 10,
+};
+/**
+ * "3", "세", "열", "십이", "열두" → number. 실패 시 null.
+ * v0.1: 1~99 범위만 다룬다.
+ */
+function parseKoreanNumber(s) {
+    if (/^\d+$/.test(s))
+        return parseInt(s, 10);
+    if (s in NATIVE)
+        return NATIVE[s];
+    // 고유어 합성: 열두, 열다섯, 스무 ...
+    for (const tens of ['스물', '스무', '열']) {
+        if (s.startsWith(tens) && s.length > tens.length) {
+            const rest = NATIVE[s.slice(tens.length)];
+            if (rest != null)
+                return NATIVE[tens] + rest;
+        }
+    }
+    // 한자어: 십, 십이, 이십, 이십삼
+    if (/^[일이삼사오육칠팔구십]+$/.test(s)) {
+        const parts = s.split('십');
+        if (parts.length === 1)
+            return SINO[s] ?? null;
+        const tens = parts[0] === '' ? 1 : SINO[parts[0]];
+        const ones = parts[1] === '' ? 0 : SINO[parts[1]];
+        if (tens == null || ones == null)
+            return null;
+        return tens * 10 + ones;
+    }
+    return null;
+}

package/dist/cjs/util/timezone.d.ts

@@ -0,0 +1,4 @@
+/** 실제 시점 → 그 시간대의 벽시계 시각을 로컬 필드로 갖는 Date */
+export declare function toWallClock(instant: Date, timeZone: string): Date;
+/** 로컬 필드를 그 시간대의 벽시계 시각으로 보고 → 실제 시점 */
+export declare function fromWallClock(wall: Date, timeZone: string): Date;

package/dist/cjs/util/timezone.js

@@ -0,0 +1,55 @@
+"use strict";
+// IANA 시간대 변환. 런타임 의존성 없이 Intl만 쓴다.
+//
+// resolve.ts는 Date의 로컬 getter/setter로 계산한다. timezone 옵션이 있으면
+// 기준 시각을 그 시간대의 벽시계 시각(로컬 필드가 같은 Date)으로 바꿔 계산하고,
+// 결과의 벽시계 시각을 다시 실제 시점으로 되돌린다.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWallClock = toWallClock;
+exports.fromWallClock = fromWallClock;
+const formatters = new Map();
+function formatter(timeZone) {
+    let f = formatters.get(timeZone);
+    if (!f) {
+        // 없는 시간대면 여기서 RangeError
+        f = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+        });
+        formatters.set(timeZone, f);
+    }
+    return f;
+}
+/** 시점 t에서 그 시간대의 벽시계 필드 */
+function fieldsAt(t, timeZone) {
+    const parts = {};
+    for (const p of formatter(timeZone).formatToParts(new Date(t))) {
+        if (p.type !== 'literal')
+            parts[p.type] = +p.value;
+    }
+    return [parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second];
+}
+/** 시점 t에서 그 시간대의 UTC 오프셋(ms). 서울 = +9h */
+function offsetAt(t, timeZone) {
+    const [y, m0, d, h, mi, s] = fieldsAt(t, timeZone);
+    return Date.UTC(y, m0, d, h, mi, s) - (t - (t % 1000));
+}
+/** 실제 시점 → 그 시간대의 벽시계 시각을 로컬 필드로 갖는 Date */
+function toWallClock(instant, timeZone) {
+    const [y, m0, d, h, mi, s] = fieldsAt(instant.getTime(), timeZone);
+    return new Date(y, m0, d, h, mi, s, instant.getMilliseconds());
+}
+/** 로컬 필드를 그 시간대의 벽시계 시각으로 보고 → 실제 시점 */
+function fromWallClock(wall, timeZone) {
+    const asUtc = Date.UTC(wall.getFullYear(), wall.getMonth(), wall.getDate(), wall.getHours(), wall.getMinutes(), wall.getSeconds(), wall.getMilliseconds());
+    // 오프셋은 시점에 따라 달라지므로(서머타임) 한 번 더 맞춘다
+    const first = offsetAt(asUtc, timeZone);
+    const second = offsetAt(asUtc - first, timeZone);
+    return new Date(asUtc - second);
+}

package/dist/event.d.ts

@@ -0,0 +1,20 @@
+import type { Ambiguity, ParseResult, Recurrence } from './types.js';
+/** parseEvent()의 결과: 할 일·일정 한 줄을 제목과 시점으로 나눈 것 */
+export interface ParsedEvent {
+    /** 날짜 부분을 뺀 나머지 ("내일 3시 치과" → "치과"). 없으면 '' */
+    title: string;
+    /** 첫 번째 날짜 표현의 date. 날짜가 없으면 null */
+    date: Date | null;
+    /** 구간의 끝이나 마감 */
+    end?: Date;
+    hasTime: boolean;
+    /** 반복 일정이면 그 규칙 */
+    recurrence?: Recurrence;
+    /** 해석이 갈릴 수 있으면 그 이유와 다른 후보 ("3시" → 15시, 후보 3시) */
+    ambiguity?: Ambiguity;
+}
+/**
+ * 문장에서 날짜로 인식된 부분과 거기 붙은 조사를 빼서 제목을 만든다 (규칙 28).
+ * 장소("강남역에서")나 동사("만나기")는 그대로 남긴다.
+ */
+export declare function toEvent(text: string, results: ParseResult[]): ParsedEvent;

package/dist/event.js

@@ -0,0 +1,30 @@
+// 날짜 바로 뒤에 붙은 조사: "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;
+    if (first.ambiguity)
+        event.ambiguity = first.ambiguity;
+    return event;
+}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import type { ParseOptions, ParseResult } from './types.js';
-export type { ParseOptions, ParseResult, WeekStart } from './types.js';
+import { type ParsedEvent } from './event.js';
+export type { Ambiguity, Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
+export type { ParsedEvent } from './event.js';
 /**
  * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
  *
@@ -36,3 +38,18 @@ export declare function parse(text: string, options?: ParseOptions): ParseResult
  * 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

@@ -6,8 +6,12 @@ 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';
-const PARSERS = [relativeDay, offset, weekday, absoluteDate, relativeMonth, relativeYear, time, duration];
+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*/;
@@ -45,6 +49,23 @@ function dedupe(frags) {
  */
 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);
+        if (r.ambiguity) {
+            out.ambiguity = { ...r.ambiguity, alternatives: r.ambiguity.alternatives.map((a) => fromWallClock(a, timezone)) };
+        }
+        return out;
+    });
+}
+/** 실행 환경의 로컬 시간대로 계산 */
+function parseLocal(text, opts) {
     const frags = dedupe(PARSERS.flatMap((p) => p(text)));
     const groups = groupFragments(frags, text);
     const results = [];
@@ -66,8 +87,10 @@ export function parseAll(text, options) {
         if (until)
             end += until[0].length;
         delete r._end;
-        r.index = g[0].index;
-        r.text = text.slice(g[0].index, end).trim();
+        // 조각이 공백으로 시작할 수 있다 ("오후 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)));
     }
@@ -76,9 +99,12 @@ export function parseAll(text, options) {
     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가 "까지"로 끝날 때만
-        const tilde = from?.[1] === '~' && b?.index === a.index + a.text.length + from[0].length;
-        if (b && from && (b.end || tilde)) {
+        // "~"는 바로 뒤에 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)) {
@@ -99,6 +125,11 @@ export function parseAll(text, options) {
                 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++;
         }
@@ -136,3 +167,20 @@ export function parse(text, options) {
 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.js

@@ -1,7 +1,8 @@
 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;
-const ISO = /(?<![\d/.-])(\d{4}|\d{2})[-./]\s*(\d{1,2})[-./]\s*(\d{1,2})(?!\d)/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;
@@ -35,7 +36,10 @@ export const absoluteDate = (text) => {
             continue;
         if (!take(m.index, m[0].length))
             continue;
-        out.push({ text: m[0], index: m.index, components: { year: expandYear(m[1]), month, day } });
+        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))

package/dist/parsers/duration.js

@@ -7,12 +7,14 @@ const NIGHTS = /(\d+)\s*박\s*(\d+)\s*일/g;
 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 == null)
-            continue;
+        if (!n)
+            continue; // "0일간"은 기간이 아니다
         const c = {};
         switch (m[3] ? '일' : m[2]) {
             case '일':

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,68 @@
+// 양력 고정 공휴일·기념일 → [월, 일]. 여러 단어는 띄어쓰기를 생략해도 된다
+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;
+// "음력 3월 3일", "음력 윤5월 1일" (음력이라고 말한 경우만)
+const LUNAR_DATE_RE = /음력\s*(윤\s*)?(\d{1,2})\s*월\s*(\d{1,2})\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_DATE_RE)) {
+        const month = +m[2], day = +m[3];
+        if (month < 1 || month > 12 || day < 1 || day > 30)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { lunarDate: { month, day, leap: !!m[1] } } });
+    }
+    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.js

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

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(';');
+}

package/dist/parsers/time.js

@@ -4,7 +4,7 @@ const CLOCK = /(오전|오후|새벽|아침|저녁|밤|낮|정오)?\s*(\d{1,2}|
 // "5시 10분 전" → 4:50
 const BEFORE = /(오전|오후|새벽|아침|저녁|밤|낮)?\s*(\d{1,2}|한|두|세|네|다섯|여섯|일곱|여덟|아홉|열|열한|열두)\s*시\s*(\d{1,2})\s*분\s*전(?=[\s,에까]|$)/g;
 // "오전 중으로", "오후 중에" → 그 시간대의 끝(12시/18시)까지
-const HALF_DAY = /(오전|오후)\s*중(?:으로|에는|에)?/g;
+const HALF_DAY = /(오전|오후)\s*중(?!순)(?:으로|에는|에)?/g;
 // "3pm", "9 AM", "12pm"
 const AMPM = /(?<![\d:])(\d{1,2})(?::(\d{2}))?\s*([ap])\.?m\.?(?![a-z])/gi;
 // "3~5시", "오후 3~5시" → "오후 3" + "5시" 두 조각 (index.ts가 "~"로 구간을 합친다)
@@ -13,7 +13,14 @@ const SHORT_RANGE = /(오전|오후|새벽|아침|저녁|밤|낮)?\s*(\d{1,2}|
 const COLON = /(?:(오전|오후|새벽|아침|저녁|밤|낮)\s*)?(?<!\d)(\d{1,2}):(\d{2})(?!\d)/g;
 // 단독 시간 단어. "낮"은 "낮다"와 겹쳐서 뒤에 공백/조사가 올 때만
 const WORD = /(정오|자정|점심|아침|저녁|밤(?!새|낮)|퇴근|낮(?=[\s에,]|$))(?!\s*\d)/g;
-const WORD_HOUR = { 정오: 12, 자정: 0, 점심: 12, 아침: 8, 저녁: 19, 밤: 21, 퇴근: 18, 낮: 12 };
+// "내일 오후", "오전에" → 9시/15시 (규칙 25). 뒤에 조사·공백·끝만 허용하고,
+// "오전반", "오후 반차", "오전오후"처럼 다른 낱말이 붙으면 잡지 않는다
+const HALF_WORD = /(?<![가-힣])(오전|오후)(?=(?:에는|에|엔|은|는|도|쯤|께)?(?:[\s,.!?~]|$))(?!\s*(?:반|오전|오후|\d))/g;
+const WORD_HOUR = {
+    정오: 12, 자정: 0, 점심: 12, 아침: 8, 저녁: 19, 밤: 21, 퇴근: 18, 낮: 12, 오전: 9, 오후: 15,
+};
+// "내일 이 시간", "다음 주 이 시간" → 기준 시각의 시:분. "같이 시간 내자"는 잡지 않는다
+const SAME_TIME = /(?<![가-힣])이\s*시간(?!대|\s*(?:뒤|후|전|동안|이내|안에))/g;
 function applyMeridiem(prefix, hour) {
     if (hour === 24)
         return 0;
@@ -116,12 +123,25 @@ export const time = (text) => {
         const hour = applyMeridiem(m[1], raw);
         out.push({ text: m[0], index: m.index, components: { hour, minute, meridiem: true } });
     }
+    for (const m of text.matchAll(SAME_TIME)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { sameTime: true } });
+    }
+    for (const m of text.matchAll(HALF_WORD)) {
+        if (!take(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true, approximate: true } });
+    }
     for (const m of text.matchAll(WORD)) {
         if (!take(m.index, m[0].length))
             continue;
         const c = { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true };
         if (m[1] === '자정')
             c.midnight = true;
+        // 정오·자정은 정확한 시각, 나머지(아침·저녁·밤·점심·낮·퇴근)는 관례
+        else if (m[1] !== '정오')
+            c.approximate = true;
         out.push({ text: m[0], index: m.index, components: c });
     }
     return out;

package/dist/parsers/weekday.js

@@ -1,3 +1,4 @@
+import { parseKoreanNumber } from '../util/number.js';
 const WEEKDAY = { 일: 0, 월: 1, 화: 2, 수: 3, 목: 4, 금: 5, 토: 6 };
 const WEEK_WORDS = {
     지지난: -2, 저저번: -2, 지난: -1, 저번: -1, 이번: 0, 다음: 1, 다다음: 2, 다담: 2, 담: 1,
@@ -14,6 +15,8 @@ const PAREN = new RegExp(`\\((${DAY})\\)`, 'g');
 // 요일 글자만 쓸 때("첫째 주 월")는 뒤에 한글이 없어야 한다 ("둘째 주 일정"의 "일"은 요일이 아님)
 const NTH = new RegExp(`(?:(\\d{1,2})\\s*월\\s*)?(첫째|첫|둘째|셋째|넷째|다섯째|마지막)\\s*주(?:\\s*(${DAY})(?:요일|욜|(?![가-힣])))?`, 'g');
 const NTH_NUM = { 첫째: 1, 첫: 1, 둘째: 2, 셋째: 3, 넷째: 4, 다섯째: 5, 마지막: -1 };
+// "2주 뒤 월요일", "3주 후 금요일" → N주 뒤의 그 주의 X요일 ("다다음주 월요일"과 같은 계산)
+const WEEKS_LATER = new RegExp(`(\\d{1,2}|한|두|세|네|다섯)\\s*주\\s*(?:뒤|후)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "지난 금요일" = 오늘 제외 가장 가까운 과거, "다음 금요일" = 오늘 제외 가장 가까운 미래
 const DIR = new RegExp(`(지난|저번|다음)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "주말에 보자" ("이번 주말"은 위 WEEKEND가 먼저 잡는다)
@@ -29,6 +32,13 @@ export const weekday = (text) => {
     const out = [];
     const taken = [];
     const overlaps = (i, len) => taken.some(([s, e]) => i < e && i + len > s);
+    for (const m of text.matchAll(WEEKS_LATER)) {
+        const n = parseKoreanNumber(m[1]);
+        if (n == null)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { weekOffset: n, weekday: WEEKDAY[m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
     for (const m of text.matchAll(NTH)) {
         const c = { nthWeek: NTH_NUM[m[2]] };
         if (m[1]) {

package/dist/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { Components, Fragment, ParseOptions, ParseResult } from './types.js';
+import type { Components, Fragment, ParseResult, ResolveOptions } from './types.js';
 /**
  * 인접한 조각(fragment)을 하나로 합친다.
  * 예: "다음주 화요일" + "오후 3시" → 하나의 결과.
@@ -18,4 +18,4 @@ export declare function isDayOnly(c: Components): boolean;
  * "오후 3~5시" → 17시, "오후 11시부터 1시까지" → 다음날 1시, "오후 3시부터 오전 1시까지" → 다음날 1시
  */
 export declare function alignEnd(start: Date, end: Components): Date;
-export declare function resolve(group: Fragment[], opts: Required<ParseOptions>): ParseResult | null;
+export declare function resolve(group: Fragment[], opts: ResolveOptions): ParseResult | null;