daiso 1.0.4 → 1.0.6

package/dist/services/lottemart/client.js

@@ -0,0 +1,254 @@
+/**
+ * 롯데마트 모바일 도와센터 클라이언트
+ */
+import { LOTTEMART_API } from './api.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+import { __testOnlyClearLotteMartGeocodeCache, geocodeLotteMartAddress } from './geocode.js';
+import { __testOnlyClearLotteMartSessionCache, fetchLotteMartHtml, fetchLotteMartPageWithSession, getCachedLotteMartSessionCookie, } from './session.js';
+import { attachDistance, fetchAllStoresForAreaList, fetchKeywordMatchedStores, getTargetAreas, normalizeArea, toDisplayArea, } from './storeSearch.js';
+import { calculateDistanceM, dedupeProducts, matchesBrandVariant, matchesKeyword, parseMarketOptions, parseProductSummary, parseProducts, parseStores, sortStores, } from './parser.js';
+import { createZettaFallbackStore, fetchZettaLotteMartProducts, fetchZettaLotteMartProductsWithPrimaryError } from './zetta.js';
+const STORE_CACHE_TTL_MS = 30 * 60 * 1000;
+const LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS = 7000;
+const storeCache = new Map();
+async function getLotteMartSessionCookie(options) {
+    if (options.sessionCookie) {
+        return options.sessionCookie;
+    }
+    return getCachedLotteMartSessionCookie(options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS);
+}
+export async function fetchLotteMartMarketOptions(area, type, options = {}) {
+    const normalizedArea = normalizeArea(area);
+    if (!normalizedArea) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    const endpoint = new URL(LOTTEMART_API.MARKET_OPTIONS_PATH, LOTTEMART_API.BASE_URL);
+    endpoint.searchParams.set('p_area', normalizedArea);
+    endpoint.searchParams.set('p_type', type);
+    const html = await fetchLotteMartHtml(endpoint.toString(), {
+        method: 'GET',
+        headers: {
+            Accept: 'text/html, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+        },
+    }, options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    return parseMarketOptions(toDisplayArea(normalizedArea), html);
+}
+export async function fetchLotteMartStoresByArea(area, options = {}) {
+    const normalizedArea = normalizeArea(area);
+    if (!normalizedArea) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    const cacheKey = normalizedArea;
+    const cached = storeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.stores;
+    }
+    const body = new URLSearchParams();
+    body.set('m_area', normalizedArea);
+    const html = await fetchLotteMartPageWithSession(LOTTEMART_API.STORE_SEARCH_PATH, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: body.toString(),
+    }, options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    const stores = parseStores(toDisplayArea(normalizedArea), html);
+    storeCache.set(cacheKey, {
+        expiresAt: Date.now() + STORE_CACHE_TTL_MS,
+        stores,
+    });
+    return stores;
+}
+async function fetchLotteMartStoresByAreaKeyword(area, keyword, options) {
+    const normalizedArea = normalizeArea(area);
+    const normalizedKeyword = keyword.trim();
+    const cacheKey = `${normalizedArea}:${normalizedKeyword}`;
+    const cached = storeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.stores;
+    }
+    const body = new URLSearchParams();
+    body.set('m_area', normalizedArea);
+    body.set('m_schWord', normalizedKeyword);
+    const html = await fetchLotteMartPageWithSession(LOTTEMART_API.STORE_SEARCH_PATH, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: body.toString(),
+    }, options.timeout, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    const stores = parseStores(toDisplayArea(normalizedArea), html);
+    storeCache.set(cacheKey, {
+        expiresAt: Date.now() + STORE_CACHE_TTL_MS,
+        stores,
+    });
+    return stores;
+}
+export async function fetchLotteMartStores(params = {}, options = {}) {
+    const { area, keyword = '', brandVariant = '', latitude, longitude, limit = 20 } = params;
+    const { timeout = DEFAULT_LOTTEMART_TIMEOUT_MS, googleMapsApiKey } = options;
+    if (area && !normalizeArea(area)) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    let resolvedLatitude = latitude;
+    let resolvedLongitude = longitude;
+    let geocodeUsed = false;
+    if ((typeof resolvedLatitude !== 'number' || typeof resolvedLongitude !== 'number') &&
+        keyword.trim().length > 0) {
+        const geocoded = await geocodeLotteMartAddress(keyword, { timeout, googleMapsApiKey });
+        if (geocoded) {
+            resolvedLatitude = geocoded.latitude;
+            resolvedLongitude = geocoded.longitude;
+            geocodeUsed = true;
+        }
+    }
+    const sessionCookie = await getLotteMartSessionCookie({ timeout });
+    const targetAreas = getTargetAreas(area);
+    const hasKeyword = keyword.trim().length > 0;
+    const fetchAreaStores = (currentArea) => hasKeyword
+        ? fetchLotteMartStoresByAreaKeyword(currentArea, keyword, {
+            timeout,
+            sessionCookie,
+            zyteApiKey: options.zyteApiKey,
+        })
+        : fetchLotteMartStoresByArea(currentArea, { timeout, sessionCookie, zyteApiKey: options.zyteApiKey });
+    const keywordMatchedStores = hasKeyword
+        ? await fetchKeywordMatchedStores(targetAreas, keyword, brandVariant, limit, fetchAreaStores)
+        : [];
+    const useKeywordMatchedStores = keywordMatchedStores.length > 0 || hasKeyword;
+    const stores = useKeywordMatchedStores
+        ? keywordMatchedStores
+        : await fetchAllStoresForAreaList(targetAreas, fetchAreaStores);
+    const filtered = attachDistance(useKeywordMatchedStores
+        ? stores
+        : stores
+            .filter((store) => matchesKeyword(store, keyword))
+            .filter((store) => matchesBrandVariant(store, brandVariant)), resolvedLatitude, resolvedLongitude);
+    const enriched = await Promise.all(filtered.map(async (store) => {
+        if (typeof resolvedLatitude !== 'number' ||
+            typeof resolvedLongitude !== 'number' ||
+            store.latitude !== 0 ||
+            store.longitude !== 0) {
+            return store;
+        }
+        const geocoded = await geocodeLotteMartAddress(store.address, { timeout, googleMapsApiKey });
+        if (!geocoded) {
+            return store;
+        }
+        return {
+            ...store,
+            latitude: geocoded.latitude,
+            longitude: geocoded.longitude,
+            distanceM: calculateDistanceM(resolvedLatitude, resolvedLongitude, geocoded.latitude, geocoded.longitude),
+        };
+    }));
+    return {
+        stores: sortStores(enriched).slice(0, limit),
+        location: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number'
+            ? { latitude: resolvedLatitude, longitude: resolvedLongitude }
+            : null,
+        geocodeUsed,
+    };
+}
+export async function resolveLotteMartStore(area, storeCode, storeName, options = {}) {
+    const normalizedStoreCode = (storeCode || '').trim();
+    if (normalizedStoreCode.length > 0) {
+        for (const currentArea of getTargetAreas(area)) {
+            const matched = (await fetchLotteMartMarketOptions(currentArea, '1', options)).find((item) => item.storeCode === normalizedStoreCode);
+            if (matched) {
+                return matched;
+            }
+        }
+        return null;
+    }
+    const normalizedStoreName = (storeName || '').trim().toLowerCase();
+    if (normalizedStoreName.length === 0) {
+        return null;
+    }
+    const allOptions = (await Promise.all(getTargetAreas(area).map((currentArea) => fetchLotteMartMarketOptions(currentArea, '1', options)))).flat();
+    return (allOptions.find((item) => item.storeName.toLowerCase() === normalizedStoreName) ||
+        allOptions.find((item) => item.storeName.toLowerCase().includes(normalizedStoreName)) ||
+        null);
+}
+export async function searchLotteMartProducts(params, options = {}) {
+    const normalizedKeyword = params.keyword.trim();
+    if (normalizedKeyword.length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const timeout = options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS;
+    if (params.source === 'zetta') {
+        return fetchZettaLotteMartProducts(createZettaFallbackStore(params), normalizedKeyword, params.pageLimit || 3, timeout);
+    }
+    const sessionCookie = await getLotteMartSessionCookie({ timeout: LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS });
+    let resolvedStore;
+    try {
+        resolvedStore = await resolveLotteMartStore(params.area, params.storeCode, params.storeName, {
+            timeout: LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS,
+            sessionCookie,
+            zyteApiKey: options.zyteApiKey,
+        });
+    }
+    catch (error) {
+        if (params.source === 'legacy') {
+            throw error;
+        }
+        const fallbackStore = createZettaFallbackStore(params);
+        return fetchZettaLotteMartProductsWithPrimaryError(fallbackStore, normalizedKeyword, params.pageLimit || 3, timeout, error);
+    }
+    if (!resolvedStore) {
+        throw new Error('검색할 롯데마트 매장을 찾지 못했습니다. area와 storeCode/storeName을 확인해주세요.');
+    }
+    const initialBody = new URLSearchParams();
+    initialBody.set('p_area', normalizeArea(resolvedStore.area));
+    initialBody.set('p_market', resolvedStore.storeCode);
+    initialBody.set('p_schWord', normalizedKeyword);
+    let initialHtml;
+    try {
+        initialHtml = await fetchLotteMartPageWithSession(LOTTEMART_API.PRODUCT_SEARCH_PATH, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: initialBody.toString(),
+        }, LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS, sessionCookie, options.zyteApiKey);
+    }
+    catch (error) {
+        if (params.source === 'legacy') {
+            throw error;
+        }
+        return fetchZettaLotteMartProductsWithPrimaryError(resolvedStore, normalizedKeyword, params.pageLimit || 3, timeout, error);
+    }
+    const pagedSessionCookie = await getCachedLotteMartSessionCookie(LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS);
+    const summary = parseProductSummary(initialHtml);
+    const firstPageProducts = parseProducts(resolvedStore.area, resolvedStore.storeCode, resolvedStore.storeName, normalizedKeyword, initialHtml);
+    const maxPage = Math.min(Math.max(params.pageLimit || 3, 1), Math.max(summary.totalPages, 1));
+    const pageHtmlList = await Promise.all(Array.from({ length: Math.max(maxPage - 1, 0) }, (_, index) => index + 2).map((page) => {
+        const endpoint = new URL(LOTTEMART_API.PRODUCT_PAGE_PATH, LOTTEMART_API.BASE_URL);
+        endpoint.searchParams.set('p_market', resolvedStore.storeCode);
+        endpoint.searchParams.set('p_schWord', normalizedKeyword);
+        endpoint.searchParams.set('page', String(page));
+        return fetchLotteMartHtml(endpoint.toString(), {
+            method: 'GET',
+            headers: {
+                Accept: 'text/html, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+        }, LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS, pagedSessionCookie, options.zyteApiKey);
+    }));
+    const pagedProducts = pageHtmlList.flatMap((html) => parseProducts(resolvedStore.area, resolvedStore.storeCode, resolvedStore.storeName, normalizedKeyword, html));
+    return {
+        area: resolvedStore.area,
+        storeCode: resolvedStore.storeCode,
+        storeName: resolvedStore.storeName,
+        totalCount: summary.totalCount,
+        totalPages: summary.totalPages,
+        products: dedupeProducts([...firstPageProducts, ...pagedProducts]),
+    };
+}
+export { calculateDistanceM, geocodeLotteMartAddress };
+export function __testOnlyClearLotteMartCaches() {
+    storeCache.clear();
+    __testOnlyClearLotteMartGeocodeCache();
+    __testOnlyClearLotteMartSessionCache();
+}

package/dist/services/lottemart/clientTypes.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데마트 클라이언트 입력 타입
+ */
+export {};

package/dist/services/lottemart/config.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데마트 서비스 공통 설정
+ */
+export const DEFAULT_LOTTEMART_TIMEOUT_MS = 45000;

package/dist/services/lottemart/debug.js

@@ -0,0 +1,92 @@
+/**
+ * 롯데마트 업스트림 단독 진단
+ */
+import { LOTTEMART_API } from './api.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+import { probeLotteMartRequest } from './session.js';
+import { normalizeArea } from './storeSearch.js';
+function resolveArea(area) {
+    const normalized = normalizeArea(area || '경기');
+    return normalized || '경기';
+}
+export function buildLotteMartDebugRequest(params) {
+    const target = params.target;
+    const area = resolveArea(params.area);
+    switch (target) {
+        case 'market-options': {
+            const endpoint = new URL(LOTTEMART_API.MARKET_OPTIONS_PATH, LOTTEMART_API.BASE_URL);
+            endpoint.searchParams.set('p_area', area);
+            endpoint.searchParams.set('p_type', params.type || '1');
+            if ((params.storeCode || '').trim().length > 0) {
+                endpoint.searchParams.set('p_werks', params.storeCode.trim());
+            }
+            return {
+                target,
+                method: 'GET',
+                url: endpoint.toString(),
+                bodyText: null,
+            };
+        }
+        case 'stores':
+            return {
+                target,
+                method: 'POST',
+                url: new URL(LOTTEMART_API.STORE_SEARCH_PATH, LOTTEMART_API.BASE_URL).toString(),
+                bodyText: new URLSearchParams({
+                    m_area: area,
+                    ...(params.storeCode ? { m_market: params.storeCode.trim() } : {}),
+                    ...(params.keyword ? { m_schWord: params.keyword.trim() } : {}),
+                }).toString(),
+            };
+        case 'products':
+            return {
+                target,
+                method: 'POST',
+                url: new URL(LOTTEMART_API.PRODUCT_SEARCH_PATH, LOTTEMART_API.BASE_URL).toString(),
+                bodyText: new URLSearchParams({
+                    p_area: area,
+                    p_market: (params.storeCode || '2415').trim(),
+                    p_schWord: (params.keyword || '핫식스').trim(),
+                }).toString(),
+            };
+        case 'product-page': {
+            const endpoint = new URL(LOTTEMART_API.PRODUCT_PAGE_PATH, LOTTEMART_API.BASE_URL);
+            endpoint.searchParams.set('p_market', (params.storeCode || '2415').trim());
+            endpoint.searchParams.set('p_schWord', (params.keyword || '핫식스').trim());
+            endpoint.searchParams.set('page', String(Math.max(params.page || 2, 1)));
+            return {
+                target,
+                method: 'GET',
+                url: endpoint.toString(),
+                bodyText: null,
+            };
+        }
+    }
+}
+export async function probeLotteMartUpstream(params) {
+    const request = buildLotteMartDebugRequest(params);
+    const timeout = params.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS;
+    const init = {
+        method: request.method,
+        headers: request.method === 'POST'
+            ? {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+            : {
+                Accept: 'text/html, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+        body: request.bodyText || undefined,
+    };
+    return {
+        request: {
+            target: request.target,
+            method: request.method,
+            url: request.url,
+            bodyText: request.bodyText,
+            timeout,
+            hasZyteApiKey: Boolean(params.zyteApiKey),
+        },
+        attempts: await probeLotteMartRequest(request.url, init, timeout, '', params.zyteApiKey),
+    };
+}

package/dist/services/lottemart/geocode.js

@@ -0,0 +1,49 @@
+/**
+ * 롯데마트 매장 주소 지오코딩
+ */
+import { fetchJson } from '../../utils/http.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+const GEOCODE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const geocodeCache = new Map();
+export async function geocodeLotteMartAddress(address, options = {}) {
+    const keyword = address.trim();
+    if (keyword.length === 0) {
+        return null;
+    }
+    const cached = geocodeCache.get(keyword);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', keyword);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        geocodeCache.set(keyword, {
+            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+            value: null,
+        });
+        return null;
+    }
+    const latitude = body.results?.[0]?.geometry?.location?.lat;
+    const longitude = body.results?.[0]?.geometry?.location?.lng;
+    const value = typeof latitude === 'number' && typeof longitude === 'number' ? { latitude, longitude } : null;
+    geocodeCache.set(keyword, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export function __testOnlyClearLotteMartGeocodeCache() {
+    geocodeCache.clear();
+}

package/dist/services/lottemart/index.js

@@ -0,0 +1,30 @@
+/**
+ * 롯데마트 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createSearchProductsTool } from './tools/searchProducts.js';
+const LOTTEMART_METADATA = {
+    id: 'lottemart',
+    name: '롯데마트',
+    version: '1.0.0',
+    description: '롯데마트 계열 매장 탐색 및 매장별 상품 검색 서비스',
+};
+class LotteMartService {
+    googleMapsApiKey;
+    zyteApiKey;
+    metadata = LOTTEMART_METADATA;
+    constructor(googleMapsApiKey, zyteApiKey) {
+        this.googleMapsApiKey = googleMapsApiKey;
+        this.zyteApiKey = zyteApiKey;
+    }
+    getTools() {
+        return [
+            createFindNearbyStoresTool(this.googleMapsApiKey, this.zyteApiKey),
+            createSearchProductsTool(this.zyteApiKey),
+        ];
+    }
+}
+export function createLotteMartService(options = {}) {
+    return new LotteMartService(options.googleMapsApiKey, options.zyteApiKey);
+}
+export * from './types.js';

package/dist/services/lottemart/keyword.js

@@ -0,0 +1,29 @@
+/**
+ * 롯데마트 매장 검색 키워드 보정
+ */
+export function buildLotteMartKeywordVariants(rawKeyword) {
+    const base = rawKeyword.trim();
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/\s+/g, '');
+    const withoutNoise = compact.replace(/(롯데마트|근처|주변)/g, '');
+    const tokens = base
+        .split(/\s+/)
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)
+        .filter((value) => !['롯데마트', '근처', '주변'].includes(value));
+    const normalizedTokens = tokens
+        .map((value) => value.replace(/역$/g, '').trim())
+        .filter((value) => value.length > 0);
+    const primaryToken = normalizedTokens[0] || tokens[0] || '';
+    const candidates = [
+        base,
+        compact,
+        withoutNoise,
+        primaryToken,
+        ...(tokens.length <= 1 ? tokens : []),
+        ...(normalizedTokens.length <= 1 ? normalizedTokens : []),
+    ];
+    return [...new Set(candidates.map((value) => value.trim()).filter((value) => value.length > 0))];
+}

package/dist/services/lottemart/parser.js

@@ -0,0 +1,185 @@
+/**
+ * 롯데마트 HTML 파싱 유틸리티
+ */
+import { buildLotteMartKeywordVariants } from './keyword.js';
+export function detectBrandVariant(storeName) {
+    if (storeName.startsWith('토이저러스')) {
+        return 'toysrus';
+    }
+    if (storeName.startsWith('맥스')) {
+        return 'max';
+    }
+    if (storeName.startsWith('보틀벙커')) {
+        return 'bottlebunker';
+    }
+    if (storeName.startsWith('Mealguru')) {
+        return 'mealguru';
+    }
+    if (storeName.startsWith('그랑그로서리')) {
+        return 'grandgrocery';
+    }
+    return 'lottemart';
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/ /gi, ' ')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/&#x2F;/gi, '/')
+        .replace(/&amp;/gi, '&');
+}
+function stripHtmlComments(value) {
+    let sanitized = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.startsWith('<!--', index)) {
+            const commentEnd = value.indexOf('-->', index + 4);
+            if (commentEnd < 0) {
+                break;
+            }
+            index = commentEnd + 3;
+            continue;
+        }
+        sanitized += value[index];
+        index += 1;
+    }
+    return sanitized.replaceAll('<!--', '').replaceAll('-->', '');
+}
+function stripTags(value) {
+    return stripHtmlComments(value).replace(/<br\s*\/?>/gi, '\n').replace(/<[^>]+>/g, ' ');
+}
+function normalizeWhitespace(value) {
+    return decodeHtmlEntities(stripTags(value)).replace(/\s+/g, ' ').trim();
+}
+export function normalizeHtml(html) {
+    const trimmed = html.trim();
+    const htmlStart = trimmed.search(/<(?:!doctype|html|option|li|ul|section)\b/i);
+    return htmlStart >= 0 ? trimmed.slice(htmlStart) : trimmed;
+}
+function toNumber(value) {
+    const parsed = Number.parseFloat(value.replace(/[^\d.-]/g, ''));
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export function calculateDistanceM(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return Math.round(6371000 * c);
+}
+function splitTopLevelBlocks(html, markerClass) {
+    const pattern = new RegExp(`<li>\\s*<div class="${markerClass}">`, 'g');
+    const normalized = html.replace(/\r/g, '');
+    const indexes = Array.from(normalized.matchAll(pattern)).map((match) => match.index || 0);
+    return indexes.map((start, index) => normalized.slice(start, indexes[index + 1] || normalized.length));
+}
+function extractFirstMatch(pattern, value) {
+    return value.match(pattern)?.[1]?.trim() || '';
+}
+export function parseMarketOptions(area, html) {
+    return Array.from(normalizeHtml(html).matchAll(/<option value="([^"]*)"[^>]*>([^<]*)<\/option>/g))
+        .map((match) => ({
+        area,
+        storeCode: (match[1] || '').trim(),
+        storeName: normalizeWhitespace(match[2] || ''),
+    }))
+        .filter((item) => item.storeCode.length > 0 && item.storeName.length > 0)
+        .map((item) => ({
+        ...item,
+        brandVariant: detectBrandVariant(item.storeName),
+    }));
+}
+export function parseStores(area, html) {
+    return splitTopLevelBlocks(normalizeHtml(html), 'shop-tit')
+        .map((block) => {
+        const storeName = normalizeWhitespace(extractFirstMatch(/<div class="shop-tit">([\s\S]*?)<\/div>/, block));
+        const detailUrl = extractFirstMatch(/<a class="link" href="([^"]+)"/, block);
+        const storeCode = extractFirstMatch(/werks=([^'"]+)/, block) || extractFirstMatch(/goClick\('([^']+)'\)/, block);
+        return {
+            area,
+            storeCode,
+            storeName,
+            brandVariant: detectBrandVariant(storeName),
+            address: normalizeWhitespace(extractFirstMatch(/주소\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            phone: normalizeWhitespace(extractFirstMatch(/상담전화\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            openTime: normalizeWhitespace(extractFirstMatch(/영업시간\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            closedDays: normalizeWhitespace(extractFirstMatch(/휴점일\s*:\s*<\/span>([\s\S]*?)<\/li>/, block)),
+            parkingType: normalizeWhitespace(extractFirstMatch(/주차정보\s*:\s*([^<]*)<\/span>/, block)),
+            parkingDetails: normalizeWhitespace(extractFirstMatch(/<div class="park-info">([\s\S]*?)<\/div>/, block)),
+            detailUrl: detailUrl.startsWith('.') ? `/mobiledowa/market/${detailUrl.replace(/^\.\//, '')}` : detailUrl,
+            latitude: 0,
+            longitude: 0,
+            distanceM: null,
+        };
+    })
+        .filter((store) => store.storeCode.length > 0 && store.storeName.length > 0);
+}
+export function parseProducts(area, storeCode, storeName, keyword, html) {
+    return splitTopLevelBlocks(normalizeHtml(html), 'prod-box')
+        .map((block) => {
+        const rawSpec = extractFirstMatch(/<div class="prod-count">([\s\S]*?)<\/div>/, block);
+        return {
+            area,
+            storeCode,
+            storeName,
+            keyword,
+            productName: normalizeWhitespace(extractFirstMatch(/<div class="prod-name">([\s\S]*?)<\/div>/, block)) ||
+                normalizeWhitespace(extractFirstMatch(/<div class="layer-head">([\s\S]*?)<\/div>/, block)),
+            barcode: normalizeWhitespace(extractFirstMatch(/<!--\s*([^>]+?)\s*-->/, rawSpec)),
+            spec: normalizeWhitespace(stripHtmlComments(rawSpec)),
+            manufacturer: normalizeWhitespace(extractFirstMatch(/제조사\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+            price: toNumber(extractFirstMatch(/가격\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+            stockQuantity: toNumber(extractFirstMatch(/재고\s*:\s*<\/th>\s*<td>([\s\S]*?)<\/td>/, block)),
+        };
+    })
+        .filter((product) => product.productName.length > 0);
+}
+export function parseProductSummary(html) {
+    const normalized = normalizeHtml(html);
+    const totalCount = toNumber(extractFirstMatch(/검색결과\s*:\s*<span>([\d,]+)<\/span>건/, normalized));
+    const totalPages = toNumber(extractFirstMatch(/var\s+totalPage\s*=\s*"(\d+)"/, normalized));
+    return {
+        totalCount,
+        totalPages: totalPages > 0 ? totalPages : 1,
+    };
+}
+export function dedupeProducts(products) {
+    return Array.from(new Map(products.map((product) => [
+        [product.productName, product.spec, product.manufacturer, product.price, product.stockQuantity].join('|'),
+        product,
+    ])).values());
+}
+export function matchesKeyword(store, keyword) {
+    const variants = buildLotteMartKeywordVariants(keyword).map((value) => value.toLowerCase());
+    if (variants.length === 0) {
+        return true;
+    }
+    const haystacks = [store.storeName, store.address, store.phone]
+        .map((value) => value.toLowerCase().replace(/\s+/g, ''))
+        .filter((value) => value.length > 0);
+    return variants.some((variant) => {
+        const normalizedVariant = variant.replace(/\s+/g, '');
+        return haystacks.some((value) => value.includes(normalizedVariant));
+    });
+}
+export function matchesBrandVariant(store, brandVariant) {
+    const normalized = (brandVariant || '').trim().toLowerCase();
+    return normalized.length === 0 ? true : store.brandVariant === normalized;
+}
+export function sortStores(stores) {
+    return [...stores].sort((a, b) => {
+        const distanceDelta = (a.distanceM ?? Number.MAX_SAFE_INTEGER) - (b.distanceM ?? Number.MAX_SAFE_INTEGER);
+        if (distanceDelta !== 0) {
+            return distanceDelta;
+        }
+        const areaDelta = a.area.localeCompare(b.area, 'ko');
+        if (areaDelta !== 0) {
+            return areaDelta;
+        }
+        return a.storeName.localeCompare(b.storeName, 'ko');
+    });
+}