ko-chrono 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 최지원
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,112 @@
-# Temporary Holding Version
+# ko-chrono
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+한국어 자연어 날짜/시간 파서. 문장 속 "다음주 화요일 오후 3시"를 `Date`로 바꿉니다.
+
+[chrono-node](https://github.com/wanasit/chrono)에 없는 한국어를 채웁니다.
+[es-hangul](https://github.com/toss/es-hangul)이 글자를 다룬다면, ko-chrono는 문장 속 시간을 다룹니다.
+
+```ts
+import { parse, parseAll, parseDate } from 'ko-chrono';
+
+// 기준: 2026-10-30 (금) 14:00
+parseDate('다음주 화요일 오후 3시');     // 2026-11-03 15:00
+parseDate('모레 점심');                  // 2026-11-01 12:00
+parseDate('토요일 아침');                // 2026-10-31 08:00
+parseDate('이번 주말');                  // 2026-10-31 (토)
+parseDate('3일 뒤');                     // 2026-11-02
+parseDate('한 시간 반 뒤');              // 2026-10-30 15:30
+parseDate('다음달 중순');                // 2026-11-15
+parseDate('내년 초');                    // 2027-01-01
+parseDate('11/5 10시 반');               // 2026-11-05 10:30
+parseDate('26년 12월 1일');              // 2026-12-01
+parseDate('십일월 오일');                // 2026-11-05
+parseDate('내일은 오후3시쯤');           // 2026-10-31 15:00
+parseDate('11월 첫째 주 월요일');        // 2026-11-02
+parseDate('지난 금요일');                // 2026-10-23
+parseDate('11월 31일');                  // null — 없는 날짜는 넘기지 않음
+
+parse('이번달 말까지 제출');
+// { date: 지금, end: 2026-10-31 23:59, text: '이번달 말까지', hasTime: false }
+
+parse('그럼 다음주 수요일 저녁 7시에 강남에서 볼까?');
+// { date: 2026-11-04 19:00, text: '다음주 수요일 저녁 7시', index: 3, hasTime: true }
+
+parse('오늘부터 3일간 휴가');
+// { date: 2026-10-30, end: 2026-11-01 23:59, text: '오늘부터 3일간' }
+
+parseAll('내일 10시 아니면 모레 2시');  // [10-31 10:00, 11-01 14:00]
+```
+
+- 런타임 의존성 0
+- 브라우저 / Node 모두 동작
+- 트리쉐이킹 가능한 ESM
+
+## 설치
+
+```bash
+npm install ko-chrono
+```
+
+## API
+
+### `parse(text, options?)`
+첫 번째 날짜/시간 표현을 찾아 `ParseResult`를 돌려줍니다. 없으면 `null`.
+
+### `parseAll(text, options?)`
+모든 표현을 배열로.
+
+### `parseDate(text, options?)`
+`parse(...)?.date` 단축형.
+
+### 옵션
+
+| 옵션 | 기본값 | 설명 |
+|---|---|---|
+| `referenceDate` | `new Date()` | "내일", "다음주"의 기준 시각 |
+| `weekStart` | `'monday'` | "이번주/다음주" 계산 기준 |
+| `defaultHour` | `0` | 시간이 없는 날짜에 넣을 시 |
+
+### 해석 규칙
+
+- "다음주 월요일" = 기준일이 속한 주의 다음 주 월요일 (금요일에 말하면 3일 뒤)
+- "월요일" 단독 = 오늘 포함 가장 가까운 미래의 월요일
+- "이번 주말" = 그 주의 토요일. "주말" 단독 = 다가오는 토요일 (토·일이면 오늘)
+- 시간만 있으면 오늘, 이미 지났으면 내일
+- 오전/오후가 없는 1~6시는 오후 ("3시에 보자" → 15:00). 7~11시는 그대로
+- 월일만 있고 이미 지났으면 내년 ("올해 3월 1일"처럼 연도를 말하면 그대로). "3월", "2월 말"도 그 달이 지났으면 내년
+- 날짜를 말한 시각은 지났어도 그대로 ("오늘 아침" → 오늘 08:00)
+- 두 자리 연도: 00~69 → 20xx, 70~99 → 19xx
+- "오후 12시" = 정오. "내일 자정" / "내일 24시" / "내일 밤 12시" = 내일이 끝나는 시점(모레 00:00)
+- 시 범위의 끝은 시작의 오전·오후를 이어받음: "오후 3~5시" → 15~17시
+- "11월 5일 목요일"처럼 날짜와 요일이 안 맞으면 `null` ("11/3(화)" 괄호 표기도 같음)
+- "지난 금요일" = 오늘 제외 가장 가까운 과거, "다음 금요일" = 오늘 제외 가장 가까운 미래
+- "11월 첫째 주 월요일" = 11월의 첫 번째 월요일. 요일이 없으면 N번째 월요일
+- "내년 이맘때", "1년 뒤"는 오늘의 월·일 유지
+- "오늘부터 3일간" → `end`는 3일째 되는 날 23:59. "3일간" 단독은 날짜가 아니라서 `null`
+- 없는 날짜(2월 30일, 11월 31일)는 다음 달로 넘기지 않고 `null`
+- "~까지" / "~이내" → `end`에 종료 시점. "이번 주 안에", "이번달 안에"는 그 기간의 마지막 날. "이번 주 내내"는 시작~끝 구간
+- "내일 30분 후"처럼 날짜와 상대 시간은 별개 결과
+
+## 지원 표현
+
+오늘·내일·모레·글피·어제·그저께 / N일·주·달·시간·분 뒤·전 / N시간 반 뒤 / 열흘·보름 / 이번주·다음주·다다음주·지난주 + 요일 / 이번·다음·지난 주말 / 요일 단독 / M월 D일 / 십일월 오일 / YYYY년 / YY년 / M/D / YYYY-MM-DD / YY.M.D / 올해·내년·작년 + 초·말 / 이번달·다음달 + 초·중순·말 / 오전·오후·새벽·아침·저녁·밤·낮 N시 (반·N분) / HH:MM / 정오·자정·점심 / ~까지·이내·안에·중으로 / A부터 B까지 / A~B / 3~5시 / 3pm / 월요일부터 금요일까지 / 월~금 / 지난·다음 X요일 / 11/3(화) / N째 주 X요일 / 마지막 주 / 이맘때 / N년 뒤 / 이틀·사흘 / 연말·연초·월초·월말 / 오전 중·퇴근 전까지 / A부터 N일간 / 3박 4일 / 이번 주 내내 / 월욜·낼·내일모레 / 띄어쓰기 생략 / 조사·어림말 (은·는·도·쯤·경·께)
+
+전체 목록과 예시는 [SPEC.md](./SPEC.md).
+
+## Playground
+
+```bash
+npm run playground
+```
+
+브라우저에서 `http://localhost:3000/playground` 를 열면 직접 입력해 볼 수 있습니다.
+
+## 로드맵
+
+- [ ] 반복 일정 (매주 월요일 9시)
+- [ ] 명절·공휴일 기준 표현
+- [ ] chrono-node `ko` 로케일 기여
+
+## 라이선스
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import type { ParseOptions, ParseResult } from './types.js';
+export type { ParseOptions, ParseResult, WeekStart } from './types.js';
+/**
+ * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
+ *
+ * @example
+ * parseAll('내일 10시 아니면 모레 2시');
+ * // → [{ date: 내일 10:00, text: '내일 10시', ... }, { date: 모레 14:00, text: '모레 2시', ... }]
+ *
+ * @example
+ * parseAll('11월 1일부터 11월 3일까지');
+ * // → [{ date: 11-01 00:00, end: 11-03 00:00, ... }]  "A부터 B까지"는 하나의 구간으로 합쳐진다
+ */
+export declare function parseAll(text: string, options?: ParseOptions): ParseResult[];
+/**
+ * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.
+ *
+ * @example
+ * parse('그럼 다음주 수요일 저녁 7시에 강남에서 볼까?');
+ * // → { date: 다음주 수요일 19:00, text: '다음주 수요일 저녁 7시', index: 3, hasTime: true }
+ *
+ * @example
+ * parse('이번달 말까지 보내주세요');
+ * // → { date: 기준 시각, end: 이번달 마지막날 23:59, text: '이번달 말까지', hasTime: false, ... }
+ *
+ * @example
+ * parse('오후 3시', { referenceDate: new Date(2026, 9, 30, 14) });
+ * // → 2026-10-30 15:00 (시간만 있으면 오늘, 이미 지났으면 내일)
+ */
+export declare function parse(text: string, options?: ParseOptions): ParseResult | null;
+/**
+ * parse()의 date만 돌려주는 단축형. 구간이면 시작 시각.
+ *
+ * @example
+ * parseDate('다음주 화요일 오후 3시'); // → Date
+ * parseDate('아무 날짜도 없음');       // → null
+ */
+export declare function parseDate(text: string, options?: ParseOptions): Date | null;

package/dist/index.js

@@ -0,0 +1,138 @@
+import { relativeDay } from './parsers/relativeDay.js';
+import { offset } from './parsers/offset.js';
+import { weekday } from './parsers/weekday.js';
+import { absoluteDate } from './parsers/absoluteDate.js';
+import { relativeMonth } from './parsers/relativeMonth.js';
+import { relativeYear } from './parsers/relativeYear.js';
+import { time } from './parsers/time.js';
+import { duration } from './parsers/duration.js';
+import { alignEnd, groupFragments, isDayOnly, isTimeOnly, isWeekdayOnly, merge, resolve } from './resolve.js';
+const PARSERS = [relativeDay, offset, weekday, absoluteDate, relativeMonth, relativeYear, time, duration];
+// "~까지" / "~부터" 접미 감지. "3시~5시"의 "~"도 시작 표시로 본다
+const UNTIL = /^\s*(전까지|까지|이내|안에|안으로|내로|중으로)/;
+const FROM = /^\s*(부터|~)\s*/;
+// "이번 주 내내" → 그 기간 전체
+const WHOLE = /^\s*내내/;
+function withDefaults(opts) {
+    return {
+        referenceDate: opts?.referenceDate ?? new Date(),
+        weekStart: opts?.weekStart ?? 'monday',
+        defaultHour: opts?.defaultHour ?? 0,
+    };
+}
+/** 겹치는 조각 제거: 더 긴 것 우선 */
+function dedupe(frags) {
+    const sorted = [...frags].sort((a, b) => b.text.length - a.text.length);
+    const kept = [];
+    for (const f of sorted) {
+        const s = f.index, e = f.index + f.text.length;
+        if (kept.some((k) => s < k.index + k.text.length && e > k.index))
+            continue;
+        kept.push(f);
+    }
+    return kept;
+}
+/**
+ * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.
+ *
+ * @example
+ * parseAll('내일 10시 아니면 모레 2시');
+ * // → [{ date: 내일 10:00, text: '내일 10시', ... }, { date: 모레 14:00, text: '모레 2시', ... }]
+ *
+ * @example
+ * parseAll('11월 1일부터 11월 3일까지');
+ * // → [{ date: 11-01 00:00, end: 11-03 00:00, ... }]  "A부터 B까지"는 하나의 구간으로 합쳐진다
+ */
+export function parseAll(text, options) {
+    const opts = withDefaults(options);
+    const frags = dedupe(PARSERS.flatMap((p) => p(text)));
+    const groups = groupFragments(frags, text);
+    const results = [];
+    const comps = [];
+    for (const g of groups) {
+        const last = g[g.length - 1];
+        const tail = text.slice(last.index + last.text.length);
+        const until = UNTIL.exec(tail) ?? WHOLE.exec(tail);
+        if (until && until[0].includes('내내'))
+            last.components.whole = true;
+        else if (until)
+            last.components.isEnd = true;
+        if (FROM.test(tail))
+            last.components.isStart = true;
+        const r = resolve(g, opts);
+        if (!r)
+            continue;
+        let end = r._end;
+        if (until)
+            end += until[0].length;
+        delete r._end;
+        r.index = g[0].index;
+        r.text = text.slice(g[0].index, end).trim();
+        results.push(r);
+        comps.push(merge(g.map((f) => f.components)));
+    }
+    // "A부터 B까지", "A~B" → 하나의 구간으로 합침
+    const merged = [];
+    for (let i = 0; i < results.length; i++) {
+        const a = results[i], b = results[i + 1];
+        const from = FROM.exec(text.slice(a.index + a.text.length));
+        // "~"는 바로 뒤에 B가 붙어 있을 때만. "부터"는 B가 "까지"로 끝날 때만
+        const tilde = from?.[1] === '~' && b?.index === a.index + a.text.length + from[0].length;
+        if (b && from && (b.end || tilde)) {
+            const bc = comps[i + 1];
+            let end = b.end ?? b.date;
+            if (isTimeOnly(bc)) {
+                end = alignEnd(a.date, bc);
+            }
+            else {
+                // "11월 1일부터 3일까지": 끝에 일만 있으면 시작의 연월을 이어받는다
+                // ("11월 28일부터 2일까지"처럼 시작보다 이르면 다음 달)
+                if (isDayOnly(bc)) {
+                    const y = a.date.getFullYear(), m0 = a.date.getMonth();
+                    end = new Date(y, m0, bc.day, end.getHours(), end.getMinutes());
+                    if (end < a.date)
+                        end = new Date(y, m0 + 1, bc.day, end.getHours(), end.getMinutes());
+                }
+                // "월요일부터 금요일까지": 끝 요일이 시작보다 앞이면 다음 주
+                if (isWeekdayOnly(bc) && end < a.date)
+                    end.setDate(end.getDate() + 7);
+                if (!b.end && !b.hasTime)
+                    end = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 23, 59);
+            }
+            merged.push({ ...a, end, text: text.slice(a.index, b.index + b.text.length).trim() });
+            i++;
+        }
+        else {
+            merged.push(a);
+        }
+    }
+    return merged;
+}
+/**
+ * 문장에서 첫 번째 날짜/시간 표현을 찾는다. 없으면 null.
+ *
+ * @example
+ * parse('그럼 다음주 수요일 저녁 7시에 강남에서 볼까?');
+ * // → { date: 다음주 수요일 19:00, text: '다음주 수요일 저녁 7시', index: 3, hasTime: true }
+ *
+ * @example
+ * parse('이번달 말까지 보내주세요');
+ * // → { date: 기준 시각, end: 이번달 마지막날 23:59, text: '이번달 말까지', hasTime: false, ... }
+ *
+ * @example
+ * parse('오후 3시', { referenceDate: new Date(2026, 9, 30, 14) });
+ * // → 2026-10-30 15:00 (시간만 있으면 오늘, 이미 지났으면 내일)
+ */
+export function parse(text, options) {
+    return parseAll(text, options)[0] ?? null;
+}
+/**
+ * parse()의 date만 돌려주는 단축형. 구간이면 시작 시각.
+ *
+ * @example
+ * parseDate('다음주 화요일 오후 3시'); // → Date
+ * parseDate('아무 날짜도 없음');       // → null
+ */
+export function parseDate(text, options) {
+    return parse(text, options)?.date ?? null;
+}

package/dist/parsers/absoluteDate.d.ts

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

package/dist/parsers/absoluteDate.js

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

package/dist/parsers/duration.d.ts

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

package/dist/parsers/duration.js

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

package/dist/parsers/offset.d.ts

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

package/dist/parsers/offset.js

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

package/dist/parsers/relativeDay.d.ts

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

package/dist/parsers/relativeDay.js

@@ -0,0 +1,22 @@
+const WORDS = {
+    그저께: -2,
+    내일모레: 2,
+    낼모레: 2,
+    낼: 1,
+    그제: -2,
+    어제: -1,
+    오늘: 0,
+    내일: 1,
+    모레: 2,
+    글피: 3,
+};
+// "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
+const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
+/** 오늘/내일/모레/글피/어제/그저께 */
+export 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;
+};

package/dist/parsers/relativeMonth.d.ts

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

package/dist/parsers/relativeMonth.js

@@ -0,0 +1,26 @@
+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;
+/** 이번달/다음달 (초/중순/말) */
+export 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;
+};

package/dist/parsers/relativeYear.d.ts

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

package/dist/parsers/relativeYear.js

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

package/dist/parsers/time.d.ts

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