ko-chrono 0.3.1 → 0.4.0

package/dist/cjs/index.d.ts

@@ -2,6 +2,7 @@ import type { ParseOptions, ParseResult } 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';
+export { toICS, type ICSOptions } from './ics.js';
 /**
  * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
  *

package/dist/cjs/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toICS = void 0;
 exports.parseAll = parseAll;
 exports.parse = parse;
 exports.parseDate = parseDate;
@@ -16,13 +17,22 @@ const recurrence_js_1 = require("./parsers/recurrence.js");
 const holiday_js_1 = require("./parsers/holiday.js");
 const resolve_js_1 = require("./resolve.js");
 const timezone_js_1 = require("./util/timezone.js");
+const number_js_1 = require("./util/number.js");
 const event_js_1 = require("./event.js");
+var ics_js_1 = require("./ics.js");
+Object.defineProperty(exports, "toICS", { enumerable: true, get: function () { return ics_js_1.toICS; } });
 const PARSERS = [relativeDay_js_1.relativeDay, offset_js_1.offset, weekday_js_1.weekday, absoluteDate_js_1.absoluteDate, relativeMonth_js_1.relativeMonth, relativeYear_js_1.relativeYear, time_js_1.time, duration_js_1.duration, recurrence_js_1.recurrence, holiday_js_1.holiday];
-// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다
-const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로)/;
+// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다. "다음주 중", "오늘 중에"도 마감
+const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로|중에(?![가-힣])|중(?![가-힣]))/;
 const FROM = /^\s*(부터|~)\s*/;
 // "이번 주 내내" → 그 기간 전체
 const WHOLE = /^\s*내내/;
