ko-chrono 0.3.0 → 0.4.0

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;

package/dist/parsers/holiday.js

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

package/dist/parsers/offset.js

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

package/dist/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/parsers/recurrence.js

@@ -95,8 +95,13 @@ export const recurrence = (text) => {
     return out;
 };
 const CODE = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
-/** RFC 5545 RRULE 문자열. 요일은 월요일부터 */
-export function toRRule(r) {
+const pad = (n) => String(n).padStart(2, '0');
+/**
+ * RFC 5545 RRULE 문자열. 요일은 월요일부터.
+ * UNTIL은 벽시계 시각 그대로 쓴다 (DTSTART가 TZID 또는 floating time일 때의 형식).
+ * dateOnly면 DTSTART가 DATE이므로 UNTIL도 날짜만.
+ */
+export function toRRule(r, dateOnly = false) {
     const parts = [`FREQ=${r.freq}`];
     if (r.interval > 1)
         parts.push(`INTERVAL=${r.interval}`);
@@ -108,5 +113,13 @@ export 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/parsers/relativeDay.js

@@ -1,5 +1,10 @@
 const WORDS = {
     그저께: -2,
+    // 업무용 한자어 (규칙 33)
+    금일: 0,
+    명일: 1,
+    익일: 1,
+    작일: -1,
     내일모레: 2,
     낼모레: 2,
     낼: 1,
@@ -10,8 +15,8 @@ const WORDS = {
     모레: 2,
     글피: 3,
 };
-// "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
-const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
+// "금일", "익일 배송", "작일" (업무용 한자어). "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
+const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])(?:금일|명일|익일|작일)|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
 /** 오늘/내일/모레/글피/어제/그저께 */
 export const relativeDay = (text) => {
     const out = [];

package/dist/parsers/relativeMonth.js

@@ -4,6 +4,9 @@ const PART = { 초: 'start', 중순: 'middle', 말: 'end' };
 const RE = /(지난|저번|이번|다다음|다음|담)\s*달\s*(초|중순|말|이맘때)?|(?<![가-힣])월(초|말)/g;
 // "11월 말", "12월 초" (absoluteDate의 MONTH_ONLY와 겹치지만 part가 있는 경우 우선)
 const ABS_PART = /(?<![\d가-힣])(\d{1,2})\s*월\s*(초|중순|말)/g;
+// 업무용 한자어 달 (규칙 33): "익월 초", "금월 말까지", "전월 실적". "전월세"는 제외
+const FORMAL_MONTH = /(?<![가-힣])(금|익|차|전)월(?!세)(?:\s*(초|중순|말))?/g;
+const FORMAL_MONTH_OFFSET = { 금: 0, 익: 1, 차: 1, 전: -1 };
 /** 이번달/다음달 (초/중순/말) */
 export const relativeMonth = (text) => {
     const out = [];
@@ -19,6 +22,12 @@ export const relativeMonth = (text) => {
             c.monthPart = PART[m[2]];
         out.push({ text: m[0], index: m.index, components: c });
     }
+    for (const m of text.matchAll(FORMAL_MONTH)) {
+        const c = { monthOffset: FORMAL_MONTH_OFFSET[m[1]] };
+        if (m[2])
+            c.monthPart = PART[m[2]];
+        out.push({ text: m[0], index: m.index, components: c });
+    }
     for (const m of text.matchAll(ABS_PART)) {
         out.push({ text: m[0], index: m.index, components: { month: +m[1], monthPart: PART[m[2]] } });
     }

package/dist/parsers/relativeYear.js

@@ -1,8 +1,8 @@
 const WORDS = {
-    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 내후년: 2,
+    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 익년: 1, 내후년: 2,
 };
 // "올해 말", "내년 초", "작년", "재작년", "내후년", "지난해", "내년 이맘때", "연말", "연초"
-const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
+const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년|익년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
 /** 올해/내년/작년 (초/말) */
 export const relativeYear = (text) => {
     const out = [];

package/dist/parsers/time.js

@@ -1,4 +1,6 @@
 import { parseKoreanNumber } from '../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
@@ -97,6 +99,8 @@ export const time = (text) => {
         const raw = 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/parsers/weekday.js

@@ -17,6 +17,13 @@ const NTH = new RegExp(`(?:(\\d{1,2})\\s*월\\s*)?(첫째|첫|둘째|셋째|넷
 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');
+// 업무용 한자어 주 (규칙 33): "차주 금요일", "금주 월요일", "전주 수요일". 금주(禁酒)·전주(도시)·차주(車主)와
+// 겹치므로 요일은 "요일/욜"까지 붙어야 하고, 요일 없이 쓸 때는 뒤에 날짜 말(내로·중으로·에·까지…)이 와야 한다.
+// "전주"는 도시 이름과 너무 자주 겹쳐서 요일이 붙을 때만
+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 DIR = new RegExp(`(지난|저번|다음)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "주말에 보자" ("이번 주말"은 위 WEEKEND가 먼저 잡는다)
@@ -32,6 +39,16 @@ 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(FORMAL_WITH_DAY)) {
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1]], weekday: WEEKDAY[m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
+    for (const m of text.matchAll(FORMAL_WEEK_ONLY)) {
+        if (overlaps(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1] ?? m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
     for (const m of text.matchAll(WEEKS_LATER)) {
         const n = parseKoreanNumber(m[1]);
         if (n == null)
@@ -68,7 +85,7 @@ export 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/resolve.js

@@ -67,6 +67,7 @@ const DATE_KEYS = [
 /** 날짜 정보 없이 시각만 있는 조각인지 ("5시까지", "17:00") */
 export function isTimeOnly(c) {
     return (c.hour !== undefined &&
+        c.recur === undefined &&
         c.hourOffset === undefined &&
         c.minuteOffset === undefined &&
         !DATE_KEYS.some((k) => c[k] !== undefined));
@@ -110,7 +111,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;
 }
 export function resolve(group, opts) {
     const c = merge(group.map((f) => f.components));
@@ -159,7 +162,15 @@ export 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) {
@@ -313,6 +324,9 @@ export 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);
@@ -324,7 +338,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);
@@ -392,13 +406,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: toRRule(r) },
+        hasTime: timed,
+        recurrence: { ...rule, rrule: toRRule(rule, !timed) },
     };
     result._end = last.index + last.text.length;
     return result;

package/dist/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ko-chrono",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "한국어 자연어 날짜/시간 파서 — '다음주 화요일 오후 3시' → Date",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -16,18 +16,33 @@
         "types": "./dist/cjs/index.d.ts",
         "default": "./dist/cjs/index.js"
       }
-    }
+    },
+    "./package.json": "./package.json"
   },
   "sideEffects": false,
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc -p tsconfig.cjs.json && node scripts/mark-cjs.mjs",
+    "prepublishOnly": "npm run build && npm test",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "playground": "npm run build && npx serve ."
   },
-  "keywords": ["korean", "한국어", "date", "parser", "natural-language", "날짜", "nlp", "chrono"],
+  "keywords": [
+    "korean",
+    "한국어",
+    "date",
+    "parser",
+    "natural-language",
+    "날짜",
+    "nlp",
+    "chrono"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",