@bluessu/meal-scraper 0.1.0

package/dist/index.cjs

@@ -0,0 +1,953 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseCafeteriaException: () => BaseCafeteriaException,
+  CafeteriaType: () => CafeteriaType,
+  HolidayException: () => HolidayException,
+  MealClient: () => MealClient,
+  MenuFetchException: () => MenuFetchException,
+  MenuParseException: () => MenuParseException,
+  buildDateRange: () => buildDateRange,
+  createMealClient: () => createMealClient,
+  defaultSettings: () => defaultSettings,
+  normalizeMenuDate: () => normalizeMenuDate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var BaseCafeteriaException = class extends Error {
+  constructor(targetDate, cafeteria, message, rawData, context = {}) {
+    const withContext = Object.keys(context).length > 0 ? `${message} | context=${JSON.stringify(context)}` : message;
+    super(`${cafeteria}(${targetDate}) ${withContext}`);
+    this.targetDate = targetDate;
+    this.cafeteria = cafeteria;
+    this.rawData = rawData;
+    this.name = this.constructor.name;
+    this.context = context;
+  }
+};
+var HolidayException = class extends BaseCafeteriaException {
+};
+var MenuFetchException = class extends BaseCafeteriaException {
+};
+var MenuParseException = class extends BaseCafeteriaException {
+};
+
+// src/domain.ts
+var CafeteriaType = /* @__PURE__ */ ((CafeteriaType2) => {
+  CafeteriaType2["HAKSIK"] = "HAKSIK";
+  CafeteriaType2["DODAM"] = "DODAM";
+  CafeteriaType2["FACULTY"] = "FACULTY";
+  CafeteriaType2["DORMITORY"] = "DORMITORY";
+  return CafeteriaType2;
+})(CafeteriaType || {});
+var CafeteriaStatus = {
+  Open: "open",
+  Closed: "closed"
+};
+var normalizeMenuSlot = (slot) => {
+  const normalized = String(slot ?? "").replace(/\s+/g, "").trim();
+  if (normalized.includes("\uC870\uC2DD") || normalized.includes("\uC544\uCE68") || normalized.includes("breakfast")) {
+    return "breakfast";
+  }
+  if (normalized.includes("\uC911\uC2DD") || normalized.includes("\uC810\uC2EC") || normalized.includes("lunch")) {
+    return "lunch";
+  }
+  if (normalized.includes("\uC11D\uC2DD") || normalized.includes("\uC800\uB141") || normalized.includes("dinner")) {
+    return "dinner";
+  }
+  return void 0;
+};
+var createDailyMenu = (date, cafeteria, menus, status = CafeteriaStatus.Open) => {
+  return { date, cafeteria, status, ...menus };
+};
+
+// src/parsers/noopMenuParser.ts
+var splitItems = (text) => text.split(/[\n\/,]/).flatMap((line) => line.split("&")).flatMap((line) => line.split(" ")).map((s) => s.replace(/\*/g, "").trim()).filter(Boolean);
+var NoopMenuParser = class {
+  async parseMenu(raw) {
+    try {
+      const dailyMenu = createDailyMenu(raw.date, raw.cafeteria, {
+        breakfast: {},
+        lunch: {},
+        dinner: {}
+      });
+      for (const [slot, text] of Object.entries(raw.menuTexts)) {
+        const items = splitItems(text).filter((item) => /[가-힣]/.test(item));
+        const slotKey = normalizeMenuSlot(slot);
+        if (!slotKey) continue;
+        dailyMenu[slotKey] = {
+          ...dailyMenu[slotKey],
+          [slot]: [...new Set(items)]
+        };
+      }
+      return dailyMenu;
+    } catch (err) {
+      throw new MenuParseException(
+        raw.date,
+        raw.cafeteria,
+        "\uAE30\uBCF8 \uD30C\uC2F1 \uC2E4\uD328",
+        err
+      );
+    }
+  }
+};
+
+// src/parsers/gptMenuParser.ts
+var SYSTEM_PROMPT = `\uB2F9\uC2E0\uC740 \uD55C\uAD6D \uB300\uD559 \uC2DD\uB2F9 \uBA54\uB274 \uB370\uC774\uD130\uB97C \uC815\uD655\uD558\uAC8C \uD30C\uC2F1\uD558\uB294 \uC804\uBB38\uAC00\uC785\uB2C8\uB2E4.
+- \uBA54\uB274\uBA85\uB9CC \uCD94\uCD9C\uD574\uC11C \uC544\uB798 JSON \uD615\uC2DD\uC73C\uB85C \uBC18\uD658:
+  { "menus": ["\uBA54\uB274\uBA851", "\uBA54\uB274\uBA852"] }
+- \uBA54\uB274\uBA85\uC740 \uD55C\uAE00\uB9CC \uC0AC\uC6A9
+- \uBD88\uD544\uC694\uD55C \uC218\uC2DD\uC5B4 (\uC608: "\uB9DB\uC788\uB294", "\uC2E0\uC120\uD55C")\uB294 \uC81C\uAC70
+- \uC911\uBCF5\uB41C \uBA54\uB274\uBA85\uC740 \uD55C \uBC88\uB9CC \uC791\uC131
+- \uBA54\uB274\uBA85\uC774 \uC5C6\uB294 \uACBD\uC6B0 menus\uB294 \uBE48 \uBC30\uC5F4\uB85C \uBC18\uD658
+- JSON \uC678 \uD14D\uC2A4\uD2B8\uB97C \uC808\uB300 \uD3EC\uD568\uD558\uC9C0 \uC54A\uC74C
+- \uBA54\uC778 \uBA54\uB274\uB97C \uAC00\uC7A5 \uC55E\uC5D0 \uBC30\uCE58
+`;
+var GPTMenuParser = class _GPTMenuParser {
+  static {
+    this.model = "gpt-5-nano";
+  }
+  constructor(apiKey) {
+    const openAI = this.resolveOpenAI(apiKey);
+    this.client = openAI;
+  }
+  async resolveOpenAI(apiKey) {
+    try {
+      const mod = await import("openai");
+      const OpenAIConstructor = mod.default ?? mod.OpenAI;
+      if (!OpenAIConstructor) {
+        throw new Error(
+          "openai \uBAA8\uB4C8\uC5D0\uC11C OpenAI \uD074\uB798\uC2A4 \uCD08\uAE30\uD654\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4."
+        );
+      }
+      return new OpenAIConstructor({ apiKey });
+    } catch (err) {
+      const isModuleNotFound = err instanceof Error && (err.message.includes("Cannot find module") || err.code === "ERR_MODULE_NOT_FOUND");
+      if (isModuleNotFound) {
+        throw new Error(
+          'openai \uD328\uD0A4\uC9C0\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. parser="gpt" \uC0AC\uC6A9 \uC2DC `pnpm add openai`\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.'
+        );
+      }
+      throw err;
+    }
+  }
+  sanitizeMenuName(menu) {
+    return String(menu).replace(/^[\s\-\*\u2022·•\d\.\)]+/g, "").replace(/\s+/g, " ").trim();
+  }
+  normalizeTextForParsing(text) {
+    const tokens = text.replace(/\s+/g, " ").trim().split(" ").filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+      return "";
+    }
+    const maxPhraseLength = 12;
+    const normalized = [];
+    for (let i = 0; i < tokens.length; ) {
+      const remaining = tokens.length - i;
+      const maxLen = Math.min(maxPhraseLength, Math.floor(remaining / 2));
+      let matchedLen = 1;
+      for (let len = maxLen; len >= 1; len--) {
+        let isRepeated = true;
+        for (let j = 0; j < len; j++) {
+          if (tokens[i + j] !== tokens[i + len + j]) {
+            isRepeated = false;
+            break;
+          }
+        }
+        if (isRepeated) {
+          matchedLen = len;
+          break;
+        }
+      }
+      normalized.push(...tokens.slice(i, i + matchedLen));
+      i += matchedLen * 2;
+    }
+    return normalized.join(" ");
+  }
+  async parseMenuText(text) {
+    if (!text || text.trim().length === 0) {
+      return [];
+    }
+    const normalizedText = this.normalizeTextForParsing(text);
+    if (!normalizedText) {
+      return [];
+    }
+    const client = await this.client;
+    const result = await client.chat.completions.create({
+      model: _GPTMenuParser.model,
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        {
+          role: "user",
+          content: `\uB2E4\uC74C \uD14D\uC2A4\uD2B8\uC5D0\uC11C \uBA54\uB274\uBA85\uB9CC \uCD94\uCD9C\uD558\uC138\uC694.
+
+${normalizedText}`
+        }
+      ],
+      response_format: { type: "json_object" }
+    });
+    if (!result?.choices || !result.choices.length) {
+      throw new Error("\uBAA8\uB378 \uC751\uB2F5 \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+    }
+    const content = result.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("\uBAA8\uB378 \uC751\uB2F5\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.");
+    }
+    const parsed = JSON.parse(content);
+    const menus = parsed?.menus;
+    if (!Array.isArray(menus)) {
+      throw new Error("menus \uBC30\uC5F4\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    }
+    return menus.map((item) => this.sanitizeMenuName(String(item))).filter((item) => item.length > 0);
+  }
+  async parseMenu(raw) {
+    const menus = {
+      breakfast: {},
+      lunch: {},
+      dinner: {}
+    };
+    const errors = {};
+    await Promise.all(
+      Object.entries(raw.menuTexts).map(async ([slot, text]) => {
+        try {
+          const unique = /* @__PURE__ */ new Set();
+          const parsed = await this.parseMenuText(text);
+          const slotKey = normalizeMenuSlot(slot);
+          if (!slotKey) return;
+          parsed.forEach((menu) => unique.add(menu));
+          menus[slotKey][slot] = Array.from(unique);
+        } catch (err) {
+          errors[slot] = String(err);
+        }
+      })
+    );
+    if (Object.keys(errors).length > 0) {
+      throw new MenuParseException(
+        raw.date,
+        raw.cafeteria,
+        "\uC77C\uBD80 \uC2AC\uB86F \uD30C\uC2F1 \uC2E4\uD328",
+        JSON.stringify(errors)
+      );
+    }
+    return createDailyMenu(raw.date, raw.cafeteria, menus);
+  }
+};
+
+// src/repositories/scrapers/soongguriScraper.ts
+var import_axios = __toESM(require("axios"));
+
+// src/config.ts
+var defaultSettings = {
+  soongguriBaseUrl: "http://m.soongguri.com/m_req/m_menu.php",
+  dormitoryBaseUrl: "https://ssudorm.ssu.ac.kr:444/SShostel/mall_main.php",
+  haksikRcd: 1,
+  dodamRcd: 2,
+  facultyRcd: 7,
+  timeoutMs: 15e3
+};
+var getRcd = (type, settings) => {
+  switch (type) {
+    case "HAKSIK" /* HAKSIK */:
+      return settings.haksikRcd;
+    case "DODAM" /* DODAM */:
+      return settings.dodamRcd;
+    case "FACULTY" /* FACULTY */:
+      return settings.facultyRcd;
+    default:
+      return 0;
+  }
+};
+
+// src/utils/parsing.ts
+var cheerio = __toESM(require("cheerio"));
+var normalizeText = (v) => v.replace(/\r/g, "").replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+var parseTableToDict = (html) => {
+  const $ = cheerio.load(html);
+  const result = {};
+  const parseWithMenuClass = () => {
+    $("tr").each((_, tr) => {
+      const menuSlot = $(tr).find("td.menu_nm").first().text().trim();
+      if (!menuSlot) return;
+      const rowText = $(tr).find("*").contents().toArray().map((node) => $(node).text()).join(" ");
+      const cleaned = normalizeText(rowText);
+      result[menuSlot] = cleaned;
+    });
+  };
+  const parseFallbackRows = () => {
+    const slotKeywords = /조식|중식|석식|점심|저녁|아침/;
+    $("tr").each((_, tr) => {
+      const cells = $(tr).find("td, th").toArray();
+      if (cells.length < 2) return;
+      const key = normalizeText($(cells[0]).text());
+      if (!key || !slotKeywords.test(key)) return;
+      const values = cells.slice(1).map((cell) => normalizeText($(cell).text())).filter((value) => value.length > 0).join(" ");
+      if (!values) return;
+      result[key] = values;
+    });
+  };
+  parseWithMenuClass();
+  if (!Object.keys(result).length) {
+    parseFallbackRows();
+  }
+  return result;
+};
+var stripStringFromDict = (menuDict) => {
+  const out = {};
+  for (const [key, value] of Object.entries(menuDict)) {
+    out[key] = normalizeText(value);
+  }
+  return out;
+};
+var make2d = (tableHtml) => {
+  if (!tableHtml) return [];
+  let $ = cheerio.load(tableHtml);
+  let rows = $("tr");
+  if (!rows.length) {
+    $ = cheerio.load(`<table>${tableHtml}</table>`);
+    rows = $("tr");
+  }
+  const matrix = [];
+  const toSpan = (value) => {
+    const v = Number.parseInt(value ?? "1", 10);
+    return Number.isNaN(v) || v < 1 ? 1 : v;
+  };
+  rows.each((rIdx, tr) => {
+    const rowCells = $(tr).children("th,td");
+    if (!matrix[rIdx]) matrix[rIdx] = [];
+    let cIdx = 0;
+    rowCells.each((_, cell) => {
+      while (matrix[rIdx][cIdx] !== void 0) cIdx += 1;
+      const txt = normalizeText($(cell).text());
+      const colspan = toSpan($(cell).attr("colspan"));
+      const rowspan = toSpan($(cell).attr("rowspan"));
+      for (let cc = 0; cc < colspan; cc++) {
+        matrix[rIdx][cIdx + cc] = txt;
+      }
+      for (let rr = 1; rr < rowspan; rr++) {
+        const targetRow = rIdx + rr;
+        if (!matrix[targetRow]) matrix[targetRow] = [];
+        for (let cc = 0; cc < colspan; cc++) {
+          matrix[targetRow][cIdx + cc] = txt;
+        }
+      }
+      cIdx += colspan;
+    });
+  });
+  return matrix.map((row) => row.map((v) => normalizeText(v ?? "")));
+};
+var make2dFromHtml = (html) => {
+  const $ = cheerio.load(html);
+  const table = $("table.boxstyle02").first();
+  if (!table.length) return [];
+  const tableHtml = table.html();
+  if (!tableHtml) return [];
+  return make2d(tableHtml);
+};
+
+// src/repositories/scrapers/soongguriScraper.ts
+var SoongguriScraper = class {
+  constructor(settings, cafeteriaType) {
+    this.settings = settings;
+    this.cafeteriaType = cafeteriaType;
+  }
+  async scrapeMenu(date) {
+    const normalizedDate = normalizeSgDate(date);
+    const url = `${this.settings.soongguriBaseUrl}?rcd=${getRcd(this.cafeteriaType, this.settings)}&sdt=${normalizedDate}`;
+    try {
+      const res = await import_axios.default.get(url, {
+        timeout: this.settings.timeoutMs,
+        responseType: "text",
+        validateStatus: (s) => s >= 200 && s < 300
+      });
+      const html = String(res.data);
+      const hasHoliday = html.includes("\uC624\uB298\uC740 \uC27D\uB2C8\uB2E4.") || html.includes("\uD734\uBB34");
+      if (hasHoliday) {
+        throw new HolidayException(
+          date,
+          this.cafeteriaType,
+          "\uD574\uB2F9\uC77C\uC740 \uD734\uBB34\uC77C\uC785\uB2C8\uB2E4.",
+          html,
+          {
+            endpoint: url,
+            operation: "scrape",
+            cafeteria: this.cafeteriaType,
+            timeoutMs: this.settings.timeoutMs
+          }
+        );
+      }
+      const parsed = parseTableToDict(html);
+      const menus = stripStringFromDict(parsed);
+      if (!Object.keys(menus).length) {
+        throw new MenuFetchException(
+          date,
+          this.cafeteriaType,
+          "\uBA54\uB274\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+          { menus, html },
+          {
+            endpoint: url,
+            operation: "parse",
+            cafeteria: this.cafeteriaType,
+            timeoutMs: this.settings.timeoutMs
+          }
+        );
+      }
+      return {
+        date,
+        cafeteria: this.cafeteriaType,
+        menuTexts: menus
+      };
+    } catch (err) {
+      if (err instanceof HolidayException) {
+        throw err;
+      }
+      if (err instanceof BaseCafeteriaException) {
+        throw err;
+      }
+      const raw = err;
+      const statusCode = raw?.status ?? raw?.response?.status;
+      const statusText = raw?.response?.statusText;
+      throw new MenuFetchException(
+        date,
+        this.cafeteriaType,
+        "\uBA54\uB274 \uC218\uC9D1 \uC2E4\uD328",
+        err,
+        {
+          endpoint: url,
+          cafeteria: this.cafeteriaType,
+          statusCode,
+          statusText,
+          timeoutMs: this.settings.timeoutMs
+        }
+      );
+    }
+  }
+};
+var normalizeSgDate = (date) => {
+  const digits = date.replace(/\D/g, "").slice(0, 8);
+  return digits.length === 8 ? digits : date;
+};
+
+// src/repositories/scrapers/haksikScraper.ts
+var HaksikScraper = class extends SoongguriScraper {
+  constructor(settings) {
+    super(settings, "HAKSIK" /* HAKSIK */);
+  }
+};
+
+// src/repositories/scrapers/dodamScraper.ts
+var DodamScraper = class extends SoongguriScraper {
+  constructor(settings) {
+    super(settings, "DODAM" /* DODAM */);
+  }
+};
+
+// src/repositories/scrapers/facultyScraper.ts
+var FacultyScraper = class extends SoongguriScraper {
+  constructor(settings) {
+    super(settings, "FACULTY" /* FACULTY */);
+  }
+};
+
+// src/repositories/scrapers/dormitoryScraper.ts
+var import_axios2 = __toESM(require("axios"));
+var DormitoryScraper = class {
+  constructor(baseUrl, timeoutMs = 15e3) {
+    this.baseUrl = baseUrl;
+    this.timeoutMs = timeoutMs;
+  }
+  async scrapeMenu(date) {
+    const dt = parseDate(date);
+    const targetDate = formatDateKey(dt);
+    const endpoint = this.baseUrl;
+    try {
+      const res = await import_axios2.default.get(this.baseUrl, {
+        params: {
+          viewform: "B0001_foodboard_list",
+          gyear: dt.getFullYear(),
+          gmonth: dt.getMonth() + 1,
+          gday: dt.getDate()
+        },
+        timeout: this.timeoutMs,
+        responseType: "arraybuffer",
+        validateStatus: (s) => s >= 200 && s < 300
+      });
+      const bytes = new Uint8Array(res.data);
+      const encoding = detectEncoding({
+        data: res.data,
+        headers: res.headers
+      });
+      const html = new TextDecoder(encoding).decode(bytes);
+      const matrix = make2dFromHtml(html);
+      const parsedRows = structureRows(matrix);
+      let matched;
+      for (const row of parsedRows) {
+        const dateStr = parseDateTokenKey(row["\uB0A0\uC9DC"]);
+        if (!dateStr) continue;
+        const menuTexts = extractMenuTexts(row);
+        if (Object.keys(menuTexts).length === 0) continue;
+        if (dateStr !== targetDate) continue;
+        matched = {
+          date: dateStr,
+          cafeteria: "DORMITORY" /* DORMITORY */,
+          menuTexts
+        };
+        break;
+      }
+      if (!matched) {
+        throw new MenuFetchException(
+          date,
+          "DORMITORY" /* DORMITORY */,
+          "\uC694\uCCAD\uD55C \uB0A0\uC9DC\uC758 \uBA54\uB274\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
+          void 0,
+          {
+            endpoint,
+            operation: "match",
+            cafeteria: "DORMITORY" /* DORMITORY */
+          }
+        );
+      }
+      return matched;
+    } catch (err) {
+      if (err instanceof HolidayException) {
+        throw err;
+      }
+      if (err instanceof BaseCafeteriaException) {
+        throw err;
+      }
+      const raw = err;
+      const statusCode = raw?.status ?? raw?.response?.status;
+      const statusText = raw?.response?.statusText;
+      throw new MenuFetchException(
+        date,
+        "DORMITORY" /* DORMITORY */,
+        "\uAE30\uC219\uC0AC \uBA54\uB274 \uD30C\uC2F1 \uC2E4\uD328",
+        err,
+        {
+          endpoint,
+          operation: "parse",
+          cafeteria: "DORMITORY" /* DORMITORY */,
+          timeoutMs: this.timeoutMs,
+          targetDate,
+          statusCode,
+          statusText
+        }
+      );
+    }
+  }
+};
+var detectEncoding = (res) => {
+  const header = String(res.headers["content-type"] ?? "").toLowerCase();
+  const headerCharset = header.match(/charset=([a-z0-9-]+)/i)?.[1];
+  if (headerCharset) {
+    const lower = headerCharset.toLowerCase();
+    if (lower.includes("utf-8") || lower.includes("utf8")) return "utf-8";
+    if (lower.includes("euc-kr") || lower.includes("cp949")) return "euc-kr";
+  }
+  const latin1Text = new TextDecoder("latin1").decode(new Uint8Array(res.data));
+  const metaCharset = latin1Text.match(
+    /<meta[^>]*charset\s*=\s*([a-z0-9-]+)/i
+  )?.[1];
+  if (metaCharset) {
+    const lower = metaCharset.toLowerCase();
+    if (lower.includes("utf-8") || lower.includes("utf8")) return "utf-8";
+    if (lower.includes("euc-kr") || lower.includes("cp949")) return "euc-kr";
+  }
+  return "euc-kr";
+};
+var parseDate = (date) => {
+  if (/^\d{8}$/.test(date)) {
+    const year = Number(date.slice(0, 4));
+    const month = Number(date.slice(4, 6));
+    const day = Number(date.slice(6, 8));
+    return new Date(year, month - 1, day);
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    const [year, month, day] = date.split("-");
+    return new Date(
+      Number(year),
+      Number(month) - 1,
+      Number(day)
+    );
+  }
+  return new Date(date);
+};
+var formatDateKey = (date) => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+};
+var parseDateTokenKey = (value) => {
+  if (!value) return "";
+  const trimmed = value.split(/\s+/)[0];
+  const withDash = trimmed.replace(/[.]/g, "-");
+  if (/^\d{4}-\d{2}-\d{2}$/.test(withDash)) {
+    return withDash;
+  }
+  const compact = withDash.replace(/-/g, "");
+  if (/^\d{8}$/.test(compact)) {
+    const year = Number(compact.slice(0, 4));
+    const month = Number(compact.slice(4, 6));
+    const day = Number(compact.slice(6, 8));
+    const parsed = new Date(year, month - 1, day);
+    if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) {
+      return "";
+    }
+    return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  }
+  if (/^\d{4}$/.test(compact)) {
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const month = Number(compact.slice(0, 2));
+    const day = Number(compact.slice(2, 4));
+    const parsed = new Date(year, month - 1, day);
+    if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) {
+      return "";
+    }
+    return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  }
+  if (/^\d{2}-\d{2}$/.test(withDash)) {
+    const [monthPart, dayPart] = withDash.split("-");
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const month = Number(monthPart);
+    const day = Number(dayPart);
+    const parsed = new Date(year, month - 1, day);
+    if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) {
+      return "";
+    }
+    return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  }
+  return "";
+};
+var structureRows = (matrix) => {
+  if (!matrix.length) return [];
+  const headers = matrix[0];
+  const dateCol = headers.findIndex((h) => h === "\uB0A0\uC9DC");
+  if (dateCol < 0) return [];
+  const colMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < headers.length; i++) {
+    if (headers[i] === "\uC870\uC2DD" || headers[i] === "\uC911\uC2DD" || headers[i] === "\uC11D\uC2DD") {
+      colMap.set(i, headers[i]);
+    }
+  }
+  const out = [];
+  for (let r = 1; r < matrix.length; r++) {
+    const row = matrix[r];
+    if (!row || !row[dateCol]) continue;
+    const dict = { \uB0A0\uC9DC: row[dateCol] || "" };
+    for (const [idx, key] of colMap) {
+      dict[key] = row[idx] || "";
+    }
+    out.push(dict);
+  }
+  return out;
+};
+var extractMenuTexts = (row) => {
+  const out = {};
+  ["\uC911\uC2DD", "\uC11D\uC2DD"].forEach((slot) => {
+    const value = row[slot];
+    if (!value) return;
+    const items = value.split("\r\n").map((x) => x.trim()).filter((x) => x.length > 0 && !x.includes("\uC6B4\uC601"));
+    if (items.length > 0) {
+      out[slot] = items.join(" ");
+    }
+  });
+  return out;
+};
+
+// src/services/scrapingService.ts
+var FoodScrapingService = class {
+  constructor(settings = defaultSettings, parser, parserMode = "noop") {
+    this.settings = settings;
+    this.parser = parser;
+    this.parserMode = parserMode;
+  }
+  createScraper(cafeteriaType) {
+    if (cafeteriaType === "HAKSIK" /* HAKSIK */) {
+      return new HaksikScraper(this.settings);
+    }
+    if (cafeteriaType === "DODAM" /* DODAM */) {
+      return new DodamScraper(this.settings);
+    }
+    if (cafeteriaType === "FACULTY" /* FACULTY */) {
+      return new FacultyScraper(this.settings);
+    }
+    if (cafeteriaType === "DORMITORY" /* DORMITORY */) {
+      return new DormitoryScraper(
+        this.settings.dormitoryBaseUrl,
+        this.settings.timeoutMs
+      );
+    }
+    throw new Error(`Unsupported cafeteria: ${cafeteriaType}`);
+  }
+  async scrapeRawMenu(cafeteriaType, date) {
+    try {
+      const scraper = this.createScraper(cafeteriaType);
+      return await scraper.scrapeMenu(date);
+    } catch (err) {
+      if (err instanceof BaseCafeteriaException) throw err;
+      throw new MenuFetchException(
+        date,
+        cafeteriaType,
+        "scrape \uC2E4\uD328",
+        err,
+        {
+          targetDate: date,
+          cafeteria: cafeteriaType,
+          operation: "scrape"
+        }
+      );
+    }
+  }
+  async scrapeAndParseMenu(cafeteriaType, date) {
+    try {
+      const raw = await this.scrapeRawMenu(cafeteriaType, date);
+      return await this.parse(raw);
+    } catch (err) {
+      if (err instanceof HolidayException) {
+        return createDailyMenu(
+          date,
+          cafeteriaType,
+          {
+            breakfast: {},
+            lunch: {},
+            dinner: {}
+          },
+          CafeteriaStatus.Closed
+        );
+      }
+      throw err;
+    }
+  }
+  async parse(raw) {
+    try {
+      return await this.parser.parseMenu(raw);
+    } catch (err) {
+      if (err instanceof BaseCafeteriaException) {
+        err.context = {
+          ...err.context,
+          parserMode: this.parserMode,
+          operation: "parse",
+          targetDate: raw.date,
+          cafeteria: raw.cafeteria
+        };
+        throw err;
+      }
+      throw new MenuParseException(
+        raw.date,
+        raw.cafeteria,
+        "parse \uC2E4\uD328",
+        err,
+        {
+          parserMode: this.parserMode,
+          operation: "parse",
+          targetDate: raw.date,
+          cafeteria: raw.cafeteria
+        }
+      );
+    }
+  }
+};
+
+// src/client/dateUtils.ts
+var MENU_DATE_COMPACT_RE = /^\d{8}$/;
+var MENU_DATE_ISO_RE = /^\d{4}-\d{2}-\d{2}$/;
+var toDate = (value) => {
+  if (MENU_DATE_COMPACT_RE.test(value)) {
+    const year = Number(value.slice(0, 4));
+    const month = Number(value.slice(4, 6));
+    const day = Number(value.slice(6, 8));
+    const date = new Date(year, month - 1, day);
+    const isValidDate = date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+    if (!isValidDate) {
+      throw new RangeError(`invalid menu date: ${value}`);
+    }
+    return date;
+  }
+  if (MENU_DATE_ISO_RE.test(value)) {
+    const [y, m, d] = value.split("-");
+    const year = Number(y);
+    const month = Number(m);
+    const day = Number(d);
+    const date = new Date(year, month - 1, day);
+    const isValidDate = date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+    if (!isValidDate) {
+      throw new RangeError(`invalid menu date: ${value}`);
+    }
+    return date;
+  }
+  throw new RangeError(`invalid menu date: ${value}`);
+};
+var normalizeMenuDate = (input) => {
+  let date;
+  if (input instanceof Date) {
+    date = input;
+  } else if (typeof input === "string") {
+    if (MENU_DATE_COMPACT_RE.test(input) || MENU_DATE_ISO_RE.test(input)) {
+      date = toDate(input);
+    } else {
+      date = new Date(input);
+    }
+  } else {
+    throw new TypeError("menu date must be a Date or string");
+  }
+  if (Number.isNaN(date.getTime())) {
+    throw new RangeError(`invalid menu date: ${String(input)}`);
+  }
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+};
+var buildDateRange = (start, end) => {
+  const parse = (value) => {
+    if (!MENU_DATE_COMPACT_RE.test(value) && !MENU_DATE_ISO_RE.test(value)) {
+      throw new RangeError(`invalid menu date: ${value}`);
+    }
+    return toDate(value);
+  };
+  const startDate = parse(start);
+  const endDate = parse(end);
+  if (startDate > endDate) {
+    throw new RangeError(`start date must not be after end date: ${start} ~ ${end}`);
+  }
+  const out = [];
+  const cursor = new Date(startDate);
+  while (cursor <= endDate) {
+    out.push(normalizeMenuDate(cursor));
+    cursor.setDate(cursor.getDate() + 1);
+  }
+  return out;
+};
+
+// src/client/concurrency.ts
+var runWithConcurrency = async (tasks, concurrency) => {
+  const limit = Math.max(1, Math.floor(concurrency) || 1);
+  const results = new Array(tasks.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (true) {
+      const current = cursor;
+      cursor += 1;
+      if (current >= tasks.length) {
+        return;
+      }
+      results[current] = await tasks[current]();
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, tasks.length) }, () => worker())
+  );
+  return results;
+};
+
+// src/client/mealClient.ts
+var DEFAULT_CONCURRENCY = 3;
+var MealClient = class {
+  constructor(options = {}) {
+    const settings = {
+      ...defaultSettings,
+      ...options.settings ?? {}
+    };
+    let parser;
+    const parserMode = options.parser ?? "noop";
+    if (parserMode === "gpt") {
+      if (!options.gptApiKey) {
+        throw new Error("gpt parser requires gptApiKey");
+      }
+      parser = new GPTMenuParser(options.gptApiKey);
+    } else if (parserMode === "custom") {
+      if (!options.parserImpl) {
+        throw new Error("custom parser requires parserImpl");
+      }
+      parser = options.parserImpl;
+    } else {
+      parser = new NoopMenuParser();
+    }
+    this.service = new FoodScrapingService(settings, parser, parserMode);
+  }
+  getRawMenu(cafeteria, date) {
+    return this.service.scrapeRawMenu(cafeteria, normalizeMenuDate(date));
+  }
+  getDailyMenu(cafeteria, date) {
+    return this.service.scrapeAndParseMenu(cafeteria, normalizeMenuDate(date));
+  }
+  async getRawMenus(cafeteria, dates, options = {}) {
+    const normalizedDates = dates.map(normalizeMenuDate);
+    const concurrencyLimit = options.concurrency ?? DEFAULT_CONCURRENCY;
+    const tasks = normalizedDates.map(
+      (date) => () => this.service.scrapeRawMenu(cafeteria, date)
+    );
+    return runWithConcurrency(tasks, concurrencyLimit);
+  }
+  async getDailyMenus(cafeteria, dates, options = {}) {
+    const normalizedDates = dates.map(normalizeMenuDate);
+    const concurrencyLimit = options.concurrency ?? DEFAULT_CONCURRENCY;
+    const tasks = normalizedDates.map(
+      (date) => () => this.service.scrapeAndParseMenu(cafeteria, date)
+    );
+    return runWithConcurrency(tasks, concurrencyLimit);
+  }
+  async getRawMenusByRange(cafeteria, start, end, options = {}) {
+    const range = buildDateRange(
+      normalizeMenuDate(start),
+      normalizeMenuDate(end)
+    );
+    const startOffset = options.startInclusive === false ? 1 : 0;
+    const targetDates = range.slice(startOffset);
+    return this.getRawMenus(cafeteria, targetDates, options);
+  }
+  async getDailyMenusByRange(cafeteria, start, end, options = {}) {
+    const range = buildDateRange(
+      normalizeMenuDate(start),
+      normalizeMenuDate(end)
+    );
+    const startOffset = options.startInclusive === false ? 1 : 0;
+    const targetDates = range.slice(startOffset);
+    return this.getDailyMenus(cafeteria, targetDates, options);
+  }
+};
+var createMealClient = (options) => {
+  return new MealClient(options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCafeteriaException,
+  CafeteriaType,
+  HolidayException,
+  MealClient,
+  MenuFetchException,
+  MenuParseException,
+  buildDateRange,
+  createMealClient,
+  defaultSettings,
+  normalizeMenuDate
+});