+// 반복 일정과 그 앞뒤 날짜 사이 (규칙 34): "다음달까지 매주 월요일", "매주 월요일, 12월 20일까지"
+const GAP = /^[\s,]*$/;
+// "다음주부터 매주 월요일"
+const FROM_GAP = /^\s*부터[\s,]*$/;
+// "총 8회", "10번 반복", "총 열 번". "매일 3번"은 하루 횟수일 수 있어 "총"이나 "반복"이 있을 때만
+const COUNT = /^[\s,]*(?:총\s*(\d{1,3}|[한두세네다섯여섯일곱여덟아홉열스무]+)\s*(?:번|회)(?:\s*반복)?|(\d{1,3}|[한두세네다섯여섯일곱여덟아홉열스무]+)\s*(?:번|회)\s*반복)/;
 function withDefaults(opts) {
     return {
         referenceDate: opts?.referenceDate ?? new Date(),
@@ -64,6 +74,9 @@ function parseAll(text, options) {
         const out = { ...r, date: (0, timezone_js_1.fromWallClock)(r.date, timezone) };
         if (r.end)
             out.end = (0, timezone_js_1.fromWallClock)(r.end, timezone);
+        // rrule의 UNTIL은 벽시계 그대로 두고, Date 값만 실제 시점으로
+        if (r.recurrence?.until)
+            out.recurrence = { ...r.recurrence, until: (0, timezone_js_1.fromWallClock)(r.recurrence.until, timezone) };
         if (r.ambiguity) {
             out.ambiguity = { ...r.ambiguity, alternatives: r.ambiguity.alternatives.map((a) => (0, timezone_js_1.fromWallClock)(a, timezone)) };
         }
@@ -76,6 +89,7 @@ function parseLocal(text, opts) {
     const groups = (0, resolve_js_1.groupFragments)(frags, text);
     const results = [];
     const comps = [];
+    const resultGroups = [];
     for (const g of groups) {
         const last = g[g.length - 1];
         const tail = text.slice(last.index + last.text.length);
@@ -99,10 +113,15 @@ function parseLocal(text, opts) {
         r.text = raw.trim();
         results.push(r);
         comps.push((0, resolve_js_1.merge)(g.map((f) => f.components)));
+        resultGroups.push(g);
     }
     // "A부터 B까지", "A~B" → 하나의 구간으로 합침
     const merged = [];
+    const mergedGroups = [];
+    const mergedComps = [];
     for (let i = 0; i < results.length; i++) {
+        mergedGroups.push(resultGroups[i]);
+        mergedComps.push(comps[i]);
         const a = results[i], b = results[i + 1];
         const from = FROM.exec(text.slice(a.index + a.text.length));
         // "~"는 바로 뒤에 B가 붙어 있을 때만. "부터"는 B가 "까지"로 끝나거나,
@@ -143,7 +162,78 @@ function parseLocal(text, opts) {
             merged.push(a);
         }
     }
-    return merged;
+    return bindRecurrence(text, merged, mergedGroups, mergedComps, opts);
+}
+/**
+ * 반복 일정 앞뒤의 날짜를 시작·끝으로 묶는다 (규칙 34).
+ * - 앞이나 뒤의 마감·구간 ("다음달까지", "11월 1일부터 12월 31일까지") → 그 시작 이후 첫 발생, 끝은 UNTIL
+ * - 앞의 "A부터" → A 이후 첫 발생
+ * - 뒤의 "총 N회", "N번 반복" → COUNT
+ * 끝이 첫 발생보다 앞이면 묶지 않는다 ("어제까지 매주 월요일").
+ */
+function bindRecurrence(text, results, groups, comps, opts) {
+    const out = [];
+    for (let i = 0; i < results.length; i++) {
+        let r = results[i];
+        if (!r.recurrence) {
+            out.push(r);
+            continue;
+        }
+        let from = r.index;
+        let to = r.index + r.text.length;
+        let bound = false;
+        // 시작·끝이 되는 날짜를 적용해 첫 발생을 다시 계산한다
+        // 시각만 있는 마감("5시까지 매일")은 그날 하루의 끝이지 반복의 끝이 아니다
+        const bindTo = (other, j) => {
+            if ((0, resolve_js_1.isTimeOnly)(comps[j]))
+                return false;
+            // 마감("다음달까지")의 date는 기준 시각이라 그대로, 지난 시작("지난주부터")은 기준 시각부터
+            const begin = other.date > opts.referenceDate ? other.date : opts.referenceDate;
+            const again = (0, resolve_js_1.resolve)(groups[i], { ...opts, referenceDate: begin });
+            if (!again?.recurrence)
+                return false;
+            // "N주 동안"은 새 시작부터 다시 센 값(again)을 쓴다
+            const until = again.recurrence.until ?? other.end;
+            if (until && until < again.date)
+                return false;
+            const shift = again.date.getTime() - r.date.getTime();
+            r = { ...r, date: again.date, recurrence: { ...again.recurrence, until } };
+            if (r.end)
+                r.end = new Date(r.end.getTime() + shift);
+            return true;
+        };
+        const prev = out[out.length - 1];
+        const prevIndex = results.indexOf(prev);
+        if (prev && !prev.recurrence) {
+            const gap = text.slice(prev.index + prev.text.length, r.index);
+            if ((prev.end ? GAP : FROM_GAP).test(gap) && bindTo(prev, prevIndex)) {
+                from = prev.index;
+                out.pop();
+                bound = true;
+            }
+        }
+        const next = results[i + 1];
+        if (!r.recurrence.until && next?.end && !next.recurrence && GAP.test(text.slice(to, next.index)) && bindTo(next, i + 1)) {
+            to = next.index + next.text.length;
+            bound = true;
+            i++;
+        }
+        const count = COUNT.exec(text.slice(to));
+        const n = count ? (0, number_js_1.parseKoreanNumber)(count[1] ?? count[2]) : null;
+        if (n && !r.recurrence.until) {
+            r = { ...r, recurrence: { ...r.recurrence, count: n } };
+            to += count[0].length;
+            bound = true;
+        }
+        if (bound) {
+            const rule = r.recurrence;
+            if (rule.until === undefined)
+                delete rule.until;
+            r = { ...r, index: from, text: text.slice(from, to).trim(), recurrence: { ...rule, rrule: (0, recurrence_js_1.toRRule)(rule, !r.hasTime) } };
+        }
+        out.push(r);
+    }
+    return out;
 }
 /**
  * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.

package/dist/cjs/parsers/absoluteDate.js

@@ -14,8 +14,8 @@ const HANGUL_MONTH = { 유: 6, 시: 10 };
 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;
+// "5일간", "3일 동안", "3박 4일"은 기간이지 날짜가 아니다. "주 5일 근무"(횟수), "30일 챌린지"도 아니다
+const DAY_ONLY = /(?<!\d)(?<!\d\s*박\s*)(?<!(?<![가-힣])주\s*)(\d{1,2})\s*일(?!요일|간|장|째|차|분|\s*동안|\s*연속|\s*챌린지)/g;
 /** 두 자리 연도 확장: 00~69 → 20xx, 70~99 → 19xx */
 const expandYear = (y) => {
     const n = +y;

package/dist/cjs/parsers/holiday.js

@@ -7,6 +7,7 @@ const FIXED = {
     크리스마스: [12, 25],
     성탄절: [12, 25],
     신정: [1, 1],
+    '새해 첫날': [1, 1],
     삼일절: [3, 1],
     '근로자의 날': [5, 1],
     노동절: [5, 1],

package/dist/cjs/parsers/offset.js

@@ -39,7 +39,9 @@ const offset = (text) => {
                 break;
             case '달':
             case '개월':
+                // "한 달 뒤" = 다음 달 같은 날 (그 달 1일이 아니라)
                 c.monthOffset = sign * n;
+                c.sameDay = true;
                 break;
             case '년':
                 // "2028년 후"는 "2028년 뒤"가 아니라 "2028년 이후"일 가능성이 크다. 100년 넘게는 상대 이동으로 보지 않는다

package/dist/cjs/parsers/recurrence.d.ts

@@ -1,5 +1,9 @@
 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;
+/**
+ * RFC 5545 RRULE 문자열. 요일은 월요일부터.
+ * UNTIL은 벽시계 시각 그대로 쓴다 (DTSTART가 TZID 또는 floating time일 때의 형식).
+ * dateOnly면 DTSTART가 DATE이므로 UNTIL도 날짜만.
+ */
+export declare function toRRule(r: Omit<Recurrence, 'rrule'>, dateOnly?: boolean): string;

package/dist/cjs/parsers/recurrence.js

@@ -100,8 +100,13 @@ const recurrence = (text) => {
 };
 exports.recurrence = recurrence;
 const CODE = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
-/** RFC 5545 RRULE 문자열. 요일은 월요일부터 */
-function toRRule(r) {
+const pad = (n) => String(n).padStart(2, '0');
+/**
+ * RFC 5545 RRULE 문자열. 요일은 월요일부터.
+ * UNTIL은 벽시계 시각 그대로 쓴다 (DTSTART가 TZID 또는 floating time일 때의 형식).
+ * dateOnly면 DTSTART가 DATE이므로 UNTIL도 날짜만.
+ */
+function toRRule(r, dateOnly = false) {
     const parts = [`FREQ=${r.freq}`];
     if (r.interval > 1)
         parts.push(`INTERVAL=${r.interval}`);
@@ -113,5 +118,13 @@ function toRRule(r) {
         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(',')}`);
     }
+    if (r.until) {
+        const u = r.until;
+        const date = `${u.getFullYear()}${pad(u.getMonth() + 1)}${pad(u.getDate())}`;
+        parts.push(`UNTIL=${dateOnly ? date : `${date}T${pad(u.getHours())}${pad(u.getMinutes())}${pad(u.getSeconds())}`}`);
+    }
+    else if (r.count) {
+        parts.push(`COUNT=${r.count}`);
+    }
     return parts.join(';');
 }

package/dist/cjs/parsers/time.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.time = void 0;
 const number_js_1 = require("../util/number.js");
+// "24시 편의점", "24시 영업": 하루 종일 연다는 뜻이지 시각이 아니다
+const OPEN_ALL_DAY = /^\s*(?:편의점|영업|운영|무인|사우나|찜질방|약국|병원|동물병원|매장|카페|식당|해장국|김밥|헬스|콜센터|상담)/;
 // "오후 3시", "3시 반", "오전 10시 30분", "새벽 2시", "저녁 7시", "낮 12시", "15시", "7시30", "3시 정각"
 const CLOCK = /(오전|오후|새벽|아침|저녁|밤|낮|정오)?\s*(\d{1,2}|한|두|세|네|다섯|여섯|일곱|여덟|아홉|열|열한|열두)\s*시(?!간)\s*(?:(반)|(\d{1,2})\s*분|(\d{2})(?![\d가-힣])|정각)?/g;
 // "5시 10분 전" → 4:50
@@ -100,6 +102,8 @@ const time = (text) => {
         const raw = (0, number_js_1.parseKoreanNumber)(m[2]);
         if (raw == null || raw > 24)
             continue;
+        if (raw === 24 && !m[1] && OPEN_ALL_DAY.test(text.slice(m.index + m[0].length)))
+            continue;
         if (!take(m.index, m[0].length))
             continue;
         const hour = applyMeridiem(m[1], raw);

package/dist/cjs/parsers/weekday.js

@@ -25,8 +25,8 @@ const WEEKS_LATER = new RegExp(`(\\d{1,2}|한|두|세|네|다섯)\\s*주\\s*(?:
 // "전주"는 도시 이름과 너무 자주 겹쳐서 요일이 붙을 때만
 const FORMAL_WEEK = { 전전: -2, 전: -1, 금: 0, 차: 1, 익: 1, 차차: 2 };
 const FORMAL_WITH_DAY = new RegExp(`(?<![가-힣])(전전|차차|전|금|차|익)주\\s*(${DAY})(?:요일|욜)`, 'g');
-// "차주 중으로", "금주 내로", "차주에 회의", "익주까지". "금주에"는 "금주에 성공했어"(禁酒)와 겹쳐서 제외
-const FORMAL_WEEK_ONLY = /(?<![가-힣])(?:(전전|차차|차|익)주(?=\s*(?:에(?!게|서)|에는|중으로|중에|내로|내|안에|안으로|까지|초|말|부터))|(금)주(?=\s*(?:중으로|중에|내로|내|안에|안으로|까지|초|말|부터)))/g;
+// "차주 중으로", "차주 중", "금주 내로", "차주에 회의", "익주까지". "금주에"는 "금주에 성공했어"(禁酒)와 겹쳐서 제외
+const FORMAL_WEEK_ONLY = /(?<![가-힣])(?:(전전|차차|차|익)주(?=\s*(?:에(?!게|서)|에는|중으로|중에|중(?![가-힣])|내로|내|안에|안으로|까지|초|말|부터))|(금)주(?=\s*(?:중으로|중에|중(?![가-힣])|내로|내|안에|안으로|까지|초|말|부터)))/g;
 // "지난 금요일" = 오늘 제외 가장 가까운 과거, "다음 금요일" = 오늘 제외 가장 가까운 미래
 const DIR = new RegExp(`(지난|저번|다음)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "주말에 보자" ("이번 주말"은 위 WEEKEND가 먼저 잡는다)
@@ -88,7 +88,7 @@ const weekday = (text) => {
         taken.push([m.index, m.index + m[0].length]);
     }
     for (const m of text.matchAll(WEEKEND)) {
-        out.push({ text: m[0], index: m.index, components: { weekOffset: WEEK_WORDS[m[1]], weekday: 6 } });
+        out.push({ text: m[0], index: m.index, components: { weekOffset: WEEK_WORDS[m[1]], weekday: 6, weekend: true } });
         taken.push([m.index, m.index + m[0].length]);
     }
     for (const m of text.matchAll(BARE_WEEKEND)) {

package/dist/cjs/resolve.js

@@ -76,6 +76,7 @@ const DATE_KEYS = [
 /** 날짜 정보 없이 시각만 있는 조각인지 ("5시까지", "17:00") */
 function isTimeOnly(c) {
     return (c.hour !== undefined &&
+        c.recur === undefined &&
         c.hourOffset === undefined &&
         c.minuteOffset === undefined &&
         !DATE_KEYS.some((k) => c[k] !== undefined));
@@ -119,7 +120,9 @@ function hasConflict(a, b) {
     const weekdayNote = (x, y) => x.day !== undefined && y.weekday !== undefined && !y.weekend &&
         y.weekOffset === undefined && y.day === undefined && y.dayOffset === undefined && y.monthPart === undefined;
     const dayConflict = both(dayKeys) && !weekdayNote(a, b) && !weekdayNote(b, a);
-    return dayConflict || both(timeKeys) || dateVsRel;
+    // 규칙 34: "다음주부터 매주 월요일"의 날짜는 반복의 시작·끝이라 따로 해석한 뒤 parseAll이 묶는다
+    const recurVsDate = (a.recur !== undefined && has(b, dateKeys)) || (b.recur !== undefined && has(a, dateKeys));
+    return dayConflict || both(timeKeys) || dateVsRel || recurVsDate;
 }
 function resolve(group, opts) {
     const c = merge(group.map((f) => f.components));
@@ -168,7 +171,15 @@ function resolve(group, opts) {
     if (!isLunar && (hasYear || c.month !== undefined || c.day !== undefined)) {
         let y = c.year ?? ref.getFullYear() + (c.yearOffset ?? 0);
         // "작년", "내년"처럼 연도만 있으면 1월 1일. "내년 이맘때", "1년 뒤"는 오늘 날짜 유지
-        const m0 = c.month !== undefined ? c.month - 1 : hasYear && !c.sameDay ? 0 : ref.getMonth();
+        let m0 = c.month !== undefined ? c.month - 1 : hasYear && !c.sameDay ? 0 : ref.getMonth();
+        // "5일까지"처럼 일만 있으면: 오늘이 그날을 넘었으면 다음 달, 아니면 이번 달 (오늘 포함).
+        // 그 달에 없는 날("11월에 31일")은 아래에서 null
+        if (!hasYear && c.month === undefined && c.day !== undefined && c.monthOffset === undefined && c.nthWeek === undefined) {
+            if (c.day < ref.getDate())
+                m0 += 1;
+            y += Math.floor(m0 / 12);
+            m0 %= 12;
+        }
         // 연도 미지정 + 이미 지났으면 내년으로.
         // 월일("3월 1일")은 그 날이, 월("3월", "2월 말")은 그 달이 통째로 지났을 때.
         if (!hasYear && c.month !== undefined) {
@@ -322,6 +333,9 @@ function resolve(group, opts) {
         // "~까지", "~이내": 시작은 기준 시각, 끝은 해당 시점(시간 없으면 그날 23:59)
         // "~내내": 시작은 그 기간의 시작, 끝은 기간의 끝
         result.end = hasTime ? new Date(d) : periodEnd(d, c);
+        // "이번 주말 내내" → 토요일부터 일요일까지
+        if (c.whole && c.weekend && !hasTime && result.end.getDay() === 6)
+            result.end.setDate(result.end.getDate() + 1);
         // 규칙 30: "어제까지"처럼 이미 지난 마감은 구간이 아니라 그 시점 (date = end)
         if (c.isEnd)
             result.date = result.end < ref ? new Date(result.end) : new Date(ref);
@@ -333,7 +347,7 @@ function periodEnd(d, c) {
     let end = new Date(d);
     if (c.weekOffset !== undefined && c.weekday === undefined)
         end.setDate(end.getDate() + 6);
-    else if (c.monthOffset !== undefined && c.monthPart === undefined && c.day === undefined)
+    else if (c.monthOffset !== undefined && c.monthPart === undefined && c.day === undefined && !c.sameDay)
         end = new Date(end.getFullYear(), end.getMonth(), lastDayOfMonth(end.getFullYear(), end.getMonth()));
     else if ((c.year !== undefined || c.yearOffset !== undefined) && c.month === undefined && !c.sameDay)
         end = new Date(end.getFullYear(), 11, 31);
@@ -401,13 +415,25 @@ function resolveRecurrence(group, c, opts) {
     }
     if (!d)
         return null;
+    // 규칙 34: "10주 동안 매주 월요일" → 오늘(또는 "A부터"의 A)부터 그 기간의 마지막 날 23:59까지
+    const rule = { ...r };
+    if (c.durationDays !== undefined || c.durationMonths !== undefined) {
+        // N달 뒤 같은 날의 전날까지. 그 달에 없는 날이면 말일로 맞춘다 (11/30 + 3달 → 2/28의 전날)
+        const until = sameDayIn(today.getFullYear(), today.getMonth() + (c.durationMonths ?? 0), today.getDate());
+        until.setDate(until.getDate() + (c.durationDays ?? 0) - 1);
+        until.setHours(23, 59, 0, 0);
+        if (until < d)
+            return null;
+        rule.until = until;
+    }
     const last = group[group.length - 1];
+    const timed = hasTime || r.freq === 'HOURLY' || r.freq === 'MINUTELY';
     const result = {
         date: d,
         text: '',
         index: group[0].index,
-        hasTime: hasTime || r.freq === 'HOURLY' || r.freq === 'MINUTELY',
-        recurrence: { ...r, rrule: (0, recurrence_js_1.toRRule)(r) },
+        hasTime: timed,
+        recurrence: { ...rule, rrule: (0, recurrence_js_1.toRRule)(rule, !timed) },
     };
     result._end = last.index + last.text.length;
     return result;

package/dist/cjs/types.d.ts

@@ -88,7 +88,15 @@ export interface Recurrence {
     byMonthDay?: number;
     /** 매년 몇 월 */
     byMonth?: number;
-    /** 'FREQ=WEEKLY;BYDAY=MO,WE,FR'. date를 DTSTART로 함께 쓰면 캘린더에 그대로 넣을 수 있다 */
+    /** 마지막 발생 한도 ("다음달까지 매주 월요일" → 다음달 말일 23:59). count와 함께 오지 않는다 */
+    until?: Date;
+    /** 전체 횟수 ("총 8회", "10번 반복") */
+    count?: number;
+    /**
+     * 'FREQ=WEEKLY;BYDAY=MO,WE,FR'. date를 DTSTART로 함께 쓰면 캘린더에 그대로 넣을 수 있다.
+     * UNTIL은 date와 같은 벽시계 시각(floating time)으로 쓴다. 시각이 없으면 'UNTIL=20261130'처럼 날짜만.
+     * DTSTART를 UTC나 TZID로 쓰는 캘린더 파일에는 toICS()가 UNTIL을 UTC로 바꿔 넣는다
+     */
     rrule: string;
 }
 export interface Fragment {

package/dist/ics.d.ts

@@ -0,0 +1,30 @@
+import type { ParseResult } from './types.js';
+import type { ParsedEvent } from './event.js';
+export interface ICSOptions {
+    /** 일정 제목. 기본값: parseEvent 결과면 그 title, parse 결과면 문장에서 찾은 부분 */
+    title?: string;
+    /**
+     * 시각을 이 시간대의 벽시계로 쓴다 (`DTSTART;TZID=Asia/Seoul:…`). 서머타임이 있는 곳의 반복 일정은 이걸 넘겨야
+     * 시각이 유지된다. 없으면 UTC로 쓴다. 종일 일정의 날짜도 이 시간대 기준.
+     */
+    timezone?: string;
+    /** 시각은 있는데 끝이 없을 때 일정 길이(분). 기본값: 60 */
+    durationMinutes?: number;
+    /** VEVENT의 UID. 기본값: 무작위 */
+    uid?: string;
+    /** DTSTAMP. 기본값: new Date() */
+    now?: Date;
+}
+/**
+ * parse / parseEvent 결과를 iCalendar(.ics) 문자열로 바꾼다. 날짜가 없으면 null.
+ * Google·Apple·Outlook 캘린더에서 그대로 가져올 수 있다.
+ *
+ * - 시각이 있으면 DTSTART/DTEND (끝이 없으면 durationMinutes 뒤)
+ * - 시각이 없으면 종일 일정 (`VALUE=DATE`, DTEND는 마지막 날의 다음날)
+ * - 반복이면 RRULE. UNTIL은 DTSTART 형식에 맞춰 UTC 또는 날짜로 다시 쓴다
+ *
+ * @example
+ * const ics = toICS(parseEvent('다음주 월요일 9시 팀 회의'), { timezone: 'Asia/Seoul' });
+ * // BEGIN:VCALENDAR … SUMMARY:팀 회의 … DTSTART;TZID=Asia/Seoul:20261102T090000 …
+ */
+export declare function toICS(input: ParseResult | ParsedEvent, options?: ICSOptions): string | null;

package/dist/ics.js

@@ -0,0 +1,77 @@
+import { toRRule } from './parsers/recurrence.js';
+import { toWallClock } from './util/timezone.js';
+const pad = (n) => String(n).padStart(2, '0');
+const ymd = (d) => `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
+const hms = (d) => `${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+const utc = (d) => `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}T` +
+    `${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}Z`;
+/** TEXT 값 이스케이프 (RFC 5545 3.3.11) */
+const escapeText = (s) => s.replace(/[\\;,]/g, (c) => `\\${c}`).replace(/\r?\n/g, '\\n');
+/** 75바이트가 넘는 줄은 CRLF + 공백으로 접는다 (RFC 5545 3.1). UTF-8 글자 중간에서는 끊지 않는다 */
+function fold(line) {
+    const out = [];
+    let cur = '';
+    let bytes = 0;
+    for (const ch of line) {
+        const cp = ch.codePointAt(0);
+        const len = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+        // 이어지는 줄은 앞의 공백 1바이트를 뺀 74바이트까지
+        if (bytes + len > (out.length ? 74 : 75)) {
+            out.push(cur);
+            cur = '';
+            bytes = 0;
+        }
+        cur += ch;
+        bytes += len;
+    }
+    out.push(cur);
+    return out.join('\r\n ');
+}
+/**
+ * parse / parseEvent 결과를 iCalendar(.ics) 문자열로 바꾼다. 날짜가 없으면 null.
+ * Google·Apple·Outlook 캘린더에서 그대로 가져올 수 있다.
+ *
+ * - 시각이 있으면 DTSTART/DTEND (끝이 없으면 durationMinutes 뒤)
+ * - 시각이 없으면 종일 일정 (`VALUE=DATE`, DTEND는 마지막 날의 다음날)
+ * - 반복이면 RRULE. UNTIL은 DTSTART 형식에 맞춰 UTC 또는 날짜로 다시 쓴다
+ *
+ * @example
+ * const ics = toICS(parseEvent('다음주 월요일 9시 팀 회의'), { timezone: 'Asia/Seoul' });
+ * // BEGIN:VCALENDAR … SUMMARY:팀 회의 … DTSTART;TZID=Asia/Seoul:20261102T090000 …
+ */
+export function toICS(input, options = {}) {
+    if (!input.date)
+        return null;
+    const tz = options.timezone;
+    const wall = (d) => (tz ? toWallClock(d, tz) : d);
+    const title = options.title ?? ('title' in input ? input.title : input.text);
+    const lines = [
+        'BEGIN:VCALENDAR',
+        'VERSION:2.0',
+        'PRODID:-//ko-chrono//KO',
+        'CALSCALE:GREGORIAN',
+        'BEGIN:VEVENT',
+        `UID:${options.uid ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}@ko-chrono`}`,
+        `DTSTAMP:${utc(options.now ?? new Date())}`,
+        `SUMMARY:${escapeText(title)}`,
+    ];
+    if (input.hasTime) {
+        const end = input.end ?? new Date(input.date.getTime() + (options.durationMinutes ?? 60) * 60_000);
+        const at = (name, d) => (tz ? `${name};TZID=${tz}:${ymd(wall(d))}T${hms(wall(d))}` : `${name}:${utc(d)}`);
+        lines.push(at('DTSTART', input.date), at('DTEND', end));
+    }
+    else {
+        const first = wall(input.date);
+        const last = input.end ? wall(input.end) : first;
+        const after = new Date(last.getFullYear(), last.getMonth(), last.getDate() + 1);
+        lines.push(`DTSTART;VALUE=DATE:${ymd(first)}`, `DTEND;VALUE=DATE:${ymd(after)}`);
+    }
+    const r = input.recurrence;
+    if (r) {
+        // recurrence.rrule의 UNTIL은 벽시계(floating) 형식이라, 시각이 있는 일정이면 UTC로 바꿔 쓴다
+        const rrule = r.until && input.hasTime ? toRRule({ ...r, until: undefined }) + `;UNTIL=${utc(r.until)}` : r.rrule;
+        lines.push(`RRULE:${rrule}`);
+    }
+    lines.push('END:VEVENT', 'END:VCALENDAR', '');
+    return lines.map(fold).join('\r\n');
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import type { ParseOptions, ParseResult } 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';
+export { toICS, type ICSOptions } from './ics.js';
 /**
  * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
  *

package/dist/index.js

@@ -6,17 +6,25 @@ 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 { recurrence, toRRule } 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 { parseKoreanNumber } from './util/number.js';
 import { toEvent } from './event.js';
+export { toICS } from './ics.js';
 const PARSERS = [relativeDay, offset, weekday, absoluteDate, relativeMonth, relativeYear, time, duration, recurrence, holiday];
-// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다
-const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로)/;
+// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다. "다음주 중", "오늘 중에"도 마감
+const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로|중에(?![가-힣])|중(?![가-힣]))/;
 const FROM = /^\s*(부터|~)\s*/;
 // "이번 주 내내" → 그 기간 전체
 const WHOLE = /^\s*내내/;
+// 반복 일정과 그 앞뒤 날짜 사이 (규칙 34): "다음달까지 매주 월요일", "매주 월요일, 12월 20일까지"
+const GAP = /^[\s,]*$/;
+// "다음주부터 매주 월요일"
+const FROM_GAP = /^\s*부터[\s,]*$/;
+// "총 8회", "10번 반복", "총 열 번". "매일 3번"은 하루 횟수일 수 있어 "총"이나 "반복"이 있을 때만
+const COUNT = /^[\s,]*(?:총\s*(\d{1,3}|[한두세네다섯여섯일곱여덟아홉열스무]+)\s*(?:번|회)(?:\s*반복)?|(\d{1,3}|[한두세네다섯여섯일곱여덟아홉열스무]+)\s*(?:번|회)\s*반복)/;
 function withDefaults(opts) {
     return {
         referenceDate: opts?.referenceDate ?? new Date(),
@@ -58,6 +66,9 @@ export function parseAll(text, options) {
         const out = { ...r, date: fromWallClock(r.date, timezone) };
         if (r.end)
             out.end = fromWallClock(r.end, timezone);
+        // rrule의 UNTIL은 벽시계 그대로 두고, Date 값만 실제 시점으로
+        if (r.recurrence?.until)
+            out.recurrence = { ...r.recurrence, until: fromWallClock(r.recurrence.until, timezone) };
         if (r.ambiguity) {
             out.ambiguity = { ...r.ambiguity, alternatives: r.ambiguity.alternatives.map((a) => fromWallClock(a, timezone)) };
         }
@@ -70,6 +81,7 @@ function parseLocal(text, opts) {
     const groups = groupFragments(frags, text);
     const results = [];
     const comps = [];
+    const resultGroups = [];
     for (const g of groups) {
         const last = g[g.length - 1];
         const tail = text.slice(last.index + last.text.length);
@@ -93,10 +105,15 @@ function parseLocal(text, opts) {
         r.text = raw.trim();
         results.push(r);
         comps.push(merge(g.map((f) => f.components)));
+        resultGroups.push(g);
     }
     // "A부터 B까지", "A~B" → 하나의 구간으로 합침
     const merged = [];
+    const mergedGroups = [];
+    const mergedComps = [];
     for (let i = 0; i < results.length; i++) {
+        mergedGroups.push(resultGroups[i]);
+        mergedComps.push(comps[i]);
         const a = results[i], b = results[i + 1];
         const from = FROM.exec(text.slice(a.index + a.text.length));
         // "~"는 바로 뒤에 B가 붙어 있을 때만. "부터"는 B가 "까지"로 끝나거나,
@@ -137,7 +154,78 @@ function parseLocal(text, opts) {
             merged.push(a);
         }
     }
-    return merged;
+    return bindRecurrence(text, merged, mergedGroups, mergedComps, opts);
+}
+/**
+ * 반복 일정 앞뒤의 날짜를 시작·끝으로 묶는다 (규칙 34).
+ * - 앞이나 뒤의 마감·구간 ("다음달까지", "11월 1일부터 12월 31일까지") → 그 시작 이후 첫 발생, 끝은 UNTIL
+ * - 앞의 "A부터" → A 이후 첫 발생
+ * - 뒤의 "총 N회", "N번 반복" → COUNT
+ * 끝이 첫 발생보다 앞이면 묶지 않는다 ("어제까지 매주 월요일").
+ */
+function bindRecurrence(text, results, groups, comps, opts) {
+    const out = [];
+    for (let i = 0; i < results.length; i++) {
+        let r = results[i];
+        if (!r.recurrence) {
+            out.push(r);
+            continue;
+        }
+        let from = r.index;
+        let to = r.index + r.text.length;
+        let bound = false;
+        // 시작·끝이 되는 날짜를 적용해 첫 발생을 다시 계산한다
+        // 시각만 있는 마감("5시까지 매일")은 그날 하루의 끝이지 반복의 끝이 아니다
+        const bindTo = (other, j) => {
+            if (isTimeOnly(comps[j]))
+                return false;
+            // 마감("다음달까지")의 date는 기준 시각이라 그대로, 지난 시작("지난주부터")은 기준 시각부터
+            const begin = other.date > opts.referenceDate ? other.date : opts.referenceDate;
+            const again = resolve(groups[i], { ...opts, referenceDate: begin });
+            if (!again?.recurrence)
+                return false;
+            // "N주 동안"은 새 시작부터 다시 센 값(again)을 쓴다
+            const until = again.recurrence.until ?? other.end;
+            if (until && until < again.date)
+                return false;
+            const shift = again.date.getTime() - r.date.getTime();
+            r = { ...r, date: again.date, recurrence: { ...again.recurrence, until } };
+            if (r.end)
+                r.end = new Date(r.end.getTime() + shift);
+            return true;
+        };
+        const prev = out[out.length - 1];
+        const prevIndex = results.indexOf(prev);
+        if (prev && !prev.recurrence) {
+            const gap = text.slice(prev.index + prev.text.length, r.index);
+            if ((prev.end ? GAP : FROM_GAP).test(gap) && bindTo(prev, prevIndex)) {
+                from = prev.index;
+                out.pop();
+                bound = true;
+            }
+        }
+        const next = results[i + 1];
+        if (!r.recurrence.until && next?.end && !next.recurrence && GAP.test(text.slice(to, next.index)) && bindTo(next, i + 1)) {
+            to = next.index + next.text.length;
+            bound = true;
+            i++;
+        }
+        const count = COUNT.exec(text.slice(to));
+        const n = count ? parseKoreanNumber(count[1] ?? count[2]) : null;
+        if (n && !r.recurrence.until) {
+            r = { ...r, recurrence: { ...r.recurrence, count: n } };
+            to += count[0].length;
+            bound = true;
+        }
+        if (bound) {
+            const rule = r.recurrence;
+            if (rule.until === undefined)
+                delete rule.until;
+            r = { ...r, index: from, text: text.slice(from, to).trim(), recurrence: { ...rule, rrule: toRRule(rule, !r.hasTime) } };
+        }
+        out.push(r);
+    }
+    return out;
 }
 /**
  * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.

package/dist/parsers/absoluteDate.js

@@ -11,8 +11,8 @@ const HANGUL_MONTH = { 유: 6, 시: 10 };
 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;
+// "5일간", "3일 동안", "3박 4일"은 기간이지 날짜가 아니다. "주 5일 근무"(횟수), "30일 챌린지"도 아니다
+const DAY_ONLY = /(?<!\d)(?<!\d\s*박\s*)(?<!(?<![가-힣])주\s*)(\d{1,2})\s*일(?!요일|간|장|째|차|분|\s*동안|\s*연속|\s*챌린지)/g;
 /** 두 자리 연도 확장: 00~69 → 20xx, 70~99 → 19xx */
 const expandYear = (y) => {
     const n = +y;