ko-chrono 0.1.0 → 0.3.0

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

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

package/dist/cjs/parsers/absoluteDate.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.absoluteDate = void 0;
+const number_js_1 = require("../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;
+};
+/** 절대 날짜 표현 */
+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]] ?? (0, number_js_1.parseKoreanNumber)(m[1]);
+        const day = (0, number_js_1.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;
+};
+exports.absoluteDate = absoluteDate;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duration = void 0;
+const number_js_1 = require("../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를 만든다. */
+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 = (0, number_js_1.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;
+};
+exports.duration = duration;

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

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

package/dist/cjs/parsers/holiday.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.holiday = void 0;
+// 양력 고정 공휴일·기념일 → [월, 일]. 여러 단어는 띄어쓰기를 생략해도 된다
+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가 표에서 찾는다 */
+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;
+};
+exports.holiday = holiday;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offset = void 0;
+const number_js_1 = require("../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분 후" */
+const offset = (text) => {
+    const out = [];
+    const taken = [];
+    for (const m of text.matchAll(HOUR_MIN)) {
+        const h = (0, number_js_1.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 = (0, number_js_1.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;
+};
+exports.offset = offset;

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurrence = void 0;
+exports.toRRule = toRRule;
+const number_js_1 = require("../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가 계산) */
+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] ? (0, number_js_1.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] ? (0, number_js_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;
+};
+exports.recurrence = recurrence;
+const CODE = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+/** RFC 5545 RRULE 문자열. 요일은 월요일부터 */
+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/cjs/parsers/relativeDay.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 오늘/내일/모레/글피/어제/그저께 */
+export declare const relativeDay: Parser;

package/dist/cjs/parsers/relativeDay.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeDay = void 0;
+const WORDS = {
+    그저께: -2,
+    내일모레: 2,
+    낼모레: 2,
+    낼: 1,
+    그제: -2,
+    어제: -1,
+    오늘: 0,
+    내일: 1,
+    모레: 2,
+    글피: 3,
+};
+// "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
+const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
+/** 오늘/내일/모레/글피/어제/그저께 */
+const relativeDay = (text) => {
+    const out = [];
+    for (const m of text.matchAll(RE)) {
+        out.push({ text: m[0], index: m.index, components: { dayOffset: WORDS[m[1]] } });
+    }
+    return out;
+};
+exports.relativeDay = relativeDay;

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

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 이번달/다음달 (초/중순/말) */
+export declare const relativeMonth: Parser;

package/dist/cjs/parsers/relativeMonth.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeMonth = void 0;
+const WORDS = { 지난: -1, 저번: -1, 이번: 0, 다음: 1, 다다음: 2, 담: 1 };
+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;
+/** 이번달/다음달 (초/중순/말) */
+const relativeMonth = (text) => {
+    const out = [];
+    for (const m of text.matchAll(RE)) {
+        if (m[3]) {
+            out.push({ text: m[0], index: m.index, components: { monthOffset: 0, monthPart: PART[m[3]] } });
+            continue;
+        }
+        const c = { monthOffset: WORDS[m[1]] };
+        if (m[2] === '이맘때')
+            c.sameDay = true;
+        else 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]] } });
+    }
+    return out;
+};
+exports.relativeMonth = relativeMonth;

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

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 올해/내년/작년 (초/말) */
+export declare const relativeYear: Parser;

package/dist/cjs/parsers/relativeYear.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeYear = void 0;
+const WORDS = {
+    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 내후년: 2,
+};
+// "올해 말", "내년 초", "작년", "재작년", "내후년", "지난해", "내년 이맘때", "연말", "연초"
+const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
+/** 올해/내년/작년 (초/말) */
+const relativeYear = (text) => {
+    const out = [];
+    for (const m of text.matchAll(RE)) {
+        if (m[3]) {
+            // "연초"는 연도가 없으므로 지난 월일 → 내년 규칙(13)을 따른다
+            const c = m[3] === '연초' ? { month: 1, monthPart: 'start' } : { month: 12, monthPart: 'end' };
+            out.push({ text: m[0], index: m.index, components: c });
+            continue;
+        }
+        const c = { yearOffset: WORDS[m[1]] };
+        if (m[2] === '초')
+            Object.assign(c, { month: 1, monthPart: 'start' });
+        if (m[2] === '말')
+            Object.assign(c, { month: 12, monthPart: 'end' });
+        if (m[2] === '이맘때')
+            c.sameDay = true;
+        out.push({ text: m[0], index: m.index, components: c });
+    }
+    return out;
+};
+exports.relativeYear = relativeYear;

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

@@ -0,0 +1,3 @@
+import type { Parser } from '../types.js';
+/** 시각 표현 */
+export declare const time: Parser;